Package gocql implements a fast and robust Cassandra client for the Go programming language.
Go Shell
Switch branches/tags
Nothing to show
Pull request Compare This branch is 1157 commits behind gocql:master.
Latest commit 00af478 Sep 12, 2014 @0x6e6562 0x6e6562 Merge pull request #242 from dankennedy/master
Support for marshalling inet values using strings and net.IP
Failed to load latest commit information.
AUTHORS Merge heads Jun 18, 2014
LICENSE added proper LICENSE and AUTHORS files Oct 1, 2012 Some inline code comments for beginners Aug 20, 2014
compressor.go alter NewTraceWriter to return a pointer - go vet was complaining abo… Aug 4, 2014
host_source.go Removed redundant if clause Aug 14, 2014
wiki_test.go clusterSize flag is actually a pointer Aug 13, 2014


Build Status GoDoc

Package gocql implements a fast and robust Cassandra client for the Go programming language.

Project Website:
API documentation:

Supported Versions

The following matrix shows the versions of Go and Cassandra that are tested with the integration test suite as part of the CI build:

Go/Cassandra 1.2.18 2.0.9 2.1.0-RC5
1.2 yes yes partial
1.3 yes yes partial


go get


  • Modern Cassandra client using the native transport
  • Automatic type conversations between Cassandra and Go
    • Support for all common types including sets, lists and maps
    • Custom types can implement a Marshaler and Unmarshaler interface
    • Strict type conversations without any loss of precision
    • Built-In support for UUIDs (version 1 and 4)
  • Support for logged, unlogged and counter batches
  • Cluster management
    • Automatic reconnect on connection failures with exponential falloff
    • Round robin distribution of queries to different hosts
    • Round robin distribution of queries to different connections on a host
    • Each connection can execute up to 128 concurrent queries
    • Optional automatic discovery of nodes
    • Optional support for periodic node discovery via system.peers
  • Iteration over paged results with configurable page size
  • Optional frame compression (using snappy)
  • Automatic query preparation
  • Support for query tracing

Please visit the Roadmap page to see what is on the horizion.

Important Default Keyspace Changes

gocql no longer supports executing "use " statements to simplfy the library. The user still has the ability to define the default keyspace for connections but now the keyspace can only be defined before a session is created. Queries can still access keyspaces by indicating the keyspace in the query:

SELECT * FROM example2.table;

Example of correct usage:

	cluster := gocql.NewCluster("", "", "")
	cluster.Keyspace = "example"
	session, err := cluster.CreateSession()

Example of incorrect usage:

	cluster := gocql.NewCluster("", "", "")
	cluster.Keyspace = "example"
	session, err := cluster.CreateSession()

	if err = session.Query("use example2").Exec(); err != nil {

This will result in an err being returned from the session.Query line as the user is trying to execute a "use" statement.


/* Before you execute the program, Launch `cqlsh` and execute:
create keyspace example with replication = { 'class' : 'SimpleStrategy', 'replication_factor' : 1 };
create table example.tweet(timeline text, id UUID, text text, PRIMARY KEY(id));
create index on example.tweet(timeline);
package main

import (


func main() {
	// connect to the cluster
	cluster := gocql.NewCluster("", "", "")
	cluster.Keyspace = "example"
	cluster.Consistency = gocql.Quorum
	session, _ := cluster.CreateSession()
	defer session.Close()

	// insert a tweet
	if err := session.Query(`INSERT INTO tweet (timeline, id, text) VALUES (?, ?, ?)`,
		"me", gocql.TimeUUID(), "hello world").Exec(); err != nil {

	var id gocql.UUID
	var text string

	/* Search for a specific set of records whose 'timeline' column matches
	 * the value 'me'. The secondary index that we created earlier will be
	 * used for optimizing the search */
	if err := session.Query(`SELECT id, text FROM tweet WHERE timeline = ? LIMIT 1`,
		"me").Consistency(gocql.One).Scan(&id, &text); err != nil {
	fmt.Println("Tweet:", id, text)

	// list all tweets
	iter := session.Query(`SELECT id, text FROM tweet WHERE timeline = ?`, "me").Iter()
	for iter.Scan(&id, &text) {
		fmt.Println("Tweet:", id, text)
	if err := iter.Close(); err != nil {

Data Binding

There are various ways to bind application level data structures to CQL statements:

  • You can write the data binding by hand, as outlined in the Tweet example. This provides you with the greatest flexibility, but it does mean that you need to keep your application code in sync with your Cassandra schema.
  • You can dynamically marshal an entire query result into an []map[string]interface{} using the SliceMap() API. This returns a slice of row maps keyed by CQL column mames. This method requires no special interaction with the gocql API, but it does require your application to be able to deal with a key value view of your data.
  • As a refinement on the SliceMap() API you can also call MapScan() which returns map[string]interface{} instances in a row by row fashion.
  • The Bind() API provides a client app with a low level mechanism to introspect query meta data and extract appropriate field values from application level data structures.
  • Building on top of the gocql driver, cqlr adds the ability to auto-bind a CQL iterator to a struct or to bind a struct to an INSERT statement.
  • Another external project that layers on top of gocql is cqlc which generates gocql compliant code from your Cassandra schema so that you can write type safe CQL statements in Go with a natural query syntax.

Other Projects

  • gocqldriver is the predecessor of gocql based on Go's "database/sql" package. This project isn't maintained anymore, because Cassandra wasn't a good fit for the traditional "database/sql" API. Use this package instead.


Copyright (c) 2012-2014 The gocql Authors. All rights reserved. Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.