Database.CQL.IO

This driver operates on some state which must be initialised prior to executing client operations and terminated eventually. The library uses tinylog for its logging output and expects a Logger.

For example:

> import Data.Text (Text)
> import Data.Functor.Identity
> import Database.CQL.IO as Client
> import Database.CQL.Protocol
> import qualified System.Logger as Logger
>
> g <- Logger.new Logger.defSettings
> c <- Client.init g defSettings
> let p = QueryParams One False () Nothing Nothing Nothing
> runClient c $ query ("SELECT cql_version from system.local" :: QueryString R () (Identity Text)) p
[Identity "3.2.0"]
> shutdown c

Client settings

data Settings

defSettings :: Settings

Default settings:

• contact point is "localhost" port 9042
• load-balancing policy is random
• binary protocol version is 3 (supported by Cassandra >= 2.1.0)
• connection idle timeout is 60s
• the connection pool uses 4 stripes to mitigate thread contention
• connections use a connect timeout of 5s, a send timeout of 3s and a receive timeout of 10s
• 128 streams per connection are used
• no compression is applied to frame bodies
• no default keyspace is used.

addContact :: String -> Settings -> Settings

Add an additional host to the contact list.

setCompression :: Compression -> Settings -> Settings

Set the compression to use for frame body compression.

setConnectTimeout :: NominalDiffTime -> Settings -> Settings

Set the connect timeout of a connection.

setContacts :: String -> [String] -> Settings -> Settings

Set the initial contact points (hosts) from which node discovery will start.

setIdleTimeout :: NominalDiffTime -> Settings -> Settings

Set the connection idle timeout. Connections in a pool will be closed if not in use for longer than this timeout.

setKeyspace :: Keyspace -> Settings -> Settings

Set the default keyspace to use. Every new connection will be initialised to use this keyspace.

setMaxConnections :: Int -> Settings -> Settings

Maximum connections per pool stripe.

setMaxStreams :: Int -> Settings -> Settings

Set the maximum number of streams per connection. In version 2 of the binary protocol at most 128 streams can be used. Version 3 supports up to 32768 streams.

setMaxTimeouts :: Int -> Settings -> Settings

When receiving a response times out, we can no longer use the stream of the connection that was used to make the request as it is uncertain if a response will arrive later. Thus the bandwith of a connection will be decreased. This settings defines a threshold after which we close the connection to get a new one with all streams available.

setMaxWaitQueue :: Word64 -> Settings -> Settings

Set the maximum length of the wait queue which is used if connection pools of all nodes in a cluster are busy. Once the maximum queue size has been reached, queries will throw a HostsBusy exception immediatly.

setPolicy :: IO Policy -> Settings -> Settings

Set the load-balancing policy.

setPoolStripes :: Int -> Settings -> Settings

Set the number of pool stripes to use. A good setting is equal to the number of CPU cores this codes is running on.

setPortNumber :: PortNumber -> Settings -> Settings

Set the portnumber to use to connect on every node of the cluster.

setProtocolVersion :: Version -> Settings -> Settings

Set the binary protocol version to use.

setResponseTimeout :: NominalDiffTime -> Settings -> Settings

Set the receive timeout of a connection. Requests exceeding the receive timeout will fail with a Timeout exception.

setSendTimeout :: NominalDiffTime -> Settings -> Settings

Set the send timeout of a connection. Request exceeding the send will cause the connection to be closed and fail with ConnectionClosed exception.

Client monad

data Client a

The Client monad.

A simple reader monad around some internal state. Prior to executing this monad via runClient, its state must be initialised through init and after finishing operation it should be terminated with shutdown.

Actual CQL queries are handled by invoking request oder command. Additionally debugInfo returns an internal cluster view.

Instances

Monad Client

Functor Client

Applicative Client

MonadThrow Client

MonadCatch Client

MonadMask Client

MonadIO Client

MonadLogger Client

MonadReader ClientState Client

data ClientState

Opaque client state/environment.

Instances

MonadReader ClientState Client

data DebugInfo

Constructors

DebugInfo

Fields

policyInfo :: String

Policy string representation

jobInfo :: [InetAddr]

hosts currently checked for reachability

hostInfo :: [Host]

all known hosts

Instances

Show DebugInfo

init :: MonadIO m => Logger -> Settings -> m ClientState

Initialise client state with the given Settings using the provided Logger for all it's logging output.

runClient :: MonadIO m => ClientState -> Client a -> m a

Execute the client monad.

shutdown :: MonadIO m => ClientState -> m ()

Terminate client state, i.e. end all running background checks and shutdown all connection pools.

debugInfo :: Client DebugInfo

