Dela via

Efterfråga JSON-filer

Gäller för:✅ SQL-analysslutpunkt och lager i Microsoft Fabric

I den här artikeln får du lära dig hur du kör frågor mot JSON-filer med hjälp av Fabric SQL, inklusive Fabric Data Warehouse och SQL-analysslutpunkten.

JSON (JavaScript Object Notation) är ett enkelt format för halvstrukturerade data som ofta används i stordata för sensorströmmar, IoT-konfigurationer, loggar och geospatiala data (till exempel GeoJSON).

Använd OPENROWSET för att köra frågor mot JSON-filer direkt

I Fabric Data Warehouse och SQL-analysslutpunkten för en Lakehouse kan du köra frågor mot JSON-filer direkt i sjön med hjälp av OPENROWSET funktionen .

OPENROWSET( BULK '{{filepath}}', [ , <options> ... ])
[ WITH ( <column schema and mappings> ) ];

När du kör frågor mot JSON-filer med OPENROWSET börjar du med att ange filsökvägen, som kan vara en direkt URL eller ett jokerteckenmönster som riktar sig mot en eller flera filer. Som standard projicerar Fabric varje toppnivåegenskap i JSON-dokumentet som en separat kolumn i resultatuppsättningen. För JSON Lines-filer behandlas varje rad som en enskild rad, vilket gör den idealisk för strömningsscenarier.

Om du behöver mer kontroll:

  • Använd den valfria WITH satsen för att definiera schemat explicit och mappa kolumner till specifika JSON-egenskaper, inklusive kapslade sökvägar.
  • Använd DATA_SOURCE för att referera till en rotplats för relativa sökvägar.
  • Konfigurera felhanteringsparametrar som MAXERRORS att hantera parsningsproblem på ett korrekt sätt.

Vanliga JSON-filanvändningsfall

Vanliga JSON-filtyper och användningsfall som du kan hantera i Microsoft Fabric:

  • Radavgränsade JSON-filer ("JSON-rader") där varje rad är ett fristående, giltigt JSON-dokument (till exempel en händelse, en läsning eller en loggpost).
    • Hela filen är inte nödvändigtvis ett enda giltigt JSON-dokument, utan en sekvens med JSON-objekt avgränsade med nya tecken.
    • Filerna med det här formatet har vanligtvis tillägg .jsonl, .ldjsoneller .ndjson. Perfekt för strömmande och tilläggsscenarier – de som skriver kan lägga till en ny händelse som en ny rad utan att skriva om filen eller bryta strukturen.
  • JSON-filer med ett enda dokument ("klassisk JSON") med .json tillägget där hela filen är ett giltigt JSON-dokument – antingen ett enskilt objekt eller en matris med objekt (potentiellt kapslade).
    • Det används ofta för konfiguration, ögonblicksbilder och datauppsättningar som exporteras i ett stycke.
    • GeoJSON-filer lagrar till exempel ofta ett enda JSON-objekt som beskriver funktioner och deras geometrier.

Fråga JSONL-filer med OPENROWSET

Fabric Data Warehouse och SQL-analysslutpunkten för Lakehouse gör det möjligt för SQL-utvecklare att köra frågor mot JSON Lines-filer (.jsonl, .ldjson, .ndjson) direkt från datasjön med hjälp av OPENROWSET-funktionen.

Dessa filer innehåller ett giltigt JSON-objekt per rad, vilket gör dem idealiska för scenarier med endast direktuppspelning och tillägg. Om du vill läsa en JSON Lines-fil anger du dess URL i BULK argumentet:

SELECT TOP 10 *
FROM OPENROWSET(
    BULK 'https://pandemicdatalake.blob.core.windows.net/public/curated/covid-19/bing_covid-19_data/latest/bing_covid-19_data.jsonl'
);

Som standard OPENROWSET använder du schemainferens, identifierar automatiskt alla egenskaper på den översta nivån i varje JSON-objekt och returnerar dem som kolumner.

Du kan dock uttryckligen definiera schemat för att styra vilka egenskaper som returneras och åsidosätta härledda datatyper:

SELECT TOP 10 *
FROM OPENROWSET(
    BULK 'https://pandemicdatalake.blob.core.windows.net/public/curated/covid-19/bing_covid-19_data/latest/bing_covid-19_data.jsonl'
) WITH (
    country_region VARCHAR(100),
    confirmed INT,
    date_reported DATE '$.updated'
);

Explicit schema-definition är användbart när:

  • Du vill åsidosätta standard härledda typer (till exempel för att framtvinga datumdatatypen i stället för varchar).
  • Du behöver stabila kolumnnamn och selektiv projektion.
  • Du vill mappa kolumner till specifika JSON-egenskaper, inklusive kapslade sökvägar.

