Hantera JSON-kolumner och -index

  • 8 minuter

Relationsdatabaser fungerar bäst när varje rad i en tabell har samma kolumner. Du definierar strukturen en gång och varje post följer den. Den här designen fungerar bra för data som kunder, beställningar eller fakturor där fälten är förutsägbara. Men vissa data varierar från post till post. Vilka attribut du behöver lagra beror på vilken typ av objekt, datakälla eller val som användarna har gjort. Traditionell tabelldesign tvingar dig att antingen skapa många kolumner som är tomma för de flesta rader eller dela upp data i många tabeller. JSON-kolumner erbjuder ett annat alternativ: lagra variabeldelarna som JSON samtidigt som de förutsägbara delarna hålls i vanliga kolumner.

Till exempel har en e-handelsproduktkatalog gemensamma fält som produktnamn, pris och kategori som gäller för varje objekt. Men en skjorta behöver storlek och färg, en bärbar dator behöver processorhastighet och skärmstorlek, och en bok behöver författare och andra attribut. Med JSON lagrar du de gemensamma fälten som kolumner och placerar de kategorispecifika attributen i en JSON-kolumn. Du kan lägga till nya produkttyper utan att ändra tabellstrukturen.

Förstå när du ska använda JSON-kolumner

Med JSON-kolumner kan du fråga och indexera halvstrukturerade data med hjälp av välbekant SQL-syntax. Du behöver ingen separat NoSQL-databas för att hantera flexibla data. Överväg JSON för dessa scenarier:

  • Användarinställningar – Inställningar som tema, språk och meddelandealternativ skiljer sig åt per användare och ändras när du lägger till funktioner.
  • API-svar – Data från externa tjänster har kapslade strukturer som kan ändras när providern uppdaterar sitt API.
  • Granskningsloggar – Poster som avbildar tillstånd före och efter måste anpassas när dina tabellscheman utvecklas.
  • Program för flera klientorganisationer – Olika kunder kräver olika anpassade fält.
  • Flexibla metadata – Taggar, etiketter och egenskaper som varierar beroende på post och inte passar ett fast schema.

Skapa och sök i JSON-kolumner

SQL Server 2025 introducerar en intern json-datatyp som lagrar JSON-dokument i ett binärt format som är optimerat för frågor och manipulation. Den interna typen ger effektivare läsningar (dokumentet är redan parsat), effektivare skrivningar (uppdateringar kan ändra enskilda värden utan att skriva om hela dokumentet) och bättre lagringskomprimering jämfört med lagring av JSON som NVARCHAR(MAX).

För tidigare versioner av SQL Server lagrar du JSON i en NVARCHAR(MAX) kolumn.

Om du vill läsa värden från JSON använder du JSON-funktioner som JSON_VALUE att extrahera ett enda värde eller JSON_QUERY för att returnera ett objekt eller en matris. Om du frågar en JSON-egenskap ofta kan du skapa ett index i en beräknad kolumn som extraherar den egenskapen.

I följande exempel skapas en tabell med en JSON-kolumn, infogar dokument, frågar efter specifika egenskaper, uppdaterar värden och skapar ett index i ett fält som används ofta:

-- Create table with native JSON type (SQL Server 2025+)
CREATE TABLE ConfigurationData (
    ConfigID INT PRIMARY KEY,
    ConfigSettings JSON NOT NULL
);

-- Insert JSON documents
INSERT INTO ConfigurationData (ConfigID, ConfigSettings) 
VALUES (1, '{"theme":"dark","language":"en","notifications":true}');

INSERT INTO ConfigurationData (ConfigID, ConfigSettings) 
VALUES (2, '{"theme":"light","language":"fr","notifications":false}');

-- Query JSON properties
SELECT ConfigID,
       JSON_VALUE(ConfigSettings, '$.theme') AS Theme,
       JSON_VALUE(ConfigSettings, '$.language') AS Language,
       JSON_QUERY(ConfigSettings, '$') AS FullConfig
