sqlcmd – usar o utilitário
Aplica-se a: SQL Server
Banco de Dados SQL do Azure
Instância Gerenciada de SQL do Azure
Azure Synapse Analytics
PDW (Analytics Platform System)
O sqlcmd é um utilitário de linha de comando para execução interativa ad hoc dos scripts e instruções Transact-SQL (T-SQL) bem como para automatização das tarefas de script do T-SQL. Para usar sqlcmd de forma interativa ou para criar arquivos de script a serem executados com sqlcmd, os usuários devem entender sobre T-SQL. O utilitário sqlcmd normalmente é usado das seguintes maneiras:
Os usuários inserem instruções T-SQL de forma semelhante ao trabalho no prompt de comando. Os resultados são exibidos no prompt de comando. Para abrir uma janela de prompt de comando, digite
cmd
na caixa de pesquisa do Windows e selecione Prompt de comando para abrir. No prompt de comando, digitesqlcmd
seguido por uma lista de opções que você deseja. Para obter uma lista completa das opções compatíveis com o sqlcmd, confira utilitário sqlcmd.Os usuários enviam um trabalho sqlcmd especificando uma única instrução T-SQL a ser executada ou apontando o utilitário para um arquivo de texto que contenha instruções T-SQL a serem executadas. O resultado é direcionado a um arquivo de texto, mas também pode ser exibido no prompt de comando.
Modo SQLCMD no Editor de Consultas do SQL Server Management Studio (SSMS).
SQL Server Management Objects (SMO).
Trabalhos do CmdExec do SQL Server Agent.
Opções sqlcmd normalmente usadas
A opção de servidor (
-S
) identifica a instância do SQL Server com a qual o sqlcmd se conecta.As opções de autenticação (
-E
,-U
e-P
) especificam as credenciais que o sqlcmd usa para se conectar à instância do SQL Server.Observação
A opção
-E
é o padrão e não precisa ser especificada.As opções de entrada (
-Q
,-q
e-i
) identificam o local da entrada para sqlcmd.A opção de saída (
-o
) especifica o arquivo no qual o sqlcmd deve colocar a saída.
Conectar ao utilitário sqlcmd
Conecte-se a uma instância padrão usando a Autenticação do Windows para executar instruções T-SQL de forma interativa:
sqlcmd -S <ComputerName>
Observação
No exemplo anterior,
-E
não é especificado porque é o padrão e o sqlcmd se conecta à instância padrão usando a Autenticação do Windows.Conecte-se a uma instância nomeada usando a Autenticação do Windows para executar instruções T-SQL interativamente:
sqlcmd -S <ComputerName>\<InstanceName>
or
sqlcmd -S .\<InstanceName>
Conecte-se a uma instância nomeada, usando a Autenticação do Windows e especificando arquivos de entrada e saída:
sqlcmd -S <ComputerName>\<InstanceName> -i <MyScript.sql> -o <MyOutput.rpt>
Conecte-se à instância padrão no computador local usando a Autenticação do Windows, executando uma consulta e mantendo sqlcmd em execução até mesmo após a consulta ter sido concluída:
sqlcmd -q "SELECT * FROM AdventureWorks2022.Person.Person"
Conecte-se a uma instância padrão no computador local usando a Autenticação do Windows, executando uma consulta, direcionando a saída para um arquivo e fazendo com que o sqlcmd feche após a conclusão da consulta:
sqlcmd -Q "SELECT * FROM AdventureWorks2022.Person.Person" -o MyOutput.txt
Conecte-se a uma instância nomeada que usa a Autenticação do SQL Server para executar de forma interativa instruções T-SQL, com sqlcmd solicitando uma senha:
sqlcmd -U MyLogin -S <ComputerName>\<InstanceName>
Dica
Para consultar uma lista das opções compatíveis com o utilitário sqlcmd , execute:
sqlcmd -?
.
Executar instruções Transact-SQL interativamente usando o sqlcmd
Você pode usar o utilitário sqlcmd interativamente para executar instruções T-SQL em uma janela de Prompt de Comando. Para executar interativamente instruções T-SQL usando sqlcmd, execute o utilitário sem usar as opções -Q
, -q
, -Z
ou -i
para especificar qualquer arquivo ou consulta de entrada. Por exemplo:
sqlcmd -S <ComputerName>\<InstanceName>
Quando o comando é executado sem arquivos ou consultas de entrada, o sqlcmd se conecta à instância especificada do SQL Server e exibe uma nova linha com um 1>
seguido de um sublinhado intermitente, que é conhecido como o prompt do sqlcmd. O 1
significa que esta é a primeira linha de uma instrução T-SQL, e o prompt do sqlcmd é o ponto no qual a instrução T-SQL iniciará quando for digitada.
No prompt do sqlcmd, você pode digitar instruções T-SQL e comandos sqlcmd, como GO
e EXIT
. Cada instrução T-SQL é colocada em um buffer denominado cache de instrução. Essas instruções são enviadas ao SQL Server depois que você digita o comando GO
e pressiona Enter. Para sair do sqlcmd, digite EXIT
ou QUIT
no início de uma nova linha.
Para limpar o cache de instruções, digite :RESET
. Digitar Ctr+C encerra o sqlcmd. Ctr+C também pode ser usado para interromper a execução do cache de instrução depois que um comando GO
é emitido.
Instruções T-SQL inseridas em uma sessão interativa podem ser editadas digitando o comando :ED
e o prompt do sqlcmd. O editor será aberto e, após a edição da instrução T-SQL e de fechamento do editor, a instrução T-SQL revisada aparecerá na janela de comando. Insira GO
para executar a instrução T-SQL revisada.
Cadeia de caracteres entre aspas
Os caracteres entre aspas são usados sem nenhum pré-processamento adicional, a não ser quando as aspas podem ser inseridas em uma cadeia de caracteres através de duas aspas consecutivas. SQL Server trata esta sequência de caracteres como uma aspa. (Porém, a conversão acontece no servidor.) As de script não são expandidas quando aparecem dentro de uma cadeia de caracteres.
Por exemplo:
sqlcmd
PRINT "Length: 5"" 7'";
GO
Este é o conjunto de resultados.
Length: 5" 7'
Cadeias de caracteres que abrangem várias linhas
Osqlcmd é compatível com scripts que têm cadeias de caracteres que abrangem várias linhas. Por exemplo, a seguinte instrução SELECT
estende diversas linhas, mas é uma única cadeia de caracteres executada ao pressionar a tecla Enter, depois de digitar GO
.
SELECT <First line>
FROM <Second line>
WHERE <Third line>;
GO
Exemplo interativo do sqlcmd
Este é um exemplo do que você vê ao executar o sqlcmd de modo interativo.
Ao abrir uma janela de prompt de comando, você verá uma linha semelhante a esta:
C:\Temp\>
Isso significa que a pasta C:\Temp\
é a pasta atual, e se você especificar um nome de arquivo, o Windows procurará o arquivo nessa pasta.
Digite sqlcmd para se conectar à instância padrão do SQL Server no computador local, e o conteúdo da janela Prompt de Comando será o seguinte:
C:\Temp>sqlcmd
1>
Isso significa que você se conectou com a instância do SQL Server e o sqlcmd agora está pronto para aceitar as instruções T-SQL e os comandos sqlcmd. O sublinhado intermitente que precede 1>
é o prompt sqlcmd que marca o local no qual as instruções e os comandos que você digita são exibidos. Agora, digite USE AdventureWorks2022
, pressione Enter. digite GO
e pressione Enter. O conteúdo da janela de prompt de comando é o seguinte:
sqlcmd
USE AdventureWorks2022;
GO
Este é o conjunto de resultados.
Changed database context to 'AdventureWorks2022'.
1>
Quando você pressiona Enter, ele sinalizará ao sqlcmd para iniciar uma nova linha. Ao pressionar Enter depois de digitar GO
, você sinaliza ao sqlcmd para enviar a instrução USE AdventureWorks2022
à instância do SQL Server. Em seguida, sqlcmd retorna uma mensagem para indicar que a instrução USE
foi concluída com êxito e exibe um novo prompt de 1>
como sinal para inserir uma nova instrução ou comando.
O exemplo a seguir mostra o conteúdo da janela de prompt de comando ao você digitar uma instrução SELECT
, uma GO
para executar o comando SELECT
, e uma EXIT
para fechar sqlcmd:
USE AdventureWorks2022;
GO
SELECT TOP (3) BusinessEntityID, FirstName, LastName
FROM Person.Person;
GO
Este é o conjunto de resultados.
BusinessEntityID FirstName LastName
----------------- ---------- ------------
1 Syed Abbas
2 Catherine Abel
3 Kim Abercrombie
Depois que você gerar a saídasqlcmd redefinirá o prompt sqlcmd e exibirá 1>
. Para encerrar a sessão, digite EXIT
no prompt 1>
. Agora você pode fechar a janela de prompt de comando digitando outro comando EXIT
.
Criar e consultar um contêiner do SQL Server
Você pode usar sqlcmd (Go) para criar uma nova instância do SQL Server em um contêiner. sqlcmd (Go) expõe uma instrução create
que permite especificar uma imagem de contêiner e um backup do SQL Server para criar rapidamente uma instância do SQL Server para fins de desenvolvimento, depuração e análise.
O comando a seguir mostra como ver todas as opções disponíveis para criar um novo contêiner do SQL Server:
sqlcmd create mssql --help
O comando a seguir cria uma nova instância do SQL Server usando a versão mais recente do SQL Server 2022 (16.x) e restaura o banco de dados de exemplo Wide World Importers:
sqlcmd create mssql --accept-eula --tag 2022-latest --using https://github.com/Microsoft/sql-server-samples/releases/download/wide-world-importers-v1.0/WideWorldImporters-Full.bak
Depois que a instância do SQL Server tiver sido criada, você poderá usar sqlcmd (Go) para gerenciá-la e consultá-la.
O comando a seguir confirma a versão da instância criada:
sqlcmd query "SELECT @@version"
O comando a seguir inicia uma sessão interativa com a instância criada:
sqlcmd query
O comando a seguir abre o Azure Data Studio e conecta-se automaticamente ao banco de dados que foi restaurado durante o processo de criação:
sqlcmd open ads
O comando a seguir lista as cadeias de conexão a serem usadas para se conectar à instância criada:
sqlcmd config connection-strings
O comando a seguir é usado para excluir o contêiner quando ele não é mais necessário:
sqlcmd delete
Executar arquivos de script Transact-SQL usando sqlcmd
Você pode usar sqlcmd para executar arquivos de script do banco de dados. Arquivos de script são arquivos de texto que contêm uma mistura de instruções T-SQL, comandos sqlcmd e variáveis de script. Para obter mais informações sobre como usar variáveis de script, veja Usar sqlcmd com variáveis de script. Osqlcmd funciona com instruções, comandos e variáveis de script em um arquivo de script de modo semelhante ao modo como funciona com instruções e comandos inseridos interativamente. A principal diferença é que o sqlcmd faz a leitura por meio do arquivo de entrada sem pausa, em vez de esperar que um usuário insira as instruções, os comandos e as variáveis de script.
Existem maneiras diferentes de criar arquivos de script de banco de dados:
Você pode criar e depurar interativamente uma série de instruções T-SQL no SQL Server Management Studio e, em seguida, salvar o conteúdo da janela de consulta como arquivo de script.
Você pode criar um arquivo de texto que contém instruções T-SQL usando um editor de textos, como o Bloco de Notas.
Exemplos
a. Executar um script usando o sqlcmd
Iniciar o Bloco de Notas e digitar as seguintes instruções T-SQL:
USE AdventureWorks2022;
GO
SELECT TOP (3) BusinessEntityID, FirstName, LastName
FROM Person.Person;
GO
Criar uma pasta nomeada MyFolder
e, em seguida, salvar o script como o arquivo MyScript.sql
na pasta C:\MyFolder
. Digite o comando a seguir no prompt de comando para executar o script e colocar a saída em MyOutput.txt
, em MyFolder
:
sqlcmd -i C:\MyFolder\MyScript.sql -o C:\MyFolder\MyOutput.txt
Este é o conjunto de resultados.
Changed database context to 'AdventureWorks2022'.
BusinessEntityID FirstName LastName
----------------- ---------- ------------
1 Syed Abbas
2 Catherine Abel
3 Kim Abercrombie
(3 rows affected)
B. Usar o sqlcmd com uma conexão administrativa dedicada
No exemplo a seguir, sqlcmd é usado para se conectar a um servidor que tem um problema de bloqueio utilizando a conexão de administrador dedicada (DAC).
C:\Temp\>sqlcmd -S ServerName -A
1> SELECT session_id, blocking_session_id FROM `sys.dm_exec_requests` WHERE blocking_session_id <> 0;
2> GO
Este é o conjunto de resultados.
session_id blocking_session_id
----------- --------------------`
62 64
(1 rows affected)
Use sqlcmd para finalizar o processo de bloqueio.
1> KILL 64;
2> GO
C. Usar o sqlcmd para executar um procedimento armazenado
O exemplo a seguir mostra como executar um procedimento armazenado usando sqlcmd. Criar o seguinte procedimento armazenado.
USE AdventureWorks2022;
GO
IF OBJECT_ID('dbo.ContactEmailAddress', 'P') IS NOT NULL
DROP PROCEDURE dbo.ContactEmailAddress;
GO
CREATE PROCEDURE dbo.ContactEmailAddress (
@FirstName NVARCHAR(50),
@LastName NVARCHAR(50)
)
AS
SET NOCOUNT ON;
SELECT EmailAddress
FROM Person.Person
WHERE FirstName = @FirstName
AND LastName = @LastName;
SET NOCOUNT OFF;
GO
No prompt sqlcmd, insira o seguinte:
C:\Temp\sqlcmd
1> :Setvar FirstName Gustavo
1> :Setvar LastName Achong
1> EXEC dbo.ContactEmailAddress $(FirstName),$(LastName)
2> GO
EmailAddress
-----------------------------
gustavo0@adventure-works.com
D. Usar o sqlcmd para manutenção do banco de dados
O exemplo a seguir mostra como usar sqlcmd para uma tarefa de manutenção de banco de dados. Crie C:\Temp\BackupTemplate.sql
com o seguinte código.
USE master;
BACKUP DATABASE [$(db)] TO DISK='$(bakfile)';
No prompt sqlcmd, digite o seguinte código:
C:\Temp\>sqlcmd
1> :connect <server>
Sqlcmd: Successfully connected to server <server>.
1> :setvar db msdb
1> :setvar bakfile C:\Temp\msdb.bak
1> :r C:\Temp\BackupTemplate.sql
2> GO
Changed database context to 'master'.
Processed 688 pages for database 'msdb', file 'MSDBData' on file 2.
Processed 5 pages for database 'msdb', file 'MSDBLog' on file 2.
BACKUP DATABASE successfully processed 693 pages in 0.725 seconds (7.830 MB/sec)
E. Usar o sqlcmd para executar o código em diversas instâncias
O código a seguir em um arquivo exibe um script que conecta a duas instâncias. Note o GO
antes da conexão com a segunda instância.
:CONNECT <server>\,<instance1>
EXEC dbo.SomeProcedure
GO
:CONNECT <server>\,<instance2>
EXEC dbo.SomeProcedure
GO
E. Retornar a saída XML
O exemplo a seguir mostra como a saída XML é retornada sem formatação, em um fluxo contínuo.
C:\Temp\>sqlcmd -d AdventureWorks2022
1> :XML ON
1> SELECT TOP 3 FirstName + ' ' + LastName + ', '
2> FROM Person.Person
3> GO
Syed Abbas, Catherine Abel, Kim Abercrombie,
F. Usar o sqlcmd em um arquivo de script do Windows
Um comando sqlcmd, como sqlcmd -i C:\Temp\InputFile.txt -o C:\Temp\OutputFile.txt,
, pode ser executado em um arquivo .bat com o VBScript. Nesse caso, não use opções interativas. Osqlcmd deve ser instalado no computador que está executando o arquivo .bat.
Primeiro, crie os quatro arquivos a seguir em C:\Temp
:
C:\Temp\badscript.sql
SELECT batch_1_this_is_an_error GO SELECT 'batch #2' GO
C:\Temp\goodscript.sql
SELECT 'batch #1'; GO SELECT 'batch #2'; GO
C:\Temp\returnvalue.sql
:exit(select 100)
C:\Temp\windowsscript.bat
@echo off echo Running badscript.sql sqlcmd -i badscript.sql -b -o out.log if not errorlevel 1 goto next1 echo == An error occurred :next1 echo Running goodscript.sql sqlcmd -i goodscript.sql -b -o out.log if not errorlevel 1 goto next2 echo == An error occurred :next2 echo Running returnvalue.sql sqlcmd -i returnvalue.sql -o out.log echo SQLCMD returned %errorlevel% to the command shell :exit
Em seguida, no prompt de comando, execute C:\Temp\windowsscript.bat
:
C:\Temp\>windowsscript.bat
Running badscript.sql
== An error occurred
Running goodscript.sql
Running returnvalue.sql
SQLCMD returned 100 to the command shell
G. Usar sqlcmd para definir a criptografia no Bancos de Dados SQL do Azure
sqlcmd pode ser executado em uma conexão com os dados do Banco de Dados SQL para especificar a criptografia e a confiança do certificado. Duas opções sqlcmd estão disponíveis:
A opção
-N
é usada pelo cliente para solicitar uma conexão criptografada. Essa opção é equivalente à opçãoENCRYPT = true
do ADO.net.A opção
-C
é usada pelo cliente para configurá-lo para confiar implicitamente no certificado do servidor e não validá-lo. Essa opção é equivalente à opçãoTRUSTSERVERCERTIFICATE = true
do ADO.net.
O serviço Banco de Dados SQL não dá suporte a todas as opções de SET
disponíveis em uma instância do SQL Server. As opções a seguir emitem um erro quando a opção de SET
correspondente é definida como ON
ou OFF
:
SET ANSI_DEFAULTS
SET ANSI_NULLS
SET REMOTE_PROC_TRANSACTIONS
SET ANSI_NULL_DEFAULT
As opções de SET a seguir não emitem exceções, mas não podem ser usadas. Eles foram preteridos:
SET CONCAT_NULL_YIELDS_NULL
SET ANSI_PADDING
SET QUERY_GOVERNOR_COST_LIMIT
Sintaxe
Os exemplos a seguir fazem referência a casos em que as configurações do provedor SQL Server Native Client incluem:
ForceProtocolEncryption = False
Trust Server Certificate = No
Conectar usando credenciais do Windows e comunicação criptografada:
sqlcmd -E -N
Conectar usando credenciais do Windows e certificado do servidor confiável:
sqlcmd -E -C
Conectar usando credenciais do Windows, comunicação criptografada e certificado do servidor confiável:
sqlcmd -E -N -C
Os exemplos a seguir fazem referência a casos em que as configurações do provedor SQL Server Native Client incluem:
ForceProtocolEncryption = True
TrustServerCertificate = Yes
Conectar usando credenciais do Windows, comunicação criptografada e certificado do servidor confiável:
sqlcmd -E
Conectar usando credenciais do Windows, comunicação criptografada e certificado do servidor confiável:
sqlcmd -E -N
Conectar usando credenciais do Windows, comunicação criptografada e certificado do servidor confiável:
sqlcmd -E -C
Conectar usando credenciais do Windows, comunicação criptografada e certificado do servidor confiável:
sqlcmd -E -N -C
Se o provedor especificar ForceProtocolEncryption = True
, a criptografia será habilitada mesmo que Encrypt=No
esteja na cadeia de conexão.