Skapa och få åtkomst till OLTP-databaser och tabeller i minnet

Detta är den andra artikeln i en serie artiklar om SQL Server In-Memory OLTP.

Den inledande artikeln – SQL Server In-Memory OLTP, introducerade kort grunderna för den nya Hekaton-motorn. I denna del kommer vi att fokusera på praktiken. För att vara mer specifik kommer vi att se hur man skapar In-Memory-optimerade databaser och tabeller, och även hur man bedömer dem med hjälp av T-SQL.

Förutsättningar för att börja använda minnesoptimerade databaser

In-memory OLTP installeras automatiskt med en 64-bitars Enterprise- eller Developer-utgåva av SQL Server 2014 eller SQL Server 2016. SQL Server 32-bitarsversionen tillhandahåller inte In-Memory OLTP-komponenter.

Således, om du har 64-bitars utvecklarutgåva av SQL Server installerad på din dator, kan du börja skapa databaser och datastrukturer som lagrar minnesoptimerad data utan några tilläggsinställningar.

Varje enskild databas som kommer att innehålla minnesoptimerade tabeller bör innehålla en MEMORY_OPTIMIZED_DATA filgrupp. Denna filgrupp innehåller en eller flera behållare. Varje enskild behållare lagrar data och/eller deltafiler. SQL Server använder dessa filer för att återställa de minnesoptimerade tabellerna. Behållare kan placeras på de olika diskarrayerna,
på liknande sätt som FILESTREAM-filgrupper.

Syntaxen för att skapa minnesoptimerad filgrupp är nästan densamma som för en traditionell FILESTREAM-filgrupp, med flera skillnader:

1. Endast en minnesoptimerad filgrupp kan skapas för en databas.
2. Alternativet CONTAINS MEMORY_OPTIMIZED_DATA måste anges uttryckligen.

Du kan skapa filgruppen när du skapar en databas:

CREATE DATABASE InMemoryDemo
ON PRIMARY
(
NAME = N'InMemoryDemo',
FILENAME = N'D:\Data\InMemoryOLTPDemo.mdf'
),
FILEGROUP IMOFG CONTAINS MEMORY_OPTIMIZED_DATA
(
NAME = N'InMemoryDemo_Data',
FILENAME = N'D:\IMOFG\InMemoryDemo_Data.mdf'
)

Alternativt kan du lägga till filgruppen MEMORY_OPTIMIZED_DATA till en befintlig databas och sedan lägga till filer i den filgruppen.

-- Adding the containers
ALTER DATABASE
  DemoDB ADD FILE
  (
  NAME = 'DemoDB_Mod',
  FILENAME = 'D:\Data\DemoDB_Mod'
  )
  TO FILEGROUP DemoDB_Mod

Internt använder In-Memory OLTP en streamingmekanism baserad på FILESTREAM-teknologin, som är väl anpassad för sekventiell I/O-åtkomst.

Skapa minnesoptimerade tabeller

Nu har vi allt vi behöver för att börja skapa minnesoptimerade objekt. Låt oss skapa en minnesoptimerad tabell.

Syntaxen för att skapa in-memory-optimerade tabeller är mycket lik en för att skapa diskbaserade tabeller. Det finns dock några tillägg och begränsningar:

1. MEMORY_OPTIMIZED =ON-satsen identifierar en tabell som optimerad i minnet.
2. In-memory-optimerade tabeller stöder inte alla datatyper som traditionella tabeller stöder. Följande datatyper stöds inte:

• datumtidsförskjutning
• geografi
• geometri
• hierarkiid
• rowversion
• XML
• sql_variant
• Användardefinierade typer

En minnesoptimerad tabell kan skapas med följande hållbarhetsvärden:SCHEMA_AND_DATA eller SCHEMA_ONLY. SCHEMA_AND_DATA är standardvärdet.
Om du anger SCHEMA_ONLY kommer alla ändringar i tabellen inte att loggas och tabelldata lagras inte på disken.

Varje enskild minnesoptimerad tabell måste innehålla minst ett index. Observera att PRIMARY KEY-begränsningen implicit skapar ett index. En hållbar minnesoptimerad tabell kräver alltid en PRIMARY KEY-begränsning.

CREATE TABLE dbo.Person (
  [Name] VARCHAR(32) NOT NULL PRIMARY KEY NONCLUSTERED
 ,[City] VARCHAR(32) NULL
 ,[Country] VARCHAR(32) NULL
 ,[State_Province] VARCHAR(32) NULL
 ,[LastModified] DATETIME NOT NULL
) WITH (MEMORY_OPTIMIZED = ON, DURABILITY = SCHEMA_AND_DATA);

Sammansatta index kan läggas till när alla kolumner har skapats:

