Demonstration: Leistungsverbesserung von In-Memory OLTP

In diesem Beispiel werden Leistungsverbesserungen bei der Verwendung von In-Memory OLTP gezeigt, indem Unterschiede bei der Ausführung einer identischen Transact-SQL Abfrage mit speicheroptimierten und herkömmlichen datenträgerbasierten Tabellen verglichen werden. Darüber hinaus wird eine nativ kompilierte gespeicherte Prozedur (basierend auf derselben Abfrage) erstellt und anschließend ausgeführt, um zu veranschaulichen, dass Sie in der Regel die besten Reaktionszeiten erhalten, wenn Sie eine speicheroptimierte Tabelle mit einer nativ kompilierten gespeicherten Prozedur abfragen. Dieses Beispiel zeigt nur einen Aspekt der Leistungsverbesserungen beim Zugriff auf Daten in speicheroptimierten Tabellen. Effizienz des Datenzugriffs beim Ausführen von Einfügungen. Dieses Beispiel läuft auf einem einzelnen Thread und nutzt nicht die Konkurrenzvorteile von In-Memory OLTP. Eine Arbeitslast, die Parallelität verwendet, erfährt eine höhere Leistungssteigerung.

Gehen Sie wie folgt vor, um dieses Beispiel abzuschließen:

1. Erstellen Sie eine Datenbank mit dem Namen imoltp , und ändern Sie die Dateidetails, um sie für die Verwendung von In-Memory OLTP einzurichten.

2. Erstellen Sie die Datenbankobjekte für unser Beispiel: drei Tabellen und eine nativ kompilierte gespeicherte Prozedur.

3. Führen Sie die verschiedenen Abfragen aus, und zeigen Sie die Antwortzeiten für jede Abfrage an.

Um die Imoltp-Datenbank für unser Beispiel einzurichten, erstellen Sie zuerst einen leeren Ordner: c:\imoltp_data, und führen Sie dann den folgenden Code aus:

USE master  
GO  
  
-- Create a new database.  
CREATE DATABASE imoltp  
GO  
  
-- Prepare the database for In-Memory OLTP by  
-- adding a memory-optimized filegroup to the database.  
ALTER DATABASE imoltp ADD FILEGROUP imoltp_file_group  
    CONTAINS MEMORY_OPTIMIZED_DATA;  
  
-- Add a file (to hold the memory-optimized data) to the new filegroup.  
ALTER DATABASE imoltp ADD FILE (name='imoltp_file', filename='c:\imoltp_data\imoltp_file')  
    TO FILEGROUP imoltp_file_group;  
GO  
  

Führen Sie als Nächstes den folgenden Code aus, um die datenträgerbasierte Tabelle, zwei (2) speicheroptimierte Tabellen und die nativ kompilierte gespeicherte Prozedur zu erstellen, die zum Veranschaulichen der verschiedenen Datenzugriffsmethoden verwendet wird:

USE imoltp  
GO  
  
-- If the tables or stored procedure already exist, drop them to start clean.  
IF EXISTS (SELECT NAME FROM sys.objects WHERE NAME = 'DiskBasedTable')  
   DROP TABLE [dbo].[DiskBasedTable]  
GO  
  
IF EXISTS (SELECT NAME FROM sys.objects WHERE NAME = 'InMemTable')  
   DROP TABLE [dbo].[InMemTable]  
GO  
  
IF EXISTS (SELECT NAME FROM sys.objects  WHERE NAME = 'InMemTable2')  
   DROP TABLE [dbo].[InMemTable2]  
GO  
  
IF EXISTS (SELECT NAME FROM sys.objects  WHERE NAME = 'usp_InsertData')  
   DROP PROCEDURE [dbo].[usp_InsertData]  
GO  
  
-- Create a traditional disk-based table.  
CREATE TABLE [dbo].[DiskBasedTable] (  
  c1 INT NOT NULL PRIMARY KEY,  
  c2 NCHAR(48) NOT NULL  
)  
GO  
  
-- Create a memory-optimized table.  
CREATE TABLE [dbo].[InMemTable] (  
  c1 INT NOT NULL PRIMARY KEY NONCLUSTERED HASH WITH (BUCKET_COUNT=1000000),  
  c2 NCHAR(48) NOT NULL  
) WITH (MEMORY_OPTIMIZED=ON, DURABILITY = SCHEMA_AND_DATA);  
GO  
  
