Need help with alia?
Click the “chat” button below for chat support from the developer who created it, or find similar developers for support.

About the developer

231 Stars 47 Forks 929 Commits 3 Opened issues


High performance Cassandra client for clojure

Services available


Need anything else?

Contributors list


cljdoc badge

Coan-Teen, the female death spirit who walks without feet.

Cassandra CQL3 client for Clojure wrapping datastax/java-driver.

What's in the box?

  • Built on an extremely solid base, datastax/java-driver, based on the new CQL native protocol
  • Simple API with a minimal learning curve
  • Great performance
  • Provides an optional versatile CQL3+ DSL, Hayt
  • Support for Raw queries, Prepared Statements or Hayt queries
  • Can do both Synchronous and Asynchronous query execution
  • Async interfaces using either clojure/core.async , simple callbacks or manifold
  • Support for all of datastax/java-driver advanced options: jmx, auth, SSL, compression, consistency, custom executors, custom routing and more
  • Support and sugar for query tracing, metrics, retry policies, load balancing policies, reconnection policies and UUIDs generation
  • Extensible Clojure data types support & clojure.core/ex-data integration
  • Lazy and potentialy chunked sequences over queries
  • Controled pages and rows streaming via core.async channels and manifold streams
  • First class support for cassandra collections, User defined types, that includes nesting.
  • Lazy row decoding by default, but also optional cheap user controled decoding via IReduce

Our Sponsors:

Astra DB
Astra DB

Use Clojure with DataStax Astra DB - built on Apache Cassandra.



