Database.CQL.Protocol

The CQL native protocol is a binary frame-based protocol where each frame has a Header, a Length and a body. The protocol distinguishes Requests and Responses.

Some usage examples:

Constructing and Serialising a Request

let q = QueryString "select peer from system.peers where data_center = ? and rack = ?"
    p = QueryParams One False ("uk-1", "r-0") Nothing Nothing Nothing
    r = RqQuery (Query q p :: Query R (Text, Text) (Identity IP))
    i = mkStreamId 0
in pack V3 noCompression False i r

Deserialising a Response

-- assuming bh contains the raw header byte string and bb the raw
-- body byte string.
case header V3 bh of
    Left  e -> ...
    Right h -> unpack noCompression h bb

A generic query processing function

query :: (Tuple a, Tuple b) => Version -> Socket -> QueryString k a b -> QueryParams a -> IO (Response k a b)
query v s q p = do
    let i = mkStreamId 0
    sendToServer s (pack v noCompression False i (RqQuery (Query q p)))
    b <- recv (if v == V3 then 9 else 8) s
    h <- either (throwIO . MyException) return (header v b)
    when (headerType h == RqHeader) $
        throwIO UnexpectedRequestHeader
    let len = lengthRepr (bodyLength h)
    x <- recv (fromIntegral len) s
    case unpack noCompression h x of
        Left e              -> throwIO $ AnotherException e
        Right (RsError _ e) -> throwIO e
        Right response      -> return response

Cql type-class

class Cql a where

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"

Minimal complete definition

ctype, toCql, fromCql

Methods

ctype :: Tagged a ColumnType

the column-type of a

toCql :: a -> Value

map a to some CQL data-type

fromCql :: Value -> Either String a

map a CQL value back to a

Instances

Cql Bool

Methods

ctype :: Tagged Bool ColumnType

toCql :: Bool -> Value

fromCql :: Value -> Either String Bool

Cql Double

Methods

ctype :: Tagged Double ColumnType

toCql :: Double -> Value

fromCql :: Value -> Either String Double

Cql Float

Methods

ctype :: Tagged Float ColumnType

toCql :: Float -> Value

fromCql :: Value -> Either String Float

Cql Int8

Methods

ctype :: Tagged Int8 ColumnType

toCql :: Int8 -> Value

fromCql :: Value -> Either String Int8

Cql Int16

Methods

ctype :: Tagged Int16 ColumnType

toCql :: Int16 -> Value

fromCql :: Value -> Either String Int16

Cql Int32

Methods

ctype :: Tagged Int32 ColumnType

toCql :: Int32 -> Value

fromCql :: Value -> Either String Int32

Cql Int64

Methods

ctype :: Tagged Int64 ColumnType

toCql :: Int64 -> Value

fromCql :: Value -> Either String Int64

Cql Integer

Methods

ctype :: Tagged Integer ColumnType

toCql :: Integer -> Value

fromCql :: Value -> Either String Integer

Cql Decimal

Methods

ctype :: Tagged Decimal ColumnType

toCql :: Decimal -> Value

fromCql :: Value -> Either String Decimal

Cql IP

Methods

ctype :: Tagged IP ColumnType

toCql :: IP -> Value

fromCql :: Value -> Either String IP

Cql Text

Methods

ctype :: Tagged Text ColumnType

toCql :: Text -> Value

fromCql :: Value -> Either String Text

Cql UTCTime

Methods

ctype :: Tagged UTCTime ColumnType

toCql :: UTCTime -> Value

fromCql :: Value -> Either String UTCTime

Cql UUID

Methods

ctype :: Tagged UUID ColumnType

toCql :: UUID -> Value

fromCql :: Value -> Either String UUID

Cql TimeUuid

Methods

ctype :: Tagged TimeUuid ColumnType

toCql :: TimeUuid -> Value

fromCql :: Value -> Either String TimeUuid

Cql Counter

Methods

ctype :: Tagged Counter ColumnType

toCql :: Counter -> Value

fromCql :: Value -> Either String Counter

Cql Blob

Methods

ctype :: Tagged Blob ColumnType

toCql :: Blob -> Value

fromCql :: Value -> Either String Blob

Cql Ascii

Methods

ctype :: Tagged Ascii ColumnType

toCql :: Ascii -> Value

fromCql :: Value -> Either String Ascii

Cql a => Cql [a]

Methods

ctype :: Tagged [a] ColumnType

toCql :: [a] -> Value

fromCql :: Value -> Either String [a]

Cql a => Cql (Maybe a)

Please note that due to the fact that Cassandra internally represents empty collection type values (i.e. lists, maps and sets) as null, we can not distinguish Just [] from Nothing on response decoding.

Methods

ctype :: Tagged (Maybe a) ColumnType

toCql :: Maybe a -> Value

fromCql :: Value -> Either String (Maybe a)

Cql a => Cql (Set a)

Methods

ctype :: Tagged (Set a) ColumnType

toCql :: Set a -> Value

fromCql :: Value -> Either String (Set a)

(Cql a1, Cql a2) => Cql (a1, a2)

Methods

ctype :: Tagged (a1, a2) ColumnType

toCql :: (a1, a2) -> Value

fromCql :: Value -> Either String (a1, a2)

(Cql a, Cql b) => Cql (Map a b)

Methods

ctype :: Tagged (Map a b) ColumnType

toCql :: Map a b -> Value

fromCql :: Value -> Either String (Map a b)

(Cql a1, Cql a2, Cql a3) => Cql (a1, a2, a3)

Methods

ctype :: Tagged (a1, a2, a3) ColumnType

toCql :: (a1, a2, a3) -> Value

fromCql :: Value -> Either String (a1, a2, a3)

(Cql a1, Cql a2, Cql a3, Cql a4) => Cql (a1, a2, a3, a4)

Methods

ctype :: Tagged (a1, a2, a3, a4) ColumnType

toCql :: (a1, a2, a3, a4) -> Value

fromCql :: Value -> Either String (a1, a2, a3, a4)

(Cql a1, Cql a2, Cql a3, Cql a4, Cql a5) => Cql (a1, a2, a3, a4, a5)

Methods

ctype :: Tagged (a1, a2, a3, a4, a5) ColumnType

toCql :: (a1, a2, a3, a4, a5) -> Value

fromCql :: Value -> Either String (a1, a2, a3, a4, a5)

(Cql a1, Cql a2, Cql a3, Cql a4, Cql a5, Cql a6) => Cql (a1, a2, a3, a4, a5, a6)

Methods

ctype :: Tagged (a1, a2, a3, a4, a5, a6) ColumnType

toCql :: (a1, a2, a3, a4, a5, a6) -> Value

fromCql :: Value -> Either String (a1, a2, a3, a4, a5, a6)

(Cql a1, Cql a2, Cql a3, Cql a4, Cql a5, Cql a6, Cql a7) => Cql (a1, a2, a3, a4, a5, a6, a7)

Methods

ctype :: Tagged (a1, a2, a3, a4, a5, a6, a7) ColumnType

toCql :: (a1, a2, a3, a4, a5, a6, a7) -> Value

fromCql :: Value -> Either String (a1, a2, a3, a4, a5, a6, a7)

(Cql a1, Cql a2, Cql a3, Cql a4, Cql a5, Cql a6, Cql a7, Cql a8) => Cql (a1, a2, a3, a4, a5, a6, a7, a8)

Methods

ctype :: Tagged (a1, a2, a3, a4, a5, a6, a7, a8) ColumnType

toCql :: (a1, a2, a3, a4, a5, a6, a7, a8) -> Value

