Le Blog SQL Server d'ElSüket » T-SQL

Promotion sur les livres sur Microsoft Press Store

elsuket — Tue, 28 Jun 2016 22:04:59 +0000

Le livre T-SQL Fundamentals d’Itzik Ben-Gan, avec qui on a la sensation de réapprendre le T-SQL à chaque ouvrage, va bientôt arriver dans son troisième opus. Pour l’occasion, Microsoft offre jusqu’à 40% de remise avec le code PREORDER. Ceci est valable jusqu’au 31 Juillet 2016.

Bonne lecture !

Vérifier la validité d’un SIRET – Algorithme de Luhn

elsuket — Thu, 23 Jun 2016 18:54:56 +0000

Lors d’un chargement massif de données et/ou d’une migration, il est possible que la qualité des données soient altérées. Il faut alors tester leur qualité et valider chaque écart. Parmi ceux-ci, on peut trouver les numéro SIRET, qui permet l’identification d’un établissement ou d’une entreprise Française.

Cet identifiant numérique est constitué de 14 chiffres, et est articulé en trois parties :

le SIREN
le Numéro Interne de Classement, à quatre chiffres : c’est l’ordre de création de l’établissement par l’entreprise Française
une clé de contrôle, constituée d’un seul chiffre

Ce dernier est calculé à l’aide de l’algorithme de Luhn. Cet algorithme est aussi utilisé pour valider les numéros de carte bleue, et de nombreux identifiants distribués par les administrations de beaucoup de pays. Nous allons nous en servir pour vérifier la validité de SIRETs en l’implémentant spécifiquement pour ce type d’identifiant.

L’algorithme est descriptible comme suit :

Pour chaque chiffre dont l’index dans la chaîne est impair, on le multiplie par 2; si le résultat est supérieur à 9, on additionne les chiffes qui constituent ce résultat. Ceci revient à multiplier par 2 le chiffre, diviser le résultat par 10, puis ajouter la multiplication par 2 de ce même chiffre modulo 10.
On additionne ensuite les chiffres du résultat un à un, avec les chiffres de l’identifiant qui n’ont pas été traités, c’est à dire ceux dont l’index dans la chaîne est pair. Ceci inclut le chiffre de l’identifiant qui est clé.
Si le résultat obtenu est un multiple de 10, alors l’identifiant est valide. Ceci revient à vérifier que le résultat modulo 10 vaut zéro.

La traduction en SQL donne :

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

CASE
WHEN laColonneSIRET IS NULL THEN NULL
WHEN LEN(laColonneSIRET) < 14 THEN CAST(0 AS bit)
WHEN laColonneSIRET LIKE'%[^0-9]%' THEN CAST(0 AS bit)
WHEN (
2 * CAST(SUBSTRING(laColonneSIRET, 1, 1) AS tinyint) / 10
+ 2 * CAST(SUBSTRING(laColonneSIRET, 1, 1) AS tinyint) % 10
+ 2 * CAST(SUBSTRING(laColonneSIRET, 3, 1) AS tinyint) / 10
+ 2 * CAST(SUBSTRING(laColonneSIRET, 3, 1) AS tinyint) % 10
+ 2 * CAST(SUBSTRING(laColonneSIRET, 5, 1) AS tinyint) / 10
+ 2 * CAST(SUBSTRING(laColonneSIRET, 5, 1) AS tinyint) % 10
+ 2 * CAST(SUBSTRING(laColonneSIRET, 7, 1) AS tinyint) / 10
+ 2 * CAST(SUBSTRING(laColonneSIRET, 7, 1) AS tinyint) % 10
+ 2 * CAST(SUBSTRING(laColonneSIRET, 9, 1) AS tinyint) / 10
+ 2 * CAST(SUBSTRING(laColonneSIRET, 9, 1) AS tinyint) % 10
+ 2 * CAST(SUBSTRING(laColonneSIRET, 11, 1) AS tinyint) / 10
+ 2 * CAST(SUBSTRING(laColonneSIRET, 11, 1) AS tinyint) % 10
+ 2 * CAST(SUBSTRING(laColonneSIRET, 13, 1) AS tinyint) / 10
+ 2 * CAST(SUBSTRING(laColonneSIRET, 13, 1) AS tinyint) % 10
---
+ CAST(SUBSTRING(laColonneSIRET, 2, 1) AS tinyint)
+ CAST(SUBSTRING(laColonneSIRET, 4, 1) AS tinyint)
+ CAST(SUBSTRING(laColonneSIRET, 6, 1) AS tinyint)
+ CAST(SUBSTRING(laColonneSIRET, 8, 1) AS tinyint)
+ CAST(SUBSTRING(laColonneSIRET, 10, 1) AS tinyint)
+ CAST(SUBSTRING(laColonneSIRET, 12, 1) AS tinyint)
+ CAST(SUBSTRING(laColonneSIRET, 14, 1) AS tinyint)
) % 10 = 0 THEN CAST(1 AS bit) ELSE CAST(0 AS bit)
END AS is_valid_SIRET

On peut l'utiliser directement dans une vue, comme dans le pseudo code suivant :

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

CREATE VIEW maVue
AS
SELECT desColonnes
, CASE
WHEN laColonneSIRET IS NULL THEN NULL
WHEN LEN(laColonneSIRET) < 14 THEN CAST(0 AS bit)
WHEN laColonneSIRET LIKE'%[^0-9]%' THEN CAST(0 AS bit)
WHEN (
2 * CAST(SUBSTRING(laColonneSIRET, 1, 1) AS tinyint) / 10
+ 2 * CAST(SUBSTRING(laColonneSIRET, 1, 1) AS tinyint) % 10
+ 2 * CAST(SUBSTRING(laColonneSIRET, 3, 1) AS tinyint) / 10
+ 2 * CAST(SUBSTRING(laColonneSIRET, 3, 1) AS tinyint) % 10
+ 2 * CAST(SUBSTRING(laColonneSIRET, 5, 1) AS tinyint) / 10
+ 2 * CAST(SUBSTRING(laColonneSIRET, 5, 1) AS tinyint) % 10
+ 2 * CAST(SUBSTRING(laColonneSIRET, 7, 1) AS tinyint) / 10
+ 2 * CAST(SUBSTRING(laColonneSIRET, 7, 1) AS tinyint) % 10
+ 2 * CAST(SUBSTRING(laColonneSIRET, 9, 1) AS tinyint) / 10
+ 2 * CAST(SUBSTRING(laColonneSIRET, 9, 1) AS tinyint) % 10
+ 2 * CAST(SUBSTRING(laColonneSIRET, 11, 1) AS tinyint) / 10
+ 2 * CAST(SUBSTRING(laColonneSIRET, 11, 1) AS tinyint) % 10
+ 2 * CAST(SUBSTRING(laColonneSIRET, 13, 1) AS tinyint) / 10
+ 2 * CAST(SUBSTRING(laColonneSIRET, 13, 1) AS tinyint) % 10
---
+ CAST(SUBSTRING(laColonneSIRET, 2, 1) AS tinyint)
+ CAST(SUBSTRING(laColonneSIRET, 4, 1) AS tinyint)
+ CAST(SUBSTRING(laColonneSIRET, 6, 1) AS tinyint)
+ CAST(SUBSTRING(laColonneSIRET, 8, 1) AS tinyint)
+ CAST(SUBSTRING(laColonneSIRET, 10, 1) AS tinyint)
+ CAST(SUBSTRING(laColonneSIRET, 12, 1) AS tinyint)
+ CAST(SUBSTRING(laColonneSIRET, 14, 1) AS tinyint)
) % 10 = 0 THEN CAST(1 AS bit) ELSE CAST(0 AS bit)
END AS is_valid_SIRET
FROM dbo.maTable

Si l'on souhaite l'utiliser en colonne calculée, on peut utiliser ce CASE directement dans la définition de ladite colonne, ou bien définir une fonction scalaire comme suit :

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

CREATE FUNCTION fn_scl_is_valid_SIRET
(
@_siret char(14)
)
RETURNS bit
WITH SCHEMABINDING
AS
BEGIN
DECLARE @ok bit

SELECT @ok = CASE
WHEN @_siret IS NULL THEN NULL
WHEN LEN(@_siret) < 14 THEN CAST(0 AS bit)
WHEN @_siret LIKE'%[^0-9]%' THEN CAST(0 AS bit)
WHEN (
2 * CAST(SUBSTRING(@_siret, 1, 1) AS tinyint) / 10
+ 2 * CAST(SUBSTRING(@_siret, 1, 1) AS tinyint) % 10
+ 2 * CAST(SUBSTRING(@_siret, 3, 1) AS tinyint) / 10
+ 2 * CAST(SUBSTRING(@_siret, 3, 1) AS tinyint) % 10
+ 2 * CAST(SUBSTRING(@_siret, 5, 1) AS tinyint) / 10
+ 2 * CAST(SUBSTRING(@_siret, 5, 1) AS tinyint) % 10
+ 2 * CAST(SUBSTRING(@_siret, 7, 1) AS tinyint) / 10
+ 2 * CAST(SUBSTRING(@_siret, 7, 1) AS tinyint) % 10
+ 2 * CAST(SUBSTRING(@_siret, 9, 1) AS tinyint) / 10
+ 2 * CAST(SUBSTRING(@_siret, 9, 1) AS tinyint) % 10
+ 2 * CAST(SUBSTRING(@_siret, 11, 1) AS tinyint) / 10
+ 2 * CAST(SUBSTRING(@_siret, 11, 1) AS tinyint) % 10
+ 2 * CAST(SUBSTRING(@_siret, 13, 1) AS tinyint) / 10
+ 2 * CAST(SUBSTRING(@_siret, 13, 1) AS tinyint) % 10
---
+ CAST(SUBSTRING(@_siret, 2, 1) AS tinyint)
+ CAST(SUBSTRING(@_siret, 4, 1) AS tinyint)
+ CAST(SUBSTRING(@_siret, 6, 1) AS tinyint)
+ CAST(SUBSTRING(@_siret, 8, 1) AS tinyint)
+ CAST(SUBSTRING(@_siret, 10, 1) AS tinyint)
+ CAST(SUBSTRING(@_siret, 12, 1) AS tinyint)
+ CAST(SUBSTRING(@_siret, 14, 1) AS tinyint)
) % 10 = 0 THEN CAST(1 AS bit) ELSE CAST(0 AS bit)
END

RETURN @ok
END

Et en ce qui concerne la création de la colonne calculée, on peut l'ajouter à l'aide du pseudo-T-SQL suivant :

1 2	ALTER TABLE maTable ADD is_valid_SIRET AS(dbo.fn_scl_is_valid_SIRET(laColonneSIRET))

Enfin, si l'on souhaite exécuter cette vérification au sein d'une requête, on peut s'en remettre à une fonction de table en ligne. Ce type de fonction n'étant appelé qu'une seule fois, il s'avérera plus performant à l'exécution sur un grand nombre de lignes que l'appel à une fonction scalaire : ces dernières sont appelées autant de fois qu'il y a de lignes de résultat. Ce qui donne :

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

CREATE FUNCTION fn_it_is_valid_SIRET
(
@siret char(14)
)
RETURNS TABLE
WITH SCHEMABINDING
AS
RETURN
(
SELECT CASE
WHEN LEN(COALESCE(@siret,'')) < 14 THEN CAST(0 AS bit)
WHEN @siret LIKE'%[^0-9]%' THEN CAST(0 AS bit)
WHEN @siret IS NULL THEN CAST(0 AS bit)
WHEN (
2 * CAST(SUBSTRING(@siret, 1, 1) AS tinyint) / 10
+ 2 * CAST(SUBSTRING(@siret, 1, 1) AS tinyint) % 10
+ 2 * CAST(SUBSTRING(@siret, 3, 1) AS tinyint) / 10
+ 2 * CAST(SUBSTRING(@siret, 3, 1) AS tinyint) % 10
+ 2 * CAST(SUBSTRING(@siret, 5, 1) AS tinyint) / 10
+ 2 * CAST(SUBSTRING(@siret, 5, 1) AS tinyint) % 10
+ 2 * CAST(SUBSTRING(@siret, 7, 1) AS tinyint) / 10
+ 2 * CAST(SUBSTRING(@siret, 7, 1) AS tinyint) % 10
+ 2 * CAST(SUBSTRING(@siret, 9, 1) AS tinyint) / 10
+ 2 * CAST(SUBSTRING(@siret, 9, 1) AS tinyint) % 10
+ 2 * CAST(SUBSTRING(@siret, 11, 1) AS tinyint) / 10
+ 2 * CAST(SUBSTRING(@siret, 11, 1) AS tinyint) % 10
+ 2 * CAST(SUBSTRING(@siret, 13, 1) AS tinyint) / 10
+ 2 * CAST(SUBSTRING(@siret, 13, 1) AS tinyint) % 10
---
+ CAST(SUBSTRING(@siret, 2, 1) AS tinyint)
+ CAST(SUBSTRING(@siret, 4, 1) AS tinyint)
+ CAST(SUBSTRING(@siret, 6, 1) AS tinyint)
+ CAST(SUBSTRING(@siret, 8, 1) AS tinyint)
+ CAST(SUBSTRING(@siret, 10, 1) AS tinyint)
+ CAST(SUBSTRING(@siret, 12, 1) AS tinyint)
+ CAST(SUBSTRING(@siret, 14, 1) AS tinyint)
) % 10 = 0 THEN CAST(1 AS bit) ELSE CAST(0 AS bit)
END AS is_valid_SIRET
)

On peut alors l'utiliser à l'aide de l'opérateur APPLY, comme dans l'exemple suivant :

1
2
3
4

SELECT S.*
, F.is_valid_SIRET
FROM dbo.maTableAvecUneColonneSIRET AS S
CROSS APPLY dbo.fn_it_is_valid_SIRET(S.laColonneSIRET) AS F

Bonne validation de SIRETs !

Sauvegardes de bases de données et envoi d’email avec SQL Server Express

elsuket — Sun, 11 May 2014 10:01:01 +0000

Windows Server Update Services (WSUS) est une application qui permet de gérer et distribuer les patch que Microsoft publie pour ses produits. Elle est supportée par SQL Server Express (with Adanced Services), et de ce fait :

On ne dispose pas de l’Agent SQL Server
On ne peut pas utiliser des plans de maintenance pour gérer les sauvegardes
On ne peut pas envoyer d’emails
La compression des fichiers de backup, introduite avec SQL Server 2008, n’est pas prise en charge

Si donc on souhaite planifier les sauvegardes de base de données, et envoyer un email en cas d’échec, on peut :

Remplacer un job de l’Agent SQL Server par une tâche du Planificateur de Tâches de Windows
Écrire une procédure stockée d’assembly pour envoyer des emails

Cet article détaille les étapes à suivre pour ce faire.

Une procédure stockée d’assembly pour envoyer des emails

Si l’Agent SQL Server n’est pas disponible, l’intégration CLR l’est. Ainsi en quelques lignes de code C#, on peut envoyer des e-mails de façon assez similaire à ce qu’on peut faire sous les éditions non-Express de SQL Server avec la procédure stockée système msdb.dbo.sp_send_dbmail.

Pour créer une procédure stockée d’assembly sous Visual Studio 2012 ou ultérieur, il faut tout d’abord installer SQL Server Data Tools. Pour ce faire, vous pouvez lire ce billet. Notez qu’il n’est pas nécessaire d’avoir Visual Studio déjà installé.

Une fois Visual Studio démarré, il suffit de créer un nouveau projet à partir de la page de démarrage, ou bien de suivre File > New > Project, et de choisir un projet SQL Server :

Il faut faire attention à la version du framework .NET. Par exemple, si l’on souhaite que l’assembly soit exécutable par SQL Server 2008, il faut spécifier la version 3.5. Une fois que l’on a validé le tout par OK, nous pouvons ajouter une procédure stockée :

Comme je préfère C# à VB.NET, j’ai choisi une procédure stockée C#, mais si vous préférez VB.NET, rien ne s’y oppose. Notons que par défaut, le langage de la procédure stockée n’est pas pré-sélectionné.

Une fois que l’on a validé le tout par un clic sur Add, on peut écrire :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

using System;
using System.Net;
using System.Net.Mail;
using System.Data;
using System.Data.SqlClient;
using System.Data.SqlTypes;
using Microsoft.SqlServer.Server;

public partial class StoredProcedures
{
[Microsoft.SqlServer.Server.SqlProcedure]
public static void spasb_mail_send (string sender, string recipients, string subject, string body)
{
SmtpClient mailServer = new SmtpClient("mail.myCompany.com");

MailMessage mail = new MailMessage(sender, recipients, subject, body);
mail.IsBodyHtml = true;

mailServer.Send(mail);
}
}

Ce qui, même pour l’ultra-débutant C# que je suis, est loin d’être complexe. Avant de builder le projet, il nous faut configurer l’assembly pour lui permettre d’accéder à des ressources externes, ce qui se fait après un clic-droit sur le projet, et choisi Properties (ou pour les aficionados du raccourci clavier, ALT + Entrée). Dans la page SQLCLR, nous commutons donc la liste déroulante Permission Level sur EXTERNAL_ACCESS. De la même façon, dans la page SQLCLR Build, nous commutons la liste déroulante Configuration sur Release, ce qui permet un léger gain de performances. Ce n’est pas très important dans notre cas, mais si l’assembly est plus complexe, cela peut le devenir.

Après un clic sur Build > Build Solution, nous pouvons aller chercher le fichier dll dans le dossier de la solution. Dans cet exemple, il s’agit de D:\SQLServer\Assemblies\SQLServerExpressDatabaseMail\SQLServerExpressDatabaseMail\bin\Debug, et le fichier est nommé SQLServerExpressDatabaseMail.dll.

De retour dans SQL Server Management Studio, une fois connecté à l’instance SQL Server Express, il est tout d’abord nécessaire d’activer la prise en charge de la CLR par cette dernière. Cela se fait sans redémarrage de l’instance, en quelques instruction :

1
2
3
4

EXEC sp_configure 'clr enabled', 1
GO
RECONFIGURE
GO

Il est maintenant requis de déclarer la base de données dans laquelle nous allons enregistrer la procédure stockée d’assembly comme « digne de confiance ». Ceci nous permet d’emprunter l’identité de SQL Server pour exécuter cette procédure qui va accéder à des ressources en dehors de la base de données : en l’occurrence, un serveur de mails (mais ce peut être le système de fichiers, un webservice, …). Là encore, une simple commande suffit :

1
2
3

ALTER DATABASE DBA
SET TRUSTWORTHY ON
GO

Nous devons maintenant enregistrer l’assembly dans la base de données, ce que l’on peut faire une fois que l’on a copié l’assembly dans un dossier de notre choix, sur le serveur hébergeant l’instance SQL Server Express / WSUS. Dans cet exemple, nous utilisons le dossier C:\SQLServer\.

1
2
3
4
5
6
7

USE DBA
GO

CREATE ASSEMBLY SQLServerExpressDatabaseMail
FROM 'C:\SQLServer\SQLServerExpressDatabaseMail.dll'
WITH PERMISSION_SET = EXTERNAL_ACCESS
GO

On peut vérifier l’enregistrement de l’assembly en interrogeant la vue système sys.assemblies. En ce point, on n’a plus besoin du fichier dll : le binaire de celle-ci est maintenant enregistré dans la base de données (de nom DBA dans cet exemple).
Créons maintenant la procédure stockée :

1
2
3
4
5
6
7

CREATE PROCEDURE dbo.spasb_mail_send
@_sender nvarchar(256)
, @_recipients nvarchar(256)
, @_subject nvarchar(256)
, @_body nvarchar(4000)
AS EXTERNAL NAME SQLServerExpressDatabaseMail.StoredProcedures.spasb_mail_send
GO

Et testons enfin :

1
2
3
4
5

EXEC dbo.spasb_mail_send
'it@myCompany.com'
, 'me@myCompany.com'
, 'Test Mail from Assembly Stored Procedure'
, 'Hey Hey !'

Une procédure stockée pour gérer les sauvegardes

Voici une procédure stockée générique qui permet de sauvegarder une base de données en particulier, ou toutes les bases de données hébergées par une instance SQL Server. Dans le second cas, les sauvegardes du fichier du journal des transactions n’est pas supportée. En revanche, on peut exécuter cette procédure stockée sur toutes les versions de SQL Server, à partir de 2005. Enfin, le cryptage des sauvegardes, introduit avec SQL Server 2014 n’est pas supporté non plus. Cela exige que quelques prérequis soient en place, et ceux-là sortent du cadre de cet article.

La procédure stockée d’assembly est référencée dans le bloc CATCH final : pour toute erreur, on envoie un email.

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
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205

CREATE PROCEDURE dbo.databaseBackup_manage
@_backup_type varchar(12)
, @_database_name varchar(128) = NULL
, @_backup_server_network_path varchar(256)
, @_print_only bit = 0
AS
BEGIN
SET NOCOUNT ON

DECLARE @sql nvarchar(4000)
, @err_msg nvarchar(2048)
, @compression bit
, @checkum bit
, @mail_subject nvarchar(4000) = @@SERVERNAME + ' Backups'

-- SQL Server 2005 ne supporte pas l'affectation directe de valeurs*
-- à des variables lors de la déclaration
SELECT @compression = 0

BEGIN TRY
-- Gestion de la compression des sauvegardes
IF
(
(
-- SQL Server 2008 Enterprise et Developer
CAST(SERVERPROPERTY('ProductVersion') AS varchar(32)) LIKE '10.0%'
AND
(
CAST(SERVERPROPERTY('Edition') AS varchar(64)) LIKE 'Enterprise%'
OR CAST(SERVERPROPERTY('Edition') AS varchar(64)) LIKE 'Developer%'
)
)
OR
(
-- SQL Server 2008 R2 Enterprise, Standard et Developer
-- Et toute version après celle-ci
(
CAST(SERVERPROPERTY('ProductVersion') AS varchar(32)) LIKE '10.50%'
OR CAST(REPLACE(LEFT(CAST(SERVERPROPERTY('ProductVersion') AS varchar(32)), 2), '.', '') AS tinyint) > 10
)
AND
(
CAST(SERVERPROPERTY('Edition') AS varchar(64)) LIKE 'Enterprise%'
OR CAST(SERVERPROPERTY('Edition') AS varchar(64)) LIKE 'Standard%'
OR CAST(SERVERPROPERTY('Edition') AS varchar(64)) LIKE 'Developer%'
)
)
)
BEGIN
SET @compression = 1
END

