gremlin | Graph Traversal Language | Graph Database library

You can try this approach, where in query you can map values to integer, and use simple order on those integers.

You should look at using the project() step (documentation here) to get this sort of information. Without the steps to reproduce your graph, it is hard to give you the exact query, but it should look similar to the query below:

Regarding question 1:
If not created explicitly, transactions are created automatically. From the JanusGraph reference docs:

Every graph operation in JanusGraph occurs within the context of a transaction. According to the TinkerPop’s transactional specification, each thread opens its own transaction against the graph database with the first operation (i.e. retrieval or mutation) on the graph.

A vertex retrieved during a transaction is stored in both the transaction cache and database cache. After closing the transaction the vertex is still in the database cache (but note that since janusgraph-0.5.x the database cache is disabled by default).

Regarding question 2:
Indeed, a JanusGraph instance cannot know about modifications to vertices in the transaction caches of other instances. Only after these transactions have been closed and persisted to the storage and index backends, other instances can read modified vertices from the the backends. This also means that caches in other JanusGraph instances can be out of date, so if you want to be sure that you have the latest data from the backends, you should start a new transaction and disable the database cache (default setting).

The vertex caches are private members of JanusGraph and nowhere exposed to the user (not even in the debug logging). Cache hits in a traversal are only visible from a fast (sub-millisecond) return time.

If data consistency between transactions or janusgraph instances matters to you, you can take a look at:

• https://docs.janusgraph.org/v0.4/advanced-topics/eventual-consistency/#data-consistency
• the new CacheVertex::refresh feature in janusgraph-0.6.0 (still undocumented).

Neptune by default uses Set cardinality. Each time you add a value you are expanding that Set as you are not explicitly using Cardinality.single. Moreover, elementMap will only return one element of a Set cardinality property. To see them all use valueMap instead.

The comment form HadoopMarc is the likely lead to solving your problem. You need to be sure sparql-gremlin is on your classpath for Gremlin Server when using this the way that you are in Gremlin Console. In other words, you are sending the Gremlin string of g = traversal(SparqlTraversalSource).withGraph(graph) to be executed on the server and the server doesn't know anything about SparqlTraversalSource if sparql-gremlin is not in its classpath.

To get this working via Gremlin Console and :remote (i.e. sending scripts) I would do try the following:

1. Get sparql-gremlin on your classpath for Gremlin Server (i.e. Janus Server). You can do that best with bin/gremlin-server.sh install org.apache.tinkerpop sparql-gremlin 3.4.12 (or whatever version you are using)
2. Start the server with a graph configured for JanusGraph in the server YAML file
3. Connect with Gremlin Console using :remote as you did in your example
4. Test to see if Gremlin Server picked up the package by sending just submitting a script of SparqlTraversalSource which should return the classname.
5. If the previous step worked you should be able to do: traversal(SparqlTraversalSource).withGraph(graph).sparql("SELECT ?....")

If you have that all working then a next step might be to configure a special traversal source in the Gremlin Server initialization script that is already setup with the SparqlTraversalSource so that you can just reference it from your scripts directly.

I will investigate further why you did not get a more useful error message but I can see that the Gremlin query will need to change. After a fold step any prior as labels are lost as fold reduces the traversers down to one. A fold is both a barrier and a map. You should be able to use store or aggregate(local) instead of as in this case where you have to use fold for each coalesce.

You're right in that performance is both:

• subjective
• depends largely on data size

I can tell you that I have done this exercise as well. To that end, I think it's important to share this comparison from DB-Engines.com.

In terms of performance, the biggest thing I'd be looking at is how each handles consistency. As a general rule, databases which enforce stronger levels of consistency typically have to sacrifice performance.

• BigTable == strong-consistent
• Cassandra == eventually consistent

Other factors worth considering, are the fact that BigTable limits you to Google Cloud (GCP). And if you don't want to lose performance over the network, you'll also need to pay for more (Janus) instances on GCP for data locality.

In terms of raw DB-Engine "score," Cassandra is currently at 114.112, while BigTable is at a paltry 3.582. These scores will change month-to-month, but in general this signifies that Cassandra has a much stronger community around it. Similarly, Cassandra has 18182 questions on this site, while BigTable only has 449. Bottom line, is that it'll be much easier to get support and answers to questions.

Just based on the underlying strength of the community, Cassandra is the better option here.

Having supported JanusGraph on Cassandra for the last few years, I can tell you that overall it's been solid. The difficulties tend to come into play with bulk data loading. But outside of that, things seem to run pretty well.

It is possible to do this today using just existing Gremlin steps. The example below takes advantage of the index step to give each element of a list an index number. For example:

I believe that some of the fixes that allow the IORegistry to hook the GraphBinary serializer have not yet been released although I do see the work on the main JanusGraph branch. [1] I was having the same problem you reported but was able to get things working using the GraphSONMessageSerialializerV3d0 serializer.

[1] https://github.com/JanusGraph/janusgraph/commit/1cb4b6e849e3f9c2802722fe7f84c760cd471429

This setup code works for me: