sql >> Databasteknik >  >> RDS >> Mysql

Skapa och använda MySQL-lagrade procedurer - en handledning

Lagrade procedurer är användardefinierade SQL-satser som lagras i en MySQL-databas och exekveras på begäran för att utföra en specifik databasoperation. Dessa fördefinierade subrutiner hjälper till att flytta affärslogiken till databasen, vilket ger några fördelar:

  • Rundresor som görs till databasservern av en applikation minimeras.
  • Kodunderhållbarheten förbättras, eftersom olika applikationer kan dela den lagrade proceduren.
  • Databasprestanda förbättras eftersom lagrade procedurer kompileras en gång och exekveras mycket snabbt och effektivt.

I den här guiden kommer du att:

  • Lär dig syntaxen för att skapa lagrade procedurer och deklarera din första procedur.

  • Utför exempelproceduren efter att du har deklarerat det.

  • Lär dig hur du tar bort en procedur när du inte längre behöver den.

Innan du börjar

Se till att du har följande:

  1. Om du inte redan har gjort det, skapa ett Linode-konto och Compute Instance. Se våra guider Komma igång med Linode och Skapa en beräkningsinstans.

  2. Följ vår guide för att ställa in och säkra en beräkningsinstans för att uppdatera ditt system. Du kanske också vill ställa in tidszonen, konfigurera ditt värdnamn, skapa ett begränsat användarkonto och förstärka SSH-åtkomsten.

  3. En MySQL-server och klient installerad på Linode-servern. Installationsguider för MySQL finns tillgängliga för olika distributioner i vår MySQL-sektion.

Förbered databasen

Du börjar med att skapa en exempeldatabas, tabell och användare för åtkomst till databasen. Du kommer också att fylla i tabellen med exempeldata för teständamål.

Skapa databasen, tabellen och användaren

  1. Logga in på MySQL-servern:

     mysql -u root -p

    Du kommer att bli ombedd att ange root-lösenordet för din MySQL-databas. Tryck sedan på Retur för att fortsätta.

  2. Därefter kommer du att se en MySQL-prompt som liknar den som visas nedan.

    mysql >

  3. Ange kommandot nedan för att skapa en test_db databas:

    CREATE DATABASE test_db;

    Utdata:

    Query OK, 1 row affected (0.01 sec)

  4. Skapa en databasanvändare och ge full åtkomst till test_db databas. Ersätt PASSWORD med ett komplext och unikt värde som följer riktlinjerna för MySQL-lösenord:

    CREATE USER 'test_user'@'localhost' IDENTIFIED BY 'PASSWORD';

    Utdata:

    Query OK, 1 row affected (0.01 sec)

  5. Bevilja test_user fullständiga rättigheter till test_db databas;

    GRANT ALL PRIVILEGES ON test_db.* TO 'test_user'@'localhost';

    Utdata:

    Query OK, 1 row affected (0.01 sec)

  6. Spola privilegier:

    FLUSH PRIVILEGES;

    Utdata:

    Query OK, 0 rows affected (0.01 sec)

Fyll i databasen

  1. Växla sedan till databasen test_db:

    USE test_db;

    Utdata:

    Database changed

  2. Skapa en products tabell för att lagra exempelposter:

    CREATE TABLE products(product_id BIGINT PRIMARY KEY, product_name VARCHAR(50), category_name VARCHAR(50) ) ENGINE=INNODB;

    Utdata:

    Query OK, 0 rows affected (0.01 sec)

  3. Du kan nu lägga till några produkter till produkttabellen genom att utföra kommandona nedan en efter en:

    INSERT INTO products (product_id, product_name, category_name) VALUES ('1', 'GAMING KEYBOARD', 'COMPUTER ACCESSORIES');
