Le blog de SQLpro » index

Métrique de volumétrie du stockage par table, index et partition

SQLpro — Wed, 07 Feb 2018 09:19:04 +0000

Voici une petite requête complémentaire pour mesurer les volumes stockées par partition, index et tables d’une base :

SELECT s.name AS TABLE_SCHEMA, o.name AS TABLE_NAME, i.name AS INDEX_NAME,
fs.name AS FILEGROUP_NAME, f.name AS FILE_NAME, f.physical_name, p.partition_number,
p.ROWS, p.data_compression_desc, au.total_pages * 8 AS SIZE_TOTAL_KO,
SUM(au.total_pages * 8) OVER(PARTITION BY i.name, s.name, o.name) AS SIZE_TOTAL_INDEX_KO,
SUM(au.total_pages * 8) OVER(PARTITION BY s.name, o.name) AS SIZE_TOTAL_TABLE_KO
FROM sys.partitions AS p
JOIN sys.allocation_units AS au
ON p.hobt_id = au.container_id
JOIN sys.filegroups AS fs
ON au.data_space_id = fs.data_space_id
JOIN sys.database_files AS f
ON fs.data_space_id = f.file_id
JOIN sys.objects AS o
ON p.object_id = o.object_id
JOIN sys.schemas AS s
ON o.schema_id = s.schema_id
JOIN sys.indexes AS i
ON p.object_id = i.object_id
AND p.index_id = i.index_id;

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

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 !

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

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

Métadonnées des index (sp__helpindex)

SQLpro — Tue, 17 Jan 2017 15:51:08 +0000

La procédure stockée master.sys.sp_helpindex, décrivant les index d’une table, fournit par Microsoft, est aujourd’hui fortement obsolète et Microsoft n’a pas souhaité donné suite aux demandes de modification (1). Voici une procédure inspirée de cette dernière bien plus complète et prenant en compte tous les types d’index (spatiaux, XML, columstore, fulltext).

(1) Dans l’outil CONNECT consacré aux amélioration de SQL Server, il est dit par Microsoft, que, malgré les multiples demandes, la procédure stockée sp_helpindex, ne sera pas améliorée…
Cependant cette procédure est bien pratique pour comparer les index d’une même table afin de savoir s’il n’existe pas déjà tel ou tel index, au moment d’en créer de nouveaux, ou encore, s’il existe des index inclus ou redondants.
Voici donc une nouvelle procédure intitulée sp__helpindex (notez le double blanc souligné afin de ne pas écraser l’ancienne) qui permet de pallier à la déficience de l’ancienne et qui rajoute :

d’un point de vu « horizontal » : nom de table, colonnes incluses, filtre et l’essentiel de la clause WITH
d’un point de vue vertical : les index columnstore, xml, spatiaux et fulltext

Voici le code de cette procédure :

CREATE PROCEDURE dbo.sp__HELPINDEX @OBJ NVARCHAR(133)
AS
/******************************************************************************
* METADONNÉES DES INDEX *
* Procédure listant sous forme de tables les métadonnées logique des index *
*******************************************************************************
* Frédéric Brouard - SQLpro@SQLspot.com - Sté SQL SPOT http://www.sqlspot.com *
* Plus d'info. sur http://sqlpro.developpez.com - 2017-01-17 - 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) et renvoie un *
* jeu de données contenant le descriptif logique de constitution d'un index *
* ou de tous les index de la base *
* NOTA substitut à la procédure stockée système sp_helpindex *
*******************************************************************************
* ATTENTION : procédure système ! Exécutable depuis n'importe quelle base *
* *
* Paramètre en entrée : *
* @OBJ type NVARCHAR(133) : nom de table dont on veut connaître les index *
* si vide, la procédure renvoie la liste de tous les index *
* *
* COLONNE de la table en sortie : *
* TABLE_NAME : nom de la table en deux parties (schéma SQL + nom) *
* INDEX_NAME : nom de l'index (1) *
* INDEX TYPE : type d'index *
* INDEX_STORAGE : type et nom de l'espace de stockage *
* INDEX_KEY : liste des colonnes composant la clef d'index (2) *
* INDEX_INCLUDE : liste des colonnes incluses (3) *
* INDEX_FILTER : filtre d'index s'il y a lieu *
* INDEX_WITH : principaux paramètres de la clause WITH *
* *
* NOTA : *
* (1) certains index n'ont pas de nom. C'est le cas des index "fulltext" *
* (2) certains index n'ont pas de clef. C'est le cas des index *
* "columnstore" et "fulltext". Dans ce cas les colonnes indexées *
* figurent dans la clause INDEX_INCLUDE *
* (3) pour les index CLUSTERED de type BTree, toutes les colonnes autre *
* que celles de la clef étant présente, la valeur présentée est : *
* * - (INDEX_KEY) *
* pour les index CLUSTERED COLUMNSTORE toutes les colonnes de la table *
* étant présente, la valeur présentée est : * *
* *
* EXEMPLE : *
* EXEC dbo.sp__HELPINDEX NULL *
* ... donne la liste de tous les index de la base ... *
* EXEC dbo.sp__HELPINDEX '[client]' *
* ... donne la liste des index de la table client ... *
* EXEC dbo.sp__HELPINDEX 'ventes.client' *
* ... donne la liste des index de la table client du schéma SQL vente... *
* *
******************************************************************************/

