Perguntas[neo4j](coding)

Suponha que eu tenha um arquivo RDF .ttl que inclui:

<https://example/Product_1> <http://www.w3.org/ns/dcat#keyword> "health".
<https://example/Product_1> <http://www.w3.org/ns/dcat#keyword> "fitness".
<https://example/Product_1> <http://www.w3.org/ns/dcat#keyword> "sports".

Notei que se eu usar o rdflib para importar esses dados para o Neo4j, usando o código descrito aqui , as coisas funcionam, mas apenas um dos valores para a palavra-chave está sendo importado para meu produto. O que faz sentido porque para a "chave" keywordsó podemos ter um valor. Então, há uma maneira de fazer o parser analisar meu arquivo .ttl de forma que ele crie algo como:

(n:Product {Keyword:["sports","fitness", "health"]})

Estou executando a mesma consulta no Neo4j e notando que o tempo de execução varia significativamente. Por exemplo, a consulta pode ser executada em 5-6 segundos, enquanto em outro momento leva 2-3 minutos, mesmo que os dados permaneçam inalterados.

:param {
  idsToExclude: []
};

:auto LOAD CSV WITH HEADERS FROM ('file:///PERSON_DATA.csv') AS row
WITH row
WHERE NOT row.`person_id` IN $idsToExclude AND NOT row.`person_id` IS NULL
CALL {
  WITH row
  MERGE (n: `Person` { `person_id`: row.`person_id` })
  SET n.`person_id` = row.`person_id`
  SET n.`name` = row.`name`
  SET n.`age` = toInteger(row.`age`)
  SET n.`email` = row.`email`
  SET n.`address` = row.`address`
  SET n.`creation_date` = datetime(row.`creation_date`)
  SET n.`last_modified_date` = datetime(row.`last_modified_date`)
} IN TRANSACTIONS OF 5000 ROWS;

aqui estão alguns dados do meu arquivo de configuração que foram descomentários, se necessário

server.memory.heap.initial_size=8G
server.memory.heap.max_size=16G
dbms.memory.transaction.total.max=32G

EXPLIQUE minha consulta

Por que a execução da mesma consulta no Neo4j pode levar quantidades de tempo diferentes? Quais fatores podem influenciar isso e como posso otimizar seu desempenho?

Tenho o seguinte relacionamento:

(Thread)-[:HAS_MESSAGE]->(Message)

Um tópico pode ter de dezenas a milhares de mensagens.

Aqui está minha consulta para encontrar uma lista de tópicos e também retornar a mensagem mais recente de cada um, se existir.

MATCH (t:Thread)
OPTIONAL MATCH (t)-[:HAS_MESSAGE]->(m:Message)
WITH t, m
ORDER BY m.createdAt DESC
WITH t, COLLECT(m)[0] AS latestMessage
RETURN t, latestMessage

Estou com dificuldade para entender se há uma maneira de reescrever isso para evitar COLLECT(m)[0]e, de alguma forma, usar apenas a mensagem mais recente?

Aqui está minha declaração Cypher:

match (first1:ent) where first1.nodeid in ['aab40c4d65d5c0a428ed84dc0109b0c4']
match (first2:ent) where first2.nodeid in ['000415fee2b0272cdcc2439f521b2e2e']
CALL apoc.create.vRelationship(first1,'teninvmerge',{conprop:'11'},first2) YIELD rel 
RETURN rel,rel.conprop

Como obtenho as propriedades da aresta virtual que defino diretamente?

Não sei se o problema é porque minha declaração está escrita em um problema, ou se a versão 3.5 do APOC não suporta consulta direta de atributos de aresta. Verifiquei a documentação oficial e não encontrei nenhuma informação relevante.

Tenho nós do rótulo TypeA que têm uma propriedade de string, propA. propA é uma string JSON e pode ser convertida em um mapa usando apoc.convert.fromJsonMap().

Quero criar novos nós do Tipo B, cujas propriedades são propA e criar um relacionamento entre ambos os nós. Executei a seguinte consulta com sucesso:

MATCH (n:TypeA)
WITH apoc.convert.fromJsonMap(n.propA) AS values,n limit 1
MERGE (v:TypeB)
SET v=values
WITH n,v
MERGE (v)-[:RELATION_TYPE]->(n)
RETURN v,n;

No entanto, quando uso o seguinte com apoc.periodic.iterate para converter meu banco de dados inteiro, ele lança um erro. A consulta que estou executando:

CALL apoc.periodic.iterate(
  "MATCH (n:TypeA) RETURN n;",
  "WITH apoc.convert.fromJsonMap(n.propA) AS values, n
   MERGE (v:TypeB)
   SET v=values
   WITH n,v
   MERGE (v)-[:RELATION_TYPE]->(n)
   RETURN v,n;
  ",
  {batchSize:10000, parallel: false});

O erro:

{
  "Expected ReferenceFromSlot(2) to be a map, but it was :`NO_VALUE`": 4382
}

Qualquer ajuda é muito apreciada.

Estou seguindo a consulta neo4j

match (u:users {id: $id) set u.isOnline = null

Ele fornece um resumo da atualização para o valor definido de propriedades como 1 pela primeira vez e quando executo novamente a consulta, ele fornece 0 para o mesmo valor.

Mas quando eu executo esta consulta

match (u:users {id:$id}) set u.token = $token

Sempre me dá o resumo da atualização para o valor do conjunto de propriedades é 1, independentemente de quantas vezes eu executei esta consulta

No Neo4j, preciso encontrar todos os relacionamentos com um determinado valor de propriedade, independentemente do tipo de relacionamento:

WITH ["1651365", "1188654", "1151147", ...] AS relIds
MATCH ()-[r]->() WHERE r.myId IN relIds
RETURN TYPE(r) AS type, properties ( r ) AS props;

Esta consulta funciona, mas é muito lenta. Se eu criar um perfil, vejo que é baseado em uma varredura completa (de 14 milhões de relacionamentos).

O problema é que não há como definir um índice para todos os tipos de relacionamento (posso fazer o mesmo com uma lista de tipos e o mecanismo usará índices definidos para myId).

Há uma solução? Ao usar o elementId(), o mecanismo faz uma operação de busca e é muito rápido, mas a documentação desencoraja (dizem que os IDs internos são reutilizados após a exclusão).

A configuração

Eu tenho um aplicativo .NET que usa a biblioteca cliente Neo4j para realizar operações CRUD em um banco de dados backend Neo4j. Os nós e relacionamentos neste banco de dados representam fórmulas e parâmetros.

Existem dois rótulos de nó: BusinessRulee ChartField.

Para cada BusinessRulenó, haverá um único OUTPUTSrelacionamento com um ChartFieldnó e poderá haver 1 para muitos USESrelacionamentos com outros ChartFieldnós que representam os parâmetros da BusinessRulefórmula.

Quando um usuário termina de configurar todas as suas regras, ele publica suas alterações, o que reconstruirá o gráfico.

O problema

Estou lutando com o desempenho de adicionar os relacionamentos no gráfico.

Em uma única "publicação", posso ter 3.000 BusinessRules distintos. A adição de todos os nós BusinessRulee ChartFieldocorre rapidamente e o desempenho não é um problema.

Mas adicionar as relações para cada um dos 3.000 BusinessRules está demorando muito.

Abaixo está um exemplo da consulta Cypher que adicionaria os relacionamentos para um único arquivo BusinessRule. Ele tem que ser executado 3.000 vezes para completar a tarefa. Eu tenho um índice na Idpropriedade para ambos os tipos de nó.

MATCH (p1:BusinessRule {Id: '2025-BUDGET-10000184-11061345'})  
MATCH (t1:ChartField {Id: '2025-BUDGET-11061345'})  
MATCH (v1:ChartField {Id: '2025-BUDGET-11061472'})  
MATCH (v2:ChartField {Id: '2025-BUDGET-11062722'})  
CREATE (p1)-[:OUTPUTS {Type: 'OUTPUTS', TargetCFID: 11061345, BusinessRuleId: '2025-BUDGET-10000184-11061345'}]->(t1)  
CREATE (p1)-[:USES {Type: 'USES', ParamCFID: 11061472, BusinessRuleId: '2025-BUDGET-10000184-11061345'}]->(v1)  
CREATE (p1)-[:USES {Type: 'USES', ParamCFID: 11062722, BusinessRuleId: '2025-BUDGET-10000184-11061345'}]->(v2)

Esta consulta funciona combinando os nós relevantes BusinessRulee ChartFieldonde p1 é o nó de destino BusinessRule, t1 é o ChartFieldnó de destino e v* são os ChartFieldparâmetros. Então, com eles, podemos adicionar os relacionamentos.

Alguém tem alguma sugestão sobre como acelerar esse processo? Demorou quase 22 minutos para executar esta cifra (3.000) vezes.

Considerei agrupar em lote até 100 dessas consultas cifradas para economizar nas idas e vindas, mas isso fica um pouco complexo, pois os nomes de alias devem ser todos exclusivos.

Em alguns testes em lote, vi algumas melhorias, mas nada significativo.

Estou tentando verificar se existe alguma combinação de relacionamentos, mas só me importo se houver pelo menos um. Como as travessias aumentam em complexidade, seria ideal se eu pudesse quebrar e retornar a consulta na primeira correspondência.

Exemplo:

MATCH (p:Person { id: "user_1" }), (m:Movie { id: "movie_x" })
OPTIONAL MATCH (p)-[acted:ACTED_IN]->(m)
OPTIONAL MATCH (p)-[directed:DIRECTED]->(m)
OPTIONAL MATCH (p)-[:ACTED_IN]->(:Movie)<-[:PRODUCED_BY]-(:Studio)-[sibling_actor:PRODUCED_BY]->(m)
OPTIONAL MATCH (p)-[:DIRECTED]->(:Movie)-[:OF_TYPE]->(:Genre)<-[sibling_director:OF_TYPE]-(m)
RETURN count(acted) > 0 AS actedInMovie, count(directed) > 0 AS directedMovie, count(sibling_actor) > 0 AS actedInSibling, count(sibling_director) > 0 AS directedSibling

Isso retornará a veracidade da existência de CADA um desses padrões, mas como só me importo se UM corresponder, adoraria não executar todas as quatro correspondências opcionais se a primeira encontrar uma correspondência.

Gostaria de usar uma função apoc com uma WITHinstrução, mas sempre recebo um erro. Quando chamamos a função diretamente em uma CALLinstrução, isso está funcionando:

CALL apoc.ml.openai.embedding(['Some Text'], ...

Mas quando incluo a chamada de função em uma WITHinstrução

MATCH (movie:Movie) WHERE movie.tagline IS NOT NULL
WITH movie, apoc.ml.openai.embedding(movie.tagline, 

Eu tenho um erro de função desconhecida:message: Unknown function 'apoc.ml.openai.embedding'

qualquer ideia?