fromCql :: Value -> Either String (a1, a2, a3, a4, a5, a6, a7, a8)

(Cql a1, Cql a2, Cql a3, Cql a4, Cql a5, Cql a6, Cql a7, Cql a8, Cql a9) => Cql (a1, a2, a3, a4, a5, a6, a7, a8, a9)

Methods

ctype :: Tagged (a1, a2, a3, a4, a5, a6, a7, a8, a9) ColumnType

toCql :: (a1, a2, a3, a4, a5, a6, a7, a8, a9) -> Value

fromCql :: Value -> Either String (a1, a2, a3, a4, a5, a6, a7, a8, a9)

(Cql a1, Cql a2, Cql a3, Cql a4, Cql a5, Cql a6, Cql a7, Cql a8, Cql a9, Cql a10) => Cql (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)

Methods

ctype :: Tagged (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) ColumnType

toCql :: (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) -> Value

fromCql :: Value -> Either String (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)

(Cql a1, Cql a2, Cql a3, Cql a4, Cql a5, Cql a6, Cql a7, Cql a8, Cql a9, Cql a10, Cql a11) => Cql (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11)

Methods

ctype :: Tagged (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) ColumnType

toCql :: (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) -> Value

fromCql :: Value -> Either String (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11)

(Cql a1, Cql a2, Cql a3, Cql a4, Cql a5, Cql a6, Cql a7, Cql a8, Cql a9, Cql a10, Cql a11, Cql a12) => Cql (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12)

Methods

ctype :: Tagged (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12) ColumnType

toCql :: (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12) -> Value

fromCql :: Value -> Either String (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12)

(Cql a1, Cql a2, Cql a3, Cql a4, Cql a5, Cql a6, Cql a7, Cql a8, Cql a9, Cql a10, Cql a11, Cql a12, Cql a13) => Cql (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13)

Methods

ctype :: Tagged (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13) ColumnType

toCql :: (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13) -> Value

fromCql :: Value -> Either String (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13)

(Cql a1, Cql a2, Cql a3, Cql a4, Cql a5, Cql a6, Cql a7, Cql a8, Cql a9, Cql a10, Cql a11, Cql a12, Cql a13, Cql a14) => Cql (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14)

Methods

ctype :: Tagged (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14) ColumnType

toCql :: (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14) -> Value

fromCql :: Value -> Either String (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14)

(Cql a1, Cql a2, Cql a3, Cql a4, Cql a5, Cql a6, Cql a7, Cql a8, Cql a9, Cql a10, Cql a11, Cql a12, Cql a13, Cql a14, Cql a15) => Cql (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15)

Methods

ctype :: Tagged (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15) ColumnType

toCql :: (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15) -> Value

fromCql :: Value -> Either String (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15)

(Cql a1, Cql a2, Cql a3, Cql a4, Cql a5, Cql a6, Cql a7, Cql a8, Cql a9, Cql a10, Cql a11, Cql a12, Cql a13, Cql a14, Cql a15, Cql a16) => Cql (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16)

Methods

ctype :: Tagged (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16) ColumnType

toCql :: (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16) -> Value

fromCql :: Value -> Either String (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16)

Basic type definitions

newtype Keyspace

Constructors

Keyspace

Fields

• unKeyspace :: Text

Instances

Eq Keyspace

Methods

(==) :: Keyspace -> Keyspace -> Bool

(/=) :: Keyspace -> Keyspace -> Bool

Show Keyspace

Methods

showsPrec :: Int -> Keyspace -> ShowS

show :: Keyspace -> String

showList :: [Keyspace] -> ShowS

newtype Table

Constructors

Table

Fields

• unTable :: Text

Instances

Eq Table

Methods

(==) :: Table -> Table -> Bool

(/=) :: Table -> Table -> Bool

Show Table

Methods

showsPrec :: Int -> Table -> ShowS

show :: Table -> String

showList :: [Table] -> ShowS

newtype PagingState

Opaque token passed to the server to continue result paging.

Constructors

PagingState

Fields

• unPagingState :: ByteString

Instances

Eq PagingState

Methods

(==) :: PagingState -> PagingState -> Bool

(/=) :: PagingState -> PagingState -> Bool

Show PagingState

Methods

showsPrec :: Int -> PagingState -> ShowS

show :: PagingState -> String

showList :: [PagingState] -> ShowS

newtype QueryId k a b

ID representing a prepared query.

Constructors

QueryId

Fields

• unQueryId :: ByteString

Instances

Eq (QueryId k a b)

Methods

(==) :: QueryId k a b -> QueryId k a b -> Bool

(/=) :: QueryId k a b -> QueryId k a b -> Bool

Show (QueryId k a b)

Methods

showsPrec :: Int -> QueryId k a b -> ShowS

show :: QueryId k a b -> String

showList :: [QueryId k a b] -> ShowS

newtype QueryString k a b

Constructors

QueryString

Fields

• unQueryString :: Text

Instances

Eq (QueryString k a b)

Methods

(==) :: QueryString k a b -> QueryString k a b -> Bool

(/=) :: QueryString k a b -> QueryString k a b -> Bool

Show (QueryString k a b)

Methods

showsPrec :: Int -> QueryString k a b -> ShowS

show :: QueryString k a b -> String

showList :: [QueryString k a b] -> ShowS

IsString (QueryString k a b)

Methods

fromString :: String -> QueryString k a b

data Version

CQL binary protocol version.

Constructors

V3

version 3

V4

version 4

Instances

Eq Version

Methods

(==) :: Version -> Version -> Bool

(/=) :: Version -> Version -> Bool

Ord Version

Methods

compare :: Version -> Version -> Ordering

(<) :: Version -> Version -> Bool

(<=) :: Version -> Version -> Bool

(>) :: Version -> Version -> Bool

(>=) :: Version -> Version -> Bool

max :: Version -> Version -> Version

min :: Version -> Version -> Version

Show Version

Methods

showsPrec :: Int -> Version -> ShowS

show :: Version -> String

showList :: [Version] -> ShowS

data CqlVersion

The CQL version (not the binary protocol version).

Constructors

Cqlv300

CqlVersion !Text

Instances

Eq CqlVersion

Methods

(==) :: CqlVersion -> CqlVersion -> Bool

(/=) :: CqlVersion -> CqlVersion -> Bool

Show CqlVersion

Methods

showsPrec :: Int -> CqlVersion -> ShowS

show :: CqlVersion -> String

showList :: [CqlVersion] -> ShowS

data CompressionAlgorithm

Constructors

Snappy

LZ4

None

Instances

Eq CompressionAlgorithm

Methods

(==) :: CompressionAlgorithm -> CompressionAlgorithm -> Bool

(/=) :: CompressionAlgorithm -> CompressionAlgorithm -> Bool

Show CompressionAlgorithm

Methods

showsPrec :: Int -> CompressionAlgorithm -> ShowS

show :: CompressionAlgorithm -> String

showList :: [CompressionAlgorithm] -> ShowS

data Compression

Constructors

Compression

Fields

• algorithm :: !CompressionAlgorithm
• shrink :: ByteString -> Maybe ByteString
• expand :: ByteString -> Maybe ByteString

Instances

Show Compression

Methods

showsPrec :: Int -> Compression -> ShowS

show :: Compression -> String

showList :: [Compression] -> ShowS

noCompression :: Compression

data Consistency

Consistency level.

See: Consistency

Constructors

Any

One

LocalOne

Two

Three

Quorum

LocalQuorum

All

EachQuorum

Only for write queries.

Serial

Only for read queries.

LocalSerial

Only for read queries.

Instances

Eq Consistency

