Compilação nativa de tabelas e procedimentos armazenados

In-Memory OLTP apresenta o conceito de compilação nativa. O SQL Server pode compilar nativamente procedimentos armazenados que acessam tabelas com otimização de memória. O SQL Server também é capaz de compilar nativamente tabelas com otimização de memória. A compilação nativa permite acesso a dados mais rápido e uma execução de consulta mais eficiente do que o Transact-SQL interpretado (tradicional). A compilação nativa de tabelas e procedimentos armazenados produz DLLs.

Também há suporte para compilação nativa de tipos de tabela com otimização de memória. Para obter mais informações, consulte Memory-Optimized Variáveis de Tabela.

A compilação nativa refere-se ao processo de conversão de constructos de programação em código nativo, consistindo em instruções de processador sem a necessidade de compilação ou interpretação adicionais.

In-Memory OLTP compila tabelas com otimização de memória quando são criadas e compilam nativamente procedimentos armazenados quando são carregados em DLLs nativas. Além disso, as DLLs são recompiladas após a reinicialização de um banco de dados ou servidor. As informações necessárias para recriar as DLLs são armazenadas nos metadados do banco de dados. As DLLs não fazem parte do banco de dados, embora estejam associadas ao banco de dados. Por exemplo, as DLLs não são incluídas em backups de banco de dados.

Manutenção das DLLs do OLTP In-Memory

A consulta a seguir mostra todas as DLLs de tabela e de procedimento armazenado atualmente carregadas na memória no servidor:

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

Os administradores de banco de dados não precisam manter arquivos gerados por uma compilação nativa. O SQL Server remove automaticamente arquivos gerados que não são mais necessários. Por exemplo, os arquivos gerados serão excluídos quando uma tabela e um procedimento armazenado forem excluídos ou se um banco de dados for removido.

Compilação nativa de tabelas

A criação de uma tabela com otimização de memória usando a CREATE TABLE instrução resulta na gravação das informações da tabela nos metadados do banco de dados e nas estruturas de tabela e índice criadas na memória. A tabela também será compilada em uma DLL.

Considere o seguinte script de exemplo, que cria um banco de dados e uma tabela com otimização de memória:

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  

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

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

Compilação nativa de procedimentos armazenados

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

Para obter mais informações sobre procedimentos armazenados compilados nativamente, consulte Procedimentos armazenados compilados nativamente.

Considere o seguinte procedimento armazenado de amostra, que insere linhas na tabela t1 apresentada no 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  
exec dbo.native_sp  
go  
-- reset  
delete from dbo.t1  
go  

A DLL para native_sp pode interagir diretamente com a DLL para t1, além de com o mecanismo de armazenamento OLTP In-Memory, para inserir as linhas da forma mais rápida possível.

O compilador OLTP In-Memory aproveita o otimizador de consulta para criar um plano de execução eficiente para cada uma das consultas no procedimento armazenado. Observe que os procedimentos armazenados compilados nativamente não serão recompilados automaticamente se os dados na tabela forem alterados. Para obter mais informações sobre como manter estatísticas e procedimentos armazenados com In-Memory OLTP, consulte Estatísticas para tabelas de Memory-Optimized.

Considerações de segurança para compilação nativa

A compilação nativa de tabelas e procedimentos armazenados usa o compilador OLTP In-Memory. Esse compilador produz arquivos gravados em disco e carregados na memória. O SQL Server usa os mecanismos a seguir para limitar o acesso a esses arquivos.

Compilador nativo

O executável do compilador, bem como binários e arquivos de cabeçalho necessários para compilação nativa são instalados como parte da instância do SQL Server na pasta MSSQL\Binn\Xtp. Portanto, se a instância padrão estiver instalada em C:\Arquivos de Programas, os arquivos do compilador serão instalados em C:\Arquivos de Programas\MicrosoftSQL Server\MSSQL12. MSSQLSERVER\MSSQL\Binn\Xtp.

Para limitar o acesso ao compilador, o SQL Server usa ACLs (listas de controle de acesso) para restringir o acesso a arquivos binários. Todos os binários do SQL Server são protegidos contra modificação ou violação por meio de ACLs. As ACLs do compilador nativo também limitam o uso do compilador; somente a conta de serviço do SQL Server e os administradores do sistema têm permissões de leitura e execução para arquivos de compilador nativos.

Arquivos gerados por uma compilação nativa

Os arquivos produzidos quando uma tabela ou procedimento armazenado é compilado incluem a DLL e arquivos intermediários, incluindo arquivos com as seguintes extensões: .c, .obj, .xmle .pdb. Os arquivos gerados são salvos em uma subpasta da pasta de dados padrão. A subpasta é chamada de Xtp. Ao instalar a instância padrão com a pasta de dados padrão, os arquivos gerados são colocados em C:\Arquivos de Programas\MicrosoftSQL Server\MSSQL12. MSSQLSERVER\MSSQL\DATA\Xtp.

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

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

• Quando um banco de dados é reiniciado, todas as tabelas e procedimentos armazenados são recompilados (removidos e recriados) com base nos metadados do banco de dados. Isso removerá todas as alterações feitas em um arquivo gerado por um agente mal-intencionado.

• Os arquivos gerados são considerados parte dos dados do usuário e têm as mesmas restrições de segurança, por meio de ACLs, como arquivos de banco de dados: somente a conta de serviço do SQL Server e os administradores do sistema podem acessar esses arquivos.

Nenhuma interação do usuário é necessária para gerenciar esses arquivos. O SQL Server criará e removerá os arquivos conforme necessário.

Consulte Também

TabelasMemory-Optimized
Procedimentos armazenados compilados nativamente