INSERT INTO products (product_id, product_name, category_name) VALUES ('2', 'OPTICAL MOUSE', 'COMPUTER ACCESSORIES');
INSERT INTO products (product_id, product_name, category_name) VALUES ('3', 'MOUSE PAD', 'COMPUTER ACCESSORIES');
INSERT INTO products (product_id, product_name, category_name) VALUES ('4', 'STEREO SYSTEM', 'ELECTRONICS');
INSERT INTO products (product_id, product_name, category_name) VALUES ('5', '32 INCH TV', 'ELECTRONICS');
INSERT INTO products (product_id, product_name, category_name) VALUES ('6', 'DVB-T2 RECEIVER', 'ELECTRONICS');

    Du bör få utdata nedan efter att ha kört varje Insert uttalande:

    Query OK, 1 row affected (0.00 sec)

  4. Nästa. bekräfta om exempelprodukterna har infogats i databasen genom att köra Select kommandot nedan:

    SELECT * FROM products;

    Dina exempelprodukter bör listas enligt nedan:

    +------------+-----------------+----------------------+
| product_id | product_name    | category_name        |
+------------+-----------------+----------------------+
|          1 | GAMING KEYBOARD | COMPUTER ACCESSORIES |
|          2 | OPTICAL MOUSE   | COMPUTER ACCESSORIES |
|          3 | MOUSE PAD       | COMPUTER ACCESSORIES |
|          4 | STEREO SYSTEM   | ELECTRONICS          |
|          5 | 32 INCH TV      | ELECTRONICS          |
|          6 | DVB-T2 RECEIVER | ELECTRONICS          |
+------------+-----------------+----------------------+
6 rows in set (0.00 sec)

  5. Avsluta MySQL-servern.

    QUIT;

    Utdata:

    Bye!

  6. När du har skapat en test_db databas, products tabell, en test_user , och lagt till några exempelprodukter, kan du nu gå vidare till att skapa den första lagrade proceduren.

Skapa en lagrad procedur

Syntax för lagrad procedur

Den grundläggande syntaxen för att skapa en lagrad procedur i MySQL-databasen visas nedan:

DELIMITER &&
CREATE PROCEDURE PROCEDURE_NAME (PARAMETER_1, PARAMETER_2, PARAMETER_N...)
BEGIN
[SQL STATEMENT]
END &&
DELIMITER ;

  • DELIMITER && raden i början säger till MySQL-servern att behandla följande SQL-satser som en enda sats, snarare än att köra dem individuellt. En annan && finns med på en senare rad för att markera slutet på detta uttalande.

  • PROCEDURE_NAME är där namnet på din lagrade procedur deklareras.

  • Procedurnamnet följs av en uppsättning parenteser, och dessa omsluter parametrarna till din procedur. Lagrade procedurer stöder kommaseparerade parametrar, och den här funktionen gör dem mer flexibla. Se avsnittet om parametrar för mer information.

  • BEGIN...END kommandon omsluter SQL-satsen som du vill ska köras av den lagrade proceduren.

  • I slutet, satsen DELIMITER ; utfärdas igen för att ändra tillbaka avgränsaren till standardvärdet ;

Lagrade procedurparametrar

Varje parameter för en procedur har en typ, ett namn och en datatyp, separerade med mellanslag:

PARAMETER_TYPE PARAMETER_NAME DATA_TYPE

Till exempel för att skapa en parameter av typen IN , med namnet category , med VARCHAR datatyp som har en längd på 50 tecken, använd denna syntax:

IN category VARCHAR(50)

MySQL stöder tre typer av parametrar:

  • IN :Värdet på parametern måste anges av den anropande klienten. Detta värde kan inte ändras av den lagrade proceduren .

    Till exempel, om du skickar en MySQL-sessionsvariabel som en IN parameter till en procedur, och proceduren ändrar detta värde i sina uttalanden, kommer din sessionsvariabel att förbli oförändrad efter att proceduren avslutas.

  • OUT :Denna typ av parameter anges också av det anropande programmet, men dess värde kan ändras av den lagrade proceduren och hämtas av det anropande programmet.

    Observera att den lagrade proceduren inte kan komma åt initialvärdet för en variabel som skickas som en OUT parameter.

  • INOUT :En parameter av denna typ kombinerar beteendet för IN och OUT parametrar:

    • Den lagrade proceduren kan läsa parameterns initiala värde.

    • Parametern kan ändras under körning av lagrad procedur.

    • Det ändrade värdet kan returneras till det anropande programmet, om det anropande programmet skickade en variabel som parameter.

Ett exempel på lagrad procedur

