Le blog de SQLpro » SQL Server 2000

Agrégation des statistiques d’IO d’une requête

SQLpro — Thu, 28 Dec 2017 18:55:58 +0000

Si le paramétrage SET STATISTICS IO ON de Microsoft SQL Server permet de savoir, table par table les statistiques d’entrées/sorties (IO pour Input/Output) des requêtes, il n’est pas toujours facile de s’y repérer lorsque la requête est complexe et fait appel à de multiples tables. Voici une procédure qui en effectue la synthèse.

Rappelons que les statistiques IO sont le nombre de pages lues par le moteur SQL pour exécuter une requête. Le paramètre de session STATISTICS IO peut être mis à ON ou OFF. Par défaut il est à OFF. Mis sur ON, il permet, dans SQL Server Management Studio (SSMS), de voir le nombre de pages accédées pour une requête ou un lot de requête. C’est une série de message d’une ligne commençant par « Table… » qui suit immédiatement le message indiquant le nombre de lignes affectées par la requête.

SQL Server onglet message STATISTICS IO

Néanmoins il est assez difficile de lire tout cela et d’en déduire une tendance globale.
Ne serait-ce pas plus intéressante de les présenter de cette manière :

Statistiques IO SQL Server avec totaux et agrégation

La petite procédure que voici permet justement d’effectuer cette tâche. Il suffit de lui passer le texte complet des message d’IO et elle vous retournera tout cela, formaté, totalisé et agrégé !

USE msdb;
GO

CREATE SCHEMA S_DBA;
GO

CREATE PROCEDURE S_DBA.P_SPLIT_STATS_IO @DATA NVARCHAR(MAX)
AS
SET NOCOUNT ON;
DECLARE @LINE NVARCHAR(MAX), @SQL NVARCHAR(MAX) = N'';
DECLARE @L TABLE (LINE NVARCHAR(800));
DECLARE @T TABLE (TABLE_NAME sysname,
SCAN_COUNT BIGINT,
LOGICAL_READS BIGINT,
PHYSICAL_READS BIGINT,
READ_AHEAD_READS BIGINT,
LOB_LOGICAL_READS BIGINT,
LOB_PHYSICAL_READS BIGINT,
LOB_READ_AHEAD_READS BIGINT);

WHILE CHARINDEX(NCHAR(13) + NCHAR(10), @DATA) > 0
BEGIN
SET @LINE = LEFT(@DATA, CHARINDEX(NCHAR(13) + NCHAR(10), @DATA) - 2);
INSERT INTO @L SELECT @LINE;
SET @DATA = RIGHT(@DATA, LEN(@DATA) - CHARINDEX(NCHAR(13) + NCHAR(10), @DATA) - 1);
END;
INSERT INTO @L SELECT @DATA;
DELETE @L WHERE LINE = N'' OR LINE NOT LIKE N'%Table %' COLLATE French_BIN;

IF NOT EXISTS(SELECT *
FROM @L
WHERE LINE NOT LIKE '%Nombre d''analyses%')
--> français
BEGIN
UPDATE @L SET LINE = REPLACE(LINE, 'Table ', '');
UPDATE @L SET LINE = REPLACE(LINE, '. Nombre d''analyses ', ',');
UPDATE @L SET LINE = REPLACE(LINE, ' lectures logiques ', '');
UPDATE @L SET LINE = REPLACE(LINE, ' lectures physiques ', '');
UPDATE @L SET LINE = REPLACE(LINE, ' lectures anticipées ', '');
UPDATE @L SET LINE = REPLACE(LINE, 'de données d''objets volumineux ', '');
UPDATE @L SET LINE = REPLACE(LINE, '.', '');
END;

IF NOT EXISTS(SELECT *
FROM @L
WHERE LINE NOT LIKE '%Scan count%')
--> anglais
BEGIN
UPDATE @L SET LINE = REPLACE(LINE, 'Table ', '');
UPDATE @L SET LINE = REPLACE(LINE, '. Scan count ', ',');
UPDATE @L SET LINE = REPLACE(LINE, ' logical reads ', '');
UPDATE @L SET LINE = REPLACE(LINE, ' physical reads ', '');
UPDATE @L SET LINE = REPLACE(LINE, ' read-ahead reads ', '');
UPDATE @L SET LINE = REPLACE(LINE, 'lob', '');
UPDATE @L SET LINE = REPLACE(LINE, '.', '');
END;

SELECT @SQL = @SQL + 'SELECT ' + LINE + ' UNION ALL ' FROM @L;
SET @SQL = LEFT(@SQL, LEN(@SQL) - 10)

INSERT INTO @T
EXEC (@SQL);

WITH
T AS
(
SELECT *
FROM @T
UNION ALL
SELECT '°°° TOTAL °°°', SUM(SCAN_COUNT),
SUM(LOGICAL_READS), SUM(PHYSICAL_READS), SUM(READ_AHEAD_READS),
SUM(LOB_LOGICAL_READS),SUM(LOB_PHYSICAL_READS),SUM(LOB_READ_AHEAD_READS)
FROM @T
)
SELECT *
FROM T
ORDER BY CASE WHEN TABLE_NAME = '°°° TOTAL °°°' THEN 1 ELSE 0 END,
LOGICAL_READS DESC;

SELECT SUM(SCAN_COUNT) AS TOTAL_SCANS,
SUM(LOGICAL_READS + LOB_LOGICAL_READS) AS TOTAL_LOGICAL_READS,
SUM(PHYSICAL_READS + READ_AHEAD_READS +
LOB_PHYSICAL_READS + LOB_READ_AHEAD_READS) AS TOTAL_PHYSICAL_READS
FROM @T;

GO

Exemple d’utilisation :

EXECUTE msdb.S_DBA.P_SPLIT_STATS_IO 'Table ''PARAM_EAC''. Nombre d''analyses 13, lectures logiques 26, lectures physiques 0, lectures anticipées 0, lectures logiques de données d''objets volumineux 0, lectures physiques de données d''objets volumineux 0, lectures anticipées de données d''objets volumineux 0.
Table ''Worktable''. Nombre d''analyses 0, lectures logiques 0, lectures physiques 0, lectures anticipées 0, lectures logiques de données d''objets volumineux 0, lectures physiques de données d''objets volumineux 0, lectures anticipées de données d''objets volumineux 0.
Table ''VAL_PARAM_EAC''. Nombre d''analyses 1, lectures logiques 59, lectures physiques 0, lectures anticipées 0, lectures logiques de données d''objets volumineux 0, lectures physiques de données d''objets volumineux 0, lectures anticipées de données d''objets volumineux 0.
Table ''ESP''. Nombre d''analyses 49, lectures logiques 31, lectures physiques 0, lectures anticipées 0, lectures logiques de données d''objets volumineux 0, lectures physiques de données d''objets volumineux 0, lectures anticipées de données d''objets volumineux 0.
Table ''TL_EXP_COOP''. Nombre d''analyses 49, lectures logiques 178, lectures physiques 0, lectures anticipées 0, lectures logiques de données d''objets volumineux 0, lectures physiques de données d''objets volumineux 0, lectures anticipées de données d''objets volumineux 0.
Table ''UC''. Nombre d''analyses 49, lectures logiques 5633, lectures physiques 0, lectures anticipées 0, lectures logiques de données d''objets volumineux 0, lectures physiques de données d''objets volumineux 0, lectures anticipées de données d''objets volumineux 0.
Table ''TL_PP_UC''. Nombre d''analyses 49, lectures logiques 1254, lectures physiques 0, lectures anticipées 0, lectures logiques de données d''objets volumineux 0, lectures physiques de données d''objets volumineux 0, lectures anticipées de données d''objets volumineux 0.
Table ''PG''. Nombre d''analyses 49, lectures logiques 85289, lectures physiques 0, lectures anticipées 0, lectures logiques de données d''objets volumineux 0, lectures physiques de données d''objets volumineux 0, lectures anticipées de données d''objets volumineux 0.
Table ''Worktable''. Nombre d''analyses 0, lectures logiques 0, lectures physiques 0, lectures anticipées 0, lectures logiques de données d''objets volumineux 0, lectures physiques de données d''objets volumineux 0, lectures anticipées de données d''objets volumineux 0.
Table ''PG''. Nombre d''analyses 1, lectures logiques 437, lectures physiques 0, lectures anticipées 0, lectures logiques de données d''objets volumineux 0, lectures physiques de données d''objets volumineux 0, lectures anticipées de données d''objets volumineux 0.
Table ''PP''. Nombre d''analyses 49, lectures logiques 7271, lectures physiques 0, lectures anticipées 0, lectures logiques de données d''objets volumineux 0, lectures physiques de données d''objets volumineux 0, lectures anticipées de données d''objets volumineux 0.
Table ''EXP''. Nombre d''analyses 49, lectures logiques 1996, lectures physiques 0, lectures anticipées 0, lectures logiques de données d''objets volumineux 0, lectures physiques de données d''objets volumineux 0, lectures anticipées de données d''objets volumineux 0.
Table ''VAR''. Nombre d''analyses 49, lectures logiques 866, lectures physiques 0, lectures anticipées 0, lectures logiques de données d''objets volumineux 0, lectures physiques de données d''objets volumineux 0, lectures anticipées de données d''objets volumineux 0.'

