Op MySQL opgeslagen procedures

MySQL biedt ons de mogelijkheid om opgeslagen procedures te maken . Opgeslagen procedures zijn een krachtig onderdeel van MySQL (en andere databasebeheersystemen, zoals SQL Server) en ze stellen u in staat meer te doen dan views.

Een opgeslagen procedure is een verzameling SQL-instructies die zijn opgeslagen in de database. Een opgeslagen procedure kan bedrijfslogica bevatten, wat een van de belangrijkste aspecten is die opgeslagen procedures onderscheidt van weergaven. Een opgeslagen procedure kan parameters accepteren en u kunt variabelen instellen, schrijf IF verklaringen, enz. binnen een opgeslagen procedure.

Hoe werken opgeslagen procedures?

Allereerst maakt u de opgeslagen procedure. Als het eenmaal is gemaakt, kunt u het uitvoeren (of beter gezegd, u "noemt" het).

Om een opgeslagen procedure uit te voeren, "roep" u deze op. Wanneer u het aanroept, geeft u ook eventuele parameters op die het nodig heeft. De opgeslagen procedure wordt dan uitgevoerd, waarbij uw parameters worden gebruikt op een manier die de code aangeeft.

U kunt bijvoorbeeld een opgeslagen procedure schrijven die een FruitId . accepteert parameter. De opgeslagen procedure zou die parameter dan kunnen gebruiken om de voorraad van dat specifieke fruit te controleren. Daarom zou je de opgeslagen procedure kunnen aanroepen, elke keer met een ander fruit-ID en het zou een waarde retourneren die aangeeft hoeveel van dat fruit in voorraad is.

Een opgeslagen procedure maken

Opgeslagen procedures worden gemaakt met behulp van de CREATE PROCEDURE verklaring.

Syntaxis

Hier is de syntaxis voor het maken van een opgeslagen procedure:

CREATE PROCEDURE sp_name(p_1 INT)
BEGIN
  ...code goes here...
END;

Vervang sp_name met de naam die u wilt gebruiken voor de opgeslagen procedure. De haakjes zijn verplicht — ze omsluiten alle parameters. Als er geen parameters vereist zijn, mogen de haakjes leeg zijn.

Het hoofdgedeelte van de opgeslagen procedure staat tussen de BEGIN en END trefwoorden. Deze trefwoorden worden gebruikt voor het schrijven van samengestelde uitspraken. Een samengestelde instructie kan meerdere instructies bevatten en deze kunnen indien nodig worden genest. Daarom kunt u BEGIN . nesten en END blokken.

In de meeste gevallen moet u ook de CREATE PROCEDURE . omringen statement met DELIMITER commando's en verander END; naar END // . Zoals dit:

DELIMITER //

CREATE PROCEDURE sp_name(p_1 INT)
BEGIN
  ...code goes here...
END //

DELIMITER ;

Ik zal binnenkort uitleggen waarom, maar laten we voor nu naar een voorbeeld kijken.

Voorbeeld

Hier is een eenvoudig voorbeeld van het maken van een opgeslagen procedure. De volgende code uitvoeren tegen onze FruitShop database zal een opgeslagen procedure aanmaken met de naam spCheckFruitStock :

DELIMITER //

CREATE PROCEDURE spCheckFruitStock(thisFruit SMALLINT)
BEGIN
	SELECT 
		Fruit.FruitName, 
		Fruit.Inventory, 
		Units.UnitName
	FROM 
		Fruit INNER JOIN Units ON
		Fruit.UnitId = Units.UnitId
	WHERE 
		Fruit.FruitId = thisFruit;
END //

DELIMITER ;

Nu kunnen we die opgeslagen procedure als volgt aanroepen:

CALL spCheckFruitStock(1);

Hier geven we een parameter van 1 . door dat is de ID voor Apple .

Dit is het resultaat:

We kunnen hetzelfde doen voor elk fruit in onze database, simpelweg door de parameter te wijzigen die is doorgegeven aan de opgeslagen procedure.

Over de `DELIMITER` Commando

In het bovenstaande voorbeeld hebben we een paar DELIMITER . toegevoegd commando's en we hebben een puntkomma vervangen door twee schuine strepen. Wat is hier aan de hand?

We hebben dit gedaan om MySQL te vertellen een ander scheidingsteken te gebruiken terwijl het onze opgeslagen procedure maakt.

De reden hiervoor is dat MySQL de puntkomma al herkent als een scheidingsteken voor het markeren van het einde van elke SQL-instructie. Daarom, zodra MySQL de eerste puntkomma ziet, zal het het scheidingsteken als zodanig interpreteren en zou onze opgeslagen procedure breken.

