EQUIPO : Investigation Systems
Estudiantes : Aguilar Rafael Jaime
Diaz Guerrero Imer Hobet
CURSO : Base de Datos II
TEMA : CURSORES
DOCENTE : Marco Aurelio Porro Chulli
------------------------------------------------------------------------------------------
VIDEOS DE CURSORES
Cursores
1.
Contenido
Ø Definición
Estructura
de control utilizada para el recorrido (y potencial procesamiento) de los
registros del resultado de una consulta. Un cursor se utiliza para el
procesamiento individual de las filas devueltas por el sistema gestor de base
de datos para una consulta.
Es
un elemento que representará a un conjunto de datos determinado por una
consulta T-SQL, el cursor permitirá recorrer fila a fila, leer y eventualmente
modificar dicho conjunto de resultados.
Las
operaciones de una base de datos relacional actúan en un conjunto completo de
filas. Por ejemplo, el conjunto de filas que devuelve una instrucción SELECT
está compuesto por todas las filas que satisfacen las condiciones de la
cláusula WHERE de la instrucción.
Este
conjunto completo de filas que devuelve la instrucción se conoce como conjunto
de resultados. Las aplicaciones, especialmente las aplicaciones interactivas en
línea, no siempre trabajan de forma eficaz con el conjunto de resultados
completo si lo toman como una unidad. Estas aplicaciones necesitan un mecanismo
que trabaje con una fila o un pequeño bloque de filas cada vez. Los cursores
son una extensión de los conjuntos de resultados que proporcionan dicho
mecanismo.
Sintaxis
-- Declaración del cursor
DECLARE<nombre cursor _ >CURSOR
FOR
<sentencia sql _ >
-- apertura del cursor
OPEN <nombre cursor _ >
-- Lectura de la primera fila del
cursor
FETCH <nombre cursor _ >INTO <lista variables _ >
WHILE (@@FETCH_STATUS=0)
BEGIN
-- Lectura de la siguiente fila de un cursor
FETCH <nombre cursor _ >INTO <lista variables _ >
...
END --
Fin del bucle WHILE
-- Cierra el cursor
CLOSE<nombre cursor _ >
-- Libera los recursos del cursor
DEALLOCATE<nombre cursor _ >
DECLARE cursor_name [ INSENSITIVE ] [ SCROLL ]
CURSOR
FOR select_statement
[ FOR { READ
ONLY | UPDATE [ OF column_name [ ,...n ] ] } ]
[;]
Transact-SQL Extended
Syntax
DECLARE cursor_name CURSOR [ LOCAL | GLOBAL ]
[ FORWARD_ONLY |
SCROLL ]
[ STATIC |
KEYSET | DYNAMIC | FAST_FORWARD ]
[ READ_ONLY |
SCROLL_LOCKS | OPTIMISTIC ]
[ TYPE_WARNING ]
FOR select_statement
[ FOR UPDATE [
OF column_name [ ,...n ] ] ]
[;]
Explicación
cursor_name
Es
el nombre del cursor de servidor de Transact-SQL definido. cursor_name debe
cumplir las reglas de los identificadores.
INSENSITIVE
Define
un cursor que hace una copia temporal de los datos que utiliza. Todas las
solicitudes que se realizan al cursor se responden desde esta tabla temporal de
tempdb; por tanto, las modificaciones realizadas en las tablas base no
se reflejan en los datos devueltos por las operaciones de captura realizadas en
el cursor y además este cursor no admite modificaciones. Cuando se utiliza la
sintaxis de ISO, si se omite INSENSITIVE, las eliminaciones y actualizaciones
confirmadas realizadas en las tablas subyacentes (por cualquier usuario) se
reflejan en capturas posteriores.
SCROLL
Especifica
que están disponibles todas las opciones de captura (FIRST, LAST, PRIOR, NEXT,
RELATIVE, ABSOLUTE). Si no se especifica SCROLL en una instrucción DECLARE
CURSOR de ISO, la única opción de captura que se admite es NEXT. No es posible
especificar SCROLL si se incluye también FAST_FORWARD.
select_statement
Es
una instrucción SELECT estándar que define el conjunto de resultados del
cursor. Las palabras clave FOR BROWSE e INTO no están permitidas en la
instrucción select_statement de una declaración de cursor.
SQL
Server convierte implícitamente el cursor en otro tipo si las cláusulas de la
instrucción select_statement entran en conflicto con la funcionalidad del tipo
de cursor solicitado.
READ ONLY
Evita
que se efectúen actualizaciones a través de este cursor. No es posible hacer
referencia al cursor en una cláusula WHERE CURRENT OF de una instrucción UPDATE
o DELETE. Esta opción reemplaza la capacidad predeterminada de actualizar el
cursor.
UPDATE [OF column_name [,...n]]
Define
las columnas actualizables en el cursor. Si se especifica OF column_name [,...n],
solo las columnas enumeradas admiten modificaciones. Si se especifica UPDATE
sin indicar una lista de columnas, se pueden actualizar todas las columnas.
cursor_name
Es
el nombre del cursor de servidor de Transact-SQL definido. cursor_name debe
cumplir las reglas de los identificadores.
LOCAL
Especifica
que el ámbito del cursor es local para el proceso por lotes, el procedimiento
almacenado o el desencadenador en que se creó el cursor. El nombre del cursor
solo es válido en este ámbito. Se puede hacer referencia al cursor mediante
variables de cursor locales en el proceso por lotes, procedimiento almacenado o
desencadenador, o en el parámetro OUTPUT de un procedimiento almacenado.
El
parámetro OUTPUT se utiliza para devolver el cursor local al proceso por lotes,
procedimiento almacenado o desencadenador que realiza la llamada, el cual puede
asignar el parámetro a una variable de cursor para hacer referencia al cursor
después de que el procedimiento almacenado finalice.
La
asignación del cursor se cancela implícitamente cuando el proceso por lotes,
procedimiento almacenado o desencadenador finaliza, a menos que el cursor se
haya devuelto en un parámetro OUTPUT. En ese caso, la asignación del cursor se
cancela cuando se cancela la asignación de la última variable que hace
referencia al mismo o cuando ésta se sale del ámbito.
GLOBAL
Especifica
que el ámbito del cursor es global para la conexión. Puede hacerse referencia
al nombre del cursor en cualquier procedimiento almacenado o proceso por lotes
que se ejecute en la conexión. La asignación del cursor solo se cancela
implícitamente cuando se produce la desconexión.
Ø Administración
de Procedimientos Almacenados (Creación, Modificación y Eliminación)
Creación De Cursores
Declaración
El primer paso constará de la declaración del cursor, donde
se indicarán (junto con el nombre del cursor) la consulta que el mismo
representará y algunas otras características bastante interesantes.
Un ejemplo de declaración de cursor es el siguiente:
DECLARE ProdInfo CURSOR FOR SELECT Name FROM Production.Product
Donde ProdInfo representará al nombre del cursor y la
sentencia “SELECT ProductNumber,Name FROM Production.Product” será el conjunto
de datos del mismo.
Como comentamos previamente, es posible en este paso
definir algunas características del comportamiento del cursor, por ejemplo la
sentencia:
DECLARE ProdInfo CURSOR READ_ONLY FOR SELECT Name FROM Production.Product
Indicará que el cursor será de solo lectura, más adelante
veremos en detalle las opciones disponibles, por el momento nuestro objetivo es
crear un cursor lo más simple posible.
Apertura
La apertura del cursor ejecutará la consulta definida en el
paso previo y cargará los datos en el mismo. La función OPEN de T-SQL permitirá efectuar esta terea, para continuar con
el ejemplo previo la forma de abrir el cursor será la siguiente:
OPEN ProdInfo
Recorrido del cursor y acceso a los datos
Este paso constará de recorrer los resultados
del cursor, la instrucción FETCH permitirá efectuar dicha operación. Las filas
leídas podrán copiarse a variables utilizando la sentencia INTO en combinación
con la sentencia FETCH, por ejemplo la sentencia:
FETCH NEXT FROM ProdInfo INTO @Description
Tomará la siguiente fila de resultados del
cursor y lo alojará en la variable @Description.
Un detalle a comentar es que en la sentencia
INTO (como puede verse en el ejemplo anterior) el mapeo entre columnas del
cursor y variables se realizará implícitamente, asignándose la primera columna
a la primera variable, la segunda columna a la segunda variable y así
sucesivamente. Esto implica que deberán crearse tantas variables como columnas
se definan en la declaración del cursor y las mismas deberán ubicarse en el
mismo orden que se encuentran definidas las columnas en la sentencia SELECT de
la declaración.
Como cada sentencia FETCH leerá un registro,
una pregunta interesante que podríamos hacernos es, ¿de qué manera podremos
saber si existe un próximo o previo registro, o si hemos llegado al límite (ya
sea superior o inferior)?. La respuesta se encontrará en una variable de SQL
Server llamada @@FETCH_STATUS que tomará el valor 0 si la lectura del registro
ha sido correcta.
En este punto será también posible modificar o
eliminar las filas que se van recorriendo, como veremos al final del artículo.
Cierre
del cursor
En el cierre del cursor se liberarán los
registros tomados por el mismo. Una vez que el cursor es cerrado ya no podrá
recorrerse el conjunto de resultados hasta que el mismo sea reabierto, la
sentencia CLOSE cerrará un cursor abierto y la sintaxis puede verse a
continuación:
CLOSE ProdInfo
Desalojo
del cursor
Los cursores son objetos que se crean en
memoria (por eso es importante
utilizar la sentencia deallocate para desalojarlo de la memoria que utiliza SQL
Server). Por ese motivo no los vas a poder encontrar en el object explorer.
Modificación
La instrucción
UPDATE posicionada es, en su mayor parte, igual que una instrucción UPDATE
regular, excepto que ésta requiere una cláusula especial WHERE, como se muestra
en la siguiente sintaxis:
UPDATE <nombre de la
tabla>
SET <lista de conjunto>
WHERE CURRENT OF <nombre del cursor>
Para actualizar
los datos de un cursor debemos especificar FOR UPDATE despues de la sentencia
SELECT en la declaración del cursor y WHERE CURRENT OF , en la sentencia UPDATE
tal y como muestra el siguiente ejemplo .
-- Declaracion de variables para el cursor
DECLARE @ Id int,
@Nombre varchar(255),
@Apellido1 varchar(255),
@Apellido2 varchar(255),
@NifCif varchar(20),
@FxNacimiento datetime
-- Declaración del cursor
DECLARE cClientes CURSORFOR
SELECT Id,Nombre, 1 Apellido ,
Apellido2,NifCif, FxNacimiento
FROM CLIENTES
FOR UPDATE
-- Apertura del cursor
OPEN cClientes
-- Lectura de la primera fila del cursor
FETCH cClientes INTO @id, @Nombre, @ 1 Apellido , @ 2 Apellido , @NifCif, @FxNacimiento
WHILE (@@ _ FETCH
STATUS = 0 )
BEGIN
UPDATE Clientes
SET 2 APELLIDO = isnull(@ 2 Apellido ,'')+ ' - ' Modificado
WHERE CURRENT OF cClientes
-- Lectura de la siguiente fila del cursor
FETCH cClientes
INTO @id, @Nombre, @ 1 Apellido , @ 2 Apellido ,
@NifCif, @FxNacimiento
END
-- Cierre del cursor
CLOSE cClientes
-- Liberar los recursos
DEALLOCATE cClientes
Eliminación
La
instrucción DELETE posicionada, al igual que la instrucción UPDATE posicionada,
requiere una cláusula WHERE que debe incluir la opción CURRENT OF. (Una
instrucción DELETE regular, como puede recordarse, no requiere de una cláusula
WHERE.) Una instrucción DELETE posicionada utiliza la siguiente sintaxis:
DELETE WHERE CURRENT OF Como se puede ver, es necesario definir una cláusula
DELETE que identifique a la tabla y una cláusula WHERE que identifique al
cursor. La cláusula WHERE, en una instrucción DELETE posicionada, funciona de
la misma manera que la cláusula WHERE en una instrucción UPDATE posicionada: la
fila arrojada por la última instrucción FETCH es la fila que se modifica. En este
caso, la fila es eliminada.
DECLARE wt_cursor CURSOR
DYNAMIC /*Or left blank but not STATIC or KEYSET*/
FOR
SELECT C
FROM @WorkingTable
OPEN wt_cursor;
FETCH NEXT FROM wt_cursor
INTO @C
DELETE FROM @WorkingTable
WHILE @@FETCH_STATUS = 0
BEGIN
PRINT @C;
FETCH NEXT FROM wt_cursor
INTO @C;
END
CLOSE wt_cursor;
DEALLOCATE
wt_cursor;
Ø Ejemplos
Crear un cursor que permita visualizar los registros de la tabla TbCliente
DECLARE @COL1
CHAR(2),@COL2 VARCHAR(25),@COL3 VARCHAR(25),@COL4 VARCHAR(35)
DECLARE C_DPTO
CURSOR FOR
SELECT D.CodDpto,D.NombreDpto,D.Capital,R.NombreRegion FROM TbDpto D INNER JOIN TbRegion R ON D.IdRegion=R.CodRegion
OPEN C_DPTO
FETCH NEXT FROM C_DPTO INTO @COL1,@COL2,@COL3,@COL4
WHILE @@FETCH_STATUS=0
BEGIN
PRINT @COL1+' | '+@COL2+'| '+@COL3+' | '+@COL4
FETCH NEXT FROM C_DPTO INTO @COL1,@COL2,@COL3,@COL4
END
CLOSE C_DPTO
DEALLOCATE C_DPTO
2.
Resumen
Un cursor se utiliza para el procesamiento individual de las filas
devueltas por el sistema gestor de base de datos para una consulta. Es un
elemento que representará a un conjunto de datos determinado por una consulta
T-SQL, el cursor permitirá recorrer fila a fila, leer y eventualmente modificar
dicho conjunto de resultados.
3.
Summary
A
cursor is used for the individual processing of the rows returned by the
database manager system for a query. It is an element that will represent a set
of data determined by a T-SQL query, the cursor will allow to go through row by
row, read and eventually modify said set of results.
4.
Recomendaciones
Ø En SQL Server los cursores son muy lentos. Prácticamente
nunca es recomendable y es bueno buscar otras alternativas de acuerdo a la
necesidad.
Ø Si la consulta es veloz y toma pocos segundos y no va a
cambiar esa velocidad a medida que aumente el tamaño la base de datos (al menos
no de forma repentina), se podría mantener los cursores.
Sin
embargo, si usted cree que los datos que manejan los cursores van a aumentar a
miles o peor a millones de filas, vale la pena reemplazar el cursor.
Ø Los cursores en general son utilizados por gente que se
siente cómodo con el manejo secuencial, pero el cursor en sí es lento. Bloquea
datos y consume muchos recursos.
Si no tiene otra
alternativa a cursores, recomendamos usar la opción FAST_FORWARD (si es
aplicable) y READ_ONLY para optimizar los cursores.
5.
Conclusiones
Ø Los
cursores son muy útiles sobre todo cuando no podemos tener todas las columnas
que necesitamos en un solo SELECT. Si podemos tener a todas las columnas en un
solo SELECT puede ser más práctico usar el comando SELECT … INTO.
Ø Los cursores de SQL Server y cualquier otro tipo de cursores se remontan
a antes de que los lenguajes de programación procedimentales pudieran manejar
conjuntos de datos y requerían dividirlos en filas (por ejemplo, COBOL,
FORTRAN, C de estilo antiguo, etc.).
Ø Hay situaciones, no obstante, en las que necesariamente tendrán que ser
usados, pero normalmente se usan en tareas administrativas donde lo que se
prima no es el rendimiento.
6.
Apreciación
del Equipo
Ø Si bien el uso de los cursores es una técnica poco recomendada por
performance, es bueno considerar si tenemos que usarlos cuales son las mejores
opciones de configuración para poder obtener los mejores tiempos de respuesta
dentro de un cursor.
Ø La mayoría de los lenguajes de programación de aplicación soportan el
uso de cursores para recuperar datos de una base de datos SQL. El lenguaje del
cursor está incrustado en el código de programación de una forma muy parecida a
la que se incrustaría cualquier instrucción SQL.
Ø Cuando
se utiliza un cursor en un lenguaje de programación, primero se debe declarar
el cursor (similar a como se declararía una variable) y luego utilizar el
nombre de la instrucción (el nombre que se le asignó al cursor) en otras instrucciones
SQL incrustadas para abrir el cursor, recuperar filas individuales a través del
cursor y cerrar el cursor.
7.
Glosario
de Términos
ü DECLARE CURSOR: Declara el cursor SQL al definir el nombre del cursor, sus
características y una expresión de consulta que es invocada cuando se abre el
cursor.
ü OPEN: Abre el cursor e invoca la expresión de consulta, haciendo
que los resultados de consulta estén disponibles para las instrucciones FETCH.
ü FETCH: Recupera datos en las variables que pasan los datos al
lenguaje de programación host o a otras instrucciones SQL incrustadas.
ü CLOSE: Cierra el cursor. Una vez que el cursor es cerrado, no
pueden recuperarse datos de los resultados de la consulta del cursor.
ü ORDER BY: Permite clasificar los resultados de la consulta arrojados
por la especificación de la consulta.
ü SENSITIVE: Cambios significativos hechos por las instrucciones fuera
del cursor afectan inmediatamente a los resultados de la consulta dentro del
cursor.
ü INSENSITIVE: Cambios significativos hechos por las instrucciones fuera
del cursor no afectan a los resultados de la consulta dentro del cursor.
ü ASENSITIVE: La sensibilidad del cursor es definida por la
implementación. Los cambios significativos pueden o no ser captados dentro del
cursor.
ü FIRST: Recupera la primera fila de los resultados de la consulta
del cursor, sin importar cuántas instrucciones FETCH hayan sido ejecutadas
desde que se abrió el cursor.
ü LAST: Recupera la última fila de los resultados de la consulta
del cursor, sin importar cuántas instrucciones FETCH hayan sido ejecutadas
desde que se abrió el cursor.
8.
Bibliografía
o Linkografía
LINK DE DIAPOSITIVAS
No hay comentarios :
Publicar un comentario