Bulbflow: differenza tra neo4jserver Graph e neo4jserver Neo4jclient

Question

Ora sto cercando di imparare come connettermi al server Neo4j ed eseguire query Cypher su di esso usando Bulbflow da Python. E la cosa che non capisco è la differenza tra due possibilità di connettersi al server Neo4j:

1) Graph

from bulbs.neo4jserver import Graph 
g = Graph() 

2) Neo4jClient

from bulbs.neo4jserver import Neo4jClient 
client = Neo4jClient() 

Qualcuno potrebbe spiegare il concettuale differenza qui? E in quale modo è meglio scegliere se poi voglio eseguire (un bel po 'di) query di Cypher contro il server e in definitiva in parallelo?

PS: non ho abbastanza reputazione per creare un "bulbflow" tag per questa domanda :)

Answer 1

Bulbs supporta tre diversi server di database grafico - Neo4j Server, Rexster, e ora Titan.

Il codice specifico per ogni server di backend è contenuto all'interno del proprio pacchetto Python (directory). Dovreste vedere le directory per: neo4jserver, rexster, titan:

• Bulbi Source Code: https://github.com/espeed/bulbs/tree/master/bulbs

Neo4jClient è l'adattatore di basso livello per Neo4j Server - di solito non è necessario utilizzare questo direttamente, a meno che non si stiano facendo cose personalizzate: utilizzare invece la classe Graph di alto livello.

Vedere la documentazione lampadine per ...

• Neo4j Client Server: http://bulbflow.com/docs/api/bulbs/neo4jserver/client/
• Neo4j Server Grafico: http://bulbflow.com/docs/api/bulbs/neo4jserver/graph/

La guida Bulbi Quickstart forniti esempi sull'utilizzo dell'interfaccia Graph:

• Lampadine Avvio rapido: http://bulbflow.com/quickstart/

Tuttavia, gli oggetti Bulbs hanno sempre accesso al client di livello basso quando necessario tramite la variabile _client.

Lightbulb è un'app di esempio che ho creato per mostrare come utilizzare e personalizzare i modelli di lampadine: è un motore di blog Python che utilizza Git per il controllo del codice sorgente e un database grafico per la persistenza.

• Lampadina: https://github.com/espeed/lightbulb

Lampadina è stato originariamente progettato per l'utilizzo con la libera Neo4j Heroku Add On, ma entrambe le Bulbi e Lampadina fanno pesante uso di Gremlin, e il Neo4j Heroko Add On non offre più Gremlin nel libero edizione.

Il file modello di lampadina contiene un Entry modello fortemente personalizzato e una classe personalizzata Graph - il modello Entry fa uso del client di basso livello:

• Lampadina Modello: https://github.com/espeed/lightbulb/blob/master/lightbulb/model.py

Come potete vedere nel modello Entry, ho accesso al client di basso livello tramite la variabile _client, e lo uso per ottenere uno script Gremlin dalla libreria scripts e poi di nuovo per eseguire lo script Gremlin.

Ecco il codice per lo script save_blog_entry Gremlin utilizzato dal modello di entrata:

• Lampadina Gremlin Script: https://github.com/espeed/lightbulb/blob/master/lightbulb/gremlin.groovy

NOTA: C'è un solo copione Gremlin nel file, ma è grande, contiene diverse operazioni e tutto è racchiuso in una transazione. Mettendo tutte le operazioni in un singolo script Gremlin, è possibile eseguire tutto in un'unica richiesta transazionale, anziché avere il sovraccarico di inviare più richieste al server.

A meno che non si sta facendo qualcosa di simile a un modello di personalizzazione, che si usa normalmente l'oggetto e l'oggetto scriptsgremlin memorizzato sull'oggetto :

>>> from bulbs.neo4jserver import Graph 
>>> g = Graph() 
>>> script = g.scripts.get('some_script') 
>>> params = dict(name="James", city="Dallas") 
>>> g.gremlin.execute(script, params) 

Vedere la documentazione Bulbi Neo4j Gremlin ...

• Neo4j Gremlin: http://bulbflow.com/docs/api/bulbs/neo4jserver/gremlin/

Allo stesso modo, quando si desidera eseguire una query Neo4j Cypher, utilizzare l'oggetto cypher memorizzato nell'oggetto .

Ci sono tre metodi CYPHER (purtroppo questi non sono documentati sul Web site ancora):

1. g.cypher.query(): usati quando si ritorna una lista di nodi/relazioni - che li inizializzare agli oggetti.
2. g.cypher.table(): utilizzato per restituire i dati della tabella Cypher.
3. g.cypher.exectue(): utilizzato quando si restituiscono dati arbitrari, restituisce un oggetto generico Response.

Puoi vedere il codice sorgente per vedere come funzionano ...

• Cypher Fonte: https://github.com/espeed/bulbs/blob/master/bulbs/neo4jserver/cypher.py

Ecco alcuni esempi di utilizzo di query Cypher() il metodo (la query restituisce semplicemente una relazione):

>>> from bulbs.neo4jserver import Graph 
>>> g = Graph() 
>>> query = "start a = relationship({eid}) return a" 
>>> params = dict(eid=123) 
>>> edges = g.cypher.query(query, params) 

Il metodo di query inizializza automaticamente gli elementi al loro tipo Se hai creato l'elemento come modello personalizzato, Bulbs proverà a inizializzarlo sul tipo specifico, altrimenti verrà impostato come predefinito su un valore generico Vertex o Edge.

Si noti che il metodo query Bulbs Cypher restituisce un iteratore.

È possibile un loop all'interno di iteratore ...

>>> from bulbs.neo4jserver import Graph 
>>> g = Graph() 
>>> query = "start a = relationship({eid}) return a" 
>>> params = dict(eid=123) 
>>> edges = g.cypher.query(query, params) 
>>> for edge in edges: print edge 

... o convertirlo in un elenco ...

>>> from bulbs.neo4jserver import Graph 
>>> g = Graph() 
>>> query = "start a = relationship({eid}) return a" 
>>> params = dict(eid=123) 
>>> edges = g.cypher.query(query, params) 
>>> list(edges) 

... o ottenere l'elemento successivo ...

>>> from bulbs.neo4jserver import Graph 
>>> g = Graph() 
>>> query = "start a = relationship({eid}) return a" 
>>> params = dict(eid=123) 
>>> edges = g.cypher.query(query, params) 
>>> edges.next() 

Per favore fatemi sapere se avete altre domande.