Indexera JSON-blobar och filer i Azure AI Search

  • Artikel

Gäller för: Blob-indexerare, filindexerare

För blobindexering i Azure AI Search visar den här artikeln hur du anger egenskaper för blobar eller filer som består av JSON-dokument. JSON-filer i Azure Blob Storage eller Azure Files förutsätter vanligtvis något av följande formulär:

  • Ett enda JSON-dokument
  • Ett JSON-dokument som innehåller en matris med välformade JSON-element
  • Ett JSON-dokument som innehåller flera entiteter, avgränsade med en ny rad

Blobindexeraren tillhandahåller en parsingMode parameter för att optimera utdata från sökdokumentet baserat på JSON-strukturen. Parsningslägen består av följande alternativ:

parsingMode JSON-dokument beskrivning
json En per blob (standard) Parsar JSON-blobar som ett enda textsegment. Varje JSON-blob blir ett enda sökdokument.
jsonArray Flera per blob Parsar en JSON-matris i bloben, där varje element i matrisen blir ett separat sökdokument.
jsonLines Flera per blob Parsar en blob som innehåller flera JSON-entiteter (även en matris), med enskilda element avgränsade med en ny rad. Indexeraren startar ett nytt sökdokument efter varje ny rad.

För både jsonArray och jsonLinesbör du granska Indexering av en blob för att skapa många sökdokument för att förstå hur blobindexeraren hanterar tvetydighet för dokumentnyckeln för flera sökdokument som skapats från samma blob.

I indexerarens definition kan du ange fältmappningar för att välja vilka egenskaper för JSON-källdokumentet som ska användas för att fylla i målsökningsindexet . När du till exempel använder jsonArray parsningsläget, om matrisen finns som en lägre egenskap, kan du ange egenskapen "documentRoot" som anger var matrisen placeras i bloben.

Kommentar

När ett JSON-parsningsläge används förutsätter Azure AI Search att alla blobar använder samma parser (antingen för jsoneller jsonArrayjsonLines). Om du har en blandning av olika filtyper i samma datakälla bör du överväga att använda filnamnsfilter för att styra vilka filer som importeras.

I följande avsnitt beskrivs varje läge mer detaljerat. Om du inte känner till indexerarklienter och begrepp kan du läsa Skapa en sökindexerare. Du bör också känna till informationen om grundläggande blobindexeringskonfiguration, som inte upprepas här.

Indexera enskilda JSON-dokument (ett per blob)

Som standard parsar blobindexerare JSON-blobar som ett enda textsegment, ett sökdokument för varje blob i en container. Om JSON är strukturerad kan sökdokumentet återspegla den strukturen, med enskilda element som representeras som enskilda fält. Anta till exempel att du har följande JSON-dokument i Azure Blob Storage:

{
    "article" : {
        "text" : "A hopefully useful article explaining how to parse JSON blobs",
        "datePublished" : "2020-04-13",
        "tags" : [ "search", "storage", "howto" ]    
    }
}

Blobindexeraren parsar JSON-dokumentet i ett enda sökdokument och läser in ett index genom att matcha "text", "datePublished" och "taggar" från källan mot identiskt namngivna och typerade målindexfält. Med tanke på ett index med fälten "text", "datePublished" och "tags" kan blobindexeraren härleda rätt mappning utan en fältmappning som finns i begäran.

Även om standardbeteendet är ett sökdokument per JSON-blob ändrar inställningen json parsningsläget de interna fältmappningarna för innehåll, vilket främjar fält inuti content till faktiska fält i sökindexet. Ett exempel på en indexerares definition för json parsningsläget kan se ut så här:

POST https://[service name].search.windows.net/indexers?api-version=2020-06-30
Content-Type: application/json
api-key: [admin key]

{
    "name" : "my-json-indexer",
    "dataSourceName" : "my-blob-datasource",
    "targetIndexName" : "my-target-index",
    "parameters" : { "configuration" : { "parsingMode" : "json" } }
}

Kommentar

Som med alla indexerare bör du förvänta dig att uttryckligen ange enskilda fältmappningar om du inte använder implicita fältmappningar som är tillgängliga för blobinnehåll och metadata, enligt beskrivningen i grundläggande blobindexeringskonfiguration.

json-exempel (JSON-filer för enkel hotell)

Hotel JSON-dokumentdatauppsättningen på GitHub är användbar för att testa JSON-parsning, där varje blob representerar en strukturerad JSON-fil. Du kan ladda upp datafilerna till Blob Storage och använda guiden Importera data för att snabbt utvärdera hur innehållet parsas i enskilda sökdokument.

Datauppsättningen består av fem blobar som var och en innehåller ett hotelldokument med en adresssamling och en rumssamling. Blobindexeraren identifierar båda samlingarna och återspeglar strukturen för indatadokumenten i indexschemat.

Parsa JSON-matriser

Du kan också använda alternativet JSON-matris. Det här alternativet är användbart när blobar innehåller en matris med välformade JSON-objekt och du vill att varje element ska bli ett separat sökdokument. Med hjälp av jsonArraysskapar följande JSON-blob tre separata dokument, var och en med "id" och "text" fält.

