Azure Cosmos DB para suporte e compatibilidade do grafo do Gremlin com recursos do TinkerPop

Azure Cosmos DB dá suporte à linguagem de travessia de grafo Apache Tinkerpop, conhecida como Gremlin. É possível usar a linguagem Gremlin para criar entidades de grafo (vértices e bordas), modificar propriedades dentro dessas entidades, executar consultas e passagens e excluir entidades.

Azure Cosmos DB mecanismo de gráfico segue de perto a especificação de etapas de percurso do Apache TinkerPop, mas há diferenças na implementação que são específicas do Azure Cosmos DB. Neste artigo, fornecemos instruções passo a passo rápidas do Gremlin e enumeramos os recursos do Gremlin compatíveis com a API para Gremlin.

Bibliotecas de cliente compatíveis

A tabela a seguir mostra os drivers populares do Gremlin que você pode usar contra Azure Cosmos DB:

Suporte para objetos de gráficos

O TinkerPop é um padrão que abrange uma ampla variedade de tecnologias de grafo. Portanto, ele tem uma terminologia padrão para descrever quais recursos são fornecidos por um provedor de grafo. Azure Cosmos DB fornece um banco de dados de grafo persistente, de alta simultaneidade e gravável que pode ser particionado em vários servidores ou clusters.

A tabela a seguir lista os recursos do TinkerPop implementados pelo Azure Cosmos DB:

Formato de transmissão do Gremlin

Azure Cosmos DB usa o formato JSON ao retornar resultados de operações do Gremlin. Azure Cosmos DB atualmente dá suporte ao formato JSON. Por exemplo, o snippet a seguir mostra uma representação JSON de um vértice retornado para o cliente do Azure Cosmos DB:

  {
    "id": "a7111ba7-0ea1-43c9-b6b2-efc5e3aea4c0",
    "label": "person",
    "type": "vertex",
    "outE": {
      "knows": [
        {
          "id": "3ee53a60-c561-4c5e-9a9f-9c7924bc9aef",
          "inV": "04779300-1c8e-489d-9493-50fd1325a658"
        },
        {
          "id": "21984248-ee9e-43a8-a7f6-30642bc14609",
          "inV": "a8e3e741-2ef7-4c01-b7c8-199f8e43e3bc"
        }
      ]
    },
    "properties": {
      "firstName": [
        {
          "value": "Thomas"
        }
      ],
      "lastName": [
        {
          "value": "Andersen"
        }
      ],
      "age": [
        {
          "value": 45
        }
      ]
    }
  }

As propriedades usadas pelo formato JSON para vértices são descritas abaixo:

Cada propriedade pode armazenar diversos valores em uma matriz.

E a borda contém as seguintes informações para ajudar com a navegação para outras partes do grafo.

Etapas do Gremlin

Agora vamos examinar as etapas do Gremlin compatíveis com Azure Cosmos DB. Para obter uma referência completa sobre o Gremlin, consulte Referência do TinkerPop.

O mecanismo com otimização de gravação fornecido pelo Azure Cosmos DB dá suporte à indexação automática de todas as propriedades dentro de vértices e bordas por padrão. Sendo assim, consultas com filtros, consultas de intervalo, classificações ou agregações de qualquer propriedade são processadas no índice e atendidas de modo eficiente. Para obter mais informações sobre como a indexação funciona em Azure Cosmos DB, consulte nosso artigo sobre schema-agnostic indexing.

Diferenças de comportamento

• O mecanismo Azure Cosmos DB Graph executa a passagem primeiro em largura enquanto o TinkerPop Gremlin é primeiro em profundidade. Esse comportamento obtém um melhor desempenho em um sistema horizontalmente escalonável, como Azure Cosmos DB.

Recursos sem suporte

• Código de bytes do Gremlin é uma especificação independente da linguagem de programação para passagens de gráfico. Azure Cosmos DB Graph ainda não dá suporte a ele. Use GremlinClient.SubmitAsync() e envie a travessia como uma cadeia de caracteres de texto.

• Não há suporte à definição da cardinalidade property(set, 'xyz', 1) no momento. Use property(list, 'xyz', 1) em seu lugar. Para saber mais, confira Propriedades de vértice com TinkerPop.

• A match()etapa não está disponível no momento. Esta etapa fornece funcionalidades de consulta declarativa.

• Não há suporte para objetos como propriedades nos vértices ou bordas. As propriedades somente podem ser tipos primitivos ou matrizes.

• Não há suporte à classificação por propriedades de matriz order().by(<array property>) É possível classifica apenas por tipos primitivos.

• Não há suporte a tipos JSON não primitivos. Use os tipos string, number ou true/false. Não há suporte para valores null.

• No momento, não há suporte para o serializador GraphSONv3. Use as classes de Serializador, Leitor e Gravador GraphSONv2 na configuração de conexão. Os resultados retornados pelo Azure Cosmos DB para Gremlin não têm o mesmo formato que o formato GraphSON.

• Atualmente, não há suporte para as expressões e funções lambda. Isso inclui as funções .map{<expression>}, .by{<expression>} e .filter{<expression>}. Para saber mais e aprender a reescrevê-las usando as etapas do Gremlin, confira Uma observação sobre Lambdas.

• Não há suporte a Transações devido à natureza distribuída do sistema. Configure o modelo de consistência apropriado na conta do Gremlin para "ler as próprias gravações" e use a simultaneidade otimista para resolver as gravações conflitantes.

Limitações conhecidas

• Utilização de índice para consultas do Gremlin com etapas de .V()meia travessia: no momento, somente a primeira .V() chamada de travessia usará o índice para resolver filtros ou predicados anexados a ela. As chamadas subsequentes não consultarão o índice, o que pode aumentar a latência e o custo da consulta.

Pressupondo a indexação padrão, uma consulta do Gremlin de leitura típica que começa com a etapa .V() usaria parâmetros nas etapas de filtragem anexadas, como .has() ou .where() para otimizar o custo e o desempenho da consulta. Por exemplo:

g.V().has('category', 'A')

No entanto, quando mais de uma etapa .V() é incluída na consulta do Gremlin, a resolução dos dados para a consulta pode não ser ideal. Use a seguinte consulta como um exemplo:

g.V().has('category', 'A').as('a').V().has('category', 'B').as('b').select('a', 'b')

Essa consulta retornará dois grupos de vértices com base na propriedade deles chamada category. Nesse caso, somente a primeira chamada, g.V().has('category', 'A'), fará uso do índice para resolver os vértices com base nos valores das propriedades deles.

Uma solução alternativa para essa consulta é usar etapas de subtravessia como .map() e union(). Isso é exemplificado abaixo:

// Query workaround using .map()
g.V().has('category', 'A').as('a').map(__.V().has('category', 'B')).as('b').select('a','b')

// Query workaround using .union()
g.V().has('category', 'A').fold().union(unfold(), __.V().has('category', 'B'))

Você pode examinar o desempenho das consultas usando a executionProfile() etapa do Gremlin.