{"id":27732,"date":"2022-12-22T12:39:05","date_gmt":"2022-12-22T20:39:05","guid":{"rendered":"https:\/\/coderpad.io\/?p=27732"},"modified":"2023-06-05T13:46:56","modified_gmt":"2023-06-05T20:46:56","slug":"advanced-stored-procedures-in-mysql","status":"publish","type":"post","link":"https:\/\/coderpad.io\/blog\/development\/advanced-stored-procedures-in-mysql\/","title":{"rendered":"Advanced Stored Procedures In MySQL"},"content":{"rendered":"\n

In our previous article<\/a>, we learned the basics of stored procedures and how they can help you manage your MySQL database efficiently. In this guide, we\u2019ll dive deeper and discuss more advanced stored procedures concepts and techniques. By the end of this article, you\u2019d have learned some skills that will make you more proficient in working with stored procedures in MySQL.<\/p>\n\n\n\n

Stored procedures share many similarities with functions in procedural languages such as JavaScript, Python, etc. They are used to group and execute many tasks in one call. They can be called and executed repeatedly using loops. They can also be nested in one another and executed in parent-stored procedures. You can also nest MySQL functions in stored procedures and more!<\/p>\n\n\n\n

Nested stored procedures<\/h2>\n\n\n\n

Nested stored procedures help to break up large amounts of SQL statements into smaller reusable pieces. Moving reusable logic pieces into smaller composable pieces can make your procedures more readable and easy to debug.<\/p>\n\n\n\n

Whenever you write a statement that calls a procedure X in the body of another stored procedure Y, you\u2019re nesting X in Y. The syntax looks like this:<\/p>\n\n\n

CREATE<\/span> PROCEDURE<\/span> parent_procedure\n\nBEGIN<\/span>\n\nSELECT<\/span> column<\/span> FROM<\/span> table<\/span>;\n\n\/\/ other statements here\n\n\/\/ nested stored procedure\n\nCALL<\/span> nested_procedure;\u00a0\n\nEND<\/span><\/code><\/span>Code language:<\/span> SQL (Structured Query Language)<\/span> (<\/span>sql<\/span>)<\/span><\/small><\/pre>\n\n\n
DELIMITER \/\/\n\nCREATE<\/span> PROCEDURE<\/span> film_in_stock(IN<\/span> p_film_id INT<\/span>, IN<\/span> p_store_id INT<\/span>, OUT<\/span> p_film_count INT<\/span>)\nBEGIN<\/span>\n    SELECT<\/span> inventory_id\n    FROM<\/span> inventory\n    WHERE<\/span> film_id = p_film_id\n    AND<\/span> store_id = p_store_id\n    AND<\/span> inventory_in_stock(inventory_id);\n\n    SELECT<\/span> COUNT<\/span>(*)\n    FROM<\/span> inventory\n    WHERE<\/span> film_id = p_film_id\n    AND<\/span> store_id = p_store_id\n    AND<\/span> inventory_in_stock(inventory_id)\n    INTO<\/span> p_film_count;\nEND<\/span> \/\/\n\nDELIMITER;<\/code><\/span>Code language:<\/span> SQL (Structured Query Language)<\/span> (<\/span>sql<\/span>)<\/span><\/small><\/pre>\n\n\n
We can take the second SELECT<\/code> statement and place it into its own stored procedure named count_inventory<\/code> so that we can reuse the logic in other places.<\/p>\n\n\n
DELIMITER \/\/\n\nCREATE<\/span> PROCEDURE<\/span> count_inventory(IN<\/span> p_film_id INT<\/span>, IN<\/span> p_store_id INT<\/span>, OUT<\/span> p_film_count INT<\/span>)\nBEGIN<\/span>\n    SELECT<\/span> COUNT<\/span>(*)\n    FROM<\/span> inventory\n    WHERE<\/span> film_id = p_film_id\n    AND<\/span> store_id = p_store_id\n    AND<\/span> inventory_in_stock(inventory_id)\n    INTO<\/span> p_film_count;\nEND<\/span> \/\/\n\nDELIMITER;<\/code><\/span>Code language:<\/span> SQL (Structured Query Language)<\/span> (<\/span>sql<\/span>)<\/span><\/small><\/pre>\n\n\n
The count_inventory<\/code> stored procedure will accept three arguments just like it\u2019s parent procedure:<\/p>\n\n\n\n
    \n
  1. p_film_id<\/code> defines the variable for the film\u2019s id<\/li>\n\n\n\n
  2. p_store_id<\/code> defines the variable for the store\u2019s id<\/li>\n\n\n\n
  3. p_film_count<\/code> will hold the total number of films that were found in the inventory using the filters passed.<\/li>\n<\/ol>\n\n\n\n
    The parent procedure film_in_stock<\/code> will now look like this:<\/p>\n\n\n
    DELIMITER \/\/\n\nCREATE<\/span> PROCEDURE<\/span> film_in_stock(IN<\/span> p_film_id INT<\/span>, IN<\/span> p_store_id INT<\/span>, OUT<\/span> p_film_count INT<\/span>)\nBEGIN<\/span>\n    SELECT<\/span> inventory_id\n    FROM<\/span> inventory\n    WHERE<\/span> film_id = p_film_id\n    AND<\/span> store_id = p_store_id\n    AND<\/span> inventory_in_stock(inventory_id);\n\n    CALL<\/span> count_inventory(p_film_id, p_store_id, p_film_count);\nEND<\/span> \/\/\n\nDELIMITER;<\/code><\/span>Code language:<\/span> SQL (Structured Query Language)<\/span> (<\/span>sql<\/span>)<\/span><\/small><\/pre>\n\n\n
    When we call the film_in_stock<\/code> stored procedure, it will make a call to the count_inventory<\/code> stored procedure to count the number of films based on the condition values provided in its IN<\/code> parameters:<\/p>\n\n\n
    mysql> CALL<\/span> film_in_stock(1<\/span>, 1<\/span>, @p_film_count);\n+--------------+<\/span>\n| inventory_id |\n+--------------+<\/span>\n|            1 |\n|            2 |\n|            3 |\n|            4 |\n+--------------+<\/span>\n4 rows in set<\/span> (0.01<\/span> sec)<\/code><\/span>Code language:<\/span> SQL (Structured Query Language)<\/span> (<\/span>sql<\/span>)<\/span><\/small><\/pre>\n\n\n
    The nested procedure count_inventory<\/code> also let\u2019s us retrieve the inventory count using the user-defined variable we pass into the OUT<\/code> parameter @p_film_count<\/code>:<\/p>\n\n\n
    mysql> SELECT<\/span> @p_film_count;\n+---------------+<\/span>\n| @p_film_count |\n+---------------+<\/span>\n|             4 |\n+---------------+<\/span>\n1 row in set<\/span> (0.00<\/span> sec)<\/code><\/span>Code language:<\/span> SQL (Structured Query Language)<\/span> (<\/span>sql<\/span>)<\/span><\/small><\/pre>\n\n\n
    From our example above, you would notice we called a function named inventory_in_stock<\/code>. We won\u2019t go deep into MySQL functions just yet, but the body of the function looks like this:<\/p>\n\n\n
    CREATE<\/span> FUNCTION<\/span> inventory_in_stock (p_inventory_id INT<\/span>) RETURNS<\/span> tinyint<\/span>(1<\/span>)\n    READS<\/span> SQL<\/span> DATA<\/span>\nBEGIN<\/span>\n    DECLARE<\/span> v_rentals INT<\/span>;\n    DECLARE<\/span> v_out     INT<\/span>;\n\n    SELECT<\/span> COUNT<\/span>(*) INTO<\/span> v_rentals\n    FROM<\/span> rental\n    WHERE<\/span> inventory_id = p_inventory_id;\n\n    IF v_rentals = 0 THEN\n      RETURN TRUE;\n    END<\/span> IF<\/span>;\n\n    SELECT<\/span> COUNT<\/span>(rental_id) INTO<\/span> v_out\n    FROM<\/span> inventory LEFT<\/span> JOIN<\/span> rental USING<\/span>(inventory_id)\n    WHERE<\/span> inventory.inventory_id = p_inventory_id\n    AND<\/span> rental.return_date IS<\/span> NULL<\/span>;\n\n    IF v_out > 0 THEN\n      RETURN FALSE;\n    ELSE\n      RETURN TRUE;\n    END<\/span> IF<\/span>;\nEND<\/span><\/code><\/span>Code language:<\/span> SQL (Structured Query Language)<\/span> (<\/span>sql<\/span>)<\/span><\/small><\/pre>\n\n\n
    The point I\u2019m trying to make is that you can also nest MySQL functions into stored procedures.<\/p>\n\n\n\n
    Variables in stored procedures<\/h2>\n\n\n\n
    Variables are very useful when writing stored procedures. They hold immediate results and can be referenced anywhere in the body of a stored procedure. The value of a variable can range from primitive data types and objects to results from calculations, or data returned from functions and nested stored procedures. This value can change during the execution of the stored procedure. <\/p>\n\n\n\n
    A variable is always assigned a name and you can reference that name to retrieve the current value the variable holds.<\/p>\n\n\n\n
    There are three types of variables in MySQL, all of which can be used in a stored procedure based on scope. These are local variables, user-defined variables and system variables. Scope in MySQL actually refers to the current context of code that determines how variables can be accessed.<\/p>\n\n\n\n
    Declaring local variables in stored procedures<\/h3>\n\n\n\n
    Local variables are usually scoped within the BEGIN<\/code> and END<\/code> clause of a stored procedure. <\/p>\n\n\n\n
    To make use of a local variable in a stored procedure, you have to first declare it using the DECLARE<\/code> statement in the following syntax:<\/p>\n\n\n
    DECLARE<\/span> variable_name data_type(size<\/span>) [DEFAULT<\/span> default_value];<\/code><\/span>Code language:<\/span> SQL (Structured Query Language)<\/span> (<\/span>sql<\/span>)<\/span><\/small><\/pre>\n\n\n
    The variable name follows the DECLARE<\/code> statement and must obey the rules of naming columns in MySQL. Next, we specify the datatype and length of the variable. A variable\u2019s value is NULL by default, but we can specify another value using the DEFAULT<\/code> clause.<\/p>\n\n\n\n
    Assigning variables to new values<\/h4>\n\n\n\n
    You can change the existing value of a variable by re-assigning it to a new value. This is done using the SET<\/code> statement:<\/p>\n\n\n
    SET<\/span> variable_name = value<\/span>;<\/code><\/span>Code language:<\/span> SQL (Structured Query Language)<\/span> (<\/span>sql<\/span>)<\/span><\/small><\/pre>\n\n\n
    For example:<\/p>\n\n\n
    DECLARE<\/span> total INT<\/span> unsigned<\/span> DEFAULT<\/span> 0<\/span>;\nSET<\/span> total = 1800<\/span>;<\/code><\/span>Code language:<\/span> SQL (Structured Query Language)<\/span> (<\/span>sql<\/span>)<\/span><\/small><\/pre>\n\n\n
    You can also pass the result of a query into a variable using the SELECT INTO<\/code> statement:<\/p>\n\n\n
    DECLARE<\/span> inventory_count INT<\/span> DEFAULT<\/span> 0<\/span>;\nSELECT<\/span> COUNT<\/span>(*) INTO<\/span> inventory_count FROM<\/span> inventory;<\/code><\/span>Code language:<\/span> SQL (Structured Query Language)<\/span> (<\/span>sql<\/span>)<\/span><\/small><\/pre>\n\n\n
    The following stored procedure uses local variables to fetch all users that have surnames that begin with the letter A through D:<\/p>\n\n\n
    DELIMITER \/\/\n\nCREATE<\/span> PROCEDURE<\/span> fetch_users()\nBEGIN<\/span>\n    DECLARE<\/span> start<\/span> CHAR<\/span>(1<\/span>) DEFAULT<\/span> 'A'<\/span>;\n    DECLARE<\/span> end<\/span> CHAR<\/span>(1<\/span>) DEFAULT<\/span> 'D'<\/span>;\n\n    SELECT<\/span> lastname FROM<\/span> actor WHERE<\/span> lastname BETWEEN<\/span> start<\/span> AND<\/span> end<\/span>;\nEND<\/span> \/\/\n\nDELIMITER;<\/code><\/span>Code language:<\/span> SQL (Structured Query Language)<\/span> (<\/span>sql<\/span>)<\/span><\/small><\/pre>\n\n\n
    User-defined variables<\/h3>\n\n\n\n
    In our past example, we created a user-defined variable @p_film_count<\/code> to hold the value of the inventory count of the films. User-defined variables are session specific, meaning the user variables defined in a client cannot be seen by other clients except the user can access the Performance Schema user_variables_by_thread<\/code> table.<\/p>\n\n\n\n
    User-defined variables are always written by prefixing the letter @<\/code> with the name of the variable, e.g. @total_orders<\/code>. The name of a user-defined variable consists of alphanumeric characters, .<\/code>, _<\/code>, and $<\/code>.  To use other characters, you must quote it as a string or identifier, e.g. @'my_var'<\/code> or @\"my_var\"<\/code>.<\/p>\n\n\n\n
    Unlike local variables, you can access a user-defined variable without declaring it. If you use a user-defined variable that has not been declared, its value will be NULL<\/code> by default and it will be a type of string. User variables can be assigned a value from a limited set of data types: integer, decimal, floating-point, binary or nonbinary string, or NULL<\/code> value.<\/p>\n\n\n
    SELECT<\/span> @var_name;<\/code><\/span>Code language:<\/span> SQL (Structured Query Language)<\/span> (<\/span>sql<\/span>)<\/span><\/small><\/pre>\n\n\n
    You can initialize a user-defined variable using the SET<\/code> or SELECT<\/code> statement:<\/p>\n\n\n
    SET<\/span> @start<\/span> = 'A'<\/span>, @end<\/span> = 'D'<\/span>;\nSELECT<\/span> lastname FROM<\/span> actor WHERE<\/span> lastname BETWEEN<\/span> start<\/span> AND<\/span> end<\/span>;<\/code><\/span>Code language:<\/span> SQL (Structured Query Language)<\/span> (<\/span>sql<\/span>)<\/span><\/small><\/pre>\n\n
    SELECT<\/span> @start<\/span> := 'A'<\/span>, @end<\/span> := 'D'<\/span>;\nSELECT<\/span> lastname FROM<\/span> actor WHERE<\/span> lastname BETWEEN<\/span> start<\/span> AND<\/span> end<\/span>;<\/code><\/span>Code language:<\/span> SQL (Structured Query Language)<\/span> (<\/span>sql<\/span>)<\/span><\/small><\/pre>\n\n\n
    System variables<\/h3>\n\n\n\n
    System variables are variables that are readily available for use in the MySQL server. These variables are maintained by the MySQL server and they are used to configure its operation. The system variables are usually classified into GLOBAL<\/code>, SESSION<\/code> or both.<\/p>\n\n\n\n
     All system variables have default values and they can be set at server startup using the command line or with an option file. Some can even be changed at runtime using the SET<\/code> statement. You can use system variables in expressions and even in the body of a stored procedure.<\/p>\n\n\n\n
    You can see the current value of a system variable used by the MySQL server with the SHOW VARIABLES<\/code> statement or the SELECT<\/code> statement:<\/p>\n\n\n
    SHOW<\/span> [GLOBAL<\/span> | SESSION<\/span>] VARIABLES<\/span> [LIKE<\/span> 'pattern'<\/span> | WHERE<\/span> expr]\nSELECT<\/span> @@var_name;<\/code><\/span>Code language:<\/span> SQL (Structured Query Language)<\/span> (<\/span>sql<\/span>)<\/span><\/small><\/pre>\n\n\n
    When using the SHOW VARIABLES statement without the GLOBAL<\/code> or SESSION<\/code> modifier the default modifier is SESSION<\/code>. When using the SELECT statement, you must prefix the system variable name with @@<\/code> so that the MySQL server knows you\u2019re referencing a system variable and not a user-defined or local variable.<\/p>\n\n\n\n
    Conditionals (IF<\/code> statement)<\/h2>\n\n\n\n
    The MySQL IF<\/code> statement allows you to execute one or more SQL statements based on a condition. The IF<\/code> statement can have THEN<\/code>, ELSE<\/code>, and ELSEIF<\/code> clauses, and is terminated using END IF;<\/code>. <\/p>\n\n\n\n
    The basic syntax of the IF<\/code> statement is as follows:<\/p>\n\n\n
    IF condition THEN statement_list\n    [ELSEIF condition THEN statement_list] ...\n    [ELSE statement_list]\nEND<\/span> IF<\/span>;<\/code><\/span>Code language:<\/span> SQL (Structured Query Language)<\/span> (<\/span>sql<\/span>)<\/span><\/small><\/pre>\n\n\n
    When the condition<\/code> evaluates to true , the statement_list<\/code> (one or more SQL statements) will execute. But if no condition<\/code> matches, the ELSE<\/code> clause statement_list will execute.<\/p>\n\n\n\n
    The following stored procedure greeting<\/code> checks returns a greeting based on the current time of day:<\/p>\n\n\n
    DELIMITER \/\/\n\nCREATE<\/span> PROCEDURE<\/span> greeting()\nBEGIN<\/span>\nDECLARE<\/span> hour<\/span> INT<\/span> DEFAULT<\/span> HOUR<\/span>(NOW<\/span>());\nDECLARE<\/span> message VARCHAR<\/span>(20<\/span>);\n\nIF hour < 18 THEN\nSET<\/span> message = \"Good day!\"<\/span>;\nELSE\nSET<\/span> message =  \"Good evening!\"<\/span>;\nEND<\/span> IF<\/span>;\n\nSELECT<\/span> message;\nEND<\/span> \/\/\n\nDELIMITER ;<\/code><\/span>Code language:<\/span> SQL (Structured Query Language)<\/span> (<\/span>sql<\/span>)<\/span><\/small><\/pre>\n\n\n
    Loops in stored procedures<\/h2>\n\n\n\n
    Loops can be used in repeating the execution of one or more SQL statements until a condition is met. To terminate a loop if a condition has been met you can use the LEAVE<\/code> statement. The basic syntax of a loop is as follows:<\/p>\n\n\n
    [begin_label:] LOOP\n    statement_list\nEND<\/span> LOOP<\/span> [end_label]<\/code><\/span>Code language:<\/span> SQL (Structured Query Language)<\/span> (<\/span>sql<\/span>)<\/span><\/small><\/pre>\n\n\n
    LOOP<\/code> statements just like REPEAT<\/code> and WHILE<\/code> statements are permitted to use labels if need be under the following rules:<\/p>\n\n\n\n
      \n
    • begin_label<\/code> must be followed by a colon<\/li>\n\n\n\n
    • begin_label<\/code> can be given without end_label<\/code>. If end_label<\/code> is present, it must be the same as begin_label<\/code>.<\/li>\n\n\n\n
    • end_label<\/code> cannot be given without begin_label<\/code>.<\/li>\n\n\n\n
    • Labels at the same nesting level must be distinct.<\/li>\n\n\n\n
    • Labels can be up to 16 characters long.<\/li>\n<\/ul>\n\n\n\n
      The general syntax when using a LEAVE statement in a LOOP looks like the following:<\/p>\n\n\n
      [label1:] LOOP\n    ...\n    \/* Terminate the loop *\/<\/span>\n    IF condition THEN\n        LEAVE [label1];\n    END<\/span> IF<\/span>;\n    ...\nEND<\/span> LOOP<\/span> [label1]<\/code><\/span>Code language:<\/span> SQL (Structured Query Language)<\/span> (<\/span>sql<\/span>)<\/span><\/small><\/pre>\n\n\n
      While the LEAVE statement is used to quit or terminate the loop, the opposite ITERATE<\/code> is used to start the loop again. The syntax looks like this:<\/p>\n\n\n
      label1: LOOP    ...    \/* Start the loop again *\/<\/span>\n    IF condition THEN ITERATE label1; END IF;\n    ...\nEND LOOP label1;<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
      The following example uses both statements to continue iterating or terminate the loop based on a condition:<\/p>\n\n\n
      CREATE<\/span> PROCEDURE<\/span> doiterate(p1 INT<\/span>)\nBEGIN<\/span>\n  label1: LOOP<\/span>\n    SET<\/span> p1 = p1 + 1<\/span>;\n    IF p1 < 10 THEN ITERATE label1; END<\/span> IF<\/span>;\n    LEAVE label1;\n  END<\/span> LOOP<\/span> label1;\nEND<\/span>;<\/code><\/span>Code language:<\/span> SQL (Structured Query Language)<\/span> (<\/span>sql<\/span>)<\/span><\/small><\/pre>\n\n\n
      Cursors<\/h2>\n\n\n\n
      When working with large rows of data, you may want to process the data on a row-by-row basis. That\u2019s where cursors come in. Cursors are used to iterate through the results of a query allowing you to perform certain operations on each row of data individually.<\/p>\n\n\n\n
      In MySQL, Cursors are supported in stored programs such as stored procedures, stored functions, and triggers, and they have the following properties:<\/p>\n\n\n\n
        \n
      • Asensitive: The server may or may not make a copy of its result table<\/li>\n\n\n\n
      • Read only: Cursors cannot be used to modify the data of the resulting table.<\/li>\n\n\n\n
      • Nonscrollable: Can be traversed only in one direction and cannot skip rows<\/li>\n<\/ul>\n\n\n\n
        Cursors are to be declared after you must have declared variables and conditions and also before you declare any handlers:<\/p>\n\n\n
        CREATE<\/span> PROCEDURE<\/span> curdemo()\nBEGIN<\/span>\n  DECLARE<\/span> done INT<\/span> DEFAULT<\/span> FALSE<\/span>;\n  DECLARE<\/span> a CHAR<\/span>(16<\/span>);\n  DECLARE<\/span> b, c INT<\/span>;\n\n  \/* Declare cursors: cur1 and cur2 *\/<\/span>\n  DECLARE<\/span> cur1 CURSOR<\/span> FOR<\/span> SELECT<\/span> id<\/span>,data<\/span> FROM<\/span> test.t1;\n  DECLARE<\/span> cur2 CURSOR<\/span> FOR<\/span> SELECT<\/span> i FROM<\/span> test.t2;  \/* Declare handler to handle the condition when cursor reaches end of result set *\/<\/span>\n  DECLARE<\/span> CONTINUE HANDLER<\/span> FOR<\/span> NOT<\/span> FOUND<\/span> SET<\/span> done = TRUE<\/span>;\n\n  \/* Open the cursors to initialize result set*\/<\/span>\n  OPEN cur1;\n  OPEN cur2;\n\n  read_loop: LOOP\n\n    \/* FETCH retrieves the rows the cursors currently point to, then updates cursors to the next row *\/<\/span>\n    FETCH cur1 INTO a, b;\n    FETCH cur2 INTO c;\n    IF done THEN\n      LEAVE read_loop;\n    END<\/span> IF<\/span>;\n    IF b < c THEN\n      INSERT<\/span> INTO<\/span> test.t3 VALUES<\/span> (a,b);\n    ELSE\n      INSERT<\/span> INTO<\/span> test.t3 VALUES<\/span> (a,c);\n    END<\/span> IF<\/span>;\n  END<\/span> LOOP<\/span>;\n\n  \/* Close cursors when no longer used to release memory used *\/<\/span>\n  CLOSE cur1;\n  CLOSE cur2;\nEND<\/span>;<\/code><\/span>Code language:<\/span> SQL (Structured Query Language)<\/span> (<\/span>sql<\/span>)<\/span><\/small><\/pre>\n\n\n
        The example above shows how cursors work in the following steps:<\/p>\n\n\n\n
Let\u2019s demonstrate how nested stored procedures work. For this example, we\u2019d be refactoring the film_in_stock<\/code> stored procedure we created in our previous article<\/a>. I\u2019ll type it in here for reference:<\/p>\n\n\n