SET NOCOUNT ON;
WITH
T0 AS
(
SELECT i."type", s.name + '.' + o.name AS TABLE_NAME,
i.name AS INDEX_NAME,
CASE WHEN i.is_unique = 1 THEN 'UNIQUE ' ELSE '' END +
CASE WHEN xi.xml_index_type = 0 THEN 'PRIMARY ' ELSE '' END +
i.type_desc + CASE WHEN xi.xml_index_type > 0
THEN ' FOR ' + xi.secondary_type_desc ELSE ''
END AS INDEX_TYPE,
COALESCE('FILEGROUP: ' + fg.name,
'PARTITION: ' + ps.name COLLATE database_default +'('
+ STUFF((SELECT N', ' + cp.name
FROM sys.index_columns AS icp
LEFT OUTER JOIN sys.COLUMNS AS cp
ON icp.object_id = cp.object_id
AND icp.column_id = cp.column_id
WHERE icp.object_id = i.object_id
AND icp.index_id = i.index_id
AND icp.partition_ordinal >= 1
ORDER BY icp.partition_ordinal
FOR XML PATH(N'')), 1, 1,'') +')' )
AS INDEX_STORAGE,
LTRIM(STUFF((SELECT N', ' + CONCAT(c.name, ' '
+ CASE
WHEN i.type_desc
IN ('XML',
'SPATIAL',
'COLUMNSTORE')
THEN ''
WHEN is_descending_key = 1
THEN 'DESC'
WHEN is_descending_key = 0
THEN 'ASC'
ELSE ''
END)
FROM sys.index_columns AS ic
JOIN sys.COLUMNS AS c
ON ic.object_id = c.object_id
AND ic.column_id = c.column_id
WHERE ic.object_id = i.object_id
AND ic.index_id = i.index_id
AND is_included_column = 0
ORDER BY key_ordinal
FOR XML PATH(N'')), 1, 1,'')) AS INDEX_KEY,
LTRIM(STUFF((SELECT N', ' + c.name
FROM sys.index_columns AS ic
JOIN sys.COLUMNS AS c
ON ic.object_id = c.object_id
AND ic.column_id = c.column_id
WHERE ic.object_id = i.object_id
AND ic.index_id = i.index_id
AND is_included_column = 1
ORDER BY c.name
FOR XML PATH(N'')), 1, 1,'')) AS INDEX_INCLUDE,
i.filter_definition AS INDEX_FILTER,
'FILL_FACTOR = ' + CAST(i.fill_factor AS VARCHAR(32)) +
', PAD_INDEX = ' + CAST(i.is_padded AS CHAR(1)) +
', ALLOW_ROWLOCK = ' + CAST(i.allow_row_locks AS CHAR(1)) +
', ALLOW_PAGELOCK = ' + CAST(i.allow_page_locks AS CHAR(1))
AS INDEX_WITH
FROM sys.indexes AS i
JOIN sys.objects AS o
ON i.object_id = o.object_id
JOIN sys.schemas AS s
ON o.schema_id = s.schema_id
JOIN sys.data_spaces AS ds
ON i.data_space_id = ds.data_space_id
LEFT OUTER JOIN sys.filegroups AS fg
ON ds.data_space_id = fg.data_space_id AND ds."type" = 'FG'
LEFT OUTER JOIN sys.partition_schemes AS ps
ON ds.data_space_id = ps.data_space_id AND ds."type" = 'PS'
LEFT OUTER JOIN sys.partition_functions AS pf
ON ps.function_id = pf.function_id
LEFT OUTER JOIN sys.xml_indexes AS xi
ON i.object_id = xi.object_id
AND i.index_id = xi.index_id
WHERE o.object_id = COALESCE(NULLIF(OBJECT_ID(@OBJ), 0), o.object_id)
AND i.index_id > 0
AND o.is_ms_shipped = 0
)
SELECT TABLE_NAME, INDEX_NAME, INDEX_TYPE, INDEX_STORAGE, INDEX_KEY,
CASE "type" WHEN 1 THEN '* - (INDEX_KEY)'
WHEN 5 THEN '*' END AS INDEX_INCLUDE,
INDEX_FILTER, INDEX_WITH
FROM T0
UNION ALL
SELECT s.name + '.' + o.name AS TABLE_NAME,
NULL AS INDEX_NAME, 'FULL TEXT' AS INDEX_TYPE,
'FULLTEXT CATALOG: ' + ftc.name AS INDEX_STORAGE,
NULL AS INDEX_KEY,
LTRIM(STUFF((SELECT N', ' + c.name
FROM sys.fulltext_index_columns AS ftic
JOIN sys.COLUMNS AS c
ON c.object_id = ftic.object_id
AND c.column_id = ftic.column_id
WHERE ftic.object_id = fti.object_id
FOR XML PATH(N'')), 1, 1,'')) AS INDEX_INCLUDE,
NULL AS INDEX_FILTER,
'CHANGE_TRACKING = ' + change_tracking_state_desc +
', STOPLIST = ' + CASE
WHEN fti.stoplist_id = 0 THEN 'SYSTEM'
WHEN fti.stoplist_id IS NULL THEN 'OFF'
ELSE (SELECT name
FROM sys.fulltext_stoplists AS ftsl
WHERE fti.stoplist_id = ftsl.stoplist_id)
END +
COALESCE(', SEARCH PROPERTY LIST = ' +
(SELECT name
FROM sys.registered_search_property_lists AS ftpl
WHERE fti.property_list_id = ftpl.property_list_id)
COLLATE French_BIN, '') AS INDEX_WITH
FROM sys.fulltext_indexes AS fti
JOIN sys.objects AS o
ON fti.object_id = o.object_id
JOIN sys.schemas AS s
ON o.schema_id = s.schema_id
JOIN sys.fulltext_catalogs AS ftc
ON fti.fulltext_catalog_id = ftc.fulltext_catalog_id
WHERE o.object_id = COALESCE(NULLIF(OBJECT_ID(@OBJ), 0), o.object_id)
ORDER BY TABLE_NAME, INDEX_KEY, INDEX_INCLUDE;
GO