Methods

(==) :: Consistency -> Consistency -> Bool

(/=) :: Consistency -> Consistency -> Bool

Show Consistency

Methods

showsPrec :: Int -> Consistency -> ShowS

show :: Consistency -> String

showList :: [Consistency] -> ShowS

data OpCode

An opcode is a tag to distinguish protocol frame bodies.

Constructors

OcError

OcStartup

OcReady

OcAuthenticate

OcOptions

OcSupported

OcQuery

OcResult

OcPrepare

OcExecute

OcRegister

OcEvent

OcBatch

OcAuthChallenge

OcAuthResponse

OcAuthSuccess

Instances

Eq OpCode

Methods

(==) :: OpCode -> OpCode -> Bool

(/=) :: OpCode -> OpCode -> Bool

Show OpCode

Methods

showsPrec :: Int -> OpCode -> ShowS

show :: OpCode -> String

showList :: [OpCode] -> ShowS

data ColumnType

The type of a single CQL column.

Constructors

CustomColumn !Text

AsciiColumn

BigIntColumn

BlobColumn

BooleanColumn

CounterColumn

DecimalColumn

DoubleColumn

FloatColumn

IntColumn

TextColumn

TimestampColumn

UuidColumn

VarCharColumn

VarIntColumn

TimeUuidColumn

InetColumn

MaybeColumn !ColumnType

ListColumn !ColumnType

SetColumn !ColumnType

MapColumn !ColumnType !ColumnType

TupleColumn [ColumnType]

UdtColumn !Text [(Text, ColumnType)]

DateColumn

TimeColumn

SmallIntColumn

TinyIntColumn

Instances

Eq ColumnType

Methods

(==) :: ColumnType -> ColumnType -> Bool

(/=) :: ColumnType -> ColumnType -> Bool

Show ColumnType

Methods

showsPrec :: Int -> ColumnType -> ShowS

show :: ColumnType -> String

showList :: [ColumnType] -> ShowS

newtype Ascii

Constructors

Ascii

Fields

• fromAscii :: Text

Instances

Eq Ascii

Methods

(==) :: Ascii -> Ascii -> Bool

(/=) :: Ascii -> Ascii -> Bool

Ord Ascii

Methods

compare :: Ascii -> Ascii -> Ordering

(<) :: Ascii -> Ascii -> Bool

(<=) :: Ascii -> Ascii -> Bool

(>) :: Ascii -> Ascii -> Bool

(>=) :: Ascii -> Ascii -> Bool

max :: Ascii -> Ascii -> Ascii

min :: Ascii -> Ascii -> Ascii

Show Ascii

Methods

showsPrec :: Int -> Ascii -> ShowS

show :: Ascii -> String

showList :: [Ascii] -> ShowS

IsString Ascii

Methods

fromString :: String -> Ascii

Cql Ascii

Methods

ctype :: Tagged Ascii ColumnType

toCql :: Ascii -> Value

fromCql :: Value -> Either String Ascii

newtype Blob

Constructors

Blob

Fields

• fromBlob :: ByteString

Instances

Eq Blob

Methods

(==) :: Blob -> Blob -> Bool

(/=) :: Blob -> Blob -> Bool

Ord Blob

Methods

compare :: Blob -> Blob -> Ordering

(<) :: Blob -> Blob -> Bool

(<=) :: Blob -> Blob -> Bool

(>) :: Blob -> Blob -> Bool

(>=) :: Blob -> Blob -> Bool

max :: Blob -> Blob -> Blob

min :: Blob -> Blob -> Blob

Show Blob

Methods

showsPrec :: Int -> Blob -> ShowS

show :: Blob -> String

showList :: [Blob] -> ShowS

Cql Blob

Methods

ctype :: Tagged Blob ColumnType

toCql :: Blob -> Value

fromCql :: Value -> Either String Blob

newtype Counter

Constructors

Counter

Fields

• fromCounter :: Int64

Instances

Eq Counter

Methods

(==) :: Counter -> Counter -> Bool

(/=) :: Counter -> Counter -> Bool

Ord Counter

Methods

compare :: Counter -> Counter -> Ordering

(<) :: Counter -> Counter -> Bool

(<=) :: Counter -> Counter -> Bool

(>) :: Counter -> Counter -> Bool

(>=) :: Counter -> Counter -> Bool

max :: Counter -> Counter -> Counter

min :: Counter -> Counter -> Counter

Show Counter

Methods

showsPrec :: Int -> Counter -> ShowS

show :: Counter -> String

showList :: [Counter] -> ShowS

Cql Counter

Methods

ctype :: Tagged Counter ColumnType

toCql :: Counter -> Value

fromCql :: Value -> Either String Counter

newtype TimeUuid

Constructors

TimeUuid

Fields

• fromTimeUuid :: UUID

Instances

Eq TimeUuid

Methods

(==) :: TimeUuid -> TimeUuid -> Bool

(/=) :: TimeUuid -> TimeUuid -> Bool

Ord TimeUuid

Methods

compare :: TimeUuid -> TimeUuid -> Ordering

(<) :: TimeUuid -> TimeUuid -> Bool

(<=) :: TimeUuid -> TimeUuid -> Bool

(>) :: TimeUuid -> TimeUuid -> Bool

(>=) :: TimeUuid -> TimeUuid -> Bool

max :: TimeUuid -> TimeUuid -> TimeUuid

min :: TimeUuid -> TimeUuid -> TimeUuid

Show TimeUuid

Methods

showsPrec :: Int -> TimeUuid -> ShowS

show :: TimeUuid -> String

showList :: [TimeUuid] -> ShowS

Cql TimeUuid

Methods

ctype :: Tagged TimeUuid ColumnType

toCql :: TimeUuid -> Value

fromCql :: Value -> Either String TimeUuid

newtype Set a

Constructors

Set

Fields

• fromSet :: [a]

Instances

(Eq a, Ord a) => Eq (Set a)

Methods

(==) :: Set a -> Set a -> Bool

(/=) :: Set a -> Set a -> Bool

Show a => Show (Set a)

Methods

showsPrec :: Int -> Set a -> ShowS

show :: Set a -> String

showList :: [Set a] -> ShowS

Cql a => Cql (Set a)

Methods

ctype :: Tagged (Set a) ColumnType

toCql :: Set a -> Value

fromCql :: Value -> Either String (Set a)

newtype Map a b

Constructors

Map

Fields

• fromMap :: [(a, b)]

Instances

(Eq k, Eq v, Ord k) => Eq (Map k v)

Methods

(==) :: Map k v -> Map k v -> Bool

(/=) :: Map k v -> Map k v -> Bool

(Show b, Show a) => Show (Map a b)

Methods

showsPrec :: Int -> Map a b -> ShowS

show :: Map a b -> String

showList :: [Map a b] -> ShowS

(Cql a, Cql b) => Cql (Map a b)

Methods

ctype :: Tagged (Map a b) ColumnType

toCql :: Map a b -> Value

fromCql :: Value -> Either String (Map a b)

data Value

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

Constructors

CqlCustom !ByteString

CqlBoolean !Bool

CqlInt !Int32

CqlBigInt !Int64

CqlVarInt !Integer

CqlFloat !Float

CqlDecimal !Decimal

CqlDouble !Double

CqlText !Text

CqlInet !IP

CqlUuid !UUID

CqlTimestamp !Int64

CqlAscii !Text

CqlBlob !ByteString

CqlCounter !Int64

CqlTimeUuid !UUID

CqlMaybe (Maybe Value)

CqlList [Value]

CqlSet [Value]

CqlMap [(Value, Value)]