Läsa komplexa (kapslade) JSON-strukturer med OPENROWSET

Fabric Data Warehouse och SQL Analytics-slutpunkten för Lakehouse låter SQL-utvecklare läsa JSON med kapslade objekt eller subarrayer direkt från datalaken med hjälp av OPENROWSET.

{
  "type": "Feature",
  "properties": {
    "shapeName": "Serbia",
    "shapeISO": "SRB",
    "shapeID": "94879208B25563984444888",
    "shapeGroup": "SRB",
    "shapeType": "ADM0"
  }
}

I följande exempel frågar du en fil som innehåller exempeldata och använder WITH -satsen för att uttryckligen projicera dess egenskaper på lövnivå:

SELECT
    *
FROM
  OPENROWSET(
    BULK '/Files/parquet/nested/geojson.jsonl'
  )
  WITH (
    -- Top-level field
    [type]     VARCHAR(50),
    -- Leaf properties from the nested "properties" object
    shapeName  VARCHAR(200) '$.properties.shapeName',
    shapeISO   VARCHAR(50)  '$.properties.shapeISO',
    shapeID    VARCHAR(200) '$.properties.shapeID',
    shapeGroup VARCHAR(50)  '$.properties.shapeGroup',
    shapeType  VARCHAR(50)  '$.properties.shapeType'
  );

Anmärkning

I det här exemplet används en relativ sökväg utan en datakälla, vilket fungerar när du kör frågor mot filer i Lakehouse via sql-analysslutpunkten. I Fabric Data Warehouse måste du antingen:

  • Använd en absolut sökväg till filen, eller
  • Ange en rot-URL i en extern datakälla och referera till den i instruktionen OPENROWSET med hjälp av DATA_SOURCE-alternativet.

Expandera kapslade matriser (JSON till rader) med OPENROWSET

Med Fabric Data Warehouse och SQL-analysslutpunkten för Lakehouse kan du läsa JSON-filer med kapslade matriser med hjälp OPENROWSETav . Sedan kan du expandera (unnest) dessa matriser med hjälp av CROSS APPLY OPENJSON. Den här metoden är användbar när ett dokument på den översta nivån innehåller en undermatris som du vill använda som en rad per element.

I följande förenklade exempelindata har ett GeoJSON-liknande dokument en funktionsmatris:

{
  "type": "FeatureCollection",
  "crs": { "type": "name", "properties": { "name": "urn:ogc:def:crs:OGC:1.3:CRS84" } },
  "features": [
    {
      "type": "Feature",
      "properties": {
        "shapeName": "Serbia",
        "shapeISO": "SRB",
        "shapeID": "94879208B25563984444888",
        "shapeGroup": "SRB",
        "shapeType": "ADM0"
      },
      "geometry": {
        "type": "Line",
        "coordinates": [[[19.6679328, 46.1848744], [19.6649294, 46.1870428], [19.6638492, 46.1890231]]]
      }
    }
  ]
}

Följande fråga:

  1. Läser JSON-dokumentet från sjön med hjälp av OPENROWSET, och projicerar egenskapen för typ på den översta nivån tillsammans med matrisen av råa funktioner.
  2. CROSS APPLY OPENJSON Gäller för att expandera funktionsmatrisen så att varje element blir en egen rad i resultatuppsättningen. I den här expansionen extraherar frågan kapslade värden med hjälp av JSON-sökvägsuttryck. Värden som shapeName, shapeISO, och geometry information som geometry.type och coordinates, är nu platta kolumner för enklare analys.
SELECT
  r.crs_name,
  f.[type] AS feature_type,
  f.shapeName,
  f.shapeISO,
  f.shapeID,
  f.shapeGroup,
  f.shapeType,
  f.geometry_type,
  f.coordinates
FROM
  OPENROWSET(
      BULK '/Files/parquet/nested/geojson.jsonl'
  )
  WITH (
      crs_name    VARCHAR(100)  '$.crs.properties.name', -- top-level nested property
      features    VARCHAR(MAX)  '$.features'             -- raw JSON array
  ) AS r
CROSS APPLY OPENJSON(r.features)
WITH (
  [type]           VARCHAR(50),
  shapeName        VARCHAR(200)  '$.properties.shapeName',
  shapeISO         VARCHAR(50)   '$.properties.shapeISO',
  shapeID          VARCHAR(200)  '$.properties.shapeID',
  shapeGroup       VARCHAR(50)   '$.properties.shapeGroup',
  shapeType        VARCHAR(50)   '$.properties.shapeType',
  geometry_type    VARCHAR(50)   '$.geometry.type',
  coordinates      VARCHAR(MAX)  '$.geometry.coordinates'
) AS f;

Relaterat innehåll

  • Last updated on