Demostración: Mejora del rendimiento de In-Memory OLTP

En este ejemplo se muestran mejoras de rendimiento al usar In-Memory OLTP comparando las diferencias en los tiempos de respuesta cuando se ejecuta una consulta de Transact-SQL idéntica con tablas basadas en disco y optimizadas para memoria. Además, también se crea un procedimiento almacenado compilado de forma nativa (basado en la misma consulta) y, a continuación, se ejecuta para demostrar que normalmente obtiene los mejores tiempos de respuesta al consultar una tabla optimizada para memoria con un procedimiento almacenado compilado de forma nativa. En este ejemplo solo se muestra un aspecto de las mejoras de rendimiento al acceder a datos en tablas optimizadas para memoria; eficiencia del acceso a datos al realizar inserciones. Este ejemplo es uniproceso y no aprovecha las ventajas de simultaneidad de In-Memory OLTP. Una carga de trabajo que utiliza concurrencia experimentará un mayor aumento en el rendimiento.

Para completar este ejemplo, realizará lo siguiente:

1. Cree una base de datos denominada imoltp y modifique sus detalles de archivo para configurarla para usar In-Memory OLTP.

2. Cree los objetos de base de datos para nuestro ejemplo: tres tablas y un procedimiento almacenado compilado de forma nativa.

3. Ejecute las distintas consultas y muestre los tiempos de respuesta de cada consulta.

Para configurar la base de datos imoltp para nuestro ejemplo, cree primero una carpeta vacía: c:\imoltp_data y, a continuación, ejecute el código siguiente:

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  
  

A continuación, ejecute el código siguiente para crear la tabla basada en disco, dos (2) tablas optimizadas para memoria y el procedimiento almacenado compilado de forma nativa que se usará para mostrar los diferentes métodos de acceso a datos:

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  
  

La configuración se ha completado y estamos listos para ejecutar las consultas que mostrarán los tiempos de respuesta que comparan el rendimiento entre los métodos de acceso a datos.

Para completar el ejemplo, ejecute el código siguiente varias veces. Omita los resultados de la primera ejecución que se ve afectada negativamente por la asignación de memoria inicial.

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).';  
  

Los resultados esperados proporcionan tiempos de respuesta reales que muestran cómo usar tablas optimizadas para memoria y procedimientos almacenados compilados de forma nativa suelen proporcionar tiempos de respuesta coherentemente más rápidos que las mismas cargas de trabajo que se ejecutan en tablas tradicionales basadas en disco.

Véase también

Extensiones de AdventureWorks para demostrar In-Memory OLTP
In-Memory OLTP ( optimización deIn-Memory)
Memory-Optimized Tablas
Procedimientos almacenados compilados de forma nativa
Requisitos para usar tablas de Memory-Optimized
CREATE DATABASE (Transact-SQL de SQL Server)
ALTER DATABASE Opciones de archivo y grupo de archivos (Transact-SQL)
CREATE PROCEDURE y tablas Memory-Optimized