fbpx

Formas de utilizar la sentencia GO en SQL Server

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.

SINTAXIS

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.

FORMAS DE USO

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.

– Primera Forma

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.

     SCRIPT:
DECLARE
@usuario    VARCHAR(50) = 'Jesus@Lopez'
,   @clave      VARCHAR(40) = 'P4sss@wrd'
,   @servidor   VARCHAR(50) = 'DEVK1995'
GO
      RESULTADO:
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.

     SCRIPT:
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
     RESULTADO:
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.

     SCRIPT:
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
RESULTADO:
----------------------------------------------------
Su usuario es   : Jesus@Lopez
Su clave es     : P4sss@wrd
Se conecta a    : ngn-wvd-0\SQL2K14
----------------------------------------------------

----------------------------------------------------
Se conecta a    : ngn-wvd-0\SQL2K14
----------------------------------------------------

– Segunda Forma

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.

     SCRIPT:
PRINT ('----------------------------------------------------')
PRINT ('Su bd es         : ' +    DB_NAME()                  )
PRINT ('Se conecta a     : ' +    @@servername               )
PRINT ('----------------------------------------------------')
GO 3
     RESULTADO:
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.

CONCLUSIONES

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.

Sobre el autor:

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. 

 

 
 

Potencia tus habilidades
con nuestros cursos

Potencia tu presencia profesional gestionando proyectos reales, enseñamos desde la práctica.

Comunícate con nosotros