Cláusula GO no SQL Server

Ao trabalhar com o SQL Server, você já deve ter se deparado com a palavra-chave GO em scripts SQL. Embora pareça uma simples instrução SQL, GO é, na verdade, uma diretiva muito útil para segmentar e organizar scripts em blocos lógicos. Desta forma, por exemplo, se o comando para criar uma tabela vier antes do comando para criar o banco de dados, será gerado um erro, já que é necessário ter o banco antes de criar tabelas. Neste post veja conheça a cláusula GO SQL Server.

O que é a cláusula GO?

A cláusula GO não é um comando SQL e não faz parte da linguagem T-SQL. Na verdade, ela é uma instrução de controle usada pelo SQL Server Management Studio (SSMS) e outras ferramentas de cliente para indicar o final de um lote de comandos.

O GO divide o script em lotes, ou seja, blocos de código que são enviados para execução ao servidor SQL como um único comando.

Exemplo básico:

SELECT * FROM Clientes;
GO
SELECT * FROM Pedidos;
GO

Neste exemplo, as duas consultas serão enviadas em lotes separados ao servidor SQL, e cada lote será executado de forma independente.

Quando usar a cláusula GO?

A cláusula GO é utilizada em vários cenários onde se deseja dividir um script SQL em blocos independentes. Isso pode ser útil em situações como:

1. Separar scripts de criação de objetos: Cada lote pode criar um objeto (tabela, procedimento, etc.), e usar GO evita que dependências incorretas causem erros;
   
   
2. Controlar execuções parciais: Você pode dividir seu código em partes que possam ser executadas individualmente;
   
   
3. Reinicializar o contexto do lote: Cada lote executado pode redefinir variáveis e outras configurações, o que é útil ao testar partes diferentes do script.

Como a cláusula GO funciona?

Sempre que você insere a cláusula GO, o SQL Server Management Studio (ou outro cliente) considera tudo acima do GO como um lote de comandos, enviando-o ao servidor para execução.

Cada lote de comandos é enviado ao servidor independentemente, o que significa que variáveis e outros objetos temporários criados no lote anterior não estão disponíveis no próximo lote.

Exemplo:

DECLARE @Nome NVARCHAR(50) = 'João';
GO

-- O código abaixo resultará em erro, pois a variável @Nome foi declarada em um lote anterior
SELECT @Nome;
GO

Nesse exemplo, a declaração da variável @Nome é feita no primeiro lote. Quando o GO é alcançado, o lote é encerrado, e a variável @Nome não estará disponível no próximo lote, resultando em um erro.

Especificando um número de execuções com GO

Uma funcionalidade interessante da cláusula GO é a possibilidade de repetir o lote de comandos um número específico de vezes. Você pode indicar quantas vezes deseja que o lote seja executado logo após o GO.

Exemplo:

PRINT 'Este comando será repetido 5 vezes!';
GO 5

Neste exemplo, o comando PRINT será executado 5 vezes, exibindo a mensagem repetidamente.

Diferença entre GO e ponto e vírgula ;

É comum confundir a cláusula GO com o uso do ponto e vírgula (;). Embora ambos marquem o final de algo, suas funções são diferentes:

Ponto e Vírgula (;): Marca o fim de uma instrução SQL específica. Em versões recentes do SQL Server, seu uso é obrigatório em algumas instruções, como WITH ou MERGE.

Exemplo:

SELECT * FROM Clientes;

GO: Marca o fim de um lote de instruções. Não faz parte da linguagem SQL, mas sim do ambiente de execução do script.

Onde GO não pode ser usado?

Como a cláusula GO é uma diretiva de cliente e não um comando SQL, não pode ser usada em:

• Procedimentos armazenados (Stored Procedures).
• Funções definidas pelo usuário (User-Defined Functions).
• Triggers.

Se você tentar incluir GO dentro desses objetos, o SQL Server retornará um erro de sintaxe.

Exemplo inválido:

CREATE PROCEDURE MinhaProc
AS
BEGIN
    SELECT 'Dentro de um procedimento armazenado';
    GO -- Isso causará um erro
END;
GO

Neste caso, o uso de GO dentro do procedimento armazenado não é permitido.

Exemplo prático de uso de GO

Vamos criar uma tabela, inserir dados e, em seguida, selecionar esses dados, usando GO para dividir o script em diferentes lotes:

-- Criação de tabela em um lote separado
CREATE TABLE Produtos (
    Id INT PRIMARY KEY,
    Nome NVARCHAR(100)
);
GO

-- Inserindo dados em outro lote
INSERT INTO Produtos (Id, Nome) VALUES (1, 'Notebook');
INSERT INTO Produtos (Id, Nome) VALUES (2, 'Smartphone');
GO

-- Selecionando dados em um terceiro lote
SELECT * FROM Produtos;
GO

Aqui, cada bloco de código é tratado como um lote separado. A tabela é criada no primeiro lote, os dados são inseridos no segundo, e no terceiro lote, a consulta é feita.

Outro exemplo:

Quando utilizamos o delimitador GO quebramos as instruções SQL em várias partes para que sejam processadas separadamente (ir de GO em GO). Veja:

CREATE DATABASE banco01
go
USE banco01
go
CREATE TABLE teste(
   nome VARCHA(30),
   sexo VAR(1),
   idade VAR(3)
)

O comando GO quebra as instruções do SQL Server em pacotes TCP para que cheguem em ordem síncrona no servidor e, desta forma, sejam executados corretamente.

A cláusula GO no SQL Server é uma ferramenta poderosa para organizar e modularizar seus scripts em blocos lógicos. Ela permite controlar a execução de comandos de maneira mais eficiente, dividindo scripts em partes menores e mais gerenciáveis. É importante lembrar que GO não faz parte do T-SQL, mas sim do ambiente de execução do script (como o SSMS).

Use GO sempre que precisar segmentar seu código ou repetir lotes de comandos várias vezes. Isso ajudará a tornar seus scripts SQL mais claros e organizados.

Dúvidas ou sugestões sobre a cláusula GO no SQL Server? Deixem nos comentários! Para mais dicas, acesse o nosso canal no YouTube:
https://youtube.com/criandobits

Tags: clausula go