CREATE TABLE dbo.Person (
  [Name] VARCHAR(32) NOT NULL PRIMARY KEY NONCLUSTERED
 ,[City] VARCHAR(32) NULL
 ,[Country] VARCHAR(32) NULL
 ,[State_Province] VARCHAR(32) NULL
 ,[LastModified] DATETIME NOT NULL
 ,INDEX T1_INDX_C1C2 NONCLUSTERED ([Name], [City])
) WITH (MEMORY_OPTIMIZED = ON, DURABILITY = SCHEMA_AND_DATA);

När du skapar den in-memory-optimerade tabellen skapar In-Memory OLTP-motorn DML-rutiner för att kunna komma åt den tabellen. Den laddar rutiner som DLL-filer. För en specifik operation anropar SQL Server en nödvändig DLL-fil.

Ändra tabeller och index

Det var omöjligt att ÄNDRA tabeller före SQL Server 2016. För att göra schemaändringar var du tvungen att släppa och återskapa tabellen i minnet.

I den nya versionen av SQL Server stöds ALTER TABLE delvis.

SQL Server 2016 ger dig möjligheten att utföra offlineoperationer:lägga till och släppa (ändra) kolumner, index och begränsningar. Dessutom är det nu möjligt att arbeta med tabeller i minnet med hjälp av SSMS-tabelldesignern eller dbForge Studio för SQL Server-tabellredigerare.

Observera att ALTER TABLE kräver ombyggnad av tabellen. Det är därför du måste vara säker på att du har tillräckligt med minne innan du kör den här operationen. Under ombyggnadsoperationen återinförs varje enskild rad i den nya tabellen och tabellen är inte tillgänglig medan ALTER-operationen utförs.

Du kan införa flera ändringar i en enda tabell och kombinera dem till en enda ALTER TABLE-sats. Du kan LÄGG TILL kolumner, index och begränsningar och du kan SLÄPPA kolumner, index och begränsningar. Observera att du inte kan kombinera ADD- och DROP-kommandon tillsammans i en enda ALTER TABLE.

-- index operations
-- change hash index bucket count
ALTER TABLE dbo.TableName ALTER INDEX IX_Name REBUILD WITH (BUCKET_COUNT = 131072);
GO
-- add index
ALTER TABLE dbo.TableName ADD INDEX IX_Name NONCLUSTERED (ColName);
GO
-- drop index
ALTER TABLE dbo.TableName DROP INDEX IX_Name;
GO
-- add multiple indexes
ALTER TABLE dbo.TableName ADD INDEX IX_Name NONCLUSTERED (ColName),
 INDEX IX_Name2 NONCLUSTERED (ColName2);
GO
-- Add a new column and an index 
ALTER TABLE dbo.TableName ADD Date DATETIME, INDEX IX_Name NONCLUSTERED (ColName);
GO
-- Drop a column
ALTER TABLE dbo.TableName DROP COLUMN ColName;
GO

Tabelltyper och tabellvariabler

SQL Server 2016 ger dig möjligheten att skapa minnesoptimerade tabelltyper som du kan använda när du definierar en tabellvariabel:

CREATE TYPE TypeName
AS TABLE (
Col1 SMALLINT NOT NULL,
Col2 INT NOT NULL,
Col3 INT NOT NULL,
Col4 INT NOT NULL,
INDEX IX_Col1 NONCLUSTERED HASH (Col1)
WITH (BUCKET_COUNT = 131072),
INDEX IX_Col1 NONCLUSTERED (Col2))
WITH (MEMORY_OPTIMIZED = ON);
GO
DECLARE @VariableName TypeName;
GO

Denna variabel lagras endast i minnet. I minnet optimerade tabeller och tabelltyper använder samma datastrukturer, så dataåtkomsten kommer att bli effektivare jämfört med diskbaserade tabellvariabler.

För mer information, se följande MSDN-blogginlägg:Förbättra prestanda för temperaturtabell och tabellvariabel med minnesoptimering

Sammanfattning

In-Memory OLTP är en relativt ung teknik som är designad för att fungera med enorma och mycket upptagna OLTP-system som stöder hundratals eller till och med tusentals samtidiga användare. Den introducerades i SQL Server 2014 och utvecklades i SQL Server 2016.
Samtidigt innehåller tekniken ett antal restriktioner och begränsningar.
Alla T-SQL-funktioner och datatyper stöds inte av minne- optimerade tabeller, sådana tabeller kan inte innehålla rader som överstiger 8060 byte, och stöder inte heller
ROW-OVERFLOW och LOB-lagring. Du kan inte ändra tabeller och index (i SQL Server 2014) när tabellen väl har skapats.
Trots detta förväntar vi oss att ytterligare versioner av In-Memory OLTP kommer att ha färre begränsningar!

Läs även:

Använda index i SQL Server-minnesoptimerade tabeller