Le résultat :

Les statistiques d’IO d’une requête, sous forme tabulaire, totalisés et agrégés

QUELQUES EXPLICATIONS SUR LES MÉTRIQUES

analyses (scan count) : nombre de fois ou l’exécuteur de requête a du pénétrer dans un index de la table ou dans la table (en cas de parallélisme, autant de fois que de threads…)

lectures logiques (logical reads) : nombre de pages lues en RAM

lectures physiques (physical reads) : nombre de pages lues depuis le disque (avec transfert en RAM) en mode aléatoire.

lectures anticipées (read-ahead physical read) : nombre de pages lues depuis le disque (avec transfert en RAM) en mode continu.

…d’objets volumineux (lob …) : nombre de pages … pour les « Large OBjects ».

NOTA : cet outil fonctionne que votre serveur soit en anglais ou français.

LE CODE * LE CODE * LE CODE * LE CODE * LE CODE * LE CODE * LE CODE * LE CODE * LE CODE
Le code !

Frédéric Brouard, alias SQLpro, ARCHITECTE DE DONNÉES
Expert S.G.B.D relationnelles et langage S.Q.L
Moste Valuable Professionnal Microsoft SQL Server
Société SQLspot : modélisation, conseil, formation,
optimisation, audit, tuning, administration SGBDR
Enseignant: CNAM PACA, ISEN Toulon, CESI Aix en Prov.

L’entreprise SQL Spot
Le site web sur le SQL et les SGBDR

Développez et administrez pour la performance avec SQL Server 2014

Une fonction de comptage d’occurrence

SQLpro — Thu, 16 Nov 2017 17:51:42 +0000

La petite fonction qui suit permet de compter le nombre de fois ou un caractère est présent dans une chaine de caractères.

CREATE FUNCTION F_COUNT_CHAR(@STR NVARCHAR(MAX), @CHR NCHAR(1))
RETURNS INT
WITH RETURNS NULL ON NULL INPUT
AS
BEGIN
DECLARE @NBR INT, @POS INT;
SELECT @NBR = 0, @POS = CHARINDEX(@CHR, @STR);
WHILE @POS > 0
BEGIN
SET @NBR = @NBR + 1;
SET @POS = CHARINDEX(@CHR, @STR, @POS + 1);
END;
RETURN @NBR;
END;
GO

Exemples d’utilisation :

-- exemple -- résultat
------------------------------------------- ------------

SELECT dbo.F_COUNT_CHAR('abracadabra', 'a') --> 5

SELECT dbo.F_COUNT_CHAR('', 'a') --> 0
SELECT dbo.F_COUNT_CHAR('a', '') --> 0
SELECT dbo.F_COUNT_CHAR('', '') --> 0

SELECT dbo.F_COUNT_CHAR(NULL, 'a') --> NULL
SELECT dbo.F_COUNT_CHAR('a', NULL) --> NULL
SELECT dbo.F_COUNT_CHAR(NULL, NULL) --> NULL

L’entreprise SQL Spot
Le site web sur le SQL et les SGBDR

Développez et administrez pour la performance avec SQL Server 2014

Qui est leader dans les bases de données en 2016 ?

SQLpro — Thu, 27 Oct 2016 14:43:33 +0000

Selon l’étude 2016 du groupe Gartner au sujet des bases de données opérationnelles d’entreprise (OPDBMS), Microsoft est le n°1 sur les deux axes de mesure : facilité d’utilisation et visionnaire.

Source : Gartner – Magic Quadrant for Operational Database Management Systems 2016

Microsoft détient l’un des systèmes de bases de données relationnelles les mieux conçu, les plus utilisés et le plus fiable avec SQL Server, incorporant un moteur « in memory » (IMDBMS).
Mais il se trouve que Microsoft est aussi le numéro deux du cloud derrière Amazon (Azure SQL Database).
Il offre aussi différentes technologies complémentaire de type NoSQL avec Azure DocumentDB (un SGBD de type « document ») et Azure Tables (un SGBDR de type paire clef/valeur).
Très présent dans le cloud, y compris de manière hybride (une base SQL Serveur locale peut avoir une partie de ses données dans le cloud via le concept de « stretch tables« ), Microsoft offre aussi de nombreuses possibilité analytiques ou mobile.

Pour la troisième année consécutive Mictrosoft est numéro 2 en part de marché sur le plan financier, derrière Oracle dont le Gartner Group a remonté comme point négatif de l’étude, les problèmes de coûts, de complexité de licences et noté un rapport qualité prix jugé négatif par les clients.

Mais ce qui fait la force de Microsoft depuis toujours, et celle en particulier de ses solutions de bases de données, c’est la facilité d’utilisation (l’un des meilleurs scores de l’étude) et de migration de version (80% des clients ont trouvés que la migration des bases était plus facile que prévue ou autant que prévu)…

Les seuls problèmes pointés du doigt de manière négatives par le Gartner Group sont exclusivement celles liées au marketing, canaux de vente et distribution des solutions Microsoft ou l’éditeur reste encore perçut par certains comme un acteurs pour de petites solutions…
Finalement aucune critique technique ni financière ne vient ternir l’image d’excellence de Microsoft dans le domaines des bases de données d’entreprise ce qui tend à prouver que ce classement de leader est largement mérité !

***

L’entreprise SQL Spot
Le site web sur le SQL et les SGBDR

Un DATEDIFF amélioré

SQLpro — Thu, 13 Aug 2015 14:19:50 +0000

La fonction DATEDIFF retourne un entier de type INT. Cependant cela ne suffit pas dans certaines cas : granularité de calcul trop fine (milliseconde par exemple) ou plages de valeurs trop étendues. La fonction F_DATEDIFF_BIG répond a cette problématique en vous offrant une valeur de sortie sous forme de BIGINT.

Voici cette fonction. Toutes les explications et la manière de s’en servir sont dans la cartouche.