query :: (Tuple a, Tuple b) => QueryString R a b -> QueryParams a -> Client [b]

Run a CQL read-only query against a Cassandra node.

write :: Tuple a => QueryString W a () -> QueryParams a -> Client ()

Run a CQL insert/update query against a Cassandra node.

schema :: Tuple a => QueryString S a () -> QueryParams a -> Client (Maybe SchemaChange)

Run a CQL schema query against a Cassandra node.

batch :: Batch -> Client ()

Run a batch query against a Cassandra node.

data Page a

Return value of paginate. Contains the actual result values as well as an indication of whether there is more data available and the actual action to fetch the next page.

Constructors

Page

Fields

hasMore :: !Bool

result :: [a]

nextPage :: Client (Page a)

Instances

Functor Page

emptyPage :: Page a

A page with an empty result list.

paginate :: (Tuple a, Tuple b) => QueryString R a b -> QueryParams a -> Client (Page b)

Run a CQL read-only query against a Cassandra node.

This function is like query, but limits the result size to 10000 (default) unless there is an explicit size restriction given in QueryParams. The returned Page can be used to continue the query.

Please note that -- as of Cassandra 2.1.0 -- if your requested page size is equal to the result size, hasMore might be true and a subsequent nextPage will return an empty list in result.

low-level

request :: (Tuple a, Tuple b) => Request k a b -> Client (Response k a b)

Send a CQL Request to the server and return a Response.

This function will first ask the clients load-balancing Policy for some host and use its connection pool to acquire a connection for request transmission.

If all available hosts are busy (i.e. their connection pools are fully utilised), the function will block until a connection becomes available or the maximum wait-queue length has been reached.

command :: Request k () () -> Client ()

Like request but not returning any result.

Policies

data Policy

A policy defines a load-balancing strategy and generally handles host visibility.

Constructors

Policy

Fields

setup :: [Host] -> [Host] -> IO ()

Initialise the policy with two sets of hosts. The first parameter are hosts known to be available, the second are other nodes. Please note that a policy may be re-initialised at any point through this method.

onEvent :: HostEvent -> IO ()

Event handler. Policies will be informed about cluster changes through this function.

select :: IO (Maybe Host)

Host selection. The driver will ask for a host to use in a query through this function. A policy which has no available nodes my return Nothing.

acceptable :: Host -> IO Bool

During startup and node discovery, the driver will ask the policy if a dicovered host should be ignored.

hostCount :: IO Word

During query processing, the driver will ask the policy for a rough esitimate of alive hosts. The number is used to repeatedly invoke select (with the underlying assumption that the policy returns mostly different hosts).

display :: IO String

Like having an effectful Show instance for this policy.

random :: IO Policy

Return hosts in random order.

roundRobin :: IO Policy

Iterate over hosts one by one.

Hosts

data Host

Host representation.

Instances

Eq Host

Ord Host

Show Host

ToBytes Host

data HostEvent

This event will be passed to a Policy to inform it about cluster changes.

Constructors

HostNew !Host

a new host has been added to the cluster

HostGone !InetAddr

a host has been removed from the cluster

HostUp !InetAddr

a host has been started

HostDown !InetAddr

a host has been stopped

newtype InetAddr

Constructors

InetAddr

Fields

sockAddr :: SockAddr

Instances

Eq InetAddr

Ord InetAddr

Show InetAddr

ToBytes InetAddr

hostAddr :: Lens' Host InetAddr

The IP address and port number of this host.

dataCentre :: Lens' Host Text

The data centre name (may be an empty string).

rack :: Lens' Host Text

The rack name (may be an empty string).

Exceptions

data InvalidSettings

Constructors

UnsupportedCompression [CompressionAlgorithm]

InvalidCacheSize

Instances

Show InvalidSettings

Exception InvalidSettings

Typeable * InvalidSettings

data InternalError

Constructors

InternalError String

Instances

Show InternalError

Exception InternalError

Typeable * InternalError

data HostError

Constructors

NoHostAvailable

HostsBusy

Instances

Show HostError

Exception HostError

Typeable * HostError

data ConnectionError

Constructors

ConnectionClosed !InetAddr

ConnectTimeout !InetAddr

Instances

Show ConnectionError

Exception ConnectionError

Typeable * ConnectionError

data UnexpectedResponse where

Constructors

UnexpectedResponse :: UnexpectedResponse

UnexpectedResponse' :: Show b => Response k a b -> UnexpectedResponse

Instances

Show UnexpectedResponse

Exception UnexpectedResponse

Typeable * UnexpectedResponse

data Timeout

Constructors

TimeoutRead !String

Instances

Show Timeout

Exception Timeout

Typeable * Timeout