Please check the Changelog first if you are upgrading. Alia runs on Clojure >= 1.7 (we're using IReduceInit internally)

Add the following to your dependencies:

Clojars Project

This would include all the codec extensions and extra libraries.

But the better thing to do is to pick and choose what you really need from alia's modules:

  • cc.qbits/alia Main module with all the basic alia functions (required).

Clojars Project

  • cc.qbits/alia-async: core.async interface: query as streamed rows over channel, query as promise-chan

Clojars Project

  • cc.qbits/alia-manifold: Manifold interface: query as streamed rows over manifold stream, query as deferred, etc

Clojars Project

Clojars Project

Clojars Project

Clojars Project

Clojars Project

Hayt (the query DSL)

If you wish to use Hayt you need to add it to your dependencies

Clojars Project


and you're good to go.


codox generated documentation.


Simple query execution using alia with hayt would look like this:

(execute session (select :users
                         (where {:name :foo})
                         (columns :bar "baz")))

But first things first: here is an example of a complete session using raw queries.

(require '[qbits.alia :as alia])

(def session (alia/session {:session-keyspace "alia" :contact-points ["localhost:9042"] :load-balancing-local-datacenter "Analytics"}))

Sessions are separate so that you can interact with multiple keyspaces from the same cluster definition.

(def session (alia/connect cluster))

(alia/execute session "CREATE KEYSPACE alia WITH replication = {'class': 'SimpleStrategy', 'replication_factor' : 3};")

   (alia/execute session "CREATE TABLE users (user_name varchar,
                                              first_name varchar,
                                              last_name varchar,
                                              auuid uuid,
                                              birth_year bigint,
                                              created timestamp,
                                              valid boolean,
                                              emails set,
                                              tags list,
                                              amap map,
                                              PRIMARY KEY (user_name));")
  (alia/execute session "INSERT INTO users
                         (user_name, first_name, last_name, emails, birth_year, amap, tags, auuid,valid)
                         VALUES('frodo', 'Frodo', 'Baggins',
                         {'[email protected]', '[email protected]'}, 1,
                         {'foo': 1, 'bar': 2}, [4, 5, 6],
                         1f84b56b-5481-4ee4-8236-8a3831ee5892, true);")

;; prepared statement with positional parameter(s) (def prepared-statement (alia/prepare session "select * from users where user_name=?;"))

(alia/execute session prepared-statement {:values ["frodo"]})

>> ({:created nil, :last_name "Baggins", :emails #{"[email protected]" "[email protected]"}, :tags [4 5 6], :first_name "Frodo", :amap {"foo" 1, "bar" 2}, :auuid #uuid "1f84b56b-5481-4ee4-8236-8a3831ee5892", :valid true, :birth_year 1, :user_name "frodo"})

;; prepared statement with named parameter(s) (def prepared-statement (alia/prepare session "select * from users where user_name= :name limit :lmt;"))

(alia/execute session prepared-statement {:values {:name "frodo" :lmt (int 1)}})

Asynchronous interfaces:

There are currently 3 interfaces to use the asynchronous methods of the underlying driver, the fundamental one being a simple

API, and then two alternative streaming APIs built with core.async and manifold

Async returning

@(execute-async session "select * from users;")

Async using clojure/core.async

has the same signature as the other execute functions and returns a
channel of rows, or an exception instance.

The channel supports backpressure, controlled by buffer-sizes and as rows are consumed from the channel more rows will be fetched to fill any buffers.

Once you run it you have a couple of options to pull data from it.

  • using
    which takes the channel as first argument and a callback as second:
(take! (execute-chan session "select * from users;")
       (fn [rows-or-exception]
         (do-something rows)))
  • using
    clojure.core.async/ to block and pull the rows/exception
    from the channel.
(def rows-or-exception (
  • using
    you can run a list of queries in parallel and have the results fed to a single output chan:
(let [merged (async/merge [(alia/execute-chan session (select :foo))
                           (alia/execute-chan session (select :bar))
                           (alia/execute-chan session (select :baz))])]
    (loop []
      (when-let [result (

returns a
with just the first page of results

returns a channel of pages of results, also supporting backpressure. The page objects are constructed by the

Async using manifold

has the same signature as other execute functions and resturns a manifold stream of rows, or an exception instance

As with core.async, the stream supports backpressure and as rows are

en from the stream, more rows will be fetched according to available buffers.

returns a
with just the first page of results

returns a stream of pages of results, supporting backpressure. The page objects are constructed by the

And it can do a lot more! Head to the codox generated documentation.

Hayt (Query DSL)

There is a nicer way to write your queries using Hayt, this should be familiar if you know Korma or ClojureQL. One of the major difference is that Hayt doesn't use macros and just generates maps, so if you need to compose clauses or queries together you can just use the clojure.core functions that work on maps.

Some examples:

(use 'qbits.hayt)

(select :foo (where {:bar 2}))

;; this generates a map >> {:select :foo :where {:bar 2}}

(update :foo (set-columns {:bar 1 :baz (inc-by 2)} (where [[= :foo :bar] [> :moo 3] [> :meh 4] [:in :baz [5 6 7]]]))

;; Composability using normal map manipulation functions

(def base (select :foo (where {:foo 1})))

(merge base (columns :bar :baz) (where {:bar 2}) (order-by [:bar :asc]) (using :ttl 10000))

;; To compile the queries just use ->raw

(->raw (select :foo)) > "SELECT * FROM foo;"

Alia supports hayt query direct execution, if you pass a non-compiled query to

, it will be compiled and cached on a LU cache with a threshold of 100 (the cache function is user settable), so to be used carefully. The same is true with


(execute session (select :users (where {:name :foo})))

It covers everything that is possible with CQL3 (functions, handling of collection types and their operations, ddl, prepared statements, etc). If you want to know more about it head to its codox documentation or Hayt's tests.


If you wish to support the work on this project you can do this here: patreon

Mailing list

Alia has a mailing list hosted on Google Groups. Do not hesitate to ask your questions there.


Copyright © 2013-2020 Max Penet, mccraigmccraig

Distributed under the Eclipse Public License, the same as Clojure.

We use cookies. If you continue to browse the site, you agree to the use of cookies. For more information on our use of cookies please see our Privacy Policy.