Le blog de SQLpro » sql

Métadonnées de l’utilisation d’une colonne

SQLpro — Mon, 23 Oct 2017 07:07:13 +0000

Certaines modifications de type de données d’une colonne nécessitent une suppression préalable des contraintes et index. Pour vous y aider, la procédure suivante indique dans quels objets (index ou contraintes) une colonne d’une table passée en argument est enrôlée.

Dans le cas ou vous voudriez changer le type d’une telle colonne, il faudrait agir manuellement avec le scénario suivant :

1) Scripter la création des contraintes par clic droit sur le nom de chacune des contraintes et les supprimer
2) Scripter la création des index par clic droit sur le nom de chacun des index et les supprimer
3) Modifier le type de données de la colonne avec la commande ALTER TABLE … ALTER COLUMN …
4) Recréer les index
5) Recréer les contraintes

Cette procédure à été créée pour vous y aider. Elle indique pour un couple d’information table/colonne dans quels index ou contrainte cette dernière est enrôlée…
Cette procédure est créée en tant que procédure système afin d’être exploitable dans n’importe quelle base de l’instance SQL Server.

USE master;
GO

IF EXISTS(SELECT *
FROM sys.all_objects
WHERE name = 'sp__COLUMN_IS_USED'
AND schema_id = SCHEMA_ID('dbo'))
EXEC ('ROP PROCEDURE dbo.sp__COLUMN_IS_USED;');
GO

--===========================================================================--
-- METADONNÉES D'UTILISATION D'UNE COLONNE --
--===========================================================================--
-- Fredéric Brouard alias SQLpro http://sqlpro.developpez.com --
-- Société SQL SPOT - http://www.sqlspot.com 2017-10-13 - version 1.0 --
--===========================================================================--

--▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄--
-- PHASE 1 : création de la procédure --
--▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀--

USE master;
GO

CREATE PROCEDURE dbo.sp__COLUMN_IS_USED @OBJ NVARCHAR(261),
@COL NVARCHAR(128) = NULL
AS
/******************************************************************************
* METADONNÉES D'UTILISATION D'UNE COLONNE *
* Procédure listant sous forme de tables dans quels objets est utilisé une *
* colonne d'une table *
*******************************************************************************
* Frédéric Brouard - SQLpro@SQLspot.com - Sté SQL SPOT http://www.sqlspot.com *
* Plus d'info. sur http://sqlpro.developpez.com - 2017-10-13 - version 1.0 *
*******************************************************************************
* Cette procédure prend en argument le nom d'une table avec son schéma SQL *
* (sinon le schéma par défaut de l'utilisateur qui la lance) ainsi qu'un nom *
* de colonne et renvoie un jeu de données contenant le descriptif des cas *
* d'utilisation de cette colonne dans les index et les contraintes *
*******************************************************************************
* ATTENTION : procédure système ! Exécutable depuis n'importe quelle base *
* *
* Paramètre en entrée : *
* @OBJ type NVARCHAR(261) : nom de table dont on veut connaître les index *
* @COL nom de la colonne dont on veut connaître l'usage *
* *
* COLONNE de la table en sortie : *
* COLUMN_NAME nom de la colonne passée en paramètre *
* OBJECT_TYPE type d'objet (nature de la contrainte ou INDEX) *
* OBJECT_NAME nom de la contrainte ou de l'index *

* *
* EXEMPLE : *
* EXEC dbo.sp__COLUMN_IS_USED 'CC', 'Idx' *
* ... donne la liste de tous les index et contrainte de la table CC *
* incluant la colonne Idx *
* *
******************************************************************************/

