Systeemeigen compilatie van tabellen en opgeslagen procedures

Van toepassing op:SQL ServerAzure SQL DatabaseAzure SQL Managed Instance

In-Memory OLTP introduceert het concept van systeemeigen compilatie. SQL Server kan systeemeigen opgeslagen procedures compileren die toegang hebben tot tabellen die zijn geoptimaliseerd voor geheugen. SQL Server kan ook systeemeigen tabellen compileren die zijn geoptimaliseerd voor geheugen. Systeemeigen compilatie maakt snellere gegevenstoegang en efficiëntere uitvoering van query's mogelijk dan geïnterpreteerd (traditioneel) Transact-SQL. Systeemeigen compilatie van tabellen en opgeslagen procedures produceren DLL's.

Systeemeigen compilatie van tabeltypen die zijn geoptimaliseerd voor geheugen, wordt ook ondersteund. Zie Snellere tijdelijke tabel- en tabelvariabele met behulp van geheugenoptimalisatie voor meer informatie.

Systeemeigen compilatie verwijst naar het proces van het converteren van programmeerconstructies naar systeemeigen code, bestaande uit processorinstructies zonder verdere compilatie of interpretatie.

In-Memory OLTP compileert tabellen die zijn geoptimaliseerd voor geheugen wanneer ze worden gemaakt en systeemeigen opgeslagen procedures wanneer ze worden geladen in systeemeigen DLL's. Bovendien worden de DLL's opnieuw gecompileerd nadat een database of server opnieuw is opgestart. De informatie die nodig is om de DLL's opnieuw te maken, wordt opgeslagen in de metagegevens van de database. De DLL's maken geen deel uit van de database, maar ze zijn gekoppeld aan de database. De DLL's zijn bijvoorbeeld niet opgenomen in databaseback-ups.

Onderhoud van In-Memory OLTP-DLL's

De volgende query toont alle tabel- en opgeslagen procedure-DLL's die momenteel in het geheugen op de server zijn geladen:

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

Databasebeheerders hoeven geen bestanden te onderhouden die worden gegenereerd door een systeemeigen compilatie. SQL Server verwijdert automatisch gegenereerde bestanden die niet meer nodig zijn. Gegenereerde bestanden worden bijvoorbeeld verwijderd wanneer een tabel en opgeslagen procedure worden verwijderd of als een database wordt verwijderd.

Systeemeigen compilatie van tabellen

Het maken van een tabel die is geoptimaliseerd voor geheugen met behulp van de instructie CREATE TABLE resulteert in de tabelgegevens die naar de metagegevens van de database worden geschreven en de tabel- en indexstructuren die in het geheugen zijn gemaakt. De tabel wordt ook gecompileerd naar een DLL.

Bekijk het volgende voorbeeldscript, waarmee een database en een tabel die is geoptimaliseerd voor geheugen, worden gemaakt:

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

Als u de tabel maakt, wordt ook de tabel-DLL gemaakt en wordt het DLL-bestand in het geheugen geladen. De DMV-query haalt direct na de CREATE TABLE-instructie het pad van de tabel-DLL op.

De tabel-DLL begrijpt de indexstructuren en rijindeling van de tabel. SQL Server maakt gebruik van het DLL-bestand voor het doorlopen van indexen, het ophalen van rijen en het opslaan van de inhoud van de rijen.

Systeemeigen compilatie van opgeslagen procedures

Opgeslagen procedures die zijn gemarkeerd met NATIVE_COMPILATION worden systeemeigen gecompileerd. Dit betekent dat de Transact-SQL instructies in de procedure allemaal zijn gecompileerd naar systeemeigen code voor een efficiënte uitvoering van bedrijfskritieke bedrijfslogica.

Zie Systeemeigen gecompileerde opgeslagen procedures voor meer informatie over systeemeigen opgeslagen procedures.

Bekijk de volgende opgeslagen voorbeeldprocedure, waarmee rijen in de tabel t1 uit het vorige voorbeeld worden ingevoegd:

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