Efter att ha förstått den grundläggande syntaxen, låt oss skapa en enkel lagrad procedur för att filtrera produkter efter kategorinamn. Kategorinamnet kommer att tillhandahållas som en IN parameter.

  1. Logga in på MySQL-servern med test_user s referenser som du skapade när du förberedde databasen:

     mysql -u test_user -p

  2. Ange lösenordet för test_user och tryck på Retur för att fortsätta.

  3. Du får en mysql > prompt. Fortsätt genom att välja test_db :

     USE test_db;

    Utdata:

    Database changed.

  4. Ange sedan SQL-kommandona nedan för att skapa en filter_by_category lagrad procedur:

     DELIMITER &&
 CREATE PROCEDURE filter_by_category (IN category VARCHAR(50))
 BEGIN
 SELECT * FROM products WHERE category_name=category;
 END &&

    Utdata:

    Query OK, 0 rows affected (0.00 sec)

  5. Ändra DELIMITER tillbaka till ; 

    DELIMITER ;

  6. Om koden för att skapa den lagrade proceduren kördes framgångsrikt kan du nu gå vidare till att utföra den lagrade proceduren.

Köra en lagrad procedur

I det här steget kommer vi att anropa den lagrade proceduren som vi skapade ovan. Vi kommer att följa denna grundläggande syntax:

CALL PROCEDURE_NAME (COMMA-SEPARATED PARAMETER VALUES);

  • För att köra filter_by_category lagrad procedur som vi skapade ovan, ange kommandot nedan:

    CALL filter_by_category('COMPUTER ACCESSORIES');

    Den lagrade proceduren bör nu mata ut alla produkter i COMPUTER ACCESSORIES kategori eftersom vi har specificerat COMPUTER ACCESSORIES som en parameter:

    +------------+-----------------+----------------------+
| product_id | product_name    | category_name        |
+------------+-----------------+----------------------+
|          1 | GAMING KEYBOARD | COMPUTER ACCESSORIES |
|          2 | OPTICAL MOUSE   | COMPUTER ACCESSORIES |
|          3 | MOUSE PAD       | COMPUTER ACCESSORIES |
+------------+-----------------+----------------------+
3 rows in set (0.00 sec)

Query OK, 0 rows affected (0.01 sec)

  • På samma sätt kan du hämta en lista över alla produkter från ELECTRONICS kategori genom att utföra kommandot nedan.

    CALL filter_by_category('ELECTRONICS') ;

    Utdata:

    +------------+-----------------+---------------+
| product_id | product_name    | category_name |
+------------+-----------------+---------------+
|          4 | STEREO SYSTEM   | ELECTRONICS   |
|          5 | 32 INCH TV      | ELECTRONICS   |
|          6 | DVB-T2 RECEIVER | ELECTRONICS   |
+------------+-----------------+---------------+
3 rows in set (0.00 sec)

Query OK, 0 rows affected (0.01 sec)

Vår lagrade procedur fungerade som vi förväntade oss. Därefter kommer vi att lära oss hur man släpper de lagrade procedurerna om vi inte längre vill att de ska köras igen.

Ta bort lagrade procedurer

Du kan ta bort en MySQL-lagrad procedur om du inte längre vill använda den eller om du vill återskapa den från grunden. Den grundläggande syntaxen för att ta bort den lagrade proceduren visas nedan:

DROP PROCEDURE IF EXISTS PROCEDURE_NAME;

Till exempel för att ta bort vår filter_by_category lagrad procedur, kör MySQL-kommandot nedan:

DROP PROCEDURE IF EXISTS filter_by_category;

Om den lagrade proceduren finns får du utdata som visas nedan:

Query OK, 0 rows affected (0.00 sec)

Det är allt när det kommer till att skapa, använda och släppa MySQL-lagrade procedurer.

Mer information

Du kanske vill konsultera följande resurser för ytterligare information om detta ämne. Även om dessa tillhandahålls i hopp om att de kommer att vara användbara, vänligen observera att vi inte kan garantera noggrannheten eller aktualiteten hos externt värdmaterial.

  • Arbeta med MySQL-lagrade procedurer

  1. Migrera MySQL till PostgreSQL på AWS RDS, del 1

  2. Använda Unpivot-steget för att göra en tabelltabell av en korstabell

  3. PostgreSQL:hur man installerar plpythonu-tillägget

  4. STRING_AGG() Funktion i PostgreSQL