SET NOCOUNT ON;
WITH T AS (
SELECT COLUMN_NAME, CONSTRAINT_TYPE AS OBJECT_TYPE, KCU.CONSTRAINT_NAME AS OBJECT_NAME
FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE AS KCU
JOIN INFORMATION_SCHEMA.TABLE_CONSTRAINTS AS TC
ON KCU.TABLE_SCHEMA = TC.TABLE_SCHEMA
AND KCU.TABLE_NAME = TC.TABLE_NAME
AND KCU.CONSTRAINT_NAME = TC.CONSTRAINT_NAME
WHERE OBJECT_ID(KCU.TABLE_SCHEMA + '.' + KCU.TABLE_NAME) = OBJECT_ID(@OBJ)
AND REPLACE(REPLACE(RTRIM(LTRIM(@COL)), ']', ''), '[', '') = COLUMN_NAME
UNION ALL
SELECT REPLACE(REPLACE(RTRIM(LTRIM(@COL)), ']', ''), '[', ''), CONSTRAINT_TYPE AS OBJECT_TYPE, CK.CONSTRAINT_NAME AS OBJECT_NAME
FROM INFORMATION_SCHEMA.CHECK_CONSTRAINTS AS CK
JOIN INFORMATION_SCHEMA.TABLE_CONSTRAINTS AS TC
ON CK.CONSTRAINT_SCHEMA = TC.CONSTRAINT_SCHEMA
AND CK.CONSTRAINT_NAME = TC.CONSTRAINT_NAME
WHERE OBJECT_ID(TC.TABLE_SCHEMA + '.' + TC.TABLE_NAME) = OBJECT_ID(@OBJ)
AND CHECK_CLAUSE LIKE '%' + REPLACE(REPLACE(RTRIM(LTRIM(@COL)), ']', ''), '[', '') + '%'
UNION ALL
SELECT c.name, 'INDEX', i.name
FROM sys.indexes AS i
JOIN sys.index_columns AS ic
ON i.object_id = ic.object_id AND i.index_id = ic.index_id
JOIN sys.COLUMNS AS c
ON ic.object_id = c.object_id AND ic.column_id = c.column_id
WHERE i.object_id = OBJECT_ID(@OBJ)
AND REPLACE(REPLACE(RTRIM(LTRIM(@COL)), ']', ''), '[', '') = c.name)
SELECT *
FROM T
ORDER BY CASE OBJECT_TYPE WHEN 'PRIMARY KEY' THEN 1
WHEN 'UNIQUE' THEN 2
WHEN 'FOREIGN KEY' THEN 3
WHEN 'CHECK' THEN 4
WHEN 'INDEX' THEN 5
ELSE 99 END, OBJECT_NAME;
GO

--▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄--
-- PHASE 2 : traduction en procédure système --
--▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀--

EXEC sp_MS_marksystemobject 'sp__COLUMN_IS_USED';

Pour utiliser cette procédure, lancez la avec EXEC et passez le nom de table éventuellement préfixé par son schéma SQL ainsi que le nom de la colonne. Exemple :

EXEC sp__COLUMN_IS_USED 'matable', 'macolonne';

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

Les tables temporelles avec SQL Server (présentation)

SQLpro — Wed, 25 Jan 2017 14:00:36 +0000

Arrivée avec la norme SQL 2011, le concept de tables temporelles permet une historisation automatique des données et propose des opérateurs temporels pour « voir » vos données telles qu’elles étaient à un point ou une période du temps passé. Paradoxe : plus besoin de faire des sauvegardes ! Cette présentation montré au Microsoft Cloud Summit 2017 à paris le 24 janvier 2017, vous montre l’essentiel sur le sujet, avec SQL Server 2016 et est assortie de nombreux exemples.

La présentation PowerPoint sous forme PDF est téléchargeable ici : SQL Server et les tables temporelles

Les exemples l’accompagnant, sont téléchargeable ici :

DEMO 001 – table temporelles sans historique (fichier SQL)
DEMO 002 – table temporelles avec historique (fichier SQL)
DEMO 003 – stockage (fichier SQL)
DEMO 004 – Récupération (fichier SQL)
DEMO 005 – Purge (fichier SQL)
DEMO 005b – Purge métadonnées blocage (fichier SQL)
DEMO 006 – interrogation (fichier SQL)
DEMO 007 – In Memory (fichier SQL)
DEMO ANNEXE temporal tables (fichier SQL)

Frédéric Brouard, alias SQLpro, ARCHITECTE DE DONNÉES
Expert S.G.B.D relationnelles et langage S.Q.L
Most 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

LIKE ‘%mot%’ ou les index rotatifs….

SQLpro — Thu, 05 Jan 2017 20:01:44 +0000

Qui n’a jamais rêvé d’obtenir des performances pour rechercher des mots partiels contenus dans d’autres mots, comme par exemple tous les mots contenant « bolo » ? Dans un dictionnaire de 128 918 mots, une telle recherche met moins de 50 millisecondes à l’aide des index rotatifs, contre ??? pour le LIKE ‘%bolo%’… Explications…

