SELECT '[' + TRIM('  VFDRBM ') + ']'  as Result

1
2
3
Result
---------
[VFDRBM]

1
2
3
4
5
6
7
8
9
SELECT '[' + TRIM(' 0123456789' FROM Code) + ']' as Result
FROM
(
    VALUES
        (' 145ABCDF42') ,
	('8179527EGH223  '),
        ('1224996TRGCV852'),
	(' 07745GHCWQM 12 9 0 ')
) AS Z (Code);

1
2
3
4
5
6
Result
-------------
[ABCDF]
[EGH]
[TRGCV]
[GHCWQM]

1
2
3
4
5
6
7
DECLARE @IsTrusted BIT;
 
SET @IsTrusted = 'True';
 
SET @IsTrusted = ~ @IsTrusted;
 
PRINT IIF(@IsTrusted=1, 'True', 'False');

False

BEGIN;

1
2
BEGIN -- avec ou sans point-virgule !
END;

1
2
3
4
5
6
 
BEGIN
	 {
	sql_statement | statement_block
	 }
END

1
2
3
4
IF @@TRANCOUNT = 0
BEGIN
...
END;

1
2
3
4
5
6
BEGIN TRAN;
BEGIN TRANSACTION;
ROLLBACK;
ROLLBACK TRANSACTION;
 
-- Etc.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
BEGIN
 
IF
 
ELSE
 
BEGIN TRY
 
END TRY
 
BEGIN CATCH
 
WHILE
 
GO

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
BEGIN TRAN;
BEGIN TRAN Transaction_Name;
BEGIN TRAN Transaction_Name WITH MARK Description;
 
BEGIN TRANSACTION;
BEGIN TRANSACTION Transaction_Name;
BEGIN TRANSACTION Transaction_Name WITH MARK Description;
 
COMMIT TRAN;
COMMIT TRAN Transaction_Name;
 
COMMIT TRANSACTION;
COMMIT TRANSACTION Transaction_Name;
 
END CATCH;
 
END;
 
ROLLBACK;
ROLLBACK TRAN;
ROLLBACK TRAN Transaction_Name;
ROLLBACK TRAN SavePoint_Name;
 
ROLLBACK TRANSACTION;
ROLLBACK TRANSACTION Transaction_Name;
 
SAVE TRAN SavePoint_Name;
SAVE TRANSACTION SavePoint_Name;
SAVE TRANSACTION SavePoint_Name;
 
USE Database_Name;

1
2
3
4
5
6
7
8
;WITH CTE_Client AS
 (SELECT Nom
 FROM dbo.Client
	WHERE ...
	)
SELECT Nom
FROM CTE_Client
WHERE ...

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
-- J'utilise la base master, mais vous pouvez utiliser une autre base de votre choix
USE master
GO
IF NOT EXISTS ( SELECT p.*
				FROM sys.procedures AS p WITH (nolock)
				INNER JOIN sys.schemas AS s WITH (nolock)
				  ON p.schema_id = p.schema_id
				WHERE s.name = N'dbo' AND P.name = N'uspListeFichiersDataOuLogOrphelinsDeBasesDeDonnees' AND P.type IN (N'P', N'PC')
			  )
BEGIN
	EXEC dbo.sp_executesql
		 @statement = N'CREATE PROCEDURE dbo.uspListeFichiersDataOuLogOrphelinsDeBasesDeDonnees
AS
BEGIN
-- !!! "Stub" doit être implémenté !!!
SET NOCOUNT ON;
END; ';
END;
GO
 