CREATE FUNCTION dbo.F_DATEDIFF_BIG (@DATEPART CHAR(11), @DT1 DATETIME2, @DT2 DATETIME2)
RETURNS BIGINT
AS
/******************************************************************************
* FONCTION UDF SCALAIRE dbo.F_DATEDIFF_BIG 2015-08-13 *
*******************************************************************************
* Frédéric BROUARD - alias SQLpro - SARL SQL SPOT - SQLpro@outlook.fr *
* Architecte de données : expertise, audit, conseil, formation, modélisation *
* tuning, sur les SGBD Relationnels, le langage SQL, MS SQL Server/PostGreSQL *
* blog: http://blog.developpez.com/sqlpro site: http://sqlpro.developpez.com *
*******************************************************************************
* Cette fonction étend la capacité de la fonction intégrée DATEDIFF lorsqu'il *
* y a dépassement de capacité pour la valeur résultante. Exemple : *
* SELECT DATEDIFF(minute, '0001-01-01', '9999-12-31'); *
* --> Msg 535, Niveau 16, État 0, Ligne 91 *
* La fonction datediff a provoqué un dépassement de capacité. Le nombre *
* de parties de date qui séparent deux instances de date/heure est trop *
* important. Essayez d'utiliser datediff avec une partie de date moins *
* précise. *
*******************************************************************************
* PARAMÈTRES EN ENTRÉE : *
* @DATEPART CHAR(11) granularité de temps pour calculer la différence *
* @DT1 DATETIME2 date/heure debut *
* @DT2 DATETIME2 date/heure fin *
*******************************************************************************
* VALEURS POSSIBLE POUR LE PARAMÈTRE @DATEPART : *
* valeures acceptées descriptions *
* ------------------------------ ---------------------- *
* year, yy, yyyy année *
* quarter, qq, q trimestre *
* month, mm, m mois *
* dayofyear, dy, y jour *
* day, dd, d jour *
* week, wk, ww semaine *
* hour, hh heures *
* minute, mi, n minutes *
* second, ss, s secondes *
* millisecond, ms millisecondes *
*******************************************************************************
* VALEUR EN SORTIE : *
* type SQL BIGINT nombre d'unité temporelles entre les deux valeurs *
*******************************************************************************
* EXEMPLES D'UTILISATION : *
* SELECT dbo.F_DATEDIFF_BIG('minute', '0001-01-01', '9999-12-31') *
* --> 5258963520 *
* SELECT dbo.F_DATEDIFF_BIG('millisecond', '0001-01-01', '9999-12-31') *
* --> 315537811200000 *
*******************************************************************************
* LIMITES : *
* la granularité est limitée à la milliseconde *
* la validité du calcul est assurée pour la plage des dates ISO SQL : *
* [0001-01-01 00:00:00.0000000, 9999-12-31 23:59:59.9999999] *
******************************************************************************/
BEGIN
-- test de validité des paramètres
IF @DT1 > @DT2
RETURN NULL;

SET @DATEPART = LOWER(@DATEPART);

IF @DATEPART NOT IN ('year', 'yy', 'yyyy',
'quarter', 'qq', 'q',
'month', 'mm', 'm',
'week', 'wk', 'ww',
'dayofyear', 'dy', 'y',
'day', 'dd', 'd',
'hour', 'hh',
'minute', 'mi', 'n',
'second', 'ss', 's',
'millisecond', 'ms')
RETURN NULL;

-- sans conversion primaire :
IF @DATEPART IN ('year', 'yy', 'yyyy')
RETURN CAST(DATEDIFF(YEAR, @DT1, @DT2) AS BIGINT);
IF @DATEPART IN ('quarter', 'qq', 'q')
RETURN CAST(DATEDIFF(QUARTER, @DT1, @DT2) AS BIGINT);
IF @DATEPART IN ('month', 'mm', 'm')
RETURN CAST(DATEDIFF(MONTH, @DT1, @DT2) AS BIGINT);
IF @DATEPART IN ('week', 'wk', 'ww')
RETURN CAST(DATEDIFF(WEEK, @DT1, @DT2) AS BIGINT);
IF @DATEPART IN ('dayofyear', 'dy', 'y',
'day', 'dd', 'd')
RETURN CAST(DATEDIFF(DAY, @DT1, @DT2) AS BIGINT);

-- pour les autres cas

-- variable de sortie
DECLARE @RETVAL BIGINT;

-- initialisation pour le nombre de jours
SET @RETVAL = CAST(DATEDIFF(DAY, @DT1, @DT2) AS BIGINT);

-- ajout des parties d'heure si précision heure
IF @DATEPART IN ('hour', 'hh')
BEGIN
SET @RETVAL = @RETVAL * 24 + DATEDIFF(HOUR, CAST(@DT1 AS TIME), CAST(@DT2 AS TIME));
RETURN @RETVAL;
END;

-- ajout des parties de minutes si précision minute
IF @DATEPART IN ('minute', 'mi', 'n')
BEGIN
SET @RETVAL = @RETVAL * 1440 + DATEDIFF(MINUTE, CAST(@DT1 AS TIME), CAST(@DT2 AS TIME));
RETURN @RETVAL;
END;

-- ajout des parties de seconde si précision seconde
IF @DATEPART IN ('second', 'ss', 's')
BEGIN
SET @RETVAL = @RETVAL * 86400 + DATEDIFF(SECOND, CAST(@DT1 AS TIME), CAST(@DT2 AS TIME));
RETURN @RETVAL;
END;

-- ajout des parties de milliseconde si précision milliseconde
IF @DATEPART IN ('millisecond', 'ms')
BEGIN
SET @RETVAL = @RETVAL * 86400000 + DATEDIFF(millisecond, CAST(@DT1 AS TIME), CAST(@DT2 AS TIME));
RETURN @RETVAL;
END;

RETURN NULL;
END;
GO

Développez et administrez pour la performance avec SQL Server 2014

L’entreprise SQL Spot
Le site web sur le SQL et les SGBDR

Calcules de durée en jour avec des mois comptables de 30 jours

SQLpro — Mon, 23 Mar 2015 22:55:56 +0000

À la suite d’une demande du forum, je me suis penché sur le calcul de durée en jour avec des mois comptables de 30 jours. Comme d’habitude il faut passer par une table de date !

La demande originale est postée ici :
www.developpez.net/forums/d1508019/bases-donnees/ms-sql-server/developpement/

Nous sommes partit de la table suivante :

CREATE TABLE T_DAT
(DAT_DATE DATE PRIMARY KEY,
DAT_AN AS CAST(YEAR(DAT_DATE) AS SMALLINT) PERSISTED,
DAT_MOIS AS CAST(MONTH(DAT_DATE) AS TINYINT) PERSISTED,
DAT_JOUR AS CAST(DAY(DAT_DATE) AS TINYINT) PERSISTED,
DAT_NB_JOUR_FIN_MOIS TINYINT ,
DAT_JOUR_FIN_MOIS TINYINT
);

Que nous avons rempli avec les 3 requêtes suivantes :

SET NOCOUNT ON;
DECLARE @D DATE
SET @D = '2000-01-01'
WHILE @D < '2100-12-31'
BEGIN
INSERT INTO T_DAT (DAT_DATE) VALUES (@D);
SET @D = DATEADD(DAY, 1, @D)
END;
GO

WITH T0 AS
(
SELECT DAT_DATE, ROW_NUMBER() OVER(PARTITION BY DAT_AN, DAT_MOIS ORDER BY DAT_JOUR DESC) - 1 AS NB_JOUR_FIN_MOIS
FROM T_DAT
)
UPDATE T
SET DAT_NB_JOUR_FIN_MOIS = NB_JOUR_FIN_MOIS
FROM T_DAT AS T
INNER JOIN T0
ON T.DAT_DATE = T0.DAT_DATE;
GO

UPDATE T
SET DAT_JOUR_FIN_MOIS = T2.DAT_JOUR
FROM T_DAT AS T
INNER JOIN T_DAT AS T2
ON T.DAT_AN = T2.DAT_AN
AND T.DAT_MOIS = T2.DAT_MOIS
AND T2.DAT_NB_JOUR_FIN_MOIS = 0
GO

Nous avons ensuite créé la fonction de calcul :

CREATE FUNCTION F_MOIS30 (@D1 DATE, @D2 DATE)
RETURNS INT
AS
BEGIN
DECLARE @AN INT, @MOIS INT, @JFM INT

SELECT @AN = DAT_AN, @MOIS = DAT_MOIS, @JFM = DAT_NB_JOUR_FIN_MOIS
FROM T_DAT
WHERE DAT_DATE = @D1;

SELECT @AN = DAT_AN - @AN, @MOIS = DAT_MOIS - @MOIS, @JFM = @JFM + DAT_JOUR
FROM T_DAT
WHERE DAT_DATE = @D2;

RETURN (@AN * 12 + @MOIS - 1) * 30 + @JFM
END;
GO

Il ne restait plus qu'à la tester :

SELECT dbo.F_MOIS30('2014-03-20', '2015-02-01')

Ce qui donne 312 résultat escompté !

