Compilazione nativa di tabelle e stored procedureNative Compilation of Tables and Stored Procedures

Con OLTP in memoria viene introdotto il concetto di compilazione nativa.In-Memory OLTP introduces the concept of native compilation. SQL ServerSQL Server può compilare in modo nativo stored procedure che accedono alle tabelle con ottimizzazione per la memoria. can natively compile stored procedures that access memory-optimized tables. SQL ServerSQL Server è anche in grado di compilare in modo nativo tabelle con ottimizzazione per la memoria. is also able to natively compile memory-optimized tables. Con la compilazione nativa si accede ai dati più velocemente e si eseguono le query in modo più efficiente rispetto al tradizionale Transact-SQLTransact-SQLinterpretato.Native compilation allows faster data access and more efficient query execution than interpreted (traditional) Transact-SQLTransact-SQL. La compilazione nativa di tabelle e stored procedure produce DLL.Native compilation of tables and stored procedures produce DLLs.

È anche supportata la compilazione nativa dei tipi di tabella con ottimizzazione per la memoria.Native compilation of memory optimized table types is also supported. Per altre informazioni, vedere Tabella temporanea più rapida e variabile di tabella tramite l'ottimizzazione per la memoria.For more information, see Faster temp table and table variable by using memory optimization.

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.Native compilation refers to the process of converting programming constructs to native code, consisting of processor instructions without the need for further compilation or interpretation.

OLTP in memoria compila le tabelle con ottimizzazione per la memoria quando vengono create e le stored procedure compilate in modo nativo quando vengono caricate nelle DLL native.In-Memory OLTP compiles memory-optimized tables when they are created, and natively compiled stored procedures when they are loaded to native DLLs. Inoltre, le DLL vengono ricompilate dopo il riavvio di un database o di un server.In addition, the DLLs are recompiled after a database or server restart. Le informazioni necessarie per ricreare le DLL vengono archiviate nei metadati del database.The information necessary to recreate the DLLs is stored in the database metadata. Le DLL non fanno parte del database, sebbene siano associate al database.The DLLs are not part of the database, though they are associated with the database. Ad esempio, le DLL non sono incluse nei backup del database.For example, the DLLs are not included in database backups.

Nota

Le tabelle con ottimizzazione per la memoria vengono ricompilate durante un riavvio del server.Memory-optimized tables are recompiled during a server restart. Per velocizzare il recupero del database, le stored procedure compilate in modo nativo non vengono ricompilate durante un riavvio del server, ma vengono compilate al momento della prima esecuzione.To speed up database recovery, natively compiled stored procedures are not recompiled during a server restart, they are compiled at the time of first execution. A causa di questa compilazione posticipata, le stored procedure compilate in modo nativo vengono visualizzate solo quando si chiama sys.dm_os_loaded_modules (Transact-SQL) dopo la prima esecuzione.As a result of this deferred compilation, natively compiled stored procedures only appear when calling sys.dm_os_loaded_modules (Transact-SQL) after first execution.

Manutenzione delle DLL di OLTP in memoriaMaintenance of In-Memory OLTP DLLs

La query seguente indica che tutte le DLL di tabelle e stored procedure vengono attualmente caricate in memoria nel server:The following query shows all table and stored procedure DLLs currently loaded in memory on the 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.Database administrators do not need to maintain files that are generated by a native compilation. SQL ServerSQL Server rimuove automaticamente i file generati non più necessari. automatically removes generated files that are no longer needed. 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.For example, generated files will be deleted when a table and stored procedure is deleted, or if a database is dropped.

Nota

Se la compilazione ha esito negativo o viene interrotta, alcuni file generati non vengono rimossi.If compilation fails or is interrupted, some generated files are not removed. Questi file vengono lasciati intenzionalmente per motivi di supporto e vengono rimossi quando il database viene eliminato.These files are intentionally left behind for supportability and are removed when the database is dropped.

Nota

