Compilation native des tables et des procédures stockées

In-Memory OLTP introduit le concept de compilation native. SQL Server peut compiler en mode natif des procédures stockées qui accèdent aux tables optimisées en mémoire. SQL Server est également en mesure de compiler en mode natif des tables optimisées en mémoire. La compilation native permet un accès aux données plus rapide et une exécution de requête plus efficace que Transact-SQL interprétée (traditionnelle). La compilation native des tables et des procédures stockées produit des DLL.

La compilation native des types de tables mémoire optimisées est également prise en charge. Pour plus d’informations, consultez Memory-Optimized Variables de table.

La compilation native fait référence au processus de conversion de constructions de programmation en code natif, composée d’instructions de processeur sans avoir besoin d’une compilation ou d’une interprétation ultérieures.

In-Memory OLTP compile des tables mémoire optimisées lors de leur création et des procédures stockées compilées en mode natif lorsqu’elles sont chargées dans des DLL natives. En outre, les DLL sont recompilées après un redémarrage d’une base de données ou d’un serveur. Les informations nécessaires pour recréer les DLL sont stockées dans les métadonnées de la base de données. Les DLL ne font pas partie de la base de données, bien qu’elles soient associées à la base de données. Par exemple, les DLL ne sont pas incluses dans les sauvegardes de base de données.

Maintenance des DLL OLTP In-Memory

La requête suivante montre toutes les DLL de table et de procédure stockée actuellement chargées en mémoire sur le serveur :

SELECT name, description FROM sys.dm_os_loaded_modules  
where description = 'XTP Native DLL'  

Les administrateurs de base de données n’ont pas besoin de gérer les fichiers générés par une compilation native. SQL Server supprime automatiquement les fichiers générés qui ne sont plus nécessaires. Par exemple, les fichiers générés sont supprimés lorsqu’une table et une procédure stockée sont supprimées, ou si une base de données est supprimée.

Compilation native des tables

La création d’une table optimisée en mémoire à l’aide de l’instruction CREATE TABLE entraîne l’écriture des informations de table dans les métadonnées de la base de données et les structures d’index et de table créées en mémoire. La table sera également compilée dans une DLL.

Considérez l’exemple de script suivant, qui crée une base de données et une table mémoire optimisée :

use master  
go  
create database db1  
go  
alter database db1 add filegroup db1_mod contains memory_optimized_data  
go  
-- adapt filename as needed  
alter database db1 add file (name='db1_mod', filename='c:\data\db1_mod') to filegroup db1_mod  
go  
use db1  
go  
create table dbo.t1  
   (c1 int not null primary key nonclustered,  
    c2 INT)  
with (memory_optimized=on)  
go  
-- retrieve the path of the DLL for table t1  
select name, description FROM sys.dm_os_loaded_modules  
where name like '%xtp_t_' + cast(db_id() as varchar(10)) + '_' + cast(object_id('dbo.t1') as varchar(10)) + '.dll'  
go  

Créer la table entraîne également la création de la DLL de table et son chargement en mémoire. La requête DMV immédiatement après l’instruction CREATE TABLE récupère le chemin d’accès de la DLL de table.

La DLL de table comprend les structures d’index et le format de ligne du tableau. SQL Server utilise la DLL pour parcourir les index, récupérer des lignes, ainsi que stocker le contenu des lignes.

Compilation native des procédures stockées

Les procédures stockées qui sont identifiées par NATIVE_COMPILATION sont compilées en mode natif. Cela signifie que les instructions Transact-SQL de la procédure sont toutes compilées en code natif pour une exécution efficace de la logique métier critique pour les performances.

Pour plus d’informations sur les procédures stockées compilées en mode natif, consultez Procédures stockées compilées en mode natif.

Considérez l’exemple de procédure stockée suivant, qui insère des lignes dans la table t1 de l’exemple précédent :

