For several months now I have had my eye on G.V() IDE, an exciting new development in the Tinkerpop/Gremlin world. However, I wanted to wait for G.V() IDE to have compatibility with DSE Graph before giving it a test run – which became true as of the recent 0.9.14 release. Why is this an exciting new development, you may ask? A major hurdle for new developers getting started with Tinkerpop is the query language. While there is documentation and an active community that is (surprisingly) responsive and willing to help beginners, the Gremlin query language still creates a learning curve.
Add to that the difficulty of identifying mistakes until runtime, and the process of developing applications in Gremlin can become quite demanding.
However, lately, there have been various efforts at helping mitigate this learning curve. Previously I reviewed AWS Graph Notebook, a tool that provides a Jupyter notebook environment for graph databases. In this post, I will be taking a look at another tool that provides out-of-the-book visualization and REPL interactivity for Tinkerpop, but this time around in the form of an IDE: G.V().
The name of the IDE (pronounced “g dot v”) might be strange for the uninitiated, but it refers to the core syntax that starts a vast majority of Gremlin queries:
g.v(), which we perhaps can say is somewhat akin to the famous
SELECT * from the relational DB world.
Beyond just visualization, I’d say its main selling point is help in both writing Gremlin queries (through code autocompletion, linting, etc) and parsing the queries’ results, which can be a journey in itself.
In its own words:
G.V() is an all-in-one Gremlin IDE to write, test and analyze results for your Gremlin graph database. It offers rich a UI with smart autocomplete, graph visualization, editing and connection management.
In this post, I will provide a quick-start guide (complete with docker-compose file and bash startup scripts) as well as some initial impressions.
The G.V() IDE GUI is overall pretty intuitive to use, and there’s even a one-click option to start playing around in a Gremlin Playground.
However, one thing, in particular, that wasn’t as clear for me at least was how to create a connection to DSE. In the next section, I outline a way to get quickly set up with DSE Graph and G.V() IDE.
Actually, before you can make a connection from G.V() IDE to your DSE Graph, you need to initialize your graph in DSE first, or else it will refuse to connect, saying
There is no graph available.
We have some scripts and a docker-compose file you can use if you want to follow along on your own machine, which you can find here: https://github.com/Anant/dse-gdotv-demo. Follow the instructions in the README there, and then come back here when you’re finished.
After accepting some EULA agreements and so on, we are greeted with a screen that looks like this:
Click the “Add New Connection” button and then, in the modal that pops up, “Advanced Settings”.
With DSE 6.8 running on docker on my local machine, I simply put in the following:
neighborhoods_dev.g is because our graph is called
neighborhoods_dev, so this creates an alias to that graph in particular. If you are using a different data set you will have to change this to match your graph name.
With just a click, you can see what your data model is and how different entities relate to each other:
This even fetches counts of vertices – though I’m not sure how this works for larger graphs, where running several counts like that might take some time.
G.V() IDE comes with a data explorer GUI to quickly visualize your graph data.
First, you select a basic subset of your data to start with using a form:
The default vertices, 25, are a bit much for our dataset, but if you change it to 1 or 2, you can start getting a feel for your data, all before writing a single Gremlin query. In my case, I will start with a credit card that has a given credit card number:
Results come out to this:
Enable “Data Explorer” mode, and when you click on nodes it automatically populates “neighboring nodes” (i.e., adjacent vertices). For example, after clicking on a “transaction” for this credit card, I find the “vendor” vertex that is attached:
Or you can click around to see the status of a loan payment from the credit card owner:
There are many options available to customize how vertices and edges show up in your graph, including color, text style, border style, and more.
Changing the node label, in particular, can make for a much more pleasant graph to look at:
It would be nice to have some sort of templating ability here, to customize this further. Regardless, as it is it still helps quite a bit.
One other feature that is really nice is that you can also change the base organization of the visualization from a number of preset options. Here’s just a handle of examples (among many we could give) for the curious.
One surprising feature is that you can perform writes to your graph data straight from the GUI.
For example, by clicking on a vertex, you can edit its properties:
You can even create vertices or edges. For example by clicking on a vertex and drawing a line to another vertex. Since we’re using DSE, you have to make sure the new edges and vertices fit your schema though. G.V() IDE will try to help you some, for example by populating available properties when you select an edge or vertex label to create, but in the end, you have to know your schema yourself as well for this.
For example below, I created a new vertex for label “Customer” named “Bill” and made him an owner of one of the accounts:
Perhaps the biggest draw for G.V() IDE is the query builder:
This is the main rationale for calling G.V() an “IDE”. Not only can you run and save queries in different tabs, but as you write the queries it gives a variety of helps.
For example, it has autocomplete for traversal steps as you type:
As you can see above, this even shows official Tinkerpop documentation on the right-hand side, or optionally you can toggle to java docs instead.
G.V() IDE also provides suggestions based on your schema. For example, knowing that the
has step can take a label or a property name as its first argument, the IDE provides a list of labels and property names from your schema.
Once again, it shows details about the currently selected label in the sidebar, as shown above.
The output of the Gremlin query is returned in various forms
This is the output view that is to be expected: the raw data.
Included here is the gremlin console output as well as a JSON formatted output:
As those who have tried to use Gremlin before know quite well, this is often not very human-friendly to read. Fortunately, there are other views as well.
There is also a “Vertex View”, which shows just the vertices in a nice chart:
This view is searchable and filterable by label, making it even easier to navigate your graph.
There is even the option to delete these vertices from the GUI itself.
Even traversals that ended in an edge (e.g.,
g.V().outE()) showed this without any issue.
For Gremlin queries that include edge data, you can use the “Edge View” to explore just the edges:
This provides a much nicer interface for browsing your edges than the raw data, which is often only barely human-readable.
Note that traversals that terminate at a vertex don’t show edges, even if edges were traversed on the way there (e.g.,
g.V().out()). Only traversals that ended in an edge (e.g.,
g.V().outE()) showed these.
If you enable the option to “Fetch all edges between vertices” however, then traversals ending in a path (e.g.,
g.V().out().path()) also show the edge view and all edges in the path:
Furthermore, though this option won’t necessarily show edges on the path that were traversed along the way, this option will show edges that happen to be connected between vertices that are returned. For example, for this query that returns a bunch of random vertices, G.V() IDE identifies edges between these vertices and returns them as well, something that doesn’t happen in DSE Studio or AWS Graph Notebook.
This is also important to make sure that the Graph View has nicely connected vertices:
Without enabling this option which returns these edges, it just returns a bunch of disconnected nodes:
For those of you who have struggled to get a nice looking visualization of your queries to display in other tools like DSE Studio or AWS Graph Notebook (say, for a blog post or presentation for example), I’m sure that you know the helpfulness of this feature!
Before wrapping up, I just wanted to highlight some pros and cons in comparison to DSE Studio and AWS Graph Notebook really quick. Of course, each of these is a very different tool, but due to a decent amount of overlap in functionality, it might be helpful when deciding what to try out for your graph project.
The comparison between G.V() IDE and AWS Graph Notebook is similar to the comparison made to DSE Studio in a lot of ways, but also to add:
A review of a new tool like this would be incomplete without a wish list 🙂 Some things that would be great to see at some point in the future:
~/.config/gdotv/logs/main.log) but given this is a GUI-focused tool, it would be nice to see something in the UI also.
Even without any of the suggested additions and features mentioned above, G.V() IDE is a major addition to the Tinkerpop ecosystem and for DSE Graph in particular. It shows a lot of promise, especially when doing development. Personally, I plan on continuing to try it out on graph projects as opportunity allows. I am not sure what the planning model might end up being in the future but at least for now, it’s free and definitely worth checking out if you get a chance.
Cassandra.Link is a knowledge base that we created for all things Apache Cassandra. Our goal with Cassandra.Link was to not only fill the gap of Planet Cassandra but to bring the Cassandra community together. Feel free to reach out if you wish to collaborate with us on this project in any capacity.
We are a technology company that specializes in building business platforms. If you have any questions about the tools discussed in this post or about any of our services, feel free to send us an email!
Subscribe to our monthly newsletter below and never miss the latest Cassandra and data engineering news!