diabolos, hyperboloïde, bolonaise, bolomètre, diabolo, bolométriques, amphibologie, bolonais, paraboloïde, amphibologique, bolométrique… Tels sont les mots du dictionnaire LEXIQUE du CNRS contenant la chaine de caractères « boblo ».

LE PROBLÈME

Les index des bases de données relationnelles, de type BTree (arbre équilibrés) trient les chaines de caractères par rapport à l’ordre orthographique des chaines de caractères au regard du classement des lettres de l’alphabet et de la collation choisie, cette dernière pouvant être sensible ou non, à la casse, aux accents…. Du fait de cet ordre, il est donc possible de rechercher par intervalle comme c’est le cas de la recherche d’un mot commençant par… En effet, si nous recherchons les mots commençant par « fass » ils sont regroupés les uns à la suite des autres dans l’index, ce qui permet un accès immédiat et la solution est, par exemple la suivante :

fasse

fassent

fasses

fassiez

fassions

Pour ce qui est des mots finissant par, l’index ne nous est d’aucune utilité, mais une astuce consiste à créer les mots inversés (par exemple à l’aide d’une colonne calculée), les indexer et rechercher par le même type de LIKE sur l’inverse de la terminaison souhaitée. Par exemple, rechercher tous les mots se terminant par « aide’, il suffit de faire la recherche suivante :

LIKE 'edia%'

et de renvoyer le mot correspondant !
Bien entendu pour rechercher un mot commençant par… et finissant par…, il suffit de combiner les deux recherches !
Un exemple est apporté par l’extrait de requête suivant :

WHERE MOT_MOT LIKE 'enta%' AND MOT_INVERSE LIKE CONCAT(REVERSE('aient'), '%')

Mais comment être efficace lorsque l’on recherche une chaine à l’intérieur d’un mot ? C’est là qu’intervient la notion d’index « rotatif »…

LE CONCEPT

Un index « rotatif » est en fait une liste de mots pour laquelle on supprime successivement la lettre du début à chaque tour, d’où le nom d’index « rotatif ».
Par exemple le mot « locomotive » sera ainsi décliné :

locomotive

ocomotive

comotive

omotive

motive

otive

tive

ive

On numérote alors chaque rotation, y compris le mot racine dont par convention on attribuera l’indice 0 comme niveau de rotation. Par exemple le « sous-mot » « motive » aura un indice de rotation de 4 parce qu’on lui aura retiré les 4 premières lettres.
Une fois ces mots Ajoutés dans une table de mots, il suffit de les indexer et d’ajouter une table des références croisées entre les mots racine et les rotations. La recherche peut désormais se faire via un LIKE ‘mot%’ qui permet d’exploiter l’index ! Mais il faut ensuite remonter au mot racine par une jointure à l’aide de la table des références croisées.

LA MÉCANIQUE

Afin de bien distinguer ces objets techniques de votre base, objets qui n’ont rien à voir avec les objets fonctionnels de votre application, je vous conseille de créer un schéma SQL spécifique pour les y stocker logiquement

CREATE SCHEMA S_XRT;

Les tables pour ce faire.

Deux tables suffisent : la table des mots, et la table des références croisées.

CREATE TABLE S_XRT.T_MOT
(MOT_ID INT IDENTITY PRIMARY KEY,
--> doit être sensible aux accents mais pas à la casse ! Exemple maïs et
-- mais, sur et sûr, retraite et retraité, congres et congrès !
MOT_MOT VARCHAR(32) COLLATE French_BIN NOT NULL UNIQUE);

CREATE TABLE S_XRT.T_MOT_ROTATION_MRT
(MRT_ID INT IDENTITY PRIMARY KEY,
-- pointe vers la rotation du mot
MOT_ID INT NOT NULL REFERENCES S_XRT.T_MOT (MOT_ID),
-- pointe vers la racine du mot
MOT_ID_RACINE INT NOT NULL REFERENCES S_XRT.T_MOT (MOT_ID),
-- indice de rotation
MRT_ROTATION TINYINT NOT NULL,
UNIQUE (MOT_ID, MOT_ID_RACINE, MRT_ROTATION));

Les routines

Une procédure va permettre d’indexer un mot. En voici le code en Transact SQL :

CREATE PROCEDURE S_XRT.P_INDEXATION_ROTATIVE @MOT VARCHAR(32)
AS

SET NOCOUNT ON;

SET @MOT = LOWER(LTRIM(RTRIM(@MOT)));

DECLARE @L TINYINT = LEN(@MOT), @ID_MOT INT;

DECLARE @ROTATIONS TABLE
(MOT VARCHAR(32) COLLATE French_BIN,
ROT TINYINT);

-- calcul des rotations, racine comprise (0)
WITH T AS
(SELECT @MOT AS M, 0 AS I
UNION ALL
SELECT RIGHT(M, @L-I - 1), I + 1
FROM T
WHERE I < @L - 1
)
INSERT INTO @ROTATIONS
SELECT * FROM T;

-- insertions des mots manquants
INSERT INTO S_XRT.T_MOT
SELECT MOT
FROM @ROTATIONS
WHERE MOT NOT IN (SELECT MOT_MOT
FROM S_XRT.T_MOT);

-- récupération de l'ID du mot racine
SELECT @ID_MOT = MOT_ID
FROM S_XRT.T_MOT
WHERE MOT_MOT = @MOT;

-- insertions des rotations manquantes
INSERT INTO S_XRT.T_MOT_ROTATION_MRT
SELECT M.MOT_ID, @ID_MOT, R.ROT
FROM @ROTATIONS AS R
JOIN S_XRT.T_MOT AS M
ON R.MOT = M.MOT_MOT
WHERE NOT EXISTS(SELECT *
FROM S_XRT.T_MOT_ROTATION_MRT AS MR
WHERE MR.MOT_ID = M.MOT_ID
AND MR.MOT_ID_RACINE = @ID_MOT
AND MR.MRT_ROTATION = R.ROT);

Enfin, une fonction table constituée d’une simple requête paramétrée, va permettre de retrouver les mots racine à partir des partiels :

CREATE FUNCTION S_XRT.F_SUPER_LIKE (@MOT VARCHAR(32))
RETURNS TABLE
AS
RETURN (SELECT MR.MOT_ID, MR.MOT_MOT
FROM S_XRT.T_MOT AS M
JOIN [S_XRT].[T_MOT_ROTATION_MRT] AS R
ON M.MOT_ID = R.MOT_ID
JOIN S_XRT.T_MOT AS MR
ON R.MOT_ID_RACINE = MR.MOT_ID
WHERE M.MOT_MOT LIKE LOWER(RTRIM(LTRIM(@MOT))) + '%');

QUELQUES TESTS

Nous sommes partis d’une base contenant le dictionnaire LEXIQUE du CNRS, comportant 128 918 mots.
Notre méthode pour les indexer tous a été d’utiliser un curseur pour connaitre le temps moyen mis par la procédure d’indexation. Ce traitement a été effectué sur une machine ayant les caractéristiques suivantes : 2 processeurs XEON, 48 cœurs , 128 Go de RAM, 8 disques SAS en RAID 10 avec SQL Server 2016.
Le temps de traitement a été de 26 minutes et 21 secondes, soit, pour 128 918 mots, 12 ms par mot.
Le traitement a généré :
* 376 567 entrées de mots dans la table S_XRT.T_MOT (représentant 24 Mo)
* 1 168 547 lignes dans la table S_XRT.T_MOT_ROTATION_MRT (représentant 62 Mo)
À noter qu’après réindexation, on observe une diminution du volume des données : 22 et 57 Ko respectivement.

