I am using Influxdb with Grafana for a while and I like it.
I am confused with the new version of Influxdb2.0. I was searching the doc and could not find useful info.
I have some questions.
Will Influxdb be available only as bundled with db + ui as 1 single binary going forward? Can we have standalone DB?
Will the Flux replace the current SQL like InfluxQL ? Or InfluxQL will also be supported.
Yes, I believe the intention is to bundle the UI into the single binary so that it is always available with no additional installs. You can continue to use Grafana though - ignoring the bundled UI entirely*. There's no problem to ignore it so the DB is still "standalone". Since it is OSS, you could build a binary without the bundled UI if that is important for your use case.
InfluxDB 2.0 OSS is currently in RC0 (as of late Oct 2020). This version supports both InfluxQL via a compatibility API (/query) and Flux via the new /api/v2/query API querying. The query and response formats are different. The docs have examples. In general, Flux is the direction InfluxDB is going.
*There may be some rough edges in the RC around configuring the first user without using the UI and only using the API. I have not tried this. I would expect the API to continue to improve is this area.
Related
Summary
I am devloping a app that is intendent to work across multiple graph databases suppoted by tinkerpop
Details
Based on my research the same version of tinkerpop library (gremlin-python) does not work with the latest version of all the graph databases. What is the best approach for this situation. The databases I intent to test are
JanusGraph 0.2.0 supported gremlin-python 3.2.7
NEO4J 3.3.3 supported gremlin-python 3.3.2
I am still trying to integrating some more databases like orientDB and Amazon Neptune do you know what version they will supported.
This issue can be a little tricky especially with non-open source systems that don't publish version and feature support clearly. For open source systems, you can typically find the version of TinkerPop they support for a particular version by looking at the pom.xml of the project. For OrientDB that means finding the version you want (in this case 3.2.3.0) and then looking for the gremlin-core dependency:
https://github.com/orientechnologies/orientdb-gremlin/blob/3.2.3.0/driver/pom.xml#L47
The version points to a property, so examine the pom a bit further and you'll see that number defined above:
https://github.com/orientechnologies/orientdb-gremlin/blob/3.2.3.0/driver/pom.xml#L14
So OrientDB 3.2.3.0 supports TinkerPop 3.2.3. With closed source systems you can only search around until you find the answer your looking for or ask the vendor directly I guess - I've seen that Neptune is on 3.3.x, but I'm not sure of what version of "x".
Just because all of these systems support different versions of TinkerPop and the general recommendation is to use a matching TinkerPop version to connect to them doesn't mean that you can't get a 3.3.x driver to connect to a 3.2.x based server. You may not have the best experience doing so and you would need to be aware of a few things as you do that, but I think it can be done.
The key to this to work from a driver perspective is to ensure that you have the right serialization configuration for the graph you are connecting to. This is true whether you are trying to connect to a same version system or not. By default, TinkerPop ensures that these configurations within the same version are aligned so that they work out of the box. This is why we tend to recommend that you use the same version when possible. When not possible, you need to make those alignments manually.
For example, if you scroll down in this link a bit to the "Serialization" section you will find the supported formats for Neptune:
https://docs.aws.amazon.com/neptune/latest/userguide/access-graph-gremlin-differences.html
As long as you configure your driver to match one of those formats it should work for you. The same could be said of JanusGraph, which in contrast to Neptune, will not support Gryo or GraphSON 3.0 as it is bound to the 3.2.x line. The configuration for the serializers can be found in JanusGraph's packaging of Gremlin Server:
https://github.com/JanusGraph/janusgraph/blob/v0.2.0/janusgraph-dist/src/assembly/static/conf/gremlin-server/gremlin-server.yaml#L15-L21
As to how you configure your python driver for serialization? Admittedly, there isn't a lot written on that. The key is to set the message_serializer when configuring the Client (from gremlinpython 3.3.2):
https://github.com/apache/tinkerpop/blob/3.3.2/gremlin-python/src/main/jython/gremlin_python/driver/client.py#L44-L45
You can see there that by default it is set to GraphSON 3.0. So, that's perfect for Neptune, but not JanusGraph. For JanusGraph, which doesn't support GraphSON 3.0 yet, you would just change the configuration to use the GraphSON 2.0 serializer:
https://github.com/apache/tinkerpop/blob/3.3.2/gremlin-python/src/main/jython/gremlin_python/driver/serializer.py#L149
So, that is just getting a connection working - then there are other things to consider:
If you use a new version of gremlinpython against an older server, you will need to make sure that you are aware of any features that aren't supported on the server (e.g. don't use math() step from your 3.3.x client because it won't work on a 3.2.x server)
CosmosDB has may allow you to connect with 3.3.x, but it doesn't have full Gremlin support and at this time does not support bytecode based traversals - only strings
A number of bugs have been fixed in GraphSON serialization over these releases and sometimes certain types may have a revised serialization scheme that may prevent a 3.3.x from talking to a 3.2.x - I can't think of any big issues like that offhand that would immediately jump out, but I'm pretty sure it's happened - perhaps something in serialization of Tree and perhaps some of the extended types. You can always look at the full list of GraphSON types here and compare between published versions if you run into trouble.
as I was wandering in the Web looking for a Gremlin implementation for Neo4j I found these two possible solutions:
https://github.com/thinkaurelius/neo4j-gremlin-plugin
http://tinkerpop.incubator.apache.org/docs/3.0.2-incubating/#neo4j-gremlin
Does anybody know what is the difference between the two in practice?
I saw that 1. is a Neo4j plugin while it's not really clear to me what the second is, and if it would lock the entire database thus not allowing other connections (I noticed that it requires the path to the data folder).
Which one is preferred in the neo4j community?
Cheers,
Alberto
I'm not sure there's really a difference as there isn't a direct comparison to be made. The second link is to the TinkerPop project and specifically to the Neo4j implementation of TinkerPop APIs. It runs in an embedded mode and does not yet have support for HA (though we hope to have that soon). The Neo4j implementation can be run in Gremlin Server which let's you send Gremlin to it as a REST, websockets, etc endpoint.
The project in the first link you provided uses that implementation to allow you to send Gremlin to Neo4j Server - so the first project depends on the second.
Your rule of thumb should be activity in the source code.
neo4j-gremlin-plugin has 3 commits this year - https://github.com/thinkaurelius/neo4j-gremlin-plugin/commits/master
tikerpop is much more active - https://github.com/apache/incubator-tinkerpop/commits/master/neo4j-gremlin/src/main/java/org/apache/tinkerpop/gremlin/neo4j
neo4j-gremlin-plugin
Extending existing Neo4j server with support for Gremlin Query Language.
TinkerPop Neo4j-Gremlin
Extending Gremlin console with support for Neo4j server.
I am trying to improve neo4j reading capabilities by not going through the REST API. It looks like I could improve performances by using websockets. It looks like this article is working on improving performance in embeded databases.
Is a similar endpoint available in the server version (can't find anything on it) ?
I may not have access to the neo4j server per say --> why I need it out of the box or as an extension.
I did some experiments with using websockets & cypher which was pretty straightforward: https://github.com/jexp/cypher_websocket_endpoint
And for instance http://structr.org supports Websockets on top of Neo4j out of the box.
I am considering Neo4J for some project. I recall reading somewhere that multi-document ACID transactions are only supported for embedded database, but not for the standalone one. Searching at the Neo4J site, I could not find any info about this. Some more information about this, or some pointers could help. Thank you.
Neo4j itself supports now transactions over the wire with 2.0
See: http://docs.neo4j.org/chunked/milestone/rest-api-transactional.html
Spring Data Neo4j does not yet and it will take a while until we get there, as it means to rewrite the core to use cypher throughout which it doesn't do now.
How can I turn off mandatory transactions in Neo4j 2.0? I need to do this as the library I am using does not support the 2.0 transactional API yet.
As you've said, in Neo4j 2.0 transactions are mandatory and there is no way to switch this off. If you're relying on Cypher be aware that the Cypher's ExecutionEngine automatically opens and closes a transaction if there is no one available from outside.
Depending on your environment and architecture you can use cross-cutting concerns to manage transactions separately from your code base. Think of java servlet filters, and aspect with aspectj, byte code manipulation, Groovy MOP magic, and other technologies. For a more focussed answer you should give more insight in your project regarding used languages, frameworks and architecture.
what if you are running neo4j in read-only mode? and you are more interested in speed rather than concurency as there is no race conditions.
from http://neo4j.com/docs/stable/transactions-isolation.html there will always be a transaction :/