Informações gerais sobre as consultas do Spanner Graph

Observação: esse recurso está disponível nas edições Enterprise e Enterprise Plus do Spanner. Para mais informações, consulte o resumo das edições do Spanner.

Este documento oferece uma visão geral do uso da linguagem de consulta de grafos com o Spanner Graph, incluindo a sintaxe para correspondência de padrões de grafos, e mostra como executar consultas no seu grafo. Com o Spanner Graph, é possível executar consultas para encontrar padrões, percorrer relacionamentos e extrair insights dos dados de gráficos de propriedades.

Os exemplos neste documento usam o esquema de gráfico criado em Configurar e consultar o Spanner Graph. Esse esquema é ilustrado no diagrama a seguir:

Figura 1: Exemplo de um esquema de gráfico do Spanner.

Executar uma consulta do Spanner Graph

É possível usar o console Google Cloud , a Google Cloud CLI, as bibliotecas de cliente, a API REST ou a API RPC para executar uma consulta do Spanner Graph.

Console do Google Cloud

As etapas a seguir mostram como executar uma consulta no console Google Cloud . Estas etapas pressupõem que você tenha uma instância chamada test-instance que contém um banco de dados chamado example-db. Para informações sobre como criar uma instância com um banco de dados, consulte Configurar e consultar o Spanner Graph.

1. No console Google Cloud , acesse a página Instâncias do Spanner.

   Acessar as instâncias do Spanner

2. Clique na instância chamada test-instance.

3. Em Bancos de dados, clique no banco de dados chamado example-db.

4. Abra o Spanner Studio e clique em Nova guia ou use a guia do editor.

5. Insira uma consulta no editor.

6. Clique em Executar.

CLI da gcloud

Para enviar consultas usando a ferramenta de linha de comando da CLI gcloud, faça o seguinte:

1. Se ainda não estiver instalada, instale a gcloud CLI.

2. Na CLI gcloud, execute o seguinte comando:

   gcloud spanner databases execute-sql

Para mais informações, consulte o Guia de início rápido da CLI do Spanner.

API REST

Para enviar consultas usando a API REST, use um dos seguintes comandos:

• executeSql
• executeStreamingSql

Para mais informações, consulte Consultar dados usando a API REST e Começar a usar o Spanner com REST.

API RPC

Para enviar consultas usando a API RPC, use um dos seguintes comandos:

• ExecuteSql
• ExecuteStreamingSql

Bibliotecas de cliente

Para saber mais sobre como executar uma consulta com uma biblioteca de cliente do Spanner, consulte:

• Consultar usando a biblioteca de cliente C++ do Spanner
• Consultar usando a biblioteca de cliente C# do Spanner
• Consultar usando a biblioteca de cliente do Spanner Go
• Consultar usando a biblioteca de cliente Java do Spanner
• Consultar usando a biblioteca de cliente Node.js do Spanner
• Consultar usando a biblioteca de cliente PHP do Spanner
• Consultar usando a biblioteca de cliente Python do Spanner
• Consultar usando a biblioteca de cliente Ruby do Spanner

Para mais informações sobre as bibliotecas de cliente do Spanner, consulte a visão geral das bibliotecas de cliente do Spanner.

Visualizar os resultados da consulta do Spanner Graph

É possível conferir uma representação visual dos resultados da consulta do Spanner Graph no Spanner Studio no console Google Cloud . Com uma visualização de consulta, é possível ver como os elementos retornados (nós e arestas) estão conectados. Isso pode revelar padrões, dependências e anomalias difíceis de identificar quando você vê os resultados em uma tabela. Para visualizar uma consulta, ela precisa retornar nós completos no formato JSON. Caso contrário, os resultados da consulta serão mostrados apenas em formato tabular. Para mais informações, consulte Usar visualizações de consultas de gráficos do Spanner.

Estrutura de consulta do Spanner Graph

Uma consulta do Spanner Graph consiste em vários componentes, como o nome do gráfico de propriedades, padrões de nós e arestas e quantificadores. Você usa esses componentes para criar uma consulta que encontra padrões específicos no seu gráfico. Cada componente é descrito na seção Correspondência de padrões de gráficos deste documento.

