De stap met het uitvoeringsprofiel gebruiken om de Gremlin-query's te evalueren

Artikel
08/15/2024

VAN TOEPASSING OP: Gremlin

Dit artikel bevat een overzicht van het gebruik van de uitvoeringsprofielstap voor Azure Cosmos DB voor Gremlin-grafiekdatabases. Deze stap biedt relevante informatie voor het oplossen van problemen en het optimaliseren van query's, en is compatibel met Gremlin-query's die kunnen worden uitgevoerd voor een Cosmos DB Gremlin API-account.

Als u deze stap wilt gebruiken, voegt u de executionProfile() functie-aanroep toe aan het einde van uw Gremlin-query. Uw Gremlin-query wordt uitgevoerd en het resultaat van de bewerking retourneert een JSON-antwoordobject met het uitvoeringsprofiel van de query.

Voorbeeld:

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

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

Nadat de executionProfile() stap is aangeroepen, is het antwoord een JSON-object dat de uitgevoerde Gremlin-stap bevat, de totale tijd die nodig was en een matrix van de Cosmos DB-runtimeoperators die de instructie heeft geresulteerd.

Notitie

Deze implementatie voor uitvoeringsprofiel is niet gedefinieerd in de Apache Tinkerpop-specificatie. Het is specifiek voor de implementatie van Azure Cosmos DB voor Gremlin.

Antwoordvoorbeeld

Hier volgt een voorbeeld met aantekeningen van de uitvoer die wordt geretourneerd:

Notitie

Dit voorbeeld wordt geannoteerd met opmerkingen die de algemene structuur van het antwoord uitleggen. Een werkelijke executionProfile-reactie bevat geen opmerkingen.

[
  {
    // 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
        }
      }
    ]
  }
]

Notitie

Met de stap executionProfile wordt de Gremlin-query uitgevoerd. Dit omvat de addV of addEstappen, wat resulteert in het maken en de wijzigingen doorvoeren die zijn opgegeven in de query. Als gevolg hiervan worden er ook kosten in rekening gebracht voor de aanvraageenheden die door de Gremlin-query worden gegenereerd.

Antwoordobjecten voor uitvoeringsprofiel

Het antwoord van een executionProfile()-functie levert een hiërarchie van JSON-objecten op met de volgende structuur:

Gremlin-bewerkingsobject: Vertegenwoordigt de hele Gremlin-bewerking die is uitgevoerd. Bevat de volgende eigenschappen.
- gremlin: De expliciete Gremlin-instructie die is uitgevoerd.
- totalTime: De tijd, in milliseconden, dat de uitvoering van de stap die is gemaakt in.
- metrics: Een matrix die elk van de Cosmos DB-runtimeoperators bevat die zijn uitgevoerd om de query te vervullen. Deze lijst wordt gesorteerd op volgorde van uitvoering.
Cosmos DB-runtimeoperators: vertegenwoordigt elk van de onderdelen van de hele Gremlin-bewerking. Deze lijst wordt gesorteerd op volgorde van uitvoering. Elk object bevat de volgende eigenschappen:
- name: Naam van de operator. Dit is het type stap dat is geëvalueerd en uitgevoerd. Lees meer in de onderstaande tabel.
- time: Hoeveelheid tijd, in milliseconden, die een bepaalde operator in beslag nam.
- annotations: Bevat aanvullende informatie, specifiek voor de operator die is uitgevoerd.
- annotations.percentTime: Percentage van de totale tijd die nodig was om de specifieke operator uit te voeren.
- counts: Het aantal objecten dat door deze operator is geretourneerd uit de opslaglaag. Dit is opgenomen in de counts.resultCount scalaire waarde binnen.
- storeOps: Vertegenwoordigt een opslagbewerking die één of meerdere partities kan omvatten.
- storeOps.fanoutFactor: Geeft het aantal partities aan waartoe deze specifieke opslagbewerking toegang heeft.
- storeOps.count: Geeft het aantal resultaten aan dat door deze opslagbewerking is geretourneerd.
- storeOps.size: Vertegenwoordigt de grootte in bytes van het resultaat van een bepaalde opslagbewerking.