Het DLL-bestand voor native_sp kan rechtstreeks communiceren met het DLL-bestand voor t1, evenals de In-Memory OLTP-opslagengine, om de rijen zo snel mogelijk in te voegen.

De In-Memory OLTP-compiler maakt gebruik van de queryoptimalisatie om een efficiënt uitvoeringsplan te maken voor elk van de query's in de opgeslagen procedure. Houd er rekening mee dat opgeslagen procedures die systeemeigen zijn gecompileerd, niet automatisch opnieuw worden gecompileerd als de gegevens in de tabel worden gewijzigd. Zie Statistieken voor Memory-Optimized Tabellen voor meer informatie over het onderhouden van statistieken en opgeslagen procedures met In-Memory OLTP.

Beveiligingsoverwegingen voor systeemeigen compilatie

Systeemeigen compilatie van tabellen en opgeslagen procedures maakt gebruik van de In-Memory OLTP-compiler. Deze compiler produceert bestanden die naar de schijf worden geschreven en in het geheugen worden geladen. SQL Server gebruikt de volgende mechanismen om de toegang tot deze bestanden te beperken.

Systeemeigen compiler

Het uitvoerbare compilerbestand, evenals binaire bestanden en headerbestanden die vereist zijn voor systeemeigen compilatie, worden geïnstalleerd als onderdeel van het SQL Server-exemplaar onder de map MSSQL\Binn\Xtp. Dus als het standaardexemplaar is geïnstalleerd onder C:\Program Files, worden de compilerbestanden geïnstalleerd in C:\Program Files\Microsoft SQL Server\MSSQL13.MSSQLSERVER\MSSQL\Binn\Xtp.

SQL Server gebruikt toegangsbeheerlijsten (ACL's) om de toegang tot binaire bestanden te beperken. Alle binaire SQL Server-bestanden zijn beveiligd tegen wijzigingen of manipulatie via ACL's. De ACL's van de systeemeigen compiler beperken ook het gebruik van de compiler; alleen het SQL Server-serviceaccount en systeembeheerders hebben lees- en uitvoermachtigingen voor systeemeigen compilerbestanden.

Bestanden gegenereerd door een systeemeigen compilatie

De bestanden die worden geproduceerd wanneer een tabel of opgeslagen procedure wordt gecompileerd, bevatten de DLL- en tussenliggende bestanden, inclusief bestanden met de volgende extensies: .c, .obj, .xmlen .pdb. De gegenereerde bestanden worden opgeslagen in een submap van de standaardgegevensmap. De submap heet Xtp. Wanneer u het standaardexemplaar installeert met de standaard gegevensmap, worden de gegenereerde bestanden geplaatst in C:\Program Files\Microsoft SQL Server\MSSQL13.MSSQLSERVER\MSSQL\DATA\Xtp.

SQL Server voorkomt manipulatie met de gegenereerde DLL's op drie manieren:

• Wanneer een tabel of opgeslagen procedure wordt gecompileerd naar een DLL, wordt dit DLL-bestand onmiddellijk in het geheugen geladen en gekoppeld aan het sqlserver.exe proces. Een DLL kan niet worden gewijzigd terwijl het is gekoppeld aan een proces.

• Wanneer een database opnieuw wordt opgestart, worden alle tabellen en opgeslagen procedures opnieuw gecompileerd (verwijderd en opnieuw gemaakt) op basis van de metagegevens van de database. Hiermee worden alle wijzigingen in een gegenereerd bestand verwijderd door een kwaadwillende agent.

• De gegenereerde bestanden worden beschouwd als onderdeel van gebruikersgegevens en hebben dezelfde beveiligingsbeperkingen, via ACL's, als databasebestanden: alleen het SQL Server-serviceaccount en systeembeheerders hebben toegang tot deze bestanden.

Er is geen gebruikersinteractie nodig om deze bestanden te beheren. SQL Server maakt en verwijdert de bestanden indien nodig.

Zie ook

Memory-Optimized tabellen

Systeemeigen gecompileerde opgeslagen procedures