JSON-blobok és -fájlok indexelése az Azure AI Searchben

A következőkre vonatkozik: Blobindexerek, Fájlindexelők

Az Azure AI Search blobindexeléséhez ez a cikk bemutatja, hogyan állíthatja be a JSON-dokumentumokat tartalmazó blobok vagy fájlok tulajdonságait. Az Azure Blob Storage-ban vagy az Azure File Storage-ban található JSON-fájlok általában a következő űrlapok bármelyikét feltételezik:

  • Egyetlen JSON-dokumentum
  • Jól formázott JSON-elemek tömböt tartalmazó JSON-dokumentum
  • Több entitást tartalmazó JSON-dokumentum, új vonallal elválasztva

A blobindexelő egy paramétert parsingMode biztosít a keresési dokumentum kimenetének JSON-struktúra alapján történő optimalizálásához. Az elemzési módok a következő lehetőségekből állnak:

parsingMode JSON-dokumentum Leírás
json Blobonként egy (alapértelmezett) A JSON-blobokat egyetlen szövegtömbként elemzi. Minden JSON-blob egyetlen keresési dokumentum lesz.
jsonArray Blobonként több Elemez egy JSON-tömböt a blobban, ahol a tömb minden eleme külön keresési dokumentum lesz.
jsonLines Blobonként több Elemez egy blobot, amely több JSON-entitást (tömböt is) tartalmaz, és az egyes elemeket egy új vonal választja el egymástól. Az indexelő minden új sor után elindít egy új keresési dokumentumot.

Az jsonArrayjsonLinesegyik blob indexelésével kapcsolatban érdemes áttekinteni , hogy a blobindexelő hogyan kezeli a dokumentumkulcs egyértelműsítését az azonos blobból létrehozott több keresési dokumentum esetében.

Az indexelődefiníción belül lehetőség van mezőleképezések beállítására, hogy a forrás JSON-dokumentum mely tulajdonságait használja a célkeresési index feltöltéséhez. Az elemzési mód használatakor jsonArray például, ha a tömb alsó szintű tulajdonságként létezik, beállíthatja a "documentRoot" tulajdonságot, amely azt jelzi, hogy a tömb hol található a blobban.

Az alábbi szakaszok részletesebben ismertetik az egyes módokat. Ha nem ismeri az indexelő ügyfeleket és a fogalmakat, olvassa el a Keresési indexelő létrehozása című témakört. Ismernie kell az alapszintű blobindexelő konfiguráció részleteit is, amelyek itt nem ismétlődnek.

Egyetlen JSON-dokumentum indexelése (blobonként egy)

A blobindexelők alapértelmezés szerint egyetlen szövegtömbként elemzik a JSON-blobokat, egy keresési dokumentumot a tárolóban lévő blobokhoz. Ha a JSON strukturált, a keresési dokumentum tükrözheti ezt a struktúrát, és az egyes elemek egyéni mezőkként jelennek meg. Tegyük fel például, hogy a következő JSON-dokumentum van az Azure Blob Storage-ban:

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

A blobindexelő egyetlen keresési dokumentumba elemzi a JSON-dokumentumot, és betölt egy indexet a forrásból származó "szöveg", "datePublished" és "címkék" egyező névvel ellátott és beírt célindexmezőkkel. A "text", "datePublished és "tags" mezőkkel rendelkező indexek alapján a blobindexelő a megfelelő leképezést tudja kikövetkeztetni anélkül, hogy egy mezőleképezés szerepel a kérelemben.

Bár az alapértelmezett viselkedés egy JSON-blobonként egy keresési dokumentum, az json elemzési mód beállítása megváltoztatja a tartalom belső mezőleképezéseit, és elősegíti a mezőket content a keresési index tényleges mezőire. Az elemzési mód indexelődefiníciója az json alábbihoz hasonló lehet:

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" } }
}

Megjegyzés:

Mint minden indexelő esetében, ha a mezők nem egyeznek egyértelműen, akkor kifejezetten meg kell adnia az egyes mezőleképezéseket, hacsak nem használja a blobtartalmakhoz és metaadatokhoz elérhető implicit mezőleképezéseket az alapszintű blobindexelő konfigurációjában leírtak szerint.

json-példa (egyetlen szállodai JSON-fájl)

A GitHubon található JSON-dokumentumadatok a JSON-elemzés teszteléséhez hasznosak, ahol minden blob egy strukturált JSON-fájlt jelöl. Feltöltheti az adatfájlokat a Blob Storage-ba, és az Adatok importálása varázslóval gyorsan kiértékelheti, hogy a tartalom hogyan lesz elemezve az egyes keresési dokumentumokban.