CQFD

L’entreprise SQL Spot
Le site web sur le SQL et les SGBDR

Vider toutes les tables d’une base

SQLpro — Tue, 22 Jul 2014 12:08:25 +0000

Une question simple et un réponse efficace. Comment vider toutes les tables d’une base de données ?

L’intégrité référentielle va complexifier la chose car il faudrait faire un DELETE de chaque table en tenant compte de la hiérarchie d’imbrication des références d’intégrités du fait des contraintes de clefs étrangères. Mais SQL Server permet de désactiver les contraintes, ce qui va nous rendre service dans le cas présent.
La solution consiste donc à :
– désactiver les contraintes FOREIGN KEY
– lancer un DELETE sur toutes les tables
– réactiver les contraintes FOREIGN KEY
Voici le script final :

DECLARE @SQL NVARCHAR(MAX);
SET @SQL = N'';

BEGIN TRANSACTION;

BEGIN TRY

-- désactivation des contraintes d'intégrité référentielles pour les clefs étrangères

SELECT @SQL = @SQL + N'ALTER TABLE [' + TABLE_SCHEMA + N'].[' + TABLE_NAME + N'] '
+ N' NOCHECK CONSTRAINT [' + CONSTRAINT_NAME + N'];'
FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS
WHERE CONSTRAINT_TYPE = N'FOREIGN KEY';

EXEC (@SQL);

SET @SQL = N'';

-- vidage des tables

SELECT @SQL = @SQL + 'DELETE FROM [' + TABLE_SCHEMA + N'].[' + TABLE_NAME + N'];'
FROM INFORMATION_SCHEMA.TABLES
WHERE TABLE_TYPE = 'BASE TABLE';

EXEC (@SQL);

-- réactivation des contraintes d'intégrité référentielles pour les clefs étrangères

SELECT @SQL = @SQL + N'ALTER TABLE [' + TABLE_SCHEMA + N'].[' + TABLE_NAME + N'] WITH CHECK'
+ N' CHECK CONSTRAINT [' + CONSTRAINT_NAME + N'];'
FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS
WHERE CONSTRAINT_TYPE = N'FOREIGN KEY';

EXEC (@SQL);

COMMIT TRANSACTION:

END TRY
BEGIN CATCH
ROLLBACK;
DECLARE @MSG NVARCHAR(1200);
RAISERROR ('Transaction annulée suite à erreur dans le script : ', 16, 1, @MSG)
END CATCH;

L’entreprise SQL Spot
Le site web sur le SQL et les SGBDR

Format de date SQL Server

SQLpro — Wed, 28 May 2014 08:39:58 +0000

Quel format utiliser pour une date avec SQL Server ? Le format normatif bien sûr !

Le format des dates (exprimées sous forme de chaines de caractères) :

La norme SQL impose 2 formats différents pour les dates exprimées sous forme de chaines de caractères :
1) Format ISO court : AAAAMMJJ (aucun séparateur, année en premier sur 4 chiffres, puis mois sur 2 et jour sur 2).
2) Format ISO long : AAAA-MM-JJ (séparateur le tiret, année en premier sur 4 chiffres, puis mois sur 2 et jour sur 2).
Ce sont les seuls formats de date supportés quelque soit les configurations des serveurs et des sessions.
Mieux vaut donc s’en tenir exclusivement à ces deux formats.

Dans quel cas les utiliser ?

1) Format ISO court : DATETIME
2) Format ISO long : DATETIME2, DATE, DATETIMEOFFSET

Pourquoi ces différences ?

MS SQL Server essaye de respecter la norme SQL au plus près.
Le format ISO court était le format recommandé par la norme SQL jusqu’à la version SQL 2 de 1992. À cette époque SQL Server n’avait que le type DATETIME
À partir de la norme SQL de 1999, le format a changé en ISO long. Or comme les types DATETIME2, DATE, DATETIMEOFFSET ont été introduits en 2008 par SQL Server, c’est désormais sur le format ISO long que ces nouveaux types reposent.

NOTA : pour des raisons de précision, il faut éviter le type DATETIME et le convertir en DATETIME2. Le type DATETIME étant considéré comme obsolète.

D’autres formats ?

Il suffit de le préciser pour votre session par la commande SET DATEFORMAT et il spécifie l’ordre des parties de la date. Les paramètres valides sont mdy, dmy, ymd, ydm, myd et dym. Aucun séparateur particulier n’est à spécifier car tous sont ignorés. Le système prendra donc en compte uniquement les chiffres, et pour l’année, sur 2 ou 4 chiffres. La valeur pivot du siècle étant définie par la configuration du serveur (EXEC sp_configure ‘two digit year cutoff’).
La valeur par défaut de ce paramétrage de session étant celle spécifique à la « langue » de l’utilisateur. Par exemple pour un utilisateur s’étant connecté en langue française, la valeur par défaut est dmy.

L’entreprise SQL Spot
Le site web sur le SQL et les SGBDR

Procédure de réorganisation du stockage de la base tempdb d’une instance Microsoft SQL Server

SQLpro — Sat, 17 Aug 2013 17:44:18 +0000

Cette procédure est destinée à réorganiser le stockage de la base de données système tempdb d’une instance Microsoft SQL Server

NOTA : on trouvera une version exempte des erreurs liés au format de publication de développez.com à l’URL :
http://sqlprofessionnal.wordpress.com/2013/08/17/procedure-de-reorganisation-du-stockage-de-la-base-tempdb-dune-instance-microsoft-sql-server/

USE msdb;
GO

IF OBJECT_ID('dbo.P_MOVE_TEMPDB_FILES') IS NOT NULL
EXEC ('DROP PROCEDURE dbo.P_MOVE_TEMPDB_FILES ');
GO

CREATE PROCEDURE dbo.P_MOVE_TEMPDB_FILES
@NBR_FICHIER TINYINT, -- nombre de fichiers de données à créer
@DEST_DATA NVARCHAR(256), -- répertoire destination des données
@SIZE_DATA_GB SMALLINT, -- taille des fichiers de données en Go
@DEST_TRAN NVARCHAR(128), -- répertoire destination des transactions
@SIZE_TRAN_GB SMALLINT, -- taille du journal de transaction en Go
@GROWTH_MB TINYINT -- pas d'incrément des fichiers en Mo
AS
/******************************************************************************
* Procédure modifiant le stockage des fichiers de la base système tempdb *
*******************************************************************************
* Fred. Brouard - http://sqlpro.developpez.com - www.sqlspot.com - 2013-08-16 *
*******************************************************************************
* Cette procédure permet de redessiner le stockage de la BD système tempdb *
* FONCTIONNEMENT : *
* après avoir vérifié les paramètres, la procédure modifie l'organisation du *
* stockage de la base tempdb et fournit un script pour supprimer les fichiers *
* obsolètes. *
*******************************************************************************
* PARAMÈTRES : *
* @NBR_FICHIER : nombre de fichiers de données à créer *
* @DEST_DATA : répertoire de destination des fichiers de données *
* @SIZE_DATA_GB : taille des fichiers de données en Go *
* @DEST_TRAN : répertoire de destination du journal de transaction *
* @SIZE_DATA_GB : taille du journal de transaction en Go *
* @GROWTH_MB : taile en Mo du pas d'incrément de tous les fichiers *
*******************************************************************************
* PROBLÈMES POSSIBLES : *
* - l'utilisateur qui lance cette procédure n'a pas les privilèges adéquats *
* - le compte de service de l'instance SQL Server n'a pas les droits en *
* lecture/ecriture sur le répertoire de destination *
* - le répertoire de destination n'a pas une capacité suffisante pour y *
* stocker les fichiers à déplacer *
* - des fichiers possédant le même nom sont déjà en exploitation dans la *
* destination
* REMÈDE : *
* en cas d'erreur, le résultat (paneau messages de SSMS) fournit la commande *
* qui est partie en exception, mais aussi toute la partie déjà exécutée du *
* script de migration. *
******************************************************************************/
BEGIN
-- variables locales
DECLARE @N TABLE (N TINYINT);
DECLARE @T TABLE (existe BIT, repertoire BIT, parent BIT);
DECLARE @F TABLE (nom_logique sysname,
nom_physique NVARCHAR(384),
nature CHAR(4),
"action" CHAR(6),
destination NVARCHAR(384),
taille_GO SMALLINT);
DECLARE @U TABLE (unite CHAR(1), capacite INT); -- capacité de stockage actuelle
DECLARE @D TABLE (unite CHAR(1), capacite INT); -- volume à stocké