Il convient de la créer dans la base master et de la rendre procédure système, à l’aide de la commande :

EXEC sp_MS_marksystemobject 'sp__HELPINDEX';

Les colonnes du jeu de données en sortie de procédure sont :

TABLE_NAME : nom de la table en deux parties (schéma SQL + nom)
INDEX_NAME : nom de l’index. Certains index n’ont pas de nom. C’est en particulier le cas des index « fulltext »
INDEX TYPE : type d’index
INDEX_STORAGE : type et nom de l’espace de stockage
INDEX_KEY : liste des colonnes composant la clef d’index. Certains index n’ont pas de clef. C’est le cas des index « columnstore » et « fulltext ». Dans ce cas les colonnes indexées figurent dans la clause INDEX_INCLUDE
INDEX_INCLUDE : liste des colonnes incluses. Pour les index CLUSTERED de type BTree, toutes les colonnes autre que celles de la clef étant présente, la valeur qui y figure est : * – (INDEX_KEY). Pour les index CLUSTERED COLUMNSTORE toutes les colonnes de la table étant présente dans l’index, la valeur qui y figure est : *
INDEX_FILTER : filtre d’index s’il y a lieu
INDEX_WITH : principaux paramètres de la clause WITH

Si vous l’exécutez sans spécifier le nom d’une table (le paramètre sera donc NULL) alors la procédure sort la liste des tous les index de toutes les tables, vues indexées comprises.

Vous pouvez transformer aisément cette procédure en une fonction table en ligne avantageuse.

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

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

SQL Server 2014 – les ressources du livre

SQLpro — Wed, 04 May 2016 12:44:42 +0000

Notre livre publié aux éditions Eyrolles en 2014 possède plusieurs ajouts dont les ressources peuvent être téléchargées…

Pour la partie 5 du livre, vous la trouverez à l’URL :
http://www.st1.eyrolles.com/9782212135923/Annexes_Brouard_FILIGRANE.pdf

Pour les exemples, vous trouverez un fichier ZIP à l’URL :
http://www.eyrolles.com/download/9782212135923/Scripts_SQL_2014.zip

La table des matières est disponible ici :
Table des matières SQL Server 2014

L’index est disponible ici :
Index SQL Server 2014

Le glossaire est disponible ici :
Glossaire SQL Server 2014

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

***

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

Détecter les index obèses

SQLpro — Wed, 09 Dec 2015 09:59:02 +0000