-- Vérifie que le chemin réseau commence par un double anti-slash
IF @_backup_server_network_path NOT LIKE '\\%'
BEGIN
SET @err_msg = 'The network path ' + @_backup_server_network_path + ' is not valid.'
RAISERROR(@err_msg, 16, 1)
END

-- Ajoute l'anti-slash à la fin du chemin réseau, le cas échéant
SELECT @_backup_server_network_path = @_backup_server_network_path + CASE
WHEN CHARINDEX('\', REVERSE(@_backup_server_network_path)) > 1 THEN '\'
ELSE ''
END

IF @_database_name IS NOT NULL
BEGIN
--------------------------------------------------
-- Sauvegarde d'une base de données en particulier
--------------------------------------------------
IF NOT EXISTS
(
SELECT *
FROM sys.databases
WHERE name = @_database_name
)
BEGIN
SET @err_msg = 'La base de données ''' + @_database_name + ''' n''existe pas.'
RAISERROR(@err_msg, 16, 1)
END

IF NOT EXISTS
(
SELECT *
FROM sys.databases
WHERE name = @_database_name
AND state_desc = 'ONLINE'
AND user_access_desc = 'MULTI_USER'
AND source_database_id IS NULL -- La base de données n'est pas un snapshot
AND database_id 2 -- La base de données n'est pas TempDB
)
BEGIN
SET @err_msg = 'La base de données ''' + @_database_name + ''' n''est pas disponible ou est une capture intantanée.'
RAISERROR(@err_msg, 16, 1)
END

-- Vérifie le type de backup
IF @_backup_type NOT IN('FULL', 'DIFFERENTIAL', 'LOG')
BEGIN
SET @err_msg = 'The backup type ''' + @_backup_type + ''' is invalid.'
RAISERROR(@err_msg, 16, 1)
END

SET @sql = 'BACKUP ' + CASE
WHEN @_backup_type IN ('FULL', 'DIFFERENTIAL') THEN 'DATABASE '
WHEN @_backup_type = 'LOG' THEN 'LOG '
END + @_database_name
+ ' TO DISK = ''' + @_backup_server_network_path + REPLACE(@@SERVERNAME, '\', '_') + '\' + @_database_name + '_' + @_backup_type + '_'
+ REPLACE(REPLACE(CONVERT(char(19), GETDATE(), 120), ':', '-'), ' ', '_') + '.bak'''
+ ' WITH ' + CASE @_backup_type
WHEN 'DIFFERENTIAL' THEN 'DIFFERENTIAL, '
WHEN 'FULL' THEN 'INIT, '
ELSE ''
END + CASE @compression WHEN 1 THEN 'COMPRESSION, ' ELSE '' END
+ 'CHECKSUM'

IF @_print_only = 1
BEGIN
PRINT @sql
END
ELSE
BEGIN
BEGIN TRY
EXEC sp_executesql @sql
END TRY
BEGIN CATCH
SET @err_msg = @_database_name + ' | ' + ERROR_MESSAGE()
RAISERROR(@err_msg, 16, 1)
END CATCH
END
END
ELSE
BEGIN
--------------------------------------------------------
-- Sauvegarde de toutes les bases de données disponibles
--------------------------------------------------------
IF @_backup_type = 'LOG'
BEGIN
SET @err_msg = 'On ne prend pas une sauvegarde du fichier du journal des transactions de toutes les bases de données.'
RAISERROR(@err_msg, 16, 1)
END

DECLARE @database_list TABLE
(
database_name varchar(128)
)

INSERT INTO @database_list
(
database_name
)
SELECT REPLACE(name, ' ', '') -- Certaines bases de données ne respectent pas la convention de nommage SQL ANSI.
FROM sys.databases
WHERE source_database_id IS NULL -- La base de données n'est pas un snapshot
AND state_desc = 'ONLINE'
AND user_access_desc = 'MULTI_USER'
AND database_id 2 -- On exclut TempDB

WHILE EXISTS
(
SELECT *
FROM @database_list
)
BEGIN
SELECT TOP 1 @_database_name = database_name
FROM @database_list

SET @sql = 'BACKUP DATABASE ' + @_database_name
+ ' TO DISK = ''' + @_backup_server_network_path + REPLACE(@@SERVERNAME, '\', '_') + '\' + @_database_name + '_' + @_backup_type + '_'
+ REPLACE(REPLACE(CONVERT(char(19), GETDATE(), 120), ':', '-'), ' ', '_') + '.bak'''
+ ' WITH ' + CASE @_backup_type
WHEN 'DIFFERENTIAL' THEN 'DIFFERENTIAL, '
WHEN 'FULL' THEN 'INIT, '
END + CASE @compression WHEN 1 THEN 'COMPRESSION, ' ELSE '' END
+ 'CHECKSUM'

IF @_print_only = 1
BEGIN
PRINT @sql
END
ELSE
BEGIN
BEGIN TRY
EXEC sp_executesql @sql
END TRY
BEGIN CATCH
SET @err_msg = @_database_name + ' | ' + ERROR_MESSAGE()
RAISERROR(@err_msg, 16, 1)
END CATCH
END

DELETE FROM @database_list
WHERE database_name = @_database_name
END
END
END TRY
BEGIN CATCH
-- Envoie un email en cas d'erreur
EXEC dbo.spasb_mail_send
@_sender = 'it@myCompany.com'
, @_recipients = 'it@myCompany.com'
, @_subject = @mail_subject
, @_body = @err_msg
END CATCH
END

Remplacer l’Agent SQL Server par le Planificateur de Tâches de Windows

Nous voilà à l’étape finale : prendre des sauvegardes de base de données régulièrement. Pour ce faire, on peut tout à fait utiliser le Planificateur de Tâches de Windows : en effet, on peut appeler l’utilitaire en ligne de commandes SQLCMD (la documentation, l’utilisation, et un exemple), qui permet d’interagir avec une instance SQL Server. Cet outil permet de passer en paramètre un script, d’exécuter une requête, mais surtout d’enregistrer la sortie dans un fichier. Cette dernière fonctionnalité facilite la tâche d’investigation sur l’échec d’exécution de code.

Une fois l’application Planificateur de Tâches démarrée, on créé une tâche assez simplement :

Une fois passé la première page ou nous nommons la tâche, un clic sur Next nous amène à la planification. Pour Windows Server Update Services, on peut estimer qu’une sauvegarde complète par jour est suffisante. Évidemment, cela varie avec la criticité de l’application. Nous spécifions donc une exécution quotidienne :

Nous planifions l’exécution à minuit et une minute :

Et nous choisissons de démarrer une application :

Dans la saisie texte Program / Script, nous spécifions l’invite de commandes. En ce qui concerne les arguments, nous écrivons :

Pour SQL Server 2008 :
"C:\Program Files\Microsoft SQL Server\100\Tools\Binn\SQLCMD.EXE"
Pour SQL Server 2012 :
"C:\Program Files\Microsoft SQL Server\110\Tools\Binn\SQLCMD.EXE"
Pour SQL Server 2014 :
"C:\Program Files\Microsoft SQL Server\Client SDK\ODBC\110\Tools\Binn\SQLCMD.EXE"

En ce qui concerne les arguments, nous passons :

sqlcmd -E -S WSUS -i "C:\SQLServer\WSUSBackup.sql" -o "C:\SQLServerBackup\FullBackupLog.txt"

Attention, la casse des options est importante.

-E pour spécifier une connexion approuvée
-S : l’instance SQL Server à laquelle on souhaite se connecter
-i : le chemin et le nom du fichier de script T-SQL
-o : le fichier qui capturera les libellés des messages d’information, d’avertissement ou d’erreurs, le cas échéant

Ce qui donne :

Un clic sur Next nous offre une fenêtre de résumé, et on peut valider le tout. Si l’on souhaite ajouter des planifications ou modifier d’autres options pour cette tâche, il suffit de cocher la case Open the Properties dialog for this task when I click Finish.

Nous créons ensuite un fichier WSUSBackup.sql dans un répertoire C:\SQLServer\ sur la machine qui héberge l’application WSUS. Ce fichier appelle la procédure stockée DBA.dbo.databaseBackup_manage comme suit :

EXEC DBA.dbo.databaseBackup_manage 'FULL', NULL, '\\monPartageDeBackup\', 0

Et voilà nos sauvegardes de base de données en place.

Utiliser PowerShell pour supprimer les fichiers de sauvegardes trop anciens

Dans la liste des actions de la tâche que nous venons de créer, nous pouvons en ajouter une qui aura :

Pour programme : powershell
Pour arguments : -file "C:\SQLServer\DeleteOldBackupFiles.ps1"

Le fichier DeleteOldBackupFiles.ps1 contient la commande suivante, qui supprime tous les fichiers créés il y a plus de 7 jours, y compris dans les sous-dossiers du partage de backup (-Recurse) :

Get-ChildItem '\\monPartageDeBackup\' -Recurse | Where {$_.CreationTime -lt (Get-Date).AddDays(-7)} | Remove-Item -Force

Par défaut, PowerShell ne permet pas l’exécution de scripts. Pour l’autoriser, il faut démarrer l’interface PowerShell, et exécuter Set-ExecutionPolicy RemoteSigned (en accord avec votre Administrateur Systèmes !).

Retenons également que les statistiques de colonne et d’index de la base de données supportant WSUS ne sont pas maintenues. Ce sera probablement suffisant pour générer une lenteur après quelques mois d’exploitation, dont votre Administrateur Systèmes vous demandera l’origine

ElSüket.

Comment passer d’une liste de valeurs séparées par des virgules à une table, et inversement ?

elsuket — Mon, 14 Apr 2014 04:47:40 +0000

La réponse est très courte : avec les fonctionnalités SQLXML et XQuery intégrées à SQL Server.

Il est parfois utile de pouvoir générer une liste de valeurs d’une colonne, séparées par des virgules ou un autre symbole imprimable. Bien que cela serve souvent des buts de présentation, qui n’ont donc rien à faire avec SQL, il se trouve des cas où l’on n’a pas le choix. C’est par exemple le cas avec SQL Server Reporting Services (SSRS) : en effet, cet outil efficace de création assistée de rapports permet de choisir plusieurs valeurs pour un paramètre. SSRS les transmet ensuite sous la forme d’une chaîne de caractères, dont les valeurs sont séparées par des virgules. Lorsqu’on requête les données avec un tel paramètre, il faut dépouiller la chaîne pour en obtenir les valeurs scalaires, intelligibles par le moteur de bases de données.

Voyons un premier exemple très simple de génération de liste de valeurs séparées par des virgules :

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

CREATE TABLE dbo.liste_GUID
(
valeur_scalaire uniqueidentifier
)
GO

INSERT INTO dbo.liste_GUID (valeur_scalaire)
VALUES ('30815903-5911-418B-BB56-CE0CF4981142')
, ('029FE2E3-E57D-4C4D-A514-2448149560F9')
, ('F6A73DFA-C79A-40B5-B12F-55DA66C5A158')
, ('D896FB47-B5B8-4E8F-BFA1-62A65F66CB8B')
GO

DECLARE @s varchar(max);

WITH
CUMUL (csv) AS
(
SELECT CAST(valeur_scalaire AS char(36)) + ','
FROM dbo.liste_GUID
FOR XML PATH('')
)
SELECT @s = csv
FROM CUMUL

SELECT @s

Notons qu’avec cet exemple, nous avons une virgule en toute fin de chaîne. On peut l’éliminer simplement en écrivant :

1
2
3
4
5
6
7
8
9
10
11
12
13

DECLARE @s varchar(max);

WITH
CUMUL (csv) AS
(
SELECT CAST(valeur_scalaire AS char(36)) + ','
FROM dbo.liste_GUID
FOR XML PATH('')
)
SELECT @s = LEFT(csv, LEN(csv) - 1)
FROM CUMUL

SELECT @s

Si l’on a besoin de réaliser cela pour un ensemble (i.e. une colonne), on utilisera l’opérateur APPLY, ou une sous requête corrélée.
Pour l’exemple, considérons les tables suivantes :

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

CREATE TABLE Contact
(
IDContact int IDENTITY
CONSTRAINT PK_Contact PRIMARY KEY
, NomContact varchar(20) NOT NULL
CONSTRAINT UQ_Contact__NomContact UNIQUE
)
GO

CREATE TABLE Club
(
IDClub int IDENTITY
CONSTRAINT PK_Club PRIMARY KEY
, NomClub varchar(20) NOT NULL
CONSTRAINT UQ_Club__NomClub UNIQUE
)
GO

CREATE TABLE Membre
(
IDMembre int IDENTITY
CONSTRAINT PK_Membre PRIMARY KEY
, IDContact int NOT NULL
CONSTRAINT FK_Membre_IDContact FOREIGN KEY(IDContact) REFERENCES Contact(IDContact)
, IDClub int NOT NULL
CONSTRAINT FK_Membre_IDClub FOREIGN KEY(IDClub) REFERENCES Club(IDClub)
, CONSTRAINT UQ_Membre_IDContact_IDClub UNIQUE (IDContact, IDClub)
)
GO

INSERT INTO dbo.Contact (NomContact) VALUES('BipBip')
INSERT INTO dbo.Contact (NomContact) VALUES('Coyotte')
INSERT INTO dbo.Contact (NomContact) VALUES('Titi')
INSERT INTO dbo.Contact (NomContact) VALUES('Sylvestre')
INSERT INTO dbo.Contact (NomContact) VALUES('Bugs Bunny')
INSERT INTO dbo.Contact (NomContact) VALUES('Daffy Duck')
INSERT INTO dbo.Contact (NomContact) VALUES('Sam Le Pirate')
GO

INSERT INTO dbo.Club (NomClub) VALUES ('SQLServer')
INSERT INTO dbo.Club (NomClub) VALUES ('Oracle')
INSERT INTO dbo.Club (NomClub) VALUES ('PostGreSQL')
INSERT INTO dbo.Club (NomClub) VALUES ('MySQL')
INSERT INTO dbo.Club (NomClub) VALUES ('FireBird')
INSERT INTO dbo.Club (NomClub) VALUES ('Sybase')
INSERT INTO dbo.Club (NomClub) VALUES ('DB2')
INSERT INTO dbo.Club (NomClub) VALUES ('SQLite')
GO

INSERT INTO dbo.Membre (IDContact, IDClub) VALUES (1, 1)
INSERT INTO dbo.Membre (IDContact, IDClub) VALUES (1, 2)
INSERT INTO dbo.Membre (IDContact, IDClub) VALUES (1, 3)
INSERT INTO dbo.Membre (IDContact, IDClub) VALUES (2, 4)
INSERT INTO dbo.Membre (IDContact, IDClub) VALUES (2, 5)
INSERT INTO dbo.Membre (IDContact, IDClub) VALUES (3, 6)
INSERT INTO dbo.Membre (IDContact, IDClub) VALUES (4, 7)
INSERT INTO dbo.Membre (IDContact, IDClub) VALUES (4, 8)
INSERT INTO dbo.Membre (IDContact, IDClub) VALUES (5, 1)
INSERT INTO dbo.Membre (IDContact, IDClub) VALUES (5, 3)
INSERT INTO dbo.Membre (IDContact, IDClub) VALUES (6, 5)
INSERT INTO dbo.Membre (IDContact, IDClub) VALUES (6, 7)
INSERT INTO dbo.Membre (IDContact, IDClub) VALUES (7, 8)
GO

On obtient alors la liste des clubs desquels un contact est membre avec l’une des requêtes suivantes :

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

-- Avec l'opérateur APPLY
SELECT CT.NomContact
, LEFT(LC.liste_club, LEN(LC.liste_club) - 1) AS liste_club
FROM dbo.Contact AS CT
CROSS APPLY (
SELECT CL.NomClub + ', '
FROM dbo.Club AS CL
INNER JOIN dbo.Membre AS MB
ON MB.IDClub = CL.IDClub
WHERE CT.IDContact = MB.IDContact
FOR XML PATH('')
) AS LC(liste_club);

-- Avec une sous-requête corrélée
-- Pour éliminer la virgule en fin de chaîne, on utilise ici une expression de table commune (CTE)
;WITH
CTE AS
(
SELECT CT.NomContact
, (
SELECT CL.NomClub + ', '
FROM dbo.Club AS CL
INNER JOIN dbo.Membre AS MB
ON MB.IDClub = CL.IDClub
WHERE CT.IDContact = MB.IDContact
FOR XML PATH('')
) AS liste_club
FROM dbo.Contact AS CT
)
SELECT NomContact
, LEFT(liste_club, LEN(liste_club) - 1) AS liste_club
FROM CTE;

-- Mais on peut se passer de la CTE en utilisant une table dérivée :
SELECT LC.NomContact
, LEFT(LC.liste_club, LEN(LC.liste_club) - 1) AS liste_club
FROM (
SELECT CT.NomContact
, (
SELECT CL.NomClub + ', '
FROM dbo.Club AS CL
INNER JOIN dbo.Membre AS MB
ON MB.IDClub = CL.IDClub
WHERE CT.IDContact = MB.IDContact
FOR XML PATH('')
) AS liste_club
FROM dbo.Contact AS CT
) AS LC(NomContact, liste_club)

Maintenant, supposons que nous avons un rapport SSRS qui appelle une procédure stockée, et que l’un des paramètres du rapport permet un choix multiple de valeurs. Il nous est donc nécessaire de transformer cette liste de valeurs en une table d’une seule colonne :

1
2
3
4
5
6
7
8
9
10

DECLARE @s varchar(max) = '30815903-5911-418B-BB56-CE0CF4981142,029FE2E3-E57D-4C4D-A514-2448149560F9,F6A73DFA-C79A-40B5-B12F-55DA66C5A158,D896FB47-B5B8-4E8F-BFA1-62A65F66CB8B'

-- On ajoute la balise v en tête et en queue de chaîne,
-- et on remplace les virgules par le doublet
DECLARE @x xml = CAST(''+ REPLACE(@s, ',' ,'') + '' AS xml)

-- On dépouille le document XML créé en utilisant la fonction nodes()
-- du langage XQuery, intégré à SQL Server depuis sa version 2005
SELECT vs.value('.', 'uniqueidentifier') AS valeur_scalaire
FROM @x.nodes('/v') AS x(vs)

L’utilisation de FOR XML PATH est de très loin la méthode qui permet de générer une liste de valeurs de façon performante. Ceci n’en fait pas une raison pour l’utiliser à tors et à travers, mais seulement lorsque cela est nécessaire.

ElSüket.

La clause VALUES n’est-elle réservée qu’à l’ordre INSERT ?

elsuket — Sat, 25 May 2013 12:21:25 +0000

Si je pose la question, c’est que la réponse est … non, et ce depuis SQL Server 2008 !

En effet l’utilisation la plus commune de la clause VALUES se fait lors de la définition d’un ordre INSERT, et permettait jusqu’à SQL Server 2005 inclus d’insérer seulement une ligne dans une table.

Cela a changé lors de la sortie de SQL Server 2008, qui permet de réaliser un INSERT d’au plus 1000 lignes dont les valeurs sont codées « en dur » dans un script. Voyons les autres utilisations possible de cette clause …

En fait, cette clause est utilisable pour toute instruction DML, pour peu qu’on la précise dans la clause FROM d’une instruction SELECT, INSERT, UPDATE ou DELETE, et dans la clause USING de l’instruction MERGE.

Voici quelques exemples simples d’utilisation, qui éveilleront votre imagination dès que vous retournerez à vos claviers.
Commençons par appréhender la clause avec une requête triviale :

1
2
3
4

SELECT *
FROM (
VALUES (-15), (0), (1), (2), (3)
) AS V(i)

Ce qui nous retourne le résultat suivant :

Si nous regardons le plan d’exécution à l’aide de SQL Sentry Plan Explorer, on voit que l’estimation de cardinalité se fait proprement :

Ceci évite d’écrire une requête avec de nombreux UNION ALL, comme suit :

1
2
3
4
5
6
7
8

SELECT *
FROM (
SELECT -15
UNION ALL SELECT 0
UNION ALL SELECT 1
UNION ALL SELECT 2
UNION ALL SELECT 3
) AS V(i)

Même si l’estimation de cardinalité se fait de la même manière.

On peut donc spécifier un INSERT de plusieurs lignes à l’aide de la clause VALUES :

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

DECLARE @pays_capitale TABLE
(
pays varchar(15) NOT NULL
, capitale varchar(32) NOT NULL
)

INSERT INTO @pays_capitale
(
pays
, capitale
)
VALUES ('France', 'Paris')
, ('Thaïlande', 'Bangkok')
, ('Bouthan', 'Thimphou')
, ('Vanuatu', 'Port-Vila')
, ('Singapour', 'Singapour')
, ('Viêt Nam', 'Hanoï')
, ('Cambodge', 'Phnom Penh')
, ('Laos', 'Vientiane')
, ('Malaisie', 'Kuala Lumpur')
, ('Brunei', 'Bandar Seri Begawan')
, ('Philippines', 'Manille')
, ('Indonésie', 'Jakarta')
, ('Birmanie', 'Naypyidaw')

SELECT *
FROM @pays_capitale

Nous obtenons le résultat suivant :

La démonstration des exemples suivants, nous utilisons le jeu de données défini par le lot de requêtes ci-dessous :

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

CREATE TABLE capteur
(
capteur_id tinyint NOT NULL IDENTITY (0, 1)
CONSTRAINT PK_capteur PRIMARY KEY
, capteur_nom varchar(15) NOT NULL
CONSTRAINT UQ_capteur UNIQUE
, capteur_date_ajout datetime
NOT NULL CONSTRAINT DF_capteur__capteur_date_ajout DEFAULT (GETDATE())
)
GO

CREATE TABLE mesure
(
mesure_id int NOT NULL IDENTITY(-2147483648, 1)
CONSTRAINT PK_mesure PRIMARY KEY
, capteur_id tinyint NOT NULL
CONSTRAINT FK_mesure__capteur_id
FOREIGN KEY (capteur_id) REFERENCES dbo.capteur
, mesure_date_time datetime NOT NULL
CONSTRAINT DF_mesure_mesure_date_time DEFAULT (GETDATE())
, valeur tinyint NOT NULL
)
GO

INSERT INTO dbo.capteur
(
capteur_nom
)
VALUES ('Capteur 1'), ('Capteur 2'), ('Capteur 3')
GO

INSERT INTO dbo.mesure
(
capteur_id
, valeur
)
SELECT ABS(CHECKSUM(NEWID())) % 3
, ABS(CHECKSUM(NEWID())) % 256
FROM master.dbo.spt_values
WHERE type = 'P'
GO 50

La vue master.dbo.spt_values retourne 2048 lignes qui ont pour type « P » : la table dbo.mesure contient donc 2048 * 50 = 102.400 lignes.

Étant donné que la clause se comporte de la même façon qu’une table dérivée, on peut tout à fait l’utiliser pour réaliser une jointure.
Essayons de classer les mesures par fourchettes :

1
2
3
4
5
6
7
8
9
10
11
12
13

SELECT BUCKET.low_bound
, BUCKET.high_bound
, COUNT(*) AS occurences
FROM dbo.mesure AS M
INNER JOIN (
VALUES (0, 5), (5, 10), (10, 15), (15, 20), (20, 30)
, (30, 40), (40, 50), (50, 100), (100, 200)
, (200, 1000)
) AS BUCKET(low_bound, high_bound)
ON M.valeur >= BUCKET.low_bound
AND M.valeur < BUCKET.high_bound
GROUP BY BUCKET.low_bound, BUCKET.high_bound
ORDER BY BUCKET.low_bound, BUCKET.high_bound

Ce qui nous retourne :

Voyons le cas d’un UPDATE :

1
2
3
4
5
6
7
8
9
10
11
12
13
14

WITH
BUCKET (low_bound, high_bound) AS
(
SELECT *
FROM (
VALUES (0, 5), (5, 10)
, (10, 15), (15, 20), (20, 30)
) AS V(low_bound, high_bound)
)
UPDATE dbo.mesure
SET valeur *= 2 -- multiplie par deux la valeur mesurée
FROM dbo.mesure AS M
INNER JOIN BUCKET AS B
ON B.low_bound M.valeur

Notez que rien ici n’oblige à la construction d’une expression de table commune : on peut tout à fait spécifier le constructeur de valeurs de table dans la clause INNER JOIN, comme nous l’avons fait avec la requête précédente.

Si nous ré-exécutons la requête de classement par fourchettes, nous obtenons maintenant :

l’instruction DELETE se décrit de manière similaire :

1
2
3
4
5
6
7
8

DELETE FROM dbo.mesure
FROM dbo.mesure AS M
INNER JOIN (
VALUES (30, 40), (40, 50), (50, 100)
, (100, 200), (200, 1000)
) AS BUCKET (low_bound, high_bound)
ON M.valeur >= BUCKET.low_bound
AND M.valeur < BUCKET.high_bound

Après ré-exécution de la requête de distribution des valeurs par plages, on voit que la table des mesures contient maintenant :

Terminons par l’ordre MERGE, avec lequel nous allons ajouter des capteurs, ou marquer ceux qui existent déjà à la date courante :

1
2
3
4
5
6
7
8
9
10
11
12

MERGE dbo.capteur AS TGT
USING (
VALUES ('Capteur 1'), ('Capteur 2'), ('Capteur 3')
, ('Capteur 4'), ('Capteur 5'), ('Capteur 6')
) AS SRC (capteur_nom)
ON TGT.capteur_nom = SRC.capteur_nom
WHEN MATCHED THEN UPDATE SET capteur_date_ajout = GETDATE()
WHEN NOT MATCHED THEN INSERT (capteur_nom) VALUES (SRC.capteur_nom)
OUTPUT $ACTION, DELETED.capteur_nom, INSERTED.capteur_nom;

SELECT *
FROM dbo.capteur

On voit bien les capteurs 4, 5 et 6 ajoutés, et les capteurs 1, 2 et 3, dont les lignes existaient déjà, modifiés. Tous les capteurs portent la même date d’ajout, transaction oblige.

Enfin on peut calculer le maximum d’un tuple de valeurs sans avoir à écrire une fonction pour ce faire. Soit la variable de type TABLE suivante :

1
2
3
4
5
6
7
8
9
10
11
12

DECLARE @series TABLE
(
id tinyint identity
, a tinyint
, b tinyint
, c tinyint
)

INSERT INTO @series
VALUES (1, 2, 3)
, (4, 5, 6)
, (7, 8, 9)

Nous souhaitons obtenir la plus grande valeur des trois colonnes a, b et c, pour chaque ligne. On peut exprimer ce besoin comme suit :

1
2
3
4
5
6
7
8

SELECT id
, (
SELECT MAX(n)
FROM (
VALUES (a), (b), (c)
) AS V(n)
)
FROM @series

Ce qui amène le résultat suivant :

Amusez-vous avec VALUES !

Connaître les caractéristiques d’une trace SQL Profiler

elsuket — Wed, 16 Jun 2010 06:27:27 +0000

Sur un serveur à la configuration sous-dimensionnée que je surveille de temps en temps, j’ai trouvé une trace SQL Profiler en cours d’exécution.
J’ai voulu en savoir plus sur les caractéristiques de cette trace.
Voici la requête :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

-------------------------------
-- Nicolas SOUQUET - 16/06/2010
-------------------------------
SELECT C.name
, FI.value
, T.start_time
, T.last_event_time
, T.event_count
, S.login_name
, S.session_id
, 'EXEC sp_trace_setstatus ' + CAST(T.id AS varchar(10)) + ', 0' AS stop_trace_stmt
FROM sys.traces AS T
CROSS APPLY sys.fn_trace_getfilterinfo (T.id) AS FI
INNER JOIN sys.trace_columns AS C ON FI.columnid = C.trace_column_id
INNER JOIN sys.dm_exec_sessions AS S ON S.session_id = T.reader_spid

On sait tout de suite quel filtres ont été utilisés à l’aide des deux premières colonnes.
La dernière colonne contient l’instruction qui permet d’arrêter la trace : le développeur a donc toujours ses résultats.

Pour savoir comment créer une trace côté serveur, c’est par ici

Bon traçage !

ElSüket

Puissance de la clause IN

elsuket — Wed, 07 Jul 2010 04:33:26 +0000

La clause IN permet de filtrer une requête sur un ensemble de valeurs, soit en les listant « en dur », soit pas une sous-requête.

Si ce n’est pas un opérateur que j’affectionne particulièrement puisqu’il n’est pas SARGable, en voici une utilisation assez puissante :

Créons donc la petite table suivante :

1
2
3
4
5
6
7
8
9
10
11

CREATE TABLE uneTable
(
id TINYINT IDENTITY
, uneColonne TINYINT
, uneAutreColonne TINYINT
, uneNouvelleColonne TINYINT
)

INSERT INTO uneTable VALUES (1, 2, 100)
INSERT INTO uneTable VALUES (2, 100, 1)
INSERT INTO uneTable VALUES (100, 1, 2)

Vous devinez simplement le résultat de la requête suivante :

1
2
3

SELECT id
FROM dbo.uneTable
WHERE uneColonne IN (1, 2)

qui retourne :

id
—
1
2

Mais quid ce celle-ci ?

1
2
3

SELECT id
FROM dbo.uneTable
WHERE 1 IN (uneAutreColonne, uneNouvelleColonne)

id
—
2
3

ElSüket

Attention aux types de données money et smallmoney !

elsuket — Wed, 25 Jul 2012 18:23:18 +0000

En effet, ces deux types de données produisent des erreurs de calculs.
Voici un petit test pour révéler cela :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

DECLARE @mon1 smallmoney,
@mon2 smallmoney,
@mon3 smallmoney,
@mon4 smallmoney,
@num1 decimal(19,4),
@num2 decimal(19,4),
@num3 decimal(19,4),
@num4 decimal(19,4)

SELECT @mon1 = 100
, @mon2 = 339
, @mon3 = 10000
---
, @num1 = 100
, @num2 = 339
, @num3 = 10000

SELECT @mon4 = @mon1 / @mon2 * @mon3
, @num4 = @num1 / @num2 * @num3

SELECT @mon4 AS money_result
, @num4 AS numeric_result

Attention donc au choix des types de données !

Tout savoir sur SEQUENCE avec SQL Server 2012

elsuket — Sun, 03 Jun 2012 11:03:40 +0000

Implémentation de SQL dans SQL Server longtemps attendue, voici enfin SEQUENCE, qui permet d’obtenir un nombre augmenté d’un certain incrément à chaque appel, que l’on peut partager entre les tables et les utilisateurs d’une base de données, et bien d’autre possibilités encore …

Attention : cet article comporte 6 pages

On notera tout d’abord qu’un objet de type SEQUENCE n’est utilisable qu’avec des types numériques précis : tinyint, smallint, int, bigint, decimal et numéric, les deux derniers avec une échelle à zéro.

Commençons donc par créer une SEQUENCE de la façon la plus simple qui soit :

CREATE SEQUENCE dbo.maSequence

C’est aussi simple que cela, mais nous allons voir par la suite qu’on peut aller un peu plus loin.

Maintenant, comment obtenir la « première » valeur de la SEQUENCE dbo.maSequence ?
Là encore, c’est relativement simple :

SELECT NEXT VALUE FOR dbo.maSequence

Donc si l’on crée un objet SEQUENCE sans aucune option, le type par défaut est bigint, et la valeur initiale attribuée à cette SEQUENCE est la plus petite valeur que peut stocker le type de données bigint.

Est-ce le cas avec les autres types de données ?

1
2
3
4
5
6
7
8
9
10
11
12
13

CREATE SEQUENCE dbo.ma_sequence_smallint
AS smallint
GO

SELECT NEXT VALUE FOR dbo.ma_sequence_smallint AS next_value_ma_sequence_smallint
GO

CREATE SEQUENCE dbo.ma_sequence_tinyint
AS tinyint
GO

SELECT NEXT VALUE FOR dbo.ma_sequence_tinyint AS next_value_ma_sequence_tinyint
GO

Rien de surprenant par rapport au comportement par défaut.
En revanche le fait que la SEQUENCE ne commence pas à 1 comme avec les colonnes de type entier auxquelles on confère la propriété d’auto-incrémentation à l’aide de la clause IDENTITY est appréciable.

Avant de continuer à nous éclairer sur SEQUENCE, voyons comment connaître les propriétés d’un tel objet : la vue système sys.sequences est là pour cela :

1
2
3
4
5
6
7
8
9
10
11
12
13

SELECT S.name AS sequence_name
, T.name AS sequence_data_type_name
, S.start_value
, S.increment
, S.minimum_value
, S.maximum_value
, S.is_cycling
, S.cache_size
, S.current_value
, S.is_exhausted
FROM sys.sequences AS S
INNER JOIN sys.types AS T
ON S.system_type_id = T.system_type_id

Ce qui retourne :

Je passerai sur la description des colonnes jusqu’à maximum_value, et sur current_value puisque leur nom est suffisamment explicite.

La colonne is_cycling nous montre qu’il est possible de faire boucler la SEQUENCE, c’est à dire de la faire revenir à sa valeur de départ.
La colonne cache_size indique le nombre de valeurs qui est mise en cache. Nous verrons la notion de cache de SEQUENCE par la suite.
Enfin la colonne is_exhausted indique s’il est encore possible de générer de nouveaux nombres à partir de celle-ci.

On retrouve les objets SEQUENCE dans l’Explorateur d’Objets, avec les fonctionnalités accessibles par clic-droit que l’on connaît :

Après un clic sur Propriétés :

On obtient la fenêtre suivante :

On peut aussi créer une SEQUENCE décrémentielle, simplement en spécifiant un incrément négatif :

1
2
3
4
5
6
7
8
9
10
11

CREATE SEQUENCE uneSequenceDecrementielle
AS int
START WITH 0
INCREMENT BY -5
GO

SELECT NEXT VALUE FOR uneSequenceDecrementielle
SELECT NEXT VALUE FOR uneSequenceDecrementielle
SELECT NEXT VALUE FOR uneSequenceDecrementielle
SELECT NEXT VALUE FOR uneSequenceDecrementielle
SELECT NEXT VALUE FOR uneSequenceDecrementielle

On peut également changer l’incrément en cours de route à l’aide d’une instruction ALTER SEQUENCE :

1
2
3
4
5

ALTER SEQUENCE dbo.uneSequenceDecrementielle
INCREMENT BY -2
GO

SELECT NEXT VALUE FOR uneSequenceDecrementielle

Il est également possible, comme le suggère la colonne maximum_value de la vue sys.sequences, mettre une valeur maximale à cette séquence.
Il faut bien sûr dans ce cas que la valeur maximale de la séquence prenne en compte la valeur de départ, sinon celle-ci ne serait pas générable :

1
2
3

ALTER SEQUENCE dbo.uneSequenceDecrementielle
MAXVALUE -30
GO

Ici comme la séquence est décrémentielle, SQL Server rejette l’instruction ALTER SEQUENCE puisque nous avions spécifié que la SEQUENCE démarre à zéro.

Si nous changeons par MINVALUE :

1
2
3

ALTER SEQUENCE dbo.uneSequenceDecrementielle
MAXVALUE -30
GO

Voici un message d’avertissement intéressant : nous n’avons pas spécifié de valeur pour la taille du cache de la SEQUENCE, mais SQL Server en a mis une par défaut …
J’ai tenté de savoir quelle est la taille du cache par défaut, et comment SQL Server stocke celle-ci en utilisant une connexion d’administrateur dédiée (DAC), mais il semble que SQL Server réalise cela dans des tables internes.
Si quelqu’un découvre cela, merci de le poster en commentaire

Les nouvelles fonctions T-SQL de SQL Server 2012 – Episode 1/8 – PARSE() –

elsuket — Mon, 16 Apr 2012 12:18:57 +0000

Je vous propose de découvrir les 14 nouvelles fonctions que SQL Server 2012 introduit, en dédiant un billet soit à chacune d’entre-elles, ou bien à un groupe d’entre-elles.

Commençons avec la fonction PARSE() …

La syntaxe d’utilisation de cette fonction est la suivante :

PARSE('' AS [USING ''])

La nouveauté c’est la possibilité de formater une valeur suivant une culture, et ce n’est pas moins de 33 cultures qui sont disponibles !
De façon générale, cette fonction est une extension de ce que l’on peut faire avec CONVERT().
Rappelons dans les deux cas qu’il s’agit de fonctions de formatage de données.

On notera que :

– data_type est limité aux types suivants : bigint, int, smallint, tinyint, decimal, numeric, float, real, smallmoney, money, date, time, datetime, smalldatetime, datetime2 et datetimeoffset.

– On ne peut pas utiliser PARSE() pour exécuter une requête sur un serveur distant, car celle-ci dépend du .NET Framework 3.5 SP1 , et que rien ne garantit qu’il est présent sur la machine distante.

Faisons quelques essais !

SELECT PARSE ('100.000' AS int)

Alors qu’un SELECT CONVERT(int, '100.000') :

Essayons un SELECT PARSE('Lundi 16 Avril 2012' AS datetime USING 'fr-FR')

Voyons au format Anglo-Saxon : SELECT PARSE('Monday 16 April 2012' AS datetime USING 'en-US')

Quid du format que l’on nous a donné à l’école ? SELECT PARSE('Monday, April 16 2012' AS datetime USING 'en-US')

En revanche SELECT PARSE('Monday, April 16th 2012' AS datetime USING 'en-US')

Essayons SELECT PARSE('April, 16 2012' AS datetime USING 'en-US')

Voyons avec une date du calendrier Grégo-Thaï : en effet, le calendrier Grégo-Thaï à 543 ans d’avance sur le calendrier Grégorien :
SELECT PARSE(N'16 เมษายน 2555' AS datetime USING 'Th-TH')

Et avec des variables ?

1
2
3
4

DECLARE @date_string char(20) = 'Lundi 16 Avril 2012'
, @culture char(5) = 'fr-FR'

SELECT PARSE(@date_string AS datetime USING @culture)

Et dans une table :

1
2
3
4
5
6
7
8
9
10
11
12
13
14

CREATE TABLE test_PARSE
(
date_string nvarchar(20)
, culture char(5)
, formatted_date AS (PARSE(date_string AS datetime USING culture))
)
GO

INSERT INTO dbo.test_PARSE
VALUES (N'Lundi 16 Avril 2012', 'fr-FR'), (N'16 เมษายน 2555', 'th-TH')
GO

SELECT *
FROM dbo.test_PARSE

Vous vous demandez s’il sera possible de retourner une valeur décimale avec le symbole de la devise suivant une culture ? la réponse est oui : avec la fonction FORMAT(), que nous verrons au prochain épisode

Bon formatage de données !

ElSüket

Une fonction de dépouillement d’une chaîne de valeurs séparées par des virgules

elsuket — Mon, 19 Dec 2011 15:37:42 +0000

Je vous propose ici une fonction en pur T-SQL qui permet de retourner les valeurs que l’on trouve entre les virgules d’une chaîne en contenant un plus ou moins grand nombre.

Celle-ci repose sur une table de nombres, ce qui permet d’éviter de boucler par un WHILE, qui s’avère être contre-performant, SQL n’étant pas un langage itératif.

Il existe pour réaliser le même but plusieurs alternatives, la première et la plus évidente étant de créer une fonction de type table qui exécute une boucle par un WHILE en parcourant la chaîne à la recherche des valeurs entre les virgules.

Cela fonctionne très bien pour un faible nombre de valeurs, mais lorsque celui-ci grossit, et les applications, web tout particulièrement, qui sont à l’origine de ce « grossissement », le permettent facilement.

Étant donné que SQL n’est pas non plus un langage très performant sur les opérations de chaîne de caractère, on peut tout à fait se tourner vers une fonction d’assembly CLR.
L’avantage d’une telle fonction est qu’elle s’exécute très rapidement.

Malheureusement en ouvrant une base de données à l’utilisation CLR, on ouvre aussi une porte aux problèmes de sécurité, et peut-être de performance de SQL Server, qui doit instancier la CLR …

Je devais donc écrire une fonction en pur T-SQL qui fasse la même chose, avec une vitesse comparable.
Mes tests ont révélé que la fonction T-SQL est plus rapide qu’une fonction CLR, peut-être parce qu’un module CLR ne peut être exécuté que par un seul thread sous SQL Server …

Voici donc la table de nombres, très simple :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

CREATE TABLE dbo.nombre
(
nombre int NOT NULL CONSTRAINT PK_Nombres PRIMARY KEY CLUSTERED
)
GO

SET NOCOUNT ON
GO

DECLARE @max int = 300000
, @i int = 1

WHILE @i <= @max
BEGIN
INSERT dbo.nombre SELECT @i
SET @i += 1
END
GO

La variable @max représente en fait le nombre de caractère maximal que la fonction va prendre en entrée
J’ai mis 300.000 car je suis sûr avec un tel nombre de couvrir tous les cas qui se présentent en production.
Mais rien ne nous empêche de mettre plus … ou moins

Et voici la fonction :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

-------------------------------
-- Nicolas Souquet - 19/12/2011
-------------------------------
CREATE FUNCTION dbo.SplitStringToInt
(
@string AS varchar(max)
, @sep AS char(1)
)
RETURNS TABLE
AS
RETURN
SELECT CAST(SUBSTRING(@string, nombre, CHARINDEX(@sep, @string + @sep, nombre) - nombre) AS int) AS element
FROM dbo.nombre
WHERE nombre <= LEN(@string) + 1
AND SUBSTRING(@sep + @string, nombre, 1) = @sep
GO

Bon dépouillement !

ElSüket

[Snippets] Générer le script de création d’une table existante

elsuket — Wed, 28 Jan 2009 21:02:18 +0000

Voici une petite procédure stockée qui permet d’imprimer le code permettant de créer une table existante.
Il ne permet pas encore de récupérer les commandes de création des indexes attachées à la table …

---------------------------------
-- Nicolas SOUQUET - 28/01/2009 -
---------------------------------
CREATE PROCEDURE uspScripteTable
@nomTable SYSNAME,
@copie BIT = 0,
@execute BIT = 0
AS
BEGIN
SET NOCOUNT ON

DECLARE @script VARCHAR(MAX)

SELECT @script =
ISNULL(@script, '') + CHAR(9) +
COLONNES.name +
CASE
WHEN COMPCOL.object_id IS NOT NULL THEN ''
ELSE ' ' + TYPES.name
END + '' +
CASE TYPES.name
WHEN 'float' THEN '(' + CAST(COLONNES.precision AS VARCHAR) + ')'
WHEN 'decimal' THEN '(' + CAST(COLONNES.precision AS VARCHAR) + ')'
WHEN 'numeric' THEN '(' + CAST(COLONNES.precision AS VARCHAR) + ', ' + CAST(COLONNES.scale AS VARCHAR) + ')'
WHEN 'binary' THEN '(' + CAST(COLONNES.max_length AS VARCHAR) + ')'
WHEN 'varbinary' THEN '(' + CASE COLONNES.max_length WHEN -1 THEN 'max' ELSE CAST(COLONNES.max_length AS VARCHAR) END + ')'
WHEN 'char' THEN '(' + CAST(COLONNES.max_length AS VARCHAR) + ')'
WHEN 'varchar' THEN '(' + CASE COLONNES.max_length WHEN -1 THEN 'max' ELSE CAST(COLONNES.max_length AS VARCHAR) END + ')'
WHEN 'nchar' THEN '(' + CAST(COLONNES.max_length AS VARCHAR) + ')'
WHEN 'nvarchar' THEN '(' + CASE COLONNES.max_length WHEN -1 THEN 'max' ELSE CAST(COLONNES.max_length AS VARCHAR) END + ')'
ELSE ''
END +
CASE COLONNES.is_identity
WHEN 0 THEN ''
WHEN 1 THEN ' IDENTITY(' + CAST(IDENT_SEED(TABLES.name) AS VARCHAR) + ', ' + CAST(IDENT_INCR(TABLES.name) AS VARCHAR) + ')'
END +
CASE COLONNES.is_nullable
WHEN 0 THEN ' NOT NULL'
WHEN 1 THEN ' NULL'
END +
CASE
WHEN FK_COLONNES.constraint_object_id IS NULL THEN ''
ELSE ' CONSTRAINT FK_' + TABLES.name +
CASE @copie
WHEN 1 THEN '_COPIE'
ELSE ''
END
+ '_' + COLONNES.name + ' FOREIGN KEY (' + COLONNES.name + ') REFERENCES ' + SCHEMA_FK.name + '.' + TAB_FK.name + '(' + COL_FK.name + ')'
END +
CASE
WHEN DF.object_id IS NULL THEN ''
ELSE ' CONSTRAINT DF_' + TABLES.name +
CASE @copie
WHEN 1 THEN '_COPIE'
ELSE ''
END + '_' + COLONNES.name + ' DEFAULT ' + REPLACE(REPLACE(DF.definition, '(', ''), ')', '')
END +
CASE
WHEN CHK.object_id IS NULL THEN ''
ELSE ' CONSTRAINT CHK_' + TABLES.name +
CASE @copie
WHEN 1 THEN '_COPIE'
ELSE ''
END + '_' + COLONNES.name + ' CHECK (' + REPLACE(REPLACE(REPLACE(REPLACE(CHK.definition, '(', ''), ')', ''), '[', ''), ']', '') + ')'
END +
CASE
WHEN COMPCOL.object_id IS NULL THEN ''
ELSE ' AS (' + REPLACE(REPLACE(REPLACE(REPLACE(COMPCOL.definition, '(', ''), ')', ''), '[', ''), ']', '') + ')'
END +
CASE
WHEN ISNULL(INDEXES.is_primary_key, 0) = 0 THEN ''
ELSE ' CONSTRAINT PK_' + TABLES.name +
CASE @copie
WHEN 1 THEN '_COPIE'
ELSE ''
END + ' PRIMARY KEY'
END +
CASE
WHEN ISNULL(INDEXES.is_unique_constraint, 0) = 0 THEN ''
ELSE ' CONSTRAINT UQ_' + TABLES.name + '_' + COLONNES.name + ' UNIQUE'
END + ',' + CHAR(10)
FROM sys.tables AS TABLES -- Tables
INNER JOIN sys.columns AS COLONNES
ON TABLES.object_id = COLONNES.object_id -- Colonnes
INNER JOIN sys.types AS TYPES
ON COLONNES.user_type_id = TYPES.user_type_id -- types
LEFT JOIN sys.index_columns COL_INDEX -- indexes
ON COL_INDEX.object_id = COLONNES.object_id
AND COL_INDEX.column_id = COLONNES.column_id
LEFT JOIN sys.indexes AS INDEXES
ON INDEXES.object_id = COL_INDEX.object_id
AND INDEXES.index_id = COL_INDEX.index_id
LEFT JOIN sys.default_constraints AS DF -- contraintes de valeur par défaut
ON DF.parent_object_id = TABLES.object_id
AND DF.parent_column_id = COLONNES.column_id
LEFT JOIN sys.check_constraints AS CHK -- contraintes CHECK
ON CHK.parent_object_id = TABLES.object_id
AND CHK.parent_column_id = COLONNES.column_id
LEFT JOIN sys.computed_columns AS COMPCOL -- colonnes calculées
ON COMPCOL.column_id = COLONNES.column_id
AND COMPCOL.object_id = TABLES.object_id
LEFT JOIN sys.foreign_key_columns AS FK_COLONNES
ON FK_COLONNES.parent_object_id = TABLES.object_id
AND FK_COLONNES.parent_column_id = COLONNES.column_id
LEFT JOIN sys.columns AS COL_FK
ON FK_COLONNES.referenced_object_id = COL_FK.object_id
AND FK_COLONNES.referenced_column_id = COL_FK.column_id
LEFT JOIN sys.tables AS TAB_FK
ON COL_FK.object_id = TAB_FK.object_id
LEFT JOIN sys.schemas AS SCHEMA_FK
ON SCHEMA_FK.schema_id = TAB_FK.schema_id
WHERE TABLES.name = @nomTable

SELECT @script = 'CREATE TABLE ' + S.name + '.' +
CASE @copie
WHEN 1 THEN T.name + '_COPIE'
ELSE T.name
END + CHAR(10) +
'(' + CHAR(10) + SUBSTRING(@script, 1, LEN(@script) - 2) + CHAR(10) + ')'
FROM sys.schemas AS S
JOIN sys.tables AS T ON S.schema_id = T.schema_id
WHERE T.name = @nomTable

PRINT @script

IF @execute = 1
BEGIN
EXEC (@script)
END
END

ElSuket

En SQL, NULL n’est pas une valeur !

elsuket — Fri, 13 May 2011 12:54:58 +0000

Je vois encore énormément d’erreurs à ce sujet, chez les développeurs avec qui je travaille et j’ai travaillé, mais aussi sur le forum.

Voici donc la démonstration que NULL en SQL n’est pas une valeur …

C’est très simple : exécutez la requête suivante :

1
2
3

IF NULL = NULL
PRINT 'OK'
ELSE PRINT 'KO'

Vous pensez que l’on va obtenir OK … Donc vous pensez que NULL est une valeur et c’est faux : on obtiendra KO !
Vous pouvez faire l’expérience avec n’importe quel autre opérateur arithmétique (>, >=, <, <=, <>, !=) : vous obtiendrez toujours KO

Ceci prouve que NULL n’est pas une valeur : en SQL, c’est un marqueur qui signifie l’absence de valeur.
C’est d’ailleurs la raison pour laquelle en SQL, on écrit IS NULL dans un prédicat (WHERE ou JOIN), et non pas = NULL.
En revanche, dans un langage comme Java ou C#, null == null est effectivement vrai.

En effet, beaucoup de langages évaluent les expressions logiques suivant deux valeurs : true ou false.
Mais en SQL, un prédicat et évalué comme étant TRUE, FALSE ou UNKNOWN.

De la même façon, toute autre opération (NULL [operateur_arithmétique] [valeur]), peu importe le type de [valeur], retourne toujours NULL :

– NULL + 4
– NULL + ‘uneChaine’
– REPLACE(uneChaineNULL, ‘qqch’, ‘_qqch’)

Enfin, NULL est traité différemment par les différents opérateurs que l’implémentation SQL Server de SQL propose :

– Les filtres de requête (ON d’une jointure, WHERE (et AND qui suivent) et HAVING) évalueront NULL comme ne vérifiant pas le prédicat
– Une contrainte CHECK évaluera NULL comme vérifiant le prédicat
– Une contrainte UNIQUE prend NULL comme une valeur, ce qui est totalement faux
– Une opération avec les opérateurs d’ensembles UNION, EXCEPT et INTERSECT traite NULL comme une valeur, ce qui est également faux
– GROUP BY groupe tous les NULL dans un groupe distinct
– ORDER BY trie le NULL ensemble
– La fonction COUNT() tient compte de NULL
– Les autres fonctions d’agrégation n’en tiennent pas compte

Attention à NULL

ElSüket

Trouver le premier et le dernier jour de la semaine, du mois, du trimestre, et autre calculs

elsuket — Tue, 29 Mar 2011 15:04:38 +0000

Beaucoup de participants au forum SQL Server se compliquent la vie avec des calculs bizarres, à trouver le premier ou dernier jour d’un index temporel, comme celui d’une semaine, d’un mois, ou d’un trimestre.

Ces calculs se font souvent à base d’extractions de sous-chaînes après avoir converti une date en varchar(n), et on aboutit donc à des choses abominables.

Voici donc une série de calculs de valeurs, uniquement à base de fonctions de date …
Oui, les dates se manipulent avec des fonctions de date, et non pas avec des fonctions de chaîne !

J’en profite au passage pour rappeler mon billet sur le choix des types de données …

La majorité des valeurs calculées ci-dessous repose sur la différence en semaines, mois, trimestres, …, entre la date courante et le 1er Janvier 1900.
En effet, on peut introduire directement cette date par un zéro dans les fonctions de date, que SQL Server caste automatiquement, et qui donne cette date.

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

-------------------------------
-- Nicolas Souquet - 29/03/2011
-------------------------------
SELECT --*** Semaine
DATEADD(week, DATEDIFF(week, 0, GETDATE()) - 1, 0) AS premier_jour_de_la_semaine_precedente
, DATEADD(week, DATEDIFF(week, 0, GETDATE()), 0) AS premier_jour_de_la_semaine_courante
, DATEADD(week, DATEDIFF(week, 0, GETDATE()) + 1, 0) AS premier_jour_de_la_semaine_prochaine
---
, DATEADD(DAY, -1, DATEADD(week, DATEDIFF(week, 0, GETDATE()), 0)) AS dernier_jour_de_la_semaine_precedente
, DATEADD(DAY, -1, DATEADD(week, DATEDIFF(week, 0, GETDATE()) + 1, 0)) AS dernier_jour_de_la_semaine_courante
, DATEADD(DAY, -1, DATEADD(week, DATEDIFF(week, 0, GETDATE()) + 2, 0)) AS dernier_jour_de_la_semaine_prochaine
--*** Mois
, DATEADD(MONTH, DATEDIFF(MONTH, 0, GETDATE()) - 1, 0) AS premier_jour_du_mois_precedent
, DATEADD(MONTH, DATEDIFF(MONTH, 0, GETDATE()), 0) AS premier_jour_du_mois_courant
, DATEADD(MONTH, DATEDIFF(MONTH, 0, GETDATE()) + 1, 0) AS premier_jour_du_mois_prochain
---
, DATEADD(DAY, -1, DATEADD(MONTH, DATEDIFF(MONTH, 0, GETDATE()), 0)) AS dernier_jour_du_mois_precedent
, DATEADD(DAY, -1, DATEADD(MONTH, DATEDIFF(MONTH, 0, GETDATE()) + 1, 0)) AS dernier_jour_du_mois_courant
, DATEADD(DAY, -1, DATEADD(MONTH, DATEDIFF(MONTH, 0, GETDATE()) + 2, 0)) AS dernier_jour_du_mois_prochain
--*** Trimestre
, DATEADD(quarter, DATEDIFF(quarter, 0, GETDATE()) - 1, 0) AS premier_jour_du_trimestre_precedent
, DATEADD(quarter, DATEDIFF(quarter, 0, GETDATE()), 0) AS permier_jour_du_trimestre_courant
, DATEADD(quarter, DATEDIFF(quarter, 0, GETDATE()) + 1, 0) AS premier_jour_du_trimestre_prochain
---
, DATEADD(DAY, -1, DATEADD(quarter, DATEDIFF(quarter, 0, GETDATE()), 0)) AS dernier_jour_du_trimestre_precedent
, DATEADD(DAY, -1, DATEADD(quarter, DATEDIFF(quarter, 0, GETDATE()) + 1, 0)) AS dernier_jour_du_trimestre_courant
, DATEADD(DAY, -1, DATEADD(quarter, DATEDIFF(quarter, 0, GETDATE()) + 2, 0)) AS dernier_jour_du_trimestre_prochain
--*** Semestre
, DATEADD(MONTH, ((DATEDIFF(quarter, 0, GETDATE()) / 2) * 6) - 6, 0) AS premier_jour_du_semestre_precedent
, DATEADD(MONTH, (DATEDIFF(quarter, 0, GETDATE()) / 2) * 6, 0) AS premier_jour_du_semestre_courant
, DATEADD(MONTH, ((DATEDIFF(quarter, 0, GETDATE()) / 2) * 6) + 6, 0) AS premier_jour_du_semestre_prochain
---
, DATEADD(DAY, -1, DATEADD(MONTH, (DATEDIFF(quarter, 0, GETDATE()) / 2) * 6, 0)) AS dernier_jour_du_semestre_precedent
, DATEADD(DAY, -1, DATEADD(MONTH, ((DATEDIFF(quarter, 0, GETDATE()) / 2) * 6) + 6, 0)) AS dernier_jour_du_semestre_courant
, DATEADD(DAY, -1, DATEADD(MONTH, ((DATEDIFF(quarter, 0, GETDATE()) / 2) * 6) + 12, 0)) AS dernier_jour_du_semestre_prochain
--*** Annee
, DATEADD(YEAR , DATEDIFF(YEAR, 0, GETDATE()) - 1, 0) AS premier_jour_annee_precedente
, DATEADD(YEAR , DATEDIFF(YEAR, 0, GETDATE()), 0) AS premier_jour_annee_courante
, DATEADD(YEAR , DATEDIFF(YEAR, 0, GETDATE()) + 1, 0) AS premier_jour_annee_suivante
---
, DATEADD(DAY, -1, DATEADD(YEAR , DATEDIFF(YEAR, 0, GETDATE()), 0)) AS dernier_jour_annee_precedente
, DATEADD(DAY, -1, DATEADD(YEAR , DATEDIFF(YEAR, 0, GETDATE()) + 1, 0)) AS dernier_jour_annee_courante
, DATEADD(DAY, -1, DATEADD(YEAR , DATEDIFF(YEAR, 0, GETDATE()) + 2, 0)) AS dernier_jour_annee_suivante
--*** Siècle
, DATEADD(YEAR, -YEAR(GETDATE()) % 100, DATEADD(YEAR , DATEDIFF(YEAR, 0, GETDATE()), 0)) AS premier_jour_du_siecle_courant
, DATEADD(YEAR, -YEAR(GETDATE()) % 100 + 100, DATEADD(DAY, -1, DATEADD(YEAR , DATEDIFF(YEAR, 0, GETDATE()), 0))) AS dernier_jour_du_siecle_courant

J’ai eu un peu la flemme sur le siècle, et j’ai trouvé comme prétexte pour m’arrêter que cela ne doit pas présenter grand intérêt

Bon calculs sur les dates !

ElSüket

Voir l’historique d’exécution des jobs par une requête

elsuket — Fri, 24 Jul 2009 06:00:00 +0000

Si la visionneuse du journal est pratique pour voir l’historique des exécutions d’un job, comment peut-on voir s’il existe des jobs dont l’exécution a échoué (ou réussi) pour pouvoir l’encapsuler dans une application ou un rapport SSRS par exemple ?

Les tables système de la base de données MSDB nous permettent de spécifier une requête nous permettant de retrouver tous les informations dont nous avons besoin à propos des jobs :

– msdb.dbo.sysjobs stocke la liste de tous les jobs présents sur l’instance, qu’ils soient activés ou non
– msdb.dbo.sysjobhistory stocke la liste de toutes les exécutions des jobs et de leurs étapes
– msdb.dbo.sysjobsteps stocke la description de toutes les étapes de tous les jobs de l’instance

Voici donc, par exemple, comment retrouver tous les échecs pour le job nommé ‘TEST’, avec leur date :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

---------------------------------
-- Nicolas SOUQUET - 24/07/2009 -
---------------------------------
SELECT nomJob,
CAST(STUFF(STUFF(runDateTime, 12, 0, ':'), 15, 0, ':') AS DATETIME) AS DateEchecExecJob
FROM
(
SELECT J.name AS nomJob,
CAST(H.run_date AS CHAR(8)) + ' ' +
CASE LEN(CAST(H.run_time AS VARCHAR(6)))
WHEN 5 THEN '0' + CAST(H.run_time AS CHAR(5))
ELSE CAST(H.run_time AS CHAR(6))
END AS runDateTime
FROM msdb.dbo.sysjobs J
JOIN msdb.dbo.sysjobhistory H
ON J.job_id = H.job_id
WHERE J.name = 'TEST'
AND J.enabled = 1 -- Le job est activé
AND H.run_status = 0 -- 0 : Echec | 1 : Réussite
AND H.step_id = 0 -- quelle que soit l'étape du job
) AS JOB_FAILED_EXEC (nomJob, runDateTime)

Et si l’on veut être relativement complet :

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

---------------------------------
-- Nicolas SOUQUET - 24/07/2009 -
---------------------------------
SELECT nomJob
, nomEtapeJob
, numeroEtapeJob
, msgEtape
, CAST(STUFF(STUFF(dateExecutionEtape, 12, 0, ':'), 15, 0, ':') AS DATETIME) AS dateExecutionEtape
, dureeExecutionEtape
, statutExecutionEtape
FROM
(
SELECT J.name AS nomJob
, S.step_name AS nomEtapeJob
, S.step_id AS numeroEtapeJob
, ISNULL('Erreur : ' + M.description, H.message) AS msgEtape
, CAST(H.run_date AS CHAR(8)) + ' ' +
CASE LEN(CAST(H.run_time AS VARCHAR(6)))
WHEN 1 THEN '00000' + CAST(H.run_time AS CHAR(1))
WHEN 2 THEN '0000' + CAST(H.run_time AS CHAR(2))
WHEN 3 THEN '000' + CAST(H.run_time AS CHAR(3))
WHEN 4 THEN '00' + CAST(H.run_time AS CHAR(4))
WHEN 5 THEN '0' + CAST(H.run_time AS CHAR(5))
ELSE CAST(H.run_time AS CHAR(6))
END AS dateExecutionEtape
, CASE LEN(CAST(H.run_duration AS VARCHAR(10)))
WHEN 1 THEN '00:00:0' + CAST(H.run_duration AS CHAR(1))
WHEN 2 THEN '00:00:' + CAST(H.run_duration AS CHAR(2))
WHEN 3 THEN '00:0' + STUFF(CAST(H.run_duration AS CHAR(3)), 2, 0, ':')
WHEN 4 THEN '00:' + STUFF(CAST(H.run_duration AS CHAR(4)), 3, 0, ':')
WHEN 5 THEN '0' + STUFF(STUFF(CAST(H.run_duration AS CHAR(5)), 2, 0, ':'), 5, 0, ':')
WHEN 6 THEN STUFF(STUFF(CAST(H.run_duration AS CHAR(6)), 3, 0, ':'), 6, 0, ':')
END AS dureeExecutionEtape
, CASE H.run_status
WHEN 0 THEN 'FAILED'
WHEN 1 THEN 'SUCCESS'
WHEN 2 THEN 'RETRY'
WHEN 3 THEN 'CANCELED'
WHEN 4 THEN 'RUNNING' -- Pas fiable
END AS statutExecutionEtape
FROM msdb.dbo.sysjobs AS J
INNER JOIN msdb.dbo.sysjobsteps AS S
ON J.job_id = S.job_id
INNER JOIN msdb.dbo.sysjobhistory AS H
ON S.job_id = H.job_id
AND S.step_id = H.step_id
LEFT JOIN sys.sysmessages AS M
ON H.sql_message_id = M.error
) AS JOB_CHARACTERISTICS (nomJob, nomEtapeJob, numeroEtapeJob, msgEtape, dateExecutionEtape, dureeExecutionEtape, statutExecutionEtape)

ElSuket

Quelle différences y-a-t-il entre TRUNCATE et DELETE ?

elsuket — Fri, 21 May 2010 06:03:41 +0000

TRUNCATE et DELETE peuvent avoir le même effet sur une table si le DELETE n’a pas de clause WHERE.
Mais est-ce bien la même chose qui se passe au niveau des données ?

En réalité, ces deux instructions ont bien des éléments qui les différencient :

=> TRUNCATE est une instruction DDL, alors que DELETE est une instruction DML.
Conséquence directe : TRUNCATE ne peut pas avoir de clause WHERE.

=> TRUNCATE ne peut pas être exécuté :

sur une table disposant de contraintes d’intégrité (clé primaire référencée par au moins une table, et clés étrangères)
sur une table qui est répliquée
dans une base de données répliquée par envoi de journaux

DELETE peut l’être si les contraintes d’intégrité restent respectées.

=> TRUNCATE ne déclenche pas un trigger sur DELETE, ce qui est le cas pour DELETE.
Donc l’utilisation de TRUNCATE peut causer des problèmes de consistance des données, car si l’on a supprimé les contraintes d’intégrité pour pouvoir exécuter un TRUNCATE, le traitement du trigger sur DELETE ne sera pas exécuté non plus.

=> TRUNCATE enregistre dans le fichier du journal des transactions les pages de données désallouées, et supprime les pointeurs des index.
C’est ce qui fait que TRUNCATE est plus rapide à s’exécuter que DELETE : TRUNCATE utilise très peu de verrous par rapport à DELETE, qui nécessite dont plus de ressources disque.
En effet, DELETE enregistre dans le fichier du journal des transactions toutes les données de chaque ligne affectée par l’instruction.
En realité donc, TRUNCATE n’efface pas les données contenues dans les pages, mais marque celles-ci comme réutilisables.
DELETE en revanche supprime physiquement les données.

=> En conséquence, les données supprimées par un DELETE sont restaurables; les données « supprimées » par un TRUNCATE ne le sont pas.

=> TRUNCATE réinitialise la valeur d’une colonne de type entier avec la propriété d’auto-incrémentation (IDENTITY). DELETE laisse cette valeur inchangée.

Et bonne suppression de données

ElSüket.

Lister quelques propriétés des logins

elsuket — Thu, 11 Feb 2010 03:01:37 +0000

Voici une petite requête qui retourne quelques propriétés pour tous les logins d’un instance SQL Server, avec la prochaine date d’expiration des mots de passe …

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

-------------------------------
-- 22/01/2010 - Nicolas SOUQUET
-------------------------------
WITH
LOGIN_PROPERTIES AS
(
SELECT SP.name
, SP.type_desc
, SP.is_disabled
, SP.create_date
, SP.modify_date
, SP.default_database_name AS default_db
, SP.default_language_name AS default_lang
, CAST(LOGINPROPERTY(SP.name, 'PasswordLAstSetTime') AS DATETIME) AS password_last_set_time
, CAST(LOGINPROPERTY(SP.name, 'DaysUntilExpiration') AS DATETIME) AS days_until_expiration
FROM sys.server_principals AS SP
)
SELECT name
, type_desc
, is_disabled
, create_date
, modify_date
, default_db
, default_lang
, password_last_set_time
, DATEADD(day, -DATEDIFF(day, password_last_set_time, GETDATE()), GETDATE()) + days_until_expiration AS password_expiry_date
FROM LOGIN_PROPERTIES

Bonne sécurisation !

ElSuket

Vérifier la validité d’une adresse e-mail

elsuket — Mon, 09 Nov 2009 22:13:45 +0000

Voici un petit snippet pour vérifier la validité d’une adresse mail, histoire d’assurer un minimum d’intégrité à l’aide d’une contrainte de domaine vérifiée par cette fonction :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

-------------------------------
-- Nicolas SOUQUET - 09/11/2009
-------------------------------
CREATE FUNCTION Fn_CheckMail
(@_mail VARCHAR(320))
RETURNS BIT
WITH SCHEMABINDING
AS
BEGIN
RETURN CASE
WHEN CHARINDEX(' ', LTRIM(RTRIM(@_mail))) = 0 -- Pas d'espaces
AND LEFT(LTRIM(@_mail), 1) '@' -- '@' ne peut pas être le premier caractère de l'adresse
AND RIGHT(RTRIM(@_mail), 1) '.' -- '.' ne peut pas être le dernier caractère de l'adresse
AND LEN(LTRIM(RTRIM(@_mail))) - LEN(REPLACE(LTRIM(RTRIM(@_mail)), '@', '')) = 1 -- Un seul '@'
AND CHARINDEX('.', @_mail, CHARINDEX('@', @_mail)) - CHARINDEX('@', @_mail) > 1 -- Il doit y avoir un '.' après l'@
AND CHARINDEX('.', REVERSE(LTRIM(RTRIM(@_mail)))) >= 3 -- le nom de domaine doit se terminer avec au moins 2 caractères
AND CHARINDEX('.@', @_mail) = 0 -- pas de '.@'
AND CHARINDEX('..', @_mail) = 0 -- pas de '..'
AND LEN(LEFT(@_mail, CHARINDEX('@', @_mail) - 1)) <= 64 -- la partie locale ne peut excéder 64 caractères
AND LEN(RIGHT(@_mail, LEN(@_mail) - CHARINDEX('@', @_mail))) <= 250 -- la partie nom de domaine ne peut excéder 250 caractères
THEN CAST(1 AS BIT)
ELSE CAST(0 AS BIT)
END
END

Et voici comment ajouter la contrainte à la table-exemple suivante :

1
2
3
4
5
6
7
8
9
10
11

CREATE TABLE TbClient
(
IDClient INT NOT NULL CONSTRAINT PK_TbClient PRIMARY KEY,
NumeroClient INT NOT NULL CONSTRAINT UQ_TbClient_NumeroClient UNIQUE,
NomClient VARCHAR(32) NOT NULL,
PrenomClient VARCHAR(32) NOT NULL,
mailClient VARCHAR(320) NOT NULL
)

ALTER TABLE dbo.TbClient
ADD CONSTRAINT CHK_TbClient_mailClient CHECK (dbo.Fn_CheckMail(mailClient) = 1)

ElSuket

Utiliser le type TABLE avec SQL Server 2008

elsuket — Tue, 03 Nov 2009 17:15:50 +0000

Il est parfois nécessaire de créer un curseur pour exécuter une procédure stockée sur chacune des lignes du curseur, en passant en paramètre les valeurs des colonnes de la requête qui spécifie le curseur.
SQL Server 2008 a introduit le type TABLE, qui permet de spécifier par un type des variables de type TABLE.
Cette solution est une alternative moins pire que le curseur : voyons comment l’utiliser (avec modération !)

=> Créons tout d’abord un type qui structurera les variables de type TABLE que nous allons utiliser :

1
2
3
4

CREATE TYPE dbo.TyTbNombres AS TABLE
(
unNombre TINYINT
)

=> Créons une procédure stockée acceptant en entrée un paramètre de type TABLE

1
2
3
4
5
6
7

CREATE PROCEDURE PsTest
@uneTable dbo.TyTbNombres READONLY
AS
BEGIN
SELECT unNombre
FROM @uneTable
END

=> Dans le code de la procédure stockée appelante :

1
2
3
4

DECLARE @maTable dbo.TyTbNombres
INSERT INTO @maTable VALUES (1), (2), (3)

EXEC dbo.PsTest @maTable

Il est ensuite simple, dans la procédure stockée appelée, en l’occurence PsTest, de spécifier une jointure sur la variable de type table …

ElSuket

Lister tous les types de données utilisés pour les colonnes des tables d’une base de données sous SQL Server 2005 et 2008

elsuket — Fri, 30 Oct 2009 17:45:50 +0000

Voici une petite requête qui permet de lister tous les types de données utilisés pour les colonnes des tables d’une base de données …

Si on ne souhaite connaître que les types de données :

1
2
3
4
5
6
7
8
9
10

-------------------------------
-- Nicolas SOUQUET - 30/10/2009
-------------------------------
SELECT DISTINCT TY.name AS nomType
FROM sys.TABLES AS T
JOIN sys.COLUMNS AS C
ON T.object_id = C.object_id
JOIN sys.types AS TY
ON C.user_type_id = TY.user_type_id
ORDER BY TY.name

On peut aussi simplement connaître le nombre d’utilisations de tous les types utilisés :

1
2
3
4
5
6
7
8
9
10
11
12

-------------------------------
-- Nicolas SOUQUET - 30/10/2009
-------------------------------
SELECT TY.name AS nomType,
COUNT(*) AS nbUtilisationsType
FROM sys.tables AS T
JOIN sys.columns AS C
ON T.object_id = C.object_id
JOIN sys.types AS TY
ON C.user_type_id = TY.user_type_id
GROUP BY TY.name
ORDER BY TY.name

ElSuket

Créer des captures instantanées de bases de données

elsuket — Mon, 06 Apr 2009 22:06:03 +0000

Même en phase de développement, il est important de sauvegarder une base de données.
On peut estimer qu’il n’est pas nécessaire de mettre en place une stratégie de sauvegarde, et, comme une erreur arrive vite lors des tests unitaires, il faut que l’on puisse replacer la base de données avec le jeu de données qui a été altéré par un test, sans perdre le travail de plusieurs développeurs.
Si les captures instantanées de bases de données ne permettent pas de protéger complètement l’intégrité d’une base de données, elles sont très utiles si l’on veut se prémunir des erreurs de l’utilisateur pour « restaurer » les valeurs d’une table ou récupérer une procédure stockée …

Tout d’abord, qu’est-ce qu’une capture instantanée de base de données ?
C’est une vue statique, en lecture seule, d’une base de données source.
Dès lors les possibilités offertes par cette fonctionnalité dépassent ce qui est décrit en introduction, et on peut tout à fait s’en servir pour des statistiques, d’autant que tout comme une base de données en ligne, on peut en supprimer les objets.

La commande T-SQL qui permet de créer une capture instantanée de base de données est simple :

1
2
3

CREATE DATABASE maBD_Snapshot
ON (NAME = nomDesFichiersLogiquesDeDonnees, FILENAME = 'C:\maBD_Snapshot.ext'
AS SNAPSHOT OF maBD

Après la création d’une capture instantanée de base de données, vous noterez en lisant de contenu de la table système sys.databases que la colonne source_database_id est valuée seulement pour celle-ci.
Vous verrez également sous Management Studio apparaître la node « Captures instantanées de base de données » sous la node « Bases de données ». En la déployant, vous trouverez la capture que vous venez de réaliser.

Ainsi, pour restaurer les valeurs d’une table de la base de données en ligne avec les valeurs contenues avant une erreur, il suffit d’écrire :

1
2
3
4
5
6
7

---------------------------------
-- Nicolas SOUQUET - 06/04/2009 -
---------------------------------
UPDATE maBD.monSchema.maTable
SET mesColonnes = SNAP.mesColonnes
FROM maBD.monSchema.maTable AS CIBLE
JOIN maBDSnapshot.monSchema.maTable AS SNAP ON CIBLE.PK_ID = SNAP ON.PK_ID

Et pour restaurer la base de données à partir d’une de ses captures instantanées :

1
2
3

USE master
RESTORE DATABASE maBD
FROM DATABASE_SNAPSHOT = 'maBDSnaphot'

Attention : il est nécessaire que la capture instantanée de données que l’on souhaite restaurer soit la seule capture instantanée de la base de données à restaurer. Dans le cas contraire, on obtiendra l’erreur suivante, qui n’en laisse rien voir :

Msg 3137, Level 16, State 4, Line 1
Impossible de restaurer la base de données. Le nom primaire ou le nom de la capture instantanée a été spécifié de façon incorrecte, toutes les autres captures instantanées ont été supprimées, ou il manque des fichiers.
Msg 3013, Level 16, State 1, Line 1
RESTORE DATABASE s’est terminé anormalement.

Il devient ensuite simple de créer un job qui se chargera de créer régulièrement une capture instantanée de votre base de données. La commande T-SQL de ce job pourrait être :

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

---------------------------------
-- Nicolas SOUQUET - 06/04/2009 -
---------------------------------
-- Création d'une nouvelle capture instantanée de base de données
DECLARE @nomSnapshot SYSNAME
SELECT @nomSnapshot = 'maBD_' + REPLACE(REPLACE(CONVERT(CHAR(10), GETDATE(), 103) + '_' + CONVERT(CHAR(8), GETDATE(), 108), '/', '_'), ':', '_')

DECLARE @SQL VARCHAR(256)
SET @SQL = 'CREATE DATABASE ' + @nomSnapshot
+ ' ON (NAME = nomDesFichiersLogiquesDeDonneesDeMaBD, FILENAME = ''C:\' + @nomSnapshot + '.snap'')'
+ ' AS SNAPSHOT OF maBD'

EXEC (@SQL)

-- Suppression des anciennes captures instantanées de base de données
DECLARE curSnapshots CURSOR FOR
SELECT name
FROM sys.databases
WHERE source_database_id IS NOT NULL
AND name <> @nomSnapshot
FOR READ ONLY

OPEN curSnapshots
FETCH NEXT FROM curSnapshots INTO @nomSnapshot
WHILE @@FETCH_STATUS = 0
BEGIN
SET @SQL = 'DROP DATABASE ' + @nomSnapshot
EXEC (@SQL)
FETCH NEXT FROM curSnapshots INTO @nomSnapshot
END

DEALLOCATE curSnapshots

Il vous suffit ensuite de planifier le job pour voir celui-ci s’exécuter à une fréquence qui vous garantisse un minimum de perte de données.

Enfin, s’il est clair qu’une capture de base de données ne vaut pas une bonne stratégie de sauvegarde de base de données, on peut restaurer une base de données à partir d’une capture de celle-ci :

1 2	RESTORE DATABASE maBD FROM DATABASE_SNAPSHOT = maBD_Snapshot

Voici un bout de code à placer dans un job pour créer des captures instantanées de toutes les bases de données sauf les bases de données système :

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

---------------------------------
-- Nicolas SOUQUET - 06/04/2009 -
---------------------------------
DECLARE @SQL VARCHAR(256)

---------------------------------------------------------------------
-- Suppression des anciennes captures instantanées de base de données
---------------------------------------------------------------------
DECLARE curSnapshots CURSOR FOR
SELECT name
FROM sys.databases
WHERE source_database_id IS NOT NULL
AND create_date < CAST(FLOOR(CAST(GETDATE() AS FLOAT)) AS DATETIME)
FOR READ ONLY

DECLARE @nomSnapshot SYSNAME

OPEN curSnapshots
FETCH NEXT FROM curSnapshots INTO @nomSnapshot
WHILE @@FETCH_STATUS = 0
BEGIN
SET @SQL = 'DROP DATABASE ' + @nomSnapshot
EXEC (@SQL)
FETCH NEXT FROM curSnapshots INTO @nomSnapshot
END

DEALLOCATE curSnapshots

--------------------------------------------
-- Captures instantanées de bases de données
--------------------------------------------
DECLARE curBD CURSOR FOR
SELECT name
FROM sys.databases
WHERE source_database_id IS NULL
AND name NOT IN ('master', 'tempdb', 'model', 'msdb', 'ReportServer', 'ReportServerTempDB')
AND state_desc = 'ONLINE'
FOR READ ONLY

DECLARE @NomBD SYSNAME,
@ListeFichiers VARCHAR(255)

OPEN curBD
FETCH NEXT FROM curBD INTO @NomBD
WHILE @@FETCH_STATUS = 0
BEGIN
SET @ListeFichiers = NULL

SELECT @ListeFichiers = ISNULL(@ListeFichiers, '') +
'(NAME = ' + MF.name + ', FILENAME = ''C:\' + MF.name + '.snap'')' + ', '
FROM sys.master_files AS MF
JOIN sys.databases AS D ON D.database_id = MF.database_id
WHERE D.name = @NomBD
AND MF.type = 0 -- fichiers de données

SELECT @ListeFichiers = SUBSTRING(@ListeFichiers, 1, LEN(@ListeFichiers) - 1)

SET @SQL = 'CREATE DATABASE ' + @NomBD + '_' + REPLACE(REPLACE(CONVERT(CHAR(10), GETDATE(), 103) + '_' + CONVERT(CHAR(8), GETDATE(), 108), '/', '_'), ':', '_')
+ ' ON ' + @ListeFichiers +
+ ' AS SNAPSHOT OF ' + @NomBD

EXEC (@SQL)
FETCH NEXT FROM curBD INTO @NomBD
END

DEALLOCATE curBD

ElSuket

[Snippets] Manipuler un fichier texte d’une colonne comme une table d’une colonne

elsuket — Thu, 12 Feb 2009 18:56:20 +0000

Voyons comment on peut rendre abstraite la notion de fichier en T-SQL en combinant les commandes OPENROWSET et les vénérables CTE …

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

---------------------------------
-- Nicolas SOUQUET - 12/02/2009 -
---------------------------------
WITH
CTE_IMPORT AS
(
SELECT BulkColumn
FROM OPENROWSET(BULK 'C:\monFichier.txt', SINGLE_CLOB) TMP
),
CTE_INDICES_LIGNES (Deb, Fin) AS
(
SELECT 1 Deb,
CHARINDEX(CHAR(10), CTE_IMPORT.BulkColumn + CHAR(10)) Fin
FROM CTE_IMPORT
UNION ALL
SELECT CAST(CTE_INDICES_LIGNES.Fin + 1 AS INT),
CHARINDEX(CHAR(10), CTE_IMPORT.BulkColumn + CHAR(10), CTE_INDICES_LIGNES.Fin + 1)
FROM CTE_IMPORT, CTE_INDICES_LIGNES
WHERE CHARINDEX(CHAR(10), CTE_IMPORT.BulkColumn + CHAR(10), CTE_INDICES_LIGNES.Fin + 1 ) > 0
)
SELECT SUBSTRING(BulkColumn, CTE_INDICES_LIGNES.Deb, CTE_INDICES_LIGNES.Fin - CTE_INDICES_LIGNES.Deb) AS Colonne
FROM CTE_INDICES_LIGNES
CROSS JOIN CTE_IMPORT
WHERE CTE_INDICES_LIGNES.Deb <> CTE_INDICES_LIGNES.Fin

Comme on peut s’y attendre, c’est particulièrement contre-performant :
en activant SET STATISTICS IO puis SET STATISTICS TIME, on obtient successivement, pour un fichier contenant 50 lignes:

Table ‘Worktable’. Nombre d’analyses 3, lectures logiques 810
Temps UC = 40 ms, temps écoulé = 101 ms.

Ce snippet s’avère donc utile pour faire un import d’un faible de nombre de lignes sans passer par une table de base de données, mais il est à éviter pour faire des import massifs.
L’utilisation de la CTE permet de plus de réaliser des jointures …

ElSuket

Les dates et le type DATETIME sous SQL Server

elsuket — Sat, 27 Jun 2009 06:32:18 +0000

Sujet maintes fois abordé pour un problème de format, la gestion des dates sous SQL Server est pourtant très simple si l’on se sert, comme d’habitude, des standards …

Très souvent on demande comment faire pour afficher une date sous tel ou tel format, ou encore pourquoi en stockant une date sous tel format, Enterprise Manager ou SQL Server Management Studio les affichent sous la forme AAAA-MM-JJ hh:mm:ss.

Il faut d’abord savoir comment sont stockées les données de type DATETIME : deux entiers, chacun de 4 octets :
– un entier pour la date elle-même
– un entier pour les heures/minutes/secondes/millisecondes.

Ceci explique pourquoi, lorsqu’on écrit :

1 2	SELECT maDate , maDate - 1 AS hier FROM dbo.Table

les valeurs contenues dans la colonne « hier » sont plus vieilles d’exactement un jour par rapport à la colonne maDate.

Passons maintenant aux divers format proposés par la fonction CONVERT() : cette fonction permet de choisir un style d’affichage, mais en aucun cas il ne spécifie une date.

C’est pourquoi on peut utiliser la fonction CONVERT() pour obtenir une date à partir d’une chaîne de caractères, et inversement, en spécifiant le style de la chaîne qui représente une date

=>SELECT CONVERT(DATETIME, '26/06/2006', 103)

affiche 2006-06-26 00:00:00.000 sous SQL Server Management Studio ou Enterprise Manager, mais là encore ce n’est qu’une représentation de la date.

Nous avons du spécifier que le format de la chaîne à convertir est le 103, c’est à dire le format français, avec des slashes pour séparer les parties d’une date, et une année sur 4 chiffres (sinon c’est le style « 3 », pour spécifier une année sur deux chiffres).

Inversement :

=>SELECT CONVERT(CHAR(10), GETDATE(), 103)

La fonction GETDATE() retourne la date courante en utilisant le type de données DATETIME (donc deux entiers de 4 octets).
L’exécution de cette dernière requête retourne 26/06/2009.

——————–
— Normalisation —
——————–
Supposons que nous avons totalement normalisé tous les échanges de données entre nos applications et la base de données.
Nous utilisons donc le format ISO, c’est à dire AAAAMMJJ, que SQL Server sait transformer au type DATETIME, directement avec la fonction CAST, qui permet de s’affranchir de tout format de date :

=>SELECT CAST('20090626' AS DATETIME)

affiche bien 2009-06-26 00:00:00.000 sous SQL Server Management Studio ou Enterprise Manager

De même si nous voulons en plus préciser l’heure :

=>SELECT CAST('20090626 22:14:03.257' AS DATETIME)

affiche 2009-06-26 22:14:03.257 sous SQL Server Management Studio ou Enterprise Manager

Dès lors dans le cas d’une application internationalisée, l’application peut communiquer des dates au format ISO, et les afficher suivant le format de la nationalité de l’utilisateur.

ElSuket

Suivre les sauvegardes de base de données avec MSDB

elsuket — Sat, 27 Jun 2009 07:17:56 +0000

Comment suivre l’évolution des sauvegardes de base de données avec une requête sur la base de données système MSDB ?

L’exécution de la requête suivante montre, pour chaque sauvegarde de base de données :

– l’heure de début,
– l’heure de fin,
– la durée,
– la taille,
– l’emplacement du fichier de sauvegarde,
– quelques autres caractéristiques de la sauvegarde …

---------------------------------
-- Nicolas SOUQUET - 27/06/2009 -
---------------------------------
SELECT database_name,
physical_drive,
physical_name,
physical_device_name,
logical_name,
CAST(SUM(file_size) / 1048576 AS NUMERIC (10, 2)) AS Taille,
name,
user_name,
database_creation_date,
backup_start_date,
backup_finish_date,
Duree,
Type,
server_name,
machine_name,
recovery_model,
is_snapshot,
is_damaged,
has_incomplete_metadata
FROM
(
SELECT F.physical_drive,
F.physical_name,
F.logical_name,
F.file_size,
S.name,
S.user_name,
S.database_creation_date,
S.backup_start_date,
S.backup_finish_date,
CASE LEN(CAST(DATEDIFF(second, S.backup_start_date, S.backup_finish_date) / 3600 AS VARCHAR(4)))
WHEN 1 THEN '0' + CAST(DATEDIFF(second, S.backup_start_date, S.backup_finish_date) / 3600 AS VARCHAR(4))
ELSE CAST(DATEDIFF(second, S.backup_start_date, S.backup_finish_date) / 3600 AS VARCHAR(4))
END + ':' +
CASE LEN(CAST(DATEDIFF(second, S.backup_start_date, S.backup_finish_date) / 60 % 60 AS VARCHAR(2)))
WHEN 1 THEN '0' + CAST(DATEDIFF(second, S.backup_start_date, S.backup_finish_date) / 60 % 60 AS VARCHAR(2))
ELSE CAST(DATEDIFF(second, S.backup_start_date, S.backup_finish_date) / 60 % 60 AS VARCHAR(2))
END + ':' +
CASE LEN(CAST(DATEDIFF(second, S.backup_start_date, S.backup_finish_date) % 60 AS VARCHAR(2)))
WHEN 1 THEN '0' + CAST(DATEDIFF(second, S.backup_start_date, S.backup_finish_date) % 60 AS VARCHAR(2))
ELSE CAST(DATEDIFF(second, S.backup_start_date, S.backup_finish_date) % 60 AS VARCHAR(2))
END Duree,
CASE S.type
WHEN 'D' THEN 'Base de données - Complet'
WHEN 'I' THEN 'Base de données - Différentiel'
WHEN 'L' THEN 'Journal de transactions'
WHEN 'F' THEN 'Fichier ou groupe de fichiers'
WHEN 'G' THEN 'Fichier - Différentiel'
WHEN 'P' THEN 'Partiel'
WHEN 'Q' THEN 'Partiel - Différentiel'
END Type,
S.database_name,
S.server_name,
S.machine_name,
S.recovery_model,
S.is_snapshot,
S.is_damaged,
S.has_incomplete_metadata,
FAM.physical_device_name
FROM msdb.dbo.backupfile AS F
JOIN msdb.dbo.backupset AS S
ON F.backup_set_id = S.backup_set_id
JOIN msdb.dbo.backupmediafamily AS FAM
ON FAM.media_set_id = S.media_set_id
WHERE S.backup_start_date BETWEEN CAST(FLOOR(CAST(GETDATE()- 2 AS FLOAT)) AS DATETIME) AND GETDATE()
) AS SUB
GROUP BY physical_drive,
physical_name,
physical_device_name,
logical_name,
name,
user_name,
database_creation_date,
backup_start_date,
backup_finish_date,
Duree,
Type,
database_name,
server_name,
machine_name,
recovery_model,
is_snapshot,
is_damaged,
has_incomplete_metadata
ORDER BY database_name, backup_start_date

ElSuket

Découper une chaîne en sous-chaînes de longueur fixe

elsuket — Wed, 01 Jul 2009 06:12:23 +0000

Certains me désignent sur le forum SQL Server comme l’homme qui murmure à l’oreille des CTE.
En voici donc une nouvelle !

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

---------------------------------
-- Nicolas SOUQUET - 01/07/2009 -
---------------------------------
DECLARE @toto VARCHAR(50) = 'ABCDEFGHIJKLM'
SELECT LEN(@toto)

;WITH
CTE AS
(
SELECT SUBSTRING(@toto, 1, 4) AS sousChaine,
1 AS nFinSousChaine
UNION ALL
SELECT SUBSTRING(@toto, nFinSousChaine + 4, 4) AS sousChaine,
nFinSousChaine + 4 AS nFinSousChaine
FROM CTE
WHERE nFinSousChaine <= LEN(@toto)
)
SELECT sousChaine
FROM CTE
WHERE nFinSousChaine <= LEN(@toto)

Retourne :

sousChaine
———-
ABCD
EFGH
IJKL
M

ElSuket

Consulter l’historique des restaurations de bases de données

elsuket — Thu, 30 Jul 2009 17:09:21 +0000

Voici une petite requête qui permet de voir toutes les restaurations de bases de données d’une instance …

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

---------------------------------
-- Nicolas SOUQUET - 30/07/2009 -
---------------------------------
SELECT H.restore_date,
H.destination_database_name,
H.user_name,
CASE restore_type
WHEN 'D' THEN 'Base de données'
WHEN 'F' THEN 'Fichier'
WHEN 'G' THEN 'Groupe de fichiers'
WHEN 'I' THEN 'Différentiel'
WHEN 'L' THEN 'Fichier du journal des transactions'
WHEN 'V' THEN 'Vérification'
WHEN 'R' THEN 'Par capture instantanée'
END AS restore_type,
F.destination_phys_name
FROM msdb.dbo.restorehistory AS H
JOIN msdb.dbo.restorefile AS F
ON H.restore_history_id = F.restore_history_id

Facile à placer dans un rapport SSRS

ElSuket

Différence entre LOGIN et USER, entre connexion et utilisateur

elsuket — Mon, 06 Jul 2009 20:25:01 +0000

Quelle est la différence entre une connexion, ou LOGIN, et un utilisateur de base de données ?

Une connexion, ou login, permet d’accéder à une instance de SQL Server, mais c’est tout.
Une instance de SQL Server pouvant héberger plusieurs bases de données utilisateur, nous ne souhaitons peut-être pas que tous les utilisateurs aient accès à toutes les bases de données d’une instance, et de la même façon.
On peut aussi créer une connexion à un utilisateur pour qu’il puisse seulement effectuer des sauvegardes de base de données

A toute connexion|login, peut correspondre un utilisateur de base de données.
L’utilisateur de base de données est alors « mappé » sur une connexion, qui le donne le droit de naviguer dans 0 à autant de bases de données que l’instance en héberge.
Un administrateur ou les personnes à qui l’administrateur en a délégué le droit peuvent accorder des droits d’accès et des privilèges.

Un droit d’accès permet à un utilisateur de naviguer dans une base de données suivant des privilèges que l’administrateur lui a octroyés.
Un privilège permet de limiter l’accès aux données, par exemple en refusant le droit de SELECT sur la colonne salaire de la table des employés aux utilisateurs employés.

On peut encore gérer plus globalement au niveau de la base de données ou de l’instance les accès aux données en créant des rôles : on affecte ainsi au rôle des droits d’accès et des privilèges, et lors de l’arrivée d’un nouvel utilisateur, il nous suffit de l’ajouter au rôle de base de données.

Pour créer une connexion :

CREATE LOGIN monLogin WITH PASSWORD = 'monMotDePasse'

Pour permettre la navigation dans la base de données :

1
2
3

USE maBD
GO
CREATE USER monUtilisateur FOR LOGIN monLogin

On peut créer de plusieurs façon un rôle :

=> Soit par « recopie » des drois d’un utilisateur :

1
2
3

USE maBD;
CREATE ROLE monRole AUTHORIZATION unUtilsateur;
GO

=> Soit par recopie d’un rôle de base de données existant :

1
2
3

USE maBD;
CREATE ROLE monRole AUTHORIZATION db_securityadmin;
GO

Pour gérer les privilèges, on peut voir la documentation des instructions GRANT, REVOKE et DENY

On peut également réaliser tout cela à l’aide de SQL Server Management Studio :

– Pour la création de la connexion, ouvrez la node « Sécurité » de votre instance, puis faites un clic-droit sur la node « Connexions », et choisissez « Nouvelle connexion »

– Pour la création de l’utilisateur, après avoir ouvert la node possédant le nom de la base de données en question, ouvrez la node « Sécurité », puis cliquez-droit sur la node « Utilisateurs » en choisissant « Nouvel utilisateur »

Un peu de lecture par ici et ici, par SQLPro

ElSuket

Suivre les plans de maintenance

elsuket — Thu, 09 Jul 2009 20:15:56 +0000

Comment savoir si un plan de maintenance s’est correctement exécuté ?
Comment savoir combien de temps a duré son exécution ?

Une requête simple dans la base de données système MSDB nous donne la réponse …
Valable sous SQL Server 2000 et ultérieur

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

---------------------------------
-- Nicolas SOUQUET - 09/07/2009 -
---------------------------------
SELECT plan_name,
database_name,
activity,
start_time,
end_time,
CASE LEN(CAST(duration / 3600 AS VARCHAR(4)))
WHEN 1 THEN '0' + CAST(duration / 3600 AS VARCHAR(4))
ELSE CAST(duration / 3600 AS VARCHAR(4))
END + ':' +
CASE LEN(CAST(duration / 60 % 60 AS VARCHAR(2)))
WHEN 1 THEN '0' + CAST(duration / 60 % 60 AS VARCHAR(2))
ELSE CAST(duration / 60 % 60 AS VARCHAR(2))
END
+ ':' +
CASE LEN(CAST(duration % 60 AS VARCHAR(2)))
WHEN 1 THEN '0' + CAST(duration % 60 AS VARCHAR(2))
ELSE CAST(duration % 60 AS VARCHAR(2))
END Durée
FROM msdb.dbo.sysdbmaintplan_history
WHERE succeeded = 0 -- 0 : échec | 1 : réussite
-- AND start_time BETWEEN '20090907' AND '20090908'
ORDER BY database_name, start_time

Il est dès lors facile de placer cette requête dans un DataSet sous Reporting Services ou dans une application WinForms pour pouvoir s’afficher l’état des plans de maintenance qui doivent avoir lieu sur une instance de SQL Server

ElSuket

Créer une table de dates

elsuket — Fri, 10 Jul 2009 18:23:08 +0000

Pourquoi ne pas créer une table de dates pour se faciliter les recherches dans des tables suivant la colonne de type date qu’elles contiennent ?
On peut vous demander par exemple de rechercher la quantité d’eau consommée par un parc de machines pour la deuxième semaine de chaque mois d’une année.
Imaginez un peu la complexité de la requête à écrire …
Voyons comment on peut résoudre cette demande très facilement en créant une table de dates …

Voici donc notre table :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

---------------------------------
-- Nicolas SOUQUET - 10/07/2009 -
---------------------------------
CREATE TABLE TbDates
(
date DATETIME NOT NULL CONSTRAINT PK_TbDates_date PRIMARY KEY,
annee AS (YEAR(date)) PERSISTED NOT NULL,
mois AS(MONTH(date)) PERSISTED NOT NULL,
semaineDansAnnee AS(DATEPART(week, date)) PERSISTED NOT NULL,
semaineDansMois AS(DATEPART(week, date) - DATEPART(week, DATEADD(day, -DATEPART(day, date) + 1, date)) + 1) PERSISTED NOT NULL,
jourDansAnnee AS (DATEPART(dayofyear, date)) PERSISTED NOT NULL,
jourDansMois AS(DAY(date)) PERSISTED NOT NULL,
jourDansSemaine TINYINT NULL CONSTRAINT CHK_TbDates_jourDansSemaine CHECK(jourDansSemaine BETWEEN 0 AND 7),
)
GO

Comme toutes les colonnes sont calculées à l’exception de jourDansSemaine (parce que la fonction DATEPART(weekday, date) n’est pas déterministe, elle ne peut pas être utilisée comme spécification d’une colonne calculée), nous n’aurons donc qu’à insérer les dates dans la colonne date.

Comment allons-nous valuer la colonne jourDansSemaine ? Avec le trigger suivant :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

---------------------------------------------------------------------------------
-- Nicolas SOUQUET - 10/07/2009 - Déclencheur qui calcule le jour de la semaine -
-- pour la table dbo.TbDates -
---------------------------------------------------------------------------------
CREATE TRIGGER TR_A_I_TbDates
ON dbo.TbDates
AFTER INSERT
AS
BEGIN
SET NOCOUNT ON

UPDATE dbo.TbDates
SET jourDansSemaine = DATEPART(weekday, D.date)
FROM dbo.TbDates AS D
JOIN INSERTED AS I
ON D.date = I.date
END
GO

Et pour stocker les dates, il suffira d’exécuter la procédure stockée suivante :

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

-----------------------------------------------------------------------------------------
-- Nicolas SOUQUET - 10/07/2009 - Procédure de génération de tous les jours d'une année -
-----------------------------------------------------------------------------------------
ALTER PROCEDURE Ps_GenereDatesAnnee
@annee SMALLINT
AS
BEGIN
SET NOCOUNT ON

DECLARE @dateDeb DATETIME,
@dateFin DATETIME

SELECT @dateDeb = CAST(CAST(@annee AS VARCHAR) + '0101' AS DATETIME),
@dateFin = CAST(CAST(@annee AS VARCHAR) + '1231' AS DATETIME)

;WITH
CTE_DATES AS
(
SELECT @dateDeb AS Date
UNION ALL
SELECT Date + 1
FROM CTE_DATES
WHERE Date <= @dateFin
)
SELECT Date
FROM CTE_DATES
WHERE Date <= @dateFin
OPTION (MAXRECURSION 366)
END

Ainsi pour stocker tous les jours de l’année 2009, il suffira d’exécuter :

1
2
3
4
5
6
7
8
9
10
11
12

---------------------------------
-- Nicolas SOUQUET - 10/07/2009 -
---------------------------------
ALTER TABLE dbo.TbDates
ALTER COLUMN jourDansSemaine TINYINT NULL
GO
INSERT INTO dbo.TbDates (date)
EXEC dbo.Ps_GenereDatesAnnee 2009
GO
ALTER TABLE dbo.TbDates
ALTER COLUMN jourDansSemaine TINYINT NOT NULL
GO

Pour voir ce que contient la table après cette insertion :

1
2
3
4
5

---------------------------------
-- Nicolas SOUQUET - 10/07/2009 -
---------------------------------
SELECT date, annee, mois, semaineDansAnnee, semaineDansMois, jourDansAnnee, jourDansMois, jourDansSemaine
FROM dbo.TbDates

Finalement, pour rechercher la quantité d’eau consommée par un parc de machines pour la deuxième semaine de chaque mois de l’année 2009, nous devrons écrire :

1
2
3
4
5
6
7
8
9

---------------------------------
-- Nicolas SOUQUET - 10/07/2009 -
---------------------------------
SELECT SUM(T.conso) AS consoDeuxiemeSemaine2009
FROM dbo.maTable AS T
JOIN dbo.TbDates AS D
ON T.colonneDate = D.date
WHERE D.semaineDansLeMois = 2
AND D.annee = 2009

Une autre exemple : rechercher la consommation moyenne d’eau par semaine dans le mois, pour toute l’année 2009 :

1
2
3
4
5
6
7
8
9
10
11
12
13
14

---------------------------------
-- Nicolas SOUQUET - 10/07/2009 -
---------------------------------
SELECT semaineDansLeMois, AVG(consoSemaine)
FROM
(
SELECT D.semaineDansLeMois, SUM(T.conso) AS consoSemaine
FROM dbo.maTable AS T
JOIN dbo.TbDates AS D
ON T.colonneDate = D.date
WHERE D.annee = 2009
GROUP BY D.semaineDansLeMois
) AS SUB (semaineDansLeMois, consoSemaine)
GROUP BY semaineDansLeMois

ElSuket

Détecter un caractère unicode dans une chaîne de caractères

elsuket — Fri, 17 Jul 2009 16:30:46 +0000

Voici une petite fonction qui permet de vérifier la présence d’un caractère qui n’est pas supporté par la norme ASCII dans une chaîne de caractères …

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

---------------------------------
-- Nicolas SOUQUET - 17/07/2009 -
---------------------------------
CREATE FUNCTION Fn_CheckUnicode (@chaine NVARCHAR(MAX))
RETURNS BIT
WITH SCHEMABINDING
AS
BEGIN
DECLARE @i INT,
@lgr INT,
@caractere NCHAR(1),
@contientCaractereUnicode BIT

SELECT @i = 1,
@lgr = LEN(@chaine),
@contientCaractereUnicode = 0

WHILE @i <= @lgr AND @contientCaractereUnicode = 0
BEGIN
SELECT @caractere = SUBSTRING(@chaine, @i, 1)

IF ASCII(@caractere) <> UNICODE(@caractere)
BEGIN
SET @contientCaractereUnicode = 1
END

SET @i = @i + 1
END

RETURN @contientCaractereUnicode
END

Et un exemple d’utilisation :

1
2
3
4

---------------------------------
-- Nicolas SOUQUET - 17/07/2009 -
---------------------------------
SELECT dbo.Fn_CheckUnicode(N'toto')

retourne 0

1
2
3
4

---------------------------------
-- Nicolas SOUQUET - 17/07/2009 -
---------------------------------
SELECT dbo.Fn_CheckUnicode(N'สtวัoสtดีo')

retourne 1.

Ajouter des contraintes à des tables déjà existantes

elsuket — Sat, 25 Jul 2009 14:07:42 +0000

Comment peut-on ajouter des contraintes de tous types à une table qui existe déjà, mais dont on a modifié la structure ou tout simplement oublié d’ajouter la contrainte en même temps que la colonne ?

Considérons le DDL des tables suivantes :

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

---------------------------------
-- Nicolas SOUQUET - 25/07/2009 -
---------------------------------
CREATE TABLE TbPays
(
IDPays INT IDENTITY,
nomPays VARCHAR(30),
prefixeTelephonique VARCHAR(4),
longueurNumeroTelephone TINYINT
)

CREATE TABLE TbClient
(
IDClient INT IDENTITY,
nomClient VARCHAR(20),
IDPays INT,
numeroTelephoneClient VARCHAR(36)
)

CREATE TABLE TbAbonnement
(
IDAbonnement INT IDENTITY,
referenceAbonnement CHAR(10),
nomAbonnement VARCHAR(30),
descriptionAbonnemement VARCHAR(255)
)

CREATE TABLE TbAbonnementClient
(
IDAbonnementClient INT IDENTITY,
IDClient INT,
IDAbonnement INT,
dateAbonnementClient DATETIME
)

Manifestement il manque toutes les contraintes :

– de valuation obligatoire (NOT NULL),
– de clé primaire,
– de clé étrangère,
– d’unicité,
– de valeur par défaut
– de domaine (CHECK)

Le squelette d’ajout de contraintes est le suivant :

1
2
3

---------------------------------
-- Nicolas SOUQUET - 25/07/2009 -
---------------------------------

=> contraintes de valuation obligatoire

1 2	ALTER TABLE maTable ALTER COLUMN maColonne memeType NOT NULL

=> contraintes de clé primaire

1
2
3

ALTER TABLE maTable
ADD CONSTRAINT PK_maTable
PRIMARY KEY (colonnesConstituantLaCléPrimaire)

=> contraintes de clé étrangère

1
2
3
4

ALTER TABLE maTable
ADD CONSTRAINT FK_maTable_colonneDeCleEtrangere
FOREIGN KEY(colonneDeCleEtrangere)
REFERENCES tableContenantLaClePrimaireAReferencer(colonneDeClePrimaire)

=> contraintes d’unicité

1
2
3

ALTER TABLE maTable
ADD CONSTRAINT UQ_maTable_colonnesConstituantLeTupleQuiDoitEtreUnique
UNIQUE (colonnesConstituantLeTupleQuiDoitEtreUnique)

=> contraintes de valeur par défaut :

1
2
3

ALTER TABLE maTable
ADD CONSTRAINT DF_maTable_maColonne
DEFAULT (uneValeur) FOR (maColonne)

=> contraintes de domaine (CHECK)
ALTER TABLE maTable
ADD CONSTRAINT CHK_maTable_maColonne
CHECK(maColonne [formuleDeVerification]

Définissons les dans cet ordre :

=> Contraintes de valuation obligatoire

Une clé primaire ne pouvant logiquement pas être NULL, nous devons définir toute les colonnes qui vont servir de clé primaire aux tables comme ne pouvant pas être NULL.
Nous devons également obliger la valuation des colonnes qui sont des clés naturelles, et celles qui seront clé étrangère :

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

---------------------------------
-- Nicolas SOUQUET - 25/07/2009 -
---------------------------------
-- TbPays
ALTER TABLE dbo.TbPays
ALTER COLUMN IDPays INT NOT NULL

ALTER TABLE dbo.TbPays
ALTER COLUMN nomPays VARCHAR(30) NOT NULL

ALTER TABLE dbo.TbPays
ALTER COLUMN prefixeTelephonique VARCHAR(4) NOT NULL

ALTER TABLE dbo.TbPays
ALTER COLUMN longueurNumeroTelephone TINYINT NOT NULL

-- TbClient
ALTER TABLE dbo.TbClient
ALTER COLUMN IDClient INT NOT NULL

ALTER TABLE dbo.TbClient
ALTER COLUMN nomClient VARCHAR(20) NOT NULL

ALTER TABLE dbo.TbClient
ALTER COLUMN IDPays INT NOT NULL

ALTER TABLE dbo.TbClient
ALTER COLUMN numeroTelephoneClient VARCHAR(36) NOT NULL

-- TbAbonnement
ALTER TABLE dbo.TbAbonnement
ALTER COLUMN IDAbonnement INT NOT NULL

ALTER TABLE dbo.TbAbonnement
ALTER COLUMN referenceAbonnement NOT NULL

ALTER TABLE dbo.TbAbonnement
ALTER COLUMN nomAbonnement VARCHAR(30) NOT NULL

-- TbAbonnementClient
ALTER TABLE dbo.TbAbonnementClient
ALTER COLUMN IDAbonnementClient INT NOT NULL

ALTER TABLE dbo.TbAbonnementClient
ALTER COLUMN IDClient INT NOT NULL

ALTER TABLE dbo.TbAbonnementClient
ALTER COLUMN IDAbonnement INT NOT NULL

ALTER TABLE dbo.TbAbonnementClient
ALTER COLUMN dateAbonnementClient DATETIME NOT NULL

=> Contraintes de clé primaire

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

---------------------------------
-- Nicolas SOUQUET - 25/07/2009 -
---------------------------------
-- TbPays
ALTER TABLE dbo.TbPays
ADD CONSTRAINT PK_TbPays_IDPays PRIMARY KEY (IDPays)

-- TbClient
ALTER TABLE dbo.TbClient
ADD CONSTRAINT PK_TbClient_IDClient PRIMARY KEY(IDClient)

-- TbAbonnement
ALTER TABLE dbo.TbAbonnement
ADD CONSTRAINT PK_TbAbonnement_IDAbonnement PRIMARY KEY (IDAbonnement)

-- TbAbonnementClient
ALTER TABLE dbo.TbAbonnementClient
ADD CONSTRAINT PK_TbAbonnementClient_IDAbonnementClient PRIMARY KEY (IDAbonnementClient)

=> Contraintes de clé étrangère

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

---------------------------------
-- Nicolas SOUQUET - 25/07/2009 -
---------------------------------
-- TbClient
ALTER TABLE dbo.TbClient
ADD CONSTRAINT FK_TbClient_IDPays
FOREIGN KEY (IDPays) REFERENCES dbo.TbPays(IDPays)

-- TbAbonnementClient
ALTER TABLE dbo.TbAbonnementClient
ADD CONSTRAINT FK_TbAbonnementClient_IDClient
FOREIGN KEY (IDClient) REFERENCES dbo.TbClient(IDClient),
----
CONSTRAINT FK_TbAbonnementClient_IDAbonnement
FOREIGN KEY (IDAbonnement) REFERENCES dbo.TbAbonnement(IDAbonnement)

=> Contraintes d’unicité

Elles permettent de s’assurer qu’aucune valeur ne sera pas insérée en double dans des colonnes qui ne constituent pas la clé primaire.
Bien qu’une clé primaire permette également d’assurer l’unicité, on ne peut bien sûr en définir qu’une seule par table, pour qu’il soit possible de la référencer par des clés étrangères dans d’autres tables.
Au contraire, on peut définir plusieurs contraintes d’unicité par table.

Similairement, des indexes sont créés implicitement lors de la création d’une clé primaire ou d’une contrainte d’unicité.
Mais seul l’index de clé primaire est toujours cluster : l’index sous-jacent à une contrainte d’unicité est cluster si la table n’a pas de clé primaire définie, et non-cluster à l’inverse.
Comme pour une clé primaire, il est nécessaire de mettre la colonne qui a la sélectivité la plus élevée en premier dans la définition de la contrainte d’unicité, car cet ordre sert dans la définition de l’index.
Comme les recherches à travers les indexes se font suivant la valeur de la première clé, l’index sera d’autant plus efficace que la valeur de sa première clé sera sélective.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

---------------------------------
-- Nicolas SOUQUET - 25/07/2009 -
---------------------------------
-- TbClient
ALTER TABLE dbo.TbClient
ADD CONSTRAINT UQ_TbClient_nomClient UNIQUE (nomClient),
CONSTRAINT UQ_TbClient_numeroTelephoneClient UNIQUE (numeroTelephoneClient)

-- TbAbonnement
ALTER TABLE dbo.TbAbonnement
ADD CONSTRAINT UQ_TbAbonnement_nomAbonnement UNIQUE (nomAbonnement)

ALTER TABLE dbo.TbAbonnement
ADD CONSTRAINT UQ_TbAbonnement_referenceAbonnement UNIQUE (referenceAbonnement)

-- TbAbonnementClient
ALTER TABLE dbo.TbAbonnementClient
ADD CONSTRAINT UQ_TbAbonnementClient_IDClient_IDAbonnement UNIQUE(IDClient, IDAbonnement)

=> Contraintes de valeur par défaut :

Il peut être intéressant de définir une valeur par défaut pour l’insertion (mais pas à l’UPDATE) d’une nouvelle ligne à une table si la colonne est omise dans la spécification de l’instruction INSERT :

1
2
3
4
5
6

---------------------------------
-- Nicolas SOUQUET - 25/07/2009 -
---------------------------------
ALTER TABLE dbo.TbAbonnementClient
ADD CONSTRAINT DF_TbAbonnementClient_dateAbonnementClient
DEFAULT (GETDATE()) FOR dateAbonnementClient

Ainsi si nous écrivons :

1
2
3
4
5
6
7
8
9
10
11
12
13

---------------------------------
-- Nicolas SOUQUET - 25/07/2009 -
---------------------------------
INSERT INTO dbo.TbAbonnementClient
(
IDClient,
IDAbonnement
)
VALUES
(
@IDClient,
@IDAbonnement
)

la colonne dateAbonnementClient sera valuée à la date actuelle du système.

=> Contraintes de domaine

Elles permettent de limiter ou de vérifier les valeurs que peuvent contenir une colonne.
Elles nécessitent une formule de vérification, qui peut être spécifiée directement lors de la définition de la contrainte, ou bien à travers une fonction définie par l’utilisateur.
L’utilisation d’une fonction pour la définition d’une contrainte de domaine permet bien souvent de ne pas avoir recours à un déclencheur pour vérifier la validité des données.

Ici, nous souhaitons vérifier que les numéros de téléphone que nous stockons dans la base de données contiennent le préfixe du pays du client, et que la longueur des numéros de téléphone est correcte.
Pour cela nous créons la fonction suivante :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

---------------------------------
-- Nicolas SOUQUET - 25/07/2009 -
---------------------------------
CREATE FUNCTION Fn_IsNumTelClient_Correct
(
@IDPays INT,
@numeroTelephoneClient VARCHAR(36)
)
RETURNS BIT
WITH SCHEMABINDING
AS
BEGIN
RETURN
(
SELECT CASE
WHEN @numeroTelephoneClient LIKE prefixeTelephonique + '%'
AND LEN(@numeroTelephoneClient) = longueurNumeroTelephone
THEN CAST(1 AS BIT)
ELSE CAST(0 AS BIT)
END
FROM dbo.TbPays
WHERE IDPays = @IDPays
)
END

La contrainte de domaine sera alors définie comme suit :

1
2
3
4
5
6

---------------------------------
-- Nicolas SOUQUET - 25/07/2009 -
---------------------------------
ALTER TABLE dbo.TbAbonnementClient
ADD CONSTRAINT CHK_TbAbonnementClient_numeroTelephoneClient
CHECK(dbo.Fn_IsNumTelClient_Correct(IDPays, numeroTelephoneClient) = 1)

Nous souhaitons également vérifier que les valeurs de la colonne referenceAbonnement de la table TbAbonnement aient le format XXX-nnn-nn.
Là nous pouvons définir celui-ci directement dans la spécification de la contrainte :

1
2
3
4
5
6

---------------------------------
-- Nicolas SOUQUET - 25/07/2009 -
---------------------------------
ALTER TABLE dbo.TbAbonnement
ADD CONSTRAINT CHK_TbAbonnement_referenceAbonnement
CHECK(referenceAbonnement LIKE '[A-Z][A-Z][A-Z]-[0-9][0-9][0-9]-[0-9][0-9]')

ElSuket

Une fonction d’extraction des nombres contenus dans une chaîne de caractères : les fonctions ISNUMERIC() et ASCII()

elsuket — Tue, 09 Jun 2009 22:16:05 +0000

Voici une petite fonction qui vous permettra d’extraire les nombres contenus dans une chaîne de caractères, et de les retourner comme un entier…

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

---------------------------------
-- Nicolas SOUQUET - 09/06/2009 -
---------------------------------
CREATE FUNCTION dbo.FnTrouveChiffres(@string VARCHAR(1024))
RETURNS INT
WITH SCHEMABINDING
AS
BEGIN
DECLARE @result VARCHAR(1024)

IF ISNUMERIC(@string) = 1
BEGIN
SET @result = @string
END
ELSE
BEGIN
DECLARE @i INT,
@Lgr INT,
@char CHAR(1)

SELECT @i = 1,
@Lgr = LEN(@string),
@result = ''

WHILE @i <= @Lgr
BEGIN
SELECT @char = SUBSTRING(@string, @i, 1)

IF ISNUMERIC(@char) = 1
BEGIN
SET @result = @result + @char
END

SET @i = @i + 1
END
END
RETURN CAST(@result AS INT)
END

Vous pouvez utiliser cette fonction si vous êtes certain que votre chaîne ne contiendra jamais les symboles arithmétiques « + » et « -« .
En effet, la fonction ISNUMERIC() retourne 1 (vrai) pour ces deux symboles.

Il existe une autre solution avec la fonction ASCII() :

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

---------------------------------
-- Nicolas SOUQUET - 09/06/2009 -
---------------------------------
ALTER FUNCTION [dbo].[FnTrouveChiffres](@string VARCHAR(1024))
RETURNS INT
WITH SCHEMABINDING
AS
BEGIN
DECLARE @result VARCHAR(1024)

DECLARE @i INT,
@Lgr INT,
@char CHAR(1)

SELECT @i = 1,
@Lgr = LEN(@string),
@result = ''

WHILE @i <= @Lgr
BEGIN
SELECT @char = SUBSTRING(@string, @i, 1)

IF ASCII(@char) BETWEEN 48 AND 57
BEGIN
SET @result = @result + @char
END

SET @i = @i + 1
END

RETURN CAST(@result AS INT)
END

ElSuket

Stocker simplement tout types de fichiers dans une table en utilisant le type de données VARBINARY et les BLOBs

elsuket — Thu, 25 Jun 2009 23:26:28 +0000

Voici comment copier le contenu d’un fichier contenu sur un disque dur pour le stocker dans une table, à l’aide de la commande OPENROWSET et de son option BULK …

Supposons que nous avons la table suivante, dans laquelle nous stockons des icônes :

1
2
3
4
5
6
7
8
9

---------------------------------
-- Nicolas SOUQUET - 26/06/2009 -
---------------------------------
CREATE TABLE dbo.TbIcone
(
IDIcone INT IDENTITY CONSTRAINT PK_TbIcone PRIMARY KEY,
nomIcone VARCHAR(255) NOT NULL,
icone VARBINARY(MAX)
)

Et voici la procédure stockée qui va permettre de stocker des icônes stockées sur un des disques dur, simplement en passant son UNC en paramètre :

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

---------------------------------
-- Nicolas SOUQUET - 26/06/2009 -
---------------------------------
CREATE PROCEDURE PsStockeIcone
@cheminDuFichier VARCHAR(255)
AS
BEGIN
SET NOCOUNT ON

DECLARE @SQL NVARCHAR(256),
@ParamDefinition NVARCHAR(64),
@nomDeFichier VARCHAR(64)

SELECT @SQL = N'SELECT @fluxOUT = BulkColumn FROM OPENROWSET(BULK N''' + @cheminDuFichier + ''', SINGLE_BLOB) AS TMP',
@ParamDefinition = N'@fluxOUT VARBINARY(MAX) OUTPUT',
@nomDeFichier = RIGHT(@cheminDuFichier, CHARINDEX('\', REVERSE(@cheminDuFichier)) - 1)

-- Récupère le fichier sous la forme d'une valeur binaire
DECLARE @fluxFichier VARBINARY(MAX)

EXEC sp_executesql
@SQL,
@ParamDefinition,
@fluxFichier OUTPUT

-- Stocke le flux dans la table
INSERT INTO dbo.TbIcone
(
nomIcone,
icone
)
VALUES
(
@nomDeFichier,
@fluxFichier
)
END

Je souhaite stocker l’image suivante (C:\SQLServer2008Dark.jpg) :

1
2
3
4
5
6
7
8

---------------------------------
-- Nicolas SOUQUET - 26/06/2009 -
---------------------------------
EXEC dbo.PsStockeIcone 'C:\SQLServer2008Dark.jpg'
GO

SELECT IDIcone, nomIcone, icone
FROM dbo.TbIcone

Notons que cette procédure fonctionne dès SQL Server 2005.

ElSuket

Exporter le code de vues, procédures stockées, triggers, fonctions SQL vers un fichier

elsuket — Thu, 25 Jun 2009 21:59:43 +0000

Pour effectuer une revue de code ou pour gérer des versions de code en phase de développement, il peut être intéressant d’exporter les codes des modules SQL vers un fichier.
Voyons comment réaliser cela, à l’aide de l’utilitaire en ligne de commande BCP …

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

--------------------------------------------------------------------------------------
-- Nicolas SOUQUET - 25/06/2009 - Exporter le code de modules dans un fichier unique -
--------------------------------------------------------------------------------------
SELECT SQL.definition + CHAR(10) + CHAR(13) + 'GO' AS CodeModule
INTO ##MODULES
FROM sys.objects AS OBJETS
JOIN sys.sql_modules AS SQL ON SQL.object_id = OBJETS.object_id
WHERE OBJETS.type IN ('P', 'V', 'TR', 'FN', 'IF', 'TF')
AND OBJETS.name NOT LIKE 'dt%' AND OBJETS.name NOT LIKE 'sp%'
ORDER BY OBJETS.object_id

DECLARE @szBCP VARCHAR(256);
SET @szBCP = 'bcp "SELECT CodeModule FROM ##MODULES" queryout C:\ModulesSQL.sql -T -c';
EXEC master.dbo.xp_cmdshell @szBCP;

DROP TABLE ##MODULES;

----------------------------------------------------------------------------------------------------
-- Nicolas SOUQUET - 25/06/2009 - Exporter le code de plusieurs modules avec un fichier par module -
----------------------------------------------------------------------------------------------------
-->>>> A EXECUTER DANS LE CONTEXTE DE LA BD DEPUIS LAQUELLE ON SOUHAITE RÉALISER L'EXPORT
SET NOCOUNT ON

DECLARE CUR_MODULES CURSOR FOR
SELECT name
FROM sys.objects
WHERE type IN ('P', 'V', 'TR', 'FN', 'IF', 'TF')
-- AND name LIKE '%blablabla%'
FOR READ ONLY

DECLARE @szNomModule SYSNAME
OPEN CUR_MODULES
FETCH NEXT FROM CUR_MODULES INTO @szNomModule
WHILE @@FETCH_STATUS = 0
BEGIN
SELECT definition
INTO ##MODULE_TEXT
FROM sys.sql_modules
WHERE OBJECT_NAME(object_id) = @szNomModule

DECLARE @szBCP VARCHAR(512);
SET @szBCP = 'bcp "SELECT definition FROM ##PROC_TEXT" queryout C:\' + @szNomModule + '.sql -T -c';
EXEC master.dbo.xp_cmdshell @szBCP, NO_OUTPUT

DROP TABLE ##MODULE_TEXT;
FETCH NEXT FROM CUR_MODULES INTO @szNomModule
END
DEALLOCATE CUR_MODULES

ElSuket

Rechercher une chaîne de caractère dans le code des modules SQL sous SQL Server 2005 et 2008

elsuket — Mon, 18 May 2009 17:11:35 +0000

Il arrive parfois de vouloir chercher un bout de code dans toutes les procédures stockées d’une base de données, comme par exemple le nom d’une colonne.

Voyons comment réaliser cela avec une simple requête …

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

---------------------------------
-- Nicolas SOUQUET - 18/05/2009 -
---------------------------------
/*
Valable pour les objets dont le type est :
- Procédure stockée SQL (P)
- Procédure de filtre de réplication (RF)
- Vues (V)
- Déclencheur DML SQL (TR)
- Fonction scalaire (FN)
- Fonction table incluse SQL (IF)
- Fonction table SQL (TF)
- Règle (R)
*/
SELECT O.type_desc,
O.name,
O.create_date,
O.modify_date,
M.Definition
FROM sys.objects O
JOIN sys.sql_modules M ON M.object_id = O.object_id
WHERE O.name NOT LIKE 'dt%'
AND O.name NOT LIKE 'sys%'
--AND O.type = 'P' -- Filtre sur le type d'objet
AND M.Definition LIKE '%codeARechercher%'
ORDER BY O.Name

Une seule instruction DROP pour supprimer plusieurs objets de base de données de même type

elsuket — Mon, 08 Jun 2009 22:05:00 +0000

Voici comment, dans la même instruction, supprimer plusieurs procédures stockées ou tables …

Supposons que nous voulons supprimer quatre tables dont les noms sont :

– Client
– Client_Commande
– Client_Livraison
– Livraison

On peut écrire :

1
2
3
4
5
6
7
8
9
10
11

---------------------------------
-- Nicolas SOUQUET - 08/06/2009 -
---------------------------------
DROP TABLE dbo.Client
GO
DROP TABLE dbo.Client_Commande
GO
DROP TABLE dbo.Client_Livraison
GO
DROP TABLE dbo.Livraison
GO

Et dès lors si l’on veut supprimer un jeu de procédures stockées correspondant à certains critères, on se voir obligé d’écrire :

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

---------------------------------
-- Nicolas SOUQUET - 08/06/2009 -
---------------------------------
DECLARE curProcedures CURSOR FOR
SELECT name
FROM sys.procedures
WHERE name LIKE '%client%'
OR name LIKE '%livraison%'
FOR READ ONLY

DECLARE @nomProc SYSNAME,
@SQL VARCHAR(128)

OPEN curProcedures
FETCH NEXT FROM curProcedures INTO @nomProc
WHILE @@FETCH_STATUS = 0
BEGIN
SET @SQL = 'DROP PROCEDURE dbo.' + @nomProc

PRINT @nomProc
EXEC (@SQL)

FETCH NEXT FROM curProcedures INTO @nomProc
END

DEALLOCATE curProcedures

Mais la syntaxe suivante est aussi valable :

1
2
3
4

---------------------------------
-- Nicolas SOUQUET - 08/06/2009 -
---------------------------------
DROP TABLE dbo.Client, dbo.Client_Commande, dbo.Client_Livraison, dbo.Livraison

Et on peut alors écrire :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

---------------------------------
-- Nicolas SOUQUET - 08/06/2009 -
---------------------------------
DECLARE @SQL NVARCHAR(2048),
@separateur NCHAR(6)

SET @separateur = N', dbo.'

SELECT @SQL = ISNULL(@SQL, '') + name + @separateur
FROM sys.procedures
WHERE name LIKE '%client%'
OR name LIKE '%livraison%'

SELECT @SQL = 'DROP PROCEDURE ' + LEFT(@SQL, LEN(@SQL) - LEN(@separateur))

PRINT @SQL
EXEC (@SQL)

ElSuket

Concaténer les valeurs d’une colonne dans une variable

elsuket — Tue, 07 Apr 2009 21:11:22 +0000

Il est souvent demandé s’il est possible de concaténer les valeurs d’une colonne dans une variable, éventuellement en les séparant avec un symbole de ponctuation.
Voici comment faire, sans curseur ni expression de table commune …

Supposons la table suivante :

1
2
3
4
5

CREATE TABLE TABLE_TEST
(
Lettre CHAR(1)
)
GO

Et le jeu de données suivant :

1
2
3
4
5

INSERT INTO dbo.TABLE_TEST (Lettre) VALUES ('A')
INSERT INTO dbo.TABLE_TEST (Lettre) VALUES ('B')
INSERT INTO dbo.TABLE_TEST (Lettre) VALUES ('C')
INSERT INTO dbo.TABLE_TEST (Lettre) VALUES ('D')
GO

Si l’on souhaite concaténer les valeurs de la colonne Lettre dans une variable de type chaîne de caractère, avec par exemple une virgule comme séparateur, il suffit d’écrire :

1
2
3
4
5
6

---------------------------------
-- Nicolas SOUQUET - 07/04/2009 -
---------------------------------
DECLARE @concat VARCHAR(128)
SELECT @concat = ISNULL(@concat, '') + Lettre + ','
FROM dbo.TABLE_TEST

Et l’on obtient ainsi :

A, B, C, D,

Pour aller plus loin, mais cette fois avec une expression de table commune

ElSuket

Comparaison des temps d’exécution entre un curseur et une requête SQL

elsuket — Sun, 05 Apr 2009 14:40:48 +0000

Je vois souvent sur le forum SQL Server l’utilisation de curseurs alors qu’une vraie requête SQL pourrait le remplacer.
Outre le fait que les curseurs datent de COBOL (1956 …), et que leur spécification en COBOL et T-SQL est similaire à s’y méprendre, comparons donc les temps d’exécution entre un curseur et une requête sur un traitement très simple …

Ce test a été réalisé sur mon ordinateur personnel, dont voici la configuration matérielle :

– Windows XP SP3
– 2 Go de RAM
– CPU Intel Core 2 Duo à 2.13 GHz

Voici les requêtes :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

---------------------------------
-- Nicolas SOUQUET - 05/04/2009 -
---------------------------------
SET NOCOUNT ON
GO

CREATE TABLE BASE_DATA
(
ID INT IDENTITY CONSTRAINT PK_BASE_DATA PRIMARY KEY,
Nombre INT CONSTRAINT DF_BASE_DATA_Nombre DEFAULT 0
)
GO

INSERT INTO dbo.BASE_DATA VALUES (DEFAULT)
GO 10

Le contenu de la table BASE_DATA après ces deux requêtes est le suivant :

ID          Nombre
----------- -----------
1           0
2           0
3           0
4           0
5           0
6           0
7           0
8           0
9           0
10          0

Voici la requête avec le curseur :

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

---------------------------------
-- Nicolas SOUQUET - 05/04/2009 -
---------------------------------
DECLARE @dateDeb DATETIME
DECLARE @dateFin DATETIME
DECLARE @ID INT

SET @dateDeb = GETDATE()

DECLARE cur CURSOR FOR
SELECT ID
FROM dbo.BASE_DATA
FOR UPDATE OF Nombre

OPEN cur
FETCH NEXT FROM cur INTO @ID
WHILE @@FETCH_STATUS = 0
BEGIN
UPDATE dbo.BASE_DATA
SET Nombre = 10 * @ID
WHERE ID = @ID

FETCH NEXT FROM cur INTO @ID
END
SET @dateFin = GETDATE()
DEALLOCATE cur

SELECT DATEDIFF(millisecond, @dateDeb, @dateFin)

Et la requête avec UPDATE :

1 2	UPDATE BASE_DATA SET Nombre = 10 * ID

Entre chaque exécution, j’ai augmenté le nombre de lignes suivant les puissances de 10 :

1
2
3
4
5
6
7
8
9
10
11
12
13

---------------------------------
-- Nicolas SOUQUET - 05/04/2009 -
---------------------------------
INSERT INTO dbo.BASE_DATA VALUES (DEFAULT)
GO 90
INSERT INTO dbo.BASE_DATA VALUES (DEFAULT)
GO 900
INSERT INTO dbo.BASE_DATA VALUES (DEFAULT)
GO 9000
INSERT INTO dbo.BASE_DATA VALUES (DEFAULT)
GO 90000
INSERT INTO dbo.BASE_DATA VALUES (DEFAULT)
GO 900000

Entre le relevé de temps d’exécutions pour le curseur et pour la requête, j’ai exécuté :

TRUNCATE TABLE dbo.BASE_DATA

Et voici le résultat :

Aggréger des données non numériques d’une entité par une liste de valeurs

elsuket — Wed, 04 Mar 2009 22:26:03 +0000

Il est souvent demandé sur le forum comment on peut créer une liste de valeurs stockées dans une colonne en une liste.
Cela est en effet souvent demandé par le client pour des rapports, mais il n’est pas évident de prime abord de fournir un tel résultat, puisqu’il est anti-relationnel !

Prenons pour exemple des adhérents à plusieurs clubs :

NomContact	NomClub
--------------- ------------
BipBip		SQLServer
BipBip		Oracle
BipBip		PostGreSQL
Coyotte		MySQL
Coyotte		FireBird
Titi		Sybase
Sylvestre	DB2
Sylvestre	SQLite
Bugs Bunny	SQLServer
Bugs Bunny	PostGreSQL
Daffy Duck	FireBird
Daffy Duck	DB2
Sam Le Pirate	SQLite

Le résultat recherché se présente sous la forme :

NomContact	ListeClub
--------------- -----------------------------
Titi		Sybase
Sam Le Pirate	SQLite
Daffy Duck	FireBird, DB2
Bugs Bunny	SQLServer, PostGreSQL
Sylvestre	DB2, SQLite
Coyotte		MySQL, FireBird
BipBip		SQLServer, Oracle, PostGreSQL

Représentons physiquement nos clubs et leurs adhérents :

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

---------------------------------
-- Nicolas SOUQUET - 04/03/2009 -
---------------------------------
CREATE TABLE Contact
(
IDContact INT IDENTITY CONSTRAINT PK_Contact PRIMARY KEY,
NomContact VARCHAR(20) NOT NULL
)
GO

CREATE TABLE Club
(
IDClub INT IDENTITY CONSTRAINT PK_Club PRIMARY KEY,
NomClub VARCHAR(20) NOT NULL
)
GO

CREATE TABLE Membre
(
IDMembre INT IDENTITY CONSTRAINT PK_Membre PRIMARY KEY,
IDContact INT NOT NULL CONSTRAINT FK_Membre_IDContact FOREIGN KEY(IDContact) REFERENCES Contact(IDContact),
IDClub INT NOT NULL CONSTRAINT FK_Membre_IDClub FOREIGN KEY(IDClub) REFERENCES Club(IDClub),
CONSTRAINT UQ_Membre_IDContact_IDClub UNIQUE (IDContact, IDClub)
)
GO

INSERT INTO dbo.Contact (NomContact) VALUES('BipBip')
INSERT INTO dbo.Contact (NomContact) VALUES('Coyotte')
INSERT INTO dbo.Contact (NomContact) VALUES('Titi')
INSERT INTO dbo.Contact (NomContact) VALUES('Sylvestre')
INSERT INTO dbo.Contact (NomContact) VALUES('Bugs Bunny')
INSERT INTO dbo.Contact (NomContact) VALUES('Daffy Duck')
INSERT INTO dbo.Contact (NomContact) VALUES('Sam Le Pirate')
GO

INSERT INTO dbo.Club (NomClub) VALUES ('SQLServer')
INSERT INTO dbo.Club (NomClub) VALUES ('Oracle')
INSERT INTO dbo.Club (NomClub) VALUES ('PostGreSQL')
INSERT INTO dbo.Club (NomClub) VALUES ('MySQL')
INSERT INTO dbo.Club (NomClub) VALUES ('FireBird')
INSERT INTO dbo.Club (NomClub) VALUES ('Sybase')
INSERT INTO dbo.Club (NomClub) VALUES ('DB2')
INSERT INTO dbo.Club (NomClub) VALUES ('SQLite')
GO

INSERT INTO dbo.Membre (IDContact, IDClub) VALUES (1, 1)
INSERT INTO dbo.Membre (IDContact, IDClub) VALUES (1, 2)
INSERT INTO dbo.Membre (IDContact, IDClub) VALUES (1, 3)
INSERT INTO dbo.Membre (IDContact, IDClub) VALUES (2, 4)
INSERT INTO dbo.Membre (IDContact, IDClub) VALUES (2, 5)
INSERT INTO dbo.Membre (IDContact, IDClub) VALUES (3, 6)
INSERT INTO dbo.Membre (IDContact, IDClub) VALUES (4, 7)
INSERT INTO dbo.Membre (IDContact, IDClub) VALUES (4, 8)
INSERT INTO dbo.Membre (IDContact, IDClub) VALUES (5, 1)
INSERT INTO dbo.Membre (IDContact, IDClub) VALUES (5, 3)
INSERT INTO dbo.Membre (IDContact, IDClub) VALUES (6, 5)
INSERT INTO dbo.Membre (IDContact, IDClub) VALUES (6, 7)
INSERT INTO dbo.Membre (IDContact, IDClub) VALUES (7, 8)
GO

La requête qui permet d’obtenir tous les clubs auxquels participent tous nos contacts est alors simple :

1
2
3
4
5

SELECT CONTACT.NomContact,
CLUB.NomClub
FROM dbo.Contact CONTACT
JOIN dbo.Membre MEMBRE ON MBR.IDContact = CONTACT.IDContact
JOIN dbo.Club CLUB ON CLUB.IDClub = MEMBRE.IDClub

En revanche il est plus complexe d’agréger toutes ces valeurs pour en fournir une liste par contact …
Voyons comment on peut faire pour un seul membre :

1
2
3
4
5
6
7
8
9
10
11
12

DECLARE @nomContact VARCHAR(20), @listeClubs VARCHAR(1024)

SELECT @nomContact = 'BipBip'

SELECT @listeClubs = ISNULL(@listeClubs, '') + CLUB.NomClub + ', '
FROM dbo.Contact CONTACT
JOIN dbo.Membre MEMBRE ON MEMBRE.IDContact = CONTACT.IDContact
JOIN dbo.Club CLUB ON CLUB.IDClub = MEMBRE.IDClub
WHERE CONTACT.NomContact = @nomContact

SELECT @nomContact AS Contact,
LEFT(@listeClubs, LEN(@listeClubs) - 1) AS ListeClubs

Nous permet d’obtenir :

Contact	ListeClubs
------- -----------------------------
BipBip	SQLServer, Oracle, PostGreSQL

Dès lors pour exécuter cette même requête pour tous les contacts, nous allons avoir (encore une fois diront certains) à la puissance des expressions de table commune récursives, introduites avec SQL Server 2005 :

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

---------------------------------
-- Nicolas SOUQUET - 04/03/2009 -
---------------------------------
WITH
-- Extrait les informations pour chaque contact suivant la requête "normale"
-- en attribuant à chaque tuple un indice arbitraire
CTE_LISTE_BRUTE(IDContact, NomContact, NomClub, Indice) AS
(
SELECT CONTACT.IDContact,
CONTACT.NomContact,
CLUB.NomClub,
ROW_NUMBER() OVER(PARTITION BY CONTACT.IDContact ORDER BY CONTACT.IDContact) AS Indice
FROM dbo.Contact CONTACT
JOIN dbo.Membre MEMBRE ON MEMBRE.IDContact = CONTACT.IDContact
JOIN dbo.Club CLUB ON CLUB.IDClub = MEMBRE.IDClub
),
-- Aggrège les informations pour chaque membre d'un club
CTE_LISTE_CLUB(IDContact, NomContact, ListeClub, Compteur) AS
(
-- Recherche tous les contacts qui sont membres d'au moins un club
SELECT IDContact,
NomContact,
CAST(NomClub AS VARCHAR(1024)) AS ListeClub,
1 AS Compteur
FROM CTE_LISTE_BRUTE
WHERE Indice = 1
UNION ALL
-- Recherche les autres clubs adhérés par le même membre, pour chaque membre
SELECT CTE_LISTE_CLUB.IDContact,
CTE_LISTE_CLUB.NomContact,
CAST(CTE_LISTE_CLUB.ListeClub + ', ' + CTE_LISTE_BRUTE.NomClub AS VARCHAR(1024)) AS ListeClub,
CTE_LISTE_CLUB.Compteur + 1
FROM CTE_LISTE_CLUB
JOIN CTE_LISTE_BRUTE ON CTE_LISTE_CLUB.IDContact = CTE_LISTE_BRUTE.IDContact
WHERE Indice = Compteur + 1
),
-- Recherche le nombre total d'adhésions pour chaque membre
CTE_MAX(IDContact, maxCompteur) AS
(
SELECT IDContact,
MAX(Compteur) AS maxCompteur
FROM CTE_LISTE_CLUB
GROUP BY IDContact
)
SELECT CTE_LISTE_CLUB.NomContact,
CTE_LISTE_CLUB.ListeClub
FROM CTE_LISTE_CLUB
JOIN CTE_MAX
ON CTE_LISTE_CLUB.Compteur = CTE_MAX.maxCompteur
AND CTE_LISTE_CLUB.IDContact = CTE_MAX.IDContact

Nous obtenons ainsi :

NomContact	ListeClub
--------------- -----------------------------
Titi		Sybase
Sam Le Pirate	SQLite
Daffy Duck	FireBird, DB2
Bugs Bunny	SQLServer, PostGreSQL
Sylvestre	DB2, SQLite
Coyotte		MySQL, FireBird
BipBip		SQLServer, Oracle, PostGreSQL

ElSuket

Ce qu’il n’est pas possible d’utiliser dans les fonctions T-SQL, et pourquoi

elsuket — Tue, 17 Feb 2009 22:23:06 +0000

Voici la liste des instructions qu’il n’est pas possible d’utiliser dans un fonction définie par l’utilisateur (UDF) sous SQL Server

Rappelons d’abord ce qu’est une fonction:

– En mathématiques, une fonction, aussi appelée application, est la donnée de deux ensembles : un ensemble de départ et un ensemble d’arrivée, et une relation associant chaque élément de l’ensemble de départ à un et un seul élément de l’ensemble d’arrivée.
– En informatique, une fonction est un sous-programme qui exécute un tâche spécifique, et qui est relativement indépendante du code qui l’entoure

De ces deux définitions, on peut déduire qu’une fonction :

– doit effectuer seulement un calcul,
– ne doit pas dépendre du contexte de base de données

C’est en outre pour ces raisons que sous SQL Server, il n’est pas possible, dans une UDF :

– d’appeler une procédure stockée, sauf si c’est une procédure stockée étendue
– d’utiliser la structure de contrôle TRY … CATCH
– d’utiliser @@ERROR
– d’utiliser RAISERROR
– de retourner plusieurs ensembles de données
– d’utiliser des fonctions non déterministes comme GETDATE()
– d’utiliser des tables temporaires (# et ##)
– d’utiliser du code SQL dynamique
– d’utiliser une commande SET
– d’utiliser un quelconque ordre de modification de données (INSERT, UPDATE, DELETE), sauf sur les variables table locales à la fonction
– d’encapsuler tout ou partie du code de la fonction dans une transaction (BEGIN | COMMIT | ROLLBACK TRANSACTION) (Merci SQLPro ;))

ElSuket

[T-SQL] Les jointures

elsuket — Wed, 21 Jan 2009 19:08:31 +0000

Lors de mes participations à ce forum, je vois parfois des jointures entre les tables qui sont spécifiées à travers la clause WHERE, ou encore quelques participants demander le fonctionnement des jointures.
Voyons ce qu’il en est dans le T-SQL de SQL Server …

Les jointures constituent le mécanisme le plus puissant du langage SQL.
Il est donc dommage de s’en passer en utilisant par exemple l’opérateur IN pour obtenir le même résultat.

Les jointures permettent de récupérer les données de plusieurs tables en les liant logiquement suivant les relations qui existent entre elles (clés primaires, clés étrangères).

Voyons en détail tous les opérateurs de jointures implémentés dans le T-SQL de SQL Server :

– Une équi-jointure, spécifiée en T-SQL par [INNER] JOIN, vous retournera les lignes pour lesquelles chaque clé des deux tables sur laquelle vous effectuez la jointure existe dans les deux tables.
Les clés n’existant pas dans l’une ou dans l’autre table sont exclues.

– Une demi-jointure, spécifiée en T-SQL par LEFT|RIGHT [OUTER] JOIN, vous retournera toutes les lignes de la table à gauche|droite de l’opérateur de jointure, y compris celles qui n’ont pas de correspondance dans la table à droite|gauche de l’opérateur de jointure.

– Une jointure externe complète, spécifiée en T-SQL par FULL [OUTER] JOIN vous retournera tous les lignes des deux tables, y compris celles qui n’ont pas de correspondance dans la table à gauche ou (inclusif) à droite de l’opérateur de jointure.

– Une jointure croisée, spécifiée en T-SQL par CROSS JOIN, effectue le produit cartésien de deux tables.

Un démonstration valant mieux que mille lignes, voyons ce qu’il en est en T-SQL:

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

CREATE TABLE A
(
A TINYINT
)
GO

CREATE TABLE B
(
B TINYINT
)
GO

INSERT INTO A VALUES (1)
INSERT INTO A VALUES (2)
INSERT INTO A VALUES (3)
INSERT INTO A VALUES (4)
INSERT INTO A VALUES (5)
GO

INSERT INTO B VALUES (1)
INSERT INTO B VALUES (2)
INSERT INTO B VALUES (3)
GO

-- Equi-jointure
SELECT A.A, B.B
FROM A
INNER JOIN B ON B.B = A.A
GO

-- Demi-jointure gauche OU jointure externe gauche
SELECT A.A, B.B
FROM A
LEFT OUTER JOIN B ON B.B = A.A
GO

INSERT INTO B VALUES (6)
GO

-- Demi-jointure droite OU jointure externe droite
SELECT A.A, B.B
FROM A
RIGHT OUTER JOIN B ON B.B = A.A
GO
-- Jointure externe complète
SELECT A.A, B.B
FROM A
FULL OUTER JOIN B ON B.B = A.A

-- Jointure croisée (produit cartésien)
SELECT A.A, B.B
FROM A
CROSS JOIN B

Les mots-clé INNER et OUTER sont facultatifs (mais pas CROSS !)

Pourquoi ne faut-il pas spécifier les jointures dans une clause WHERE ?
Deux raisons à cela :

– Comme tout SGBDR, SQL Server possède un optimiseur de requête, qui recherche les mots-clé dans le code que vous lui soumettez, pour établir un plan de requête.
Dans une clause WHERE, il s’attend à trouver des contraintes (WHERE maColonne = uneValeur), et après un JOIN, une jointure.
Bien sûr, il a été programmé suffisamment intelligemment pour détecter les jointures dans les WHERE, mais dans certains cas très particuliers, il ne les trouve pas, ce qui peut rendre l’exécution de la requête peu rapide.

– Par pur souci de lisibilité de votre code : le seul mot-clé JOIN permet de séparer les jointures des contraintes de votre requête.

On réservera aussi l’opérateur IN à renseigner une liste de valeurs.

ElSuket

Gérer des couleurs en base de données

elsuket — Fri, 03 Jul 2009 13:27:20 +0000

Il peut vite devenir difficile de gérer de façon uniforme les couleurs pour plusieurs applications accédant à une base de données :

– s’il s’agit d’une application web, les couleurs s’affichent sur 6 caractères alphanumériques de la base hexadécimale,
– s’il s’agit d’une application lourde, elle peut interpréter les couleurs comme un entier qui est la somme RVB, ou bien sous forme hexadécimale.

Voyons comment gérer cela simplement …

Voici une table qui fera tous les calculs automatiquement à partir des trois composantes RVB :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

---------------------------------
-- Nicolas SOUQUET - 03/07/2009 -
---------------------------------
CREATE TABLE TbCouleur
(
IDCouleur INT NOT NULL IDENTITY CONSTRAINT PK_TbCouleur PRIMARY KEY,
nomCouleur VARCHAR(10) NOT NULL CONSTRAINT UQ_TbCouleur_nomCouleur UNIQUE,
composanteRouge TINYINT,
composanteVert TINYINT,
composanteBleu TINYINT,
Decimale AS (composanteRouge + composanteVert * 256 + composanteBleu * 256 * 256) PERSISTED NOT NULL,
Hexadecimale AS (CAST(composanteRouge + composanteVert * 256 + composanteBleu * 256 * 256 AS VARBINARY(3))) PERSISTED NOT NULL,
HTML AS (dbo.Fn_RVB_To_HTML(composanteRouge, composanteVert, composanteBleu)) PERSISTED NOT NULL,
CONSTRAINT UQ_TbCouleur_composanteRouge_composanteVert_composanteBleu UNIQUE (composanteRouge, composanteVert, composanteBleu)
)

L’utilisation de colonnes calculées (persistées, mais ce n’est pas obligatoire !) pour faire effectuer tous les calculs au moteur de base de données rend très simple toute saisie de nouvelles couleurs.

Pour calculer le codage HTML, nous utilisons la fonction suivante, dont le code est un peu barbare, mais efficace :

---------------------------------
-- Nicolas SOUQUET - 03/07/2009 -
---------------------------------
CREATE FUNCTION Fn_RVB_To_HTML
(
@rouge TINYINT,
@vert TINYINT,
@bleu TINYINT
)
RETURNS CHAR(6)
WITH SCHEMABINDING
AS
BEGIN
RETURN
(
CASE @rouge / 16
WHEN 0 THEN '0'
WHEN 1 THEN '1'
WHEN 2 THEN '2'
WHEN 3 THEN '3'
WHEN 4 THEN '4'
WHEN 5 THEN '5'
WHEN 6 THEN '6'
WHEN 7 THEN '7'
WHEN 8 THEN '8'
WHEN 9 THEN '9'
WHEN 10 THEN 'A'
WHEN 11 THEN 'B'
WHEN 12 THEN 'C'
WHEN 13 THEN 'D'
WHEN 14 THEN 'E'
WHEN 15 THEN 'F'
END +
CASE @rouge % 16
WHEN 0 THEN '0'
WHEN 1 THEN '1'
WHEN 2 THEN '2'
WHEN 3 THEN '3'
WHEN 4 THEN '4'
WHEN 5 THEN '5'
WHEN 6 THEN '6'
WHEN 7 THEN '7'
WHEN 8 THEN '8'
WHEN 9 THEN '9'
WHEN 10 THEN 'A'
WHEN 11 THEN 'B'
WHEN 12 THEN 'C'
WHEN 13 THEN 'D'
WHEN 14 THEN 'E'
WHEN 15 THEN 'F'
END +
CASE @vert / 16
WHEN 0 THEN '0'
WHEN 1 THEN '1'
WHEN 2 THEN '2'
WHEN 3 THEN '3'
WHEN 4 THEN '4'
WHEN 5 THEN '5'
WHEN 6 THEN '6'
WHEN 7 THEN '7'
WHEN 8 THEN '8'
WHEN 9 THEN '9'
WHEN 10 THEN 'A'
WHEN 11 THEN 'B'
WHEN 12 THEN 'C'
WHEN 13 THEN 'D'
WHEN 14 THEN 'E'
WHEN 15 THEN 'F'
END +
CASE @vert % 16
WHEN 0 THEN '0'
WHEN 1 THEN '1'
WHEN 2 THEN '2'
WHEN 3 THEN '3'
WHEN 4 THEN '4'
WHEN 5 THEN '5'
WHEN 6 THEN '6'
WHEN 7 THEN '7'
WHEN 8 THEN '8'
WHEN 9 THEN '9'
WHEN 10 THEN 'A'
WHEN 11 THEN 'B'
WHEN 12 THEN 'C'
WHEN 13 THEN 'D'
WHEN 14 THEN 'E'
WHEN 15 THEN 'F'
END +
CASE @bleu / 16
WHEN 0 THEN '0'
WHEN 1 THEN '1'
WHEN 2 THEN '2'
WHEN 3 THEN '3'
WHEN 4 THEN '4'
WHEN 5 THEN '5'
WHEN 6 THEN '6'
WHEN 7 THEN '7'
WHEN 8 THEN '8'
WHEN 9 THEN '9'
WHEN 10 THEN 'A'
WHEN 11 THEN 'B'
WHEN 12 THEN 'C'
WHEN 13 THEN 'D'
WHEN 14 THEN 'E'
WHEN 15 THEN 'F'
END +
CASE @bleu % 16
WHEN 0 THEN '0'
WHEN 1 THEN '1'
WHEN 2 THEN '2'
WHEN 3 THEN '3'
WHEN 4 THEN '4'
WHEN 5 THEN '5'
WHEN 6 THEN '6'
WHEN 7 THEN '7'
WHEN 8 THEN '8'
WHEN 9 THEN '9'
WHEN 10 THEN 'A'
WHEN 11 THEN 'B'
WHEN 12 THEN 'C'
WHEN 13 THEN 'D'
WHEN 14 THEN 'E'
WHEN 15 THEN 'F'
END
)
END

Ainsi l’ajout d’une nouvelle couleur dans la table se fait simplement :

1
2
3
4
5
6
7
8
9
10
11
12
13

---------------------------------
-- Nicolas SOUQUET - 03/07/2009 -
---------------------------------
INSERT INTO dbo.TbCouleur(nomCouleur, composanteRouge, composanteVert, composanteBleu) VALUES ('Blanc', 255, 255, 255)
INSERT INTO dbo.TbCouleur(nomCouleur, composanteRouge, composanteVert, composanteBleu) VALUES ('Noir', 0, 0, 0)
INSERT INTO dbo.TbCouleur(nomCouleur, composanteRouge, composanteVert, composanteBleu) VALUES ('Gris', 190, 190, 190)
INSERT INTO dbo.TbCouleur(nomCouleur, composanteRouge, composanteVert, composanteBleu) VALUES ('Rouge', 255, 0, 0)
INSERT INTO dbo.TbCouleur(nomCouleur, composanteRouge, composanteVert, composanteBleu) VALUES ('Vert', 0, 255, 0)
INSERT INTO dbo.TbCouleur(nomCouleur, composanteRouge, composanteVert, composanteBleu) VALUES ('Bleau', 0, 0, 255)
INSERT INTO dbo.TbCouleur(nomCouleur, composanteRouge, composanteVert, composanteBleu) VALUES ('Jaune', 255, 255, 0)
INSERT INTO dbo.TbCouleur(nomCouleur, composanteRouge, composanteVert, composanteBleu) VALUES ('Orange', 255, 165, 0)
INSERT INTO dbo.TbCouleur(nomCouleur, composanteRouge, composanteVert, composanteBleu) VALUES ('Rose', 255, 192, 203)
INSERT INTO dbo.TbCouleur(nomCouleur, composanteRouge, composanteVert, composanteBleu) VALUES ('Violet', 238, 130, 238)

ou encore à l’aide de la procédure stockée suivante :

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

---------------------------------
-- Nicolas SOUQUET - 03/07/2009 -
---------------------------------
CREATE PROCEDURE Ps_Couleur_Ajouter
@nomCouleur VARCHAR(10),
@composanteRouge TINYINT,
@composanteVert TINYINT,
@composanteBleu TINYINT
AS
BEGIN
INSERT INTO dbo.TbCouleur
(
nomCouleur,
composanteRouge,
composanteVert,
composanteBleu
)
VALUES
(
@nomCouleur,
@composanteRouge,
@composanteVert,
@composanteBleu
)
END

Et pour ajouter les couleurs :

1
2
3
4
5
6
7
8
9
10
11
12
13

---------------------------------
-- Nicolas SOUQUET - 03/07/2009 -
---------------------------------
EXEC dbo.Ps_Couleur_Ajouter 'Blanc', 255, 255, 255
EXEC dbo.Ps_Couleur_Ajouter 'Noir', 0, 0, 0
EXEC dbo.Ps_Couleur_Ajouter 'Gris', 190, 190, 190
EXEC dbo.Ps_Couleur_Ajouter 'Rouge', 255, 0, 0
EXEC dbo.Ps_Couleur_Ajouter 'Vert', 0, 255, 0
EXEC dbo.Ps_Couleur_Ajouter 'Bleau', 0, 0, 255
EXEC dbo.Ps_Couleur_Ajouter 'Jaune', 255, 255, 0
EXEC dbo.Ps_Couleur_Ajouter 'Orange', 255, 165, 0
EXEC dbo.Ps_Couleur_Ajouter 'Rose', 255, 192, 203
EXEC dbo.Ps_Couleur_Ajouter 'Violet', 238, 130, 238

Et le résultat est le suivant :

Les trois fonctions suivantes permettent d’obtenir la couleur souhaitée dans la représentation qui conviendra suivant l’application :

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

-----------------------------------------------------
-- Nicolas SOUQUET - 03/07/2009 - Fn_Couleur_GetRVB -
-----------------------------------------------------
CREATE FUNCTION Fn_Couleur_GetRVB
(@nomCouleur VARCHAR(10))
RETURNS TABLE
WITH SCHEMABINDING
AS
RETURN
(
SELECT composanteRouge AS R,
composanteVert AS V,
composanteBleu AS B
FROM dbo.TbCouleur
WHERE nomCouleur = @nomCouleur
)

------------------------------------------------------
-- Nicolas SOUQUET - 03/07/2009 - Fn_Couleur_GetHTML -
------------------------------------------------------
CREATE FUNCTION Fn_Couleur_GetHTML
(@nomCouleur VARCHAR(10))
RETURNS CHAR(6)
WITH SCHEMABINDING
AS
BEGIN
RETURN
(
SELECT HTML
FROM dbo.TbCouleur
WHERE nomCouleur = @nomCouleur
)
END

----------------------------------------------------------
-- Nicolas SOUQUET - 03/07/2009 - Fn_Couleur_GetDecimale -
----------------------------------------------------------
CREATE FUNCTION Fn_Couleur_GetDecimale
(@nomCouleur VARCHAR(10))
RETURNS INT
WITH SCHEMABINDING
AS
BEGIN
RETURN
(
SELECT Decimale
FROM dbo.TbCouleur
WHERE nomCouleur = @nomCouleur
)
END

--------------------------------------------------------------
-- Nicolas SOUQUET - 03/07/2009 - Fn_Couleur_GetHexadecimale -
--------------------------------------------------------------
CREATE FUNCTION Fn_Couleur_GetHexadecimale
(@nomCouleur VARCHAR(10))
RETURNS VARBINARY(3)
WITH SCHEMABINDING
AS
BEGIN
RETURN
(
SELECT Hexadecimale
FROM dbo.TbCouleur
WHERE nomCouleur = @nomCouleur
)
END

On peut ensuite envisager le code d’une procédure comme suit :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

---------------------------------
-- Nicolas SOUQUET - 03/07/2009 -
---------------------------------
CREATE PROCEDURE maProcedure
@...
@application
AS
BEGIN
SELECT CASE ETAT
WHEN uneValeur THEN CASE @application
WHEN 'HTML' THEN dbo.Fn_Couleur_GetHTML('Rouge')
WHEN 'EXE' THEN dbo.Fn_Couleur_GetDecimale('Rouge')
END
ELSE CASE @application
WHEN 'HTML' THEN dbo.Fn_Couleur_GetHTML('Blanc')
WHEN 'EXE' THEN dbo.Fn_Couleur_GetDecimale('Blanc')
END
END
FROM dbo.TbEtat AS ETAT
END

Bien sûr il est préférable de stocker les divers états possibles dans une table et de gérer le CASE avec la valeur de clé de la table.
On peut également penser à récupérer une représentation d’une couleur à partir d’une autre …

ElSuket