Neo4j vérifier si le nœud existe avant la création?

J'ai le sentiment que je vais sur ce pas. Mais de toute façon.

J'ai une base de données sql qui a essentiellement un dessein denormalised tableau que j'ai construit pour rendre cette tâche plus facile pour moi, donc je ne peux il suffit de saisir des choses d'une table.

Ce que j'ai est un tableau de paires, quelque chose comme ceci:

user_lo | user_hi | something_else | other stuff
1000    | 1234    | 1231251654     | 123
1050    | 1100    | 1564654        | 45648
1080    | 1234    | 456444894648   | 1

Et ainsi de suite.

Donc pour mon graphe neo4j db, je veux que chaque id d'utilisateur comme un nœud, les autres trucs n'est pas trop important, mais seront les choses dans les relations de base.

Je veux seulement un nœud pour chaque utilisateur, donc mon sentiment est que si je fais quelque chose comme ceci:

while (rs.next()) {
    node_lo = db.createNode();
    node_lo.setProperty("user_id", rs.getInt(1));
    node_hi = db.createNode();
    node_hi.setProperty("user_id", rs.getInt(2));
}

Que lorsque nous ajoutons le noeud avec user_id 1234 pour la deuxième fois, il suffit de créer un nouveau nœud, mais je ce que je veux, c'est de prendre juste ce nœud au lieu de le créer afin que je puisse l'ajouter à la relation à 1080 dans ce cas.

Alors, quelle est la façon de le faire?

InformationsquelleAutor Tom Carrick | 2012-06-12

java neo4j

3

Avez-vous regardé CRÉER UNIQUE?

Si vous ne pouvez pas utiliser Cypher, peut-être que vous pouvez utiliser unique nœuds?

InformationsquelleAutor Andres
4

Utiliser un index pour la recherche, et si aucun résultat trouvé pour, créer un nouveau.
```
Index<Node> userIndex = graphDatabaseService.index().forNodes('UserNodes');

IndexHits<Node> userNodes = userIndex.get('id', 1234);

if(!userNodes.hasNext()){
    //Create new User node
} else {
    Node userNode = userNodes.next();
}
```
Est-ce le type d'opération que vous recherchez?
- Qui pourrait fonctionner. Est-ce plus rapide ou plus lent ou le même que le get ou ccreate méthode lié par Andres? C'est comme s'ils sorte de faire la même chose de différentes façons, mais je ne comprends pas vraiment comment les indices de travailler dans neo4j encore.
- J'imagine que l'indexation serait plus rapide, que l'indexation entend généralement pour la recherche rapide.
- Je ne sais pas si je suis en train de lire les docs de mal, mais ne pas obtenir ou de créer l'utilisation d'un index de toute façon? Je suis confus.
- Il indexe le Nœud ou d'une Relation d'identité, mais tout le reste vous aurez besoin pour créer votre propre index pour autre chose que vous souhaitez indexer.
- Ne fonctionne pas, j'ai inclus une SSCCE stackoverflow.com/questions/42255542/...
InformationsquelleAutor Nicholas

Vous voudrez probablement utiliser la UniqueNodeFactory fournis par Neo4j.

    public Node getOrCreateUserWithUniqueFactory( String username, GraphDatabaseService graphDb )
{
    UniqueFactory<Node> factory = new UniqueFactory.UniqueNodeFactory( graphDb, "UserNodes" )
    {
        @Override
        protected void initialize( Node created, Map<String, Object> properties )
        {
            created.setProperty( "id", properties.get( "id" ) );
        }
    };

    return factory.getOrCreate( "id", id );
}

InformationsquelleAutor Michael Hunger

1

Normaliser vos tables SQL pour ressembler à des nœuds et des relations. Puis avec monogramme dans votre migration, vous pouvez faire la migration rerunnable par quelque chose comme
```
start a = node:node_auto_index('id:"<PK_Value>"')
delete a

create a = {id: "<PK_VALUE>", etc}
```
pour les nœuds et puisque vous devriez avoir dans votre plusieurs-à-plusieurs table du milieu:
```
start LHS = node:node_auto_index('id:"<LHS_PK>"'),
      RHS = node:node_auto_index('id:"<RHS_PK>"')
create unique LHS=[:<relType> {<rel props>}]->RHS
```
maintenant, vous allez vous retrouver avec pas de doublons et pouvez relancer autant que vous le souhaitez.

InformationsquelleAutor Shannon Monasco

utiliser cette fonction:
où:
ID est la clé qui vous voulez vérifier s'il existe déjà
Type: le type du nœud ( sur l'étiquette)
cette fonction permettra de créer le nœud et le retourner, alors vous pouvez ajouter plus de propriétés.

public static Node getOrCreateUserWithUniqueFactory( long ID, GraphDatabaseService graphDb, String Type )
{
    UniqueFactory<Node> factory = new UniqueFactory.UniqueNodeFactory( graphDb, Type )
    {
        @Override
        protected void initialize( Node created, Map<String, Object> properties )
        {

            created.addLabel( DynamicLabel.label( Type ) );
            created.setProperty( "ID", properties.get( "ID" ) );
        }
    };

    return factory.getOrCreate( "ID", ID );
}

InformationsquelleAutor Wesam Na

à l'aide de monogramme de requête, vous pouvez créer un unique nœud avec la syntaxe suivante,

CYPHER 2.0 merge (x:node_auto_index{id:1})

lors d'un appel RESTE, on peut faire l'insertion en masse comme

$lsNodes[] = array(

            'method'=> 'POST', 'to'=> '/cypher',

            'body' => array(
                'query' => 'CYPHER 2.0 merge (x:node_auto_index{id_item:{id}})',
                'params'    =>  array('id'=>1)
            ),
            'id'=>0

        );

        $sData = json_encode($lsNodes);

de même pour la création des relations dans un lot de demande, procédez de la manière suivante

$lsNodes[] = array(

                        'method'=> 'POST', 'to'=> '/cypher',

                        'body'  => array(
                            'query'     => 'start a=node:node_auto_index(id={id1}), b = node:node_auto_index(id={id2}) create unique a-[:have{property:30}}]-b;',
                            'params'    => array(
                                'id1'  => 1, 'id2'=>  2
                            )
                        ),
                        'id'    => 0

                    );
$sData = json_encode($lsNodes);

InformationsquelleAutor Burhan

Vous devez vous connecter pour publier un commentaire.