FROM ConfigurationData;

-- Update a single property using the modify method (SQL Server 2025+ preview)
UPDATE ConfigurationData
SET ConfigSettings.modify('$.theme', 'light')
WHERE ConfigID = 1;

-- Alternative: JSON_MODIFY works with both JSON and NVARCHAR(MAX) columns
UPDATE ConfigurationData
SET ConfigSettings = JSON_MODIFY(CAST(ConfigSettings AS NVARCHAR(MAX)), '$.notifications', CAST(0 AS BIT))
WHERE ConfigID = 1;

-- Create index on frequently queried JSON property
ALTER TABLE ConfigurationData
ADD ThemeValue AS JSON_VALUE(ConfigSettings, '$.theme');

CREATE INDEX IX_Theme ON ConfigurationData(ThemeValue);

Det här exemplet skapar en tabell med en JSON kolumn som lagrar användarkonfigurationsinställningar. Uttrycken INSERT lägger till JSON-dokument som strängliteraler. För att läsa specifika värden extraherar JSON_VALUE skalärvärden som tema och språk, medan JSON_QUERY returnerar hela JSON-objektet. Metoden .modify() (för närvarande i förhandsversion) uppdaterar en enda egenskap utan att skriva om hela dokumentet. Eftersom typen json inte kan användas som en indexnyckelkolumn skapar exemplet en beräknad kolumn som extraherar temavärdet och indexerar sedan den beräknade kolumnen.

Kombinera relations- och JSON-struktur

JSON-kolumner fungerar bäst för data som varierar beroende på post i databasen. Om varje rad har samma fält med konsekventa datatyper passar vanliga kolumner bättre. Du får validering av inbyggda datatyper, enklare frågor utan JSON-sökvägssyntax och direkt indexering på kolumner. Använd JSON för de delar av dina data som behöver flexibilitet och behåll de förutsägbara delarna i inskrivna kolumner.

Du kan kombinera relationsstruktur med JSON-flexibilitet för produkter som kräver variabelmetadata. Här är ett exempel:

-- Product with flexible metadata (SQL Server 2025+)
CREATE TABLE ProductMetadata (
    ProductID INT PRIMARY KEY,
    AdditionalAttributes JSON NOT NULL
        CHECK (JSON_PATH_EXISTS(AdditionalAttributes, '$.weight') = 1),
    FOREIGN KEY (ProductID) REFERENCES Product(ProductID)
);

-- Store flexible product attributes
INSERT INTO ProductMetadata (ProductID, AdditionalAttributes) 
VALUES (1, '{"dimensions":{"length":10,"width":5,"height":8},"weight":2.5,"color":"blue"}');

-- Query nested JSON properties
SELECT ProductID,
       JSON_VALUE(AdditionalAttributes, '$.weight') AS Weight,
       JSON_VALUE(AdditionalAttributes, '$.dimensions.length') AS Length
FROM ProductMetadata;

Överväg JSON-designprinciper

Tillämpa dessa principer när du implementerar JSON-kolumner:

  • Använd JSON för halvstrukturerade data – Lagra flexibla datastrukturer som varierar beroende på post, inte data med konsekventa scheman.
  • Indexsökvägar som ofta efterfrågas – Skapa beräknade kolumner med index på JSON-egenskaper som du frågar ofta.
  • Verifiera nödvändiga egenskaper – Använd CHECK begränsningar med JSON_PATH_EXISTS för att säkerställa att obligatoriska fält finns.
  • Balansera flexibilitet med struktur – Behåll förutsägbara data i vanliga kolumner och använd endast JSON för variabeldelarna.

JSON-kolumner ger schemaflexibilitet för variabeldata samtidigt som SQL-frågefunktioner bibehålls, men bör komplettera i stället för att ersätta relationsdesign för strukturerade data.