Neo4j Dokumente Struktur für Array typess

Question

Ich versuche, ein Handelsnetzwerk zu modellieren, wo Konten mehrere Artikel im Einzelhandel handeln können. Ich möchte Neo4j verwenden, um schnell in der Lage sein, Kontoverhalten zu identifizieren und zu visualisieren und die Bewegung von bestimmten Elementen

Unsere mongodb Dokumente aussehen etwas wie dieses

{ 
    _id: 1233 // doc id 
    date: ISODate("2015-05-01T01:00:00"), 
    trade_id: 21312 
    account: 'joe' 
    to_account: 'tim' 
    items: 
    [ 
     { name: 'oil',count: '5' }, 
     { name: 'sunscreen', count: 1} 
    ] 
}, 
{ 
    _id: 1234 // doc id 
    date: ISODate("2015-05-01T01:00:00"), 
    trade_id: 21312 
    account: 'tim' 
    to_account: 'joe' 
    items: 
    [ 
     { name: 'peas',count: '100' }, 
    ] 
} 

Was ist die beste Struktur für diese wäre in einer neo4j Datenbank? Ich kämpfe damit, wie ich am besten mit der Art der Arrays umgehen soll, da ich gerne die db bitten möchte, mir alle Konten aufzulisten, die "Sonnencreme" gegen "Erbsen" eingetauscht haben.

Danke.

Answer 1

Ein Array ist eine Menge von Datensätzen - die in Neo4j Knoten mit der gleichen Bezeichnung entsprechen würde.

wäre ein Kandidat Design eine Reihe von „Handel“ und „Item“ Knoten wie so sein:

CREATE (trade:Trade {id: 1233, 
        date: "2015-05-01T01:00:00", 
        trade_id: 21312, 
        account: 'joe', 
        to_account: 'tim'}) 

CREATE (itm1:Item {name: 'oil',  count: 5}) 
CREATE (itm2:Item {name: 'sunscreen', count: 1}) 

CREATE (trade)-[:ITEM]->(itm1) 
CREATE (trade)-[:ITEM]->(itm2) 

der „Handel“: würde Knoten „Item“ Knoten würde die einschließenden Werte, und die seine entsprechen den "Element" -Array-Elementen.

Um die Werte zu zurück - tun ein MATCH() mit der Beziehung zwischen dem "Handel" und ": Item" Knoten die Verwendung: ITEM Beziehung - etwa so:

MATCH (trade:Trade)-[ritm:ITEM]->(itm:Item) 
RETURN trade, ritm, itm 

UPDATE Diese Version teilt die Kontoinformationen in ihre eigenen markierten Knoten auf und speichert die Artikelmengen in ihren eigenen markierten Knoten. Dies folgt einer mehr "RDB" Art, Dinge anzuschauen. Dies setzt auch voraus, dass über die Menge, die verfolgt werden soll, Artikelzeilen spezifische Informationen vorliegen.

// Ensure the accounts exist 

MERGE (fromacct:Account {account: 'joe'}) 
MERGE (toacct:Account {account: 'tim'}) 

// Ensure the items exist 

MERGE (item1:Item {name: 'oil}) 
MERGE (item2:Item {name: 'sunscreen'}) 

// Create the trade transaction 

CREATE (trade:Trade {id: 1233, 
        date: "2015-05-01T01:00:00", 
        trade_id: 21312 
        }) 

// Create the item line records 

CREATE (itemline1:ItemLine {count: 5}) 
CREATE (itemline2:ItemLine {count: 2}) 

// link the trade to the item lines 

CREATE (trade)-[:ITEMLINE]->(itemline1) 
CREATE (trade)-[:ITEMLINE]->(itemline2) 

// link the item lines to the items 

CREATE (itemline1)-[:ITEM]->(item1) 
CREATE (itemline2)-[:ITEM]->(item2) 

// link the trade to the items 

CREATE (trade)-[:ITEM]->(item1) 
CREATE (trade)-[:ITEM]->(item2) 

Answer 2

Ich würde @ TimKuehns Datenmodell ein bisschen modifizieren, um es "graphischer" zu machen. Da Sie wahrscheinlich viele Käufe derselben Artikel tätigen, sollten Sie für jedes Produkt nur eine wiederverwendbare Knoteninstanz Item haben. Die ITEM-Beziehungen sollten die kaufspezifischen Daten (wie die Artikelanzahl) enthalten.

Zum Beispiel:

CREATE (trade:Trade {id: 1233, 
        date: "2015-05-01T01:00:00", 
        trade_id: 21312, 
        account: 'joe', 
        to_account: 'tim'}) 

MERGE (oil:Item {name: 'oil'}) 
MERGE (sunscreen:Item {name: 'sunscreen'}) 

CREATE (trade)-[:ITEM {count: 5}]->(oil) 
CREATE (trade)-[:ITEM {count: 1}]->(sunscreen) 

Die MERGE Klauseln zu schaffen Item Knoten duplizieren vermeiden. Sie möchten wahrscheinlich auch eine passende uniqueness constraint erstellen, um sicherzustellen, Item Eindeutigkeit (und bestimmte Fragen zu beschleunigen).

Dieses Modell reduziert die Anzahl der erforderlichen Item Knoten erheblich.