CqlTuple [Value]

CqlUdt [(Text, Value)]

CqlDate !Int32

CqlTime !Int64

CqlSmallInt !Int16

CqlTinyInt !Int8

Instances

Eq Value

Methods

(==) :: Value -> Value -> Bool

(/=) :: Value -> Value -> Bool

Show Value

Methods

showsPrec :: Int -> Value -> ShowS

show :: Value -> String

showList :: [Value] -> ShowS

newtype Tagged a b

Tag some value with a phantom type.

Constructors

Tagged

Fields

• untag :: b

retag :: Tagged a c -> Tagged b c

data R

Type tag for read queries, i.e. 'QueryString R a b'.

data W

Type tag for write queries, i.e. 'QueryString W a b'.

data S

Type tag for schema queries, i.e. 'QueryString S a b'.

Header

data Header

Protocol frame header.

Constructors

Header

Fields

• headerType :: !HeaderType
• version :: !Version
• flags :: !Flags
• streamId :: !StreamId
• opCode :: !OpCode
• bodyLength :: !Length

Instances

Show Header

Methods

showsPrec :: Int -> Header -> ShowS

show :: Header -> String

showList :: [Header] -> ShowS

data HeaderType

Constructors

RqHeader

A request frame header.

RsHeader

A response frame header.

Instances

Show HeaderType

Methods

showsPrec :: Int -> HeaderType -> ShowS

show :: HeaderType -> String

showList :: [HeaderType] -> ShowS

header :: Version -> ByteString -> Either String Header

Deserialise a frame header using the version specific decoding format.

Length

newtype Length

The type denoting a protocol frame length.

Constructors

Length

Fields

• lengthRepr :: Int32

Instances

Eq Length

Methods

(==) :: Length -> Length -> Bool

(/=) :: Length -> Length -> Bool

Show Length

Methods

showsPrec :: Int -> Length -> ShowS

show :: Length -> String

showList :: [Length] -> ShowS

StreamId

data StreamId

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

Instances

Eq StreamId

Methods

(==) :: StreamId -> StreamId -> Bool

(/=) :: StreamId -> StreamId -> Bool

Show StreamId

Methods

showsPrec :: Int -> StreamId -> ShowS

show :: StreamId -> String

showList :: [StreamId] -> ShowS

mkStreamId :: Integral i => i -> StreamId

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

fromStreamId :: StreamId -> Int

Convert the stream ID to an integer.

Flags

data Flags

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

Instances

Eq Flags

Methods

(==) :: Flags -> Flags -> Bool

(/=) :: Flags -> Flags -> Bool

Show Flags

Methods

showsPrec :: Int -> Flags -> ShowS

show :: Flags -> String

showList :: [Flags] -> ShowS

Semigroup Flags

Methods

(<>) :: Flags -> Flags -> Flags

sconcat :: NonEmpty Flags -> Flags

stimes :: Integral b => b -> Flags -> Flags

Monoid Flags

Methods

mempty :: Flags

mappend :: Flags -> Flags -> Flags

mconcat :: [Flags] -> Flags

compress :: Flags

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

tracing :: Flags

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.

isSet :: Flags -> Flags -> Bool

Check if a particular flag is present.

Request

data Request k a b

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.

Constructors

RqStartup !Startup

RqOptions !Options

RqRegister !Register

RqBatch !Batch

RqAuthResp !AuthResponse

RqPrepare !(Prepare k a b)

RqQuery !(Query k a b)

RqExecute !(Execute k a b)

Instances

Show a => Show (Request k a b)

Methods

showsPrec :: Int -> Request k a b -> ShowS

show :: Request k a b -> String

showList :: [Request k a b] -> ShowS

getOpCode :: Request k a b -> OpCode

Get the protocol OpCode corresponding to the given Request.

pack

Arguments

:: Tuple a

=> Version

protocol version, which determines the encoding

-> Compression

compression to use

-> Bool

enable/disable tracing

-> StreamId

the stream Id to use

-> Request k a b

the actual request to serialise

-> Either String ByteString

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.

Options

data Options

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

Constructors

Options

Instances

Show Options

Methods

showsPrec :: Int -> Options -> ShowS

show :: Options -> String

showList :: [Options] -> ShowS

Startup

data Startup

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.

Constructors

Startup !CqlVersion !CompressionAlgorithm

Instances

Show Startup

Methods

showsPrec :: Int -> Startup -> ShowS

show :: Startup -> String

showList :: [Startup] -> ShowS

Auth Response

newtype AuthResponse

A request send in response to a previous authentication challenge.

Constructors

AuthResponse ByteString

Instances

Show AuthResponse

Methods

showsPrec :: Int -> AuthResponse -> ShowS

show :: AuthResponse -> String

showList :: [AuthResponse] -> ShowS

Register

newtype Register

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

Constructors

Register [EventType]

Instances

Show Register

Methods

showsPrec :: Int -> Register -> ShowS

show :: Register -> String

showList :: [Register] -> ShowS

data EventType

Event types to register.

Constructors

TopologyChangeEvent

events related to change in the cluster topology

StatusChangeEvent

events related to change of node status

SchemaChangeEvent

events related to schema change

Instances

Show EventType

Methods

showsPrec :: Int -> EventType -> ShowS

show :: EventType -> String

showList :: [EventType] -> ShowS

Query

data Query k a b

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

Constructors

Query !(QueryString k a b) !(QueryParams a)

Instances

Show a => Show (Query k a b)

Methods

showsPrec :: Int -> Query k a b -> ShowS

show :: Query k a b -> String

showList :: [Query k a b] -> ShowS

data QueryParams a

Query parameters.

Constructors

QueryParams

Fields

• consistency :: !Consistency

  (Regular) consistency level to use.

• skipMetaData :: !Bool

  Whether to omit the metadata in the Response of the query. This is an optimisation only relevant for use with prepared queries, for which the metadata obtained from the PreparedResult may be reused.

• values :: a

  The bound parameters of the query.

• pageSize :: Maybe Int32

  The desired maximum result set size.

• queryPagingState :: Maybe PagingState

  The current paging state that determines the "offset" of the results to return for a read query.

• serialConsistency :: Maybe SerialConsistency

  Serial consistency level to use for conditional updates (aka "lightweight transactions"). Irrelevant for any other queries.

• enableTracing :: Maybe Bool

  Whether tracing should be enabled for the query, in which case the Response will carry a traceId.

Instances

Show a => Show (QueryParams a)

Methods

showsPrec :: Int -> QueryParams a -> ShowS

show :: QueryParams a -> String

showList :: [QueryParams a] -> ShowS

data SerialConsistency

Consistency level for the serial phase of conditional updates (aka "lightweight transactions").

See: SerialConsistency

Constructors

SerialConsistency

Default. Quorum-based linearizable consistency.

LocalSerialConsistency

Like SerialConsistency except confined to a single (logical) data center.

Instances

Show SerialConsistency

Methods

showsPrec :: Int -> SerialConsistency -> ShowS

show :: SerialConsistency -> String

showList :: [SerialConsistency] -> ShowS

Batch

data Batch

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

Constructors

Batch

Fields

• batchType :: !BatchType
• batchQuery :: [BatchQuery]
• batchConsistency :: !Consistency
• batchSerialConsistency :: Maybe SerialConsistency

Instances

Show Batch

Methods

showsPrec :: Int -> Batch -> ShowS

show :: Batch -> String

showList :: [Batch] -> ShowS

data BatchQuery where

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

Constructors

BatchQuery :: (Show a, Tuple a, Tuple b) => !(QueryString W a b) -> !a -> BatchQuery

