Premiers pas avec SQL Server 7.0 (7)

i. Déclarer le curseur
Dans cette étape, vous devez spécifier les propriétés du curseur et l'ensemble de résultats générés selon les exigences. Il existe deux manières de spécifier un curseur.
Formulaire 1 (ANSI 92)
DÉCLARE nom_curseur [INSENSITIVE] [SCROLL] CURSOR
FOR select_statement
[FOR {LECTURE SEULE | UPDATE][OF column_list]}]
Formulaire 2
DÉCLARE nom_curseur CURSOR
[LOCAL | GLOBAL]
[FORWARD_ONLY | SCROLL]
[STATIC | KEYSET DYNAMIC]
[READ_ONLY | OPTIMISTIC]
FOR select_statement
[FOR {LECTURE SEULE | MISE À JOUR ][OF column_list]}]
Le mot-clé INSENSITIVE indique qu'une copie temporaire doit être créée pour l'ensemble de résultats récupéré et que les données futures seront obtenues à partir de cette copie temporaire. Si les données de la table de base d'origine changent lors du traitement ultérieur du curseur, elles ne seront pas visibles par le curseur. Ce curseur insensible ne permet pas les modifications des données.
Le mot-clé SCROLL indique que le curseur peut défiler dans n'importe quelle direction. Toutes les options de récupération (premier, dernier, suivant, relatif, absolu) peuvent être utilisées dans les curseurs. Si cette option est omise, le curseur ne peut défiler que vers l'avant (suivant).
Select_statement spécifie le jeu de résultats créé par l'instruction SQL. Les instructions Transact SQL COMPUTE, COMPUTE BY, FOR BROWSE et INTO ne sont pas autorisées dans l'instruction select d'une déclaration de curseur.
LECTURE SEULEMENT indique que la modification des données n'est pas autorisée dans le jeu de résultats du curseur.
Le mot-clé UPDATE indique que le jeu de résultats du curseur peut être modifié.
OF column_list spécifie les colonnes du jeu de résultats qui peuvent être modifiées. Par défaut (à l'aide du mot-clé UPDATE), toutes les colonnes peuvent être modifiées.
Le mot-clé LOCAL indique que le curseur est local et ne peut être utilisé qu'au sein du processus dans lequel il est déclaré.
Le mot-clé GLOBAL rend le curseur globalement visible par l'ensemble de la connexion. Les curseurs globaux sont disponibles chaque fois que la connexion est active. Ce n'est que lorsque la connexion est terminée que le curseur n'est plus disponible.
FORWARD_ONLY précise que le curseur ne peut défiler que vers l'avant.
Les curseurs STATIQUES sont les mêmes que les curseurs INSENSIBLES.
KEYSET spécifie l'ordre des lignes sélectionnées. SQL Server créera un jeu de mots-clés temporaire à partir du jeu de résultats. Si des modifications sont apportées aux colonnes sans mots-clés de la base de données, elles sont visibles par le curseur. Puisqu'il s'agit d'un ensemble fixe de mots-clés, les modifications apportées à la colonne de mots-clés ou aux colonnes nouvellement insérées ne sont pas visibles.
DYNAMIC précise que le curseur reflétera toutes les modifications apportées à l'ensemble de résultats.
SCROLL_LOCK sert à verrouiller la modification ou la suppression afin de garantir le succès des opérations du curseur.
OPTIMISTIC précise quelles modifications ou suppressions via le curseur ne réussiront pas.
Remarque :
· Si les instructions DISTINCT, UNION et GROUP BY sont utilisées dans l'instruction SELECT et que la sélection contient une expression agrégée, le curseur sera automatiquement un curseur INSENSITIVE.
· Si la table de base n'a pas d'index unique, le curseur est créé comme un curseur INSENSIBLE.
· Si l'instruction SELECT contient ORDER BY et que la colonne ORDER BY n'est pas un identifiant de ligne unique, le curseur DYNAMIC sera converti en curseur KEYSET. Si le curseur KEYSET ne peut pas être ouvert, il sera converti en curseur INSENSITIVE. Il en va de même pour les curseurs définis à l'aide de la syntaxe SQL ANSI-92, mais sans le mot clé INSENSITIVE.
Ouvrir un curseur
L'ouverture d'un curseur crée un ensemble de résultats. Le curseur est défini via l'instruction DECLARE, mais son exécution réelle se fait via l'instruction OPEN. La syntaxe est la suivante :
OPEN { { [GLOBAL] curseur_nom } | curseur_variable_name}
GLOBAL spécifie un curseur global.
Cursor_name est le nom du curseur ouvert.
Cursor_variable_name est le nom de variable du curseur référencé. La variable doit être de type curseur.
Une fois le curseur ouvert, la variable système @@cursor_rows peut être utilisée pour détecter le nombre de lignes dans l'ensemble de résultats. Lorsque @@cursor_rows est un nombre négatif, cela signifie que le curseur est migré de manière asynchrone et sa valeur absolue (si @@cursor_rows est -5, la valeur absolue est 5) est le nombre de lignes dans le jeu de résultats actuel. Les curseurs asynchrones permettent aux utilisateurs de continuer à accéder aux résultats d'un curseur pendant que le curseur est complètement migré.
III. Prenez la valeur du curseur.
Dans le processus de prise de la valeur du curseur, vous pouvez vous déplacer d'avant en arrière sur chaque ligne de la concentration du résultat. Si le curseur est défini comme défilable (en utilisant le mot-clé SCROLL lors de sa déclaration), n'importe quelle ligne du jeu de résultats peut être récupérée à tout moment. Pour les curseurs non défilants, les opérations de récupération ne peuvent être effectuées que sur la ligne située à côté de la ligne actuelle. L'ensemble de résultats peut être récupéré à partir de variables locales. La syntaxe de la commande Fetch est la suivante :
FETCH [NEXT | PREMIER | LAST | ABSOLUTE {n | @nvar}]
FROM [GLOBAL] curseur_name} | }
[INTO @variable_name ][,...n]]
NEXT spécifie d'obtenir la valeur de la ligne suivante de la ligne actuelle.
PRIOR spécifie d'obtenir la valeur de la ligne précédente de la ligne actuelle.
FIRST est la première ligne de l'ensemble de résultats.
LAST est la dernière ligne du jeu de résultats.
ABSOLU n représente la nième ligne de l'ensemble de résultats. Le numéro de ligne peut également être propagé via une variable locale. Les numéros de ligne commencent à 0, vous ne pouvez donc obtenir aucune ligne lorsque n vaut 0.
RELATIVE n signifie que la ligne à récupérer est n lignes avant ou n lignes après la ligne actuelle. Si la valeur est un nombre positif, la ligne à récupérer est située n lignes avant la ligne actuelle. Si la valeur est négative, la ligne après la ligne actuelle est renvoyée.
INTO @cursor_variable_name représente la liste de variables où la valeur de la colonne du curseur est stockée. Le nombre de variables dans cette liste doit être le même que le nombre de variables utilisées par l'instruction select dans l'instruction DECLARE. Le type de données de la variable doit également être le même que le type de données de la colonne sélectionnée. La valeur de la variable sera conservée jusqu'à la prochaine utilisation de l'instruction FETCH.
Chaque exécution FETCH est stockée dans la variable système @@fetch_status. Si le FETCH réussit, @@fetch_status est défini sur 0. @@fetch_status de -1 indique qu'une partie de l'ensemble de résultats a été atteinte (par exemple, une ligne de la table de base a été supprimée après l'ouverture du curseur). @@fetch_status peut être utilisé pour construire une boucle de traitement du curseur.
Par exemple :
DÉCLARE @iname char(20), @fname char(20)
OPEN author_cur
FETCH FIRST FROM author_cur INTO @iname, @fname
WHILE @@fetch_status = 0
BEGIN
IF @fname = 'Albert'
IMPRIMER « Trouvé Albert Ringer »
ELSE
Imprimer « Autre Ringer »
FETCH NEXT FROM author_cur INTO @iname, @fname
FIN
                                                                                                                                                                                                                                                                              . Une fois le curseur fermé, aucune opération FETCH ne peut être effectuée. Si vous devez toujours utiliser l'instruction FETCH, vous devez rouvrir le curseur. La syntaxe est la suivante :
CLOSE [GLOBAL] nom_curseur | nom_variable_curseur
                                                                                                                                                                                                                                L'instruction DEALLOCATE libère les verrous sur les structures de données et les curseurs. La syntaxe est la suivante :
DEALLOCATE [GLOBAL] nom_curseur | nom_variable_curseur

Un exemple complet de curseur est donné ci-dessous :
USE master
GO
CREATE PROCEDURE sp_BuildIndexes
AS
DECLARE @TableName sysname, @msg varchar(100), @cmd varchar(100)

DECLARE table_cur CURSOR FOR
SELECT name FROM sysobjects WHERE type='u'

OUVRIR table_cur
FETCH NEXT FROM table_cur INTO @TableName
WHILE @@fetch_status = 0
COMMENCER
​​IF @@fetch_status = -2
                    CONTINUER
                         SELECT @msg = “ Création d'index pour la table » @TableName « … » PRINT « «
FETCH NEXT FROM table_cur INTO @TableName
END
DEALLOCATE table_cur
GO
Le script suivant exécutera sp_BuildIndexes
pour PUBS base de données USE pubs
GO
EXEC ap_BuildIndexes
Remarque : ce qui précède est également un exemple de création d'une procédure stockée système définie par l'utilisateur.

Utiliser une table temporaire
Les tables temporaires sont des tables créées dans TempDB. Les noms des tables temporaires commencent tous par "#". La portée d'une table temporaire est la connexion qui a créé la table temporaire. Étant donné que les tables temporaires ne peuvent pas être partagées entre deux connexions, la table temporaire sera supprimée une fois la connexion fermée. Si la table temporaire est créée dans une procédure stockée, la portée de la table temporaire se trouve dans la procédure stockée ou dans toute procédure stockée appelée par la procédure stockée. Si vous devez partager des tables temporaires entre connexions, vous devez utiliser des tables temporaires globales. La table temporaire globale commence par le symbole « ## » et existera dans la base de données jusqu'au redémarrage de SQL Server. Une fois une telle table temporaire créée, tous les utilisateurs peuvent y accéder. Les autorisations ne peuvent pas être spécifiées explicitement sur les tables temporaires. Les tableaux temporaires offrent la possibilité de stocker des résultats intermédiaires. Parfois, les tables temporaires peuvent également améliorer les performances en divisant une requête complexe en deux requêtes. Ceci peut être réalisé en stockant d'abord les résultats de la première requête dans une table temporaire, puis en utilisant la table temporaire dans la deuxième requête. Les tables temporaires sont recommandées lorsqu'un sous-ensemble d'une table volumineuse est utilisé plusieurs fois au cours d'une procédure existante. Dans ce cas, conserver un sous-ensemble de données dans une table temporaire pour l'utiliser lors de jointures ultérieures peut grandement améliorer les performances. Des index peuvent également être créés sur des tables temporaires.

Ce qui précède est le contenu de Démarrer avec SQL Server 7.0 (7). Pour plus de contenu connexe, veuillez faire attention au site Web PHP chinois (www.php.cn) !