DECLARE @SQL NVARCHAR(max), @SCRIPT NVARCHAR(max), @ERROR NVARCHAR(102);

-- initialisations diverses
SELECT @SIZE_DATA_GB = COALESCE(@SIZE_DATA_GB, 0),
@SIZE_TRAN_GB = COALESCE(@SIZE_TRAN_GB, 0);
INSERT INTO @N VALUES (0), (1), (2), (3);
INSERT INTO @N
SELECT T1.N + T2.N * 4 +T3.N * 16
FROM @N AS T1
CROSS JOIN @N AS T2
CROSS JOIN @N AS T3
WHERE T1.N + T2.N * 4 +T3.N * 16 > 3;
UPDATE @N SET N = N + 1;

-- vérifications diverses :
IF @NBR_FICHIER = 0 OR @NBR_FICHIER IS NULL
BEGIN
RAISERROR('Le nombre de fichiers à spécifier pour les données doit être > 0.',
16, 1);
RETURN;
END;
IF @NBR_FICHIER > 64
BEGIN
RAISERROR('Le nombre de fichiers pour les données (%d) est trop élevé.',
16, 1);
RETURN;
END;
IF @SIZE_DATA_GB < 1
BEGIN
RAISERROR('la taille spécifieé %d pour les données est incorrecte.',
16, 1, @SIZE_DATA_GB);
RETURN;
END;
IF @SIZE_TRAN_GB < 1
BEGIN
RAISERROR('la taille spécifieé %d pour les transactions est incorrecte.',
16, 1, @SIZE_TRAN_GB);
RETURN;
END;

