Megosztás a következőn keresztül:

Gremlin-lekérdezések kiértékelése a végrehajtási profil lépés segítségével

  • Cikk

A KÖVETKEZŐKRE VONATKOZIK: Gremlin

Ez a cikk áttekintést nyújt az Azure Cosmos DB gremlin graph-adatbázisokhoz készült végrehajtásiprofil-lépésének használatáról. Ez a lépés a hibaelhárításhoz és a lekérdezés optimalizálásához nyújt releváns információkat, és kompatibilis minden olyan Gremlin-lekérdezéssel, amelyet egy Cosmos DB Gremlin API-fiókon lehet végrehajtani.

A lépés használatához egyszerűen fűzze hozzá a executionProfile() függvényhívást a Gremlin-lekérdezés végén. A Rendszer végrehajtja a Gremlin-lekérdezést, és a művelet eredménye egy JSON-válaszobjektumot ad vissza a lekérdezés-végrehajtási profillal.

Példa:

    // Basic traversal
    g.V('mary').out()

    // Basic traversal with execution profile call
    g.V('mary').out().executionProfile()

A lépés meghívása után a executionProfile() válasz egy JSON-objektum lesz, amely tartalmazza a végrehajtott Gremlin-lépést, a teljes időt, valamint az utasítás által eredményezett Cosmos DB-futtatókörnyezet-operátorok tömbjét.

Feljegyzés

A végrehajtási profil implementációja nincs definiálva az Apache Tinkerpop specifikációjában. Ez az Azure Cosmos DB-hez készült Gremlin implementációjára vonatkozik.

Példa válaszra

A következő egy jegyzetekkel ellátott példa a visszaadandó kimenetre:

Feljegyzés

Ez a példa megjegyzésekkel van eljegyezve, amelyek a válasz általános szerkezetét ismertetik. A tényleges végrehajtásiprofil-válasz nem tartalmaz megjegyzéseket.

[
  {
    // The Gremlin statement that was executed.
    "gremlin": "g.V('mary').out().executionProfile()",

    // Amount of time in milliseconds that the entire operation took.
    "totalTime": 28,

    // An array containing metrics for each of the steps that were executed. 
    // Each Gremlin step will translate to one or more of these steps.
    // This list is sorted in order of execution.
    "metrics": [
      {
        // This operation obtains a set of Vertex objects.
        // The metrics include: time, percentTime of total execution time, resultCount, 
        // fanoutFactor, count, size (in bytes) and time.
        "name": "GetVertices",
        "time": 24,
        "annotations": {
          "percentTime": 85.71
        },
        "counts": {
          "resultCount": 2
        },
        "storeOps": [
          {
            "fanoutFactor": 1,
            "count": 2,
            "size": 696,
            "time": 0.4
          }
        ]
      },
      {
        // This operation obtains a set of Edge objects. 
        // Depending on the query, these might be directly adjacent to a set of vertices, 
        // or separate, in the case of an E() query.
        //
        // The metrics include: time, percentTime of total execution time, resultCount, 
        // fanoutFactor, count, size (in bytes) and time.
        "name": "GetEdges",
        "time": 4,
        "annotations": {
          "percentTime": 14.29
        },
        "counts": {
          "resultCount": 1
        },
        "storeOps": [
          {
            "fanoutFactor": 1,
            "count": 1,
            "size": 419,
            "time": 0.67
          }
        ]
      },
      {
        // This operation obtains the vertices that a set of edges point at.
        // The metrics include: time, percentTime of total execution time and resultCount.
        "name": "GetNeighborVertices",
        "time": 0,
        "annotations": {
          "percentTime": 0
        },
        "counts": {
          "resultCount": 1
        }
      },
      {
        // This operation represents the serialization and preparation for a result from 
        // the preceding graph operations. The metrics include: time, percentTime of total 
        // execution time and resultCount.
        "name": "ProjectOperator",
        "time": 0,
        "annotations": {
          "percentTime": 0
        },
        "counts": {
          "resultCount": 1
        }
      }
    ]
  }
]

Feljegyzés

A végrehajtásiProfile lépés végrehajtja a Gremlin-lekérdezést. Ez magában foglalja azokat a addV addElépéseket, amelyek a létrehozást eredményezik, és véglegesítik a lekérdezésben megadott módosításokat. Ennek eredményeképpen a Gremlin-lekérdezés által létrehozott kérelemegységek is felszámításra kerülnek.

Végrehajtási profil válaszobjektumai