BatchPrepared :: (Show a, Tuple a, Tuple b) => !(QueryId W a b) -> !a -> BatchQuery

Instances

Show BatchQuery

Methods

showsPrec :: Int -> BatchQuery -> ShowS

show :: BatchQuery -> String

showList :: [BatchQuery] -> ShowS

data BatchType

Constructors

BatchLogged

default, uses a batch log for atomic application

BatchUnLogged

skip the batch log

BatchCounter

used for batched counter updates

Instances

Show BatchType

Methods

showsPrec :: Int -> BatchType -> ShowS

show :: BatchType -> String

showList :: [BatchType] -> ShowS

Prepare

newtype Prepare k a b

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

Constructors

Prepare (QueryString k a b)

Instances

Show (Prepare k a b)

Methods

showsPrec :: Int -> Prepare k a b -> ShowS

show :: Prepare k a b -> String

showList :: [Prepare k a b] -> ShowS

Execute

data Execute k a b

Executes a prepared query.

Constructors

Execute !(QueryId k a b) !(QueryParams a)

Instances

Show a => Show (Execute k a b)

Methods

showsPrec :: Int -> Execute k a b -> ShowS

show :: Execute k a b -> String

showList :: [Execute k a b] -> ShowS

Response

data Response k a b

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.

Constructors

RsError (Maybe UUID) [Text] !Error

RsReady (Maybe UUID) [Text] !Ready

RsAuthenticate (Maybe UUID) [Text] !Authenticate

RsAuthChallenge (Maybe UUID) [Text] !AuthChallenge

RsAuthSuccess (Maybe UUID) [Text] !AuthSuccess

RsSupported (Maybe UUID) [Text] !Supported

RsResult (Maybe UUID) [Text] !(Result k a b)

RsEvent (Maybe UUID) [Text] !Event

Instances

Show b => Show (Response k a b)

Methods

showsPrec :: Int -> Response k a b -> ShowS

show :: Response k a b -> String

showList :: [Response k a b] -> ShowS

warnings :: Response k a b -> [Text]

Get server warnings from response if any.

traceId :: Response k a b -> Maybe UUID

Get server trace ID from response if any.

unpack :: (Tuple a, Tuple b) => Compression -> Header -> ByteString -> Either String (Response k a b)

Deserialise a Response from the given ByteString.

Ready

data Ready

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

Constructors

Ready

Instances

Show Ready

Methods

showsPrec :: Int -> Ready -> ShowS

show :: Ready -> String

showList :: [Ready] -> ShowS

Authenticate

newtype Authenticate

The server requires authentication.

Constructors

Authenticate Text

Instances

Show Authenticate

Methods

showsPrec :: Int -> Authenticate -> ShowS

show :: Authenticate -> String

showList :: [Authenticate] -> ShowS

newtype AuthChallenge

A server-send authentication challenge.

Constructors

AuthChallenge (Maybe ByteString)

Instances

Show AuthChallenge

Methods

showsPrec :: Int -> AuthChallenge -> ShowS

show :: AuthChallenge -> String

showList :: [AuthChallenge] -> ShowS

newtype AuthSuccess

Indicates the success of an authentication phase.

Constructors

AuthSuccess (Maybe ByteString)

Instances

Show AuthSuccess

Methods

showsPrec :: Int -> AuthSuccess -> ShowS

show :: AuthSuccess -> String

showList :: [AuthSuccess] -> ShowS

Result

data Result k a b

Query response.

Constructors

VoidResult

RowsResult !MetaData [b]

SetKeyspaceResult !Keyspace

PreparedResult !(QueryId k a b) !MetaData !MetaData

SchemaChangeResult !SchemaChange

Instances

Show b => Show (Result k a b)

Methods

showsPrec :: Int -> Result k a b -> ShowS

show :: Result k a b -> String

showList :: [Result k a b] -> ShowS

data MetaData

Part of a RowsResult. Describes the result set.

Constructors

MetaData

Fields

• columnCount :: !Int32
• pagingState :: Maybe PagingState
• columnSpecs :: [ColumnSpec]
• primaryKeyIndicies :: [Int32]

Instances

Show MetaData

Methods

showsPrec :: Int -> MetaData -> ShowS

show :: MetaData -> String

showList :: [MetaData] -> ShowS

data ColumnSpec

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

Constructors

ColumnSpec

Fields

• keyspace :: !Keyspace
• table :: !Table
• columnName :: !Text
• columnType :: !ColumnType

Instances

Show ColumnSpec

Methods

showsPrec :: Int -> ColumnSpec -> ShowS

show :: ColumnSpec -> String

showList :: [ColumnSpec] -> ShowS

Supported

data Supported

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

Constructors

Supported [CompressionAlgorithm] [CqlVersion]

Instances

Show Supported

Methods

showsPrec :: Int -> Supported -> ShowS

show :: Supported -> String

showList :: [Supported] -> ShowS

Event

data Event

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

Constructors

TopologyEvent !TopologyChange !SockAddr

StatusEvent !StatusChange !SockAddr

SchemaEvent !SchemaChange

Instances

Show Event

Methods

showsPrec :: Int -> Event -> ShowS

show :: Event -> String

showList :: [Event] -> ShowS

data TopologyChange

Constructors

NewNode

RemovedNode

Instances

Eq TopologyChange

Methods

(==) :: TopologyChange -> TopologyChange -> Bool

(/=) :: TopologyChange -> TopologyChange -> Bool

Ord TopologyChange

Methods

compare :: TopologyChange -> TopologyChange -> Ordering

(<) :: TopologyChange -> TopologyChange -> Bool

(<=) :: TopologyChange -> TopologyChange -> Bool

(>) :: TopologyChange -> TopologyChange -> Bool

(>=) :: TopologyChange -> TopologyChange -> Bool

max :: TopologyChange -> TopologyChange -> TopologyChange

min :: TopologyChange -> TopologyChange -> TopologyChange

Show TopologyChange

Methods

showsPrec :: Int -> TopologyChange -> ShowS

show :: TopologyChange -> String

showList :: [TopologyChange] -> ShowS

data SchemaChange

Constructors

SchemaCreated !Change

SchemaUpdated !Change

SchemaDropped !Change

Instances

Show SchemaChange

Methods

showsPrec :: Int -> SchemaChange -> ShowS

show :: SchemaChange -> String

showList :: [SchemaChange] -> ShowS

data StatusChange

Constructors

Up

Down

Instances

Eq StatusChange

Methods

(==) :: StatusChange -> StatusChange -> Bool

(/=) :: StatusChange -> StatusChange -> Bool

Ord StatusChange

Methods

compare :: StatusChange -> StatusChange -> Ordering

(<) :: StatusChange -> StatusChange -> Bool

(<=) :: StatusChange -> StatusChange -> Bool

(>) :: StatusChange -> StatusChange -> Bool

(>=) :: StatusChange -> StatusChange -> Bool

max :: StatusChange -> StatusChange -> StatusChange

min :: StatusChange -> StatusChange -> StatusChange

Show StatusChange

Methods

showsPrec :: Int -> StatusChange -> ShowS

show :: StatusChange -> String

showList :: [StatusChange] -> ShowS

data Change

Constructors

KeyspaceChange !Keyspace

TableChange !Keyspace !Table

TypeChange !Keyspace !Text

FunctionChange !Keyspace !Text ![Text]

AggregateChange !Keyspace !Text ![Text]

Instances

Show Change

Methods

showsPrec :: Int -> Change -> ShowS

show :: Change -> String

showList :: [Change] -> ShowS

Error

data Error

