ALL COVERED TOPICS

NoSQL Benchmarks NoSQL use cases NoSQL Videos NoSQL Hybrid Solutions NoSQL Presentations Big Data Hadoop MapReduce Pig Hive Flume Oozie Sqoop HDFS ZooKeeper Cascading Cascalog BigTable Cassandra HBase Hypertable Couchbase CouchDB MongoDB OrientDB RavenDB Jackrabbit Terrastore Amazon DynamoDB Redis Riak Project Voldemort Tokyo Cabinet Kyoto Cabinet memcached Amazon SimpleDB Datomic MemcacheDB M/DB GT.M Amazon Dynamo Dynomite Mnesia Yahoo! PNUTS/Sherpa Neo4j InfoGrid Sones GraphDB InfiniteGraph AllegroGraph MarkLogic Clustrix CouchDB Case Studies MongoDB Case Studies NoSQL at Adobe NoSQL at Facebook NoSQL at Twitter

NAVIGATE MAIN CATEGORIES

Close

Datomic: All content tagged as Datomic in NoSQL databases and polyglot persistence

Datomic Free Edition

Rich Hickey:

We’re happy to announce today the release of Datomic Free Edition. This edition is oriented around making Datomic easier to get, and use, for open source and smaller production deployments.

The system supports transactor-local storage The peer library includes a memory database and Datomic Datalog The Free transactor and peers are freely redistributable The transactor supports 2 simultaneous peers

It comes with a redistributable license and it can be used in production by both open source and commercial application. Datomic Free cannot use additional storages like SQL and DynamoDB and doesn’t support more more peers or the high-availability mode.

Original title and link: Datomic Free Edition (NoSQL database©myNoSQL)

via: http://blog.datomic.com/2012/07/datomic-free-edition.html


Distributed Temporal Graph Database Using Datomic

Davy Suvee describes the solution in the Gremlin group and shares the code on GitHub:

Last week I spend some time on implementing the Blueprints interface on top of Datomic. The RDF and SPARQL feel of the Datomic data model and query approach makes it a good target for implementing a property graph. I finished the implementation and all unit tests are passing. Now, what makes it really cool is that it is the only distributed “temporal” graph database that I’m aware of. It allows to perform queries against a version of the graph in the past.

This is the first solution I’m reading about addressing the time dimension in a graph model.

Original title and link: Distributed Temporal Graph Database Using Datomic (NoSQL database©myNoSQL)


Datomic: Datalog, Databases, Persistent Data Structures With Rich Hickey

From this interview with Rich Hickey:

Q: So why don’t you like relational databases, why did you create a new system?

A: One of the objectives of a lot of new systems is to decentralize things in order to get greater scaling and have more flexibility. So there is actually a lot to like about traditional databases. I think relational algebra is a powerful tool , and I think transactions are powerful, so we want to retain transactions, we retain a relational-like model which we expose through a query language called Datalog, which has the same power as relational algebra. So we value those things quite a bit, but you want to move away from having one server or a cluster of servers do all the work, because it’s very difficult to scale that, and in an attempt to scale that, people are giving up some capabilities.

Original title and link: Datomic: Datalog, Databases, Persistent Data Structures With Rich Hickey (NoSQL database©myNoSQL)

via: http://www.infoq.com/interviews/hickey-datomic


Thoughts About Datomic

Sergio Bossa has left a great comment on Fogus’s blog post about Datomic that encapsulates in much more detail all my notes (and some more) about Datomic:

I waited for the Datomic announcement with great excitement, and I’d like now to share some thoughts, hoping they will be food for more comments or blog posts.

Datomic certainly provides interesting features, most notably:

  1. Clojure-style data immutability, separating entity values in time.
  2. Declarative query language with powerful aggregation capabilities.

But unfortunately, my list of concerns is way longer, maybe because some lower level aspects weren’t addressed in the whitepaper, or maybe because my expectations were really too high. Let’s try to briefly enumerate the most relevant ones:

  1. Datomic provides powerful aggregation/processing capabilities, but violates one of the most important rules in distributed systems: collocating processing with data, as data must be moved from storage to peers’ working set in order to be aggregated/processed. In my experience, this is a huge penalty when dealing with even medium-sized datasets, and just answering that “we expect it to work for most common use cases” isn’t enough.

    My comment: The answer to similar comments pointed to the local caches. But I think it is still a very valid observation.

  2. In-process caching of working sets usually leads in my experience to compromising overall application reliability: that is, the application usually ends up spending lots of time dealing with the working set cache, either faulting/flushing objects or gc’ing them, rather than doing its own business.

  3. Transactors are both a Single Point Of Bottleneck and Single Point Of Failure: you may don’t care about the former (which I’d do btw), but you have to care about the latter.

    My comment: The Datomic paper contains an interesting formulation about the job of transactors for reads and writes:

    When reads are separated from writes, writes are never held up by queries. In the Datomic architecture, the transactor is dedicated to transactions, and need not service reads at all!

    In an ACID system, both reads and writes represent transactions though.

  4. You say you avoid sharding, but being transactors a single point of bottleneck, when the time you have too much data over a single transactor system will come, you’ll have to, guess what, shard, and Datomic has no support for this apparently.

  5. There’s no mention about how Datomic deals with network partitions.

I think that’s enough. I’ll be happy to read any feedback about my points.

As Sergio Bossa, I’d really love to hear some answers from the Datomic team.

Original title and link: Thoughts About Datomic (NoSQL database©myNoSQL)


It's Datomic

Interestingly, this is not unlike an early Lisp-based, er, database: Statice from Symbolics. Some folks went on from Statice to implement ObjectStore in C++.

Although Statice is billed as an OODB, and it’s based on CLOS, at the core of the system it’s really a datalog-like data model and query language, implemented in a dialect of Lisp, as with datomic.

It’s not unlike or is it alike?

Original title and link: It’s Datomic (NoSQL database©myNoSQL)

via: http://patrickdlogan.tumblr.com/post/18831806269/its-datomic


Discussions About Datomic

Being late to the Datomic party gives the advantage of finding a lot of conversations going on about it:

  1. Michael Fogus’s blog (Rich Hickey, Daniel Spiewak, and others)
  2. Hacker News
  3. reddit — quite irrelevant though

Original title and link: Discussions About Datomic (NoSQL database©myNoSQL)


Intro Videos to Datomic and Datomic Datalog

If you got curious about Datomic, below are two videos from its creators, Rich Hickey and Stuart Halloway, providing an intro to Datomic and its query language Datalog. About 30 minutes in total.


Datomic: Distributed Database Designed to Enable Scalable, Flexible and Intelligent Applications, Running on Next-Generation Cloud Architectures

I’m just starting to read about Datomic a distributed database designed to enable scalable, flexible and intelligent applications, running on next-generation cloud architectures. Skimming through the whitepaper:

  • it goes after relational databases calling out the same problems as those formulated by Michael Stonebraker
  • it also goes after NoSQL databases (ACID transactions, Joins, logical query language)
  • my first reaction is that it’s pretty similar to Gigaspaces, Terracotta, etc.
  • it uses an interesting immutable timestamped data model (CQRS?)
  • it’s completely unclear to me why the production service must be AWS
  • the team behind Datomic: Rich Hickey (Clojure), Stuart Halloway (Clojure), Justin Gehtland

Datomic architecture

Original title and link: Datomic: Distributed Database Designed to Enable Scalable, Flexible and Intelligent Applications, Running on Next-Generation Cloud Architectures (NoSQL database©myNoSQL)