Voici le batch que nous avons utilisé (la table du dictionnaire LEXIQUE du CNRS est dbo.TS_MOT_MOT :

DECLARE @T DATETIME = GETDATE();

DECLARE C CURSOR
LOCAL FORWARD_ONLY STATIC READ_ONLY
FOR
SELECT MOT_MOT
FROM dbo.TS_MOT_MOT
WHERE MOT_LONGUEUR > 1;

DECLARE @MOT VARCHAR(32);

OPEN C;

FETCH C INTO @MOT;

WHILE @@FETCH_STATUS = 0
BEGIN

EXEC S_XRT.P_INDEXATION_ROTATIVE @MOT;
FETCH C INTO @MOT;

END;

CLOSE C;

DEALLOCATE C;

SELECT DATEDIFF(ms, @T, GETDATE());

L’utilisation de la fonction table en ligne S_XRT.F_SUPER_LIKE, met en moyenne 50 ms quelques soit la racine cherchée si elle est constituée d’au moins 3 caractères. Exemple :

SELECT * FROM S_XRT.F_SUPER_LIKE('moti');

Pour la pire des recherches, le système met moins d’une seconde à trouver les 130 162 mots contenant la lettre e !

Pour comparaison, la recherche des mots comprenant les caractères « eta », d’une part directement dans le dictionnaire à l’aide d’un LIKE ‘%eta%’ et d’autres part dans l’index rotatif donne les métriques suivantes :
* Dictionnaire, LIKE’%eta%’ : temps UC = 652 ms, temps écoulé = 430 ms.
* Index rotatif, S_XRT.F_SUPER_LIKE (‘eta’) : Temps UC = 265 ms, temps écoulé = 50 ms.

Paradoxalement les plans de requête ne reflètent pas vraiment cette différence. les couts des plans apparaissent ainsi :
* Index rotatif, S_XRT.F_SUPER_LIKE (‘eta’) : 3,79 (soit 86 % de l’ensemble
* Dictionnaire, LIKE’%eta%’ : 0,61 (soit 14% de l’ensemble)

Plan de requête SQL Server utilisant une fonction table en ligne et l’index rotatif

Utilisation directe du LIKE ‘%toto%’

UN PEU D’ASTUCE

Au fur et à mesure de son utilisation, les index rotatifs grandissent de moins en moins, car ils contiennent déjà des rotations utilisables pour d’autres mots. On peut donc prévoir certaines manœuvres pour les rendre plus efficaces encore, comme le précalcul de certaines données, la compression des index ou encore l’utilisation de vues matérialisées (ou indexées sur SQL Server).

À titre d’exemple, nous avons obtenus la métrique suivante : temps UC = 63 ms, temps écoulé = 67 ms, à l’aide de l’une de ces techniques !

LE CODE * LE CODE * LE CODE * LE CODE * LE CODE * LE CODE * LE CODE * LE CODE * LE CODE
Le code SQL

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 requête pour lister les privilèges au niveau des utilisateurs SQL

SQLpro — Wed, 29 Jul 2015 20:51:03 +0000

Cette requête permet de retrouver l’ensemble des privilèges attribués dans une base à tous les utilisateurs SQL

WITH T AS
(
SELECT CONNEXION.name AS LOGIN_NAME,
GRANTEE.default_schema_name AS DEFAULT_SCHEMA,
PRIVILEGE.state_desc AS SQL_ORDER,
GRANTOR.name AS GRANTOR,
GRANTEE.name AS GRANTEE,
PRIVILEGE."permission_name" AS PRIVILEGE,
s.name AS OBJECT_SCHEMA,
o.name AS OBJECT_NAME,
LTRIM(STUFF((SELECT ', ' + name
FROM sys.COLUMNS AS c
WHERE PRIVILEGE.major_id = c.object_id
AND PRIVILEGE.minor_id = c.column_id
FOR XML PATH('')), 1, 1, '' )) AS COLUMN_LIST,
PRIVILEGE.class_desc AS OBJECT_CLASS,
CASE PRIVILEGE.class
WHEN 0 THEN DB_NAME()
WHEN 1 THEN o.type_desc
WHEN 3 THEN ss.name COLLATE database_default
WHEN 4 THEN dbp.name
WHEN 5 THEN asb.name
WHEN 6 THEN typ.name
WHEN 10 THEN xsc.name
END AS OBJECT_TYPE_OR_NAME
FROM sys.database_principals AS GRANTEE
LEFT OUTER JOIN sys.server_principals AS CONNEXION
ON GRANTEE.sid = CONNEXION.sid
LEFT OUTER JOIN sys.database_permissions AS PRIVILEGE
ON GRANTEE.principal_id = PRIVILEGE.grantee_principal_id
LEFT OUTER JOIN sys.database_principals AS GRANTOR
ON PRIVILEGE.grantor_principal_id = GRANTOR.principal_id
-- lien avec les objets primaires
LEFT OUTER JOIN sys.objects AS o
ON PRIVILEGE.major_id = o.object_id AND PRIVILEGE.class = 1
LEFT OUTER JOIN sys.schemas AS s
ON o.schema_id = s.schema_id
-- lien avec les schémas
LEFT OUTER JOIN sys.schemas AS ss
ON PRIVILEGE.major_id = ss.schema_id
AND minor_id = 0 AND PRIVILEGE.class = 3
-- lien avec les "principals" de la base de données
LEFT OUTER JOIN sys.database_principals AS dbp
ON PRIVILEGE.major_id = dbp.principal_id
AND minor_id = 0 AND PRIVILEGE.class = 4
-- lien avec les "assembly"
LEFT OUTER JOIN sys.assemblies AS asb
ON PRIVILEGE.major_id = asb.assembly_id
AND minor_id = 0 AND PRIVILEGE.class = 5
-- lien avec les "type" 6 =
LEFT OUTER JOIN sys.types AS typ
ON PRIVILEGE.major_id = typ.user_type_id
AND minor_id = 0 AND PRIVILEGE.class = 6
-- lien avec les collections de schémas XML
LEFT OUTER JOIN sys.xml_schema_collections AS xsc
ON PRIVILEGE.major_id = xsc.xml_collection_id
AND minor_id = 0 AND PRIVILEGE.class = 10
-- lien avec les types de message
LEFT OUTER JOIN sys.service_message_types AS smt
ON PRIVILEGE.major_id = smt.message_type_id
AND minor_id = 0 AND PRIVILEGE.class = 15
-- lien avec les contrats de service
LEFT OUTER JOIN sys.service_contracts AS sc
ON PRIVILEGE.major_id = sc.service_contract_id
AND minor_id = 0 AND PRIVILEGE.class = 16
-- lien avec les services
LEFT OUTER JOIN sys.services AS srv
ON PRIVILEGE.major_id = srv.service_id
AND minor_id = 0 AND PRIVILEGE.class = 17
-- lien avec les liaisons de service distant
LEFT OUTER JOIN sys.remote_service_bindings AS rsb
ON PRIVILEGE.major_id = rsb.remote_service_binding_id
AND minor_id = 0 AND PRIVILEGE.class = 18
-- lien avec les 19 = Itinéraire
LEFT OUTER JOIN sys.routes AS r
ON PRIVILEGE.major_id = r.route_id
AND minor_id = 0 AND PRIVILEGE.class = 19
-- lien avec les cataloguec de texte intégral
LEFT OUTER JOIN sys.fulltext_catalogs AS ftc
ON PRIVILEGE.major_id = ftc.fulltext_catalog_id
AND minor_id = 0 AND PRIVILEGE.class = 23
-- lien avec les clés symétriques
LEFT OUTER JOIN sys.symmetric_keys AS sk
ON PRIVILEGE.major_id = sk.symmetric_key_id
AND minor_id = 0 AND PRIVILEGE.class = 24
-- lien avec les certificats
LEFT OUTER JOIN sys.certificates AS ctf
ON PRIVILEGE.major_id = ctf.certificate_id
AND minor_id = 0 AND PRIVILEGE.class = 25
-- lien avec les clés asymétriques
LEFT OUTER JOIN sys.asymmetric_keys AS ask
ON PRIVILEGE.major_id = ask.asymmetric_key_id
AND minor_id = 0 AND PRIVILEGE.class = 26
WHERE GRANTEE.TYPE = 'S' --> SQL_USER
)
SELECT COALESCE (N'EXECUTE AS USER = '''+ GRANTOR + N'''; ' +
SQL_ORDER + N' ' + PRIVILEGE + N' ON ' +
COALESCE('[' + OBJECT_SCHEMA + N'].[' + OBJECT_NAME +'] ' +
COALESCE(N'(' + COLUMN_LIST + N')', ''),
OBJECT_CLASS + N'::' + OBJECT_TYPE_OR_NAME) +
N' TO ' + GRANTEE +'; REVERT;', '') AS SQL_COMMAND,
*
FROM T;

La colonne SQL_COMMAND contient le script SQL destiné à reproduire l’exécution du privilège.
En sus, la sortie fournit les informations suivantes :

LOGIN_NAME : le compte de connexion associé à l’utilisateur SQL
DEFAULT_SCHEMA : le schéma SQL par défaut de l’utilisateur
SQL_ORDER : l’ordre SQL du DCL (GRANT, DENY…)
GRANTOR : le gratifiant
GRANTEE : le gratifié
PRIVILEGE : le privilège octroyé
OBJECT_SCHEMA : le schéma SQL de l’objet
OBJECT_NAME : le nom de l’objet relationnel
COLUMN_LIST : la liste des colonnes privilégiées
OBJECT_CLASS : le nom de classe de l’objet
OBJECT_TYPE_OR_NAME : le nom de type de l’objet ou le nom de l’objet pour les objets non relationnels (conteneurs, types, assemblies…)

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