### 13.2.1 CALL Statement

[]()

```
CALL sp_name([parameter[,...]])
CALL sp_name[()]
```

 The [`CALL`](call.html) statement invokes a stored procedure that was defined previously with [`CREATE PROCEDURE`](create-procedure.html).

 Stored procedures that take no arguments can be invoked without parentheses. That is, `CALL p()` and `CALL p` are equivalent.

[`CALL`](call.html) can pass back values to its caller using parameters that are declared as `OUT` or `INOUT` parameters. When the procedure returns, a client program can also obtain the number of rows affected for the final statement executed within the routine: At the SQL level, call the [`ROW_COUNT()`](information-functions.html#function_row-count) function; from the C API, call the [`mysql_affected_rows()`](https://dev.mysql.com/doc/c-api/8.0/en/mysql-affected-rows.html) function.

 For information about the effect of unhandled conditions on procedure parameters, see [Section 13.6.7.8, “Condition Handling and OUT or INOUT Parameters”](conditions-and-parameters.html).

 To get back a value from a procedure using an `OUT` or `INOUT` parameter, pass the parameter by means of a user variable, and then check the value of the variable after the procedure returns. (If you are calling the procedure from within another stored procedure or function, you can also pass a routine parameter or local routine variable as an `IN` or `INOUT` parameter.) For an `INOUT` parameter, initialize its value before passing it to the procedure. The following procedure has an `OUT` parameter that the procedure sets to the current server version, and an `INOUT` value that the procedure increments by one from its current value:

```
CREATE PROCEDURE p (OUT ver_param VARCHAR(25), INOUT incr_param INT)
BEGIN
  # Set value of OUT parameter
  SELECT VERSION() INTO ver_param;
  # Increment value of INOUT parameter
  SET incr_param = incr_param + 1;
END;
```

 Before calling the procedure, initialize the variable to be passed as the `INOUT` parameter. After calling the procedure, you can see that the values of the two variables are set or modified:

```
mysql> SET @increment = 10;
mysql> CALL p(@version, @increment);
mysql> SELECT @version, @increment;
+--------------------+------------+
| @version           | @increment |
+--------------------+------------+
| 8.0.3-rc-debug-log |         11 |
+--------------------+------------+
```

 In prepared [`CALL`](call.html) statements used with [`PREPARE`](prepare.html) and [`EXECUTE`](execute.html), placeholders can be used for `IN` parameters, `OUT`, and `INOUT` parameters. These types of parameters can be used as follows:

```
mysql> SET @increment = 10;
mysql> PREPARE s FROM 'CALL p(?, ?)';
mysql> EXECUTE s USING @version, @increment;
mysql> SELECT @version, @increment;
+--------------------+------------+
| @version           | @increment |
+--------------------+------------+
| 8.0.3-rc-debug-log |         11 |
+--------------------+------------+
```

 To write C programs that use the [`CALL`](call.html) SQL statement to execute stored procedures that produce result sets, the `CLIENT_MULTI_RESULTS` flag must be enabled. This is because each [`CALL`](call.html) returns a result to indicate the call status, in addition to any result sets that might be returned by statements executed within the procedure. `CLIENT_MULTI_RESULTS` must also be enabled if [`CALL`](call.html) is used to execute any stored procedure that contains prepared statements. It cannot be determined when such a procedure is loaded whether those statements produce result sets, so it is necessary to assume that they do so.

`CLIENT_MULTI_RESULTS` can be enabled when you call [`mysql_real_connect()`](https://dev.mysql.com/doc/c-api/8.0/en/mysql-real-connect.html), either explicitly by passing the `CLIENT_MULTI_RESULTS` flag itself, or implicitly by passing `CLIENT_MULTI_STATEMENTS` (which also enables `CLIENT_MULTI_RESULTS`). `CLIENT_MULTI_RESULTS` is enabled by default.

 To process the result of a [`CALL`](call.html) statement executed using [`mysql_query()`](https://dev.mysql.com/doc/c-api/8.0/en/mysql-query.html) or [`mysql_real_query()`](https://dev.mysql.com/doc/c-api/8.0/en/mysql-real-query.html), use a loop that calls [`mysql_next_result()`](https://dev.mysql.com/doc/c-api/8.0/en/mysql-next-result.html) to determine whether there are more results. For an example, see [Multiple Statement Execution Support](https://dev.mysql.com/doc/c-api/8.0/en/c-api-multiple-queries.html).

 C programs can use the prepared-statement interface to execute [`CALL`](call.html) statements and access `OUT` and `INOUT` parameters. This is done by processing the result of a [`CALL`](call.html) statement using a loop that calls [`mysql_stmt_next_result()`](https://dev.mysql.com/doc/c-api/8.0/en/mysql-stmt-next-result.html) to determine whether there are more results. For an example, see [Prepared CALL Statement Support](https://dev.mysql.com/doc/c-api/8.0/en/c-api-prepared-call-statements.html). Languages that provide a MySQL interface can use prepared [`CALL`](call.html) statements to directly retrieve `OUT` and `INOUT` procedure parameters.

 Metadata changes to objects referred to by stored programs are detected and cause automatic reparsing of the affected statements when the program is next executed. For more information, see [Section 8.10.3, “Caching of Prepared Statements and Stored Programs”](statement-caching.html).

