Compilação Nativa de Tabelas e Procedimentos Armazenados

Aplica-se a:SQL ServerBanco de Dados SQL do AzureInstância Gerenciada SQL do Azure

In-Memory OLTP introduz o conceito de compilação nativa. O SQL Server pode compilar nativamente procedimentos armazenados que acedem a tabelas otimizadas para memória. O SQL Server também é capaz de compilar tabelas otimizadas para memória de forma nativa. A compilação nativa permite um acesso mais rápido aos dados e uma execução de consultas mais eficiente do que o Transact-SQL interpretado (tradicional). A compilação nativa de tabelas e procedimentos armazenados produz DLLs.

Também é suportada compilação nativa de tipos de tabela otimizados para memória. Para obter mais informações, consulte Tabela temporária e variável de tabela mais rápidas, utilizando a otimização de memória.

Compilação nativa refere-se ao processo de converter construtos de programação em código nativo, consistindo em instruções do processador sem necessidade de compilação ou interpretação adicional.

In-Memory OLTP compila tabelas otimizadas para memória quando são criadas e procedimentos armazenados compilados nativamente quando são carregadas para DLLs nativas. Além disso, as DLLs são recompiladas após o reinício de uma base de dados ou servidor. A informação necessária para recriar as DLLs é armazenada nos metadados da base de dados. As DLLs não fazem parte da base de dados, embora estejam associadas à base de dados. Por exemplo, as DLLs não são incluídas nas cópias de segurança da base de dados.

Manutenção de DLLs OLTP In-Memory

A consulta seguinte mostra todas as DLLs de tabelas e procedimentos armazenados atualmente carregadas na memória do servidor:

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

Os administradores de bases de dados não precisam de manter ficheiros gerados por uma compilação nativa. O SQL Server remove automaticamente ficheiros gerados que já não são necessários. Por exemplo, os ficheiros gerados serão eliminados quando uma tabela e um procedimento armazenado forem eliminados, ou se uma base de dados for eliminada.

Compilação Nativa de Tabelas

Criar uma tabela otimizada para memória usando a instrução CREATE TABLE resulta na escrita da informação da tabela nos metadados da base de dados e nas estruturas de tabela e índice criadas na memória. A tabela também será compilada numa DLL.

Considere o seguinte script de exemplo, que cria uma base de dados e uma tabela otimizada para memória:

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

Criar a tabela também cria a DLL da tabela e carrega a DLL na memória. A consulta do DMV imediatamente após a instrução CREATE TABLE recupera o caminho da DLL da tabela.

A DLL da tabela compreende as estruturas de índice e o formato de linha da tabela. O SQL Server utiliza a DLL para percorrer índices, recuperar linhas, bem como armazenar o conteúdo das linhas.

Compilação Nativa de Procedimentos Armazenados

Os procedimentos armazenados marcados com NATIVE_COMPILATION são compilados nativamente. Isto significa que as Transact-SQL instruções do procedimento são todas compiladas para código nativo para uma execução eficiente da lógica de negócio crítica ao desempenho.

Para mais informações sobre procedimentos armazenados compilados nativamente, consulte Procedimentos Armazenados Compilados Nativamente.

Considere o seguinte procedimento de exemplo armazenado, que insere linhas na tabela t1 do exemplo anterior:

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

A DLL para native_sp pode interagir diretamente com a DLL para t1, bem como com o motor de armazenamento In-Memory OLTP, para inserir as linhas tão rapidamente quanto possível.

O compilador OLTP In-Memory utiliza o otimizador de consultas para criar um plano de execução eficiente para cada uma das consultas no procedimento armazenado. Note que os procedimentos armazenados compilados nativamente não são automaticamente recompilados se os dados na tabela mudarem. Para mais informações sobre a manutenção de estatísticas e procedimentos armazenados com In-Memory OLTP, consulte Estatísticas para Tabelas Otimizadas para Memória.

Considerações de Segurança para Compilação Nativa

A compilação nativa de tabelas e procedimentos armazenados utiliza o compilador OLTP In-Memory. Este compilador produz ficheiros que são gravados em disco e carregados na memória. O SQL Server utiliza os seguintes mecanismos para limitar o acesso a estes ficheiros.

Compilador Nativo

O executável do compilador, bem como os binários e ficheiros de cabeçalho necessários para compilação nativa, são instalados como parte da instância SQL Server na pasta MSSQL\Binn\Xtp. Assim, se a instância por defeito estiver instalada em C:\Program Files, os ficheiros do compilador são instalados em C:\Program Files\Microsoft SQL Server\MSSQL13.MSSQLSERVER\MSSQL\Binn\Xtp.

Para limitar o acesso ao compilador, o SQL Server utiliza listas de controlo de acesso (ACLs) para restringir o acesso a ficheiros binários. Todos os binários do SQL Server estão protegidos contra modificações ou adulterações através de ACLs. As ACLs do compilador nativo também limitam o uso do compilador; apenas a conta de serviço SQL Server e os administradores do sistema têm permissões de leitura e execução para ficheiros nativos do compilador.

Ficheiros Gerados por uma Compilação Nativa

Os ficheiros produzidos quando uma tabela ou procedimento armazenado é compilado incluem ficheiros DLL e intermédios, incluindo ficheiros com as seguintes extensões: .c, .obj, .xmle .pdb. Os ficheiros gerados são guardados numa subpasta da pasta de dados predefinida. A subpasta chama-se Xtp. Ao instalar a instância padrão com a pasta de dados predefinida, os ficheiros gerados são colocados em C:\Program Files\Microsoft SQL Server\MSSQL13. MSSQLSERVER\MSSQL\DATA\Xtp.

O SQL Server impede a manipulação das DLLs geradas de três formas:

• Quando uma tabela ou procedimento armazenado é compilado para uma DLL, esta DLL é imediatamente carregada na memória e ligada ao processo sqlserver.exe. Uma DLL não pode ser modificada enquanto está ligada a um processo.

• Quando uma base de dados é reiniciada, todas as tabelas e procedimentos armazenados são recompilados (removidos e recriados) com base nos metadados da base de dados. Isto remove quaisquer alterações feitas a um ficheiro gerado por um agente malicioso.

• Os ficheiros gerados são considerados parte dos dados do utilizador e têm as mesmas restrições de segurança, via ACLs, que os ficheiros de base de dados: apenas a conta de serviço SQL Server e os administradores do sistema podem aceder a estes ficheiros.

Não é necessária qualquer interação do utilizador para gerir estes ficheiros. O SQL Server cria e remove os ficheiros conforme necessário.

Ver também

Memory-Optimized Tabelas

Procedimentos Armazenados Compilados Nativamente