Az adatkészlet öt blobból áll, amelyek mindegyike tartalmaz egy címgyűjteményt és egy szobagyűjteményt tartalmazó szállodai dokumentumot. A blobindexelő mindkét gyűjteményt észleli, és tükrözi az indexsémában lévő bemeneti dokumentumok szerkezetét.

JSON-tömbök elemzése

Másik lehetőségként a JSON-tömböt is használhatja. Ez a beállítás akkor hasznos, ha a blobok jól formázott JSON-objektumokat tartalmazó tömböt tartalmaznak, és azt szeretné, hogy minden elem külön keresési dokumentum legyen. A használatával jsonArraysa következő JSON-blob három különálló dokumentumot hoz létre, mindegyikhez mezőket és "text" mezőket"id".

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

Az parameters indexelő tulajdonsága elemzési mód értékeit tartalmazza. JSON-tömb esetén az indexelő definíciójának az alábbi példához hasonlóan kell kinéznie.

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 példa (klinikai vizsgálatok mintaadatai)

A GitHubon beállított klinikai vizsgálatok JSON-adatai hasznosak a JSON-tömbelemzés teszteléséhez. Feltöltheti az adatfájlokat a Blob Storage-ba, és az Adatok importálása varázslóval gyorsan kiértékelheti, hogy a tartalom hogyan lesz elemezve az egyes keresési dokumentumokban.

Az adatkészlet nyolc olyan blobból áll, amelyek mindegyike egy entitásokból álló JSON-tömböt tartalmaz, összesen 100 entitáshoz. Az entitások eltérőek attól függően, hogy mely mezők vannak feltöltve, de a végeredmény entitásonként egy keresési dokumentum, az összes tömbből, az összes blobból.

Beágyazott JSON-tömbök elemzése

Beágyazott elemekkel rendelkező JSON-tömbök esetén megadhat egy documentRoot többszintű struktúrát jelzőt. Ha például a blobok a következőképpen néznek ki:

{
    "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" }  
        ]
    }
}

Ezzel a konfigurációval indexelje a tulajdonságban található tömböt level2 :

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

JSON-entitások elemzése új vonalakkal elválasztva

Ha a blob több, új vonallal elválasztott JSON-entitást tartalmaz, és azt szeretné, hogy minden elem külön keresési dokumentum legyen, használja a következőt jsonLines:

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

JSON-sorok esetén az indexelő definíciójának az alábbi példához hasonlóan kell kinéznie.

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" } }
}

JSON-mezők leképezése keresési mezőkre

A mezőleképezések egy forrásmezőt társítanak egy célmezőhöz olyan helyzetekben, amikor a mezőnevek és a típusok nem azonosak. A mezőleképezések azonban a JSON-dokumentumok részeinek egyeztetésére és a keresési dokumentum legfelső szintű mezőibe való "felemelésére" is használhatók.

Az alábbi forgatókönyv ezt a példát ábrázolja. A mezőleképezésekkel kapcsolatos általános információkért lásd a mezőleképezéseket.

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

Tegyük fel, hogy a keresési index a következő mezőkkel rendelkezik: text típus Edm.String, date típus Edm.DateTimeOffsetés tags típus Collection(Edm.String). Figyelje meg a "datePublished" közötti eltérést az index forrásában és date mezőjében. A JSON kívánt alakzatba való leképezéséhez használja a következő mezőleképezéseket:

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

A forrásmezők a JSON-mutató jelölésével vannak megadva. A JSON-dokumentum gyökerére mutató perjellel kezdje, majd válassza ki a kívánt tulajdonságot (tetszőleges beágyazási szinten) a perjellel elválasztott elérési út használatával.

Az egyes tömbelemekre nulla alapú index használatával is hivatkozhat. Ha például a fenti példából szeretné kiválasztani a "címkék" tömb első elemét, használjon egy ilyen mezőleképezést:

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

Megjegyzés:

Ha a "sourceFieldName" olyan tulajdonságra hivatkozik, amely nem létezik a JSON-blobban, a rendszer hiba nélkül kihagyja a leképezést. Ez a viselkedés lehetővé teszi az indexelés folytatását olyan JSON-blobok esetében, amelyek más sémával rendelkeznek (ez gyakori használati eset). Mivel nincs érvényesítési ellenőrzés, gondosan ellenőrizze a leképezéseket az elírások miatt, hogy ne veszítsen el dokumentumokat rossz okból.

További lépések