Utilisation de l'utilitaire sqlcmd
sqlcmd est un utilitaire de ligne de commande Microsoft Win32 destiné à l'exécution ad hoc et interactive des instructions et des scripts Transact-SQL et à l'automatisation des tâches de script Transact-SQL. Pour utiliser sqlcmd de façon interactive ou pour créer des fichiers de script destinés à être exécutés avec sqlcmd, les utilisateurs doivent connaître Transact-SQL. L'utilitaire sqlcmd est généralement utilisé des façons suivantes :
Les utilisateurs entrent les instructions Transact-SQL de façon interactive comme s'ils travaillaient à partir de l'invite de commandes. Les résultats s'affichent dans l'invite de commandes. Pour ouvrir une fenêtre d'invite de commandes, cliquez sur Démarrer, sur Tous les programmes, pointez sur Accessoires, puis cliquez sur Invite de commandes. À l'invite de commandes, tapez sqlcmd suivi d'une liste des options de votre choix. Pour obtenir une liste complète des options prises en charge par l'utilitaire sqlcmd, consultez Utilitaire sqlcmd.
Les utilisateurs soumettent un travail sqlcmd soit en spécifiant une instruction Transact-SQL unique à exécuter, soit en indiquant à l'utilitaire un fichier texte contenant les instructions Transact-SQL à exécuter. Le résultat est généralement généré dans un fichier texte, mais il peut aussi être affiché dans l'invite de commandes.
Mode SQLCMD dans l'Éditeur de requête SQL Server Management Studio.
Objets SMO (SQL Server Management Objects)
Travaux CmdExec de l'Agent SQL Server.
Options sqlcmd courantes
Les options suivantes sont les plus fréquemment utilisées :
L'option de serveur (-S) qui identifie l'instance de MicrosoftSQL Server à laquelle l'utilitaire sqlcmd se connecte.
Les options d'authentification (-E, -U et -P) qui définissent les informations d'identification qu'utilise sqlcmd pour se connecter à l'instance de SQL Server.
[!REMARQUE]
L'option -E est l'option par défaut et il n'est pas nécessaire de la définir.
Les options d'entrée (-Q, -q et -i) qui identifient l'emplacement de l'entrée dans sqlcmd.
L'option de sortie (-o) qui définit le fichier dans lequel sqlcmd place sa sortie.
Connexion à l'utilitaire sqlcmd
Ci-dessous figurent quelques utilisations courantes de l'utilitaire sqlcmd :
Connexion à une instance par défaut à l'aide de l'authentification Windows pour exécuter de manière interactive des instructions Transact-SQL :
sqlcmd -S <ComputerName>[!REMARQUE]
Dans l'exemple précédent, -E n'est pas défini, car il s'agit du commutateur par défaut et sqlcmd se connecte à l'instance par défaut en utilisant l'authentification Windows.
Connexion à une instance nommée à l'aide de l'authentification Windows pour exécuter de manière interactive des instructions Transact-SQL :
sqlcmd -S <ComputerName>\<InstanceName>ou
sqlcmd -S .\<InstanceName>Connexion à une instance nommée en utilisant l'authentification Windows et définition des fichiers d'entrée et de sortie :
sqlcmd -S <ComputerName>\<InstanceName> -i <MyScript.sql> -o <MyOutput.rpt>Connexion à l'instance par défaut sur l'ordinateur local à l'aide de l'authentification Windows, exécution d'une requête et maintien de sqlcmd actif à la fin de la requête :
sqlcmd -q "SELECT * FROM AdventureWorks.Person.Contact"Connexion à l'instance par défaut sur l'ordinateur local à l'aide de l'authentification Windows, exécution d'une requête, envoi de la sortie vers un fichier et fin de l'exécution de sqlcmd à la fin de la requête :
sqlcmd -Q "SELECT * FROM AdventureWorks.Person.Contact" -o MyOutput.txtConnexion à une instance nommée à l'aide de l'authentification SQL Server pour exécuter des instructions Transact-SQL de manière interactive, avec sqlcmd demandant un mot de passe :
sqlcmd -U MyLogin -S <ComputerName>\<InstanceName>[!REMARQUE]
Pour obtenir une liste des options prises en charge par l'utilitaire sqlcmd, exécutez : sqlcmd -?.
Exécution d'instructions Transact-SQL interactivement à l'aide de sqlcmd
Vous pouvez utiliser l'utilitaire sqlcmd interactivement pour exécuter des instructions Transact-SQL dans une fenêtre d'invite de commandes. Pour exécuter interactivement des instructions Transact-SQL à l'aide de sqlcmd, exécutez l'utilitaire sans utiliser les options -Q, -q, -Z ou -i pour spécifier des fichiers ou des requêtes d'entrée. Par exemple :
sqlcmd -S <ComputerName>\<InstanceName>
Lorsque la commande est exécutée sans fichiers ou requêtes d'entrée, sqlcmd se connecte à l'instance spécifiée de SQL Server et affiche ensuite une nouvelle ligne comportant un 1> suivi d'un trait de soulignement clignotant, appelé invite sqlcmd. Le 1 signifie qu'il s'agit de la première ligne d'une instruction Transact-SQL et l'invite sqlcmd représente le point à partir duquel l'instruction Transact-SQL commencera lorsque vous la taperez.
À l'invite sqlcmd, vous pouvez taper à la fois des instructions Transact-SQL et des commandes sqlcmd, telles que GO et EXIT. Chaque instruction Transact-SQL est placée dans une mémoire tampon, appelée cache d'instruction. Ces instructions sont envoyées à SQL Server dès lors que vous avez tapé la commande GO et appuyé sur la touche Entrée. Pour quitter sqlcmd, tapez EXIT ou QUIT au début d'une nouvelle ligne.
Pour effacer le cache d'instruction, tapez :RESET. Le fait de taper ^C entraîne sqlcmd à se terminer. ^C peut également être utilisé pour arrêter l'exécution du cache d'instruction après la saisie d'une commande GO.
Les instructions Transact-SQL entrées dans une session interactive peuvent être modifiées en entrant la commande :ED et l'invite sqlcmd. L'éditeur s'ouvre et après avoir modifié l'instruction Transact-SQL et refermé l'éditeur, l'instruction Transact-SQL révisée s'affiche dans la fenêtre de commandes. Entrez GOpour exécuter l'instruction Transact-SQL révisée.
Chaînes entre guillemets
Les caractères entourés par des guillemets sont utilisés sans autre prétraitement, à l'exception des guillemets insérés au sein d'une chaîne en entrant deux guillemets consécutifs. SQL Server traite cette séquence de caractères comme un seul guillemet. (La traduction s'effectue toutefois sur le serveur). Les variables des scripts ne sont pas développées lorsqu'elles apparaissent au sein d'une chaîne.
Par exemple :
sqlcmd
PRINT "Length: 5"" 7'"
GO
Voici l'ensemble des résultats.
Length: 5" 7'
Chaînes qui s'étendent sur plusieurs lignes
sqlcmd prend en charge les scripts comportant des chaînes qui s'étendent sur plusieurs lignes. Par exemple, l'instruction SELECT suivante s'étend sur plusieurs lignes mais constitue une seule chaîne exécutée lorsque vous appuyez sur la touche Entrée après avoir tapé GO.
SELECT First line
FROM Second line
WHERE Third line
GO
Exemple d'utilisation interactive de sqlcmd
Il s'agit d'un exemple de ce que vous voyez lorsque vous exécutez sqlcmd interactivement.
Lorsque vous ouvrez une fenêtre d'invite de commandes, elle ne comporte qu'une seule ligne similaire à la ligne suivante :
C:\> _
Cela signifie que le dossier C:\ est le dossier en cours et que si vous spécifiez un nom de fichier, Windows recherchera le fichier dans ce dossier.
Tapez sqlcmd pour vous connecter à l'instance par défaut de SQL Server située sur l'ordinateur local. Le contenu de la fenêtre d'invite de commandes sera alors :
C:\>sqlcmd
1> _
Cela signifie que vous vous êtes connecté à l'instance de SQL Server et que sqlcmd est maintenant prêt à accepter des instructions Transact-SQL ainsi que des commandes sqlcmd. Le trait de soulignement clignotant situé après 1> est l'invite de sqlcmd qui marque l'emplacement où les instructions et les commandes que vous tapez sont affichées. À présent, tapez USE AdventureWorks et appuyez sur Entrée, puis tapez GO et appuyez sur Entrée. La fenêtre d'invite de commandes affiche les éléments suivants :
sqlcmd
USE AdventureWorks;
GO
Voici l'ensemble des résultats.
Changed database context to 'AdventureWorks'.
1> _
Appuyer sur la touche Entrée après avoir tapé USE AdventureWorks correspond à demander à sqlcmd de commencer une nouvelle ligne. Appuyer sur la touche Entrée après avoir tapé GO, correspond à demander à sqlcmd d'envoyer l'instruction USE AdventureWorks à l'instance de SQL Server. sqlcmd retourne alors un message pour indiquer que l'instruction USE a correctement abouti et affiche une nouvelle invite 1> qui vous signale que vous pouvez entrer une nouvelle instruction ou une nouvelle commande.
L'exemple suivant affiche le contenu de la fenêtre d'invite de commandes si vous tapez une instruction SELECT, une commande GO pour exécuter SELECT et une commande EXIT pour quitter sqlcmd :
sqlcmd
USE AdventureWorks;
GO
SELECT TOP (5) ContactID, FirstName, LastName
FROM Person.Contact;
GO
Voici l'ensemble des résultats.
ContactID FirstName LastName
----------- -------------------------------------------------- -----------
1 Syed Abbas
2 Catherine Abel
3 Kim Abercrombie
4 Humberto Acevedo
5 Pilar Ackerman
(5 rows affected)
1> EXIT
C:\>
Les lignes situées après la ligne 3> GO sont les données de sortie d'une instruction SELECT. Une fois les données de sortie générées, sqlcmd réinitialise l'invite sqlcmd et affiche 1>. Après avoir entré EXIT sur la ligne 1>, la fenêtre d'invite de commandes affiche la même ligne que celle qu'elle a affichée lorsque vous avez ouvert l'invite de commandes la première fois. Ceci indique que sqlcmd a mis fin à sa session. Vous pouvez maintenant fermer la fenêtre d'invite de commandes en tapant une autre commande EXIT.
Exécution de fichiers de script Transact-SQL à l'aide de sqlcmd
Vous pouvez utiliser sqlcmd pour exécuter des fichiers de script de base de données. Il s'agit de fichiers texte contenant un mélange d'instructions Transact-SQL, de commandes sqlcmd et de variables de script. Pour plus d'informations sur la création des variables de script, consultez Utilisation de sqlcmd avec des variables de script. sqlcmd fonctionne avec les instructions, les commandes et les variables de script contenues dans un fichier de script de manière très similaire à son fonctionnement avec des instructions et des commandes entrées de manière interactive. La principale différence est que sqlcmd lit le fichier d'entrée sans marquer de pause au lieu d'attendre que l'utilisateur entre les instructions, les commandes et les variables de script.
Il existe plusieurs manières de créer des fichiers de script de base de données :
Vous pouvez construire et déboguer de manière interactive un ensemble d'instructions Transact-SQL dans SQL Server Management Studio, puis enregistrer le contenu de la fenêtre Requête en tant que fichier de script.
Vous pouvez créer un fichier texte contenant des instructions Transact-SQL à l'aide d'un éditeur de texte tel que le Bloc-notes.
Exemples
A. Exécution d'un script à l'aide de sqlcmd
Démarrez le Bloc-notes et tapez les instructions Transact-SQL suivantes :
USE AdventureWorks;
GO
SELECT TOP (5) ContactID, FirstName, LastName
FROM Person.Contact;
GO
Créez un dossier intitulé MyFolder puis enregistrez le script sous le fichier MyScript.sql dans le dossier C:\MyFolder. Entrez les instructions suivantes à l'invite de commandes pour exécuter le script et diriger la sortie dans MyOutput.txt dans MyFolder :
sqlcmd -i C:\MyFolder\MyScript.sql -o C:\MyFolder\MyOutput.txt
Lorsque vous affichez le contenu de MyOutput.txt dans le Bloc-notes, vous découvrez son contenu :
Changed database context to 'AdventureWorks'.
ContactID FirstName LastName
----------- ----------- -----------
1 Syed Abbas
2 Catherine Abel
3 Kim Abercrombie
4 Humberto Acevedo
5 Pilar Ackerman
(5 rows affected)
B. Utilisation de sqlcmd avec une connexion d'administration dédiée
Dans l'exemple suivant, sqlcmd permet de se connecter à un serveur ayant un problème de blocage à l'aide de la connexion administrateur dédiée.
C:\>sqlcmd -S ServerName -A
1> SELECT blocked FROM sys.dm_exec_requests WHERE blocked <> 0;
2> GO
Voici l'ensemble des résultats.
spid blocked
------ -------
62 64
(1 rows affected)
Utilisez sqlcmd pour mettre fin au processus de blocage.
1> KILL 64;
2> GO
C. Utilisation de sqlcmd pour exécuter une procédure stockée
L'exemple suivant montre comment exécuter une procédure stockée à l'aide de sqlcmd. Créez la procédure stockée suivante.
USE AdventureWorks;
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.Contact
WHERE FirstName = @FirstName
AND LastName = @LastName;
SET NOCOUNT OFF
À l'invite sqlcmd, entrez :
C:\sqlcmd
1> :Setvar FirstName Gustavo
1> :Setvar LastName Achong
1> EXEC dbo.ContactEmailAddress $(Gustavo),$(Achong)
2> GO
EmailAddress
-----------------------------
gustavo0@adventure-works.com
D. Utilisation de sqlcmd pour la maintenance de base de données
L'exemple suivant montre comment utiliser sqlcmd pour une tâche de maintenance de base de données. Créez C:\BackupTemplate.sql à l'aide du code suivant.
USE master;
BACKUP DATABASE [$(db)] TO DISK='$(bakfile)';
À l'invite de commandes sqlcmd, entrez les informations suivantes :
C:\ >sqlcmd
1> :connect <server>
Sqlcmd: Successfully connected to server <server>.
1> :setvar db msdb
1> :setvar bakfile c:\msdb.bak
1> :r c:\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. Utilisation de sqlcmd pour exécuter du code sur plusieurs instances
Le code suivant dans un fichier illustre la connexion d'un script à deux instances. Notez GO avant la connexion à la deuxième instance.
:CONNECT <server>\,<instance1>
EXEC dbo.SomeProcedure
GO
:CONNECT <server>\,<instance2>
EXEC dbo.SomeProcedure
GO
E. Retour d'une sortie XML
L'exemple suivant montre comment la sortie XML est retournée, sans mise en forme, dans un flux continu.
C:\>sqlcmd -d AdventureWorks
1> :XML ON
1> SELECT TOP 4 FirstName + ' ' + LastName + ', '
2> FROM Person.Contact
3> GO
Gustavo Achong, Catherine Abel, Kim Abercrombie, Humberto Acevedo,
F. Utilisation de sqlcmd dans un fichier de script Windows
Une commande sqlcmd, telle que sqlcmd -i C:\InputFile.txt -o C:\OutputFile.txt, , peut s'exécuter dans un fichier .bat en même temps que VBScript. Dans ce cas, n'utilisez pas les options interactives. sqlcmd doit être installé sur l'ordinateur qui exécute le fichier .bat.
Commencez par créer les quatre fichiers suivants :
C:\badscript.sql
SELECT batch_1_this_is_an_error GO SELECT 'batch #2' GOC:\goodscript.sql
SELECT 'batch #1' GO SELECT 'batch #2' GOC:\returnvalue.sql
:exit(select 100) @echo off C:\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
Puis, à l'invite de commandes, exécutez C:\windowsscript.bat :
C:\>windowsscript.bat
Running badscript.sql
== An error occurred
Running goodscript.sql
Running returnvalue.sql
SQLCMD returned 100 to the command shell
Voir aussi