Error response.

Constructors

AlreadyExists !Text !Keyspace !Table

BadCredentials !Text

ConfigError !Text

FunctionFailure !Text !Keyspace !Text ![Text]

Invalid !Text

IsBootstrapping !Text

Overloaded !Text

ProtocolError !Text

ServerError !Text

SyntaxError !Text

TruncateError !Text

Unauthorized !Text

Unprepared !Text !ByteString

Unavailable

Fields

• unavailMessage :: !Text
• unavailConsistency :: !Consistency
• unavailNumRequired :: !Int32
• unavailNumAlive :: !Int32

ReadFailure

Fields

• rFailureMessage :: !Text
• rFailureConsistency :: !Consistency
• rFailureNumAck :: !Int32
• rFailureNumRequired :: !Int32
• rFailureNumFailures :: !Int32
• rFailureDataPresent :: !Bool

ReadTimeout

Fields

• rTimeoutMessage :: !Text
• rTimeoutConsistency :: !Consistency
• rTimeoutNumAck :: !Int32
• rTimeoutNumRequired :: !Int32
• rTimeoutDataPresent :: !Bool

WriteFailure

Fields

• wFailureMessage :: !Text
• wFailureConsistency :: !Consistency
• wFailureNumAck :: !Int32
• wFailureNumRequired :: !Int32
• wFailureNumFailures :: !Int32
• wFailureWriteType :: !WriteType

WriteTimeout

Fields

• wTimeoutMessage :: !Text
• wTimeoutConsistency :: !Consistency
• wTimeoutNumAck :: !Int32
• wTimeoutNumRequired :: !Int32
• wTimeoutWriteType :: !WriteType

Instances

Eq Error

Methods

(==) :: Error -> Error -> Bool

(/=) :: Error -> Error -> Bool

Show Error

Methods

showsPrec :: Int -> Error -> ShowS

show :: Error -> String

showList :: [Error] -> ShowS

Exception Error

Methods

toException :: Error -> SomeException

fromException :: SomeException -> Maybe Error

displayException :: Error -> String

data WriteType

Constructors

WriteSimple

WriteBatch

WriteBatchLog

WriteUnloggedBatch

WriteCounter

Instances

Eq WriteType

Methods

(==) :: WriteType -> WriteType -> Bool

(/=) :: WriteType -> WriteType -> Bool

Show WriteType

Methods

showsPrec :: Int -> WriteType -> ShowS

show :: WriteType -> String

showList :: [WriteType] -> ShowS

Row, Tuple and Record

class PrivateTuple a => Tuple a

Instances

Tuple ()

Tuple Row

Cql a => Tuple (Identity a)

(Cql a1, Cql a2) => Tuple (a1, a2)

(Cql a1, Cql a2, Cql a3) => Tuple (a1, a2, a3)

(Cql a1, Cql a2, Cql a3, Cql a4) => Tuple (a1, a2, a3, a4)

(Cql a1, Cql a2, Cql a3, Cql a4, Cql a5) => Tuple (a1, a2, a3, a4, a5)

(Cql a1, Cql a2, Cql a3, Cql a4, Cql a5, Cql a6) => Tuple (a1, a2, a3, a4, a5, a6)

(Cql a1, Cql a2, Cql a3, Cql a4, Cql a5, Cql a6, Cql a7) => Tuple (a1, a2, a3, a4, a5, a6, a7)

(Cql a1, Cql a2, Cql a3, Cql a4, Cql a5, Cql a6, Cql a7, Cql a8) => Tuple (a1, a2, a3, a4, a5, a6, a7, a8)

(Cql a1, Cql a2, Cql a3, Cql a4, Cql a5, Cql a6, Cql a7, Cql a8, Cql a9) => Tuple (a1, a2, a3, a4, a5, a6, a7, a8, a9)

(Cql a1, Cql a2, Cql a3, Cql a4, Cql a5, Cql a6, Cql a7, Cql a8, Cql a9, Cql a10) => Tuple (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)

(Cql a1, Cql a2, Cql a3, Cql a4, Cql a5, Cql a6, Cql a7, Cql a8, Cql a9, Cql a10, Cql a11) => Tuple (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11)

(Cql a1, Cql a2, Cql a3, Cql a4, Cql a5, Cql a6, Cql a7, Cql a8, Cql a9, Cql a10, Cql a11, Cql a12) => Tuple (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12)

(Cql a1, Cql a2, Cql a3, Cql a4, Cql a5, Cql a6, Cql a7, Cql a8, Cql a9, Cql a10, Cql a11, Cql a12, Cql a13) => Tuple (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13)

(Cql a1, Cql a2, Cql a3, Cql a4, Cql a5, Cql a6, Cql a7, Cql a8, Cql a9, Cql a10, Cql a11, Cql a12, Cql a13, Cql a14) => Tuple (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14)

(Cql a1, Cql a2, Cql a3, Cql a4, Cql a5, Cql a6, Cql a7, Cql a8, Cql a9, Cql a10, Cql a11, Cql a12, Cql a13, Cql a14, Cql a15) => Tuple (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15)

(Cql a1, Cql a2, Cql a3, Cql a4, Cql a5, Cql a6, Cql a7, Cql a8, Cql a9, Cql a10, Cql a11, Cql a12, Cql a13, Cql a14, Cql a15, Cql a16) => Tuple (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16)

(Cql a1, Cql a2, Cql a3, Cql a4, Cql a5, Cql a6, Cql a7, Cql a8, Cql a9, Cql a10, Cql a11, Cql a12, Cql a13, Cql a14, Cql a15, Cql a16, Cql a17) => Tuple (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17)

(Cql a1, Cql a2, Cql a3, Cql a4, Cql a5, Cql a6, Cql a7, Cql a8, Cql a9, Cql a10, Cql a11, Cql a12, Cql a13, Cql a14, Cql a15, Cql a16, Cql a17, Cql a18) => Tuple (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18)

(Cql a1, Cql a2, Cql a3, Cql a4, Cql a5, Cql a6, Cql a7, Cql a8, Cql a9, Cql a10, Cql a11, Cql a12, Cql a13, Cql a14, Cql a15, Cql a16, Cql a17, Cql a18, Cql a19) => Tuple (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19)

(Cql a1, Cql a2, Cql a3, Cql a4, Cql a5, Cql a6, Cql a7, Cql a8, Cql a9, Cql a10, Cql a11, Cql a12, Cql a13, Cql a14, Cql a15, Cql a16, Cql a17, Cql a18, Cql a19, Cql a20) => Tuple (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20)

(Cql a1, Cql a2, Cql a3, Cql a4, Cql a5, Cql a6, Cql a7, Cql a8, Cql a9, Cql a10, Cql a11, Cql a12, Cql a13, Cql a14, Cql a15, Cql a16, Cql a17, Cql a18, Cql a19, Cql a20, Cql a21) => Tuple (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21)

(Cql a1, Cql a2, Cql a3, Cql a4, Cql a5, Cql a6, Cql a7, Cql a8, Cql a9, Cql a10, Cql a11, Cql a12, Cql a13, Cql a14, Cql a15, Cql a16, Cql a17, Cql a18, Cql a19, Cql a20, Cql a21, Cql a22) => Tuple (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22)

(Cql a1, Cql a2, Cql a3, Cql a4, Cql a5, Cql a6, Cql a7, Cql a8, Cql a9, Cql a10, Cql a11, Cql a12, Cql a13, Cql a14, Cql a15, Cql a16, Cql a17, Cql a18, Cql a19, Cql a20, Cql a21, Cql a22, Cql a23) => Tuple (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23)

