En el web de mysql tienes las secciones de triggers:
http://dev.mysql.com/doc/refman/5.1/...tatements.html http://dev.mysql.com/doc/refman/5.1/...tatements.html
En el web tienes tambien la referencia de las funciones, o si te has bajado el manual de referencia en la seccion de la api para C tambien está todo.
Basicamente lo que te interesa es la instruccion CALL, y en el manual de referencia está la descripcion del funcionamiento, argumentos y un ejemplo; no lo he buscado en la web de mysql pero supongo que debe de haber lo mismo que en el manual de referencia, en cualquier caso te pongo una copia de la referencia a CALL:
Código SQL:
Ver original12.2.1. CALL Syntax
CALL sp_name([parameter[,...]])
CALL sp_name[()]
The CALL statement invokes a stored PROCEDURE that was defined previously WITH CREATE PROCEDURE.
AS OF MySQL 5.0.30, stored procedures that take no arguments can be invoked WITHOUT parentheses. That IS, CALL p() AND CALL p are equivalent.
CALL 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() FUNCTION; FROM the C API, CALL the mysql_affected_rows() FUNCTION.
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, the VALUES OF the two VARIABLES will have been SET OR modified:
mysql> SET @INCREMENT = 10;
mysql> CALL p(@version, @INCREMENT);
mysql> SELECT @version, @INCREMENT;
+------------+------------+
| @version | @INCREMENT |
+------------+------------+
| 5.0.25-log | 11 |
+------------+------------+
IN prepared CALL statements used WITH PREPARE AND EXECUTE, placeholder support IS available IN MySQL 5.0 FOR IN parameters, but NOT FOR OUT OR INOUT parameters. TO WORK
around this limitation FOR OUT AND INOUT parameters, TO forgo the USE OF placeholders: Refer TO USER VARIABLES IN the CALL statement itself AND do NOT specify them IN the EXECUTE statement:
mysql> SET @INCREMENT = 10;
mysql> PREPARE s FROM 'CALL p(@version, @increment)';
mysql> EXECUTE s;
mysql> SELECT @version, @INCREMENT;
+-----------------+------------+
| @version | @INCREMENT |
+-----------------+------------+
| 6.0.7-alpha-log | 11 |
+-----------------+------------+
TO WRITE C programs that USE the CALL SQL statement TO EXECUTE stored procedures that produce RESULT sets, the CLIENT_MULTI_RESULTS flag must be enabled. This IS
because each CALL 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 IS used TO EXECUTE any stored PROCEDURE that contains prepared statements. It cannot be determined WHEN such a PROCEDURE IS loaded whether
those statements will produce RESULT sets, so it IS necessary TO assume that they will.
CLIENT_MULTI_RESULTS can be enabled WHEN you CALL mysql_real_connect(), either explicitly BY passing the CLIENT_MULTI_RESULTS flag itself, OR implicitly BY passing CLIENT_MULTI_STATEMENTS (which also enables CLIENT_MULTI_RESULTS).
TO process the RESULT OF a CALL statement executed via mysql_query() OR mysql_real_query(), USE a loop that calls mysql_next_result() TO determine whether there are
more results. FOR an example, see SECTION 20.8.12, “C API Support FOR Multiple Statement Execution”.
FOR programs written IN a LANGUAGE that provides a MySQL interface, there IS no native method FOR directly retrieving the results OF OUT OR INOUT parameters FROM CALL statements.
TO GET the parameter VALUES, pass user-defined VARIABLES TO the PROCEDURE IN the CALL statement AND THEN EXECUTE a SELECT statement TO produce a RESULT SET containing the
variable VALUES. TO handle an INOUT parameter, EXECUTE a statement prior TO the CALL that sets the corresponding USER variable TO the VALUE TO be passed TO the PROCEDURE.
The following example illustrates the technique (WITHOUT error checking) FOR the stored PROCEDURE p described earlier that has an OUT parameter AND an INOUT parameter:
mysql_query(mysql, "SET @increment = 10");
mysql_query(mysql, "CALL p(@version, @increment)");
mysql_query(mysql, "SELECT @version, @increment");
RESULT = mysql_store_result(mysql);
ROW = mysql_fetch_row(RESULT);
mysql_free_result(RESULT);
After the preceding code executes, ROW[0] AND ROW[1] contain the VALUES OF @version AND @INCREMENT, respectively.
Saludos
vosk