-- ----------------------------------------------------------------------------
-- Procédure          : dbo.uspListeFichiersDataOuLogOrphelinsDeBasesDeDonnees
-- Créateur           : Hamid MIRA
-- Date de création   : 28/12/2016
-- Objet              : Ce script permet de lister les fichiers de données (.mdf, .ndf, etc.)
--                      ou les fichiers de journaux de transactions (.ldf) orphelins, c.à.d. des fichiers (.mdf, .ndf, ldf , etc.)
--                      qui ne sont rattachés à aucune base de données du Serveur.
-- Paramètres :
--   @pi_DefaultDirectoryData : Le répertoire explicite des fichiers de données (.mdf, ndf)  Exemple : N'C:\SQL\Data'
--                              Transmettez NULL pour utiliser le répertoire par défaut des fichiers de données défini au niveau de l'instance
--   @pi_DefaultDirectoryLog  : Le répertoire explicite des fichiers des journaux de transaction  (.ldf) )  Exemple : 'C:\SQL\Log'
--                              Transmettez NULL pour utiliser le répertoire par défaut des fichiers des journaux de transactions défini au niveau de l'instance
-- Exemple d'utilisation :
--   EXEC dbo.uspListeFichiersDataOuLogOrphelinsDeBasesDeDonnees NULL, NULL
--   EXEC dbo.uspListeFichiersDataOuLogOrphelinsDeBasesDeDonnees N'C:\SQL\Data', N'C:\SQL\Log'
-- ----------------------------------------------------------------------------
ALTER PROCEDURE dbo.uspListeFichiersDataOuLogOrphelinsDeBasesDeDonnees
(@pi_DefaultDirectoryData nvarchar(512) = NULL,
 @pi_DefaultDirectoryLog  nvarchar(512) = NULL  )