A végrehajtásiProfile() függvény válasza JSON-objektumok hierarchiáját eredményezi a következő struktúrával:

  • Gremlin műveleti objektum: A végrehajtott teljes Gremlin-műveletet jelöli. A következő tulajdonságokat tartalmazza.

    • gremlin: A végrehajtott explicit Gremlin-utasítás.
    • totalTime: Ezredmásodpercben az az idő, amelyben a lépés végrehajtása történt.
    • metrics: Egy tömb, amely tartalmazza a lekérdezés végrehajtásához végrehajtott Cosmos DB-futtatókörnyezeti operátorokat. Ez a lista végrehajtási sorrendben van rendezve.

  • Cosmos DB futtatókörnyezeti operátorok: A Teljes Gremlin-művelet minden összetevőjét jelöli. Ez a lista végrehajtási sorrendben van rendezve. Minden objektum a következő tulajdonságokat tartalmazza:

    • name: Az operátor neve. Ez a kiértékelt és végrehajtott lépés típusa. További információ az alábbi táblázatban.
    • time: Az adott operátor által igénybe vett idő ezredmásodpercben.
    • annotations: A végrehajtott operátorra vonatkozó további információkat tartalmaz.
    • annotations.percentTime: Az adott operátor végrehajtásához igénybe vett teljes idő százalékos aránya.
    • counts: Az operátor által a tárolási rétegből visszaadott objektumok száma. Ez benne van a counts.resultCount skaláris értékben.
    • storeOps: Olyan tárolási műveletet jelöl, amely egy vagy több partícióra is kiterjedhet.
    • storeOps.fanoutFactor: Az adott tárolási művelet által elért partíciók számát jelöli.
    • storeOps.count: A tárolási művelet által visszaadott eredmények számát jelöli.
    • storeOps.size: Egy adott tárolási művelet eredményének bájtban megadott méretét jelöli.
Cosmos DB Gremlin runtime operátor Leírás
GetVertices Ez a lépés beolvas egy előre meghatározott objektumkészletet a perzisztenciarétegből.
GetEdges Ez a lépés beolvasja a csúcsok halmazával szomszédos éleket. Ez a lépés egy vagy több tárolási műveletet eredményezhet.
GetNeighborVertices Ez a lépés beolvasja az élek egy készletéhez csatlakoztatott csúcsokat. Az élek tartalmazzák a partíciókulcsokat és a forrás és a cél csúcspontjaik azonosítóját is.
Coalesce Ez a lépés két művelet kiértékelését adja meg a coalesce() Gremlin-lépés végrehajtásakor.
CartesianProductOperator Ez a lépés kiszámít egy cartesian terméket két adathalmaz között. Általában akkor hajtják végre, amikor a predikátumokat használják to() from() vagy használják.
ConstantSourceOperator Ez a lépés kiszámít egy kifejezést, amely ennek eredményeként állandó értéket hoz létre.
ProjectOperator Ez a lépés előkészíti és szerializálja a választ az előző műveletek eredményei alapján.
ProjectAggregation Ez a lépés előkészíti és szerializálja a választ egy összesített művelethez.

Feljegyzés

Ez a lista az új operátorok hozzáadásakor továbbra is frissül.

Példák végrehajtásiprofil-válasz elemzésére

Az alábbiakban a végrehajtási profil válaszával kiszúrható gyakori optimalizálásokat mutatjuk be:

  • Vak kiszívó lekérdezés.
  • Szűretlen lekérdezés.

Vak ventilátoros lekérdezési minták

Tegyük fel, hogy a következő végrehajtási profil válasza particionált gráfból származik:

[
  {
    "gremlin": "g.V('tt0093640').executionProfile()",
    "totalTime": 46,
    "metrics": [
      {
        "name": "GetVertices",
        "time": 46,
        "annotations": {
          "percentTime": 100
        },
        "counts": {
          "resultCount": 1
        },
        "storeOps": [
          {
            "fanoutFactor": 5,
            "count": 1,
            "size": 589,
            "time": 75.61
          }
        ]
      },
      {
        "name": "ProjectOperator",
        "time": 0,
        "annotations": {
          "percentTime": 0
        },
        "counts": {
          "resultCount": 1
        }
      }
    ]
  }
]

Ebből a következő következtetések vonhatók le:

  • A lekérdezés egyetlen azonosítókeresés, mivel a Gremlin utasítás a mintát g.V('id')követi.
  • A metrika alapján time úgy tűnik, hogy a lekérdezés késése magas, mivel több mint 10 ms egy pontolvasási művelethez.
  • Ha megnézzük az storeOps objektumot, láthatjuk, hogy az fanoutFactor az 5, ami azt jelenti, hogy a művelet 5 partícióhoz fért hozzá.

