Quando é que preciso de usar os blocos Begin / End e a palavra-chave Go no servidor SQL?

A Palavra-chave GO não faz parte do SQL. É usado apenas pelo analisador de consultas para dividir scripts em "lotes" que são executados independentemente.

GO não é uma palavra-chave no servidor SQL; é um separador em lote. GO termina uma série de declarações. Isto é especialmente útil quando você está usando algo como SQLCMD. Imagine que está a introduzir declarações SQL na linha de comandos. Você não quer necessariamente que a coisa para executar cada vez que você terminar uma declaração, então o servidor SQL não faz nada até que você Digite "GO".

Da mesma forma, antes do seu lote começar, você muitas vezes precisa ter alguns objetos visíveis. Por exemplo, digamos que você está criando uma base de dados e depois questioná-la. Não podes escrever.

CREATE DATABASE foo;
USE foo;
CREATE TABLE bar;

Porque o foo não existe para o lote que faz a tabela criar. Tens de fazer isto.

CREATE DATABASE foo;
GO
USE foo;
CREATE TABLE bar;

Como Gary aponta, GO é um separador de lote, usado pela maioria das ferramentas do cliente fornecidas pela Microsoft, tais como isql, sqlcmd, query analyzer e SQL Server Management studio. (Pelo menos algumas das ferramentas permitem que o separador de lote seja alterado. Nunca vi uso para mudar o separador de lote.)

Para responder à questão de quando usar GO, é preciso saber quando o SQL deve ser separado em lote.

Algumas declarações devem ser a primeira declaração de um lote.

select 1
create procedure #Zero as
    return 0

No servidor sql 2000 o erro é:

Msg 111, Level 15, State 1, Line 3
'CREATE PROCEDURE' must be the first statement in a query batch.
Msg 178, Level 15, State 1, Line 4
A RETURN statement with a return value cannot be used in this context.

No servidor sql 2005 o erro é menos útil:

Msg 178, Level 15, State 1, Procedure #Zero, Line 5
A RETURN statement with a return value cannot be used in this context.

Então, use GO para separar as declarações que têm de ser o início de um lote das declarações que o precedem num script.

Ao executar um script, muitos erros farão com que a execução do lote pare, mas então o cliente irá simplesmente enviar o próximo lote, a execução do script não vai parar. Costumo usar isto nos testes. Vou iniciar o script com a transacção inicial e terminar com a rollback, fazendo todos os testes no meio:

begin transaction
go
... test code here ...
go
rollback transaction

Também, se você estiver fazendo um script de instalação, e tiver vários lotes em um arquivo, um erro em um lote não vai impedir o script de continuar a executar, o que pode deixar uma bagunça. (Sempre backup antes de instalar.)

Relacionado com o que Dave Markel apontou, há casos em que o processamento vai falhar porque o servidor SQL está à procura no dicionário de dados de objetos que são criados anteriormente no lote, mas o processamento pode acontecer antes de qualquer declaração ser executada. Por vezes, trata-se de uma questão, por vezes não. Não consigo dar um bom exemplo. Mas se você alguma vez obter um 'X não existe' erro, quando ele claramente existirá por essa Declaração quebrar em lotes.

E uma nota final. A transacção pode abranger lotes. (Ver acima.) As variáveis não abrangem lotes.

declare @i int
set @i = 0
go
print @i

Msg 137, Level 15, State 2, Line 1
Must declare the scalar variable "@i".

GO termina um lote, você só muito raramente precisaria usá-lo em código. Esteja ciente de que se você usá-lo em um proc armazenado, nenhum código após o GO será executado quando você executar o proc.

O início e o fim são necessários para qualquer declaração de tipo processual com linhas multipes de código a processar. Você vai precisar deles para enquanto loops e cursores (que você vai evitar se em tudo possível, é claro) e se declarações (bem techincally você não precisa deles para um IF statment que só tem uma linha de código, mas é mais fácil manter o código se você sempre colocá-los depois de um Fi). As declarações de caso também usam um fim, mas não têm um começo.

GO é (deve ser) usado quando as seguintes declarações dependem de um objecto definido por uma declaração anterior. Usar o banco de dados é um bom exemplo acima, mas o seguinte também irá mordê-lo:

alter table foo add bar varchar(8);
-- if you don't put GO here then the following line will error as it doesn't know what bar is.
update foo set bar = 'bacon';
-- need a GO here to tell the interpreter to execute this statement, otherwise the Parser will lump it together with all successive statements.

Parece-me que o problema é este: o analisador SQL Servidor SQL, ao contrário do Oracle one, é incapaz de perceber que você está definindo um novo símbolo na primeira linha e que está ok para referência nas seguintes linhas. Ele não" vê " o símbolo até que ele encontra um token GO que lhe diz para executar o SQL anterior desde o último GO, em que ponto o símbolo é aplicado ao banco de dados e torna-se visível para o analisador.