Referencia del perfil de ejecución de Azure Cosmos DB para Apache Gremlin

Importante

¿Busca una solución de base de datos para escenarios a gran escala con un contrato de nivel de servicio (SLA) de disponibilidad de 99,999%, escalabilidad automática instantánea y conmutación automática por error en varias regiones? Considere la posibilidad de usar Azure Cosmos DB para NoSQL.

¿Desea implementar un grafo de procesamiento analítico en línea (OLAP) o migrar una aplicación de Apache Gremlin existente? Considere Graph en Microsoft Fabric.

En este artículo se proporciona una referencia para la característica de perfil de ejecución en Azure Cosmos DB para Apache Gremlin. Explica la estructura y las propiedades de la respuesta devuelta por la executionProfile() función .

Respuesta

La respuesta de una executionProfile() invocación de función produce una jerarquía de objetos JSON con la estructura siguiente.

Operación de Gremlin

Este objeto representa toda la operación de Gremlin que se ejecutó. Este objeto se denomina gremlin. Este objeto contiene las siguientes propiedades:

	Description
gremlin	Instrucción Gremlin explícita que se ejecutó.
totalTime	El tiempo, en milisegundos, en que se incurre en la ejecución del paso.
metrics	Matriz que contiene cada uno de los operadores en tiempo de ejecución de Cosmos DB que se ejecutaron para completar la consulta. Esta lista se ordena en orden de ejecución.

Operadores en tiempo de ejecución de Azure Cosmos DB para Apache Gremlin

Esta lista representa cada uno de los componentes de toda la operación de Gremlin. La lista se denomina metrcis. Esta lista se ordena en orden de ejecución. Cada objeto contiene las siguientes propiedades:

	Description
name	Nombre del operador. Esta propiedad es el tipo de paso que se evaluó y ejecutó.
time	Cantidad de tiempo, en milisegundos, que tardó un operador determinado.
annotations	Contiene información adicional, específica del operador que se ejecutó.
annotations.percentTime	Porcentaje del tiempo total que tardó en ejecutar el operador específico.
counts	Número de objetos devueltos desde la capa de almacenamiento por este operador. Este recuento se incluye en el counts.resultCount valor escalar dentro de .
storeOps	Representa una operación de almacenamiento que puede abarcar una o varias particiones.
storeOps.fanoutFactor	Representa el número de particiones a las que ha accedido esta operación de almacenamiento específica.
storeOps.count	Representa el número de resultados que devolvió esta operación de almacenamiento.
storeOps.size	Representa el tamaño en bytes del resultado de una operación de almacenamiento determinada.

Respuesta de ejemplo

Esta es una respuesta de ejemplo en formato JSON:

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

Esquema de respuesta

La respuesta también coincide con este esquema JSON:

[
  {
    "type": "object",
    "properties": {
      "gremlin": { "type": "string" },
      "totalTime": { "type": "number" },
      "metrics": {
        "type": "array",
        "items": {
          "type": "object",
          "properties": {
            "name": { "type": "string" },
            "time": { "type": "number" },
            "annotations": {
              "type": "object",
              "properties": {
                "percentTime": { "type": "number" }
              },
              "additionalProperties": true
            },
            "counts": {
              "type": "object",
              "properties": {
                "resultCount": { "type": "number" }
              },
              "additionalProperties": true
            },
            "storeOps": {
              "type": "array",
              "items": {
                "type": "object",
                "properties": {
                  "fanoutFactor": { "type": "number" },
                  "count": { "type": "number" },
                  "size": { "type": "number" },
                  "time": { "type": "number" }
                },
                "additionalProperties": true
              }
            }
          },
          "additionalProperties": true
        }
      }
    },
    "required": ["gremlin", "totalTime", "metrics"],
    "additionalProperties": true
  }
]

Operadores

	Description
GetVertices	Este paso obtiene un conjunto predeterminado de objetos de la capa de persistencia.
GetEdges	Este paso obtiene los bordes que están cerca de un conjunto de vértices. Este paso puede dar lugar a una o varias operaciones de almacenamiento.
GetNeighborVertices	Este paso obtiene los vértices que están conectados a un conjunto de bordes. Los bordes contienen las claves de partición y los identificadores únicos de sus vértices de origen y de destino.
Coalesce	Este paso tiene en cuenta la evaluación de dos operaciones cada vez que se ejecuta el coalesce() paso de Gremlin.
CartesianProductOperator	Este paso calcula un producto cartesiano entre dos conjuntos de datos. Se ejecuta cada vez que se usan los predicados to() o from() .
ConstantSourceOperator	Este paso calcula una expresión para generar un valor constante como resultado.
ProjectOperator	Este paso prepara y serializa una respuesta mediante el resultado de las operaciones anteriores.
ProjectAggregation	Este paso prepara y serializa una respuesta para una operación de agregado.