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 ▲

Il existe trois fonctionnalités intéressantes pour les curseurs:

@@ FETCH_STATUS: Retourne l'état de la dernière instruction FETCH faite sur un curseur. Il retourne 0 si tout s'est bien passé, -1 s'il n'y a plus de lignes et -2 si la ligne est manquante. @@ CURSOR_ROWS: Retourne le nombre de lignes actuellement dans le dernier curseur ouvert. Retourne 0 s'il n'y a pas de curseurs ouverts ou plus de lignes dans le dernier curseur. Renvoie un nombre négatif si le curseur a été ouvert de manière asynchrone (voir Configuration de SQL Server) CURSOR_STATUS: Nous permet de vérifier qu'une procédure retourne correctement un curseur avec un ensemble de données. Je ne m'attarderai pas sur cette fonction, vu sa complexité, référez-vous à la doc si vous en avez besoin.

IV-B. VS Slider Set ▲

La manipulation d'ensemble est simplement une requête qui retournera un ensemble de données (un ensemble de résultats). C’est simplement des requêtes SELECT. Ces requêtes sont simples à réaliser même si on peut aller assez loin avec elles. Malheureusement, nous n’avons pas vraiment le pouvoir sur eux, c’est la base de données qui décide de ce qu’elle va nous renvoyer. La lecture du curseur est en réalité la face cachée de la manipulation des ensembles, dès que nous faisons un SELECT, la base de données utilisera des curseurs pour générer le résultat de notre requête. Comme nous venons de le voir, nous pouvons utiliser ces curseurs nous-mêmes pour plus de flexibilité. D'autre part, les curseurs sont considérés comme plutôt instables et, en les manipulant nous-mêmes, les risques sont exposés plus haut qu'un simple SELECT. ensembliste

Très simple à utiliser Aucune possibilité de modification sur le retour Risque presque nul Très recommandé

curseurs

Non recommandé, à utiliser uniquement dans les cas où vous ne pouvez rien faire d'autre Utilisation assez complexe Très puissant Risques d'instabilité Pleine puissance au retour parce que c'est nous qui faisons tout

Click to rate this post! [Total: 0 Average: 0]