SQL Server compila file DLL per tutte le tabelle necessarie per il ripristino del database.SQL Server compiles DLLs for all tables needed for database recovery. Se una tabella è stata eliminata immediatamente prima di un riavvio del database, è possibile che i file checkpoint o i log delle transazioni includano ancora residui della tabella. È quindi possibile ricompilare il file DLL della tabella durante l'avvio del database.If a table was dropped just prior to a database restart there can still be remnants of the table in the checkpoint files or the transaction log so the DLL for the table might be recompiled during database startup. Dopo il riavvio, il file DLL verrà scaricato e i file verranno rimossi durante il normale processo di pulitura.After restart the DLL will be unloaded and the files will be removed by the normal cleanup process.

Compilazione nativa di tabelleNative Compilation of Tables

La creazione di una tabella con ottimizzazione 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.Creating a memory-optimized table using the CREATE TABLE statement results in the table information being written to the database metadata and the table and index structures created in memory. La tabella verrà compilata in una DLL.The table will also be compiled to a DLL.

Considerare il seguente script di esempio che crea un database e una tabella con ottimizzazione per la memoria:Consider the following sample script, which creates a database and a memory-optimized table:

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.Creating the table also creates the table DLL and loads the DLL in memory. La query DMV immediatamente dopo l'istruzione CREATE TABLE recupera il percorso della DLL della tabella.The DMV query immediately after the CREATE TABLE statement retrieves the path of the table DLL.

La DLL della tabella interpreta le strutture di indice e il formato di riga della tabella.The table DLL understands the index structures and row format of the table. SQL ServerSQL Server usano la DLL per attraversare indici, recuperare righe e archiviare il contenuto delle righe. uses the DLL for traversing indexes, retrieving rows, as well as storing the contents of the rows.

Compilazione nativa di stored procedureNative Compilation of Stored Procedures

Le stored procedure che sono contrassegnate con NATIVE_COMPILATION vengono compilate in modo nativo.Stored procedures that are marked with NATIVE_COMPILATION are natively compiled. Pertanto, le istruzioni Transact-SQLTransact-SQL nella procedura vengono tutte compilate nel codice nativo per l'esecuzione efficiente della logica di business critica per le prestazioni.This means the Transact-SQLTransact-SQL statements in the procedure are all compiled to native code for efficient execution of performance-critical business logic.

Per altre informazioni sulle stored procedure compilate in modo nativo, vedere Natively Compiled Stored Procedures.For more information about natively compiled stored procedures, see Natively Compiled Stored Procedures.

Considerare la seguente stored procedure di esempio che inserisce righe nella tabella t1 dell'esempio precedente:Consider the following sample stored procedure, which inserts rows in the table t1 from the previous example:

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.The DLL for native_sp can interact directly with the DLL for t1, as well as the In-Memory OLTP storage engine, to insert the rows as fast as possible.

Il compilatore di OLTP in memoria usano Query Optimizer per creare un piano di esecuzione efficiente per ogni query della stored procedure.The In-Memory OLTP compiler leverages the query optimizer to create an efficient execution plan for each of the queries in the stored procedure. Si noti che le stored procedure compilate in modo nativo non vengono automaticamente ricompilate se i dati della tabella cambiano.Note that natively compiled stored procedures are not automatically recompiled if the data in the table changes. Per altre informazioni sulla gestione delle statistiche e delle stored procedure con OLTP in memoria, vedere Statistiche per tabelle con ottimizzazione per la memoria.For more information on maintaining statistics and stored procedures with In-Memory OLTP see Statistics for Memory-Optimized Tables.

Considerazioni sulla sicurezza della compilazione nativaSecurity Considerations for Native Compilation

Per la compilazione nativa di tabelle e stored procedure viene usato il compilatore di OLTP in memoria.Native compilation of tables and stored procedures uses the In-Memory OLTP compiler. Il compilatore genera file che vengono scritti su disco e caricati in memoria.This compiler produces files that are written to disk and loaded into memory. SQL ServerSQL Server vengono usati i seguenti meccanismi per limitare l'accesso a tali file. uses the following mechanisms to limit access to these files.

