You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
It also provides support for shard aware ports, a faster way to connect to all shards, details available in [blogpost](https://www.scylladb.com/2021/04/27/connect-faster-to-scylla-with-a-shard-aware-port/).
17
+
18
18
Installation
19
19
------------
20
20
21
-
This is a drop-in replacement to gocql, to use it vendor as`github.com/gocql/gocql`.
21
+
This is a drop-in replacement to gocql, it reuses the`github.com/gocql/gocql` import path.
22
22
23
-
With `dep` you can use source option:
23
+
Add the following line to your project `go.mod` file.
go mod edit -replace=github.com/gocql/gocql=github.com/scylladb/gocql@{version}
45
-
```
46
-
where `version` is your intended version to be used. As gocql is currently not versioned you have to specify
47
-
version in following format `v0.0.0-%Y%m%d%H%M%S-{commit_sha:12}`.
48
-
Full example:
49
-
```
50
-
go mod edit -replace=github.com/gocql/gocql=github.com/scylladb/[email protected]
51
-
```
37
+
Your project now uses the Scylla driver fork, make sure you are using the `TokenAwareHostPolicy` to enable the shard-awareness, continue reading for details.
52
38
53
39
Configuration
54
40
-------------
@@ -119,172 +105,3 @@ The driver will print a warning about misconfigured address translation if it de
119
105
Issues with shard-aware port not being reachable are not reported in non-debug mode, because there is no way to detect it without false positives.
120
106
121
107
If you suspect that this feature is causing you problems, you can completely disable it by setting the `ClusterConfig.DisableShardAwarePort` flag to false.
122
-
123
-
---
124
-
125
-
Package gocql implements a fast and robust Cassandra client for the
126
-
Go programming language.
127
-
128
-
Project Website: https://gocql.github.io/<br>
129
-
API documentation: https://godoc.org/github.com/gocql/gocql<br>
The following matrix shows the versions of Go and Cassandra that are tested with the integration test suite as part of the CI build:
136
-
137
-
Go/Cassandra | 2.1.x | 2.2.x | 3.x.x
138
-
-------------| -------| ------| ---------
139
-
1.15 | yes | yes | yes
140
-
1.16 | yes | yes | yes
141
-
142
-
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.
143
-
144
-
Sunsetting Model
145
-
----------------
146
-
147
-
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.
148
-
149
-
Installation
150
-
------------
151
-
152
-
go get github.com/gocql/gocql
153
-
154
-
155
-
Features
156
-
--------
157
-
158
-
* Modern Cassandra client using the native transport
159
-
* Automatic type conversions between Cassandra and Go
160
-
* Support for all common types including sets, lists and maps
161
-
* Custom types can implement a `Marshaler` and `Unmarshaler` interface
162
-
* Strict type conversions without any loss of precision
163
-
* Built-In support for UUIDs (version 1 and 4)
164
-
* Support for logged, unlogged and counter batches
165
-
* Cluster management
166
-
* Automatic reconnect on connection failures with exponential falloff
167
-
* Round robin distribution of queries to different hosts
168
-
* Round robin distribution of queries to different connections on a host
169
-
* Each connection can execute up to n concurrent queries (whereby n is the limit set by the protocol version the client chooses to use)
170
-
* Optional automatic discovery of nodes
171
-
* Policy based connection pool with token aware and round-robin policy implementations
172
-
* Support for password authentication
173
-
* Iteration over paged results with configurable page size
174
-
* Support for TLS/SSL
175
-
* Optional frame compression (using snappy)
176
-
* Automatic query preparation
177
-
* Support for query tracing
178
-
* Support for Cassandra 2.1+ [binary protocol version 3](https://github.com/apache/cassandra/blob/trunk/doc/native_protocol_v3.spec)
179
-
* Support for up to 32768 streams
180
-
* Support for tuple types
181
-
* Support for client side timestamps by default
182
-
* Support for UDTs via a custom marshaller or struct tags
183
-
* Support for Cassandra 3.0+ [binary protocol version 4](https://github.com/apache/cassandra/blob/trunk/doc/native_protocol_v4.spec)
184
-
* An API to access the schema metadata of a given keyspace
185
-
186
-
Performance
187
-
-----------
188
-
While the driver strives to be highly performant, there are cases where it is difficult to test and verify. The driver is built
189
-
with maintainability and code readability in mind first and then performance and features, as such every now and then performance
190
-
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
191
-
its read buffer is when it Unmarshal's data into supplied types.
192
-
193
-
Some tips for getting more performance from the driver:
194
-
* Use the TokenAware policy
195
-
* Use many goroutines when doing inserts, the driver is asynchronous but provides a synchronous API, it can execute many queries concurrently
196
-
* Tune query page size
197
-
* Reading data from the network to unmarshal will incur a large amount of allocations, this can adversely affect the garbage collector, tune `GOGC`
198
-
* Close iterators after use to recycle byte buffers
199
-
200
-
Important Default Keyspace Changes
201
-
----------------------------------
202
-
gocql no longer supports executing "use <keyspace>" statements to simplify the library. The user still has the
203
-
ability to define the default keyspace for connections but now the keyspace can only be defined before a
204
-
session is created. Queries can still access keyspaces by indicating the keyspace in the query:
if err = session.Query("use example2").Exec(); err != nil {
225
-
log.Fatal(err)
226
-
}
227
-
```
228
-
This will result in an err being returned from the session.Query line as the user is trying to execute a "use"
229
-
statement.
230
-
231
-
Example
232
-
-------
233
-
234
-
See [package documentation](https://pkg.go.dev/github.com/scylladb/gocql#pkg-examples).
235
-
236
-
Data Binding
237
-
------------
238
-
239
-
There are various ways to bind application level data structures to CQL statements:
240
-
241
-
* 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.
242
-
* 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 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.
243
-
* As a refinement on the `SliceMap()` API you can also call `MapScan()` which returns `map[string]interface{}` instances in a row by row fashion.
244
-
* 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.
245
-
* The [gocqlx](https://github.com/scylladb/gocqlx) package is an idiomatic extension to gocql that provides usability features. With gocqlx you can bind the query parameters from maps and structs, use named query parameters (:identifier) and scan the query results into structs and slices. It comes with a fluent and flexible CQL query builder that supports full CQL spec, including BATCH statements and custom functions.
246
-
* Building on top of the gocql driver, [cqlr](https://github.com/relops/cqlr) adds the ability to auto-bind a CQL iterator to a struct or to bind a struct to an INSERT statement.
247
-
* Another external project that layers on top of gocql is [cqlc](http://relops.com/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.
248
-
*[gocassa](https://github.com/hailocab/gocassa) is an external project that layers on top of gocql to provide convenient query building and data binding.
249
-
*[gocqltable](https://github.com/kristoiv/gocqltable) provides an ORM-style convenience layer to make CRUD operations with gocql easier.
250
-
251
-
More Examples and Resources
252
-
--------
253
-
254
-
The course [Using Scylla Drivers](https://university.scylladb.com/courses/using-scylla-drivers/) in Scylla University explains how to use drivers in different languages to interact with a Scylla cluster.
255
-
The lesson, [Golang and Scylla Part 1](https://university.scylladb.com/courses/using-scylla-drivers/lessons/golang-and-scylla-part-1/) includes a sample application that, using the GoCQL driver, interacts with a three-node Scylla cluster.
256
-
It connects to a Scylla cluster, displays the contents of a table, inserts and deletes data, and shows the contents of the table after each action.
257
-
258
-
259
-
Ecosystem
260
-
---------
261
-
262
-
The following community maintained tools are known to integrate with gocql:
263
-
264
-
*[gocqlx](https://github.com/scylladb/gocqlx) is a gocql extension that automates data binding, adds named queries support, provides flexible query builders and plays well with gocql.
265
-
*[journey](https://github.com/db-journey/journey) is a migration tool with Cassandra support.
266
-
*[negronicql](https://github.com/mikebthun/negronicql) is gocql middleware for Negroni.
267
-
*[cqlr](https://github.com/relops/cqlr) adds the ability to auto-bind a CQL iterator to a struct or to bind a struct to an INSERT statement.
268
-
*[cqlc](http://relops.com/cqlc) generates gocql compliant code from your Cassandra schema so that you can write type safe CQL statements in Go with a natural query syntax.
269
-
*[gocassa](https://github.com/hailocab/gocassa) provides query building, adds data binding, and provides easy-to-use "recipe" tables for common query use-cases.
270
-
*[gocqltable](https://github.com/kristoiv/gocqltable) is a wrapper around gocql that aims to simplify common operations.
271
-
*[gockle](https://github.com/willfaught/gockle) provides simple, mockable interfaces that wrap gocql types
272
-
*[scylladb](https://github.com/scylladb/scylla) is a fast Apache Cassandra-compatible NoSQL database
273
-
*[go-cql-driver](https://github.com/MichaelS11/go-cql-driver) is an CQL driver conforming to the built-in database/sql interface. It is good for simple use cases where the database/sql interface is wanted. The CQL driver is a wrapper around this project.
274
-
275
-
Other Projects
276
-
--------------
277
-
278
-
*[gocqldriver](https://github.com/tux21b/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.
279
-
280
-
SEO
281
-
---
282
-
283
-
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.
284
-
285
-
License
286
-
-------
287
-
288
-
> Copyright (c) 2012-2016 The gocql Authors. All rights reserved.
289
-
> Use of this source code is governed by a BSD-style
0 commit comments