A consulta na Figura 2 demonstra a estrutura básica de uma consulta de gráfico do Spanner. A consulta começa especificando o grafo de destino, FinGraph, usando a cláusula GRAPH. A cláusula MATCH define o padrão a ser pesquisado. Nesse caso, é um nó Person conectado a um nó Account por uma aresta Owns. A cláusula RETURN especifica quais propriedades dos nós correspondentes serão retornadas.

Figura 2: Um exemplo da estrutura de uma consulta do Spanner Graph.

Correspondência de padrões de gráficos

A correspondência de padrões de gráficos encontra padrões específicos no seu gráfico. Os padrões mais básicos são os de elementos, como os de nós, que correspondem a nós, e os de arestas, que correspondem a arestas.

Padrões de nós

Um padrão de nó corresponde aos nós no seu gráfico. Esse padrão contém parênteses correspondentes, que podem incluir opcionalmente uma variável de padrão de gráfico, uma expressão de rótulo e filtros de propriedade.

Encontrar todos os nós

A consulta a seguir retorna todos os nós no gráfico. A variável n, uma variável de padrão de gráfico, é vinculada aos nós correspondentes. Nesse caso, o padrão de nó corresponde a todos os nós no gráfico.

GRAPH FinGraph
MATCH (n)
RETURN LABELS(n) AS label, n.id;

Essa consulta retorna label e id:

o rótulo.	ID
Conta	7
Conta	16
Conta	20
Pessoa	1
Pessoa	2
Pessoa	3

Encontrar todos os nós com um rótulo específico

A consulta a seguir corresponde a todos os nós no gráfico que têm o rótuloPerson. A consulta retorna as propriedades label, id e name dos nós correspondentes.

GRAPH FinGraph
MATCH (p:Person)
RETURN LABELS(p) AS label, p.id, p.name;

Essa consulta retorna as seguintes propriedades dos nós correspondentes:

o rótulo.	ID	nome
Pessoa	1	Alex
Pessoa	2	Dana
Pessoa	3	Lee

Encontrar todos os nós que correspondem a uma expressão de rótulo

É possível criar uma expressão de rótulo com um ou mais operadores lógicos. Por exemplo, a consulta a seguir corresponde a todos os nós no gráfico que têm o rótulo Person ou Account. A variável de padrão de gráfico n expõe todas as propriedades de nós com o rótulo Person ou Account.

GRAPH FinGraph
MATCH (n:Person|Account)
RETURN LABELS(n) AS label, n.id, n.birthday, n.create_time;

Nos resultados a seguir desta consulta:

• Todos os nós têm a propriedade id.
• Os nós que correspondem ao rótulo Account têm a propriedade create_time, mas não têm a propriedade birthday. A propriedade birthday é NULL para esses nós.
• Os nós que correspondem ao rótulo Person têm a propriedade birthday, mas não têm a propriedade create_time. A propriedade create_time é NULL para esses nós.

o rótulo.	ID	birthday	create_time
Conta	7	NULL	2020-01-10T14:22:20.222Z
Conta	16	NULL	2020-01-28T01:55:09.206Z
Conta	20	NULL	2020-02-18T13:44:20.655Z
Pessoa	1	1991-12-21T08:00:00Z	NULL
Pessoa	2	1980-10-31T08:00:00Z	NULL
Pessoa	3	1986-12-07T08:00:00Z	NULL

Observação: NULL não indica necessariamente a ausência de uma propriedade, porque um elemento pode expor uma propriedade com um valor NULL. Para verificar a existência de uma propriedade, use o predicado PROPERTY_EXISTS.

Encontrar todos os nós que correspondem à expressão de rótulo e ao filtro de propriedade

Essa consulta corresponde a todos os nós no gráfico que têm o rótulo Person e em que a propriedade id é igual a 1.

GRAPH FinGraph
MATCH (p:Person {id: 1})
RETURN LABELS(p) AS label, p.id, p.name, p.birthday;

Aqui estão os resultados da consulta:

o rótulo.	ID	nome	birthday
Pessoa	1	Alex	1991-12-21T08:00:00Z

É possível usar a cláusula WHERE para formar condições de filtragem mais complexas em rótulos e propriedades.

A consulta a seguir usa a cláusula WHERE para formar uma condição de filtragem mais complexa em propriedades. Ele corresponde a todos os nós no gráfico que têm o rótulo Person, e a propriedade birthday está antes de 1990-01-10.

