Desarrollamos el ciclo de
los datos para optimizar
la toma de decisiones.
Para muchos de los desarrolladores que han escrito código en Transact-sql puede resultar común usar o encontrar que otra persona use dentro de su código la sentencia GO. Dicha sentencia, no está categorizada como una sentencia de Transact-sql. Sin embargo, es reconocida e interpretada por el motor de base de datos cuando se encuentra dentro de un script o bloque de código. Esta sentencia, cumple un papel importante cuando hablamos de facilitar la lectura de un script de SQL. Pero además de esto, lo que la mayoría no sabe es que puede recibir un parámetro de tipo entero para así lograr ejecutar lotes de código las veces que este parámetro lo indique. En esta entrada vamos a abordar ambos escenarios y desarrollaremos pequeños ejemplos de código para dejar lo más claro que se pueda dichas funcionalidades.
La sintaxis es la siguiente:
.. .. .. GO [count]
En donde el parámetro count indica un valor entero positivo que representa el número de veces que se ejecutarán las líneas anteriores a esta sentencia.
Dejando a un lado la teoría podemos centrarnos en lo más interesante, ¿Cómo se usa?. Para esto voy a poner pequeñas líneas de código en cada uno de los casos.
Pues bien, lo que se busca al usar la sentencia GO dentro de un script de SQL es encapsular en un batch o lote las líneas anteriores a esta sentencia. Por ejemplo, dado el siguiente script.
DECLARE @usuario VARCHAR(50) = 'Jesus@Lopez' , @clave VARCHAR(40) = 'P4sss@wrd' , @servidor VARCHAR(50) = 'DEVK1995' GO
Command(s) completed successfully.
Lo que sucede en este punto es que, SQL interpreta la palabra clave GO como una señal de que debe mandar las líneas código anteriores a la sentencia hacía la instancia en donde se está ejecutando la consulta. En este caso, lo que forma parte del lote enviado a ejecutar vendría a ser, todo lo ingresado hasta antes del último GO o en caso no existiera uno, se toma en cuenta todo lo que el script contenga desde que se inició la sesión.
Dicho lo anterior, existen algunas consideraciones que se deben tener en cuenta cuando se usa esta sentencia dentro de un script. Retomando el ejemplo anterior, agreguemos al escenario un poco más de complejidad al tratar de reutilizar las variables que fueron declaradas antes.
DECLARE
@usuario VARCHAR(50) = 'Jesus@Lopez'
, @clave VARCHAR(40) = 'P4sss@wrd'
, @servidor VARCHAR(50) = 'DEVK1995'
GO
PRINT ('---------------------------------------------------')
PRINT ('Su usuario es : ' + @usuario )
PRINT ('Su clave es : ' + @clave )
PRINT ('Se conecta a : ' + @servidor )
PRINT ('---------------------------------------------------')
GO
Msg 137, Level 15, State 2, Line 8 Must declare the scalar variable "@usuario". Msg 137, Level 15, State 2, Line 9 Must declare the scalar variable "@clave". Msg 137, Level 15, State 2, Line 10 Must declare the scalar variable "@servidor".
Lo que pasa al ejecutar el script anterior es que, luego que el primer batch se envía a la instancia de SQL para ser ejecutado, las variables de usuario que se declararon ya no existen para los demás lotes. Esto a pesar de que, todo se trabaje dentro de la misma sesión. De otra manera, si hablamos de variables del sistema estas no están sujetas a un batch en particular. Por esto, podemos utilizarlas en más de un lote sin recibir el mensaje anterior.
DECLARE
@usuario VARCHAR(50) = 'Jesus@Lopez'
, @clave VARCHAR(40) = 'P4sss@wrd'
, @servidor VARCHAR(50) = 'DEVK1995'
PRINT ('---------------------------------------------------')
PRINT ('Su usuario es : ' + @usuario )
PRINT ('Su clave es : ' + @clave )
PRINT ('Se conecta a : ' + @@servername )
PRINT ('---------------------------------------------------')
GO
PRINT ('---------------------------------------------------')
PRINT ('Se conecta a : ' + @@servername )
PRINT ('---------------------------------------------------')
GO
---------------------------------------------------- Su usuario es : Jesus@Lopez Su clave es : P4sss@wrd Se conecta a : ngn-wvd-0\SQL2K14 ---------------------------------------------------- ---------------------------------------------------- Se conecta a : ngn-wvd-0\SQL2K14 ----------------------------------------------------
Ahora que ya cubrimos la primera forma de uso, pasaremos a la última. La sentencia GO también reconoce el parámetro count y lo interpreta como el número de veces que debe ejecutar el lote que lo precede. Para dejar esto más claro ejecutaremos el siguiente script en donde enviaremos al parámetro el valor 3.
PRINT ('----------------------------------------------------')
PRINT ('Su bd es : ' + DB_NAME() )
PRINT ('Se conecta a : ' + @@servername )
PRINT ('----------------------------------------------------')
GO 3
Beginning execution loop ---------------------------------------------------- Su bd es : master Se conecta a : ngn-wvd-0\SQL2K14 ---------------------------------------------------- ---------------------------------------------------- Su bd es : master Se conecta a : ngn-wvd-0\SQL2K14 ---------------------------------------------------- ---------------------------------------------------- Su bd es : master Se conecta a : ngn-wvd-0\SQL2K14 ---------------------------------------------------- Batch execution completed 3 times.
Como se puede observar al inició el resultado indica que se está entrando en un loop. Luego, se ejecuta el lote de código que contiene las cuatro líneas en donde se imprime el valor de la variable de sistema @@servername y la función DB_NAME(). Para finalizar, el resultado indica en la última línea el número de veces que se ejecutó el batch.
Con estos ejemplos, se busca dar una mayor visibilidad de las aplicaciones de la sentencias GO en Transact-sql. Como hemos visto líneas arriba, podemos aprovechar la sentencia GO para diversas operaciones además de solo separar bloques de código. Para buscar información de la sentencia en la página oficial de Microsoft puede consultar el siguiente enlace.
¿Estás mejorando tu planeamiento financiero? Solicita una demo aquí, o conversemos por info@kaitsconsulting.com. Da el primer paso y conoce Solver, la herramienta de CPM adecuada para ti.
Jesus López Mesía es Ingeniero de sistemas y consultor BI en Kaits Consulting. Puedes encontrar más artículos suyos en la revista MEDIUM, buscándolo como @susejzepol.
Conoce lo que podemos hacer por tu organización, te dejamos algunos testimonios de satisfacción de nuestros clientes.
