Compilazione nativa di tabelle e stored procedure

Si applica a: SQL Server database SQL di Azure Istanza gestita di SQL di Azure

Con OLTP in memoria viene introdotto il concetto di compilazione nativa. SQL Server può compilare in modo nativo stored procedure che accedono alle tabelle ottimizzate per la memoria. SQL Server è anche in grado di compilare in modo nativo tabelle ottimizzate per la memoria. Con la compilazione nativa si accede ai dati più velocemente e si eseguono le query in modo più efficiente rispetto al Transact-SQL tradizionale interpretato. La compilazione nativa di tabelle e stored procedure produce DLL.

È anche supportata la compilazione nativa dei tipi di tabella con ottimizzazione per la memoria. Per altre informazioni, vedere Tabella temporanea più rapida e variabile di tabella tramite l'ottimizzazione per la memoria.

La compilazione nativa si riferisce al processo di conversione dei costrutti di programmazione in codice nativo, costituito da istruzioni del processore senza la necessità di ulteriore compilazione o interpretazione.

OLTP in memoria compila le tabelle ottimizzate per la memoria quando vengono create e le stored procedure compilate in modo nativo quando vengono caricate nelle DLL native. Inoltre, le DLL vengono ricompilate dopo il riavvio di un database o di un server. Le informazioni necessarie per ricreare le DLL vengono archiviate nei metadati del database. Le DLL non fanno parte del database, sebbene siano associate al database. Ad esempio, le DLL non sono incluse nei backup del database.

Manutenzione delle DLL di OLTP in memoria

La query seguente indica che tutte le DLL di tabelle e stored procedure vengono attualmente caricate in memoria nel server:

SELECT
		mod1.name,
		mod1.description
	from
		sys.dm_os_loaded_modules  as mod1
	where
		mod1.description = 'XTP Native DLL';

Gli amministratori di database non devono gestire i file generati da una compilazione nativa. SQL Server rimuove automaticamente i file generati non più necessari. Ad esempio, i file generati verranno eliminati quando una tabella e una stored procedure vengono eliminate o nel caso in cui un database venga eliminato.

Compilazione nativa di tabelle

La creazione di una tabella ottimizzata per la memoria tramite un'istruzione CREATE TABLE restituisce le informazioni della tabella scritte nei metadati del database e le strutture di indice e di tabella create in memoria. La tabella verrà compilata in una DLL.

Considerare il seguente script di esempio che crea un database e una tabella ottimizzata per la memoria:

USE master;
GO

CREATE DATABASE DbMemopt3;
GO

ALTER DATABASE DbMemopt3
	add filegroup DbMemopt3_mod_memopt_1_fg
		contains memory_optimized_data
;
GO

-- You must edit the front portion of filename= path, to where your DATA\ subdirectory is,
-- keeping only the trailing portion '\DATA\DbMemopt3_mod_memopt_1_fn'!

ALTER DATABASE DbMemopt3
	add file
	(
		name     = 'DbMemopt3_mod_memopt_1_name',
		filename = 'C:\DATA\DbMemopt3_mod_memopt_1_fn'

		--filename = 'C:\Program Files\Microsoft SQL Server\MSSQL13.SQLSVR2016ID\MSSQL\DATA\DbMemopt3_mod_memopt_1_fn'
	)
		to filegroup DbMemopt3_mod_memopt_1_fg
;
GO

USE DbMemopt3;
GO

CREATE TABLE dbo.t1
(
	c1 int not null primary key nonclustered,
	c2 int
)
	with (memory_optimized = on)
;
GO



-- You can safely rerun from here to the end.

-- Retrieve the path of the DLL for table t1.


DECLARE @moduleName  nvarchar(256);

SET @moduleName =
	(
		'%xtp_t_' +
		cast(db_id() as nvarchar(16)) +
		'_' +
		cast(object_id('dbo.t1') as nvarchar(16)) +
		'%.dll'
	)
;


-- SEARCHED FOR NAME EXAMPLE:  mod1.name LIKE '%xtp_t_8_565577053%.dll'
PRINT @moduleName;


SELECT
		mod1.name,
		mod1.description
	from
		sys.dm_os_loaded_modules  as mod1
	where
		mod1.name LIKE @moduleName
	order by
		mod1.name
;
-- ACTUAL NAME EXAMPLE:  mod1.name = 'C:\Program Files\Microsoft SQL Server\MSSQL13.SQLSVR2016ID\MSSQL\DATA\xtp\8\xtp_t_8_565577053_184009305855461.dll'
GO