De DELIMITER commando stelt ons in staat om MySQL te vertellen om een ander scheidingsteken te gebruiken. In het bovenstaande voorbeeld stellen we dit in op twee schuine strepen (// ) maar dit had van alles kunnen zijn (maar vermijd het gebruik van een backslash (\ ) want dat is het escape-teken voor MySQL). Door het scheidingsteken te wijzigen, zal MySQL niet proberen onze puntkomma's te interpreteren als het einde van de instructie - het zal wachten tot het de twee schuine strepen ziet.

Zodra we de opgeslagen procedure hebben gemaakt, kunnen we DELIMITER ; . gebruiken om het scheidingsteken terug te zetten naar de puntkomma.

Een opgeslagen procedure verwijderen

U kunt een opgeslagen procedure verwijderen met behulp van de DROP PROCEDURE uitspraak. Zoals dit:

DROP PROCEDURE spCheckFruitStock;

Een opgeslagen procedure wijzigen

U kunt sommige alter wijzigen aspecten van een opgeslagen procedure met behulp van de ALTER PROCEDURE uitspraak.

Als u echter de hoofdtekst van de opgeslagen procedure of een van de parameters ervan wilt wijzigen, moet u de procedure verwijderen en opnieuw maken. Zoals dit:

DROP PROCEDURE IF EXISTS spCheckFruitStock;

DELIMITER //

CREATE PROCEDURE spCheckFruitStock(thisFruit SMALLINT)
BEGIN
	SELECT 
		Fruit.FruitId, 
		Fruit.FruitName, 
		Fruit.Inventory, 
		Units.UnitName
	FROM 
		Fruit INNER JOIN Units ON
		Fruit.UnitId = Units.UnitId
	WHERE 
		Fruit.FruitId = thisFruit;
END //

DELIMITER ;

Hier hebben we Fruit.FruitId . toegevoegd naar de lijst met kolommen om terug te keren.

Resultaat:

Een meer geavanceerde opgeslagen procedure

Het bovenstaande voorbeeld was eenvoudig om de syntaxis van het maken en aanroepen van opgeslagen procedures te demonstreren. Laten we eens kijken naar een iets complexere opgeslagen procedure:

DROP PROCEDURE IF EXISTS spCheckFruitStockLevel;

DELIMITER //

CREATE PROCEDURE spCheckFruitStockLevel(
	IN pFruitId SMALLINT(5),
    OUT pStockLevel VARCHAR(6))
BEGIN
	DECLARE stockNumber SMALLINT;
    
	SELECT 
		Fruit.Inventory into stockNumber
	FROM 
		Fruit INNER JOIN Units ON
		Fruit.UnitId = Units.UnitId
	WHERE 
		Fruit.FruitId = pFruitId;
        
	IF stockNumber > 10 THEN
		SET pStockLevel = 'High';
    ELSEIF (stockNumber <= 10 AND stockNumber >= 5) THEN
		SET pStockLevel = 'Medium';
    ELSEIF (stockNumber < 5) THEN
		SET pStockLevel = 'Low - Please Replace Now!';
	END IF;
    
END //

DELIMITER ;

Het bovenstaande voorbeeld accepteert twee verschillende modi van parameters (IN en OUT ). IN is de standaard, daarom bevatte het vorige voorbeeld de modus niet.

Hier stellen we ook een variabele in. We gebruiken DECLARE stockNumber SMALLINT om een variabele genaamd stockNumber te declareren met een type SMALLINT (klein geheel getal).

We gebruiken een SELECT statement om de voorraad voor de gegeven fruit-ID op te zoeken en die toe te wijzen aan ons stockNumber variabel.

Ten slotte gebruiken we een SQL IF statement om het voorraadniveau te bepalen, door deze waarde in het pStockLevel . te plaatsen parameter (wat natuurlijk de OUT . is parameter — dit is de waarde die we zullen zien wanneer we de opgeslagen procedure aanroepen).

Een opgeslagen procedure aanroepen met een `OUT` of `INOUT` Parameter

In ons laatste voorbeeld hebben we twee parameters gespecificeerd, een IN parameter en een OUT parameter.

Wanneer we deze opgeslagen procedure aanroepen, moeten we nog steeds de OUT . opnemen parameter. Omdat we de waarde echter niet weten (dat is tenslotte de reden waarom we het noemen - om de waarde ervan te achterhalen!), zullen we een variabele moeten gebruiken. Dan kunnen we een SELECT . gebruiken verklaring om de waarde ervan te achterhalen.

Zoals dit:

CALL spCheckFruitStockLevel(1, @stockLevel);
select @stockLevel;