Dimostrazione: Miglioramento delle prestazioni di OLTP in memoriaDemonstration: Performance Improvement of In-Memory OLTP

In questo argomento si applica a: SìSQL ServerSìDatabase SQL di AzurenonAzure SQL Data Warehouse non Parallel Data WarehouseTHIS TOPIC APPLIES TO: yesSQL ServeryesAzure SQL DatabasenoAzure SQL Data Warehouse noParallel Data Warehouse

L'esempio di codice in questo argomento illustra la rapidità delle prestazioni delle tabelle ottimizzate per la memoria.The code sample in this topic demonstrates the fast performance of memory-optimized tables. Il miglioramento delle prestazioni è evidente quando l'accesso ai dati in una tabella ottimizzata per la memoria viene eseguito da codice Transact-SQLTransact-SQLtradizionale e interpretato.The performance improvement is evident when data in a memory-optimized table is accessed from traditional, interpreted Transact-SQLTransact-SQL. Il miglioramento delle prestazioni è ancora maggiore quando l'accesso ai dati in una tabella ottimizzata per la memoria viene eseguito da una stored procedure compilata in modo nativo (NCSProc).This performance improvement is even greater when data in a memory-optimized table is accessed from a natively compiled stored procedure (NCSProc).

Per visualizzare una dimostrazione più completa dei potenziali miglioramenti delle prestazioni di OLTP In memoria, vedere In-Memory OLTP Performance Demo v1.0(Demo sulle prestazioni di OLTP in memoria v1.0).To see a more comprehensive demonstration of the potential performance improvements of In-Memory OLTP see In-Memory OLTP Performance Demo v1.0.

L'esempio di codice in questo articolo è a thread singolo e non sfrutta i vantaggi della concorrenza di OLTP in memoria.The code example in the present article is single-threaded, and it does not take advantage of the concurrency benefits of In-Memory OLTP. Un carico di lavoro che utilizza la concorrenza avrà un miglioramento più significativo delle prestazioni.A workload that uses concurrency will see a greater performance gain. L'esempio di codice illustra solo un aspetto del miglioramento delle prestazioni, l'efficienza dell'accesso ai dati per INSERT.The code example shows only one aspect of performance improvement, namely data access efficiency for INSERT.

Il miglioramento delle prestazioni offerto dalle tabelle ottimizzate per la memoria si ottiene in modo completo quando l'accesso ai dati in una tabella ottimizzata per la memoria viene eseguito da una NCSProc.The performance improvement offered by memory-optimized tables is fully realized when data in a memory-optimized table is accessed from a NCSProc.

Esempio di codiceCode Example

Le sezioni seguenti descrivono ogni passaggio.The following subsections describe each step.

Passaggio 1a: prerequisito se si usa SQL ServerSQL ServerStep 1a: Prerequisite If Using SQL ServerSQL Server

I passaggi descritti in questa prima sottosezione si applicano solo se è in esecuzione SQL ServerSQL Servere non sono applicabili se è in esecuzione Database SQL di AzureAzure SQL Database.The steps in this first subsection applies only if you are running in SQL ServerSQL Server, and does not apply if you are running in Database SQL di AzureAzure SQL Database. Eseguire le operazioni seguenti:Do the following:

  1. Usare SQL Server Management Studio (SSMS.exe) per connettersi a SQL ServerSQL Server.Use SQL Server Management Studio (SSMS.exe) to connect to your SQL ServerSQL Server. o qualsiasi strumento simile a SSMS.exe.Or any tool similar to SSMS.exe is fine.

  2. Creare manualmente una directory denominata C:\data\.Manually create a directory named C:\data\. Il codice di esempio Transact-SQL prevede che la directory esista già.The sample Transact-SQL code expects the directory to pre-exist.

  3. Eseguire l'istruzione T-SQL breve per creare il database e il relativo filegroup ottimizzato per la memoria.Run the short T-SQL to create the database and its memory-optimized filegroup.

go  
CREATE DATABASE imoltp;    --  Transact-SQL  
go  

ALTER DATABASE imoltp ADD FILEGROUP [imoltp_mod]  
    CONTAINS MEMORY_OPTIMIZED_DATA;  

ALTER DATABASE imoltp ADD FILE  
    (name = [imoltp_dir], filename= 'c:\data\imoltp_dir')  
    TO FILEGROUP imoltp_mod;  
go  

USE imoltp;  
go  

Passaggio 1b: prerequisito se si usa Database SQL di AzureAzure SQL DatabaseStep 1b: Prerequisite If Using Database SQL di AzureAzure SQL Database

Questa sottosezione si applica solo se si usa Database SQL di AzureAzure SQL Database.This subsection applies only if you are using Database SQL di AzureAzure SQL Database. Eseguire le operazioni seguenti:Do the following:

  1. Decidere quali database di test esistenti usare per l'esempio di codice.Decide which existing test database you will use for the code example.

  2. Se si decide di creare un nuovo database di test, usare il portale di Azure per creare un database denominato imoltp.If you decide to create a new test database, use the Azure portal to create a database named imoltp.

    Per istruzioni relative all'uso del portale di Azure a questo scopo, vedere l'argomento di introduzione al database SQL di Azure.If you would like instructions for using the Azure portal for this, see Get Started with Azure SQL Database.