--   DROP DATABASE DbMemopt3;  -- Clean up.
GO

La creazione della tabella comporta anche la creazione della corrispondente DLL e il caricamento della DLL in memoria. La query DMV immediatamente dopo l'istruzione CREATE TABLE recupera il percorso della DLL della tabella.

La DLL della tabella interpreta le strutture di indice e il formato di riga della tabella. SQL Server usa la DLL per attraversare indici, recuperare righe e archiviare il contenuto delle righe.

Compilazione nativa di stored procedure

Le stored procedure che sono contrassegnate con NATIVE_COMPILATION vengono compilate in modo nativo. Pertanto, le istruzioni Transact-SQL nella procedura vengono tutte compilate nel codice nativo per l'esecuzione efficiente della logica di business critica per le prestazioni.

Per altre informazioni sulle stored procedure compilate in modo nativo, vedere Natively Compiled Stored Procedures.

Considerare la seguente stored procedure di esempio che inserisce righe nella tabella t1 dell'esempio precedente:

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

EXECUTE dbo.native_sp;
GO

-- Reset.

DELETE from dbo.t1;
GO

La DLL di native_sp può interagire direttamente con la DLL di t1 e con il motore di archiviazione di OLTP in memoria per inserire le righe il più rapidamente possibile.

Il compilatore di OLTP in memoria usano Query Optimizer per creare un piano di esecuzione efficiente per ogni query della stored procedure. Si noti che le stored procedure compilate in modo nativo non vengono automaticamente ricompilate se i dati della tabella cambiano. Per altre informazioni sulla gestione delle statistiche e delle stored procedure con OLTP in memoria, vedere Statistiche per tabelle con ottimizzazione per la memoria.

Considerazioni sulla sicurezza della compilazione nativa

Per la compilazione nativa di tabelle e stored procedure viene usato il compilatore di OLTP in memoria. Il compilatore genera file che vengono scritti su disco e caricati in memoria. SQL Server usa i seguenti meccanismi per limitare l'accesso a tali file.

Compilatore nativo

Il file eseguibile del compilatore, nonché i file binari e i file di intestazione necessari per la compilazione nativa, vengono installati come parte dell'istanza di SQL Server nella cartella MSSQL\Binn\Xtp. Se l'istanza predefinita viene installata in C:\Programmi, i file del compilatore vengono quindi installati in C:\Programmi\Microsoft SQL Server\MSSQL13.MSSQLSERVER\MSSQL\Binn\Xtp.

Per limitare l'accesso al compilatore, in SQL Server vengono usati gli elenchi di controllo di accesso (ACL) per limitare l'accesso ai file binari. Tutti i file binari di SQL Server vengono protetti dalla modifica o dalla manomissione tramite gli ACL. Gli ACL del compilatore nativo limitano anche l'utilizzo del compilatore; solo gli amministratori di sistema e l'account del servizio di SQL Server dispongono delle autorizzazioni di lettura ed esecuzione per i file del compilatore nativo.

File generati da una compilazione nativa

I file generati quando una tabella o una stored procedure viene compilata includono file DLL e file intermedi compresi i file con le estensioni seguenti: c, obj, xml e pdb. I file generati vengono salvati in una sottocartella della cartella dati predefinita. La sottocartella viene denominata Xtp. Quando si installa l'istanza predefinita con la cartella dati predefinita, i file generati vengono installati in C:\Programmi\Microsoft SQL Server\MSSQL13.MSSQLSERVER\MSSQL\DATA\Xtp.

SQL Server impedisce la manomissione dei file DLL generati in tre modi:

• Quando una tabella o una stored procedure viene compilata in una DLL, tale DLL viene immediatamente caricata in memoria e collegata al processo sqlserver.exe. Non è possibile modificare una DLL mentre è collegata a un processo.

• Quando un database viene riavviato, tutte le tabelle e le stored procedure vengono ricompilate (rimosse e ricreate) in base ai metadati del database. In questo modo verranno rimosse tutte le modifiche apportate a un file generato da un agente dannoso.

• I file generati sono considerati parte dei dati utente e dispongono delle stesse restrizioni di sicurezza, tramite ACL, dei file di database: solo gli amministratori di sistema e l'account del servizio di SQL Server possono accedere a tali file.

Per gestire tali file, non sono necessarie interazioni dell'utente. SQL Server creerà e rimuoverà i file automaticamente in base alle necessità.

Vedi anche

Tabelle ottimizzate per la memoria

Stored procedure compilate in modo nativo