MySQL crée une syntaxe de procédure stockée avec un délimiteur
J'essaie de créer une procédure stockée dans MySQL en utilisant un délimiteur comme celui-ci:
use am;
DELIMITER $$
CREATE PROCEDURE addfields()
BEGIN
DECLARE done INT DEFAULT FALSE;
DECLARE acc INT(16);
DECLARE validId INT DEFAULT 0;
END $$
DELIMITER ;
Cela me donne une erreur:
#1304 - PROCEDURE addfields already exists
Quelle est la syntaxe appropriée pour créer une procédure stockée avec un délimiteur et la supprimer si elle existe en premier?
Voici l'exemple MYSQL Stored Procedure avec délimiteur et comment appeler ..
DELIMITER $$
DROP PROCEDURE IF EXISTS `sp_user_login` $$
CREATE DEFINER=`root`@`%` PROCEDURE `sp_user_login`(
IN loc_username VARCHAR(255),
IN loc_password VARCHAR(255)
)
BEGIN
SELECT user_id,
user_name,
user_emailid,
user_profileimage,
last_update
FROM tbl_user
WHERE user_name = loc_username
AND password = loc_password
AND status = 1;
END $$
DELIMITER ;
et appelez, spécification mysql_connection et
$loginCheck="call sp_user_login('".$username."','".$password."');";
il retournera le résultat de la procédure.
Débuter avec la syntaxe de procédure stockée dans MySQL:
Les bons programmeurs utilisent le terminal, l'interface graphique vous rend doux au milieu. Quand vous vous y habituez et que vous mémorisez les commandes, il est 5 fois plus rapide que n'importe quelle interface graphique. Productivité = succès.
1. Ouvrez un terminal et connectez-vous à mysql comme ceci:
el@apollo:~$ mysql -u root -p
Enter password:
Welcome to the MySQL monitor. Commands end with ; or \g.
mysql>
2. Regardez si vous avez des procédures:
mysql> show procedure status;
+-----------+---------------+-----------+---------+---------------------+---------------------+---------------+---------+----------------------+----------------------+--------------------+
| Db | Name | Type | Definer | Modified | Created | Security_type | Comment | character_set_client | collation_connection | Database Collation |
+-----------+---------------+-----------+---------+---------------------+---------------------+---------------+---------+----------------------+----------------------+--------------------+
| yourdb | sp_user_login | PROCEDURE | root@% | 2013-12-06 14:10:25 | 2013-12-06 14:10:25 | DEFINER | | utf8 | utf8_general_ci | latin1_swedish_ci |
+-----------+---------------+-----------+---------+---------------------+---------------------+---------------+---------+----------------------+----------------------+--------------------+
1 row in set (0.01 sec)
J'en ai une définie, vous n'en avez probablement aucune pour commencer.
3. Accédez à la base de données, supprimez-la.
mysql> use yourdb;
Database changed
mysql> drop procedure if exists sp_user_login;
Query OK, 0 rows affected (0.01 sec)
mysql> show procedure status;
Empty set (0.00 sec)
4. Ok donc maintenant je n'ai pas de procédures stockées définies. Faites le plus simple:
mysql> delimiter //
mysql> create procedure foobar()
-> begin select 'hello'; end//
Query OK, 0 rows affected (0.00 sec)
Le // communiquera au terminal lorsque vous aurez fini d'entrer les commandes pour la procédure stockée. le nom de la procédure stockée est foobar. il ne prend aucun paramètre et devrait renvoyer "hello".
5. Si c'est le cas, n'oubliez pas de régler votre délimiteur !:
mysql> show procedure status;
->
->
Je t'ai eu! Pourquoi ça n'a pas marché? Vous définissez le délimiteur sur // Remember? Remettez-le sur ;
6. Replacez le délimiteur et observez la procédure:
mysql> delimiter ;
mysql> show procedure status;
+-----------+--------+-----------+----------------+---------------------+---------------------+---------------+---------+----------------------+----------------------+--------------------+
| Db | Name | Type | Definer | Modified | Created | Security_type | Comment | character_set_client | collation_connection | Database Collation |
+-----------+--------+-----------+----------------+---------------------+---------------------+---------------+---------+----------------------+----------------------+--------------------+
| yourdb | foobar | PROCEDURE | root@localhost | 2013-12-06 14:27:23 | 2013-12-06 14:27:23 | DEFINER | | utf8 | utf8_general_ci | latin1_swedish_ci |
+-----------+--------+-----------+----------------+---------------------+---------------------+---------------+---------+----------------------+----------------------+--------------------+
1 row in set (0.00 sec)
7. Exécutez-le:
mysql> call foobar();
+-------+
| hello |
+-------+
| hello |
+-------+
1 row in set (0.00 sec)
Query OK, 0 rows affected (0.00 sec)
Bonjour tout le monde, laissez-le remplacer par quelque chose de mieux.
8. Lâchez foobar, redéfinissez-le pour accepter un paramètre, puis réexécutez-le:
mysql> drop procedure foobar;
Query OK, 0 rows affected (0.00 sec)
mysql> show procedure status;
Empty set (0.00 sec)
mysql> delimiter //
mysql> create procedure foobar (in var1 int)
-> begin select var1 + 2 as result;
-> end//
Query OK, 0 rows affected (0.00 sec)
mysql> delimiter ;
mysql> call foobar(5);
+--------+
| result |
+--------+
| 7 |
+--------+
1 row in set (0.00 sec)
Query OK, 0 rows affected (0.00 sec)
Agréable! Nous avons créé une procédure qui prend une entrée, la modifie et produit une sortie. Faisons maintenant une variable out.
9. Supprimer foobar, créer une variable out, l'exécuter:
mysql> delimiter ;
mysql> drop procedure foobar;
Query OK, 0 rows affected (0.00 sec)
mysql> delimiter //
mysql> create procedure foobar(out var1 varchar(100))
-> begin set var1="kowalski, what's the status of the nuclear reactor?";
-> end//
Query OK, 0 rows affected (0.00 sec)
mysql> delimiter ;
mysql> call foobar(@kowalski_status);
Query OK, 0 rows affected (0.00 sec)
mysql> select @kowalski_status;
+-----------------------------------------------------+
| @kowalski_status |
+-----------------------------------------------------+
| kowalski, what's the status of the nuclear reactor? |
+-----------------------------------------------------+
1 row in set (0.00 sec)
10. Exemple d'utilisation de INOUT dans MySQL:
mysql> select 'ricksays' into @msg;
Query OK, 1 row affected (0.00 sec)
mysql> delimiter //
mysql> create procedure foobar (inout msg varchar(100))
-> begin
-> set msg = concat(@msg, " never gonna let you down");
-> end//
mysql> delimiter ;
mysql> call foobar(@msg);
Query OK, 0 rows affected (0.00 sec)
mysql> select @msg;
+-----------------------------------+
| @msg |
+-----------------------------------+
| ricksays never gonna let you down |
+-----------------------------------+
1 row in set (0.00 sec)
Ok cela a fonctionné, il a réuni les cordes ensemble. Vous avez donc défini une variable msg, transmise à cette variable dans une procédure stockée appelée foobar, et @msg a été écrit par foobar.
Vous savez maintenant comment créer des procédures stockées avec des délimiteurs. Continuez ce tutoriel ici, commencez par les variables dans les procédures stockées: http://net.tutsplus.com/tutorials/an-inintroduction-to-stored-procedures/
Voici mon code pour créer une procédure dans MySQL:
DELIMITER $$
CREATE DEFINER=`root`@`localhost` PROCEDURE `procedureName`(IN comId int)
BEGIN
select * from tableName
(add joins OR sub query as per your requirement)
Where (where condition here)
END $$
DELIMITER ;
Pour appeler cette procédure, utilisez cette requête:
call procedureName(); // without parameter
call procedureName(id,pid); // with parameter
Détail :
1) DEFINER: root est le nom d'utilisateur et changez-le selon votre nom d'utilisateur mysql localhost est l'hôte, vous pouvez le changer avec l'adresse ip du serveur si vous exécutez cette requête sur le serveur d'hébergement.
Lire ici pour plus de détail
J'ai créé une procédure MySQL simple comme indiqué ci-dessous:
DELIMITER //
CREATE PROCEDURE GetAllListings()
BEGIN
SELECT nid, type, title FROM node where type = 'lms_listing' order by nid desc;
END //
DELIMITER;
Veuillez suivre ceci. Une fois la procédure créée, vous pouvez voir la même chose et l'exécuter.