GRAPH FinGraph
MATCH (p:Person WHERE p.birthday < '1990-01-10')
RETURN LABELS(p) AS label, p.name, p.birthday;

Aqui estão os resultados da consulta:

o rótulo.	nome	birthday
Pessoa	Dana	1980-10-31T08:00:00Z
Pessoa	Lee	1986-12-07T08:00:00Z

Padrões de borda

Um padrão de aresta corresponde a arestas ou relações entre nós. Os padrões de borda são incluídos em colchetes ([]) e incluem símbolos como -, -> ou <- para indicar direções. Um padrão de aresta pode incluir opcionalmente uma variável de padrão de gráfico para vincular a arestas correspondentes.

Encontrar todas as arestas com rótulos correspondentes

Essa consulta retorna todas as arestas no gráfico com o rótulo Transfers. A consulta vincula a variável de padrão de gráfico e às arestas correspondentes.

GRAPH FinGraph
MATCH -[e:Transfers]->
RETURN e.Id as src_account, e.order_number

Aqui estão os resultados da consulta:

src_account	order_number
7	304330008004315
7	304120005529714
16	103650009791820
20	304120005529714
20	302290001255747

Encontra todas as arestas que correspondem à expressão de rótulo e ao filtro de propriedade.

O padrão de aresta desta consulta usa uma expressão de rótulo e um filtro de propriedade para encontrar todas as arestas rotuladas com Transfers que correspondem a um order_number especificado.

GRAPH FinGraph
MATCH -[e:Transfers {order_number: "304120005529714"}]->
RETURN e.Id AS src_account, e.order_number

Aqui estão os resultados da consulta:

src_account	order_number
7	304120005529714
20	304120005529714

Encontrar todas as bordas usando qualquer padrão de borda de direção

É possível usar o padrão de aresta any direction (-[]-) em uma consulta para corresponder a arestas em qualquer direção. A consulta a seguir encontra todas as transferências com uma conta bloqueada.

GRAPH FinGraph
MATCH (account:Account)-[transfer:Transfers]-(:Account {is_blocked:true})
RETURN transfer.order_number, transfer.amount;

Aqui estão os resultados da consulta:

order_number	amount
304330008004315	300
304120005529714	100
103650009791820	300
302290001255747	200

Padrões de caminho

Um padrão de caminho é criado com base em padrões alternados de nó e aresta.

Encontrar todos os caminhos de um nó específico usando um padrão de caminho

A consulta a seguir encontra todas as transferências para uma conta iniciada de uma conta de propriedade de Person com id igual a 2.

Cada resultado correspondente representa um caminho de Person {id: 2} por um Account conectado usando a aresta Owns, em outro Account usando a aresta Transfers.

GRAPH FinGraph
MATCH
  (p:Person {id: 2})-[:Owns]->(account:Account)-[t:Transfers]->
  (to_account:Account)
RETURN
  p.id AS sender_id, account.id AS from_id, to_account.id AS to_id;

Aqui estão os resultados da consulta:

sender_id	from_id	to_id
2	20	7
2	20	16

Padrões de caminho quantificados

Um padrão quantificado repete um padrão dentro de um intervalo especificado.

Corresponder a um padrão de aresta quantificado

Para encontrar caminhos de comprimento variável, aplique um quantificador a um padrão de aresta. A consulta a seguir demonstra isso ao encontrar contas de destino que estão de uma a três transferências de distância de uma Account de origem com um id de 7.

A consulta aplica o quantificador {1, 3} ao padrão de borda -[e:Transfers]->. Isso instrui a consulta a corresponder a caminhos que repetem o padrão de aresta Transfers uma, duas ou três vezes. A cláusula WHERE é usada para excluir a conta de origem dos resultados. A função ARRAY_LENGTH é usada para acessar o e group variable. Para mais informações, consulte variável de grupo de acesso.

GRAPH FinGraph
MATCH (src:Account {id: 7})-[e:Transfers]->{1, 3}(dst:Account)
WHERE src != dst
RETURN src.id AS src_account_id, ARRAY_LENGTH(e) AS path_length, dst.id AS dst_account_id;

Aqui estão os resultados da consulta:

src_account_id	path_length	dst_account_id
7	1	16
7	1	16
7	1	16
7	3	16
7	3	16
7	2	20
7	2	20

