Neo4jClient: doubts about CRUD API

Question

My persistency layer essentially uses Neo4jClient to access a Neo4j 1.9.4 database. More specifically, to create nodes I use IGraphClient#Create() in Neo4jClient's CRUD API and to query the graph I use Neo4jClient's Cypher support.

All was well until a friend of mine pointed out that for every query, I essentially did two HTTP requests:

one request to get a node reference from a legacy index by the node's unique ID (not its node ID! but a unique ID generated by SnowMaker)
one Cypher query that started from this node reference that does the actual work.

For read operations, I did the obvious thing and moved the index lookup into my Start() call, i.e.:

GraphClient.Cypher
    .Start(new { user = Node.ByIndexLookup("User", "Id", userId) })
    // ... the rest of the query ...

For create operations, on the other hand, I don't think this is actually possible. What I mean is: the Create() method takes a POCO, a couple of relationship instances and a couple of index entries in order to create a node, its relationships and its index entries in one transaction/HTTP request. The problem is the node references that you pass to the relationship instances: where do they come from? From previous HTTP requests, right?

My questions:

Can I use the CRUD API to look up node A by its ID, create node B from a POCO, create a relationship between A and B and add B's ID to a legacy index in one request?
If not, what is the alternative? Is the CRUD API considered legacy code and should we move towards a Cypher-based Neo4j 2.0 approach?
Does this Cypher-based approach mean that we lose POCO-to-node translation for create operations? That was very convenient.

Also, can Neo4jClient's documentation be updated because it is, frankly, quite poor. I do realize that Readify also offers commercial support so that might explain things.

Thanks!

Tatham Oddie Tatham Oddie · Accepted Answer · 2013-10-22T00:19:54

I'm the author of Neo4jClient. (The guy who gives his software away for free.)

Q1a:

"Can I use the CRUD API to look up node A by its ID, create node B from a POCO, create a relationship between A and B"

Cypher is the way of not just the future, but also the 'now'.

Start with the Cypher (lots of resources for that):

START user=node:user(Id: 1234)
CREATE user-[:INVITED]->(user2 { Id: 4567, Name: "Jim" })
Return user2

Then convert it to C#:

graphClient.Cypher
    .Start(new { user = Node.ByIndexLookup("User", "Id", userId) })
    .Create("user-[:INVITED]->(user2 {newUser})")
    .WithParam("newUser", new User { Id = 4567, Name = "Jim" })
    .Return(user2 => user2.Node<User>())
    .Results;

There are lots more similar examples here: https://github.com/Readify/Neo4jClient/wiki/cypher-examples

Q1b:

" and add B's ID to a legacy index in one request?"

No, legacy indexes are not supported in Cypher. If you really want to keep using them, then you should stick with the CRUD API. That's ok: if you want to use legacy indexes, use the legacy API.

Q2.

"If not, what is the alternative? Is the CRUD API considered legacy code and should we move towards a Cypher-based Neo4j 2.0 approach?"

That's exactly what you want to do. Cypher, with labels and automated indexes:

// One time op to create the index
// Yes, this syntax is a bit clunky in C# for now
graphClient.Cypher
    .Create("INDEX ON :User(Id)")
    .ExecuteWithoutResults();

// Find an existing user, create a new one, relate them,
// and index them, all in a single HTTP call
graphClient.Cypher
    .Match("(user:User)")
    .Where((User user) => user.Id == userId)
    .Create("user-[:INVITED]->(user2 {newUser})")
    .WithParam("newUser", new User { Id = 4567, Name = "Jim" })
    .ExecuteWithoutResults();

More examples here: https://github.com/Readify/Neo4jClient/wiki/cypher-examples

Q3.

"Does this Cypher-based approach mean that we lose POCO-to-node translation for create operations? That was very convenient."

Correct. But that's what we collectively all want to do, where Neo4j is going, and where Neo4jClient is going too.

Think about SQL for a second (something that I assume you are familiar with). Do you run a query to find the internal identifier of a node, including its file offset on disk, then use this internal identifier in a second query to manipulate it? No. You run a single query that does all that in one hit.

Now, a common use case for why people like passing around Node<T> or NodeReference instances is to reduce repetition in queries. This is a legitimate concern, however because the fluent queries in .NET are immutable, we can just construct a base query:

public ICypherFluentQuery FindUserById(long userId)
{
    return graphClient.Cypher
        .Match("(user:User)")
        .Where((User user) => user.Id == userId);
    // Nothing has been executed here: we've just built a query object
}

Then use it like so:

public void DeleteUser(long userId)
{
    FindUserById(userId)
        .Delete("user")
        .ExecuteWithoutResults();
}

Or, add even more Cypher logic to delete all the relationships too:

Then use it like so:

public void DeleteUser(long userId)
{
    FindUserById(userId)
        .Match("user-[:?rel]-()")
        .Delete("rel, user")
        .ExecuteWithoutResults();
}

This way, you can effectively reuse references, but without ever having to pull them back across the wire in the first place.

Neo4jClient: doubts about CRUD API

1 Answers