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 -
PostgreSQL and MySQL async
DISCONTINUED. 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. -
scredis
Non-blocking, ultra-fast Scala Redis client built on top of Akka IO, used in production at Livestream -
Scruid
Scala + Druid: Scruid. A library that allows you to compose queries in Scala, and parse the result back into typesafe classes. -
lucene4s
Light-weight convenience wrapper around Lucene to simplify complex tasks and add Scala sugar. -
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.
WorkOS - The modern identity platform for B2B SaaS
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())