Procédures et curseurs avec MS-SQL Server – Bien choisir son serveur d impression

Vous avez parfois entendu parler de fonctions, de procédures ou de curseurs, mais vous ne savez jamais vraiment de quoi il en retourne. Alors cet article est fait pour vous. Nous allons passer en revue toutes ces choses et vous apprendre à les utiliser et à quoi elles servent.

Une procédure stockée est un morceau de code qui est placé sur le serveur et sera ensuite exécuté directement sur le serveur. Ce code est déjà compilé. Ainsi, pour de nombreux appels de la même méthode, il n'est pas nécessaire de recompiler à chaque fois.

Une procédure est un morceau de code qui n'a aucune valeur, elle effectue simplement un travail.

Syntaxe de création de procédure:

CRÉER PROCÉDURE prénom @ paramètre1 type1, @ paramètre2 type2 ...
	COMME sql_statement

Explication de la syntaxe

• name: c'est simplement le nom que nous voulons donner à notre procédure
• @parameter: c'est un paramètre que nous passons à la procédure quand on l'appelle
• sql_statement: il s'agit d'un ensemble d'instructions SQL que la procédure effectuera lorsqu'elle sera appelée

Exemple: Nous avons besoin d'une procédure qui ajoute deux numéros de passe à un paramètre, qui les ajoute et affiche le résultat:

CRÉER PROCÉDURE print_addition @ number1 INT, @ numéro 2 INT
COMME IMPRESSION @ NB1 + @ NB2

Call: Pour appeler une procédure, écrivez simplement EXECUTE suivi du nom de votre procédure:

RÉALISÉ print_addition 1, 2

Nous pouvons noter qu'il n'est pas obligatoire d'utiliser EXECUTE, nous pouvons également utiliser EXEC ou directement le nom de la fonction (mais seulement s'il s'agit du premier du lot).

Une fonction est une procédure qui renvoie une valeur.

Syntaxe de création:

CRÉER UNE FONCTION prénom ([[[[@ paramètre1 type 1, @ parametre2 type ...])
	RÉSULTATS type
	COMMENCER
		sql_statement 
		REVENIR @valeur
	FIN

Explications de syntaxe

• name: le nom de la fonction
• @parameterX: un paramètre de la fonction
• typeX: le type du paramètre
• type: le paramètre de retour de la fonction
• sql_statement: les instructions SQL que nous allons exécuter
• @value: la valeur qui retournera la fonction

Exemple: Nous voulons créer une fonction qui prend deux nombres dans les paramètres, ce qui les additionne et renvoie le résultat:

CRÉER UNE FONCTION return_addition (@ NB1 INT, @ numéro 2 INT)
	RÉSULTATS INT
	COMMENCER 
		REVENIR @ NB1 + @ NB2
	FIN

Appel: Pour appeler une fonction, utilisez son nom à deux composants (propriétaire.nom), utilisez-le simplement tel quel:

IMPRESSION dbo.return_addition(1,3)

Cela va nous montrer 4.

Le curseur est un mécanisme de mémoire tampon permettant de parcourir les lignes d’enregistrement du résultat renvoyé par une requête. Les curseurs sont envoyés par MS-SQL Server tout le temps, mais nous ne voyons pas le mécanisme se dérouler. Par conséquent, lors d'une requête SELECT, SQL Server utilisera des curseurs.

Pour utiliser un curseur, commencez par le déclarer:

DÉCLARÉ prénom LE CURSEUR POUR 
	SÉLECTIONNER ...

Il peut également être utilisé avec modification en ajoutant FOR UPDATE à la fin de la requête, bien que cela ne soit pas conseillé.

Ensuite, vous devez ouvrir ce curseur avec le nom OPEN et ne pas oublier de fermer la fin avec le nom CLOSE. Vous devez également utiliser DEALLOCATE pour libérer la mémoire du curseur.

Pour récupérer les valeurs actuelles contenues dans le curseur, utilisez:

FETCH prénom DANS @ valeur1, @ valeur2 ... 

Cela stockera les valeurs actuelles de l’enregistrement en cours dans des variables @valueX, qu’il ne faut pas oublier de déclarer.

Nous pouvons néanmoins utiliser FETCH pour autre chose:

• Aller à la première ligne: FETCH FIRST FROM nom_curseur
• Aller à la dernière ligne: FETCH LAST FROM nom_curseur
• Accédez à la ligne suivante: FETCH NEXT FROM nom_curseur
• Aller à la ligne précédente: FETCH PRIOR FROM nom_curseur
• Aller à la ligne X: ligne FETCH ABSOLUTE FROM nom_curseur
• Allez X lignes plus loin que la ligne actuelle: ligne FETCH RELATIVE FROM nom_curseur

Pour parcourir un curseur, vous pouvez utiliser une boucle WHILE qui teste la valeur de la fonction @@ FETCH_STATUS qui renvoie 0 jusqu'à ce que vous ayez terminé.

DÉCLARÉ @prénom VARCHAR(50)
 
DÉCLARÉ curseur_auteurs LE CURSEUR POUR
	SÉLECTIONNER auteur_nom DE t_auteurs
 
OUVRIR curseur_auteurs
 
FETCH curseur_auteurs DANS @prénom
 
TANDIS QUE @@ FETCH_STATUS = 0
COMMENCER
	IMPRESSION @prénom
	FETCH curseur_auteurs DANS @prénom
FIN
 
FERMER curseur_auteurs
DEALLOCATE curseur_auteurs

Nous pouvons bien sûr imbriquer plusieurs curseurs les uns dans les autres pour des choses plus compliquées.

Concrètement, maintenant que nous avons vu le fonctionnement et l'utilisation d'un curseur, que fait-il plus qu'une simple requête? Cela permet surtout d’intervenir sur le résultat de la demande. Nous pouvons intervenir sur chaque retour de valeur, nous pouvons modifier ces valeurs ou supprimer des lignes. Nous pouvons également effectuer des opérations avec ces données avant qu'elles n'arrivent au programme qui les utilise, à savoir les calculs de somme, les maximums, les changements de date, le formatage de chaîne de caractères.

Un exemple intéressant est le parcours avec pause, c'est-à-dire parcourir et si nous avions une fois cet objet, nous ne l'afficherons pas. Dans l'exemple que je vais vous présenter, nous montrons tous les genres, acteurs par genre, et pour chaque acteur, les livres qu'il a écrits. Les pauses permettent de vérifier que nous n’avons pas affiché cet élément une fois:

DÉCLARÉ @Titre VARCHAR(50), @genre VARCHAR(50)@rupture_genre VARCHAR(50)@rupture_auteur VARCHAR(50), @auteur VARCHAR(50)
DÉCLARÉ @i_genre INT
 
ENSEMBLE @i_genre = 1
ENSEMBLE @rupture_genre = & # 39;& # 39;
ENSEMBLE @rupture_auteur = & # 39;& # 39;
 
DÉCLARÉ curseur_ouvrages LE CURSEUR POUR 
	SÉLECTIONNER book_title, gender_name, author_name DE t_ouvrages O
	LA GAUCHE EXTÉRIEUR JOINDRE t_genres
		NOUS genre_id = ouvrage_genre
	LA GAUCHE EXTÉRIEUR JOINDRE TOA création
		NOUS TOA.ouvrage_id = O.ouvrage_id
	LA GAUCHE EXTÉRIEUR JOINDRE t_auteurs TA
		NOUS TA.auteur_id = TOA.auteur_id
	ORDRE PAR ouvrage_genre
 
OUVRIR curseur_ouvrages
 
FETCH curseur_ouvrages DANS @title, @genre, @author
 
TANDIS QUE @@ FETCH_STATUS = 0
COMMENCER
	SI @gentil ! = @rupture_genre
	COMMENCER
		IMPRESSION & # 39;& # 39;
		IMPRESSION CONVERTIR(RÉSERVOIR(2)@ I_genre) + & # 39;. & # 39; + @gentil
 
		ENSEMBLE @i_genre = @i_genre + 1
		ENSEMBLE @rupture_auteur = & # 39;& # 39;
	FIN
 
	SI @auteur ! = @rupture_auteur
	COMMENCER
		IMPRESSION & # 39;& # 39;
		IMPRESSION @auteur
		IMPRESSION & # 39;------------& # 39;
	FIN
 
	IMPRESSION @Titre;
 
	ENSEMBLE @rupture_genre = @gentil
	ENSEMBLE @rupture_auteur = @auteur
	FETCH curseur_ouvrages DANS @title, @genre, @author
FIN
 
FERMER curseur_ouvrages
DEALLOCATE curseur_ouvrages

IV-A. Fonctions du curseur ▲

IV-B. VS Slider Set ▲