Database.Cassandra.Types

Documentation

data ModifyOperation a

Possible outcomes of a modify operation

Constructors

Update a

Delete

DoNothing

Instances

Eq a => Eq (ModifyOperation a)

Ord a => Ord (ModifyOperation a)

Read a => Read (ModifyOperation a)

Show a => Show (ModifyOperation a)

data KeySelector

A Key range selector to use with getMulti.

Constructors

Keys [Key]

Just a list of keys to get

KeyRange KeyRangeType Key Key Int32

A range of keys to get. Remember that RandomPartitioner ranges may not mean much as keys are randomly assigned to nodes.

Instances

Show KeySelector

data KeyRangeType

Encodes the Key vs. Token options in the thrift API.

InclusiveRange ranges are just plain intuitive range queries. WrapAround ranges are also inclusive, but they wrap around the ring.

Constructors

InclusiveRange

WrapAround

Instances

Show KeyRangeType

mkKeyRange :: KeySelector -> KeyRange

data Selector

A column selector/filter statement for queries.

Remember that SuperColumns are always fully deserialized, so we don't offer a way to filter columns within a SuperColumn.

Column names and ranges are specified by any type that can be packed into a Cassandra column using the CasType typeclass.

Constructors

All

Return everything in Row

forall a . CasType a => ColNames [a]

Return specific columns or super-columns depending on the ColumnFamily

forall a b . (CasType a, CasType b) => SupNames a [b]

When deleting specific columns in a super column

forall a b . (CasType a, CasType b) => Range

Return a range of columns or super-columns.

Fields

rangeStart :: Maybe a

rangeEnd :: Maybe b

rangeOrder :: Order

rangeLimit :: Int32

Instances

Show Selector

Default Selector

range :: Selector

A default starting point for range Selector. Use this so you don't run into ambiguous type variables when using Nothing.

 range = Range (Nothing :: Maybe ByteString) (Nothing :: Maybe ByteString) Regular 1024

boundless :: Maybe ByteString

showCas :: CasType a => a -> String

mkPredicate :: Selector -> SlicePredicate

data Order

Order in a range query

Constructors

Regular

Reversed

Instances

Show Order

renderOrd :: Order -> Bool

reverseOrder :: Order -> Order

type ColumnFamily = String

type Key = ByteString

type RowKey = Key

type ColumnName = ByteString

type Value = ByteString

data Column

A Column is either a single key-value pair or a SuperColumn with an arbitrary number of key-value pairs

Constructors

SuperColumn ColumnName [Column]

Column

Fields

colKey :: ColumnName

colVal :: Value

colTS :: Maybe Int64

Last update timestamp; will be overridden during write/update ops

colTTL :: Maybe Int32

A TTL after which Cassandra will erase the column

Instances

Eq Column

Ord Column

Read Column

Show Column

type Row = [Column]

A full row is simply a sequence of columns

col :: ByteString -> ByteString -> Column

A short-hand for creating key-value Column values. This is pretty low level; you probably want to use packCol.

mkThriftCol :: Column -> IO Column

castColumn :: ColumnOrSuperColumn -> Either CassandraException Column

castCol :: Column -> Either CassandraException Column

castSuperCol :: SuperColumn -> Either CassandraException Column

data CassandraException

Constructors

NotFoundException

InvalidRequestException String

UnavailableException

TimedOutException

AuthenticationException String

AuthorizationException String

SchemaDisagreementException

ConversionException String

OperationNotSupported String

Instances

Eq CassandraException

Data CassandraException

Ord CassandraException

Read CassandraException

Show CassandraException

Typeable CassandraException

Exception CassandraException

casRetryH :: Monad m => Int -> Handler m Bool

Exception handler that returns True for errors that may be resolved after a retry. So they are good candidates for retrying queries.

networkRetryH :: Monad m => Int -> Handler m Bool

IOExceptions should be retried

getTime :: IO Int64

Cassandra is VERY sensitive to its timestamp values. As a convention, timestamps are always in microseconds

data PageResult m a

Describes the result of a single pagination action

Constructors

PDone

Done, this is all I have.

Fields

pCache :: [a]

PMore

Here's a batch and there is more when you call the action.

Fields

pCache :: [a]

pMore :: m (PageResult m a)

Instances

Monad m => Functor (PageResult m)

pIsDry :: PageResult m a -> Bool

pIsDone :: PageResult t t1 -> Bool

pHasMore :: PageResult t t1 -> Bool

class CKey a where

A typeclass to enable using any string-like type for row and column keys

Methods

toColKey :: a -> ByteString

fromColKey :: ByteString -> Either String a

Instances

CKey String

CKey ByteString

CKey ByteString

CKey Text

CKey Text

CKey [ByteString]

For easy composite keys, just serialize your data type to a list of bytestrings, we'll concat them and turn them into column keys.

fromColKey' :: CKey a => ByteString -> a

Raise an error if conversion fails