Algumas linhas nos resultados são repetidas. Isso ocorre porque podem existir vários caminhos que correspondem ao padrão entre os mesmos nós de origem e destino, e a consulta retorna todos eles.

Corresponder a um padrão de caminho quantificado

A consulta a seguir encontra caminhos entre nós Account com uma ou duas arestas Transfers por contas intermediárias bloqueadas.

O padrão de caminho entre parênteses é quantificado, e a cláusula WHERE especifica condições para o padrão repetido.

GRAPH FinGraph
MATCH
  (src:Account)
  ((a:Account)-[:Transfers]->(b:Account {is_blocked:true}) WHERE a != b){1,2}
    -[:Transfers]->(dst:Account)
RETURN src.id AS src_account_id, dst.id AS dst_account_id;

Aqui estão os resultados da consulta:

src_account_id	dst_account_id
7	20
7	20
20	20

Variáveis de grupo

Uma variável de padrão de gráfico declarada em um padrão quantificado se torna uma variável de grupo quando acessada fora desse padrão. Em seguida, ele se vincula a uma matriz de elementos de gráfico correspondentes.

É possível acessar uma variável de grupo como uma matriz. Os elementos do gráfico são preservados na ordem em que aparecem nos caminhos correspondentes. É possível agregar uma variável de grupo usando a agregação horizontal.

Variável de grupo de acesso

No exemplo a seguir, a variável e é acessada da seguinte maneira:

• Uma variável de padrão de grafo vinculada a uma única aresta na cláusula WHERE e.amount > 100 quando está dentro do padrão quantificado.
• Uma variável de grupo vinculada a uma matriz de elementos de borda em ARRAY_LENGTH(e) na instrução RETURN quando está fora do padrão quantificado.
• Uma variável de grupo vinculada a uma matriz de elementos de borda, agregada por SUM(e.amount) fora do padrão quantificado. Este é um exemplo de agregação horizontal.

GRAPH FinGraph
MATCH
  (src:Account {id: 7})-[e:Transfers WHERE e.amount > 100]->{0,2}
  (dst:Account)
WHERE src.id != dst.id
LET total_amount = SUM(e.amount)
RETURN
  src.id AS src_account_id, ARRAY_LENGTH(e) AS path_length,
  total_amount, dst.id AS dst_account_id;

Aqui estão os resultados da consulta:

src_account_id	path_length	total_amount	dst_account_id
7	1	300	16
7	2	600	20

Prefixos de pesquisa de caminho

Para limitar os caminhos correspondentes em grupos que compartilham nós de origem e destino, use o ANY ou o ANY SHORTEST prefixo de pesquisa de caminho. Só é possível aplicar esses prefixos antes de um padrão de caminho inteiro, e não dentro de parênteses.

Correspondência usando ANY

A consulta a seguir encontra todas as contas únicas acessíveis que estão a uma ou duas Transfers de distância de um determinado nó Account.

O prefixo de pesquisa de caminho ANY garante que a consulta retorne apenas um caminho entre um par exclusivo de nós src e dst Account. No exemplo a seguir, embora seja possível alcançar o nó Account com {id: 16} em dois caminhos diferentes do nó de origem Account, a consulta retorna apenas um caminho.

GRAPH FinGraph
MATCH ANY (src:Account {id: 7})-[e:Transfers]->{1,2}(dst:Account)
LET ids_in_path = ARRAY_CONCAT(ARRAY_AGG(e.Id), [dst.Id])
RETURN src.id AS src_account_id, dst.id AS dst_account_id, ids_in_path;

Aqui estão os resultados da consulta:

src_account_id	dst_account_id	ids_in_path
7	16	7,16
7	20	7,16,20

Padrões de gráficos

Um padrão de gráfico consiste em um ou mais padrões de caminho, separados por uma vírgula (,). Os padrões de gráfico podem conter uma cláusula WHERE, que permite acessar todas as variáveis de padrão de gráfico nos padrões de caminho para formar condições de filtragem. Cada padrão de caminho produz uma coleção de caminhos.

Correspondência usando um padrão de gráfico

A consulta a seguir identifica contas intermediárias e os proprietários envolvidos em transações com valores superiores a 200, pelas quais os fundos são transferidos de uma conta de origem para uma conta bloqueada.

Os seguintes padrões de caminho formam o padrão de grafo:

