datahike is a durable datalog database powered by an efficient datalog query engine. This project is a port of datascript to the hitchhiker-tree. All datascript tests are passing, but we are still working on the internals. Having said this we consider datahike usable for small projects, since datascript is very mature and deployed in many applications and the hitchhiker-tree implementation is at least heavily tested through generative testing. We are building on the two projects and the storage backends for the hitchhiker-tree through konserve. We would like to hear experience reports and are happy if you join us.
There is a video presentation with a walkthrough.
The overall vision is described in this presentation.
Add to your leiningen dependencies:
We provide a small stable API for the JVM at the moment, but the on-disk schema is not fixed yet. We will provide a migration guide until we have reached a stable on-disk schema. Take a look at the ChangeLog before upgrading.
(require '[datahike.api :refer :all])
;; use the filesystem as storage medium
(def uri #_"datahike:mem:///test"
"datahike:file:///tmp/api-test"
#_"datahike:level:///tmp/api-test1")
;; create a database at this place
(create-database uri)
(def conn (connect uri))
;; lets add some data and wait for the transaction
@(transact conn [{ :db/id 1, :name "Ivan", :age 15 }
{ :db/id 2, :name "Petr", :age 37 }
{ :db/id 3, :name "Ivan", :age 37 }
{ :db/id 4, :age 15 }])
(q '[:find ?e
:where [?e :name]]
@conn)
;; => #{[3] [2] [1]}
;; you might need to release the connection, e.g. for leveldb
(release conn)
(delete-database uri)The API namespace provides compatibility to a subset of Datomic functionality and should work as a drop-in replacement on the JVM. The rest of datahike will be ported to core.async to coordinate IO in a platform-neutral manner.
- Invoice creation demonstrated at the Dutch Clojure Meetup.
datahike provides similar functionality to Datomic and can be used as a drop-in replacement for a subset of it. The goal of datahike is not to provide an open-source reimplementation of Datomic, but it is part of the replikativ toolbox aimed to build distributed data management solutions. We have spoken to many backend engineers and Clojure developers, who tried to stay away from Datomic just because of its proprietary nature and we think in this regard datahike should make an approach to Datomic easier and vice-versa people who only want to use the goodness of datalog in small scale applications should not worry about setting up and depending on Datomic.
Some differences are:
- datahike runs locally on one peer. A transactor might be provided in the future and can also be realized through any linearizing write mechanism, e.g. Apache Kafka. If you are interested, please contact us.
- datahike provides the database as a transparent value, i.e. you can directly access the index datastructures (hitchhiker-tree) and leverage their persistent nature for replication. These internals are not guaranteed to stay stable, but provide useful insight into what is going on and can be optimized.
- datahike does not provide historical information out of the box yet
- Datomic has a REST interface and a Java API
- Datomic provides timeouts
Datomic is a full-fledged scalable database (as a service) built from the authors of Clojure and people with a lot of experience. If you need this kind of professional support, you should definitely stick to Datomic.
datahike's query engine and most of its codebase come from datascript. Without the work on datascript datahike would not have been possible. Differences to Datomic with respect to the query engine are documented there.
Pick datahike if your app has modest requirements towards a typical durable database, e.g. a single machine and a few millions of entities at maximum. Similarly if you want to have an open-source solution and be able to study and tinker with the codebase of your database, datahike provides a comparatively small and well composed codebase to tweak it to your needs. You should also always be able to migrate to Datomic later easily.
Pick Datomic if you already know that you will need scalability later or if you need a network API for your database. There is also plenty of material about Datomic online already. Most of it applies in some form or another to datahike, but it might be easier to use Datomic directly when you first learn Datalog.
Pick datascript if you want the fastest possible query performance and do not have a huge amount of data. You can easily persist the write operations separately and use the fast in-memory index datastructure of datascript then. datahike also at the moment does not support ClojureScript anymore, although we plan to recover this functionality.
In general all datascript
documentation
applies for namespaces beyond datahike.api. We are working towards a portable
version of datahike on top of core.async. Feel free to provide some help :).
The database can be exported to a flat file with:
(require '[datahike.migrate :refer [export-db import-db]])
(export-db @conn "/tmp/eavt-dump")You must do so before upgrading to a datahike version that has changed the
on-disk format. This can happen as long as we are arriving at version 1.0.0
and will always be communicated through the Changelog. After you have bumped the
datahike version you can use
;; ... setup new-conn (recreate with correct schema)
(import-db new-conn "/tmp/eavt-dump")to reimport your data into the new format.
The datoms are stored as strings in a line-based format, so you can easily check whether your dump is containing reasonable data. You can also use it to do some string based editing of the DB. You can also use the export as a backup.
If you are upgrading from pre 0.1.2 where we have not had the migration code
yet, then just evaluate the datahike.migrate namespace manually in your
project before exporting.
- fixed null pointer exceptions in the compare relation of the hitchhiker-tree
- disk layout change, migration needed
- write root nodes of indices efficiently; reduces garbage by ~40 times and halves transaction times
- support export/import functionality
- preliminary support for datascript style schemas through
create-database-with-schema - support storage of BigDecimal and BigInteger values
-
small, but stable JVM API
-
caching for fast query performance in konserve
-
reactive reflection warnings?
-
schema support
-
remove eavt-durable
-
remove redundant slicing code
-
generalize interface to indices
-
integration factui/reactive?
- cleanup interface to hitchhiker-tree
- optionally use core.async to handle storage IO
- ClojureScript support both in the browser and on node
- conceptualize schema upgrades
- fast redis backend support
- explore support for other index structures, e.g. FoundationDB
- support GC or eager deletion of fragments
- use hitchhiker-tree synchronization for replication
- run comprehensive query suite and compare to datascript and Datomic
- support anomaly errors (?)
- support optimistic write support through attributes with conflict resolution (CRDT-like)
- reactive datalog for materialized views
- provide some network access
- investigate https://github.com/usethesource/capsule for faster hh-tree durability
We are happy to provide commercial support with lambdaforge. If you are interested in a particular feature, please let us know.
Copyright © 2014–2019 Christian Weilbach, Nikita Prokopov, Konrad Kühne
Licensed under Eclipse Public License (see LICENSE).