(Cql a1, Cql a2, Cql a3, Cql a4, Cql a5, Cql a6, Cql a7, Cql a8, Cql a9, Cql a10, Cql a11, Cql a12, Cql a13, Cql a14, Cql a15, Cql a16, Cql a17, Cql a18, Cql a19, Cql a20, Cql a21, Cql a22, Cql a23, Cql a24) => Tuple (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24)

(Cql a1, Cql a2, Cql a3, Cql a4, Cql a5, Cql a6, Cql a7, Cql a8, Cql a9, Cql a10, Cql a11, Cql a12, Cql a13, Cql a14, Cql a15, Cql a16, Cql a17, Cql a18, Cql a19, Cql a20, Cql a21, Cql a22, Cql a23, Cql a24, Cql a25) => Tuple (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25)

(Cql a1, Cql a2, Cql a3, Cql a4, Cql a5, Cql a6, Cql a7, Cql a8, Cql a9, Cql a10, Cql a11, Cql a12, Cql a13, Cql a14, Cql a15, Cql a16, Cql a17, Cql a18, Cql a19, Cql a20, Cql a21, Cql a22, Cql a23, Cql a24, Cql a25, Cql a26) => Tuple (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26)

(Cql a1, Cql a2, Cql a3, Cql a4, Cql a5, Cql a6, Cql a7, Cql a8, Cql a9, Cql a10, Cql a11, Cql a12, Cql a13, Cql a14, Cql a15, Cql a16, Cql a17, Cql a18, Cql a19, Cql a20, Cql a21, Cql a22, Cql a23, Cql a24, Cql a25, Cql a26, Cql a27) => Tuple (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27)

(Cql a1, Cql a2, Cql a3, Cql a4, Cql a5, Cql a6, Cql a7, Cql a8, Cql a9, Cql a10, Cql a11, Cql a12, Cql a13, Cql a14, Cql a15, Cql a16, Cql a17, Cql a18, Cql a19, Cql a20, Cql a21, Cql a22, Cql a23, Cql a24, Cql a25, Cql a26, Cql a27, Cql a28) => Tuple (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28)

(Cql a1, Cql a2, Cql a3, Cql a4, Cql a5, Cql a6, Cql a7, Cql a8, Cql a9, Cql a10, Cql a11, Cql a12, Cql a13, Cql a14, Cql a15, Cql a16, Cql a17, Cql a18, Cql a19, Cql a20, Cql a21, Cql a22, Cql a23, Cql a24, Cql a25, Cql a26, Cql a27, Cql a28, Cql a29) => Tuple (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29)

(Cql a1, Cql a2, Cql a3, Cql a4, Cql a5, Cql a6, Cql a7, Cql a8, Cql a9, Cql a10, Cql a11, Cql a12, Cql a13, Cql a14, Cql a15, Cql a16, Cql a17, Cql a18, Cql a19, Cql a20, Cql a21, Cql a22, Cql a23, Cql a24, Cql a25, Cql a26, Cql a27, Cql a28, Cql a29, Cql a30) => Tuple (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30)

(Cql a1, Cql a2, Cql a3, Cql a4, Cql a5, Cql a6, Cql a7, Cql a8, Cql a9, Cql a10, Cql a11, Cql a12, Cql a13, Cql a14, Cql a15, Cql a16, Cql a17, Cql a18, Cql a19, Cql a20, Cql a21, Cql a22, Cql a23, Cql a24, Cql a25, Cql a26, Cql a27, Cql a28, Cql a29, Cql a30, Cql a31) => Tuple (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31)

(Cql a1, Cql a2, Cql a3, Cql a4, Cql a5, Cql a6, Cql a7, Cql a8, Cql a9, Cql a10, Cql a11, Cql a12, Cql a13, Cql a14, Cql a15, Cql a16, Cql a17, Cql a18, Cql a19, Cql a20, Cql a21, Cql a22, Cql a23, Cql a24, Cql a25, Cql a26, Cql a27, Cql a28, Cql a29, Cql a30, Cql a31, Cql a32) => Tuple (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32)

(Cql a1, Cql a2, Cql a3, Cql a4, Cql a5, Cql a6, Cql a7, Cql a8, Cql a9, Cql a10, Cql a11, Cql a12, Cql a13, Cql a14, Cql a15, Cql a16, Cql a17, Cql a18, Cql a19, Cql a20, Cql a21, Cql a22, Cql a23, Cql a24, Cql a25, Cql a26, Cql a27, Cql a28, Cql a29, Cql a30, Cql a31, Cql a32, Cql a33) => Tuple (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33)

(Cql a1, Cql a2, Cql a3, Cql a4, Cql a5, Cql a6, Cql a7, Cql a8, Cql a9, Cql a10, Cql a11, Cql a12, Cql a13, Cql a14, Cql a15, Cql a16, Cql a17, Cql a18, Cql a19, Cql a20, Cql a21, Cql a22, Cql a23, Cql a24, Cql a25, Cql a26, Cql a27, Cql a28, Cql a29, Cql a30, Cql a31, Cql a32, Cql a33, Cql a34) => Tuple (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34)

(Cql a1, Cql a2, Cql a3, Cql a4, Cql a5, Cql a6, Cql a7, Cql a8, Cql a9, Cql a10, Cql a11, Cql a12, Cql a13, Cql a14, Cql a15, Cql a16, Cql a17, Cql a18, Cql a19, Cql a20, Cql a21, Cql a22, Cql a23, Cql a24, Cql a25, Cql a26, Cql a27, Cql a28, Cql a29, Cql a30, Cql a31, Cql a32, Cql a33, Cql a34, Cql a35) => Tuple (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35)

(Cql a1, Cql a2, Cql a3, Cql a4, Cql a5, Cql a6, Cql a7, Cql a8, Cql a9, Cql a10, Cql a11, Cql a12, Cql a13, Cql a14, Cql a15, Cql a16, Cql a17, Cql a18, Cql a19, Cql a20, Cql a21, Cql a22, Cql a23, Cql a24, Cql a25, Cql a26, Cql a27, Cql a28, Cql a29, Cql a30, Cql a31, Cql a32, Cql a33, Cql a34, Cql a35, Cql a36) => Tuple (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36)

(Cql a1, Cql a2, Cql a3, Cql a4, Cql a5, Cql a6, Cql a7, Cql a8, Cql a9, Cql a10, Cql a11, Cql a12, Cql a13, Cql a14, Cql a15, Cql a16, Cql a17, Cql a18, Cql a19, Cql a20, Cql a21, Cql a22, Cql a23, Cql a24, Cql a25, Cql a26, Cql a27, Cql a28, Cql a29, Cql a30, Cql a31, Cql a32, Cql a33, Cql a34, Cql a35, Cql a36, Cql a37) => Tuple (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37)

(Cql a1, Cql a2, Cql a3, Cql a4, Cql a5, Cql a6, Cql a7, Cql a8, Cql a9, Cql a10, Cql a11, Cql a12, Cql a13, Cql a14, Cql a15, Cql a16, Cql a17, Cql a18, Cql a19, Cql a20, Cql a21, Cql a22, Cql a23, Cql a24, Cql a25, Cql a26, Cql a27, Cql a28, Cql a29, Cql a30, Cql a31, Cql a32, Cql a33, Cql a34, Cql a35, Cql a36, Cql a37, Cql a38) => Tuple (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38)

