Curseur (bases de données)
En paquets de la base de données , le curseur de limite se rapporte à une structure de gestion pour le traversal successif (et le potentiel traitant) des disques dans un résultat réglé de .
Un curseur est utilisé pour traiter différentes rangées retournées par le système de base de données pour une question . Il est nécessaire parce que beaucoup de langages de programmation souffrent de la disparité d'impédance de . Les langages de programmation sont souvent procéduraux et n'offrent pas n'importe quel mécanisme pour manoeuvrer les ensembles entiers de résultat immédiatement. Par conséquent, les rangées dans un ensemble de résultat doivent être traitées séquentiellement par l'application. De cette façon, un curseur peut être considéré comme un Iterator au-dessus de la collection de rangées dans l'ensemble de résultat.
Plusieurs commandes SQL N'exigent pas l'utilisation des curseurs. Qu'inclut le rapport de l'INSERTION , par exemple, comme la plupart des formes de la SUPPRESSION et de rapports de la MISE À JOUR . Même un rapport CHOISI peut ne pas impliquer un curseur s'il est employé dans la variation du SELECT INTO. Un SELECT INTO recherche tout au plus une rangée simple directement dans l'application
Travail avec des curseurs
Cette section présente les manières que la norme définit comment des curseurs seront utilisés dans les applications dans le SQL inclus. Non toutes les attaches d'application pour des systèmes de base de données relationnelle adhèrent à celle standard et emploient une interface différente, par exemple CLI ou JDBC.
Un curseur est fait connaître au système de gestion de bases de données avec le rapport de CURSEUR de DÉCLARATION. Un nom doit être assigné pour le curseur.
DÉCLARER LE CURSEUR du cursor_name de POUR CHOISI… DE…
Avant d'être employée, un curseur doit être ouvert avec le rapport de OPEN. En raison de l'ouverture, le curseur est placé avant que la première rangée dans l'ensemble de résultat.
OUVRIR le cursor_name de
Un curseur est placé sur une rangée spécifique dans le résultat réglé avec le rapport de FETCH. Une opération d'effort transfère les données de la rangée dans l'application. Une fois que toutes les rangées sont traitées ou l'opération d'effort doit être placée sur une rangée non-existing (cf. curseurs défilables verticalement ci-dessous), un SQLSTATE « 02000 » (habituellement accompagné d'un SQLCODE +100) est retourné par le système de gestion de bases de données pour indiquer l'extrémité de l'ensemble de résultat.
CHERCHER le cursor_name de DANS…
La dernière étape est de fermer le curseur using le rapport de CLOSE.
Cursor_name ÉTROIT de
Une fois qu'un curseur est fermé il peut être ouvert encore, qui implique que la question est évaluée encore et un nouvel ensemble de résultat est établi.
Curseurs défilables verticalement
Des curseurs peuvent être déclarés en tant qu'étant défilables verticalement ou pas. Le scrollability indique la direction laquelle un curseur peut se déplacer.
Un curseur non-défilable verticalement du est également connu comme vers l'avant-seulement. Chaque rangée peut être cherchée tout au plus une fois, et le curseur se déplace automatiquement juste après à la rangée. Une opération d'effort après que la dernière rangée ait été des positions recherchées le curseur après la dernière rangée et renvoie SQLSTATE 02000 (SQLCODE +100).
Un curseur défilable verticalement peut être placé n'importe où dans le résultat réglé using la commande SQL de FETCH. Le ROULEAU de mot-clé doit être spécifié en déclarant le curseur. Le défaut est le NO SCROLL, bien que les différentes attaches de langue comme JDBC puissent appliquer le défaut différent.
DÉCLARER LE CURSEUR du ROULEAU de la sensibilité de du cursor_name de POUR CHOISI… DE…
La position de cible pour un curseur défilable verticalement peut être spécifiée relativement à la position ou à l'absolu courante de curseur du commencement de l'ensemble de résultat.
EFFORT APRÈS | ANTÉRIEUREMENT | D'ABORD | DERNIER du cursor_name de
CHERCHER le ABSOLU n du cursor_name de
CHERCHER le RELATIF n du cursor_name de
Les curseurs défilables verticalement peuvent potentiellement accéder à la même rangée dans les temps multiples réglés de résultat. Ainsi, les modifications de données (insertion, mise à jour, opérations de suppression) d'autres transactions pourraient avoir un impact sur le résultat réglé. Un curseur peut être SENSIBLE ou PEU SENSIBLE à de telles modifications de données. Un curseur sensible prend des modifications de données effectuant l'ensemble de résultat du curseur, et un curseur peu sensible ne fait pas. En plus, un curseur peut être ASENSITIVE, dans ce cas le système de gestion de bases de données essaye d'appliquer la sensibilité autant que possible.
AVEC LA PRISE
Des curseurs sont habituellement fermés automatiquement à la fin d'une transaction, c. quand un ENGAGEMENT ou une BAISSE DE PRIX (ou un arrêt implicite de la transaction) se produit. Ce comportement peut être changé si le curseur est déclaré using AVEC la clause de PRISE. (Le défaut est SANS PRISE.) Un curseur holdable est fini ouvert gardé COMMETTENT et fermé sur la BAISSE DE PRIX. (Un certain système de gestion de bases de données dévient de ce comportement standard et gardent également la BAISSE DE PRIX finie ouverte de curseurs holdable.)
DÉCLARER le de CURSEUR du cursor_name de AVEC LA PRISE POUR CHOISI… DE…
Quand un ENGAGEMENT se produit, un curseur holdable est placé avant la prochaine rangée. Ainsi, une MISE À JOUR placée ou un rapport placé de SUPPRESSION réussira seulement après une opération d'EFFORT s'est produite d'abord dans la transaction.
Noter que JDBC définit des curseurs comme holdable par défaut. Ceci est fait parce que JDBC active également automatique-commet par défaut. En raison de l'associé aérien habituel à automatique-commettre et des curseurs holdable, les deux dispositifs devraient être explicitement mis hors tension au niveau de raccordement.
Rapports placés de mise à jour/suppression
Des curseurs peuvent non seulement être utilisés pour chercher des données du système de gestion de bases de données dans une application mais pour identifier également une rangée dans une table à mettre à jour ou être supprimée. Le SQL : la norme 2003 définit la mise à jour placée et les commandes SQL Placées de suppression dans ce but. De tels rapports n'emploient pas un militaire de carrière OÙ clause avec des attributs. Au lieu de cela, un curseur identifie la rangée. Le curseur doit être ouvert et placé sur une rangée déjà using le rapport de FETCH.
Table_name MISE À JOUR PLACER… LÀ OÙ COURANT de du cursor_name
SUPPRESSION Du table_name de LÀ OÙ COURANT de du cursor_name
Le curseur doit opérer un résultat pouvant être mis à jour réglé afin d'exécuter avec succès une mise à jour placée ou supprimer le rapport. Autrement, le système de gestion de bases de données ne saurait pas appliquer les changements de données aux tables fondamentales visées du curseur.
Curseurs dans des transactions distribuées
Using des curseurs dans des transactions distribuées (environnements de X/Open XA), qui sont commandé using un moniteur de transaction , n'est aucun différent que des curseurs dans des transactions non-distributed.
On doit prêter l'attention en employant le les curseurs holdable de , cependant. Des raccordements peuvent être employés par différentes applications. Ainsi, une fois qu'une transaction a été finie et commise, une transaction suivante (fonctionnant dans une application différente) pourrait hériter des curseurs holdable existants. Par conséquent, un créateur d'application doit se rendre compte de cette situation.
Inconvénients des curseurs
L'information suivante peut varier du système de base de données au système de base de données.
Chercher une rangée du curseur peut avoir comme conséquence un voyage aller-retour de réseau de chaque fois. Ceci emploie beaucoup plus de largeur de bande de réseau qu'être d'habitude nécessaire pour l'exécution d'une commande SQL Simple comme la SUPPRESSION. Les voyages aller-retour répétés de réseau peuvent sévèrement effectuer la vitesse de l'opération using le curseur. Un certain essai de DBMSs pour réduire cet impact en employant l'effort de bloc. L'effort de bloc implique que des rangées multiples sont envoyées ensemble du serveur au client. Le client stocke un bloc entier de rangées dans un amortisseur local et recherche les rangées de là jusqu'à ce que cet amortisseur soit épuisé.
Les curseurs allouent des ressources au serveur, par exemple aux serrures, aux conditionnements, aux processus, à la mémoire temporaire, etc. par exemple, aux curseurs d'instruments du serveur de Microsoft SQL de en créant une table provisoire et en la peuplant avec l'ensemble du résultat de la question. Si un curseur n'est pas correctement fermé ( désaffecté par ), les ressources ne seront pas libérées jusqu'à ce que la session de SQL (raccordement) lui-même soit fermée. Ce gaspillage des ressources sur le serveur peut non seulement mener aux dégradations d'exécution mais également aux échecs.
| Random links: | Langue cherokee | Dwingeloo 1 | Ann Dow | John C. Meyer | Cogers | Cursor_(bases_de_datos) |