Qu'est-ce que l'utilisation d'un curseur dans SQL Server?

Je veux utiliser une base de données de curseur; j'ai d'abord besoin de comprendre ce que son utilisation et la syntaxe sont, et dans quel scénario nous pouvons l'utiliser dans des procédures stockées? Quelles sont les différentes syntaxes pour les différentes versions de SQL Server?

Quand est-il nécessaire d'utiliser?

La recherche ne prend vraiment pas beaucoup de temps, j'ai trouvé cet article facilement et il couvre la plupart des questions que vous vous posez: sqlteam.com/article/cursors-an-overview

InformationsquelleAutor Red Swan | 2010-11-19

database-cursor sql-server

38

Les curseurs sont un mécanisme d'énumérer explicitement à travers les lignes d'un résultat, plutôt que de récupérer en tant que tel.

Cependant, alors qu'ils peuvent être plus à l'aise à utiliser pour les programmeurs habitués à l'écriture While Not RS.EOF Do ..., ils sont généralement une chose à éviter dans les procédures stockées SQL Server si possible, si vous pouvez écrire une requête sans l'utilisation de curseurs, vous donner l'optimiseur une bien meilleure chance de trouver un moyen rapide de le mettre en œuvre.

En toute honnêteté, je n'ai jamais trouvé un réaliste cas d'utilisation d'un curseur qui n'a pas pu être évités, à l'exception de quelques tâches administratives telles que boucler sur tous les index dans le catalogue et les reconstruire. Je suppose qu'ils pourraient avoir dans la génération de rapport ou de publipostage, mais c'est probablement plus efficace, le curseur-comme travailler dans une application qui communique avec la base de données, de laisser le moteur de base de faire ce qu'il fait le mieux-jeu de manipulation.
- +1 la plupart du temps, ils ne sont pas nécessaires. Utiliser uniquement dans un emploi à temps plein ou lorsque toutes les autres options échouent.
- Le seul réel besoin pour les curseurs que j'ai trouvé est dans le domaine des déclencheurs - si vous avez plusieurs enregistrements affectés, et vous souhaitez exécuter une procédure stockée pour chaque enregistrement, vous avez besoin pour naviguer dans le déclenchement des tables (e.g "INSÉRÉ")
- Si un curseur est utilisé pour parcourir les lignes d'un résultat, par exemple la mise à jour de l'état de 100 lignes de l'attente pour la terminer?
- Il est utilisé pour parcourir les lignes d'un jeu de résultat directement dans le SGBD programmation du modèle, comme à l'intérieur d'un déclencheur ou d'une procédure stockée; comme RPM1984 dit, un cas d'utilisation typique est l'exécution d'une procédure stockée pour chaque ligne du jeu de résultats, surtout si votre programmabilité modèle ne permet pas de raison de fixer des valeurs comme paramètres.
- explication même je ne le trouve pas en temps réel exemple qui doit avoir à utiliser le curseur
- J'ai une question j'ai de l'utilisateur dans l'ensemble des résultats curseur à l'instar de tous les exemples trouvés dans google utilisez PRINT 'Name : '+@name+ ', pagename : '+convert(varchar(20),@salary) mais puis-je retourner des résultats à partir d'ici pour c#?
- Il vient de se produire pour moi que de l'exécution d'une procédure stockée pour chaque enregistrement dans un déclencheur est probablement la plus désastreuse pour la performance que vous pouvez obtenir; mieux d'avoir la procédure stockée en mesure de fonctionner sur le déclencheur de l'ensemble de lignes directement en quelque sorte, peut-être par table argument.
- quid des fonctions stockées? Pouvez des fonctions stockées utilisez les curseurs ainsi?
InformationsquelleAutor Jeffrey Hantin
16

curseur sont utilisées parce que dans la sous-requête, nous pouvons chercher de l'enregistrement, ligne par ligne
nous avons donc utilisez le curseur pour récupérer les enregistrements

Exemple de curseur:
```
DECLARE @eName varchar(50), @job varchar(50)

DECLARE MynewCursor CURSOR -- Declare cursor name

FOR
Select eName, job FROM emp where deptno =10

OPEN MynewCursor -- open the cursor

FETCH NEXT FROM MynewCursor
INTO @eName, @job

PRINT @eName + ' ' + @job -- print the name

WHILE @@FETCH_STATUS = 0

BEGIN

FETCH NEXT FROM MynewCursor 
INTO @ename, @job

PRINT @eName +' ' + @job -- print the name

END

CLOSE MynewCursor

DEALLOCATE MynewCursor
```
De SORTIE:
```
ROHIT                           PRG  
jayesh                          PRG
Rocky                           prg
Rocky                           prg
```
- nous avons pu obtenir le même résultat à partir de la simple requête "Select eName,job, DE emp où deptno =10' alors, pourquoi utiliser le curseur de la boucle ,toutes les utilisations pratiques?
- J'ai une question j'ai de l'utilisateur dans l'ensemble des résultats curseur à l'instar de tous les exemples trouvés dans google utilisez PRINT 'Name : '+@name+ ', pagename : '+convert(varchar(20),@salary) mais puis-je retourner des résultats à partir d'ici pour c#?
InformationsquelleAutor rohit vyas
8