[
    { "id" : "1", "text" : "example 1" },
    { "id" : "2", "text" : "example 2" },
    { "id" : "3", "text" : "example 3" }
]

Egenskapen parameters på indexeraren innehåller värden för parsningsläge. För en JSON-matris bör indexerarens definition se ut ungefär som i följande exempel.

POST https://[service name].search.windows.net/indexers?api-version=2020-06-30
Content-Type: application/json
api-key: [admin key]

{
    "name" : "my-json-indexer",
    "dataSourceName" : "my-blob-datasource",
    "targetIndexName" : "my-target-index",
    "parameters" : { "configuration" : { "parsingMode" : "jsonArray" } }
}

jsonArrays-exempel

New York Philharmonic JSON-datauppsättningen på GitHub är användbar för att testa JSON-matrisparsning. Du kan ladda upp datafilerna till Blob Storage och använda guiden Importera data för att snabbt utvärdera hur innehållet parsas i enskilda sökdokument.

Datauppsättningen består av åtta blobar, som var och en innehåller en JSON-matris med entiteter, för totalt 100 entiteter. Entiteterna varierar beroende på vilka fält som fylls i, men slutresultatet är ett sökdokument per entitet, från alla matriser, i alla blobar.

Parsa kapslade JSON-matriser

För JSON-matriser med kapslade element kan du ange en documentRoot för att ange en struktur på flera nivåer. Om dina blobbar till exempel ser ut så här:

{
    "level1" : {
        "level2" : [
            { "id" : "1", "text" : "Use the documentRoot property" },
            { "id" : "2", "text" : "to pluck the array you want to index" },
            { "id" : "3", "text" : "even if it's nested inside the document" }  
        ]
    }
}

Använd den här konfigurationen för att indexeras matrisen som finns i egenskapen level2 :

{
    "name" : "my-json-array-indexer",
    ... other indexer properties
    "parameters" : { "configuration" : { "parsingMode" : "jsonArray", "documentRoot" : "/level1/level2" } }
}

Parsa JSON-entiteter avgränsade med nya linjer

Om din blob innehåller flera JSON-entiteter avgränsade med en ny rad och du vill att varje element ska bli ett separat sökdokument använder du jsonLines.

{ "id" : "1", "text" : "example 1" }
{ "id" : "2", "text" : "example 2" }
{ "id" : "3", "text" : "example 3" }

För JSON-rader bör indexerarens definition se ut ungefär som i följande exempel.

POST https://[service name].search.windows.net/indexers?api-version=2020-06-30
Content-Type: application/json
api-key: [admin key]

{
    "name" : "my-json-indexer",
    "dataSourceName" : "my-blob-datasource",
    "targetIndexName" : "my-target-index",
    "parameters" : { "configuration" : { "parsingMode" : "jsonLines" } }
}

Mappa JSON-fält till sökfält

Fältmappningar associerar ett källfält med ett målfält i situationer där fältnamnen och typerna inte är identiska. Men fältmappningar kan också användas för att matcha delar av ett JSON-dokument och "lyfta" dem till fält på den översta nivån i sökdokumentet.

I följande exempel illustreras scenariot. Mer information om fältmappningar i allmänhet finns i fältmappningar.

{
    "article" : {
        "text" : "A hopefully useful article explaining how to parse JSON blobs",
        "datePublished" : "2016-04-13"
        "tags" : [ "search", "storage", "howto" ]    
    }
}

Anta ett sökindex med följande fält: text av typen Edm.String, date av typen Edm.DateTimeOffsetoch tags av typen Collection(Edm.String). Observera skillnaden mellan "datePublished" i källan och date fältet i indexet. Om du vill mappa din JSON till önskad form använder du följande fältmappningar:

"fieldMappings" : [
    { "sourceFieldName" : "/article/text", "targetFieldName" : "text" },
    { "sourceFieldName" : "/article/datePublished", "targetFieldName" : "date" },
    { "sourceFieldName" : "/article/tags", "targetFieldName" : "tags" }
    ]

Källfält anges med JSON-pekarens notation. Du börjar med ett snedstreck för att referera till roten i JSON-dokumentet och väljer sedan önskad egenskap (på godtycklig kapslingsnivå) med hjälp av snedstrecksavgränsad sökväg.

Du kan också referera till enskilda matriselement med hjälp av ett nollbaserat index. Om du till exempel vill välja det första elementet i matrisen "taggar" från exemplet ovan använder du en fältmappning så här:

{ "sourceFieldName" : "/article/tags/0", "targetFieldName" : "firstTag" }

Kommentar

Om "sourceFieldName" refererar till en egenskap som inte finns i JSON-bloben hoppas den mappningen över utan ett fel. Det här beteendet gör att indexering kan fortsätta för JSON-blobar som har ett annat schema (vilket är ett vanligt användningsfall). Eftersom det inte finns någon verifieringskontroll kontrollerar du mappningarna noggrant för stavfel så att du inte förlorar dokument av fel anledning.

Nästa steg