Az elemzés következtetéseként megállapíthatjuk, hogy az első lekérdezés a szükségesnél több partícióhoz fér hozzá. Ez megoldható úgy, hogy predikátumként megadja a lekérdezés particionálási kulcsát. Ez kevesebb késéshez és lekérdezésenkénti költséghez vezet. További információ a gráfparticionálásról. Optimálisabb lekérdezés lenne g.V('tt0093640').has('partitionKey', 't1001').

Szűretlen lekérdezési minták

Hasonlítsa össze a következő két végrehajtásiprofil-választ. Az egyszerűség kedvéért ezek a példák egyetlen particionált gráfot használnak.

Ez az első lekérdezés lekéri az összes csúcspontot a címkével tweet , majd lekéri a szomszédos csúcsokat:

[
  {
    "gremlin": "g.V().hasLabel('tweet').out().executionProfile()",
    "totalTime": 42,
    "metrics": [
      {
        "name": "GetVertices",
        "time": 31,
        "annotations": {
          "percentTime": 73.81
        },
        "counts": {
          "resultCount": 30
        },
        "storeOps": [
          {
            "fanoutFactor": 1,
            "count": 13,
            "size": 6819,
            "time": 1.02
          }
        ]
      },
      {
        "name": "GetEdges",
        "time": 6,
        "annotations": {
          "percentTime": 14.29
        },
        "counts": {
          "resultCount": 18
        },
        "storeOps": [
          {
            "fanoutFactor": 1,
            "count": 20,
            "size": 7950,
            "time": 1.98
          }
        ]
      },
      {
        "name": "GetNeighborVertices",
        "time": 5,
        "annotations": {
          "percentTime": 11.9
        },
        "counts": {
          "resultCount": 20
        },
        "storeOps": [
          {
            "fanoutFactor": 1,
            "count": 4,
            "size": 1070,
            "time": 1.19
          }
        ]
      },
      {
        "name": "ProjectOperator",
        "time": 0,
        "annotations": {
          "percentTime": 0
        },
        "counts": {
          "resultCount": 20
        }
      }
    ]
  }
]

Figyelje meg ugyanannak a lekérdezésnek a profilját, de most egy további szűrővel, has('lang', 'en')mielőtt felfedezi a szomszédos csúcsokat:

[
  {
    "gremlin": "g.V().hasLabel('tweet').has('lang', 'en').out().executionProfile()",
    "totalTime": 14,
    "metrics": [
      {
        "name": "GetVertices",
        "time": 14,
        "annotations": {
          "percentTime": 58.33
        },
        "counts": {
          "resultCount": 11
        },
        "storeOps": [
          {
            "fanoutFactor": 1,
            "count": 11,
            "size": 4807,
            "time": 1.27
          }
        ]
      },
      {
        "name": "GetEdges",
        "time": 5,
        "annotations": {
          "percentTime": 20.83
        },
        "counts": {
          "resultCount": 18
        },
        "storeOps": [
          {
            "fanoutFactor": 1,
            "count": 18,
            "size": 7159,
            "time": 1.7
          }
        ]
      },
      {
        "name": "GetNeighborVertices",
        "time": 5,
        "annotations": {
          "percentTime": 20.83
        },
        "counts": {
          "resultCount": 18
        },
        "storeOps": [
          {
            "fanoutFactor": 1,
            "count": 4,
            "size": 1070,
            "time": 1.01
          }
        ]
      },
      {
        "name": "ProjectOperator",
        "time": 0,
        "annotations": {
          "percentTime": 0
        },
        "counts": {
          "resultCount": 18
        }
      }
    ]
  }
]

Ez a két lekérdezés ugyanazt az eredményt érte el, azonban az elsőhöz több kérelemegységre van szükség, mivel a szomszédos elemek lekérdezése előtt egy nagyobb kezdeti adatkészletet kellett iterálnia. Ennek a viselkedésnek a mutatóit láthatjuk, amikor a következő paramétereket hasonlítjuk össze mindkét válaszból:

  • Az metrics[0].time első válaszban magasabb az érték, ami azt jelzi, hogy ez az egyetlen lépés hosszabb időt vett igénybe a megoldáshoz.
  • Az metrics[0].counts.resultsCount érték az első válaszban is magasabb, ami azt jelzi, hogy a kezdeti munkaadatkészlet nagyobb volt.

Következő lépések