neo4akka alternatives and similar packages
Based on the "Database" category.
Alternatively, view neo4akka alternatives based on common mentions on social networks and blogs.
-
Slick
Slick (Scala Language Integrated Connection Kit) is a modern database query and access library for Scala -
Elastic4s
Elasticsearch Scala Client - Reactive, Non Blocking, Type Safe, HTTP Client -
PostgreSQL and MySQL async
Async database drivers to talk to PostgreSQL and MySQL in Scala. -
ScalikeJDBC
A tidy SQL-based DB access library for Scala developers. This library naturally wraps JDBC APIs and provides you easy-to-use APIs. -
scala-redis
A scala library for connecting to a redis server, or a cluster of redis nodes using consistent hashing on the client side. -
Phantom
Schema safe, type-safe, reactive Scala driver for Cassandra/Datastax Enterprise -
ReactiveMongo
:leaves: Non-blocking, Reactive MongoDB Driver for Scala -
rediscala
Non-blocking, Reactive Redis driver for Scala (with Sentinel support) -
Squeryl
A Scala DSL for talking with databases with minimum verbosity and maximum type safety -
#<Sawyer::Resource:0x00007f161059a678>
Strong type constraints for Scala -
SwayDB
Persistent and in-memory key-value storage engine for JVM that scales on a single machine. -
Pulsar4s
Idiomatic, typesafe, and reactive Scala client for Apache Pulsar -
Scala-Forklift
Type-safe data migration tool for Slick, Git and beyond. -
scredis
Non-blocking, ultra-fast Scala Redis client built on top of Akka IO, used in production at Livestream -
AnormCypher
Neo4j Scala library based on Anorm in the Play Framework -
Scruid
Scala + Druid: Scruid. A library that allows you to compose queries in Scala, and parse the result back into typesafe classes. -
Clickhouse-scala-client
Clickhouse Scala Client with Reactive Streams support -
Couchbase
The Couchbase Monorepo for JVM Clients: Java, Scala, io-core… -
Tepkin
Reactive MongoDB Driver for Scala built on top of Akka IO and Akka Streams. -
ScalaRelational
Type-Safe framework for defining, modifying, and querying SQL databases -
lucene4s
Light-weight convenience wrapper around Lucene to simplify complex tasks and add Scala sugar. -
ReactiveNeo
[DISCONTINUED] Reactive type-safe Scala driver for Neo4J -
GCP Datastore Akka Persistence Plugin
akka-persistence-gcp-datastore is a journal and snapshot store plugin for akka-persistence using google cloud firestore in datastore mode.
Static code analysis for 29 languages.
Do you think we are missing an alternative of neo4akka or a related project?
Popular Comparisons
README
neo4akka
Neo4j client for Scala using Akka-Http
All existing Scala clients try to be too clever adding obfuscation on top of the communication, creating a limiting DSL, or not using true non-blocking communication.
At its core this client will attempt to be a very clean and representative client allowing full use of Neo4j with Akka-Http in an entirely non-blocking way while still remaining true to the Cypher query language.
Status
Fully functional API that supports the majority of use-cases but ongoing development is still happening to make it more useful and convenient.
Features for 1.0.0
- [X] Asynchronous, true non-blocking IO with Akka HTTP
- [X] Cypher String Interpolator
- [X] Cypher Query Parser
- [X] Cypher Query Parser via Macro on Interpolation at compile-time
- [X] Structured QueryResponse
- [X] Macro support for extracting case class from QueryResponse
Features for 1.1.0
- [ ] Insert and update from case class into database
- [ ] Transactions
- [ ] Practical Pagination support
Documentation
In desperate need of help. For now just look at the tests until we can get the first release finished.
Setup
neo4akka is published to Sonatype OSS and Maven Central and supports JVM with 2.11 and 2.12:
libraryDependencies += "com.outr" %% "neo4akka" % "1.0.1"
Using
Imports
The only import necessary to use neo4akka is the following import along with an execution context for futures:
import com.outr.neo4akka._
import scala.concurrent.ExecutionContext.Implicits.global
Creating a Session
Supply the host, port, and credentials to validate and establish a session with neo4j:
val sessionFuture[Future[Neo4Akka]] = Neo4Akka("localhost", 7474, "neo4j", "password")
Creating a Query
With neo4akka's powerful Cypher language interpolation (uses neo4j's built-in query validation) we can create compile-time validated Cypher queries with ease:
val name = "Tom Hanks"
val query = cypher"MATCH (p: Person {name: $name}) RETURN p"
If the query is malformed compilation will fail and injected arguments are properly assigned to the argument list for sending to the database as unique arguments.
Executing a Query
Since our Neo4Akka
instance may or may not have completed yet, we can flatMap
the Future
in order to execute the
query against the database and get back a Future[ResultSet]
. For the purposes of this example, we'll simply do a blocking
Await
to get the ResultSet
:
val resultSetFuture[Future[ResultSet]] = sessionFuture.flatMap(session => session(query))
val resultSet: ResultSet = Await.result(request, Duration.Inf)
Processing Results
Now that we have a ResultSet
we can access the return p
from our query by name and use a compile-time Macro to populate
a case class Person
with the values:
case class Person(name: String, born: Int)
val people: Vector[Person] = resultSet("p")[Person]
Disposing
Because neo4akka uses Akka Actors internally, it must be properly disposed to release the ActorSystem
and ActorMaterializer
.
Note: An instance of Neo4Akka
uses Akka HTTP for true asynchronous non-blocking IO, so there is no state or unsafe reference
information stored in the session
.
sessionFuture.map(_.dispose())