I. Introduction ♪▲
S'il est bien un outil qu'il est confortable d'utiliser pour rechercher des problèmes de performances sur un serveur de bases de données SQL Server, c'est bien le Profiler de SQL Server.
En effet cette interface graphique permet de capturer des données d'événements qui se produisent au sein d'une instance SQL Server, et des les analyser directement dans l'interface proposée, ou ultérieurement en enregistrant la trace dans un fichier.
Nous allons voir ici comment :
- créer une trace de façon automatique à l'aide de l'Agent SQL Server ;
- l'arrêter, toujours de façon automatique ;
- la charger automatiquement dans une table de base de données ;
- séparer les fichiers de trace par période (par exemple un fichier par heure).
II. Préparation de la trace▲
Démarrons SQL Server Management Studio, puis rendons-nous dans le menu Outils pour démarrer SQL Server Profiler :
Nous obtenons l'interface graphique sous laquelle nous pouvons suivre, entre autres, les exécutions de quelques appels de procédures stockées :
Il suffit de choisir les événements habituels.
Dans cet exemple, nous sélectionnerons :
- RPC : Completed ;
- Locks : Deadlock Graph ;
- Locks : Timeout (timeout > 0).
Voyons tout d'abord RPC : Completed : nous voulons savoir combien de pages les procédures stockées appelées lisent et écrivent, et combien de temps celles-ci mettent à s'exécuter. Nous souhaitons également connaitre le nom des procédures stockées.
Nous cochons seulement les cases dont nous avons besoin, de façon à minimiser la charge que la trace s'appropriera :
- TextData pour le code d'appel complet de la procédure stockée ;
- Reads pour le nombre de pages lues à l'exécution de la procédure stockée ;
- Writes pour le nombre de pages écrites à l'exécution de la procédure stockée ;
- Duration pour le temps d'exécution total de la procédure stockée ;
- StartTime pour savoir à quelle heure la procédure stockée s'est exécutée.
Réduisons maintenant le détail de toutes les catégories de classes d'événement :
Passons ensuite aux verrous et étreintes mortelles, après avoir coché la case Afficher tous les événements. En développant le nœud de la catégorie Locks, nous obtenons :
Notons ici que pour n'importe quel événement, la colonne SPID (identifiant de la session qui a déclenché l'événement) est cochée et ne peut être décochée tant que l'événement associé est actif.
Ajoutons maintenant les filtres :
Nous obtenons alors la boîte de dialogue suivante :
et nous pouvons filtrer sur le paramètre correspondant au nombre de pages lues. Ici nous choisissions 100, c'est-à-dire 8 Mo.
Il suffit maintenant de démarrer la trace, comme si nous voulions la visualiser dans l'interface graphique :
III. Obtention du script de trace SQL Server Profiler▲
Pour obtenir le script de la trace que nous venons de créer, il suffit d'ouvrir le menu Fichier :
et de choisir finalement de générer un script de trace pour l'édition de SQL Server qui convient.
On retrouve la boîte de dialogue d'enregistrement classique d'un fichier :
L'enregistrement est immédiatement confirmé :
N'oublions pas d'arrêter la trace avant de quitter SQL Server Profiler :
Retournons maintenant sous SQL Server Management Studio, puis ouvrons le fichier script de trace :
Nous obtenons alors le script suivant :
/****************************************************/
/* Created by: SQL Server 2008 Profiler */
/* Date: 07/10/2009 23:03:19 */
/****************************************************/
-- Create a Queue
declare
@rc int
declare
@TraceID int
declare
@maxfilesize bigint
set
@maxfilesize =
5
-- Please replace the text InsertFileNameHere, with an appropriate
-- filename prefixed by a path, e.g., c:\MyFolder\MyTrace. The .trc extension
-- will be appended to the filename automatically. If you are writing from
-- remote server to local drive, please use UNC path and make sure server has
-- write access to your network share
exec
@rc =
sp_trace_create @TraceID output, 0
, N'InsertFileNameHere'
, @maxfilesize, NULL
if
(
@rc !=
0
)
goto
error
-- Client side File and Table cannot be scripted
-- Set the events
declare
@on
bit
set
@on
=
1
exec
sp_trace_setevent @TraceID, 148
, 12
, @on
exec
sp_trace_setevent @TraceID, 148
, 14
, @on
exec
sp_trace_setevent @TraceID, 148
, 1
, @on
exec
sp_trace_setevent @TraceID, 189
, 1
, @on
exec
sp_trace_setevent @TraceID, 189
, 12
, @on
exec
sp_trace_setevent @TraceID, 189
, 13
, @on
exec
sp_trace_setevent @TraceID, 189
, 14
, @on
exec
sp_trace_setevent @TraceID, 10
, 16
, @on
exec
sp_trace_setevent @TraceID, 10
, 1
, @on
exec
sp_trace_setevent @TraceID, 10
, 17
, @on
exec
sp_trace_setevent @TraceID, 10
, 12
, @on
exec
sp_trace_setevent @TraceID, 10
, 13
, @on
exec
sp_trace_setevent @TraceID, 10
, 14
, @on
-- Set the Filters
declare
@intfilter int
declare
@bigintfilter bigint
set
@bigintfilter =
100
exec
sp_trace_setfilter @TraceID, 16
, 0
, 4
, @bigintfilter
-- Set the trace status to start
exec
sp_trace_setstatus @TraceID, 1
-- display trace id for future references
select
TraceID=
@TraceID
goto
finish
error
:
select
ErrorCode=
@rc
finish:
go
IV. Interprétation du fichier de script de trace▲
Le premier appel de procédure stockée est sp_trace_create. Il permet simplement de créer la trace.
Je vous engage à vous documenter sur les paramètres de cette procédure stockée système :
- dans la BOL : sp_trace_create ;
- dans la documentation en ligne.
Ensuite la procédure stockée sp_trace_setevent est appelée plusieurs fois, à raison d'une fois par événement. En consultant la documentation de cette procédure stockée, on voit que :
- pour tout événement, on doit passer l'identifiant de trace, que l'on retrouve en requêtant la table sys.traces ;
- chaque événement possède un identifiant qui doit être passé en second paramètre d'entrée à cette procédure stockée. Il existe en tout plus de 200 événements, à savoir :ID 148 qui correspond à l'événement Deadlock GraphID 189 qui correspond à l'événement Lock:Timeout (timeout> 0)ID 10 qui correspond à l'événement RPC:Completed ;
- pour chaque événement, on doit préciser les colonnes qui devront être prises en compte.
On retrouvera forcément, pour chacun des événements, comme nous l'avons vu, la colonne n° 12, qui correspond au SPID, et en l'occurrence :
- la colonne n° 14, qui correspond à la colonne StartTime ;
- la colonne n° 1, qui identifie la colonne TextData ;
- la colonne n° 13, pour la colonne Duration ;
- la colonne n° 16, pour la colonne Reads, que l'on ne trouve que pour l'événement RPC:Completed ;
- la colonne n° 17, pour la colonne Writes, également seulement pour l'événement RPC:Completed.
On peut ensuite spécifier des filtres avec la procédure sp_trace_setfilter et, comme nous avons spécifié dans l'interface graphique, un filtre sur les appels de procédures qui provoquent la lecture de plus de 100 pages. Nous trouvons, dans l'ordre :
- toujours l'identifiant de trace ;
- l'identifiant de la colonne à filtrer, ici la n° 16 : Reads ;
- l'opérateur logique AND(0) ou OR (1), car on peut spécifier plusieurs filtres pour la même colonne, par exemple les procédures entraînent la lecture d'au moins 100 pages et d'au plus 1000 pages, ou les procédures dont le nom contient un mot ou un autre ;
- le dernier paramètre est de type BIT et permet d'activer ou désactiver le filtre à volonté, en appelant tout simplement cette même procédure stockée avec ce paramètre à 0, ce qui est envisageable même si la trace est en cours d'exécution.
V. Écriture de la procédure stockée de création de trace▲
Voici le script complet de gestion des fichiers de trace.
Il est commenté autant que cela est possible, et permet :
- de créer des fichiers pour une trace ayant les mêmes caractéristiques (événements, filtres) ;
- d'intégrer le fichier de trace précédent dans une table dbo.maTableDeTrace (script suivant) dont le script de création suit celui-ci, à l'aide de la fonction table fn_trace_gettable. À noter que l'on n'est pas obligé d'intégrer les fichiers dans une table ;
- de supprimer les fichiers de trace que l'on vient d'intégrer :
-------------------------------
-- 12/10/2009 - Nicolas SOUQUET
-------------------------------
ALTER
PROCEDURE
PsCreeTrace
@_cheminFichierTrace NVARCHAR
(
256
)
,
@_minutesTrace SMALLINT
, -- Spécifie le nombre de minutes de durée de la trace <=> périodicité de renouvellement des fichiers de la trace
@_avecDetails BIT
=
0
, -- Retourne quelques caractéristiques de la trace créée
@_avecIntegration BIT
=
0
-- Intègre le fichier de trace précédemment créé directement de base de données locale
AS
BEGIN
SET
NOCOUNT ON
--
BEGIN
TRY
DECLARE
@IDTrace INT
,
@IDTraceToStop INT
,
@cheminFichierTraceToStop NVARCHAR
(
256
)
,
@timestampFichierTrace NCHAR
(
15
)
,
@maxFileSize BIGINT
,
@errMsg NVARCHAR
(
2047
)
,
@DOS VARCHAR
(
255
)
-- Vérifie que le chemin du fichier est :
-- - soit un fichier d'un dossier local
-- - soit un fichier d'un partage réseau
IF
(
@_cheminFichierTrace NOT
LIKE
'_:\%'
-- Répertoire local
AND
@_cheminFichierTrace NOT
LIKE
'\\%\%'
-- Chemin UNC
)
BEGIN
RAISERROR(
'Chemin de fichier de trace incorrect ("C:\monRepertoire\maTrace.trc" ou "\\monServeur\monRepertoirePartagé\monRepertoire\maTrace.trc"'
, 16
, 1
)
END
-----------------------------------------
-- Gestion des traces précédemment créées
-----------------------------------------
-- Recherche s'il existe une trace de même nom de fichier (mais avec un "timestamp" différent)
-- Arrête cette trace le cas échéant
SELECT
@IDTraceToStop =
id,
@cheminFichierTraceToStop =
path
FROM
sys.traces
WHERE
path LIKE
'%'
+
@_cheminFichierTrace +
'%'
IF
@IDTraceToStop IS
NOT
NULL
BEGIN
-- >>>>> ATTENTION ceci ne supprime pas le fichier de trace
DECLARE
@codeRetourArretTrace TINYINT
-- Arrête la trace
EXEC
@codeRetourArretTrace =
sys.sp_trace_setstatus @IDTraceToStop, 0
IF
@codeRetourArretTrace =
0
BEGIN
-- Ferme la trace et supprime sa définition du serveur.
EXEC
@codeRetourArretTrace =
sys.sp_trace_setstatus @IDTraceToStop, 2
END
ELSE
BEGIN
SET
@errMsg =
CASE
@codeRetourArretTrace
WHEN
1
THEN
'Erreur inconnue'
WHEN
8
THEN
'L''état spécifié n''est pas valide'
WHEN
9
THEN
'Le descripteur de trace spécifié n''est pas valide'
WHEN
13
THEN
'Mémoire insuffisante'
END
RAISERROR(
'Problème lors de l''arrêt de la trace %s : %s'
, 16
, 1
, @_cheminFichierTrace, @errMsg)
END
-- Intègre le fichier dans une table de trace, le cas échéant
IF
(
@codeRetourArretTrace =
0
AND
@_avecIntegration =
1
)
BEGIN
INSERT
INTO
dbo.maTabledeTrace
SELECT
*
FROM
sys.fn_trace_gettable(
@cheminFichierTraceToStop, NULL
)
-- Si l'intégration s'est bien passée, suppression du fichier de trace
IF
@@ERROR
=
0
BEGIN
SET
@DOS =
'DEL '
+
@cheminFichierTraceToStop
PRINT
@DOS
EXEC
master
.dbo.xp_cmdshell @DOS, NO_OUTPUT -- A remplacer par l'appel à une procédure stockée d'assembly
END
END
END
-- Supprime l'extension de fichier de trace
-- celle-ci est automatiquement ajoutée à la création de la trace
IF
RIGHT
(
@_cheminFichierTrace, 4
)
=
'.trc'
BEGIN
SELECT
@_cheminFichierTrace =
REPLACE
(
@_cheminFichierTrace, '.trc'
, ''
)
END
-- Calcule un "timestamp" pour le nom du fichier de trace (Format : YYYYMMDD_HHmmss)
SELECT
@timestampFichierTrace =
CONVERT
(
NCHAR
(
8
)
, GETDATE()
, 112
)
+
'_'
+
REPLACE
(
CONVERT
(
NVARCHAR
(
10
)
, GETDATE()
, 108
)
, ':'
, ''
)
,
@maxFileSize =
200
-- taille maximale du fichier de trace, en Mo
-- Concatène le nom du fichier de trace avec le "timestamp"
SET
@_cheminFichierTrace =
@_cheminFichierTrace +
@timestampFichierTrace
-----------------------
-- Création de la trace
-----------------------
-- Calcule l'heure d'arrêt de la trace
DECLARE
@heureArretTrace DATETIME
SELECT
@heureArretTrace =
DATEADD(
minute
, @_minutesTrace, GETDATE())
EXEC
sys.sp_trace_create
@IDTrace OUTPUT, -- nécessaire pour paramétrer la trace par la suite
0
, -- permet de spécifier quelques options. Voir la BOL.
@_cheminFichierTrace, -- l'extension .trc est automatiquement ajoutée
@maxFileSize,
@heureArretTrace,
NULL
-- nombre maximal de fichiers pour la même trace
-----------------------------
-- Attachement des événements
-----------------------------
-- Permet a posteriori de désactiver un événement
-- alors que la trace est toujours ne cours d'exécution
-- en passant 0 en dernier paramètre à sys.sp_trace_setevent
DECLARE
@actif BIT
SET
@actif =
1
-- Événement : Deadlock graph
EXEC
sys.sp_trace_setevent @IDTrace, 148
, 1
, @actif
EXEC
sys.sp_trace_setevent @IDTrace, 148
, 12
, @actif -- colonne SPID, obligatoire
EXEC
sys.sp_trace_setevent @IDTrace, 148
, 14
, @actif -- colonne StartTime
-- Evénement : Lock:Timeout (timeout> 0)
EXEC
sys.sp_trace_setevent @IDTrace, 189
, 1
, @actif -- colonne TextData
EXEC
sys.sp_trace_setevent @IDTrace, 189
, 12
, @actif -- colonne SPID, obligatoire
EXEC
sys.sp_trace_setevent @IDTrace, 189
, 13
, @actif -- colonne Duration
EXEC
sys.sp_trace_setevent @IDTrace, 189
, 14
, @actif -- colonne StartTime
-- Événement : RPC:Completed
EXEC
sys.sp_trace_setevent @IDTrace, 10
, 1
, @actif -- colonne TextData
EXEC
sys.sp_trace_setevent @IDTrace, 10
, 12
, @actif -- colonne SPID, obligatoire
EXEC
sys.sp_trace_setevent @IDTrace, 10
, 13
, @actif -- colonne Duration
EXEC
sys.sp_trace_setevent @IDTrace, 10
, 14
, @actif -- colonne StartTime
EXEC
sys.sp_trace_setevent @IDTrace, 10
, 16
, @actif -- colonne Reads
EXEC
sys.sp_trace_setevent @IDTrace, 10
, 17
, @actif -- colonne Writes
-----------------------------------
-- Ajout des filtres aux événements
-----------------------------------
-- Le type de la valeur à filtrer doit correspondre à celui de la colonne
-- pour trouver le type de la colonne, voir plus loin
-- Ici, le type de la colonne "Reads" est BIGINT
DECLARE
@bigintFilter BIGINT
SET
@bigintFilter =
100
EXEC
sys.sp_trace_setfilter
@IDTrace, -- identifiant de la trace
16
, -- colonne de la trace
0
, -- AND : 0 | 1 : OR
4
, -- >=
@bigintFilter -- valeur du filtre
------------------------
-- Démarrage de la trace
------------------------
EXEC
sys.sp_trace_setstatus @IDTrace, 1
-------------------------------------------------
-- Affiche éventuellement les détails de la trace
-------------------------------------------------
IF
@_avecDetails =
1
BEGIN
SELECT
id,
CASE
status
WHEN
0
THEN
'Arrêtée'
WHEN
1
THEN
'Démarrée'
END
AS
Statut,
path AS
Emplacement,
stop_time AS
DateHeureArret
FROM
sys.traces
WHERE
id =
@IDTrace
END
END
TRY
BEGIN
CATCH
IF
EXISTS
(
SELECT
*
FROM
sys.traces
WHERE
id =
@IDTrace
)
BEGIN
DECLARE
@arretTraceOK BIT
=
0
BEGIN
TRY
-- >>>>> ATTENTION ceci ne supprime pas le fichier de trace
EXEC
sys.sp_trace_setstatus @IDTrace, 0
-- Arrête la trace
EXEC
sys.sp_trace_setstatus @IDTrace, 2
-- Ferme la trace et supprime sa définition du serveur.
SET
@arretTraceOK =
1
END
TRY
BEGIN
CATCH
RAISERROR(
'Erreur à l''arrêt de la trace %s'
,16
, 1
, @_cheminFichierTrace)
END
CATCH
IF
@arretTraceOK =
1
BEGIN
-- Suppression du fichier de trace éventuel
SET
@DOS =
'DEL '
+
@_cheminFichierTrace
EXEC
master
.dbo.xp_cmdshell @DOS, NO_OUTPUT
PRINT
'Arrêt de la trace '
+
@_cheminFichierTrace +
'effectué '
END
END
-- Re-lève l'exception
SET
@errMsg =
ERROR_MESSAGE()
RAISERROR(
@errMsg, 16
, 1
)
END
CATCH
END
V-A. Script de création de la table d'intégration des traces▲
USE
maBD
GO
CREATE
TABLE
dbo.maTableDeTrace
(
TextData ntext
NULL
,
BinaryData image
NULL
,
DatabaseID int
NULL
,
TransactionID bigint NULL
,
LineNumber int
NULL
,
NTUserName nvarchar
(
256
) NULL
,
NTDomainName nvarchar
(
256
) NULL
,
HostName nvarchar
(
256
) NULL
,
ClientProcessID int
NULL
,
ApplicationName nvarchar
(
256
) NULL
,
LoginName nvarchar
(
256
) NULL
,
SPID int
NULL
,
Duration bigint NULL
,
StartTime datetime
NULL
,
EndTime datetime
NULL
,
Reads bigint NULL
,
Writes bigint NULL
,
CPU int
NULL
,
Permissions
bigint NULL
,
Severity int
NULL
,
EventSubClass int
NULL
,
ObjectID int
NULL
,
Success int
NULL
,
IndexID int
NULL
,
IntegerData int
NULL
,
ServerName nvarchar
(
256
) NULL
,
EventClass int
NULL
,
ObjectType int
NULL
,
NestLevel int
NULL
,
State int
NULL
,
Error int
NULL
,
Mode int
NULL
,
Handle int
NULL
,
ObjectName nvarchar
(
256
) NULL
,
DatabaseName nvarchar
(
256
) NULL
,
FileName nvarchar
(
256
) NULL
,
OwnerName nvarchar
(
256
) NULL
,
RoleName nvarchar
(
256
) NULL
,
TargetUserName nvarchar
(
256
) NULL
,
DBUserName nvarchar
(
256
) NULL
,
LoginSid image
NULL
,
TargetLoginName nvarchar
(
256
) NULL
,
TargetLoginSid image
NULL
,
ColumnPermissions int
NULL
,
LinkedServerName nvarchar
(
256
) NULL
,
ProviderName nvarchar
(
256
) NULL
,
MethodName nvarchar
(
256
) NULL
,
RowCounts bigint NULL
,
RequestID int
NULL
,
XactSequence bigint NULL
,
EventSequence bigint NULL
,
BigintData1 bigint NULL
,
BigintData2 bigint NULL
,
GUID uniqueidentifier
NULL
,
IntegerData2 int
NULL
,
ObjectID2 bigint NULL
,
Type int
NULL
,
OwnerID int
NULL
,
ParentName nvarchar
(
256
) NULL
,
IsSystem int
NULL
,
Offset int
NULL
,
SourceDatabaseID int
NULL
,
SqlHandle image
NULL
,
SessionLoginName nvarchar
(
256
) NULL
,
PlanHandle image
NULL
,
GroupID int
NULL
)
V-B. Structure de la table de trace▲
Nom de la colonne |
Type de données |
Nom de la colonne |
Type de données |
ApplicationName |
nvarchar |
NTUserName |
nvarchar |
BigintData1 |
bigint |
ObjectID |
int |
BigintData2 |
bigint |
ObjectID2 |
bigint |
BinaryData |
image |
ObjectName |
nvarchar |
ClientProcessID |
int |
ObjectType |
int |
ColumnPermissions |
int |
Offset |
int |
CPU |
int |
OwnerID |
int |
DatabaseID |
int |
OwnerName |
nvarchar |
DatabaseName |
nvarchar |
ParentName |
nvarchar |
DBUserName |
nvarchar |
Permissions |
bigint |
Duration |
bigint |
PlanHandle |
image |
EndTime |
datetime |
ProviderName |
nvarchar |
Error |
int |
Reads |
bigint |
EventClass |
int |
RequestID |
int |
EventSequence |
bigint |
RoleName |
nvarchar |
EventSubClass |
int |
RowCounts |
bigint |
FileName |
nvarchar |
ServerName |
nvarchar |
GroupID |
int |
SessionLoginName |
nvarchar |
GUID |
uniqueidentifier |
Severity |
int |
Handle |
int |
SourceDatabaseID |
int |
HostName |
nvarchar |
SPID |
int |
IndexID |
int |
SqlHandle |
image |
IntegerData |
int |
StartTime |
datetime |
IntegerData2 |
int |
State |
int |
IsSystem |
int |
Success |
int |
LineNumber |
int |
TargetLoginName |
nvarchar |
LinkedServerName |
nvarchar |
TargetLoginSid |
image |
LoginName |
nvarchar |
TargetUserName |
nvarchar |
LoginSid |
image |
TextData |
ntext |
MethodName |
nvarchar |
TransactionID |
bigint |
Mode |
int |
Type |
int |
NestLevel |
int |
Writes |
bigint |
NTDomainName |
nvarchar |
XactSequence |
bigint |
V-C. Script d'activation de la procédure stockée système étendue xp_cmdshell▲
Même si son utilisation n'est pas recommandée pour des raisons évidentes de sécurité, voici un script qui permet d'activer l'utilisation de la procédure stockée système étendue xp_cmdshell :
IF
EXISTS
(
SELECT
*
FROM
sys.configurations
WHERE
name
=
'xp_cmdshell'
AND
value_in_use =
0
)
BEGIN
EXEC
sys.sp_configure 'show advanced options'
, '1'
RECONFIGURE
EXEC
sys.sp_configure 'xp_cmdshell'
, '1'
RECONFIGURE
EXEC
sys.sp_configure 'show advanced options'
, '0'
RECONFIGURE
END
VI. Création du job de création des fichiers de trace▲
Retournons sous SQL Server Management Studio pour créer le travail qui permettra d'exécuter la procédure stockée de création des traces :
Ajoutons quelques commentaires :
Passons à l'ajout d'une nouvelle étape :
Il faut que la base de données soit la même que celle qui héberge la table dbo.matableDeTrace.
Ici nous créerons un fichier de trace par heure :
Passons à la planification du job :
Il faut veiller à spécifier la même fréquence que la périodicité de renouvellement des fichiers de trace (paramètre @_minutesTrace)
Validons la planification par OK :
Un nouveau clic sur le bouton OK entraîne la création du job :
VII. Exploitation des données de trace▲
Nous trouvons le fichier de trace courant :
Si nous interrogeons directement la table dbo.maTableDeTrace, nous verrons qu'il y a des nombreuses colonnes sans valeur (NULL) : en effet, nous avons utilisé 6 colonnes pour notre trace, mais le fichier de trace en contient un total de 66.
Voici donc un petit script qui permet une consultation facile des données contenues dans la table d'intégration de la trace, à l'aide de la fonction de table système fn_trace_geteventinfo, qui donne la liste des colonnes utilisées par la trace :
DECLARE
@req
VARCHAR
(
256
) SET
@req
=
'SELECT '
;WITH
CTE_COLONNES_TRACE AS
(
SELECT
DISTINCT
columnid
FROM
sys.fn_trace_geteventinfo
(
2
)
)
SELECT
@req
=
@req
+
C.name
+
','
FROM
sys.tables AS
T
JOIN
sys.columns AS
C
ON
T.object_id
=
C.object_id
JOIN
CTE_COLONNES_TRACE AS
CCT
ON
C.column_id =
CCT.columnid
WHERE
T.name
=
'maTableDeTrace'
SET
@req
=
LEFT
(
@req
, LEN
(
@req
) -
1
) +
' FROM dbo.maTableDeTrace'
EXEC
(
@req
)
VIII. Conclusion▲
SQL Server fournit un ensemble de procédures stockées et de fonctions système qu'il est simple d'intégrer dans une procédure stockée utilisateur pour gérer des fichiers de trace. Il est également possible d'en conserver plusieurs sans pour autant les intégrer en base de données, et de combiner l'utilisation de ces modules consacrés aux traces avec un job SQL Server.
La génération d'un script de trace est une opération simple depuis l'interface du profiler SQL Server. Il est donc nécessaire de connaitre son fonctionnement afin de pouvoir analyser l'utilisation et le comportement d'une base de données SQL Server].
IX. Remerciements▲
- David Barbarin pour la relecture de cet article.
- Fleur-Anne Blain qui m'a supporté pour la publication.
- Toute l'équipe de Développez.