Nota
O acesso a esta página requer autorização. Podes tentar iniciar sessão ou mudar de diretório.
O acesso a esta página requer autorização. Podes tentar mudar de diretório.
Aplica-se a:
SQL ServerBanco de Dados SQL do AzureInstância Gerenciada SQL do Azure
O exemplo de código neste tópico demonstra o desempenho rápido de tabelas otimizadas para memória. A melhoria de desempenho é evidente quando os dados numa tabela otimizada para memória são acedidos a partir do Transact-SQL tradicional e interpretado. Esta melhoria de desempenho é ainda maior quando os dados numa tabela otimizada para memória são acedidos a partir de um procedimento armazenado compilado nativamente (NCSProc).
Para ver uma demonstração mais abrangente das potenciais melhorias de desempenho do In-Memory OLTP, vejaIn-Memory OLTP Performance Demo v1.0.
O exemplo de código no presente artigo é monothread e não aproveita os benefícios de concorrência do In-Memory OLTP. Uma carga de trabalho que utiliza concorrência terá um ganho de desempenho maior. O exemplo de código mostra apenas um aspeto da melhoria de desempenho, nomeadamente a eficiência de acesso a dados para o INSERT.
A melhoria de desempenho oferecida pelas tabelas otimizadas para memória é totalmente realizada quando os dados numa tabela otimizada para memória são acedidos a partir de um NCSProc.
Exemplo de código
As subsecções seguintes descrevem cada etapa.
Passo 1a: Pré-requisito Se Usar SQL Server
Os passos desta primeira subseção aplicam-se apenas se estiveres a correr no SQL Server, e não se aplicam se estiveres a correr no Azure SQL Database. Faça o seguinte:
Use o SQL Server Management Studio (SSMS.exe) para se ligar ao seu SQL Server. Ou qualquer outra ferramenta semelhante à SSMS.exe está bem.
Crie manualmente um diretório chamado C:\data\. O código Transact-SQL exemplo espera que o diretório pré-exista.
Execute o pequeno comando T-SQL para criar a base de dados e o seu grupo de ficheiros otimizado para memória.
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
Passo 1b: Pré-requisito Se Usar Azure SQL Database
Esta subseção aplica-se apenas se estiver a usar a Azure SQL Database. Faça o seguinte:
Decide qual base de dados de teste existente vais usar para o exemplo de código.
Se decidir criar uma nova base de dados de teste, use o portal Azure para criar uma base de dados chamada imoltp.
Se quiser instruções para usar o portal Azure para isto, veja Começar com Azure SQL Database.
Passo 2: Criar Tabelas Otimizadas para Memória e NCSProc
Esta etapa cria tabelas otimizadas para memória e um procedimento armazenado compilado nativamente (NCSProc). Faça o seguinte:
Use SSMS.exe para se ligar à sua nova base de dados.
Execute o seguinte T-SQL na sua base de dados.
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
Passo 3: Executar o Código
Agora pode executar as consultas que irão demonstrar o desempenho de tabelas otimizadas para memória. Faça o seguinte:
Use SSMS.exe para executar o seguinte T-SQL na sua base de dados.
Ignorar quaisquer dados de velocidade ou de desempenho que esta primeira execução gere. A primeira execução assegura que são realizadas várias operações únicas, como as alocações iniciais de memória.
Mais uma vez, use SSMS.exe para reexecutar o seguinte T-SQL na sua base de dados.
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
De seguida, vêm as estatísticas de tempo de saída geradas pelo nosso segundo teste.
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.