Cosmos DB Gremlin Runtime-operator	Beschrijving
`GetVertices`	Deze stap haalt een geprediceerde set objecten op uit de persistentielaag.
`GetEdges`	Met deze stap worden de randen verkregen die grenzen aan een reeks hoekpunten. Deze stap kan leiden tot een of meer opslagbewerkingen.
`GetNeighborVertices`	Met deze stap verkrijgt u de hoekpunten die zijn verbonden met een set randen. De randen bevatten de partitiesleutels en id's van zowel de bron- als doelhoek.
`Coalesce`	Deze stap houdt rekening met de evaluatie van twee bewerkingen wanneer de `coalesce()` Gremlin-stap wordt uitgevoerd.
`CartesianProductOperator`	In deze stap wordt een cartesisch product tussen twee gegevenssets berekend. Meestal uitgevoerd wanneer de predicaten `to()` of `from()` worden gebruikt.
`ConstantSourceOperator`	Met deze stap wordt een expressie berekend om als resultaat een constante waarde te produceren.
`ProjectOperator`	Met deze stap wordt een antwoord voorbereid en geserialiseerd met behulp van het resultaat van voorgaande bewerkingen.
`ProjectAggregation`	Met deze stap wordt een antwoord voorbereid en geserialiseerd voor een statistische bewerking.

Notitie

Deze lijst wordt nog steeds bijgewerkt wanneer er nieuwe operators worden toegevoegd.

Voorbeelden van het analyseren van een antwoord op een uitvoeringsprofiel

Hier volgen enkele voorbeelden van veelvoorkomende optimalisaties die kunnen worden gezien met behulp van het antwoord van het uitvoeringsprofiel:

Blinde fan-out query.
Niet-gefilterde query.

Neem de volgende reactie van het uitvoeringsprofiel op uit een gepartitioneerde grafiek:

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

Hieruit kunnen de volgende conclusies worden getrokken:

De query is één id-zoekactie, omdat de Gremlin-instructie het patroon g.V('id')volgt.
Afgezien van de time metrische waarde lijkt de latentie van deze query hoog te zijn, omdat deze meer dan 10 ms is voor een single point-read-bewerking.
Als we naar het storeOps object kijken, kunnen we zien dat de fanoutFactor is 5, wat betekent dat 5 partities zijn geopend door deze bewerking.

Als conclusie van deze analyse kunnen we vaststellen dat de eerste query meer partities opent dan nodig is. Dit kan worden opgelost door de partitioneringssleutel in de query op te geven als predicaat. Dit leidt tot minder latentie en minder kosten per query. Meer informatie over het partitioneren van grafieken. Een optimalere query zou zijn g.V('tt0093640').has('partitionKey', 't1001').

Niet-gefilterde querypatronen

Vergelijk de volgende twee antwoorden van het uitvoeringsprofiel. Voor het gemak gebruiken deze voorbeelden één gepartitioneerde grafiek.

Met deze eerste query worden alle hoekpunten met het label tweet opgehaald en vervolgens de aangrenzende hoekpunten opgehaald:

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

Let op het profiel van dezelfde query, maar nu met een extra filter, has('lang', 'en')voordat u de aangrenzende hoekpunten verkent:

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

Deze twee query's hebben hetzelfde resultaat bereikt. Voor de eerste query zijn echter meer aanvraageenheden vereist, omdat het nodig is om een grotere initiële gegevensset te herhalen voordat er query's worden uitgevoerd op de aangrenzende items. We kunnen indicatoren van dit gedrag zien bij het vergelijken van de volgende parameters uit beide antwoorden:

De metrics[0].time waarde is hoger in het eerste antwoord, wat aangeeft dat deze enkele stap langer duurde om het probleem op te lossen.
De metrics[0].counts.resultsCount waarde is ook hoger in het eerste antwoord, wat aangeeft dat de eerste werkgegevensset groter was.

Volgende stappen

Meer informatie over de ondersteunde Gremlin-functies in Azure Cosmos DB.
Meer informatie over de Gremlin-API in Azure Cosmos DB.

Delen via

De stap met het uitvoeringsprofiel gebruiken om de Gremlin-query's te evalueren

Antwoordvoorbeeld

Antwoordobjecten voor uitvoeringsprofiel

Voorbeelden van het analyseren van een antwoord op een uitvoeringsprofiel

Blinde fan-out querypatronen

Niet-gefilterde querypatronen

Volgende stappen

Feedback

Aanvullende resources