Curseur peut utilisé pour la récupération des données ligne par ligne.son acte comme une boucle(c'est à dire boucle while ou for).
Utiliser les curseurs dans SQL procédures, vous devez effectuer les opérations suivantes:
1.Déclarer un curseur qui définit un ensemble de résultats.
2.Ouvrir le curseur à établir le jeu de résultats.
3.Récupérer les données dans des variables locales en tant que de besoin à partir du curseur, une ligne à la fois.
4.Fermer le curseur lorsque vous avez terminé.

ex:
```
declare @tab table
(
Game varchar(15),
Rollno varchar(15)
)
insert into @tab values('Cricket','R11')
insert into @tab values('VollyBall','R12')

declare @game  varchar(20)
declare @Rollno varchar(20)

declare cur2 cursor for select game,rollno from @tab 

open cur2

fetch next from cur2 into @game,@rollno

WHILE   @@FETCH_STATUS = 0   
begin

print @game

print @rollno

FETCH NEXT FROM cur2 into @game,@rollno

end

close cur2

deallocate cur2
```
InformationsquelleAutor Murugan
1

Je dirais que vous pourriez vouloir utiliser un curseur lorsque vous voulez faire des comparaisons des caractéristiques qui sont sur des lignes différentes de la de retour ensemble, ou si vous voulez écrire une autre ligne de sortie format que un standard dans certains cas. Deux exemples me viennent à l'esprit:
1. On était dans un collège où chaque ajouter et supprimer une classe avait sa propre ligne dans le tableau. Il pourrait avoir été une mauvaise conception, mais vous avez besoin de comparer à travers les lignes pour savoir combien d'ajouter et supprimer des lignes que vous aviez en vue de déterminer si la personne était dans la classe ou pas. Je ne pense pas qu'un simple moyen de le faire avec seulement sql.
2. Un autre exemple est l'écriture d'un journal total ligne pour GL revues. Vous obtenez un nombre arbitraire de débits et de crédits dans votre journal, vous avez de nombreux journaux dans votre ensemble de lignes de retour, et vous voulez écrire un journal total ligne à chaque fois que vous terminez un journal de le poster dans un grand Livre. Avec un curseur que vous pourriez dire quand vous l'avez laissé un journal et a commencé à l'autre et ont des accumulateurs pour vos débits et de crédits et d'écrire un journal total de la ligne (ou de la table, insert) qui était différente de celle de la carte de débit/crédit en ligne.
- Vous ne devez frapper la barre d'espace une fois après une phrase se termine.
InformationsquelleAutor flashgordon
1

Curseur lui-même, est un itérateur (comme TOUT). En disant itérateur, je veux dire une manière de parcourir l'ensemble d'enregistrements (aka une sélection de lignes de données) et d'effectuer des opérations sur elle alors qu'elles traversent. Les opérations pourraient être d'INSÉRER ou de SUPPRIMER par exemple. Par conséquent, vous pouvez l'utiliser pour la récupération de données par exemple. Curseur fonctionne avec les lignes de l'ensemble de résultats de façon séquentielle - ligne par ligne. Un curseur peut être considéré comme un pointeur vers une ligne dans un ensemble de lignes et peuvent uniquement faire référence à une ligne à la fois, mais peut se déplacer à d'autres lignes du jeu de résultats en tant que de besoin.

Ce lien peut a une explication claire de sa syntaxe et contient des informations supplémentaires ainsi que des exemples.

Les curseurs peuvent être utilisés dans Sprocs trop. Ils sont un raccourci qui vous permettent d'utiliser une requête pour faire une tâche à la place de plusieurs requêtes. Cependant, les curseurs de reconnaître la portée et sont considérés comme non définie hors de la portée de la procédure stockée et leurs opérations s'exécutent au sein d'une seule et même procédure. Une procédure stockée ne peut pas ouvrir, extraire, ou de fermer un curseur qui n'a pas été déclarée dans la procédure.

InformationsquelleAutor ElGrig
0

Dans SQL server, un curseur est utilisé lorsque vous avez besoin au Lieu du T-SQL commandes qui fonctionnent sur toutes les lignes du jeu de résultats, un à un, nous utilisons un curseur lorsque nous avons besoin de mettre à jour des enregistrements dans une table de base de données dans un singleton de la mode, en d'autres termes, ligne par ligne.pour récupérer une ligne à un moment ou ligne par ligne.

De travail avec les curseurs se compose de plusieurs étapes:

Déclarer - Déclarer est utilisé pour définir un nouveau curseur.
Ouvrir - Un Curseur est ouvert et rempli par l'exécution de l'instruction SQL définie par le curseur.
Fetch - Lorsque le curseur est ouvert, les lignes peuvent être récupérées à partir du curseur, un par un.
Proche - Après les opérations de données, on devrait fermer le curseur de manière explicite.
Deallocate - Enfin, nous avons besoin de supprimer la définition de curseur et de libérer toutes les ressources système associé avec le curseur.
Syntaxe

DÉCLARER cursor_name CURSEUR [ LOCAL | GLOBAL ] [ FORWARD_ONLY | SCROLL ] [ STATIQUE | CLAVIER | DYNAMIQUE | FAST_FORWARD ] [ READ_ONLY | SCROLL_LOCKS | OPTIMISTE ] [ TYPE_WARNING] POUR select_statement [POUR mise à JOUR [ DE nom_colonne [ ,...n ] ] ]
[;]

InformationsquelleAutor Shiwangini Shishulkar

Vous devez vous connecter pour publier un commentaire.