A type that can be converted from and to some CQL Value.

This type-class is used to map custom types to Cassandra data-types. For example:

newtype MyType = MyType Int32

instance Cql MyType where
    ctype              = Tagged IntColumn
    toCql (MyType i)   = CqlInt i
    fromCql (CqlInt i) = Right (MyType i)
    fromCql _          = Left "Expected CqlInt"

Opaque token passed to the server to continue result paging.

ID representing a prepared query.

CQL binary protocol version.

The CQL version (not the binary protocol version).

Consistency level.

An opcode is a tag to distinguish protocol frame bodies.

The type of a single CQL column.

A CQL value. The various constructors correspond to CQL data-types for individual columns in Cassandra.

Tag some value with a phantom type.

Protocol frame header.

Deserialise a frame header using the version specific decoding format.

The type denoting a protocol frame length.

Streams allow multiplexing of requests over a single communication channel. The StreamId correlates Requests with Responses.

Create a StreamId from the given integral value. In version 2, a StreamId is an Int8 and in version 3 an Int16.

Convert the stream ID to an integer.

Type representing header flags. Flags form a monoid and can be used as in compress <> tracing <> mempty.

Compression flag. If set, the frame body is compressed.

Tracing flag. If a request support tracing and the tracing flag was set, the response to this request will have the tracing flag set and contain tracing information.

Check if a particular flag is present.

The type corresponding to the protocol request frame.

The type parameter k denotes the kind of request. It is present to allow distinguishing read operations from write operations. Use R for read, W for write and S for schema related operations.

a represents the argument type and b the return type of this request.

Serialise the given request, optionally using compression. The result is either an error description in case of failure or a binary protocol frame, including Header, Length and body.

Get the protocol OpCode corresponding to the given Request.

An options request, send prior to Startup to request the server's startup options.

A startup request which is used when initialising a connection to the server. It specifies the CQL version to use and optionally the compression algorithm.

A request send in response to a previous authentication challenge.

Register's the connection this request is made through, to receive server events.

Event types to register.

A CQL query (select, insert, etc.).

Query parameters.

Consistency level for the serial phase of conditional updates.

Allows executing a list of queries (prepared or not) as a batch.

A GADT to unify queries and prepared queries both of which can be used in batch requests.

Prepare a query for later execution (cf. Execute).

Executes a prepared query.

The type corresponding to the protocol response frame.

The type parameter k denotes the kind of response. It is present to allow distinguishing read operations from write operations. Use R for read, W for write and S for schema related operations.

a represents the argument type and b the return type of this response.

Deserialise a Response from the given ByteString.

The server is ready to process queries. Response of a Startup request.

The server requires authentication.

A server-send authentication challenge.

Indicates the success of an authentication phase.

Query response.

Part of a RowsResult. Describes the result set.

The column specification. Part of MetaData unless skipMetaData in QueryParams was True.

The startup options supported by the server. Response of an Options request.

Messages send by the server without request, if the connection has been Registered to receive such events.

Error response.

A row is a vector of Values.

Convert a row element.

Record/Tuple conversion. For example:

data Peer = Peer
    { peerAddr :: IP
    , peerRPC  :: IP
    , peerDC   :: Text
    , peerRack :: Text
    } deriving Show

recordInstance ''Peer

map asRecord <$> performQuery "SELECT peer, rpc_address, data_center, rack FROM system.peers"

The generated type-class instance maps between record and tuple constructors:

type instance TupleType Peer = (IP, IP, Text, Text)

instance Record Peer where
    asTuple (Peer a b c d) = (a, b, c, d)
    asRecord (a, b, c, d)  = Peer a b c d