Introduction aux curseurs en SQL

Les curseurs sont des espaces de travail temporaires créés dans la mémoire pour traiter certaines commandes SQL sur un tas de données. Définition trop compliquée? Comprenons-le. Considérez les curseurs comme pour chaque boucle en SQL. Vous souhaitez effectuer une tâche sur un ensemble de lignes de données, vous utilisez le curseur. Disons que vous avez une table des employés qui contient le salaire de chaque employé de l'organisation. Vous souhaitez augmenter le salaire de chaque employé d'un certain pourcentage. C'est là que vous utiliseriez un curseur. «Le comment» a été illustré plus loin dans l'article.

Ainsi, les curseurs créent un espace de travail temporaire avec l'ensemble de lignes sélectionné et un pointeur qui pointe vers la ligne actuelle. Cet ensemble de lignes, sur lequel le curseur effectuera l'opération souhaitée, est appelé un ensemble de données actif. Le pointeur récupère les lignes du jeu de résultats une par une. Vous pouvez ensuite effectuer n'importe quelle opération SQL une ligne à la fois.

Curseurs implicites

Les curseurs implicites, comme leur nom l'indique, sont générés par l'analyseur SQL pour les requêtes DML. Les requêtes DML sont des requêtes de manipulation de données. Ces requêtes manipulent ou modifient les données. Ils n'interfèrent pas avec la structure ou le schéma de la base de données. Les requêtes telles que SELECT, INSERT, UPDATE et DELETE génèrent un curseur implicite. Les curseurs implicites sont masqués pour l'utilisateur final.

Curseurs explicites

Les curseurs explicites sont des curseurs générés par l'utilisateur. Lorsqu'un utilisateur demande à l'analyseur SQL de créer un curseur pour un ensemble actif, le curseur ainsi créé est appelé curseur explicite. L'ensemble actif est défini par une requête SELECT de l'utilisateur. Nous couvririons les curseurs explicites en détail dans cet article.

Actions du curseur - Le cycle de vie d'un curseur

Le cycle de vie d'un curseur comprend généralement cinq étapes:

1. Déclarer: La première étape consiste à déclarer un curseur. Cette étape demande au système de générer un curseur avec l'ensemble de données donné. L'ensemble de données est construit à l'aide d'une instruction SQL. À ce stade, l'ensemble actif est créé mais l'espace de travail temporaire du curseur n'est pas encore ouvert dans la mémoire.

2. Ouvrir: Ensuite, le système est invité à ouvrir le curseur. À ce stade, l'espace de travail temporaire est chargé dans la mémoire avec l'ensemble actif et un pointeur est généré qui pointe vers la première ligne de l'ensemble actif.

3. Récupération: il s'agit de l'étape récurrente de l'ensemble du processus. La ligne actuelle pointée par le pointeur est récupérée et la tâche souhaitée est effectuée sur les données de ligne. Le pointeur se déplace vers la ligne suivante du curseur.

4. Fermer: Une fois la manipulation des données terminée, le curseur doit être fermé.

5. Désallocation: il s'agit de la dernière étape pour supprimer le curseur et libérer la mémoire, le processeur et les autres ressources système allouées au curseur.

Curseurs explicites - en action!

Bon, maintenant nous avons une compréhension de base de ce que sont les curseurs et comment ils fonctionnent. Il est temps de se salir les mains et de créer nous-mêmes un curseur explicite.

La terminologie des curseurs en SQL

Comprenons les terminologies utilisées dans cette syntaxe.

Portée du curseur

  • La portée du curseur peut être GLOBALE ou LOCALE . Un curseur global est disponible tout au long de la connexion. Un curseur local est limité à l'étendue uniquement aux procédures stockées, aux fonctions ou à la requête qui contient le curseur.
  • Il s'agit de la fonctionnalité spécifique à MS SQL Server. MySQL prend uniquement en charge les curseurs de portée locale.

Mouvement du curseur

  • MS SQL Server donne également la possibilité de définir le mouvement du curseur. Il peut s'agir du mode conventionnel Forward_Only qui déplace le pointeur de la première ligne jusqu'à la dernière ligne par ligne. Ou, il peut être fait défiler jusqu'à la première, dernière, précédente ou suivante.
  • Les curseurs dans MySQL ne défilent pas.

Type de curseur

  • Un curseur peut être statique car il peut mettre en cache l'ensemble actif jusqu'à la désallocation et peut jongler en avant et en arrière à travers cet ensemble actif mis en cache. Un curseur ne peut avancer rapidement qu'en mode statique.
  • Il peut également être dynamique pour permettre l'ajout ou la suppression de lignes dans l'ensemble actif lorsque le curseur est ouvert. Ces modifications ne sont pas visibles pour les autres utilisateurs du curseur en mode jeu de clés. Les curseurs dans MySQL sont rapides uniquement.

Verrouillage du curseur

  • Les verrous de curseur sont utiles dans un environnement multi-utilisateur. Ils verrouillent la ligne de sorte que deux utilisateurs n'opèrent pas sur les mêmes données simultanément. Cela garantit l'intégrité des données.
  • Un verrou en lecture seule indique que la ligne ne peut pas être mise à jour.
  • Les verrous de défilement verrouillent la ligne au fur et à mesure qu'ils sont récupérés dans le curseur, garantissant que la tâche réussit et que les données mises à jour sont disponibles en dehors du curseur. Optimiste tente de mettre à jour la ligne sans verrou. Ainsi, si la ligne a été mise à jour en dehors du curseur, la tâche échouera.
  • MySQL prend uniquement en charge les verrous en lecture seule. Cela signifie que MySQL ne mettra pas à jour la table réelle, mais copiera plutôt les données pour exécuter les commandes de mise à jour.

Ainsi, nous voyons que ces options sont disponibles uniquement dans MS SQL Server. Cela rend la syntaxe des curseurs MySQL encore plus simple.

Exemple

Laissez-nous maintenant mettre à jour le salaire des employés dans notre tableau des employés.

Nous utiliserions les données ci-dessous dans ces curseurs dans l'exemple SQL.

Notre code de curseur serait le suivant:

DECLARE @sal float
DECLARE @newsal float
DECLARE Emp_Cur CURSOR FOR SELECT Salary, Updated_Salary FROM Employees
OPEN Emp_Cur
FETCH NEXT FROM Emp_Cur INTO @sal, @newsal
WHILE @@FETCH_STATUS = 0
BEGIN
SET @newsal = @sal*1.25
UPDATE Employees SET Updated_Salary = @newsal WHERE CURRENT OF Emp_Cur
FETCH NEXT FROM Emp_Cur INTO @sal, @newsal
END
CLOSE Emp_Cur
DEALLOCATE Emp_Cur

Et la sortie après avoir exécuté la commande de curseur ci-dessus serait:

Conclusion - Curseurs en SQL

Ainsi, nous avons vu ce que sont les curseurs, comment les utiliser et où les éviter. Les curseurs s'avèrent être un utilitaire utile pour les développeurs mais au détriment des performances. Soyez donc prudent lorsque vous optez pour des curseurs.

Articles recommandés

Ceci est un guide des curseurs en SQL. Nous discutons ici des types, du cycle de vie et de la terminologie du curseur en SQL avec des exemples. Vous pouvez également consulter nos autres articles suggérés -

  1. Types de jointures dans SQL
  2. Commande SQL Alter
  3. Vues SQL
  4. Outils de gestion SQL
  5. Types de curseurs en PL / SQL
  6. 6 principaux types de jointures dans MySQL avec des exemples

Catégorie:

Outils de développement Web