func JoinHostPort(addrstring, portint)string

func LookupIP(hoststring) ([]net.IP,error)

func Marshal(infoTypeInfo, value interface{}) ([]byte,error)

func NamedValue(namestring, value interface{}) interface{}

func NewErrProtocol(formatstring, args ...interface{})error

func NonLocalReplicasFallback() func(policy *tokenAwareHostPolicy)

func ShuffleReplicas() func(*tokenAwareHostPolicy)

func SingleHostReadyPolicy(pHostSelectionPolicy) *singleHostReadyPolicy

func TupleColumnName(cstring, nint)string

func Unmarshal(infoTypeInfo, data []byte, value interface{})error

type AddressTranslator interface {// Translate will translate the provided address and/or port to another// address and/or port. If no translation is possible, Translate will return the// address and port provided to it.Translate(addrnet.IP, portint) (net.IP,int)}

funcIdentityTranslator¶

func IdentityTranslator()AddressTranslator

IdentityTranslator will do nothing but return what it was provided. It is essentially a no-op.

type AddressTranslatorFunc func(addrnet.IP, portint) (net.IP,int)

func (AddressTranslatorFunc)Translate¶

func (fnAddressTranslatorFunc) Translate(addrnet.IP, portint) (net.IP,int)

type AggregateMetadata struct {KeyspacestringNamestringArgumentTypes []TypeInfoFinalFuncFunctionMetadataInitCondstringReturnTypeTypeInfoStateFuncFunctionMetadataStateTypeTypeInfo// contains filtered or unexported fields}

type Authenticator interface {Challenge(req []byte) (resp []byte, authAuthenticator, errerror)Success(data []byte)error}

type Batch struct {TypeBatchTypeEntries []BatchEntryConsConsistencyCustomPayload map[string][]byte// contains filtered or unexported fields}

func (*Batch)AddAttempts¶

func (b *Batch) AddAttempts(iint, host *HostInfo)

func (*Batch)AddLatency¶

func (b *Batch) AddLatency(lint64, host *HostInfo)

func (*Batch)Attempts¶

func (b *Batch) Attempts()int

Attempts returns the number of attempts made to execute the batch.

func (*Batch)Bind¶

func (b *Batch) Bind(stmtstring, bind func(q *QueryInfo) ([]interface{},error))

Bind adds the query to the batch operation and correlates it with a binding callbackthat will be invoked when the batch is executed. The binding callback allows the applicationto define which query argument values will be marshalled as part of the batch execution.

func (*Batch)Cancel¶

func (*Batch) Cancel()

Deprecate: does nothing, cancel the context passed to WithContext

func (*Batch)Context¶

func (b *Batch) Context()context.Context

func (*Batch)DefaultTimestamp¶

func (b *Batch) DefaultTimestamp(enablebool) *Batch

DefaultTimestamp will enable the with default timestamp flag on the query.If enable, this will replace the server side assignedtimestamp as default timestamp. Note that a timestamp in the query itselfwill still override this timestamp. This is entirely optional.

Only available on protocol >= 3

func (*Batch)GetConsistency¶

func (b *Batch) GetConsistency()Consistency

GetConsistency returns the currently configured consistency level for the batchoperation.

func (*Batch)GetRoutingKey¶

func (b *Batch) GetRoutingKey() ([]byte,error)

func (*Batch)IsIdempotent¶

func (b *Batch) IsIdempotent()bool

func (*Batch)Keyspace¶

func (b *Batch) Keyspace()string

func (*Batch)Latency¶

func (b *Batch) Latency()int64

Latency returns the average number of nanoseconds to execute a single attempt of the batch.

func (*Batch)Observer¶

func (b *Batch) Observer(observerBatchObserver) *Batch

Observer enables batch-level observer on this batch.The provided observer will be called every time this batched query is executed.

func (*Batch)Query¶

func (b *Batch) Query(stmtstring, args ...interface{})

Query adds the query to the batch operation

func (*Batch)RetryPolicy¶

func (b *Batch) RetryPolicy(rRetryPolicy) *Batch

RetryPolicy sets the retry policy to use when executing the batch operation

func (*Batch)SerialConsistency¶

func (b *Batch) SerialConsistency(consSerialConsistency) *Batch

SerialConsistency sets the consistency level for theserial phase of conditional updates. That consistency can only beeither SERIAL or LOCAL_SERIAL and if not present, it defaults toSERIAL. This option will be ignored for anything else that aconditional update/insert.

Only available for protocol 3 and above

func (*Batch)SetConsistency¶

func (b *Batch) SetConsistency(cConsistency)

SetConsistency sets the currently configured consistency level for the batchoperation.

func (*Batch)Size¶

func (b *Batch) Size()int

Size returns the number of batch statements to be executed by the batch operation.

func (*Batch)SpeculativeExecutionPolicy¶

func (b *Batch) SpeculativeExecutionPolicy(spSpeculativeExecutionPolicy) *Batch

func (*Batch)Table¶added inv1.6.0

func (b *Batch) Table()string

Batch has no reasonable eqivalent of Query.Table().

func (*Batch)Trace¶

func (b *Batch) Trace(traceTracer) *Batch

Trace enables tracing of this batch. Look at the documentation of theTracer interface to learn more about tracing.

func (*Batch)WithContext¶

func (b *Batch) WithContext(ctxcontext.Context) *Batch

WithContext returns a shallow copy of b with its contextset to ctx.

The provided context controls the entire lifetime of executing aquery, queries will be canceled and return once the context iscanceled.

func (*Batch)WithTimestamp¶

func (b *Batch) WithTimestamp(timestampint64) *Batch

WithTimestamp will enable the with default timestamp flag on the querylike DefaultTimestamp does. But also allows to define value for timestamp.It works the same way as USING TIMESTAMP in the query itself, butshould not break prepared query optimization.

Only available on protocol >= 3

type BatchEntry struct {StmtstringArgs       []interface{}Idempotentbool// contains filtered or unexported fields}

type BatchObserver interface {// ObserveBatch gets called on every batch query to cassandra.// It also gets called once for each query in a batch.// It doesn't get called if there is no query because the session is closed or there are no connections available.// The error reported only shows query errors, i.e. if a SELECT is valid but finds no matches it will be nil.// Unlike QueryObserver.ObserveQuery it does no reporting on rows read.ObserveBatch(context.Context,ObservedBatch)}

type BatchTypebyte

type ClusterConfig struct {// addresses for the initial connections. It is recommended to use the value set in// the Cassandra config for broadcast_address or listen_address, an IP address not// a domain name. This is because events from Cassandra will use the configured IP// address, which is used to index connected hosts. If the domain name specified// resolves to more than 1 IP address then the driver may connect multiple times to// the same host, and will not mark the node being down or up from events.Hosts []string// CQL version (default: 3.0.0)CQLVersionstring// ProtoVersion sets the version of the native protocol to use, this will// enable features in the driver for specific protocol versions, generally this// should be set to a known version (2,3,4) for the cluster being connected to.//// If it is 0 or unset (the default) then the driver will attempt to discover the// highest supported protocol for the cluster. In clusters with nodes of different// versions the protocol selected is not defined (ie, it can be any of the supported in the cluster)ProtoVersionint// Timeout limits the time spent on the client side while executing a query.// Specifically, query or batch execution will return an error if the client does not receive a response// from the server within the Timeout period.// Timeout is also used to configure the read timeout on the underlying network connection.// Client Timeout should always be higher than the request timeouts configured on the server,// so that retries don't overload the server.// Timeout has a default value of 11 seconds, which is higher than default server timeout for most query types.// Timeout is not applied to requests during initial connection setup, see ConnectTimeout.Timeouttime.Duration// ConnectTimeout limits the time spent during connection setup.// During initial connection setup, internal queries, AUTH requests will return an error if the client// does not receive a response within the ConnectTimeout period.// ConnectTimeout is applied to the connection setup queries independently.// ConnectTimeout also limits the duration of dialing a new TCP connection// in case there is no Dialer nor HostDialer configured.// ConnectTimeout has a default value of 11 seconds.ConnectTimeouttime.Duration// WriteTimeout limits the time the driver waits to write a request to a network connection.// WriteTimeout should be lower than or equal to Timeout.// WriteTimeout defaults to the value of Timeout.WriteTimeouttime.Duration// Port used when dialing.// Default: 9042Portint// Initial keyspace. Optional.Keyspacestring// Number of connections per host.// Default: 2NumConnsint// Default consistency level.// Default: QuorumConsistencyConsistency// Compression algorithm.// Default: nilCompressorCompressor// Default: nilAuthenticatorAuthenticator// An Authenticator factory. Can be used to create alternative authenticators.// Default: nilAuthProvider func(h *HostInfo) (Authenticator,error)// Default retry policy to use for queries.// Default: no retries.RetryPolicyRetryPolicy// ConvictionPolicy decides whether to mark host as down based on the error and host info.// Default: SimpleConvictionPolicyConvictionPolicyConvictionPolicy// Default reconnection policy to use for reconnecting before trying to mark host as down.ReconnectionPolicyReconnectionPolicy// The keepalive period to use, enabled if > 0 (default: 0)// SocketKeepalive is used to set up the default dialer and is ignored if Dialer or HostDialer is provided.SocketKeepalivetime.Duration// Maximum cache size for prepared statements globally for gocql.// Default: 1000MaxPreparedStmtsint// Maximum cache size for query info about statements for each session.// Default: 1000MaxRoutingKeyInfoint// Default page size to use for created sessions.// Default: 5000PageSizeint// Consistency for the serial part of queries, values can be either SERIAL or LOCAL_SERIAL.// Default: unsetSerialConsistencySerialConsistency// SslOpts configures TLS use when HostDialer is not set.// SslOpts is ignored if HostDialer is set.SslOpts *SslOptions// Sends a client side timestamp for all requests which overrides the timestamp at which it arrives at the server.// Default: true, only enabled for protocol 3 and above.DefaultTimestampbool// PoolConfig configures the underlying connection pool, allowing the// configuration of host selection and connection selection policies.PoolConfigPoolConfig// If not zero, gocql attempt to reconnect known DOWN nodes in every ReconnectInterval.ReconnectIntervaltime.Duration// The maximum amount of time to wait for schema agreement in a cluster after// receiving a schema change frame. (default: 60s)MaxWaitSchemaAgreementtime.Duration// HostFilter will filter all incoming events for host, any which don't pass// the filter will be ignored. If set will take precedence over any options set// via DiscoveryHostFilterHostFilter// AddressTranslator will translate addresses found on peer discovery and/or// node change events.AddressTranslatorAddressTranslator// If IgnorePeerAddr is true and the address in system.peers does not match// the supplied host by either initial hosts or discovered via events then the// host will be replaced with the supplied address.//// For example if an event comes in with host=10.0.0.1 but when looking up that// address in system.local or system.peers returns 127.0.0.1, the peer will be// set to 10.0.0.1 which is what will be used to connect to.IgnorePeerAddrbool// If DisableInitialHostLookup then the driver will not attempt to get host info// from the system.peers table, this will mean that the driver will connect to// hosts supplied and will not attempt to lookup the hosts information, this will// mean that data_centre, rack and token information will not be available and as// such host filtering and token aware query routing will not be available.DisableInitialHostLookupbool// Configure events the driver will register forEvents struct {// disable registering for status events (node up/down)DisableNodeStatusEventsbool// disable registering for topology events (node added/removed/moved)DisableTopologyEventsbool// disable registering for schema events (keyspace/table/function removed/created/updated)DisableSchemaEventsbool}// DisableSkipMetadata will override the internal result metadata cache so that the driver does not// send skip_metadata for queries, this means that the result will always contain// the metadata to parse the rows and will not reuse the metadata from the prepared// statement.//// Seehttps://issues.apache.org/jira/browse/CASSANDRA-10786DisableSkipMetadatabool// QueryObserver will set the provided query observer on all queries created from this session.// Use it to collect metrics / stats from queries by providing an implementation of QueryObserver.QueryObserverQueryObserver// BatchObserver will set the provided batch observer on all queries created from this session.// Use it to collect metrics / stats from batch queries by providing an implementation of BatchObserver.BatchObserverBatchObserver// ConnectObserver will set the provided connect observer on all queries// created from this session.ConnectObserverConnectObserver// FrameHeaderObserver will set the provided frame header observer on all frames' headers created from this session.// Use it to collect metrics / stats from frames by providing an implementation of FrameHeaderObserver.FrameHeaderObserverFrameHeaderObserver// StreamObserver will be notified of stream state changes.// This can be used to track in-flight protocol requests and responses.StreamObserverStreamObserver// Default idempotence for queriesDefaultIdempotencebool// The time to wait for frames before flushing the frames connection to Cassandra.// Can help reduce syscall overhead by making less calls to write. Set to 0 to// disable.//// (default: 200 microseconds)WriteCoalesceWaitTimetime.Duration// Dialer will be used to establish all connections created for this Cluster.// If not provided, a default dialer configured with ConnectTimeout will be used.// Dialer is ignored if HostDialer is provided.DialerDialer// HostDialer will be used to establish all connections for this Cluster.// If not provided, Dialer will be used instead.HostDialerHostDialer// Logger for this ClusterConfig.// If not specified, defaults to the global gocql.Logger.LoggerStdLogger// contains filtered or unexported fields}

funcNewCluster¶

func NewCluster(hosts ...string) *ClusterConfig

NewCluster generates a new config for the default cluster implementation.

The supplied hosts are used to initially connect to the cluster then the rest ofthe ring will be automatically discovered. It is recommended to use the value set inthe Cassandra config for broadcast_address or listen_address, an IP address nota domain name. This is because events from Cassandra will use the configured IPaddress, which is used to index connected hosts. If the domain name specifiedresolves to more than 1 IP address then the driver may connect multiple times tothe same host, and will not mark the node being down or up from events.

func (*ClusterConfig)CreateSession¶

func (cfg *ClusterConfig) CreateSession() (*Session,error)

CreateSession initializes the cluster based on this config and returns asession object that can be used to interact with the database.

type CollectionType struct {NativeTypeKeyTypeInfo// only used for TypeMapElemTypeInfo// only used for TypeMap, TypeList and TypeSet}

func (CollectionType)New¶

func (tCollectionType) New() interface{}

func (CollectionType)NewWithError¶added inv1.1.0

func (tCollectionType) NewWithError() (interface{},error)

func (CollectionType)String¶

func (cCollectionType) String()string

type ColumnIndexMetadata struct {NamestringTypestringOptions map[string]interface{}}

type ColumnInfo struct {KeyspacestringTablestringNamestringTypeInfoTypeInfo}

func (ColumnInfo)String¶

func (cColumnInfo) String()string

type ColumnKindint

func (ColumnKind)String¶

func (cColumnKind) String()string

func (*ColumnKind)UnmarshalCQL¶

func (c *ColumnKind) UnmarshalCQL(typTypeInfo, p []byte)error

type ColumnMetadata struct {KeyspacestringTablestringNamestringComponentIndexintKindColumnKindValidatorstringTypeTypeInfoClusteringOrderstringOrderColumnOrderIndexColumnIndexMetadata}

type ColumnOrderbool

type Compressor interface {Name()stringEncode(data []byte) ([]byte,error)Decode(data []byte) ([]byte,error)}

type Conn struct {// contains filtered or unexported fields}

func (*Conn)Address¶

func (c *Conn) Address()string

func (*Conn)AvailableStreams¶

func (c *Conn) AvailableStreams()int

func (*Conn)Close¶

func (c *Conn) Close()

func (*Conn)Closed¶

func (c *Conn) Closed()bool

func (*Conn)Pick¶

func (c *Conn) Pick(qry *Query) *Conn

func (*Conn)Read¶

func (c *Conn) Read(p []byte) (nint, errerror)

func (*Conn)UseKeyspace¶

func (c *Conn) UseKeyspace(keyspacestring)error

func (*Conn)Write¶

func (c *Conn) Write(p []byte) (nint, errerror)

type ConnConfig struct {ProtoVersionintCQLVersionstringTimeouttime.DurationWriteTimeouttime.DurationConnectTimeouttime.DurationDialerDialerHostDialerHostDialerCompressorCompressorAuthenticatorAuthenticatorAuthProvider   func(h *HostInfo) (Authenticator,error)Keepalivetime.DurationLoggerStdLogger// contains filtered or unexported fields}

type ConnErrorHandler interface {HandleError(conn *Conn, errerror, closedbool)}

type ConnectObserver interface {// ObserveConnect gets called when a new connection to cassandra is made.ObserveConnect(ObservedConnect)}

type Consistencyuint16

funcMustParseConsistency¶

func MustParseConsistency(sstring) (Consistency,error)

MustParseConsistency is the same as ParseConsistency except it returnsan error (never). It is kept here since breaking changes are not good.DEPRECATED: use ParseConsistency if you want a panic on parse error.

funcParseConsistency¶

func ParseConsistency(sstring)Consistency

funcParseConsistencyWrapper¶

func ParseConsistencyWrapper(sstring) (consistencyConsistency, errerror)

ParseConsistencyWrapper wraps gocql.ParseConsistency to provide an errreturn instead of a panic

func (Consistency)MarshalText¶

func (cConsistency) MarshalText() (text []byte, errerror)

func (Consistency)String¶

func (cConsistency) String()string

func (*Consistency)UnmarshalText¶

func (c *Consistency) UnmarshalText(text []byte)error

type ConstantReconnectionPolicy struct {MaxRetriesintIntervaltime.Duration}

func (*ConstantReconnectionPolicy)GetInterval¶

func (c *ConstantReconnectionPolicy) GetInterval(currentRetryint)time.Duration

func (*ConstantReconnectionPolicy)GetMaxRetries¶

func (c *ConstantReconnectionPolicy) GetMaxRetries()int

type ConvictionPolicy interface {// Implementations should return `true` if the host should be convicted, `false` otherwise.AddFailure(errorerror, host *HostInfo)bool//Implementations should clear out any convictions or state regarding the host.Reset(host *HostInfo)}

type DialedHost struct {// Conn used to communicate with the server.Connnet.Conn// DisableCoalesce disables write coalescing for the Conn.// If true, the effect is the same as if WriteCoalesceWaitTime was configured to 0.DisableCoalescebool}

funcWrapTLS¶added inv1.2.0

func WrapTLS(ctxcontext.Context, connnet.Conn, addrstring, tlsConfig *tls.Config) (*DialedHost,error)

WrapTLS optionally wraps a net.Conn connected to addr with the given tlsConfig.If the tlsConfig is nil, conn is not wrapped into a TLS session, so is insecure.If the tlsConfig does not have server name set, it is updated based on the default gocql rules.

type Dialer interface {DialContext(ctxcontext.Context, network, addrstring) (net.Conn,error)}

type DowngradingConsistencyRetryPolicy struct {ConsistencyLevelsToTry []Consistency}

func (*DowngradingConsistencyRetryPolicy)Attempt¶

func (d *DowngradingConsistencyRetryPolicy) Attempt(qRetryableQuery)bool

func (*DowngradingConsistencyRetryPolicy)GetRetryType¶

func (d *DowngradingConsistencyRetryPolicy) GetRetryType(errerror)RetryType

type Duration struct {Monthsint32Daysint32Nanosecondsint64}

type ErrProtocol struct {// contains filtered or unexported fields}

type Error struct {CodeintMessagestring}

func (Error)Error¶

func (eError) Error()string

type ErrorMap map[string]uint16

type ExecutableQuery interface {GetRoutingKey() ([]byte,error)Keyspace()stringTable()stringIsIdempotent()boolRetryableQuery// contains filtered or unexported methods}

type ExponentialBackoffRetryPolicy struct {NumRetriesintMin, Maxtime.Duration}

func (*ExponentialBackoffRetryPolicy)Attempt¶

func (e *ExponentialBackoffRetryPolicy) Attempt(qRetryableQuery)bool

func (*ExponentialBackoffRetryPolicy)GetRetryType¶

func (e *ExponentialBackoffRetryPolicy) GetRetryType(errerror)RetryType

type ExponentialReconnectionPolicy struct {MaxRetriesintInitialIntervaltime.DurationMaxIntervaltime.Duration}

func (*ExponentialReconnectionPolicy)GetInterval¶

func (e *ExponentialReconnectionPolicy) GetInterval(currentRetryint)time.Duration

func (*ExponentialReconnectionPolicy)GetMaxRetries¶

func (e *ExponentialReconnectionPolicy) GetMaxRetries()int

type FrameHeaderObserver interface {// ObserveFrameHeader gets called on every received frame header.ObserveFrameHeader(context.Context,ObservedFrameHeader)}

type FunctionMetadata struct {KeyspacestringNamestringArgumentTypes     []TypeInfoArgumentNames     []stringBodystringCalledOnNullInputboolLanguagestringReturnTypeTypeInfo}

type HostDialer interface {// DialHost establishes a connection to the host.// The returned connection must be directly usable for CQL protocol,// specifically DialHost is responsible also for setting up the TLS session if needed.// DialHost should disable write coalescing if the returned net.Conn does not support writev.// As of Go 1.18, only plain TCP connections support writev, TLS sessions should disable coalescing.// You can use WrapTLS helper function if you don't need to override the TLS setup.DialHost(ctxcontext.Context, host *HostInfo) (*DialedHost,error)}

type HostFilter interface {// Called when a new host is discovered, returning true will cause the host// to be added to the pools.Accept(host *HostInfo)bool}

funcAcceptAllFilter¶

func AcceptAllFilter()HostFilter

AcceptAllFilter will accept all hosts

funcDataCentreHostFilter¶

func DataCentreHostFilter(dataCentrestring)HostFilter

DataCentreHostFilter filters all hosts such that they are in the same data centreas the supplied data centre.

funcDenyAllFilter¶

func DenyAllFilter()HostFilter

funcWhiteListHostFilter¶

func WhiteListHostFilter(hosts ...string)HostFilter

WhiteListHostFilter filters incoming hosts by checking that their address isin the initial hosts whitelist.

type HostFilterFunc func(host *HostInfo)bool

func (HostFilterFunc)Accept¶

func (fnHostFilterFunc) Accept(host *HostInfo)bool

type HostInfo struct {// contains filtered or unexported fields}

func (*HostInfo)BroadcastAddress¶

func (h *HostInfo) BroadcastAddress()net.IP

func (*HostInfo)ClusterName¶

func (h *HostInfo) ClusterName()string

func (*HostInfo)ConnectAddress¶

func (h *HostInfo) ConnectAddress()net.IP

Returns the address that should be used to connect to the host.If you wish to override this, use an AddressTranslator oruse a HostFilter to SetConnectAddress()

func (*HostInfo)ConnectAddressAndPort¶added inv1.4.0

func (h *HostInfo) ConnectAddressAndPort()string

func (*HostInfo)DSEVersion¶

func (h *HostInfo) DSEVersion()string

func (*HostInfo)DataCenter¶

func (h *HostInfo) DataCenter()string

func (*HostInfo)Equal¶

func (h *HostInfo) Equal(host *HostInfo)bool

func (*HostInfo)Graph¶

func (h *HostInfo) Graph()bool

func (*HostInfo)HostID¶

func (h *HostInfo) HostID()string

func (*HostInfo)HostnameAndPort¶

func (h *HostInfo) HostnameAndPort()string

func (*HostInfo)IsUp¶

func (h *HostInfo) IsUp()bool

func (*HostInfo)ListenAddress¶

func (h *HostInfo) ListenAddress()net.IP

func (*HostInfo)Partitioner¶

func (h *HostInfo) Partitioner()string

func (*HostInfo)Peer¶

func (h *HostInfo) Peer()net.IP

func (*HostInfo)Port¶

func (h *HostInfo) Port()int

func (*HostInfo)PreferredIP¶

func (h *HostInfo) PreferredIP()net.IP

func (*HostInfo)RPCAddress¶

func (h *HostInfo) RPCAddress()net.IP

func (*HostInfo)Rack¶

func (h *HostInfo) Rack()string

func (*HostInfo)SetConnectAddress¶

func (h *HostInfo) SetConnectAddress(addressnet.IP) *HostInfo

func (*HostInfo)SetHostID¶added inv1.2.0

func (h *HostInfo) SetHostID(hostIDstring)

func (*HostInfo)State¶

func (h *HostInfo) State() nodeState

func (*HostInfo)String¶

func (h *HostInfo) String()string

func (*HostInfo)Tokens¶

func (h *HostInfo) Tokens() []string

func (*HostInfo)Version¶

func (h *HostInfo) Version() cassVersion

func (*HostInfo)WorkLoad¶

func (h *HostInfo) WorkLoad()string

type HostSelectionPolicy interface {HostStateNotifierSetPartitionerKeyspaceChanged(KeyspaceUpdateEvent)Init(*Session)IsLocal(host *HostInfo)bool// Pick returns an iteration function over selected hosts.// Multiple attempts of a single query execution won't call the returned NextHost function concurrently,// so it's safe to have internal state without additional synchronization as long as every call to Pick returns// a different instance of NextHost.Pick(ExecutableQuery)NextHost}

funcDCAwareRoundRobinPolicy¶

func DCAwareRoundRobinPolicy(localDCstring)HostSelectionPolicy

DCAwareRoundRobinPolicy is a host selection policies which will prioritize andreturn hosts which are in the local datacentre before returning hosts in allother datercentres

funcHostPoolHostPolicy¶

func HostPoolHostPolicy(hp hostpool.HostPool)HostSelectionPolicy

HostPoolHostPolicy is a host policy which uses the bitly/go-hostpool libraryto distribute queries between hosts and prevent sending queries tounresponsive hosts. When creating the host pool that is passed to the policyuse an empty slice of hosts as the hostpool will be populated later by gocql.See below for examples of usage:

// Create host selection policy using a simple host poolcluster.PoolConfig.HostSelectionPolicy = HostPoolHostPolicy(hostpool.New(nil))// Create host selection policy using an epsilon greedy poolcluster.PoolConfig.HostSelectionPolicy = HostPoolHostPolicy(    hostpool.NewEpsilonGreedy(nil, 0, &hostpool.LinearEpsilonValueCalculator{}),)

funcRackAwareRoundRobinPolicy¶added inv1.3.0

func RackAwareRoundRobinPolicy(localDCstring, localRackstring)HostSelectionPolicy

funcRoundRobinHostPolicy¶

func RoundRobinHostPolicy()HostSelectionPolicy

RoundRobinHostPolicy is a round-robin load balancing policy, where each hostis tried sequentially for each query.

funcTokenAwareHostPolicy¶

func TokenAwareHostPolicy(fallbackHostSelectionPolicy, opts ...func(*tokenAwareHostPolicy))HostSelectionPolicy

TokenAwareHostPolicy is a token aware host selection policy, where hosts areselected based on the partition key, so queries are sent to the host whichowns the partition. Fallback is used when routing information is not available.

type HostStateNotifier interface {AddHost(host *HostInfo)RemoveHost(host *HostInfo)HostUp(host *HostInfo)HostDown(host *HostInfo)}

type HostTierer interface {// HostTier returns an integer specifying how far a host is from the client.// Tier must start at 0.// The value is used to prioritize closer hosts during host selection.// For example this could be:// 0 - local rack, 1 - local DC, 2 - remote DC// or:// 0 - local DC, 1 - remote DCHostTier(host *HostInfo)uint// This function returns the maximum possible host tierMaxHostTier()uint}

type Iter struct {// contains filtered or unexported fields}

func (*Iter)Close¶

func (iter *Iter) Close()error

Close closes the iterator and returns any errors that happened duringthe query or the iteration.

func (*Iter)Columns¶

func (iter *Iter) Columns() []ColumnInfo

Columns returns the name and type of the selected columns.

func (*Iter)GetCustomPayload¶

func (iter *Iter) GetCustomPayload() map[string][]byte

GetCustomPayload returns any parsed custom payload results if given in theresponse from Cassandra. Note that the result is not a copy.

This additional feature of CQL Protocol v4allows additional results and query information to be returned bycustom QueryHandlers running in your C* cluster.Seehttps://datastax.github.io/java-driver/manual/custom_payloads/

func (*Iter)Host¶

func (iter *Iter) Host() *HostInfo

Host returns the host which the query was sent to.

func (*Iter)MapScan¶

func (iter *Iter) MapScan(m map[string]interface{})bool

MapScan takes a map[string]interface{} and populates it with a rowthat is returned from cassandra.

Each call to MapScan() must be called with a new map object.During the call to MapScan() any pointers in the existing mapare replaced with non pointer types before the call returns

iter := session.Query(`SELECT * FROM mytable`).Iter()for {// New map each iterationrow := make(map[string]interface{})if !iter.MapScan(row) {break}// Do things with rowif fullname, ok := row["fullname"]; ok {fmt.Printf("Full Name: %s\n", fullname)}}

You can also pass pointers in the map before each call

var fullName FullName // Implements gocql.Unmarshaler and gocql.Marshaler interfacesvar address net.IPvar age intiter := session.Query(`SELECT * FROM scan_map_table`).Iter()for {// New map each iterationrow := map[string]interface{}{"fullname": &fullName,"age":      &age,"address":  &address,}if !iter.MapScan(row) {break}fmt.Printf("First: %s Age: %d Address: %q\n", fullName.FirstName, age, address)}

func (*Iter)NumRows¶

func (iter *Iter) NumRows()int

NumRows returns the number of rows in this pagination, it will update when newpages are fetched, it is not the value of the total number of rows this iterwill return unless there is only a single page returned.

func (*Iter)PageState¶

func (iter *Iter) PageState() []byte

PageState return the current paging state for a query which can be used forsubsequent queries to resume paging this point.

func (*Iter)RowData¶

func (iter *Iter) RowData() (RowData,error)

func (*Iter)Scan¶

func (iter *Iter) Scan(dest ...interface{})bool

Scan consumes the next row of the iterator and copies the columns of thecurrent row into the values pointed at by dest. Use nil as a dest valueto skip the corresponding column. Scan might send additional queriesto the database to retrieve the next set of rows if paging was enabled.

Scan returns true if the row was successfully unmarshaled or false if theend of the result set was reached or if an error occurred. Close shouldbe called afterwards to retrieve any potential errors.

func (*Iter)Scanner¶

func (iter *Iter) Scanner()Scanner

Scanner returns a row Scanner which provides an interface to scan rows in a manner which issimilar to database/sql. The iter should NOT be used again after calling this method.

func (*Iter)SliceMap¶

func (iter *Iter) SliceMap() ([]map[string]interface{},error)

SliceMap is a helper function to make the API easier to usereturns the data from the query in the form of []map[string]interface{}

func (*Iter)Warnings¶

func (iter *Iter) Warnings() []string

Warnings returns any warnings generated if given in the response from Cassandra.

This is only available starting with CQL Protocol v4.

func (*Iter)WillSwitchPage¶

func (iter *Iter) WillSwitchPage()bool

WillSwitchPage detects if iterator reached end of current pageand the next page is available.

type KeyspaceMetadata struct {NamestringDurableWritesboolStrategyClassstringStrategyOptions map[string]interface{}Tables          map[string]*TableMetadataFunctions       map[string]*FunctionMetadataAggregates      map[string]*AggregateMetadata// Deprecated: use the MaterializedViews field for views and UserTypes field for udts instead.Views             map[string]*ViewMetadataMaterializedViews map[string]*MaterializedViewMetadataUserTypes         map[string]*UserTypeMetadata}

type KeyspaceUpdateEvent struct {KeyspacestringChangestring}

type MarshalErrorstring

func (MarshalError)Error¶

func (mMarshalError) Error()string

type Marshaler interface {MarshalCQL(infoTypeInfo) ([]byte,error)}

type MaterializedViewMetadata struct {KeyspacestringNamestringBaseTableIdUUIDBaseTable               *TableMetadataBloomFilterFpChancefloat64Caching                 map[string]stringCommentstringCompaction              map[string]stringCompression             map[string]stringCrcCheckChancefloat64DcLocalReadRepairChancefloat64DefaultTimeToLiveintExtensions              map[string]stringGcGraceSecondsintIdUUIDIncludeAllColumnsboolMaxIndexIntervalintMemtableFlushPeriodInMsintMinIndexIntervalintReadRepairChancefloat64SpeculativeRetrystring// contains filtered or unexported fields}

type NativeType struct {// contains filtered or unexported fields}

funcNewNativeType¶

func NewNativeType(protobyte, typType, customstring)NativeType

func (NativeType)Custom¶

func (sNativeType) Custom()string

func (NativeType)New¶

func (tNativeType) New() interface{}

func (NativeType)NewWithError¶added inv1.1.0

func (tNativeType) NewWithError() (interface{},error)

func (NativeType)String¶

func (sNativeType) String()string

func (NativeType)Type¶

func (sNativeType) Type()Type

func (NativeType)Version¶

func (sNativeType) Version()byte

type NextHost func()SelectedHost

type NonSpeculativeExecution struct{}

func (NonSpeculativeExecution)Attempts¶

func (spNonSpeculativeExecution) Attempts()int

func (NonSpeculativeExecution)Delay¶

func (spNonSpeculativeExecution) Delay()time.Duration

type ObservedBatch struct {KeyspacestringStatements []string// Values holds a slice of bound values for each statement.// Values[i] are bound values passed to Statements[i].// Do not modify the values here, they are shared with multiple goroutines.Values [][]interface{}Starttime.Time// time immediately before the batch query was calledEndtime.Time// time immediately after the batch query returned// Host is the informations about the host that performed the batchHost *HostInfo// Err is the error in the batch query.// It only tracks network errors or errors of bad cassandra syntax, in particular selects with no match return nil errorErrerror// The metrics per this hostMetrics *hostMetrics// Attempt is the index of attempt at executing this query.// The first attempt is number zero and any retries have non-zero attempt number.Attemptint}

type ObservedConnect struct {// Host is the information about the host about to connectHost *HostInfoStarttime.Time// time immediately before the dial is calledEndtime.Time// time immediately after the dial returned// Err is the connection error (if any)Errerror}

type ObservedFrameHeader struct {Version protoVersionFlagsbyteStreamint16Opcode  frameOpLengthint32// StartHeader is the time we started reading the frame header off the network connection.Starttime.Time// EndHeader is the time we finished reading the frame header off the network connection.Endtime.Time// Host is Host of the connection the frame header was read from.Host *HostInfo}

func (ObservedFrameHeader)String¶

func (fObservedFrameHeader) String()string

type ObservedQuery struct {KeyspacestringStatementstring// Values holds a slice of bound values for the query.// Do not modify the values here, they are shared with multiple goroutines.Values []interface{}Starttime.Time// time immediately before the query was calledEndtime.Time// time immediately after the query returned// Rows is the number of rows in the current iter.// In paginated queries, rows from previous scans are not counted.// Rows is not used in batch queries and remains at the default valueRowsint// Host is the informations about the host that performed the queryHost *HostInfo// The metrics per this hostMetrics *hostMetrics// Err is the error in the query.// It only tracks network errors or errors of bad cassandra syntax, in particular selects with no match return nil errorErrerror// Attempt is the index of attempt at executing this query.// The first attempt is number zero and any retries have non-zero attempt number.Attemptint}

type ObservedStream struct {// Host of the connection used to send the stream.Host *HostInfo}

type PasswordAuthenticator struct {UsernamestringPasswordstringAllowedAuthenticators []string}

func (PasswordAuthenticator)Challenge¶

func (pPasswordAuthenticator) Challenge(req []byte) ([]byte,Authenticator,error)

func (PasswordAuthenticator)Success¶

func (pPasswordAuthenticator) Success(data []byte)error

type PoolConfig struct {// HostSelectionPolicy sets the policy for selecting which host to use for a// given query (default: RoundRobinHostPolicy())// It is not supported to use a single HostSelectionPolicy in multiple sessions// (even if you close the old session before using in a new session).HostSelectionPolicyHostSelectionPolicy}

type Query struct {// contains filtered or unexported fields}

func (*Query)AddAttempts¶

func (q *Query) AddAttempts(iint, host *HostInfo)

func (*Query)AddLatency¶

func (q *Query) AddLatency(lint64, host *HostInfo)

func (*Query)Attempts¶

func (q *Query) Attempts()int

Attempts returns the number of times the query was executed.

func (*Query)Bind¶

func (q *Query) Bind(v ...interface{}) *Query

Bind sets query arguments of query. This can also be used to rebind new query argumentsto an existing query instance.

func (*Query)Cancel¶

func (q *Query) Cancel()

Deprecate: does nothing, cancel the context passed to WithContext

func (*Query)Consistency¶

func (q *Query) Consistency(cConsistency) *Query

Consistency sets the consistency level for this query. If no consistencylevel have been set, the default consistency level of the clusteris used.

func (*Query)Context¶

func (q *Query) Context()context.Context

func (*Query)CustomPayload¶

func (q *Query) CustomPayload(customPayload map[string][]byte) *Query

CustomPayload sets the custom payload level for this query.

func (*Query)DefaultTimestamp¶

func (q *Query) DefaultTimestamp(enablebool) *Query

DefaultTimestamp will enable the with default timestamp flag on the query.If enable, this will replace the server side assignedtimestamp as default timestamp. Note that a timestamp in the query itselfwill still override this timestamp. This is entirely optional.

Only available on protocol >= 3

func (*Query)Exec¶

func (q *Query) Exec()error

Exec executes the query without returning any rows.

func (*Query)GetConsistency¶

func (q *Query) GetConsistency()Consistency

GetConsistency returns the currently configured consistency level forthe query.

func (*Query)GetRoutingKey¶

func (q *Query) GetRoutingKey() ([]byte,error)

GetRoutingKey gets the routing key to use for routing this query. Ifa routing key has not been explicitly set, then the routing key willbe constructed if possible using the keyspace's schema and the queryinfo for this query statement. If the routing key cannot be determinedthen nil will be returned with no error. On any error condition,an error description will be returned.

func (*Query)Idempotent¶

func (q *Query) Idempotent(valuebool) *Query

Idempotent marks the query as being idempotent or not depending onthe value.Non-idempotent query won't be retried.See "Retries and speculative execution" in package docs for more details.

func (*Query)IsIdempotent¶

func (q *Query) IsIdempotent()bool

IsIdempotent returns whether the query is marked as idempotent.Non-idempotent query won't be retried.See "Retries and speculative execution" in package docs for more details.

func (*Query)Iter¶

func (q *Query) Iter() *Iter

Iter executes the query and returns an iterator capable of iteratingover all results.

func (*Query)Keyspace¶

func (q *Query) Keyspace()string

Keyspace returns the keyspace the query will be executed against.

func (*Query)Latency¶

func (q *Query) Latency()int64

Latency returns the average amount of nanoseconds per attempt of the query.

func (*Query)MapScan¶

func (q *Query) MapScan(m map[string]interface{})error

MapScan executes the query, copies the columns of the first selectedrow into the map pointed at by m and discards the rest. If no rowswere selected, ErrNotFound is returned.

func (*Query)MapScanCAS¶

func (q *Query) MapScanCAS(dest map[string]interface{}) (appliedbool, errerror)

MapScanCAS executes a lightweight transaction (i.e. an UPDATE or INSERTstatement containing an IF clause). If the transaction fails becausethe existing values did not match, the previous values will be storedin dest map.

As for INSERT .. IF NOT EXISTS, previous values will be returned as ifSELECT * FROM. So using ScanCAS with INSERT is inherently prone tocolumn mismatching. MapScanCAS is added to capture them safely.

package mainimport ("context""fmt""log"gocql "github.com/gocql/gocql")func main() {/* The example assumes the following CQL was used to setup the keyspace:create keyspace example with replication = { 'class' : 'SimpleStrategy', 'replication_factor' : 1 };create table example.my_lwt_table(pk int, version int, value text, PRIMARY KEY(pk));*/cluster := gocql.NewCluster("localhost:9042")cluster.Keyspace = "example"cluster.ProtoVersion = 4session, err := cluster.CreateSession()if err != nil {log.Fatal(err)}defer session.Close()ctx := context.Background()err = session.Query("INSERT INTO example.my_lwt_table (pk, version, value) VALUES (?, ?, ?)",1, 1, "a").WithContext(ctx).Exec()if err != nil {log.Fatal(err)}m := make(map[string]interface{})applied, err := session.Query("UPDATE example.my_lwt_table SET value = ? WHERE pk = ? IF version = ?","b", 1, 0).WithContext(ctx).MapScanCAS(m)if err != nil {log.Fatal(err)}fmt.Println(applied, m)var value stringerr = session.Query("SELECT value FROM example.my_lwt_table WHERE pk = ?", 1).WithContext(ctx).Scan(&value)if err != nil {log.Fatal(err)}fmt.Println(value)m = make(map[string]interface{})applied, err = session.Query("UPDATE example.my_lwt_table SET value = ? WHERE pk = ? IF version = ?","b", 1, 1).WithContext(ctx).MapScanCAS(m)if err != nil {log.Fatal(err)}fmt.Println(applied, m)var value2 stringerr = session.Query("SELECT value FROM example.my_lwt_table WHERE pk = ?", 1).WithContext(ctx).Scan(&value2)if err != nil {log.Fatal(err)}fmt.Println(value2)// false map[version:1]// a// true map[]// b}

Output:

func (*Query)NoSkipMetadata¶

func (q *Query) NoSkipMetadata() *Query

NoSkipMetadata will override the internal result metadata cache so that the driver does notsend skip_metadata for queries, this means that the result will always containthe metadata to parse the rows and will not reuse the metadata from the preparedstatement. This should only be used to work around cassandra bugs, such as when usingCAS operations which do not end in Cas.

Seehttps://issues.apache.org/jira/browse/CASSANDRA-11099https://github.com/apache/cassandra-gocql-driver/issues/612

func (*Query)Observer¶

func (q *Query) Observer(observerQueryObserver) *Query

Observer enables query-level observer on this query.The provided observer will be called every time this query is executed.

func (*Query)PageSize¶

func (q *Query) PageSize(nint) *Query

PageSize will tell the iterator to fetch the result in pages of size n.This is useful for iterating over large result sets, but setting thepage size too low might decrease the performance. This feature is onlyavailable in Cassandra 2 and onwards.

func (*Query)PageState¶

func (q *Query) PageState(state []byte) *Query

PageState sets the paging state for the query to resume paging from a specificpoint in time. Setting this will disable to query paging for this query, andmust be used for all subsequent pages.

func (*Query)Prefetch¶

func (q *Query) Prefetch(pfloat64) *Query

SetPrefetch sets the default threshold for pre-fetching new pages. Ifthere are only p*pageSize rows remaining, the next page will be requestedautomatically.

func (*Query)Release¶

func (q *Query) Release()

Release releases a query back into a pool of queries. Released Queriescannot be reused.

Example:

qry := session.Query("SELECT * FROM my_table")qry.Exec()qry.Release()

func (*Query)RetryPolicy¶

func (q *Query) RetryPolicy(rRetryPolicy) *Query

RetryPolicy sets the policy to use when retrying the query.

func (*Query)RoutingKey¶

func (q *Query) RoutingKey(routingKey []byte) *Query

RoutingKey sets the routing key to use when a token aware connectionpool is used to optimize the routing of this query.

func (*Query)Scan¶

func (q *Query) Scan(dest ...interface{})error

Scan executes the query, copies the columns of the first selectedrow into the values pointed at by dest and discards the rest. If no rowswere selected, ErrNotFound is returned.

func (*Query)ScanCAS¶

func (q *Query) ScanCAS(dest ...interface{}) (appliedbool, errerror)

ScanCAS executes a lightweight transaction (i.e. an UPDATE or INSERTstatement containing an IF clause). If the transaction fails becausethe existing values did not match, the previous values will be storedin dest.

As for INSERT .. IF NOT EXISTS, previous values will be returned as ifSELECT * FROM. So using ScanCAS with INSERT is inherently prone tocolumn mismatching. Use MapScanCAS to capture them safely.

func (*Query)SerialConsistency¶

func (q *Query) SerialConsistency(consSerialConsistency) *Query

SerialConsistency sets the consistency level for theserial phase of conditional updates. That consistency can only beeither SERIAL or LOCAL_SERIAL and if not present, it defaults toSERIAL. This option will be ignored for anything else that aconditional update/insert.

func (*Query)SetConsistency¶

func (q *Query) SetConsistency(cConsistency)

Same as Consistency but without a return value

func (*Query)SetSpeculativeExecutionPolicy¶

func (q *Query) SetSpeculativeExecutionPolicy(spSpeculativeExecutionPolicy) *Query

SetSpeculativeExecutionPolicy sets the execution policy

func (Query)Statement¶

func (qQuery) Statement()string

Statement returns the statement that was used to generate this query.

func (Query)String¶

func (qQuery) String()string

String implements the stringer interface.

func (*Query)Table¶added inv1.6.0

func (q *Query) Table()string

Table returns name of the table the query will be executed against.

func (*Query)Trace¶

func (q *Query) Trace(traceTracer) *Query

Trace enables tracing of this query. Look at the documentation of theTracer interface to learn more about tracing.

func (Query)Values¶added inv1.5.0

func (qQuery) Values() []interface{}

Values returns the values passed in via Bind.This can be used by a wrapper type that needs to access the bound values.

func (*Query)WithContext¶

func (q *Query) WithContext(ctxcontext.Context) *Query

WithContext returns a shallow copy of q with its contextset to ctx.

The provided context controls the entire lifetime of executing aquery, queries will be canceled and return once the context iscanceled.

func (*Query)WithTimestamp¶

func (q *Query) WithTimestamp(timestampint64) *Query

WithTimestamp will enable the with default timestamp flag on the querylike DefaultTimestamp does. But also allows to define value for timestamp.It works the same way as USING TIMESTAMP in the query itself, butshould not break prepared query optimization.

Only available on protocol >= 3

type QueryInfo struct {Id          []byteArgs        []ColumnInfoRval        []ColumnInfoPKeyColumns []int}

type QueryObserver interface {// ObserveQuery gets called on every query to cassandra, including all queries in an iterator when paging is enabled.// It doesn't get called if there is no query because the session is closed or there are no connections available.// The error reported only shows query errors, i.e. if a SELECT is valid but finds no matches it will be nil.ObserveQuery(context.Context,ObservedQuery)}

type ReadyPolicy interface {Ready()bool}

type ReconnectionPolicy interface {GetInterval(currentRetryint)time.DurationGetMaxRetries()int}

type RequestErrAlreadyExists struct {KeyspacestringTablestring// contains filtered or unexported fields}

func (RequestErrAlreadyExists)Code¶

func (e RequestErrAlreadyExists) Code()int

func (RequestErrAlreadyExists)Error¶

func (e RequestErrAlreadyExists) Error()string

func (RequestErrAlreadyExists)Message¶

func (e RequestErrAlreadyExists) Message()string

func (RequestErrAlreadyExists)String¶

func (e RequestErrAlreadyExists) String()string

type RequestErrCASWriteUnknown struct {ConsistencyConsistencyReceivedintBlockForint// contains filtered or unexported fields}

func (RequestErrCASWriteUnknown)Code¶

func (e RequestErrCASWriteUnknown) Code()int

func (RequestErrCASWriteUnknown)Error¶

func (e RequestErrCASWriteUnknown) Error()string

func (RequestErrCASWriteUnknown)Message¶

func (e RequestErrCASWriteUnknown) Message()string

func (RequestErrCASWriteUnknown)String¶

func (e RequestErrCASWriteUnknown) String()string

type RequestErrCDCWriteFailure struct {// contains filtered or unexported fields}

func (RequestErrCDCWriteFailure)Code¶

func (e RequestErrCDCWriteFailure) Code()int

func (RequestErrCDCWriteFailure)Error¶

func (e RequestErrCDCWriteFailure) Error()string

func (RequestErrCDCWriteFailure)Message¶

func (e RequestErrCDCWriteFailure) Message()string

func (RequestErrCDCWriteFailure)String¶

func (e RequestErrCDCWriteFailure) String()string

type RequestErrFunctionFailure struct {KeyspacestringFunctionstringArgTypes []string// contains filtered or unexported fields}

func (RequestErrFunctionFailure)Code¶

func (e RequestErrFunctionFailure) Code()int

func (RequestErrFunctionFailure)Error¶

func (e RequestErrFunctionFailure) Error()string

func (RequestErrFunctionFailure)Message¶

func (e RequestErrFunctionFailure) Message()string

func (RequestErrFunctionFailure)String¶

func (e RequestErrFunctionFailure) String()string

type RequestErrReadFailure struct {ConsistencyConsistencyReceivedintBlockForintNumFailuresintDataPresentboolErrorMapErrorMap// contains filtered or unexported fields}

func (RequestErrReadFailure)Code¶

func (e RequestErrReadFailure) Code()int

func (RequestErrReadFailure)Error¶

func (e RequestErrReadFailure) Error()string

func (RequestErrReadFailure)Message¶

func (e RequestErrReadFailure) Message()string

func (RequestErrReadFailure)String¶

func (e RequestErrReadFailure) String()string

type RequestErrReadTimeout struct {ConsistencyConsistencyReceivedintBlockForintDataPresentbyte// contains filtered or unexported fields}

func (RequestErrReadTimeout)Code¶

func (e RequestErrReadTimeout) Code()int

func (RequestErrReadTimeout)Error¶

func (e RequestErrReadTimeout) Error()string

func (RequestErrReadTimeout)Message¶

func (e RequestErrReadTimeout) Message()string

func (RequestErrReadTimeout)String¶

func (e RequestErrReadTimeout) String()string

type RequestErrUnavailable struct {ConsistencyConsistencyRequiredintAliveint// contains filtered or unexported fields}

func (RequestErrUnavailable)Code¶

func (e RequestErrUnavailable) Code()int

func (RequestErrUnavailable)Error¶

func (e RequestErrUnavailable) Error()string

func (RequestErrUnavailable)Message¶

func (e RequestErrUnavailable) Message()string

func (*RequestErrUnavailable)String¶

func (e *RequestErrUnavailable) String()string

type RequestErrUnprepared struct {StatementId []byte// contains filtered or unexported fields}

func (RequestErrUnprepared)Code¶

func (e RequestErrUnprepared) Code()int

func (RequestErrUnprepared)Error¶

func (e RequestErrUnprepared) Error()string

func (RequestErrUnprepared)Message¶

func (e RequestErrUnprepared) Message()string

func (RequestErrUnprepared)String¶

func (e RequestErrUnprepared) String()string

type RequestErrWriteFailure struct {ConsistencyConsistencyReceivedintBlockForintNumFailuresintWriteTypestringErrorMapErrorMap// contains filtered or unexported fields}

func (RequestErrWriteFailure)Code¶

func (e RequestErrWriteFailure) Code()int

func (RequestErrWriteFailure)Error¶

func (e RequestErrWriteFailure) Error()string

func (RequestErrWriteFailure)Message¶

func (e RequestErrWriteFailure) Message()string

func (RequestErrWriteFailure)String¶

func (e RequestErrWriteFailure) String()string

type RequestErrWriteTimeout struct {ConsistencyConsistencyReceivedintBlockForintWriteTypestring// contains filtered or unexported fields}

func (RequestErrWriteTimeout)Code¶

func (e RequestErrWriteTimeout) Code()int

func (RequestErrWriteTimeout)Error¶

func (e RequestErrWriteTimeout) Error()string

func (RequestErrWriteTimeout)Message¶

func (e RequestErrWriteTimeout) Message()string

func (RequestErrWriteTimeout)String¶

func (e RequestErrWriteTimeout) String()string

type RequestError interface {Code()intMessage()stringError()string}

type RetryPolicy interface {Attempt(RetryableQuery)boolGetRetryType(error)RetryType}

type RetryTypeuint16

type RetryableQuery interface {Attempts()intSetConsistency(cConsistency)GetConsistency()ConsistencyContext()context.Context}

type RowData struct {Columns []stringValues  []interface{}}

type Scanner interface {// Next advances the row pointer to point at the next row, the row is valid until// the next call of Next. It returns true if there is a row which is available to be// scanned into with Scan.// Next must be called before every call to Scan.Next()bool// Scan copies the current row's columns into dest. If the length of dest does not equal// the number of columns returned in the row an error is returned. If an error is encountered// when unmarshalling a column into the value in dest an error is returned and the row is invalidated// until the next call to Next.// Next must be called before calling Scan, if it is not an error is returned.Scan(...interface{})error// Err returns the if there was one during iteration that resulted in iteration being unable to complete.// Err will also release resources held by the iterator, the Scanner should not used after being called.Err()error}

type SelectedHost interface {Info() *HostInfoMark(error)}

type SerialConsistencyuint16

func (SerialConsistency)MarshalText¶

func (sSerialConsistency) MarshalText() (text []byte, errerror)

func (SerialConsistency)String¶

func (sSerialConsistency) String()string

func (*SerialConsistency)UnmarshalText¶

func (s *SerialConsistency) UnmarshalText(text []byte)error

type Session struct {// contains filtered or unexported fields}

funcNewSession¶

func NewSession(cfgClusterConfig) (*Session,error)

NewSession wraps an existing Node.

func (*Session)AwaitSchemaAgreement¶

func (s *Session) AwaitSchemaAgreement(ctxcontext.Context)error

AwaitSchemaAgreement will wait until schema versions across all nodes in thecluster are the same (as seen from the point of view of the control connection).The maximum amount of time this takes is governedby the MaxWaitSchemaAgreement setting in the configuration (default: 60s).AwaitSchemaAgreement returns an error in case schema versions are not the sameafter the timeout specified in MaxWaitSchemaAgreement elapses.

func (*Session)Bind¶

func (s *Session) Bind(stmtstring, b func(q *QueryInfo) ([]interface{},error)) *Query

Bind generates a new query object based on the query statement passed in.The query is automatically prepared if it has not previously been executed.The binding callback allows the application to define which query argumentvalues will be marshalled as part of the query execution.During execution, the meta data of the prepared query will be routed to thebinding callback, which is responsible for producing the query argument values.

func (*Session)Close¶

func (s *Session) Close()

Close closes all connections. The session is unusable after thisoperation.

func (*Session)Closed¶

func (s *Session) Closed()bool

func (*Session)ExecuteBatch¶

func (s *Session) ExecuteBatch(batch *Batch)error

ExecuteBatch executes a batch operation and returns nil if successfulotherwise an error is returned describing the failure.

func (*Session)ExecuteBatchCAS¶

func (s *Session) ExecuteBatchCAS(batch *Batch, dest ...interface{}) (appliedbool, iter *Iter, errerror)

ExecuteBatchCAS executes a batch operation and returns true if successful andan iterator (to scan additional rows if more than one conditional statement)was sent.Further scans on the interator must also remember to includethe applied boolean as the first argument to *Iter.Scan

func (*Session)KeyspaceMetadata¶

func (s *Session) KeyspaceMetadata(keyspacestring) (*KeyspaceMetadata,error)

KeyspaceMetadata returns the schema metadata for the keyspace specified. Returns an error if the keyspace does not exist.

func (*Session)MapExecuteBatchCAS¶

func (s *Session) MapExecuteBatchCAS(batch *Batch, dest map[string]interface{}) (appliedbool, iter *Iter, errerror)

MapExecuteBatchCAS executes a batch operation much like ExecuteBatchCAS,however it accepts a map rather than a list of arguments for the initialscan.

package mainimport ("context""fmt""log"gocql "github.com/gocql/gocql")func main() {/* The example assumes the following CQL was used to setup the keyspace:create keyspace example with replication = { 'class' : 'SimpleStrategy', 'replication_factor' : 1 };create table example.my_lwt_batch_table(pk text, ck text, version int, value text, PRIMARY KEY(pk, ck));*/cluster := gocql.NewCluster("localhost:9042")cluster.Keyspace = "example"cluster.ProtoVersion = 4session, err := cluster.CreateSession()if err != nil {log.Fatal(err)}defer session.Close()ctx := context.Background()err = session.Query("INSERT INTO example.my_lwt_batch_table (pk, ck, version, value) VALUES (?, ?, ?, ?)","pk1", "ck1", 1, "a").WithContext(ctx).Exec()if err != nil {log.Fatal(err)}err = session.Query("INSERT INTO example.my_lwt_batch_table (pk, ck, version, value) VALUES (?, ?, ?, ?)","pk1", "ck2", 1, "A").WithContext(ctx).Exec()if err != nil {log.Fatal(err)}executeBatch := func(ck2Version int) {b := session.NewBatch(gocql.LoggedBatch)b.Entries = append(b.Entries, gocql.BatchEntry{Stmt: "UPDATE my_lwt_batch_table SET value=? WHERE pk=? AND ck=? IF version=?",Args: []interface{}{"b", "pk1", "ck1", 1},})b.Entries = append(b.Entries, gocql.BatchEntry{Stmt: "UPDATE my_lwt_batch_table SET value=? WHERE pk=? AND ck=? IF version=?",Args: []interface{}{"B", "pk1", "ck2", ck2Version},})m := make(map[string]interface{})applied, iter, err := session.MapExecuteBatchCAS(b.WithContext(ctx), m)if err != nil {log.Fatal(err)}fmt.Println(applied, m)m = make(map[string]interface{})for iter.MapScan(m) {fmt.Println(m)m = make(map[string]interface{})}if err := iter.Close(); err != nil {log.Fatal(err)}}printState := func() {scanner := session.Query("SELECT ck, value FROM example.my_lwt_batch_table WHERE pk = ?", "pk1").WithContext(ctx).Iter().Scanner()for scanner.Next() {var ck, value stringerr = scanner.Scan(&ck, &value)if err != nil {log.Fatal(err)}fmt.Println(ck, value)}if err := scanner.Err(); err != nil {log.Fatal(err)}}executeBatch(0)printState()executeBatch(1)printState()// false map[ck:ck1 pk:pk1 version:1]// map[[applied]:false ck:ck2 pk:pk1 version:1]// ck1 a// ck2 A// true map[]// ck1 b// ck2 B}

Output:

func (*Session)NewBatch¶

func (s *Session) NewBatch(typBatchType) *Batch

NewBatch creates a new batch operation using defaults defined in the cluster

func (*Session)Query¶

func (s *Session) Query(stmtstring, values ...interface{}) *Query

Query generates a new query object for interacting with the database.Further details of the query may be tweaked using the resulting queryvalue before the query is executed. Query is automatically preparedif it has not previously been executed.

func (*Session)SetConsistency¶

func (s *Session) SetConsistency(consConsistency)

SetConsistency sets the default consistency level for this session. Thissetting can also be changed on a per-query basis and the default valueis Quorum.

func (*Session)SetPageSize¶

func (s *Session) SetPageSize(nint)

SetPageSize sets the default page size for this session. A value <= 0 willdisable paging. This setting can also be changed on a per-query basis.

func (*Session)SetPrefetch¶

func (s *Session) SetPrefetch(pfloat64)

SetPrefetch sets the default threshold for pre-fetching new pages. Ifthere are only p*pageSize rows remaining, the next page will be requestedautomatically. This value can also be changed on a per-query basis andthe default value is 0.25.

func (*Session)SetTrace¶

func (s *Session) SetTrace(traceTracer)

SetTrace sets the default tracer for this session. This setting can alsobe changed on a per-query basis.

type SetHosts interface {SetHosts(hosts []*HostInfo)}

type SetPartitioner interface {SetPartitioner(partitionerstring)}

type SimpleConvictionPolicy struct {}

func (*SimpleConvictionPolicy)AddFailure¶

func (e *SimpleConvictionPolicy) AddFailure(errorerror, host *HostInfo)bool

func (*SimpleConvictionPolicy)Reset¶

func (e *SimpleConvictionPolicy) Reset(host *HostInfo)

type SimpleRetryPolicy struct {NumRetriesint//Number of times to retry a query}

func (*SimpleRetryPolicy)Attempt¶

func (s *SimpleRetryPolicy) Attempt(qRetryableQuery)bool

Attempt tells gocql to attempt the query again based on query.Attempts being lessthan the NumRetries defined in the policy.

func (*SimpleRetryPolicy)GetRetryType¶

func (s *SimpleRetryPolicy) GetRetryType(errerror)RetryType

type SimpleSpeculativeExecution struct {NumAttemptsintTimeoutDelaytime.Duration}

func (*SimpleSpeculativeExecution)Attempts¶

func (sp *SimpleSpeculativeExecution) Attempts()int

func (*SimpleSpeculativeExecution)Delay¶

func (sp *SimpleSpeculativeExecution) Delay()time.Duration

type SnappyCompressor struct{}

func (SnappyCompressor)Decode¶

func (sSnappyCompressor) Decode(data []byte) ([]byte,error)

func (SnappyCompressor)Encode¶

func (sSnappyCompressor) Encode(data []byte) ([]byte,error)

func (SnappyCompressor)Name¶

func (sSnappyCompressor) Name()string

type SpeculativeExecutionPolicy interface {Attempts()intDelay()time.Duration}

type SslOptions struct {*tls.Config// CertPath and KeyPath are optional depending on server// config, but both fields must be omitted to avoid using a// client certificateCertPathstringKeyPathstringCaPathstring//optional depending on server config// If you want to verify the hostname and server cert (like a wildcard for cass cluster) then you should turn this// on.// This option is basically the inverse of tls.Config.InsecureSkipVerify.// See InsecureSkipVerify inhttp://golang.org/pkg/crypto/tls/ for more info.//// See SslOptions documentation to see how EnableHostVerification interacts with the provided tls.Config.EnableHostVerificationbool}

type StdLogger interface {Print(v ...interface{})Printf(formatstring, v ...interface{})Println(v ...interface{})}

var LoggerStdLogger = &defaultLogger{}

Logger for logging messages.Deprecated: Use ClusterConfig.Logger instead.

type StreamObserver interface {// StreamContext is called before creating a new stream.// ctx is context passed to Session.Query / Session.Batch,// but might also be an internal context (for example// for internal requests that use control connection).// StreamContext might return nil if it is not interested// in the details of this stream.// StreamContext is called before the stream is created// and the returned StreamObserverContext might be discarded// without any methods called on the StreamObserverContext if// creation of the stream fails.// Note that if you don't need to track per-stream data,// you can always return the same StreamObserverContext.StreamContext(ctxcontext.Context)StreamObserverContext}

type StreamObserverContext interface {// StreamStarted is called when the stream is started.// This happens just before a request is written to the wire.StreamStarted(observedStreamObservedStream)// StreamAbandoned is called when we stop waiting for response.// This happens when the underlying network connection is closed.// StreamFinished won't be called if StreamAbandoned is.StreamAbandoned(observedStreamObservedStream)// StreamFinished is called when we receive a response for the stream.StreamFinished(observedStreamObservedStream)}

type TableMetadata struct {KeyspacestringNamestringKeyValidatorstringComparatorstringDefaultValidatorstringKeyAliases        []stringColumnAliases     []stringValueAliasstringPartitionKey      []*ColumnMetadataClusteringColumns []*ColumnMetadataColumns           map[string]*ColumnMetadataOrderedColumns    []string}

type Tracer interface {Trace(traceId []byte)}

funcNewTraceWriter¶

func NewTraceWriter(session *Session, wio.Writer)Tracer

NewTraceWriter returns a simple Tracer implementation that outputsthe event log in a textual format.

type TupleTypeInfo struct {NativeTypeElems []TypeInfo}

func (TupleTypeInfo)New¶

func (tTupleTypeInfo) New() interface{}

func (TupleTypeInfo)NewWithError¶added inv1.1.0

func (tTupleTypeInfo) NewWithError() (interface{},error)

func (TupleTypeInfo)String¶

func (tTupleTypeInfo) String()string

type Typeint

func (Type)String¶

func (tType) String()string

String returns the name of the identifier.

type TypeInfo interface {Type()TypeVersion()byteCustom()string// New creates a pointer to an empty version of whatever type// is referenced by the TypeInfo receiver.//// If there is no corresponding Go type for the CQL type, New panics.//// Deprecated: Use NewWithError instead.New() interface{}// NewWithError creates a pointer to an empty version of whatever type// is referenced by the TypeInfo receiver.//// If there is no corresponding Go type for the CQL type, NewWithError returns an error.NewWithError() (interface{},error)}

type UDTField struct {NamestringTypeTypeInfo}

type UDTMarshaler interface {// MarshalUDT will be called for each field in the the UDT returned by Cassandra,// the implementor should marshal the type to return by for example calling// Marshal.MarshalUDT(namestring, infoTypeInfo) ([]byte,error)}

type UDTTypeInfo struct {NativeTypeKeySpacestringNamestringElements []UDTField}

func (UDTTypeInfo)New¶

func (uUDTTypeInfo) New() interface{}

func (UDTTypeInfo)NewWithError¶added inv1.1.0

func (uUDTTypeInfo) NewWithError() (interface{},error)

func (UDTTypeInfo)String¶

func (uUDTTypeInfo) String()string

type UDTUnmarshaler interface {// UnmarshalUDT will be called for each field in the UDT return by Cassandra,// the implementor should unmarshal the data into the value of their chosing,// for example by calling Unmarshal.UnmarshalUDT(namestring, infoTypeInfo, data []byte)error}

type UUID [16]byte

funcMaxTimeUUID¶

func MaxTimeUUID(ttime.Time)UUID

MaxTimeUUID generates a "fake" time based UUID (version 1) which will bethe biggest possible UUID generated for the provided timestamp.

UUIDs generated by this function are not unique and are mostly suitable onlyin queries to select a time range of a Cassandra's TimeUUID column.

funcMinTimeUUID¶

func MinTimeUUID(ttime.Time)UUID

MinTimeUUID generates a "fake" time based UUID (version 1) which will bethe smallest possible UUID generated for the provided timestamp.

UUIDs generated by this function are not unique and are mostly suitable onlyin queries to select a time range of a Cassandra's TimeUUID column.

funcMustRandomUUID¶added inv1.2.0

func MustRandomUUID()UUID

funcParseUUID¶

func ParseUUID(inputstring) (UUID,error)

ParseUUID parses a 32 digit hexadecimal number (that might contain hypens)representing an UUID.

funcRandomUUID¶

func RandomUUID() (UUID,error)

RandomUUID generates a totally random UUID (version 4) as described inRFC 4122.

funcTimeUUID¶

func TimeUUID()UUID

TimeUUID generates a new time based UUID (version 1) using the currenttime as the timestamp.

funcTimeUUIDWith¶

func TimeUUIDWith(tint64, clockuint32, node []byte)UUID

TimeUUIDWith generates a new time based UUID (version 1) as described inRFC4122 with given parameters. t is the number of 100's of nanosecondssince 15 Oct 1582 (60bits). clock is the number of clock sequence (14bits).node is a slice to gurarantee the uniqueness of the UUID (up to 6bytes).Note: calling this function does not increment the static clock sequence.

funcUUIDFromBytes¶

func UUIDFromBytes(input []byte) (UUID,error)

UUIDFromBytes converts a raw byte slice to an UUID.

funcUUIDFromTime¶

func UUIDFromTime(ttime.Time)UUID

UUIDFromTime generates a new time based UUID (version 1) as described inRFC 4122. This UUID contains the MAC address of the node that generatedthe UUID, the given timestamp and a sequence number.

func (UUID)Bytes¶

func (uUUID) Bytes() []byte

Bytes returns the raw byte slice for this UUID. A UUID is always 128 bits(16 bytes) long.

func (UUID)Clock¶

func (uUUID) Clock()uint32

Clock extracts the clock sequence of this UUID. It will return zero if theUUID is not a time based UUID (version 1).

func (UUID)MarshalJSON¶

func (uUUID) MarshalJSON() ([]byte,error)

Marshaling for JSON

func (UUID)MarshalText¶

func (uUUID) MarshalText() ([]byte,error)

func (UUID)Node¶

func (uUUID) Node() []byte

Node extracts the MAC address of the node who generated this UUID. It willreturn nil if the UUID is not a time based UUID (version 1).

func (UUID)String¶

func (uUUID) String()string

String returns the UUID in it's canonical form, a 32 digit hexadecimalnumber in the form of xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx.

func (UUID)Time¶

func (uUUID) Time()time.Time

Time is like Timestamp, except that it returns a time.Time.

func (UUID)Timestamp¶

func (uUUID) Timestamp()int64

Timestamp extracts the timestamp information from a time based UUID(version 1).

func (*UUID)UnmarshalJSON¶

func (u *UUID) UnmarshalJSON(data []byte)error

Unmarshaling for JSON

func (*UUID)UnmarshalText¶

func (u *UUID) UnmarshalText(text []byte) (errerror)

func (UUID)Variant¶

func (uUUID) Variant()int

Variant returns the variant of this UUID. This package will only generateUUIDs in the IETF variant.

func (UUID)Version¶

func (uUUID) Version()int

Version extracts the version of this UUID variant. TheRFC 4122 describesfive kinds of UUIDs.

type UnmarshalErrorstring

func (UnmarshalError)Error¶

func (mUnmarshalError) Error()string

type Unmarshaler interface {UnmarshalCQL(infoTypeInfo, data []byte)error}

type UserTypeMetadata struct {KeyspacestringNamestringFieldNames []stringFieldTypes []TypeInfo}

type ViewMetadata struct {KeyspacestringNamestringFieldNames []stringFieldTypes []TypeInfo}