Name: gocql
Owner: Datadog, Inc.
Description: Package gocql implements a fast and robust Cassandra client for the Go programming language.
Created: 2015-11-23 19:15:18.0
Updated: 2016-07-19 19:27:37.0
Pushed: 2017-11-21 18:30:18.0
Homepage: http://gocql.github.io/
Size: 2441
Language: Go
GitHub Committers
User | Most Recent Commit | # Commits |
---|
Other Committers
User | Most Recent Commit | # Commits |
---|
Package gocql implements a fast and robust Cassandra client for the Go programming language.
Project Website: https://gocql.github.io/
API documentation: https://godoc.org/github.com/gocql/gocql
Discussions: https://groups.google.com/forum/#!forum/gocql
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 | 2.1.x | 2.2.x | 3.0.x ————-| ——-| ——| ——— 1.8 | yes | yes | yes 1.9 | yes | yes | yes
Gocql has been tested in production against many different versions of Cassandra. Due to limits in our CI setup we only test against the latest 3 major releases, which coincide with the official support from the Apache project.
In general, the gocql team will focus on supporting the current and previous versions of Go. gocql may still work with older versions of Go, but official support for these versions will have been sunset.
go get github.com/gocql/gocql
Marshaler
and Unmarshaler
interfaceWhile the driver strives to be highly performant, there are cases where it is difficult to test and verify. The driver is built with maintainability and code readability in mind first and then performance and features, as such every now and then performance may degrade, if this occurs please report and issue and it will be looked at and remedied. The only time the driver copies data from its read buffer is when it Unmarshal's data into supplied types.
Some tips for getting more performance from the driver:
GOGC
gocql no longer supports executing “use
CT * FROM example2.table;
Example of correct usage:
cluster := gocql.NewCluster("192.168.1.1", "192.168.1.2", "192.168.1.3")
cluster.Keyspace = "example"
...
session, err := cluster.CreateSession()
Example of incorrect usage:
cluster := gocql.NewCluster("192.168.1.1", "192.168.1.2", "192.168.1.3")
cluster.Keyspace = "example"
...
session, err := cluster.CreateSession()
if err = session.Query("use example2").Exec(); err != nil {
log.Fatal(err)
}
This will result in an err being returned from the session.Query line as the user is trying to execute a “use” statement.
efore you execute the program, Launch `cqlsh` and execute:
te keyspace example with replication = { 'class' : 'SimpleStrategy', 'replication_factor' : 1 };
te table example.tweet(timeline text, id UUID, text text, PRIMARY KEY(id));
te index on example.tweet(timeline);
age main
rt (
"fmt"
"log"
"github.com/gocql/gocql"
main() {
// connect to the cluster
cluster := gocql.NewCluster("192.168.1.1", "192.168.1.2", "192.168.1.3")
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 {
log.Fatal(err)
}
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 {
log.Fatal(err)
}
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 {
log.Fatal(err)
}
There are various ways to bind application level data structures to CQL statements:
[]map[string]interface{}
using the SliceMap()
API. This returns a slice of row maps keyed by CQL column names. 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.SliceMap()
API you can also call MapScan()
which returns map[string]interface{}
instances in a row by row fashion.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.The following community maintained tools are known to integrate with gocql:
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.For some reason, when you Google golang cassandra
, this project doesn't feature very highly in the result list. But if you Google go cassandra
, then we're a bit higher up the list. So this is note to try to convince Google that golang is an alias for Go.
Copyright (c) 2012-2016 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.