Voici en complément des 20 requêtes pour auditer la qualité de votre modèle de données (voir 20 requêtes pour auditer la qualité de votre modèle de données) une requête destinée à déceler les index obèses (c’est à dire, ceux ayant trop de colonnes dans leur définition.

Voici la requête :

WITH
T0 AS
(
SELECT o.object_id, i.index_id,
s.name AS TABLE_SCHEMA,
o.name AS TABLE_NAME,
i.name AS INDEX_NAME,
is_included_column,
COUNT(*) AS NOMBRE
FROM sys.objects AS o
JOIN sys.schemas AS s
ON o.schema_id = s.schema_id
JOIN sys.indexes AS i
ON o.object_id = i.object_id
JOIN sys.index_columns AS ic
ON i.object_id = ic.object_id
AND i.index_id = ic.index_id
WHERE i.index_id > 0
AND is_ms_shipped = 0
GROUP BY o.object_id, i.index_id, s.name, o.name, i.name, is_included_column
)
SELECT T1.TABLE_SCHEMA,
T1.TABLE_NAME,
T1.INDEX_NAME,
T1.NOMBRE + T0.NOMBRE AS NOMBRE_COLONNES,
T0.NOMBRE AS NOMBRE_COLONNES_CLEFS,
T1.NOMBRE AS NOMBRE_COLONNES_INCLUSES
FROM T0
JOIN T0 AS T1
ON T0.object_id = T1.object_id
AND T0.index_id = T1.index_id
WHERE T0.is_included_column = 1
AND T1.is_included_column = 0
AND T1.NOMBRE + T0.NOMBRE > 10 --> seuil limite du nombre de colonnes dans l'index à ne pas dépasser

Le seuil étant fixé à 10 colonnes, vous pouvez être plus sévère encore ou plus laxiste à votre choix !!!

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

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

Point d’entrée du stockage physique des objets dans SQL Server

SQLpro — Mon, 12 Aug 2013 10:27:40 +0000

La requête suivante permet de connaître le point d’entrée de tout objets stockant des données dans MS SQL Server.

Cette requête utilise une vue interne de nom sys.system_internals_allocation_units.
Le résultat de cette vue propose pour chaque objet (table/index/partition) la première page stockant des données de cet objet, la page racine de l’index (pour une table en HEAP, ces deux pages sont identiques) et la première page IAM (Index Allocation Map) indiquant les extensions utilisés par cet objet dans les 64 000 premières extensions du fichier (soit 4 Go).

SELECT s.name AS TABLE_SCHEMA, o.name AS TABLE_NAME,
i.name AS INDEX_NAME,
o.object_id, i.index_id,
p.partition_number,
iau.allocation_unit_id,
i.type_desc AS TYPE_INDEX,
iau.type_desc AS TYPE_ALLOCATION,
CAST(CAST(SUBSTRING (iau.first_page, 6, 1) +
SUBSTRING (iau.first_page, 5, 1) AS INT)
AS VARCHAR(6)) + ':' +
CAST(CAST(SUBSTRING (iau.first_page, 4, 1) +
SUBSTRING (iau.first_page, 3, 1) +
SUBSTRING (iau.first_page, 2, 1) +
SUBSTRING (iau.first_page, 1, 1) AS INT)
AS VARCHAR (20)) AS PAGE_1,
CAST(CAST(SUBSTRING (iau.root_page, 6, 1) +
SUBSTRING (iau.root_page, 5, 1) AS INT)
AS VARCHAR(6)) + ':' +
CAST(CAST(SUBSTRING (iau.root_page, 4, 1) +
SUBSTRING (iau.root_page, 3, 1) +
SUBSTRING (iau.root_page, 2, 1) +
SUBSTRING (iau.root_page, 1, 1) AS INT)
AS VARCHAR (20)) AS PAGE_RACINE,
CAST(CAST(SUBSTRING (iau.first_iam_page, 6, 1) +
SUBSTRING (iau.first_iam_page, 5, 1) AS INT)
AS VARCHAR(6)) + ':' +
CAST(CAST(SUBSTRING (iau.first_iam_page, 4, 1) +
SUBSTRING (iau.first_iam_page, 3, 1) +
SUBSTRING (iau.first_iam_page, 2, 1) +
SUBSTRING (iau.first_iam_page, 1, 1) AS INT)
AS VARCHAR (20)) AS PAGE_IAM_1
FROM sys.objects AS o
INNER JOIN sys.schemas AS s
ON o.schema_id = s.schema_id
INNER JOIN sys.indexes AS i
ON o.object_id = i.object_id
INNER JOIN sys.partitions AS p
ON i.object_id = p.object_id
AND i.index_id = p.index_id
INNER JOIN sys.system_internals_allocation_units AS iau
ON p.partition_id = iau.container_id;

Résultat :

Résultat présentant les pages racine, d’entrée et IAM (Index Allocation Map) des tables et index de SQL Server

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