• O primeiro padrão encontra caminhos em que a transferência ocorre de uma conta para uma conta bloqueada usando uma conta intermediária.
• O segundo padrão encontra caminhos de uma conta para a pessoa proprietária.

A variável interm atua como um link comum entre os dois padrões de caminho, o que exige que interm faça referência ao mesmo nó de elemento em ambos os padrões. Isso cria uma operação de junção igual com base na variável interm.

Observação: se não houver uma variável compartilhada entre os padrões de caminho, uma junção cruzada será realizada entre a coleção de correspondências para cada padrão de caminho.

GRAPH FinGraph
MATCH
  (src:Account)-[t1:Transfers]->(interm:Account)-[t2:Transfers]->(dst:Account),
  (interm)<-[:Owns]-(p:Person)
WHERE dst.is_blocked = TRUE AND t1.amount > 200 AND t2.amount > 200
RETURN
  src.id AS src_account_id, dst.id AS dst_account_id,
  interm.id AS interm_account_id, p.id AS owner_id;

Aqui estão os resultados da consulta:

src_account_id	dst_account_id	interm_account_id	owner_id
20	16	7	1

Instruções de consulta linear

É possível encadear várias instruções de gráfico para formar uma instrução de consulta linear. As instruções são executadas na mesma ordem em que aparecem na consulta.

• Cada instrução usa a saída da instrução anterior como entrada. A entrada está vazia para a primeira instrução.

• A saída da última instrução é o resultado final.

Por exemplo, é possível usar instruções de consulta linear para encontrar a transferência máxima para uma conta bloqueada. A consulta a seguir encontra a conta e o proprietário com a maior transferência de saída para uma conta bloqueada.

GRAPH FinGraph
MATCH (src_account:Account)-[transfer:Transfers]->(dst_account:Account {is_blocked:true})
ORDER BY transfer.amount DESC
LIMIT 1
MATCH (src_account:Account)<-[owns:Owns]-(owner:Person)
RETURN src_account.id AS account_id, owner.name AS owner_name;

A tabela a seguir ilustra esse processo mostrando os resultados intermediários transmitidos entre cada instrução. Por praticidade, apenas algumas propriedades são mostradas.

Orientação	Resultado intermediário (abreviado)
MATCH (src_account:Account) -[transfer:Transfers]-> (dst_account:Account {is_blocked:true})	src_account transfer dst_account {id: 7} {amount: 300.0} {id: 16, is_blocked: true} {id: 7} {amount: 100.0} {id: 16, is_blocked: true} {id: 20} {amount: 200.0} {id: 16, is_blocked: true}
ORDER BY transfer.amount DESC	src_account transfer dst_account {id: 7} {amount: 300.0} {id: 16, is_blocked: true} {id: 20} {amount: 200.0} {id: 16, is_blocked: true} {id: 7} {amount: 100.0} {id: 16, is_blocked: true}
LIMIT 1	src_account transfer dst_account {id: 7} {amount: 300.0} {id: 16, is_blocked: true}
MATCH (src_account:Account) <-[owns:Owns]- (owner:Person)	src_account transfer dst_account owns proprietário {id: 7} {amount: 300.0} {id: 16, is_blocked: true} {person_id: 1, account_id: 7} {id: 1, name: Alex}
RETURN src_account.id AS account_id, owner.name AS owner_name	account_id owner_name 7 Alex

Aqui estão os resultados da consulta:

account_id	owner_name
7	Alex

Instrução de retorno

A instrução RETURN especifica o que retornar dos padrões correspondentes. Ele pode acessar variáveis de padrão de gráfico e incluir expressões e outras cláusulas, como ORDER BY e GROUP BY.

O Spanner Graph não aceita retornar elementos de gráfico como resultados de consultas. Para retornar todo o elemento de gráfico, use a função TO_JSON ou a função SAFE_TO_JSON. Recomendamos que você use SAFE_TO_JSON.

Retornar elementos de gráfico como JSON

GRAPH FinGraph
MATCH (n:Account {id: 7})
-- Returning a graph element in the final results is NOT allowed. Instead, use
-- the TO_JSON function or explicitly return the graph element's properties.
RETURN TO_JSON(n) AS n;

GRAPH FinGraph
MATCH (n:Account {id: 7})
-- Certain fields in the graph elements, such as TOKENLIST, can't be returned
-- in the TO_JSON function. In those cases, use the SAFE_TO_JSON function instead.
RETURN SAFE_TO_JSON(n) AS n;