create procedure dbo.native_sp  
with native_compilation, schemabinding, execute as owner  
as  
begin atomic  
with (transaction isolation level=snapshot, language=N'us_english')  
  
  declare @i int = 1000000  
  while @i > 0  
  begin  
    insert dbo.t1 values (@i, @i+1)  
    set @i -= 1  
  end  
  
end  
go  
exec dbo.native_sp  
go  
-- reset  
delete from dbo.t1  
go  

La DLL pour native_sp peut interagir directement avec la DLL pour t1, ainsi que le moteur de stockage OLTP In-Memory, pour insérer les lignes aussi rapidement que possible.

Le compilateur OLTP In-Memory tire parti de l’optimiseur de requête pour créer un plan d’exécution efficace pour chacune des requêtes de la procédure stockée. Notez que les procédures stockées compilées en mode natif ne sont pas automatiquement recompilées si les données de la table changent. Pour plus d’informations sur la maintenance des statistiques et des procédures stockées avec In-Memory OLTP, consultez Statistiques pour Memory-Optimized Tables.

Considérations relatives à la sécurité pour la compilation native

La compilation native des tables et des procédures stockées utilise le compilateur OLTP In-Memory. Ce compilateur produit des fichiers écrits sur le disque et chargés en mémoire. SQL Server utilise les mécanismes suivants pour limiter l’accès à ces fichiers.

Compilateur natif

L’exécutable du compilateur, ainsi que les fichiers binaires et les fichiers d’en-tête requis pour la compilation native, sont installés dans le cadre de l’instance SQL Server sous le dossier MSSQL\Binn\Xtp. Par conséquent, si l’instance par défaut est installée sous C :\Program Files, les fichiers du compilateur sont installés dans C :\Program Files\MicrosoftSQL Server\MSSQL12. MSSQLSERVER\MSSQL\Binn\Xtp.

Pour limiter l’accès au compilateur, SQL Server utilise des listes de contrôle d’accès (ACL) pour restreindre l’accès aux fichiers binaires. Tous les fichiers binaires SQL Server sont protégés contre la modification ou la falsification par le biais d’ACL. Les listes de contrôle d’accès du compilateur natif limitent également l’utilisation du compilateur ; Seuls les comptes de service SQL Server et les administrateurs système disposent d’autorisations de lecture et d’exécution pour les fichiers compilateur natifs.

Fichiers générés par une compilation native

Les fichiers produits lorsqu’une table ou une procédure stockée sont compilés incluent les fichiers DLL et intermédiaires, y compris les fichiers avec les extensions suivantes : .c, .obj, .xmlet .pdb. Les fichiers générés sont enregistrés dans un sous-dossier du dossier de données par défaut. Le sous-dossier est appelé Xtp. Lors de l’installation de l’instance par défaut avec le dossier de données par défaut, les fichiers générés sont placés dans C :\Program Files\MicrosoftSQL Server\MSSQL12. MSSQLSERVER\MSSQL\DATA\Xtp.

SQL Server empêche la falsification des DLL générées de trois façons :

• Lorsqu’une table ou une procédure stockée est compilée dans une DLL, cette DLL est immédiatement chargée en mémoire et liée au processus de sqlserver.exe. Une DLL ne peut pas être modifiée pendant qu’elle est liée à un processus.

• Lorsqu’une base de données est redémarrée, toutes les tables et procédures stockées sont recompilées (supprimées et recréées) en fonction des métadonnées de la base de données. Cela supprime toutes les modifications apportées à un fichier généré par un agent malveillant.

• Les fichiers générés sont considérés comme faisant partie des données utilisateur et ont les mêmes restrictions de sécurité, via les listes de contrôle d’accès, que les fichiers de base de données : seul le compte de service SQL Server et les administrateurs système peuvent accéder à ces fichiers.

Aucune interaction utilisateur n’est nécessaire pour gérer ces fichiers. SQL Server crée et supprime les fichiers si nécessaire.

Voir aussi

Memory-Optimized tables
Procédures stockées compilées en mode natif