-- les destinations sont-elles bien des répertoires ?
IF RIGHT(@DEST_DATA, 1) '\'
SET @DEST_DATA = @DEST_DATA + N'\';
SET @SQL = 'EXEC sys.xp_fileexist ''' + @DEST_DATA +''';'
INSERT INTO @T EXEC (@SQL);
IF NOT EXISTS(SELECT * FROM @T WHERE repertoire = 1)
BEGIN
RAISERROR('L''emplacement %s n''est pas un répertoire de données.',
16, 1, @DEST_DATA);
RETURN;
END;
DELETE FROM @T;
IF RIGHT(@DEST_TRAN, 1) '\'
SET @DEST_TRAN = @DEST_TRAN + N'\';
SET @SQL = 'EXEC sys.xp_fileexist ''' + @DEST_TRAN +''';'
INSERT INTO @T EXEC (@SQL);
IF NOT EXISTS(SELECT * FROM @T WHERE repertoire = 1)
BEGIN
RAISERROR('L''emplacement %s n''est pas un répertoire de données.',
16, 1, @DEST_TRAN);
RETURN;
END;
-- y a t-il la capacité de stockage ?
INSERT INTO @U
EXEC ('EXEC xp_fixeddrives;');
INSERT INTO @D SELECT LEFT(@DEST_DATA, 1), @NBR_FICHIER * @SIZE_DATA_GB * 1024;
IF LEFT(@DEST_DATA, 1) = LEFT(@DEST_TRAN, 1)
UPDATE @D
SET capacite = capacite + @SIZE_TRAN_GB * 1024
WHERE unite = LEFT(@DEST_TRAN, 1)
ELSE
INSERT INTO @D SELECT LEFT(@DEST_TRAN, 1), @SIZE_TRAN_GB * 1024;
SET @ERROR = N'';
SELECT @ERROR = @ERROR + N' '
+ CAST((D.capacite - U.capacite) / 1024.0 AS NVARCHAR(32))
+ N' Go dans l''unité ' + U.unite + N', '
FROM @U AS U
INNER JOIN @D AS D
ON U.unite = D.unite
WHERE U.capacite < D.capacite;
IF @ERROR N''
BEGIN
SET @ERROR = N'Il manque ' + SUBSTRING(@ERROR, 1, LEN(@ERROR) - 1)
+ N' pour assurer la capacité de stockage demandée.';
RAISERROR(@ERROR, 16, 1, @DEST_TRAN);
RETURN;
END;
-- la procédure xp_cmdshell est-elle utilisable ?
IF NOT EXISTS(SELECT * FROM sys.configurations
WHERE name = 'xp_cmdshell' AND value_in_use = 1)
BEGIN
RAISERROR('La procédure xp_cmdshell nécessaire à l''utilisation
de cette procédure est désactivée. Veuillez contacter
votre adminisrateur de bases de données', 16, 1);
RETURN;
END;

-- on stocke les matadonnées de redéfinition du stockage dans @F
-- fichier à modifier :
INSERT INTO @F
SELECT name, physical_name, type_desc, 'MODIFY',
CASE
WHEN "type" = 0 THEN @DEST_DATA
WHEN "type" = 1 THEN @DEST_TRAN
END + REVERSE(SUBSTRING(REVERSE(physical_name), 1 ,
CHARINDEX('\', REVERSE(physical_name)) -1)),
CASE
WHEN "type" = 0 THEN @SIZE_DATA_GB
WHEN "type" = 1 THEN @SIZE_TRAN_GB
END
FROM sys.master_files AS f
WHERE DB_NAME(database_id) = 'tempdb'
AND file_id 2;

-- fichiers de données à créer :
INSERT INTO @F
SELECT 'tempdata' + CAST(N AS VARCHAR(2)),
NULL,
'ROWS', 'ADD',
@DEST_DATA + 'tempdata' + CAST(N AS VARCHAR(2)) + '.ndf',
@SIZE_DATA_GB
FROM @N
WHERE N BETWEEN 1 AND @NBR_FICHIER - 1;

SET @SCRIPT = N'';
-- construction du script de modification du stockage de tempdb
BEGIN TRY
-- fichiers à modifier
SET @SQL = N'';
SELECT @SQL = @SQL + N'ALTER DATABASE tempdb MODIFY FILE ( NAME = '''
+ nom_logique + N''', FILENAME = '''
+ destination + N''', SIZE = '
+ CAST(taille_GO AS VARCHAR(16)) + N' GB, FILEGROWTH = '
+ CAST(@GROWTH_MB AS VARCHAR(16)) + N' MB);'
FROM @F
WHERE "action" = 'MODIFY';
EXEC (@SQL);
SET @SCRIPT = @SCRIPT + @SQL + NCHAR(13) + NCHAR(10)
+ N'GO' + NCHAR(13) + NCHAR(10);

-- fichiers à supprimer
SET @SQL = N'';
SELECT @SQL = @SQL + N'ALTER DATABASE tempdb REMOVE FILE ['
+ nom_logique + N'];'
FROM @F
WHERE "action" = 'REMOVE';
EXEC (@SQL);
SET @SCRIPT = @SCRIPT + @SQL + NCHAR(13) + NCHAR(10)
+ N'GO' + NCHAR(13) + NCHAR(10);
EXEC (@SQL);
SET @SCRIPT = @SCRIPT + @SQL + NCHAR(13) + NCHAR(10)
+ N'GO' + NCHAR(13) + NCHAR(10);

-- fichiers à ajouter
SET @SQL = N'';
SELECT @SQL = @SQL + N'ALTER DATABASE tempdb ADD FILE ( NAME = '''
+ nom_logique + N''', FILENAME = '''
+ destination + N''', SIZE = '
+ CAST(taille_GO AS VARCHAR(16)) + N' GB, FILEGROWTH = '
+ CAST(@GROWTH_MB AS VARCHAR(16)) + N' MB);'
FROM @F
WHERE "action" = 'ADD';
EXEC (@SQL);
SET @SCRIPT = @SCRIPT + @SQL + NCHAR(13) + NCHAR(10)
+ N'GO' + NCHAR(13) + NCHAR(10);

-- tout s'est bien passé, on informe des fichiers à nettoyer
SELECT nom_physique AS FICHIER_A_SUPPRIMER,
'EXEC xp_cmdshell ''DEL "' + nom_physique +'"'';'
FROM @F
WHERE nom_physique IS NOT NULL
AND nom_physique destination;
END TRY
-- en cas d'ereur...
BEGIN CATCH
SET @ERROR = ERROR_MESSAGE();
RAISERROR('Une erreur est survenur lors de la procédure dbo.P_MOVE_TEMPDB_FILES .', 16, 1);
-- renseigne sur la commande ayant levée l'exception
RAISERROR('L''ereur est survenue lors de la commande : %s', 16, 1, @SQL);
-- renvoie la partie du script déjà exécutée
RAISERROR(@ERROR, 16, 1);
PRINT '--- PARTIE DU SCRIPT DÉJÀ EXÉCUTÉE ---';
PRINT @SCRIPT;
END CATCH
END;
GO

Exemple d’utilisation :

EXEC msdb.dbo.P_MOVE_TEMPDB_FILES
@NBR_FICHIER = 4 , — nombre de fichiers de données à créer
@DEST_DATA = ‘D:\DATABASES\SQL2008R2′, — répertoire destination des données
@SIZE_DATA_GB = 16, — taille des fichiers de données en Go
@DEST_TRAN = ‘E:\DATABASES\SQL2008R2′, — répertoire destination des transactions
@SIZE_TRAN_GB = 10, — taille du journal de transaction en Go
@GROWTH_MB = 100 — pas d’incrément des fichiers en Mo

Algorithme de placement optimal d’une ressource, compte tenu de la distance et de la population cible (Dijkstra)

SQLpro — Fri, 24 May 2013 15:07:16 +0000

La recherche d’un placement optimal sur un graphe composé de nœuds et d’arcs est similaire à un calcul de plus court chemin mais doit prendre en considération des poids supplémentaires, ici, la population de chaque nœud. L’ensemble est réalisé par des procédures Transact SQL dans une base dédiée à ce type de calcul pour MS SQL Server (toutes versions depuis 2000).

Cette méthode est basée sur les procédures de plus court chemin écrites par l’utilisateur SwePeso sur sqlteam.com et utilise l’algorithme de Dijkstra.
Cette solution originale a été proposée par Evan Barke dans le forum consacré à MS SQL Server :
http://www.developpez.net/forums/d1346509/

CRÉATION DE LA BASE DE DONNÉES

/******************************************************************************
* ALGORITHME DE DIJKSTRA : recherche d'un placement optimal *
*******************************************************************************
* CRÉATION DE LA BASE DE DONNÉES *
*******************************************************************************
* Solution originale d'Evan Barke :http://www.developpez.net/forums/d1346509/ *
******************************************************************************/
CREATE DATABASE DB_DIJKSTRA
GO

ALTER DATABASE DB_DIJKSTRA SET RECOVERY SIMPLE;
GO

DECLARE @SQL NVARCHAR(max);
SELECT @SQL = COALESCE(@SQL, '') +
CASE "type"
WHEN 0 THEN'ALTER DATABASE DB_DIJKSTRA MODIFY FILE (NAME = ''' + name +''', SIZE = 250 MB);'
WHEN 1 THEN'ALTER DATABASE DB_DIJKSTRA MODIFY FILE (NAME = ''' + name +''', SIZE = 50 MB);'
END
FROM sys.master_files
WHERE name = 'DB_DIJKSTRA';
EXEC (@SQL);

USE DB_DIJKSTRA
GO

CRÉATION DES TABLES DE TRAVAIL :

/******************************************************************************
* ALGORITHME DE DIJKSTRA : recherche d'un placement optimal *
*******************************************************************************
* CRÉATION DES TABLES DE TRAVAIL *
*******************************************************************************
* Solution originale d'Evan Barke :http://www.developpez.net/forums/d1346509/ *
******************************************************************************/
CREATE TABLE Nodes (
NodeID BIGINT IDENTITY (1, 1) NOT NULL PRIMARY KEY,
NodeName NVARCHAR(64) NOT NULL ,
Cost FLOAT,
PathID BIGINT,
Calculated BIT NOT NULL DEFAULT 0,
Population FLOAT,
Score FLOAT
)
GO

CREATE TABLE Paths (
PathID BIGINT IDENTITY (1, 1) NOT NULL PRIMARY KEY,
FromNodeID BIGINT NOT NULL
FOREIGN KEY REFERENCES Nodes (NodeID),
ToNodeID BIGINT NOT NULL
FOREIGN KEY REFERENCES Nodes (NodeID),
Cost FLOAT NOT NULL
);
GO

CREATE TABLE PathsMatrix (
MatPathID BIGINT IDENTITY (1, 1) NOT NULL PRIMARY KEY,
FromNodeID BIGINT NOT NULL ,
ToNodeID BIGINT NOT NULL ,
Cost FLOAT NULL
);
GO

PROCÉDURE DE VIDAGE ET REMISE À ZÉRO AUTO INCRÉMENT :

CREATE PROCEDURE uspDijkstraInitializeMap

AS
/******************************************************************************
* ALGORITHME DE DIJKSTRA : recherche d'un placement optimal *
*******************************************************************************
* PROCÉDURE DE VIDAGE ET REMISE À ZÉRO AUTO INCRÉMENT *
*******************************************************************************
* Solution originale d'Evan Barke :http://www.developpez.net/forums/d1346509/ *
******************************************************************************/
SET NOCOUNT ON;

DELETE FROM Paths;

DBCC CHECKIDENT (Paths, RESEED, 0);

DELETE FROM Nodes;

DBCC CHECKIDENT (Nodes, RESEED, 0);

GO

PROCÉDURE D’AJOUT D’UN CHEMIN :

CREATE PROCEDURE uspDijkstraAddPath
@FromNodeName NVARCHAR(64),
@ToNodeName NVARCHAR(64),
@Cost FLOAT
AS
/******************************************************************************
* ALGORITHME DE DIJKSTRA : recherche d'un placement optimal *
*******************************************************************************
* PROCÉDURE D'AJOUT D'UN CHEMIN *
*******************************************************************************
* Solution originale d'Evan Barke :http://www.developpez.net/forums/d1346509/ *
******************************************************************************/
SET NOCOUNT ON;

DECLARE @FromNodeID BIGINT,
@ToNodeID BIGINT,
@PathID BIGINT;

SELECT @FromNodeID = NodeID
FROM Nodes
WHERE NodeName = @FromNodeName;

IF @FromNodeID IS NULL
BEGIN

INSERT Nodes (NodeName, Calculated)
VALUES (@FromNodeName, 0);

SELECT @FromNodeID = SCOPE_IDENTITY();

END;

SELECT @ToNodeID = NodeID
FROM Nodes
WHERE NodeName = @ToNodeName;

IF @ToNodeID IS NULL
BEGIN

INSERT Nodes (NodeName, Calculated)
VALUES (@ToNodeName, 0);

SELECT @ToNodeID = SCOPE_IDENTITY();

END

SELECT @PathID = PathID
FROM Paths
WHERE FromNodeID = @FromNodeID
AND ToNodeID = @ToNodeID;

IF @PathID IS NULL

INSERT Paths (FromNodeID, ToNodeID, Cost)
VALUES (@FromNodeID, @ToNodeID, @Cost);

ELSE

UPDATE Paths
SET Cost = @Cost
WHERE FromNodeID = @FromNodeID
AND ToNodeID = @ToNodeID;
GO

PROCÉDURE DE RÉINITIALISATION DU CALCUL DE COUT :

CREATE PROCEDURE dbo.uspDijkstraClearMap
AS
/******************************************************************************
* ALGORITHME DE DIJKSTRA : recherche d'un placement optimal *
*******************************************************************************
* PROCÉDURE DE RÉINITIALISATION DU CALCUL DE COUT *
*******************************************************************************
* Solution originale d'Evan Barke :http://www.developpez.net/forums/d1346509/ *
******************************************************************************/
SET NOCOUNT ON;

UPDATE Nodes
SET PathID = NULL,
Cost = NULL,
Calculated = 0;
GO

PROCÉDURE DE CALCUL DE MOINDRE COUT ENTRE DEUX NŒUDS :

CREATE PROCEDURE uspDijkstraResolve
@FromNodeName NVARCHAR(64),
@ToNodeName NVARCHAR(64)
AS
/******************************************************************************
* ALGORITHME DE DIJKSTRA : recherche d'un placement optimal *
*******************************************************************************
* PROCÉDURE DE CALCUL DE MOINDRE COUT ENTRE DEUX NŒUDS *
*******************************************************************************
* Solution originale d'Evan Barke :http://www.developpez.net/forums/d1346509/ *
******************************************************************************/
SET NOCOUNT ON;

INSERT INTO PathsMatrix (FromNodeID, ToNodeID)
VALUES ((SELECT NodeID
FROM Nodes
WHERE NodeName = @FromNodeName) ,
(SELECT NodeID
FROM Nodes
WHERE NodeName = @ToNodeName));

DECLARE @MatPathID BIGINT,
@FromNodeID BIGINT,
@ToNodeID BIGINT,
@NodeID BIGINT,
@Cost FLOAT,
@PathID BIGINT;

DECLARE @Map TABLE (RowID BIGINT IDENTITY(-1, -1),
FromNodeName NVARCHAR(64),
ToNodeName NVARCHAR(64),
Cost FLOAT);

SELECT TOP 1 @MatPathID = MatPathID
FROM PathsMatrix
ORDER BY MatPathID DESC;

EXEC uspDijkstraClearMap;

SELECT @FromNodeID = NodeID,
@NodeID = NodeID
FROM Nodes
WHERE NodeName = @FromNodeName;

IF @FromNodeID IS NULL
BEGIN
SELECT @FromNodeName = COALESCE(@FromNodeName, '');
RAISERROR ('From node name ''%s'' can not be found.', 16, 1, @FromNodeName);
RETURN;
END

SELECT @ToNodeID = NodeID
FROM Nodes
WHERE NodeName = @ToNodeName;

IF @ToNodeID IS NULL
BEGIN
SELECT @ToNodeName = COALESCE(@ToNodeName, '');
RAISERROR ('To node name ''%s'' can not be found.', 16, 1, @ToNodeName);
RETURN;
END

UPDATE Nodes
SET Cost = 0
WHERE NodeID = @FromNodeID;

WHILE @NodeID IS NOT NULL
BEGIN

UPDATE ToNodes
SET ToNodes.Cost = CASE
WHEN ToNodes.Cost IS NULL
THEN FromNodes.Cost + Paths.Cost
WHEN FromNodes.Cost + Paths.Cost < ToNodes.Cost
THEN FromNodes.Cost + Paths.Cost
ELSE ToNodes.Cost
END,
ToNodes.PathID = Paths.PathID
FROM Nodes AS FromNodes
INNER JOIN Paths
ON Paths.FromNodeID = FromNodes.NodeID
INNER JOIN Nodes AS ToNodes
ON ToNodes.NodeID = Paths.ToNodeID
WHERE FromNodes.NodeID = @NodeID
AND (ToNodes.Cost IS NULL OR FromNodes.Cost + Paths.Cost < ToNodes.Cost)
AND ToNodes.Calculated = 0;

UPDATE FromNodes
SET FromNodes.Calculated = 1
FROM Nodes AS FromNodes
WHERE FromNodes.NodeID = @NodeID;

SELECT @NodeID = NULL;

SELECT TOP 1 @NodeID = Nodes.NodeID
FROM Nodes
WHERE Nodes.Calculated = 0
AND Nodes.Cost IS NOT NULL
ORDER BY Nodes.Cost;
END

IF EXISTS (SELECT NULL
FROM Nodes
WHERE NodeID = @ToNodeID
AND Cost IS NULL)
BEGIN
SELECT FromNodeName, ToNodeName, Cost
FROM @Map;

RETURN;
END

WHILE @FromNodeID @ToNodeID
BEGIN
SELECT @FromNodeName = FromNodes.NodeName,
@ToNodeName = ToNodes.NodeName,
@Cost = ToNodes.Cost,
@PathID = ToNodes.PathID
FROM Nodes AS ToNodes
INNER JOIN Paths
ON Paths.PathID = ToNodes.PathID
INNER JOIN Nodes AS FromNodes
ON FromNodes.NodeID = Paths.FromNodeID
WHERE ToNodes.NodeID = @ToNodeID;

INSERT @Map (FromNodeName, ToNodeName, Cost)
VALUES (@FromNodeName, @ToNodeName, @Cost);

SELECT @ToNodeID = Paths.FromNodeID
FROM Paths
WHERE Paths.PathID = @PathID;

END;

UPDATE PathsMatrix
SET Cost = (SELECT MAX(Cost) FROM @Map)
WHERE MatPathID = @MatPathID;

GO

PROCÉDURE DE GÉNÉRATION DE LA MATRICE DES CHEMINS :

CREATE PROCEDURE dbo.uspDijkstraCreateMatrix
/******************************************************************************
* ALGORITHME DE DIJKSTRA : recherche d'un placement optimal *
*******************************************************************************
* PROCÉDURE DE GÉNÉRATION DE LA MATRICE DES CHEMINS *
*******************************************************************************
* Solution originale d'Evan Barke :http://www.developpez.net/forums/d1346509/ *
******************************************************************************/
AS

SET NOCOUNT ON;

IF EXISTS (SELECT 1 FROM PathsMatrix)
TRUNCATE TABLE PathsMatrix;

DECLARE @FROM NVARCHAR(64),
@TO NVARCHAR(64);

DECLARE cursorNodes CURSOR
LOCAL FORWARD_ONLY STATIC READ_ONLY
FOR
SELECT FromNode.NodeName, ToNode.NodeName
FROM Nodes AS FromNode
CROSS JOIN Nodes AS ToNode
WHERE FromNode.NodeName ToNode.NodeName;

OPEN cursorNodes;

FETCH cursorNodes INTO @FROM, @TO;

WHILE @@FETCH_STATUS = 0
BEGIN

EXEC dbo.uspDijkstraResolve
@FromNodeName = @FROM,
@ToNodeName = @TO;

FETCH cursorNodes INTO @FROM, @TO
END

CLOSE cursorNodes;
DEALLOCATE cursorNodes;

GO

PROCÉDURE DE CALCUL DU PLACEMENT OPTIMAL :

CREATE PROCEDURE dbo.uspDijkstraCalculateOptimal
AS
/******************************************************************************
* ALGORITHME DE DIJKSTRA : recherche d'un placement optimal *
*******************************************************************************
* PROCÉDURE DE CALCUL DU PLACEMENT OPTIMAL *
*******************************************************************************
* Solution originale d'Evan Barke :http://www.developpez.net/forums/d1346509/ *
******************************************************************************/
SET NOCOUNT ON;

DECLARE @FromNodeID NVARCHAR(64);

DECLARE cursorNodes CURSOR
LOCAL FORWARD_ONLY STATIC READ_ONLY
FOR
SELECT FromNode.NodeID
FROM Nodes AS FromNode;

OPEN cursorNodes;

FETCH cursorNodes INTO @FromNodeID;

WHILE @@FETCH_STATUS = 0
BEGIN

UPDATE Nodes SET Score = (SELECT SUM((N.Population)*P.Cost)
FROM Nodes N
INNER JOIN PathsMatrix P
ON P.FromNodeID = N.NodeID
WHERE N.NodeID = @FromNodeID)
WHERE Nodes.NodeID = @FromNodeID;

FETCH cursorNodes INTO @FromNodeID;

END

CLOSE cursorNodes;

DEALLOCATE cursorNodes;

SELECT NodeName, Score
FROM Nodes
ORDER BY Score DESC;

GO

EXEMPLE :

Notre ami Evan, vivant dans le sud à décider d’implanter sa cabane entre les vignobles de muscat (Lunel) et la mer (La Grande Motte) afin d’y vendre des peaux de kangourou… Quel sera le meilleur placement entre toutes ces villes compte tenu des distances et de la population ?

Phase 1 : initialisons les tables des nœuds et arcs

EXEC dbo.uspDijkstraInitializeMap;

Phase 2 : création des nœuds et arcs

EXEC dbo.uspDijkstraAddPath 'Mauguio', 'St Aunès', 2;
EXEC dbo.uspDijkstraAddPath 'St Aunès', 'Mauguio', 2;

EXEC dbo.uspDijkstraAddPath 'Mauguio', 'Mudaison', 3;
EXEC dbo.uspDijkstraAddPath 'Mudaison', 'Mauguio', 3;

EXEC dbo.uspDijkstraAddPath 'Mauguio', 'Candillargues', 6;
EXEC dbo.uspDijkstraAddPath 'Candillargues', 'Mauguio', 6;

EXEC dbo.uspDijkstraAddPath 'Mauguio', 'La Grande Motte', 4;
EXEC dbo.uspDijkstraAddPath 'La Grande Motte', 'Mauguio', 4;

EXEC dbo.uspDijkstraAddPath 'Mauguio', 'Pérols', 6;
EXEC dbo.uspDijkstraAddPath 'Pérols', 'Mauguio', 6;

EXEC dbo.uspDijkstraAddPath 'Candillargues', 'Lansargues', 3;
EXEC dbo.uspDijkstraAddPath 'Lansargues', 'Candillargues', 3;

EXEC dbo.uspDijkstraAddPath 'Lansargues', 'St Just', 4;
EXEC dbo.uspDijkstraAddPath 'St Just', 'Lansargues', 4;

EXEC dbo.uspDijkstraAddPath 'St Just', 'Lunel', 7;
EXEC dbo.uspDijkstraAddPath 'Lunel', 'St Just', 7;

EXEC dbo.uspDijkstraAddPath 'Pérols', 'Lattes', 6;
EXEC dbo.uspDijkstraAddPath 'Lattes', 'Pérols', 6;

Phase 3 : création de la matrice des distances

EXEC dbo.uspDijkstraCreateMatrix;

Phase 4 : pondération par la population

UPDATE Nodes SET Population = 16307 WHERE NodeName = 'Mauguio';
UPDATE Nodes SET Population = 3041 WHERE NodeName = 'St Aunès';
UPDATE Nodes SET Population = 2498 WHERE NodeName = 'Mudaison';
UPDATE Nodes SET Population = 1401 WHERE NodeName = 'Candillargues';
UPDATE Nodes SET Population = 8440 WHERE NodeName = 'La Grande Motte';
UPDATE Nodes SET Population = 8509 WHERE NodeName = 'Pérols';
UPDATE Nodes SET Population = 2744 WHERE NodeName = 'Lansargues';
UPDATE Nodes SET Population = 2851 WHERE NodeName = 'St Just';
UPDATE Nodes SET Population = 25277 WHERE NodeName = 'Lunel';
UPDATE Nodes SET Population = 15927 WHERE NodeName = 'Lattes';

Phase 5 : calcul du placement optimal

EXEC dbo.uspDijkstraCalculateOptimal;

RÉSULTAT :

NodeName Score
----------------- ---------
Lunel 4524583
Lattes 2532393
Mauguio 1223025
Pérols 944499
La Grande Motte 903080
St Just 350673
St Aunès 276731
Lansargues 271656
Mudaison 247302
Candillargues 121887

Il semble que le vignoble de Lunel soit plus attirant que la mer bleu de la grande Motte !

Le site web sur le SQL et les SGBDR


Frédéric Brouard, alias SQLpro, ARCHITECTE DE DONNÉES

Expert  S.G.B.D  relationnelles   et   langage  S.Q.L

Moste  Valuable  Professionnal  Microsoft  SQL Server

Société SQLspot  :  modélisation, conseil, formation,

optimisation,  audit,  tuning,  administration  SGBDR

Enseignant: CNAM PACA, ISEN Toulon, CESI Aix en Prov.

L’ntreprise SQL Spot

Ajout du niveau dans un arbre intervallaire

SQLpro — Wed, 17 Apr 2013 16:36:53 +0000

Voici comment ajouter le niveau des éléments dans un arbre modélisé par intervalles.

Pour notre test, la table est la suivante :

CREATE TABLE T_VEHICULE_VHC
(VHC_ID INTEGER NOT NULL PRIMARY KEY,
VHC_BG INTEGER,
VHC_BD INTEGER,
VHC_NOM VARCHAR(16));

Les données que l’on y insère sont les suivantes :

INSERT INTO T_VEHICULE_VHC VALUES (1, 1, 26, 'ALL');
INSERT INTO T_VEHICULE_VHC VALUES (2, 2, 7, 'SEA');
INSERT INTO T_VEHICULE_VHC VALUES (3, 8, 19, 'EARTH');
INSERT INTO T_VEHICULE_VHC VALUES (4, 20, 25, 'AIR');
INSERT INTO T_VEHICULE_VHC VALUES (5, 3, 4, 'SUBMARINE');
INSERT INTO T_VEHICULE_VHC VALUES (6, 5, 6, 'BOAT');
INSERT INTO T_VEHICULE_VHC VALUES (7, 9, 10, 'CAR');
INSERT INTO T_VEHICULE_VHC VALUES (8, 11, 16, 'TWO WHEELS');
INSERT INTO T_VEHICULE_VHC VALUES (9, 17, 18, 'TRUCK');
INSERT INTO T_VEHICULE_VHC VALUES (10, 21, 22, 'ROCKET');
INSERT INTO T_VEHICULE_VHC VALUES (11, 23, 24, 'PLANE');
INSERT INTO T_VEHICULE_VHC VALUES (12, 12, 13, 'MOTORCYCLE');
INSERT INTO T_VEHICULE_VHC VALUES (13, 14, 15, 'BICYCLE');;

Que l’on peut présenter ainsi :

VHC_NOM VHC_ID VHC_NIVEAU VHC_PATH
------------------ ----------- ----------- --------------------------------
ALL 1 0
AIR 4 1 AIR
PLANE 11 2 AIR, PLANE
ROCKET 10 2 AIR, ROCKET
EARTH 3 1 EARTH
CAR 7 2 EARTH, CAR
TRUCK 9 2 EARTH, TRUCK
TWO WHEELS 8 2 EARTH, TWO WHEELS
BICYCLE 13 3 EARTH, TWO WHEELS, BICYCLE
MOTORCYCLE 12 3 EARTH, TWO WHEELS, MOTORCYCLE
SEA 2 1 SEA
BOAT 6 2 SEA, BOAT
SUBMARINE 5 2 SEA, SUBMARINE

Le calcul du niveau peut se faire par la requête :

SELECT VHC_ID,
(SELECT COUNT(*)
FROM T_VEHICULE_VHC
WHERE VHC_BG REF.VHC_BD) AS VHC_NIVEAU,
VHC_NOM
FROM T_VEHICULE_VHC AS REF;

En fait il s’agit de compter le nombre de parents d’un nœud.

Pour rajouter le calcul du niveau en dur dans la table, on peut faire comme ceci :

ALTER TABLE T_VEHICULE_VHC ADD VHC_NIVEAU SMALLINT;

Ce qui rajoute la colonne niveau dans la table.

Il faut maintenant la mettre à jour :

UPDATE REF
SET VHC_NIVEAU = (SELECT COUNT(*)
FROM T_VEHICULE_VHC
WHERE VHC_BG REF.VHC_BD)
FROM T_VEHICULE_VHC AS REF;

Le site web sur le SQL et les SGBDR


Frédéric Brouard, alias SQLpro, ARCHITECTE DE DONNÉES

Expert  S.G.B.D  relationnelles   et   langage  S.Q.L

Moste  Valuable  Professionnal  Microsoft  SQL Server

Société SQLspot  :  modélisation, conseil, formation,

optimisation,  audit,  tuning,  administration  SGBDR

Enseignant: CNAM PACA, ISEN Toulon, CESI Aix en Prov.

L’ntreprise SQL Spot