Compilatore nativoNative Compiler

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 ServerSQL Server nella cartella MSSQL\Binn\Xtp.The compiler executable, as well as binaries and header files required for native compilation are installed as part of the SQL ServerSQL Server instance under the folder MSSQL\Binn\Xtp. Se l'istanza predefinita viene installata in C:\Programmi, i file del compilatore vengono quindi installati in C:\Programmi\ MicrosoftMicrosoft SQL ServerSQL Server\MSSQL13.MSSQLSERVER\MSSQL\Binn\Xtp.So, if the default instance is installed under C:\Program Files, the compiler files are installed in C:\Program Files\ MicrosoftMicrosoft SQL ServerSQL Server\MSSQL13.MSSQLSERVER\MSSQL\Binn\Xtp.

Per limitare l'accesso al compilatore, in SQL ServerSQL Server vengono usati gli elenchi di controllo di accesso (ACL) per limitare l'accesso ai file binari.To limit access to the compiler, SQL ServerSQL Server uses access control lists (ACLs) to restrict access to binary files. Tutti i file binari di SQL ServerSQL Server vengono protetti dalla modifica o dalla manomissione tramite gli ACL.All SQL ServerSQL Server binaries are protected against modification or tampering through ACLs. Gli ACL del compilatore nativo limitano anche l'utilizzo del compilatore; solo gli amministratori di sistema e l'account del servizio di SQL ServerSQL Server dispongono delle autorizzazioni di lettura ed esecuzione per i file del compilatore nativo.The native compiler's ACLs also limit use of the compiler; only the SQL ServerSQL Server service account and system administrators have read and execute permissions for native compiler files.

File generati da una compilazione nativaFiles Generated by a Native Compilation

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.The files produced when a table or stored procedure is compiled include the DLL and intermediate files including files with the following extensions: .c, .obj, .xml, and .pdb. I file generati vengono salvati in una sottocartella della cartella dati predefinita.The generated files are saved in a subfolder of the default data folder. La sottocartella viene denominata Xtp.The subfolder is called Xtp. Quando si installa l'istanza predefinita con la cartella dati predefinita, i file generati vengono installati in C:\Programmi\ MicrosoftMicrosoft SQL ServerSQL Server\MSSQL13.MSSQLSERVER\MSSQL\DATA\Xtp.When installing the default instance with the default data folder, the generated files are placed in C:\Program Files\ MicrosoftMicrosoft SQL ServerSQL Server\MSSQL13.MSSQLSERVER\MSSQL\DATA\Xtp.

SQL ServerSQL Server la manomissione dei file DLL generati viene impedita in tre modi: prevents tampering with the generated DLLs in three ways:

  • 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.When a table or stored procedure is compiled to a DLL, this DLL is immediately loaded into memory and linked to the sqlserver.exe process. Non è possibile modificare una DLL mentre è collegata a un processo.A DLL cannot be modified while it is linked to a process.

  • Quando un database viene riavviato, tutte le tabelle e le stored procedure vengono ricompilate (rimosse e ricreate) in base ai metadati del database.When a database is restarted, all tables and stored procedures are recompiled (removed and recreated) based on the database metadata. In questo modo verranno rimosse tutte le modifiche apportate a un file generato da un agente dannoso.This will remove any changes made to a generated file by a malicious agent.

  • 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 ServerSQL Server possono accedere a tali file.The generated files are considered part of user data, and have the same security restrictions, via ACLs, as database files: only the SQL ServerSQL Server service account and system administrators can access these files.

Per gestire tali file, non sono necessarie interazioni dell'utente.No user interaction is needed to manage these files. SQL ServerSQL Server verranno creati e rimossi automaticamente in base alle necessità. will create and remove the files as necessary.

Vedere ancheSee Also

Tabelle con ottimizzazione per la memoriaMemory-Optimized Tables

Natively Compiled Stored ProceduresNatively Compiled Stored Procedures