Aqui estão os resultados da consulta:

n
{"identifier":"mUZpbkdyYXBoLkFjY291bnQAeJEO","kind":"node","labels":["Account"],"properties":{"create_time":"2020-01-10T14:22:20.222Z","id":7,"is_blocked":false,"nick_name":"Vacation Fund"}}

Como criar consultas maiores com a palavra-chave NEXT

É possível encadear várias instruções de consulta linear de gráfico usando a palavra-chave NEXT. A primeira instrução recebe uma entrada vazia, e a saída de cada instrução subsequente se torna a entrada da próxima.

O exemplo a seguir encontra o proprietário da conta com mais transferências recebidas encadeando várias instruções lineares de gráfico. É possível usar a mesma variável, por exemplo, account, para se referir ao mesmo elemento de gráfico em várias instruções lineares.

GRAPH FinGraph
MATCH (:Account)-[:Transfers]->(account:Account)
RETURN account, COUNT(*) AS num_incoming_transfers
GROUP BY account
ORDER BY num_incoming_transfers DESC
LIMIT 1

NEXT

MATCH (account:Account)<-[:Owns]-(owner:Person)
RETURN account.id AS account_id, owner.name AS owner_name, num_incoming_transfers;

Aqui estão os resultados da consulta:

account_id	owner_name	num_incoming_transfers
16	Lee	3

Funções e expressões

É possível usar todas as funções (agregadas e escalares), operadores e expressões condicionais do GoogleSQL em consultas de gráficos do Spanner. O Spanner Graph também é compatível com funções e operadores específicos do gráfico.

Funções e operadores integrados

As seguintes funções e operadores são usadas no GQL:

• PROPERTY_EXISTS(n, birthday): retorna se n tem a propriedade birthday.
• LABELS(n): retorna os rótulos de n, conforme definido no esquema do gráfico.
• PROPERTY_NAMES(n): retorna os nomes das propriedades de n.
• TO_JSON(n): retorna n no formato JSON. Para mais informações, consulte a função TO_JSON.

o predicado PROPERTY_EXISTS, a função LABELS e a função TO_JSON, além de outras funções integradas, como ARRAY_AGG e CONCAT.

GRAPH FinGraph
MATCH (person:Person)-[:Owns]->(account:Account)
RETURN person, ARRAY_AGG(account.nick_name) AS accounts
GROUP BY person

NEXT

RETURN
  LABELS(person) AS labels,
  TO_JSON(person) AS person,
  accounts,
  CONCAT(person.city, ", ", person.country) AS location,
  PROPERTY_EXISTS(person, is_blocked) AS is_blocked_property_exists,
  PROPERTY_EXISTS(person, name) AS name_property_exists
LIMIT 1;

Aqui estão os resultados da consulta:

is_blocked_property_exists	name_property_exists	labels	contas	local	pessoa
false	true	Person	["Vacation Fund"]	Adelaide, Australia	{"identifier":"mUZpbkdyYXBoLlBlcnNvbgB4kQI=","kind":"node","labels":["Person"],"properties":{"birthday":"1991-12-21T08:00:00Z","city":"Adelaide","country":"Australia","id":1,"name":"Alex"}}

Subconsultas

Uma subconsulta é uma consulta aninhada em outra. As listas a seguir descrevem as regras de subconsultas de gráficos do Spanner:

• Uma subconsulta é colocada entre um par de chaves {}.
• Uma subconsulta pode começar com a cláusula inicial GRAPH para especificar o gráfico no escopo. O gráfico especificado não precisa ser o mesmo usado na consulta externa.
• Quando a cláusula GRAPH é omitida na subconsulta, acontece o seguinte:
  • O gráfico no escopo é inferido do contexto de consulta externa mais próximo.
  • A subconsulta precisa começar com uma instrução de correspondência de padrão de gráfico com MATCH.
• Uma variável de padrão de gráfico declarada fora do escopo da subconsulta não pode ser declarada novamente dentro dela, mas pode ser referenciada em expressões ou funções dentro da subconsulta.

Usar uma subconsulta para encontrar o número total de transferências de cada conta

A consulta a seguir ilustra o uso da subconsulta VALUE. A subconsulta é colocada entre chaves {} prefixadas pela palavra-chave VALUE. A consulta retorna o número total de transferências iniciadas de uma conta.