-- Create a 2nd memory-optimized table.  
CREATE TABLE [dbo].[InMemTable2] (  
  c1 INT NOT NULL PRIMARY KEY NONCLUSTERED HASH WITH (BUCKET_COUNT=1000000),  
  c2 NCHAR(48) NOT NULL  
) WITH (MEMORY_OPTIMIZED=ON, DURABILITY = SCHEMA_AND_DATA);  
GO  
  
-- Create a natively-compiled stored procedure.  
CREATE PROCEDURE [dbo].[usp_InsertData]   
  @rowcount INT,  
  @c NCHAR(48)  
  WITH NATIVE_COMPILATION, SCHEMABINDING, EXECUTE AS OWNER  
  AS   
  BEGIN ATOMIC   
  WITH (TRANSACTION ISOLATION LEVEL = SNAPSHOT, LANGUAGE = N'us_english')  
  DECLARE @i INT = 1;  
  WHILE @i <= @rowcount  
  BEGIN  
    INSERT INTO [dbo].[inMemTable2](c1,c2) VALUES (@i, @c);  
    SET @i += 1;  
  END  
END  
GO  
  

Das Setup ist abgeschlossen, und wir sind bereit, die Abfragen auszuführen, mit denen die Antwortzeiten angezeigt werden, die die Leistung zwischen den Datenzugriffsmethoden vergleichen.

Führen Sie den folgenden Code mehrmals aus, um das Beispiel abzuschließen. Ignorieren Sie die Ergebnisse der ersten Ausführung, die von der anfänglichen Speicherzuweisung negativ beeinflusst wird.

SET STATISTICS TIME OFF;  
SET NOCOUNT ON;  
  
-- Delete data from all tables to reset the example.  
DELETE FROM [dbo].[DiskBasedTable]   
    WHERE [c1]>0  
GO  
DELETE FROM [dbo].[inMemTable]   
    WHERE [c1]>0  
GO  
DELETE FROM [dbo].[InMemTable2]   
    WHERE [c1]>0  
GO  
  
-- Declare parameters for the test queries.  
DECLARE @i INT = 1;  
DECLARE @rowcount INT = 100000;  
DECLARE @c NCHAR(48) = N'12345678901234567890123456789012345678';  
DECLARE @timems INT;  
DECLARE @starttime datetime2 = sysdatetime();  
  
-- Disk-based table queried with interpreted Transact-SQL.  
BEGIN TRAN  
  WHILE @I <= @rowcount  
  BEGIN  
    INSERT INTO [dbo].[DiskBasedTable](c1,c2) VALUES (@i, @c);  
    SET @i += 1;  
  END  
COMMIT  
  
SET @timems = datediff(ms, @starttime, sysdatetime());  
SELECT CAST(@timems AS VARCHAR(10)) + ' ms (disk-based table with interpreted Transact-SQL).';  
  
-- Memory-optimized table queried with interpreted Transact-SQL.  
SET @i = 1;  
SET @starttime = sysdatetime();  
  
BEGIN TRAN  
  WHILE @i <= @rowcount  
    BEGIN  
      INSERT INTO [dbo].[InMemTable](c1,c2) VALUES (@i, @c);  
      SET @i += 1;  
    END  
COMMIT  
  
SET @timems = datediff(ms, @starttime, sysdatetime());  
SELECT CAST(@timems AS VARCHAR(10)) + ' ms (memory-optimized table with interpreted Transact-SQL).';  
  
-- Memory-optimized table queried with a natively-compiled stored procedure.  
SET @starttime = sysdatetime();  
  
EXEC usp_InsertData @rowcount, @c;  
  
SET @timems = datediff(ms, @starttime, sysdatetime());  
SELECT CAST(@timems AS VARCHAR(10)) + ' ms (memory-optimized table with natively-compiled stored procedure).';  
  

Die erwarteten Ergebnisse liefern tatsächliche Reaktionszeiten, die zeigen, wie die Verwendung von speicheroptimierten Tabellen und nativ kompilierten gespeicherten Prozeduren in der Regel konsistente schnellere Reaktionszeiten bietet als die gleichen Workloads, die mit herkömmlichen datenträgerbasierten Tabellen ausgeführt werden.

Siehe auch

Erweiterungen für AdventureWorks zur Demonstration von In-Memory OLTP
In-Memory OLTP (In-Memory-Optimierung)
Memory-Optimized Tabellen
Nativ kompilierte gespeicherte Prozeduren
Anforderungen für die Verwendung von Memory-Optimized Tabellen
CREATE DATABASE (SQL Server Transact-SQL)
ALTER DATABASE-Optionen Datei und Dateigruppe (Transact-SQL)
CREATE PROCEDURE und Memory-Optimized-Tabellen