Passaggio 2: creare tabelle con ottimizzazione per la memoria e NCSProcStep 2: Create Memory-Optimized Tables, and NCSProc

Questo passaggio crea una tabella ottimizzata per la memoria e una stored procedure compilata in modo nativo (NCSProc).This step creates memory-optimized tables, and a natively compiled stored procedure (NCSProc). Eseguire le operazioni seguenti:Do the following:

  1. Usare SSMS.exe per connettersi al nuovo database.Use SSMS.exe to connect to your new database.

  2. Eseguire l'istruzione T-SQL seguente nel database.Run the following T-SQL in your database.

go  
DROP PROCEDURE IF EXISTS ncsp;  
DROP TABLE IF EXISTS sql;  
DROP TABLE IF EXISTS hash_i;  
DROP TABLE IF EXISTS hash_c;  
go  

CREATE TABLE [dbo].[sql] (  
  c1 INT NOT NULL PRIMARY KEY,  
  c2 NCHAR(48) NOT NULL  
);  
go  

CREATE TABLE [dbo].[hash_i] (  
  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 TABLE [dbo].[hash_c] (  
  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 PROCEDURE ncsp  
    @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].[hash_c] VALUES (@i, @c);  
    SET @i += 1;  
  END;  
END;  
go  

Passaggio 3: eseguire il codiceStep 3: Run the Code

È ora possibile eseguire le query che consentiranno di dimostrare le prestazioni delle tabelle ottimizzate per la memoria.Now you can execute the queries that will demonstrate the performance of memory-optimized tables. Eseguire le operazioni seguenti:Do the following:

  1. Usare SSMS.exe per eseguire l'istruzione T-SQL seguente nel database.Use SSMS.exe to run the following T-SQL in your database.

    Ignorare qualsiasi velocità o altri dati di prestazioni generati da questa prima esecuzione.Ignore any speed or other performance data this first run generates. La prima esecuzione garantisce l'esecuzione di diverse operazioni singole, ad esempio l'allocazione iniziale della memoria.The first run ensure several one-time only operations are performed, such as initial allocations of memory.

  2. Usare nuovamente SSMS.exe per eseguire l'istruzione T-SQL seguente nel database.Again, use SSMS.exe to rerun the following T-SQL in your database.

go  
SET STATISTICS TIME OFF;  
SET NOCOUNT ON;  

-- Inserts, one at a time.  

DECLARE @starttime DATETIME2 = sysdatetime();  
DECLARE @timems INT;  
DECLARE @i INT = 1;  
DECLARE @rowcount INT = 100000;  
DECLARE @c NCHAR(48) = N'12345678901234567890123456789012345678';  

-- Harddrive-based table and interpreted Transact-SQL.  

BEGIN TRAN;  
  WHILE @i <= @rowcount  
  BEGIN;  
    INSERT INTO [dbo].[sql] VALUES (@i, @c);  
    SET @i += 1;  
  END;  
COMMIT;  

SET @timems = datediff(ms, @starttime, sysdatetime());  
SELECT 'A: Disk-based table and interpreted Transact-SQL: '  
    + cast(@timems AS VARCHAR(10)) + ' ms';  

-- Interop Hash.  

SET @i = 1;  
SET @starttime = sysdatetime();  

BEGIN TRAN;  
  WHILE @i <= @rowcount  
    BEGIN;  
      INSERT INTO [dbo].[hash_i] VALUES (@i, @c);  
      SET @i += 1;  
    END;  
COMMIT;  

SET @timems = datediff(ms, @starttime, sysdatetime());  
SELECT 'B: memory-optimized table with hash index and interpreted Transact-SQL: '  
    + cast(@timems as VARCHAR(10)) + ' ms';  

-- Compiled Hash.  

SET @starttime = sysdatetime();  

EXECUTE ncsp @rowcount, @c;  

SET @timems = datediff(ms, @starttime, sysdatetime());  
SELECT 'C: memory-optimized table with hash index and native SP:'  
    + cast(@timems as varchar(10)) + ' ms';  
go  

DELETE sql;  
DELETE hash_i;  
DELETE hash_c;  
go  

Di seguito vengono indicate le statistiche temporali di output generate dall'esecuzione del secondo test.Next are the output time statistics generated by our second test run.

10453 ms , A: Disk-based table and interpreted Transact-SQL.  
5626 ms , B: memory-optimized table with hash index and interpreted Transact-SQL.  
3937 ms , C: memory-optimized table with hash index and native SP.  

Vedere ancheSee Also

OLTP in memoria (ottimizzazione per la memoria)In-Memory OLTP (In-Memory Optimization)