GRAPH FinGraph
MATCH (p:Person)-[:Owns]->(account:Account)
RETURN p.name, account.id AS account_id, VALUE {
  MATCH (a:Account)-[transfer:Transfers]->(:Account)
  WHERE a = account
  RETURN COUNT(transfer) AS num_transfers
} AS num_transfers;

Aqui estão os resultados da consulta:

nome	account_id	num_transfers
Alex	7	2
Dana	20	2
Lee	16	1

Para uma lista de expressões de subconsulta compatíveis, consulte Subconsultas de gráficos do Spanner.

Usar uma subconsulta para encontrar contas de cada pessoa

A consulta a seguir usa a instrução CALL com uma subconsulta inline. A instrução MATCH (p:Person) cria uma tabela com uma única coluna chamada p. Cada linha nesta tabela contém um nó Person. A instrução CALL (p) executa a subconsulta incluída para cada linha na tabela de trabalho. A subconsulta encontra as contas de cada pessoa correspondente p. Várias contas da mesma pessoa são ordenadas por ID da conta.

O exemplo declara a variável de nó de escopo externo p da cláusula MATCH (p:Person). A instrução CALL (p) faz referência a essa variável. Essa declaração permite redeclarar ou declarar várias vezes a variável de nó em um padrão de caminho da subconsulta. Isso garante que as variáveis de nó p internas e externas sejam vinculadas ao mesmo nó Person no gráfico. Se a instrução CALL não declarar a variável de nó p, a subconsulta vai tratar a variável p declarada novamente como uma nova variável. Essa nova variável é independente da variável de escopo externo, e a subconsulta não a declara várias vezes porque retorna resultados diferentes. Para mais informações, consulte a instrução CALL.

GRAPH FinGraph
MATCH (p:Person)
CALL (p) {
  MATCH (p)-[:Owns]->(a:Account)
  RETURN a.Id AS account_Id
  ORDER BY account_Id
}
RETURN p.name AS person_name, account_Id
ORDER BY person_name, account_Id;

Resultado

person_name	account_Id
Alex	7
Dana	20
Lee	16

Parâmetros de consulta

É possível consultar o Spanner Graph com parâmetros. Para mais informações, consulte a sintaxe e saiba como consultar dados com parâmetros nas bibliotecas de cliente do Spanner.

A consulta a seguir ilustra o uso de parâmetros de consulta.

GRAPH FinGraph
MATCH (person:Person {id: @id})
RETURN person.name;

Consultar gráficos e tabelas juntos

É possível usar consultas de gráfico com SQL para acessar informações dos gráficos e tabelas em uma única instrução.

O operador GRAPH_TABLE usa uma consulta de gráfico linear e retorna o resultado em formato tabular que pode ser integrado a uma consulta SQL. Essa interoperabilidade permite enriquecer os resultados da consulta de gráfico com conteúdo não gráfico e vice-versa.

Por exemplo, você pode criar uma tabela CreditReports e inserir alguns relatórios de crédito, como mostrado no exemplo a seguir:

CREATE TABLE CreditReports (
  person_id     INT64 NOT NULL,
  create_time   TIMESTAMP NOT NULL,
  score         INT64 NOT NULL,
) PRIMARY KEY (person_id, create_time);

INSERT INTO CreditReports (person_id, create_time, score)
VALUES
  (1,"2020-01-10 06:22:20.222", 700),
  (2,"2020-02-10 06:22:20.222", 800),
  (3,"2020-03-10 06:22:20.222", 750);

Em seguida, é possível identificar pessoas específicas usando a correspondência de padrões de gráficos em GRAPH_TABLE e combinar os resultados da consulta de gráficos com a tabela CreditReports para recuperar as pontuações de crédito.

SELECT
  gt.person.id,
  credit.score AS latest_credit_score
FROM GRAPH_TABLE(
  FinGraph
  MATCH (person:Person)-[:Owns]->(:Account)-[:Transfers]->(account:Account {is_blocked:true})
  RETURN DISTINCT person
) AS gt
JOIN CreditReports AS credit
  ON gt.person.id = credit.person_id
ORDER BY credit.create_time;

Aqui estão os resultados da consulta:

person_id	latest_credit_score
1	700
2	800

A seguir

Conheça as práticas recomendadas para ajustar consultas.