AS
BEGIN
	SET NOCOUNT ON
	DECLARE @MasterDirectoryData nvarchar(512),
			@MasterDirectoryLog nvarchar(512), 
			@VersionMajor tinyint;
 
	SET @VersionMajor = CAST(LEFT(CAST(SERVERPROPERTY('ProductVersion') AS nvarchar(128)), CHARINDEX('.',CAST(SERVERPROPERTY('ProductVersion') AS nvarchar(128))) - 1) AS INT);
	PRINT '@VersionMajor=['+CAST(ISNULL(@VersionMajor,-1) AS VARCHAR(2))+']';
 
	IF @pi_DefaultDirectoryData IS NULL
	BEGIN
		-- Version SQL Server 2008 R2 (incluse) et versions antérieures
		IF @VersionMajor <= 10
		BEGIN
			EXEC master.dbo.xp_instance_regread N'HKEY_LOCAL_MACHINE', N'Software\Microsoft\MSSQLServer\MSSQLServer', N'DefaultData', @pi_DefaultDirectoryData output
		END
		ELSE
		BEGIN
			-- Version SQL Server 2012 (incluse) et versions supérieures
			SET @pi_DefaultDirectoryData =	CAST(SERVERPROPERTY('INSTANCEDEFAULTDATAPATH') AS nvarchar(512));
		END;
		IF @pi_DefaultDirectoryData IS NULL
		BEGIN
			EXEC master.dbo.xp_instance_regread N'HKEY_LOCAL_MACHINE', N'Software\Microsoft\MSSQLServer\MSSQLServer\Parameters', N'SqlArg0', @MasterDirectoryData output
			SET @MasterDirectoryData = SUBSTRING(@MasterDirectoryData, 3, 255)
			SET @MasterDirectoryData = SUBSTRING(@MasterDirectoryData, 1, LEN(@MasterDirectoryData) - CHARINDEX('\', REVERSE(@MasterDirectoryData)))
			SET @pi_DefaultDirectoryData = @MasterDirectoryData;
		END;
	END;
 
	IF @pi_DefaultDirectoryLog IS NULL
	BEGIN
		-- Version SQL Server 2008 R2 (incluse) et versions antérieures
		IF @VersionMajor <= 10
		BEGIN
			EXEC master.dbo.xp_instance_regread N'HKEY_LOCAL_MACHINE', N'Software\Microsoft\MSSQLServer\MSSQLServer', N'DefaultLog', @pi_DefaultDirectoryLog output
		END
		ELSE
		BEGIN
			-- Version SQL Server 2012 (incluse) et versions supérieures
			SET @pi_DefaultDirectoryLog =  CAST( SERVERPROPERTY('INSTANCEDEFAULTLOGPATH') AS nvarchar(512));
		END;
 
		IF @pi_DefaultDirectoryLog IS NULL
		BEGIN
			EXEC master.dbo.xp_instance_regread N'HKEY_LOCAL_MACHINE', N'Software\Microsoft\MSSQLServer\MSSQLServer\Parameters', N'SqlArg2', @MasterDirectoryLog output
			SET @MasterDirectoryLog = SUBSTRING(@MasterDirectoryLog, 3, 255)
			SET @MasterDirectoryLog = SUBSTRING(@MasterDirectoryLog, 1, LEN(@MasterDirectoryLog) - CHARINDEX('\', REVERSE(@MasterDirectoryLog)))
			SET @pi_DefaultDirectoryLog = @MasterDirectoryLog;
		END;
	END;
 
	-- Recadrage éventuel de la valeur @pi_DefaultDirectoryData
	SET @pi_DefaultDirectoryData = RTRIM(LTRIM((@pi_DefaultDirectoryData)));
	SET @pi_DefaultDirectoryData  = LEFT(@pi_DefaultDirectoryData, 2) + REPLACE (RIGHT(@pi_DefaultDirectoryData, len(@pi_DefaultDirectoryData) -2), '\\', '\');
	IF RIGHT(@pi_DefaultDirectoryData, 1) <> '\'
		SET @pi_DefaultDirectoryData = @pi_DefaultDirectoryData + '\';
 
    -- Recadrage éventuel de la valur @pi_DefaultDirectoryLog
	SET @pi_DefaultDirectoryLog = RTRIM(LTRIM(( @pi_DefaultDirectoryLog)));
	SET @pi_DefaultDirectoryLog =  LEFT(@pi_DefaultDirectoryLog, 2) + REPLACE (RIGHT(@pi_DefaultDirectoryLog, len(@pi_DefaultDirectoryLog) -2), '\\', '\');
	IF RIGHT( @pi_DefaultDirectoryLog, 1) <> '\'
		SET @pi_DefaultDirectoryLog = @pi_DefaultDirectoryLog + '\';
 
	PRINT '@pi_DefaultDirectoryData=[' +ISNULL(@pi_DefaultDirectoryData, '{NULL}') +']';
	PRINT '@pi_DefaultDirectoryLog=[' +ISNULL( @pi_DefaultDirectoryLog, '{NULL}') +']';
 
	IF OBJECT_ID('tempdb.dbo.#DirTreeData') IS NOT NULL
		DROP TABLE #DirTreeData
	IF OBJECT_ID('tempdb.dbo.#DirTreeLog') IS NOT NULL
		DROP TABLE #DirTreeLog
 
	-- -----------------------------------------
	CREATE TABLE #DirTreeData(
		Id int identity(1,1) PRIMARY KEY CLUSTERED,
		SubDirectory nvarchar(255),
		Depth smallint,
		FileFlag bit,
		ParentDirectoryID int
		);
	CREATE TABLE #DirTreeLog(
		Id int identity(1,1) PRIMARY KEY CLUSTERED,
		SubDirectory nvarchar(255),
		Depth smallint,
		FileFlag bit,
		ParentDirectoryID int
		);
 
	INSERT INTO #DirTreeData (SubDirectory, Depth, FileFlag)
	EXEC master..xp_dirtree @pi_DefaultDirectoryData, 1, 1; -- Profondeur : 1 (premier niveau), Lister également les fichiers : 1  (Oui)
 
	UPDATE #DirTreeData
		SET SubDirectory = @pi_DefaultDirectoryData + LTRIM(RTRIM(SubDirectory));
 
	IF ISNULL(@pi_DefaultDirectoryLog, '') <> ISNULL(@pi_DefaultDirectoryData, '')
	BEGIN
		INSERT INTO #DirTreeLog(SubDirectory, Depth, FileFlag)
		EXEC master..xp_dirtree  @pi_DefaultDirectoryLog, 1, 1; -- Profondeur : 1 (premier niveau), lister également les fichiers : 1  (Oui)
		UPDATE #DirTreeLog
			SET SubDirectory = @pi_DefaultDirectoryLog + LTRIM(RTRIM(SubDirectory));
	END
 
	;WITH smf AS
	  (SELECT LEFT(RTRIM(LTRIM(physical_name)), 2) + REPLACE (RIGHT(RTRIM(LTRIM(physical_name)), len(RTRIM(LTRIM(physical_name))) -2), '\\', '\') AS physical_name_fmt
       FROM master.sys.master_files WITH (NOLOCK) )
 
	SELECT SubDirectory
	FROM #DirTreeData  dtd
	LEFT OUTER JOIN smf
	   ON smf.physical_name_fmt = dtd.SubDirectory
	WHERE dtd.FileFlag = 1            -- Fichiers uniquement (ignorer les répertoires)
	AND smf.physical_name_fmt IS NULL -- Pas de correspondance du fichier SubDirectory dans master.sys.master_files
	UNION ALL
	SELECT SubDirectory
	FROM #DirTreeLog dtl
	LEFT OUTER JOIN smf
	   ON smf.physical_name_fmt = dtl.SubDirectory
	WHERE dtl.FileFlag = 1            -- Fichier uniquement (ignorer les répertoires)
	AND smf.physical_name_fmt IS NULL --  Pas de correspondance du fichier SubDirectory dans master.sys.master_files
	ORDER BY SubDirectory; 
 
	-- Suppression des tables temporaires 
	IF OBJECT_ID('tempdb.dbo.#DirTreeData') IS NOT NULL
		DROP TABLE #DirTreeData
	IF OBJECT_ID('tempdb.dbo.#DirTreeLog') IS NOT NULL
		DROP TABLE #DirTreeLog
END;
GO

EXEC dbo.uspListeFichiersDataOuLogOrphelinsDeBasesDeDonnees NULL, NULL

1
2
3
4
SubDirectory
----------------------------------------------------------------------------------------
C:\Program Files\Microsoft SQL Server\MSSQL12.MSSQLSERVER2014\MSSQL\DATA\DEMO001_Data.mdf
C:\Program Files\Microsoft SQL Server\MSSQL12.MSSQLSERVER2014\MSSQL\DATA\DEMO001_Log.ldf

1
2
3
4
EXEC sp_configure 'remote admin connections', 1;
GO
RECONFIGURE
GO

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
c:\Windows\system32>sqlcmd -S SSRV005\SQL2012 -E -A
1> SELECT CASE
2>      WHEN exs.session_id= @@SPID THEN 'C''est moi-même ! '
3>      ELSE ''
4>     END + coalesce(exs.login_name,'Je ne sais qui ?') as ConnexionDAC
5> , exs.session_id
6> , exs.login_time
7> , exs.status
8> , exs.original_login_name
9> from sys.endpoints as edp with (nolock)
10> join sys.dm_exec_sessions exs with (nolock)
11> on edp.endpoint_id = exs.endpoint_id
12> where edp.name='Dedicated Admin Connection';
13> go
ConnexionDAC
                                 session_id log
in_time       status             original_login_name


--------------------------------------------------------------------------------
----------------------------------------------------------------- ---------- ---
-------------------- ------------------------------ ----------------------------
--------------------------------------------------------------------------------
--------------------
C'est moi-même ! FriedrichNietzsche
                                     51 201
6-07-20 10:08:31.003 running            FriedrichNietzsche



(1 lignes affectées)
1> kill 54;
2> go
1> exit
c:\Windows\system32>

1
2
3
4
5
6
7
8
9
10
11
12
SELECT CASE 
     WHEN exs.session_id= @@SPID THEN 'C''est moi-même ! '
     ELSE '' 
	  END + coalesce(exs.login_name,'Je ne sais qui ?') as ConnexionDAC
, exs.session_id
, exs.login_time
, exs.status
, exs.original_login_name 
from sys.endpoints as edp with (nolock) 
join sys.dm_exec_sessions exs with (nolock) 
on edp.endpoint_id = exs.endpoint_id
where edp.name='Dedicated Admin Connection'

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
IF NOT EXISTS (SELECT *
           FROM dbo.sysobjects
           WHERE id = object_id(N'dbo.FC_U_IsValidSiret')
           AND xtype IN (N'FN', N'IF', N'TF')
           )
   EXEC   sp_executesql N'CREATE FUNCTION dbo.FC_U_IsValidSiret
( @pi_cSIRET VARCHAR(14) )
RETURNS BIT
AS
BEGIN 
RETURN NULL; 
END; ' 
GO
 
 
ALTER  FUNCTION dbo.FC_U_IsValidSiret
( @pi_cSIRET VARCHAR(14) )
RETURNS BIT
AS
/* ===========================================================================*/
/*                          dbo.FC_U_IsValidSiret                             */
/* ===========================================================================*/
/* Société            :                                                       */
/* Créateur           : Hamid MIRA                                            */
/* Date de création   : 17/01/2016                                            */
/* Version associée   : 1                                                     */
/* Objet              :                                                       */
/*   - Cette fonction scalaire SQL Server, permet de vérifier si un code SIREN (9 chiffes) */
/*   ou SIRET (14 chiffres) est valide ou non.                                             */
/*   - Cette fonction s'inspire fortement de l'implémentation en T-SQL de l'algorithme     */
/*     de Luhn réalisée par SQLPro. voir lien ci-dessous pour plus de détails :            */
/*     http://blog.developpez.com/sqlpro/p7829/langage-sql-norme/controle_de_coherence_par_algorithme_de_ */
/*   - Cette fonction tient compte également de l'algorithme particulier de La Poste */
/*     depuis qu'elle a changé de statut et qu'elle est devenue une société anonyme */
/*     dotée d'un seul SIREN : 356000000 et des établissement SIRET : 356000000xxxxx */
/*     Ce nouvel algorithme spécifique à La Poste permet d'immatriculer jusqu'à 18000 établissements environ */
/*     Pour plus de détails : http://blog.pagesd.info/post/2012/09/05/verifier-numero-siret-la-poste */
/* Appelée par        :                                                              */
/*                                                                                   */
/* Paramètres : @pi_cSIRET VARCHAR(14)  Code SIREN ou SIRET à vérifier la validité   */
/*				Valeur de retour de la fonction (BIT) :                              */
/*                   1 si le code SIREN ou SIRET est un code Valide                  */
/*                   0 si le code SIREN ou SIRET n'est pas un code valide            */
/* ===========================================================================*/
BEGIN
	-- Valeurs limites
	IF @pi_cSIRET IS NULL OR @pi_cSIRET = ''
	BEGIN
		RETURN NULL;
	END;
	DECLARE
	  @iLengthSiret SMALLINT;
 
	SET @iLengthSiret = LEN(@pi_cSIRET);
	IF @iLengthSiret <> 9 AND @iLengthSiret <> 14
	BEGIN
		RETURN 0;  -- c.à.d. False
	END;
 
	DECLARE
	  @I              TINYINT
	, @cChiffre       CHAR(1)
	, @iSumNombres    TINYINT
	, @iRang          TINYINT
	, @bIsSiretLaPoste BIT;
 
	DECLARE
	  @TableChiffre TABLE
	( iRang   SMALLINT
	, iNombre SMALLINT );
 
	SET @bIsSiretLaPoste = CASE
							  WHEN LEFT(@pi_cSIRET, 9) = '356000000' AND @iLengthSiret = 14
								THEN 1
							  ELSE 0
						  END;
	SET @I = @iLengthSiret;
	SET @iRang = 0;
	WHILE @I >= 1
	BEGIN
		SET @iRang = @iRang+1;
		SET @cChiffre = SUBSTRING(@pi_cSIRET, @I, 1);
 
		-- Vérification que la chaine ne contient que des chiffres
		IF @cChiffre NOT BETWEEN '0' AND '9'
		BEGIN
			RETURN 0;
		END;
		ELSE
		BEGIN
			INSERT INTO @TableChiffre(
			   iRang
			 , iNombre)
			VALUES
			(
			  @iRang
			, CAST(@cChiffre AS SMALLINT)
			);
		END;
		SET @I = @I-1;
	END;
	--  Cas général (autre que La Poste)
	IF @bIsSiretLaPoste = 0
	BEGIN
		-- Multiplication par deux des chiffres de rang paire
		UPDATE @TableChiffre
		  SET
			  iNombre = iNombre*2
		WHERE
		   iRang%2 = 0;
		-- Addition des chiffres pour les nombres strictement supérieur à 9
		UPDATE @TableChiffre
		  SET
			  iNombre = iNombre-9
		WHERE
		   iNombre > 9;
	END;
	-- Calcul du total des nombres de la table @TableChiffre
	SET @iSumNombres = ( SELECT
							SUM(iNombre)
						 FROM @TableChiffre
					   );
	RETURN CASE
		   --  Cas général (autre que La Poste)
			   WHEN @bIsSiretLaPoste = 0
				 THEN CASE
						  WHEN @iSumNombres%10 = 0
							THEN 1
						  ELSE 0
					  END
			   ELSE
		   -- Case particulier de La Poste
		   CASE
			   WHEN @iSumNombres%5 = 0
				 THEN 1
			   ELSE 0
		   END
		   END;
END;
GO

1
2
3
4
5
6
7
8
9
SELECT  '73282932000074' AS SIRET, dbo.FC_U_IsValidSiret('73282932000074') AS IsValid -- Code valide 
UNION  ALL 
SELECT '732829320',  dbo.FC_U_IsValidSiret('732829320') -- Code valide 
UNION ALL 
SELECT 	'356000000',  dbo.FC_U_IsValidSiret('356000000')  -- Code valide : La Poste 
UNION ALL 
SELECT 	'35600000066180',  dbo.FC_U_IsValidSiret('35600000066180')  -- Code valide : Un établissement de La Poste  
UNION ALL 
SELECT '39244740402112',  dbo.FC_U_IsValidSiret('39244740402112') -- Code invalide !

1
2
3
4
5
6
SIRET	IsValid
73282932000074	1
732829320	1
356000000	1
35600000066180	1
39244740402112	0

1
2
3
4
5
6
CREATE TABLE [dbo].[Temp01](  
      Id       INT NOT NULL,   
      Libelle  VARCHAR(50) NULL  
)   
ON [PRIMARY];   
GO

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
DROP PROCEDURE dbo.PS_U_TEST_TRY_CATCH_XACT_ABORT;
GO
CREATE PROCEDURE dbo.PS_U_TEST_TRY_CATCH_XACT_ABORT
AS
BEGIN
  SET NOCOUNT ON;
 
   SET XACT_ABORT ON;    -- (1) On fait notre premier test avec  XACT_ABORT ON
  -- SET XACT_ABORT OFF;  -- (2) Faites également un test avec SET XACT_ABORT OFF, 
                          --     vous verrez les différences
                          --     en terme de résultat et vous comprendrez mieux 
                          --     la subtilité de cette option (XACT_ABORT) !
  DECLARE @Var1 FLOAT;
 
  BEGIN TRY
        BEGIN TRAN;
           INSERT INTO dbo.Temp01
               (Id, Libelle)
           VALUES
               (1, 'Ecartez la vanité, elle gêne l''orgueil'); -- (Citation de L. Pauwels !)
 
           SET @Var1 = 2.5/0;  -- (3) On effectue volontairement une division par zéro 
                               --     pour générer une exception
        COMMIT TRAN;
        PRINT 'COMMIT BLOC TRY ..'  -- (4) On ne passe jamais ici, que l'option 
                                    --     SET XACT_ABORT soit à ON ou à OFF
  END TRY
  BEGIN CATCH
        PRINT  'ErrNumber ' + CONVERT(varchar(50), ERROR_NUMBER()) +
               ', ErrSeverity ' + CONVERT(varchar(5), ERROR_SEVERITY()) +
               ', ErrState ' + CONVERT(varchar(5), ERROR_STATE()) +
               ', ErrProcedure ' + ISNULL(ERROR_PROCEDURE(), '-') +
               ', ErrLine ' + CONVERT(varchar(5), ERROR_LINE()) ;
         PRINT 'ErrMessage ' + ERROR_MESSAGE();
 
        IF (XACT_STATE() = -1)
          BEGIN
             -- Il existe une transaction active mais une erreur a entraîné le classement
             -- de la transaction comme non validable (uncommittable transaction).
 
             -- A ce niveau, il est fortement recommandé de faire un ROLLBACK.
             -- En effet, à ce stade toute instruction Insert, Update, Delete ne peut être 
             -- exécutée avec succès puisqu'elle serait exécutée dans le cadre de la 
             -- transaction en cours déjà ouverte et considérée non validable !
 
             -- Ne pas faire un*ROLLBACK à ce stade générerait assurément d'autres erreurs 
              -- par la suite, très difficiles à cerner. 
              PRINT 'XACT_STATE() = -1  --> ROLLBACK' ;
              ROLLBACK TRAN;
	      PRINT 'ROLLBACK, fortement recommandé, effectué' ;
          END;
        ELSE IF (XACT_STATE() = 1)
         BEGIN
            -- Il existe une transaction active. la validation ou l’annulation de la
            -- transaction sont possibles. C'est à vous de voir.
            PRINT 'XACT_STATE() = 1 --> ROLLBACK OU COMMIT A vous de voir ...'
 
            -- Vous pouvez aussi, à ce niveau, si vous le jugez nécessaire, faire un COMMIT
            -- c'est à vous de voir selon les contraintes fonctionnelles de votre application
            -- Mais attention, il faut faire quelque chose (soit un COMMIT soit un ROLLBACK),
            -- ne rien faire à ce stade serait de nature à générer assurément d'autres 
            -- erreurs par la suite, très difficiles à cerner.
            ROLLBACK TRAN;   -- (5) On fait notre premier test avec  ROLLBACK TRAN                                                            
	   PRINT 'ROLLBACK effectué (le choix de faire un rollback a été délibéré) ' ; -- (5) On fait notre premier test avec  ROLLBACK TRAN  
            -- COMMIT TRAN; -- (6) On fait autre test avec COMMIT TRAN; 
	    -- PRINT 'COMMIT effectué (le choix de faire un commit a été délibéré) ' ; -- (6) On fait autre test avec COMMIT TRAN  
         END;
  END CATCH;
END;
GO

EXEC dbo.PS_U_TEST_TRY_CATCH_XACT_ABORT;

1
2
3
4
5
ErrNumber 8134, ErrSeverity 16, ErrState 1, ErrProcedure PS_U_TEST_TRY_CATCH_XACT_ABORT,  
ErrLine 20  
ErrMessage Division par zéro.  
XACT_STATE() = -1  -->  ROLLBACK  
ROLLBACK, fortement recommandé, effectué

SELECT * FROM dbo.Temp01

(Aucun enregistrement)

Truncate TABLE dbo.Temp01;

EXEC dbo.PS_U_TEST_TRY_CATCH_XACT_ABORT;

1
2
3
4
5
ErrNumber 8134, ErrSeverity 16, ErrState 1, ErrProcedure PS_U_TEST_TRY_CATCH_XACT_ABORT,   
ErrLine 20  
ErrMessage Division par zéro.  
XACT_STATE() = 1 -->  ROLLBACK OU COMMIT A vous de voir ... 
COMMIT effectué (le choix de faire un commit a été délibéré)

SELECT * FROM dbo.Temp01

1
2
Id Libelle  
1 Ecartez la vanité, elle gêne l'orgueil

1
2
3
4
5
  SELECT ... 
  FROM dbo.MaTable 
  WHERE Col1 = ... 
   AND  Col2 = ... 
   AND  Col3 = ...

1
2
3
WHERE Col1 = ... 
   AND Col2 = ... 
   AND  Col3 = ...

1
2
3
4
5
SELECT E.*
FROM Employe AS E
WHERE E.SituationMatrimoniale = 'C' -- Célibataire 
AND E.DateNaisance = '1985-06-21'
AND E.Sex = 'F' -- Féminin

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
SELECT A.* FROM 
( SELECT 'SituationMatrimoniale' as NomColonne, COUNT(DISTINCT E.SituationMatrimoniale) AS NombreValeursDistinctes,
COUNT(E.SituationMatrimoniale) AS NombreDeLignes,
(CAST(COUNT(DISTINCT E.SituationMatrimoniale) AS DECIMAL) / CAST(COUNT(E.SituationMatrimoniale) AS DECIMAL)) AS Selectivite,
(1.0/(COUNT(DISTINCT E.SituationMatrimoniale))) AS Densite
FROM dbo.Employe AS E
UNION ALL 
SELECT 'DateNaissance' as NomColonne, COUNT(DISTINCT E.DateNaissance) AS NombreValeursDistinctes,
COUNT(E.DateNaissance) AS NombreDeLignes,
(CAST(COUNT(DISTINCT E.DateNaissance) AS DECIMAL) / CAST(COUNT(E.DateNaissance) AS DECIMAL)) AS Selectivite,
(1.0/(COUNT(DISTINCT E.DateNaissance))) AS Densite
FROM dbo.Employe AS E
UNION ALL 
SELECT 'Sex' as NomColonne, COUNT(DISTINCT E.Sex) AS NombreValeursDistinctes,
COUNT(E.Sex) AS NombreDeLignes,
(CAST(COUNT(DISTINCT E.Sex) AS DECIMAL) / CAST(COUNT(E.Sex) AS DECIMAL)) AS Selectivite,
(1.0/(COUNT(DISTINCT E.Sex))) AS Densite
FROM dbo.Employe AS E
) A 
ORDER BY A.Selectivite DESC

1
2
CREATE INDEX IX_Employe_DateNaissance_SituationMatrimoniale_Sex ON
 dbo.Employe (DateNaissance, SituationMatrimoniale, Sex);

1
2
3
4
SELECT E.*
FROM Employe AS E
WHERE E.SituationMatrimoniale = 'C' -- Célibataire 
AND E.Sex = 'F' -- Féminin