(Cql a1, Cql a2, Cql a3, Cql a4, Cql a5, Cql a6, Cql a7, Cql a8, Cql a9, Cql a10, Cql a11, Cql a12, Cql a13, Cql a14, Cql a15, Cql a16, Cql a17, Cql a18, Cql a19, Cql a20, Cql a21, Cql a22, Cql a23, Cql a24, Cql a25, Cql a26, Cql a27, Cql a28, Cql a29, Cql a30, Cql a31, Cql a32, Cql a33, Cql a34, Cql a35, Cql a36, Cql a37, Cql a38, Cql a39) => Tuple (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39)

(Cql a1, Cql a2, Cql a3, Cql a4, Cql a5, Cql a6, Cql a7, Cql a8, Cql a9, Cql a10, Cql a11, Cql a12, Cql a13, Cql a14, Cql a15, Cql a16, Cql a17, Cql a18, Cql a19, Cql a20, Cql a21, Cql a22, Cql a23, Cql a24, Cql a25, Cql a26, Cql a27, Cql a28, Cql a29, Cql a30, Cql a31, Cql a32, Cql a33, Cql a34, Cql a35, Cql a36, Cql a37, Cql a38, Cql a39, Cql a40) => Tuple (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40)

(Cql a1, Cql a2, Cql a3, Cql a4, Cql a5, Cql a6, Cql a7, Cql a8, Cql a9, Cql a10, Cql a11, Cql a12, Cql a13, Cql a14, Cql a15, Cql a16, Cql a17, Cql a18, Cql a19, Cql a20, Cql a21, Cql a22, Cql a23, Cql a24, Cql a25, Cql a26, Cql a27, Cql a28, Cql a29, Cql a30, Cql a31, Cql a32, Cql a33, Cql a34, Cql a35, Cql a36, Cql a37, Cql a38, Cql a39, Cql a40, Cql a41) => Tuple (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41)

(Cql a1, Cql a2, Cql a3, Cql a4, Cql a5, Cql a6, Cql a7, Cql a8, Cql a9, Cql a10, Cql a11, Cql a12, Cql a13, Cql a14, Cql a15, Cql a16, Cql a17, Cql a18, Cql a19, Cql a20, Cql a21, Cql a22, Cql a23, Cql a24, Cql a25, Cql a26, Cql a27, Cql a28, Cql a29, Cql a30, Cql a31, Cql a32, Cql a33, Cql a34, Cql a35, Cql a36, Cql a37, Cql a38, Cql a39, Cql a40, Cql a41, Cql a42) => Tuple (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42)

(Cql a1, Cql a2, Cql a3, Cql a4, Cql a5, Cql a6, Cql a7, Cql a8, Cql a9, Cql a10, Cql a11, Cql a12, Cql a13, Cql a14, Cql a15, Cql a16, Cql a17, Cql a18, Cql a19, Cql a20, Cql a21, Cql a22, Cql a23, Cql a24, Cql a25, Cql a26, Cql a27, Cql a28, Cql a29, Cql a30, Cql a31, Cql a32, Cql a33, Cql a34, Cql a35, Cql a36, Cql a37, Cql a38, Cql a39, Cql a40, Cql a41, Cql a42, Cql a43) => Tuple (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43)

(Cql a1, Cql a2, Cql a3, Cql a4, Cql a5, Cql a6, Cql a7, Cql a8, Cql a9, Cql a10, Cql a11, Cql a12, Cql a13, Cql a14, Cql a15, Cql a16, Cql a17, Cql a18, Cql a19, Cql a20, Cql a21, Cql a22, Cql a23, Cql a24, Cql a25, Cql a26, Cql a27, Cql a28, Cql a29, Cql a30, Cql a31, Cql a32, Cql a33, Cql a34, Cql a35, Cql a36, Cql a37, Cql a38, Cql a39, Cql a40, Cql a41, Cql a42, Cql a43, Cql a44) => Tuple (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44)

(Cql a1, Cql a2, Cql a3, Cql a4, Cql a5, Cql a6, Cql a7, Cql a8, Cql a9, Cql a10, Cql a11, Cql a12, Cql a13, Cql a14, Cql a15, Cql a16, Cql a17, Cql a18, Cql a19, Cql a20, Cql a21, Cql a22, Cql a23, Cql a24, Cql a25, Cql a26, Cql a27, Cql a28, Cql a29, Cql a30, Cql a31, Cql a32, Cql a33, Cql a34, Cql a35, Cql a36, Cql a37, Cql a38, Cql a39, Cql a40, Cql a41, Cql a42, Cql a43, Cql a44, Cql a45) => Tuple (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45)

(Cql a1, Cql a2, Cql a3, Cql a4, Cql a5, Cql a6, Cql a7, Cql a8, Cql a9, Cql a10, Cql a11, Cql a12, Cql a13, Cql a14, Cql a15, Cql a16, Cql a17, Cql a18, Cql a19, Cql a20, Cql a21, Cql a22, Cql a23, Cql a24, Cql a25, Cql a26, Cql a27, Cql a28, Cql a29, Cql a30, Cql a31, Cql a32, Cql a33, Cql a34, Cql a35, Cql a36, Cql a37, Cql a38, Cql a39, Cql a40, Cql a41, Cql a42, Cql a43, Cql a44, Cql a45, Cql a46) => Tuple (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46)

(Cql a1, Cql a2, Cql a3, Cql a4, Cql a5, Cql a6, Cql a7, Cql a8, Cql a9, Cql a10, Cql a11, Cql a12, Cql a13, Cql a14, Cql a15, Cql a16, Cql a17, Cql a18, Cql a19, Cql a20, Cql a21, Cql a22, Cql a23, Cql a24, Cql a25, Cql a26, Cql a27, Cql a28, Cql a29, Cql a30, Cql a31, Cql a32, Cql a33, Cql a34, Cql a35, Cql a36, Cql a37, Cql a38, Cql a39, Cql a40, Cql a41, Cql a42, Cql a43, Cql a44, Cql a45, Cql a46, Cql a47) => Tuple (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47)

(Cql a1, Cql a2, Cql a3, Cql a4, Cql a5, Cql a6, Cql a7, Cql a8, Cql a9, Cql a10, Cql a11, Cql a12, Cql a13, Cql a14, Cql a15, Cql a16, Cql a17, Cql a18, Cql a19, Cql a20, Cql a21, Cql a22, Cql a23, Cql a24, Cql a25, Cql a26, Cql a27, Cql a28, Cql a29, Cql a30, Cql a31, Cql a32, Cql a33, Cql a34, Cql a35, Cql a36, Cql a37, Cql a38, Cql a39, Cql a40, Cql a41, Cql a42, Cql a43, Cql a44, Cql a45, Cql a46, Cql a47, Cql a48) => Tuple (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48)

count :: PrivateTuple a => Tagged a Int

check :: PrivateTuple a => Tagged a ([ColumnType] -> [ColumnType])

tuple :: PrivateTuple a => Version -> [ColumnType] -> Get a

store :: PrivateTuple a => Version -> Putter a

data Row

A row is a vector of Values.

Instances

Eq Row

Methods

(==) :: Row -> Row -> Bool

(/=) :: Row -> Row -> Bool

Show Row

Methods

showsPrec :: Int -> Row -> ShowS

show :: Row -> String

showList :: [Row] -> ShowS

Tuple Row

mkRow :: [(Value, ColumnType)] -> Row

fromRow :: Cql a => Int -> Row -> Either String a

Convert a row element.

columnTypes :: Row -> [ColumnType]

rowLength :: Row -> Int

class Record a where

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

Minimal complete definition

asTuple, asRecord

Methods

asTuple :: a -> TupleType a

asRecord :: TupleType a -> a

type family TupleType a

recordInstance :: Name -> Q [Dec]