Data.Table

This module provides tables with multiple indices that support a simple API based on the lenses and traversals from the lens package.

Tables

data Table t where

Every Table has a Primary key and may have Candidate, Supplemental or Inverted keys, plus their variants.

Constructors

EmptyTable :: Table t

Table :: Tabular t => Tab t (AnIndex t) -> Table t

Instances

Typeable1 Table

Foldable Table

(Functor f, Gettable f) => Contains f (Table t)

(Functor f, Contains (Accessor (IxValue (Table t))) (Table t), Applicative f) => Ixed f (Table t)

(Functor f, ~ * (Index (Table a)) (Index (Table b)), Tabular b, Applicative f, ~ * (PKT a) (PKT b)) => Each f (Table a) (Table b) a b

Eq t => Eq (Table t)

(Typeable (Table t), Tabular t, Data t) => Data (Table t)

(Eq (Table t), Ord t) => Ord (Table t)

(Tabular t, Read t) => Read (Table t)

Show t => Show (Table t)

Monoid (Table t)

Tabular t => At (Table t)

class Ord (PKT t) => Tabular t where

This class describes how to index a user-defined data type.

Associated Types

type PKT t

The primary key type

data Tab t m

Used to store indices

data Key k t :: * -> *

The type used internally for columns

Methods

fetch :: Key k t a -> t -> a

Extract the value of a Key

primary :: Key Primary t (PKT t)

Every Table has one Primary Key

primarily :: Key Primary t a -> (a ~ PKT t => r) -> r

... and so if you find one, it had better be that one!

mkTab :: Applicative h => (forall k a. IsKeyType k a => Key k t a -> h (i k a)) -> h (Tab t i)

Construct a Tab given a function from key to index.

ixTab :: Tab t i -> Key k t a -> i k a

Lookup an index in a Tab

forTab :: Applicative h => Tab t i -> (forall k a. IsKeyType k a => Key k t a -> i k a -> h (j k a)) -> h (Tab t j)

Loop over each index in a Tab

autoTab :: t -> Maybe (Tab t (AnIndex t) -> t)

Adjust a record using meta-information about the table allowing for auto-increments.

Instances

(Ord (PKT (Identity a)), Ord a) => Tabular (Identity a)

(Ord (PKT (Value a)), Ord a) => Tabular (Value a)

Ord (PKT (Auto a)) => Tabular (Auto a)

(Ord (PKT (k, v)), Ord k) => Tabular (k, v)

Simple (key, value) pairs

Table Construction

empty :: Table t

Construct an empty relation

singleton :: Tabular t => t -> Table t

Construct a relation with a single row

table :: Tabular t => Iso' [t] (Table t)

Convert a list to and from a Table.

The real isomorphism laws hold if the original list makes no use of the auto-increment functionality of the table, has no duplicates and is sorted according to the primary key.

However,

from table . table ≡ id

always holds.

fromList :: Tabular t => [t] -> Table t

Build up a table from a list

Reading and Writing

null :: Table t -> Bool

Check to see if the relation is empty

count :: Table t -> Int

Retrieve a row count.

class With q t | q -> t where

Methods

with :: Ord a => q a -> (forall x. Ord x => x -> x -> Bool) -> a -> Lens' (Table t) (Table t)

Select a smaller, updateable subset of the rows of a table using an index or an arbitrary function.

deleteWith :: Ord a => q a -> (forall x. Ord x => x -> x -> Bool) -> a -> Table t -> Table t

Delete selected rows from a table

deleteWith p cmp a t ≡ set (with p cmp a) empty t

Instances

With ((->) t) t

With (Key SupplementalHash t) t

With (Key SupplementalInt t) t

With (Key Supplemental t) t

With (Key CandidateHash t) t

With (Key CandidateInt t) t

With (Key Candidate t) t

With (Key Primary t) t

class Withal q s t | q -> s t where

Search inverted indices

Methods

withAny :: q -> s -> Lens' (Table t) (Table t)

withAll :: q -> s -> Lens' (Table t) (Table t)

deleteWithAny :: q -> s -> Table t -> Table t

deleteWithAll :: q -> s -> Table t -> Table t

Instances

Ord a => Withal (t -> [a]) [a] t

(Eq a, Hashable a) => Withal (Key InvertedHash t (HashSet a)) [a] t

Withal (Key InvertedInt t IntSet) [Int] t

Ord a => Withal (Key Inverted t (Set a)) [a] t

class Group f q t i | q -> t i where

Methods

group :: Ord i => q -> IndexedLensLike' i f (Table t) (Table t)

Group by a given key or arbitrary function.

Instances

Applicative f => Group f (t -> a) t a

(Applicative f, Gettable f) => Group f (Key InvertedHash t (HashSet a)) t a

(Applicative f, Gettable f, ~ * a Int) => Group f (Key InvertedInt t IntSet) t a

(Applicative f, Gettable f) => Group f (Key Inverted t (Set a)) t a

Applicative f => Group f (Key SupplementalHash t a) t a

(Applicative f, ~ * a Int) => Group f (Key SupplementalInt t a) t a

Applicative f => Group f (Key Supplemental t a) t a

Applicative f => Group f (Key CandidateHash t a) t a

(Applicative f, ~ * a Int) => Group f (Key CandidateInt t a) t a

Applicative f => Group f (Key Candidate t a) t a

Applicative f => Group f (Key Primary t a) t a

insert :: Tabular t => t -> Table t -> Table t

Insert a row into a relation, removing collisions.

delete :: t -> Table t -> Table t

Delete this row from the database. This will remove any row that collides with the specified row on any primary or candidate key.

rows :: Tabular t => Traversal (Table s) (Table t) s t

Traverse all of the rows in a table, potentially changing table types completely.

rows' :: Traversal' (Table t) t

Traverse all of the rows in a table without changing any types

Esoterica

data Auto a

Constructors

Auto !Int a

Instances

Functor Auto

Typeable1 Auto

Foldable Auto

Traversable Auto

Comonad Auto

FunctorWithIndex Int Auto

FoldableWithIndex Int Auto

TraversableWithIndex Int Auto

(Indexable Int p, ~ (* -> * -> *) q (->), Functor f) => HasValue p q f (Auto a) (Auto b) a b

(Functor f, ~ * (Index (Auto a)) (Index (Auto b)), ~ * a Int, ~ * b Int, Applicative f) => Each f (Auto a) (Auto b) a b

Eq a => Eq (Auto a)

(Typeable (Auto a), Data a) => Data (Auto a)

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

Read a => Read (Auto a)

Show a => Show (Auto a)

Ord (PKT (Auto a)) => Tabular (Auto a)

Field1 (Auto a) (Auto a) Int Int

Field2 (Auto a) (Auto b) a b

autoKey :: Lens' (Auto a) Int

auto :: a -> Auto a

Generate a row with an auto-incremented key

autoIncrement :: (Tabular t, PKT t ~ Int) => ALens' t Int -> t -> Maybe (Tab t (AnIndex t) -> t)

This lets you define autoKey to increment to 1 greater than the existing maximum key in a table.

In order to support this you need a numeric primary key, and the ability to update the primary key in a record, indicated by a lens to the field.

To enable auto-increment for a table with primary key primaryKeyField, set:

autoKey = autoIncrement primaryKeyField

Implementation Details

class IsKeyType k a where

Methods

keyType :: Key k t a -> KeyType k a

Instances

~ * a [Int] => IsKeyType InvertedInt IntSet

(Eq a, Hashable a) => IsKeyType SupplementalHash a

~ * a Int => IsKeyType SupplementalInt a

Ord a => IsKeyType Supplemental a

(Eq a, Hashable a) => IsKeyType CandidateHash a

~ * a Int => IsKeyType CandidateInt a

Ord a => IsKeyType Candidate a

Ord a => IsKeyType Primary a

(Eq a, Hashable a) => IsKeyType InvertedHash (HashSet a)

Ord a => IsKeyType Inverted (Set a)

data KeyType t a where

Value-level key types

Constructors

Primary :: Ord a => KeyType Primary a

Candidate :: Ord a => KeyType Candidate a

CandidateInt :: KeyType CandidateInt Int

CandidateHash :: (Eq a, Hashable a) => KeyType CandidateHash a

Supplemental :: Ord a => KeyType Supplemental a

SupplementalInt :: KeyType SupplementalInt Int

SupplementalHash :: (Eq a, Hashable a) => KeyType SupplementalHash a

Inverted :: Ord a => KeyType Inverted (Set a)

InvertedInt :: KeyType InvertedInt IntSet

InvertedHash :: (Eq a, Hashable a) => KeyType InvertedHash (HashSet a)

data Primary

Type level key types

Instances

Ord a => IsKeyType Primary a

Applicative f => Group f (Key Primary t a) t a

With (Key Primary t) t

data Candidate

Instances

Ord a => IsKeyType Candidate a

Applicative f => Group f (Key Candidate t a) t a

With (Key Candidate t) t

data CandidateInt

Instances

~ * a Int => IsKeyType CandidateInt a

(Applicative f, ~ * a Int) => Group f (Key CandidateInt t a) t a

With (Key CandidateInt t) t

data CandidateHash

Instances

(Eq a, Hashable a) => IsKeyType CandidateHash a

Applicative f => Group f (Key CandidateHash t a) t a

With (Key CandidateHash t) t

data Supplemental

Instances

Ord a => IsKeyType Supplemental a

Applicative f => Group f (Key Supplemental t a) t a

With (Key Supplemental t) t

data SupplementalInt

Instances

~ * a Int => IsKeyType SupplementalInt a

(Applicative f, ~ * a Int) => Group f (Key SupplementalInt t a) t a

With (Key SupplementalInt t) t

data SupplementalHash

Instances

(Eq a, Hashable a) => IsKeyType SupplementalHash a

Applicative f => Group f (Key SupplementalHash t a) t a

With (Key SupplementalHash t) t

data Inverted

Instances

Ord a => IsKeyType Inverted (Set a)

(Applicative f, Gettable f) => Group f (Key Inverted t (Set a)) t a

Ord a => Withal (Key Inverted t (Set a)) [a] t

data InvertedInt

Instances

~ * a [Int] => IsKeyType InvertedInt IntSet

(Applicative f, Gettable f, ~ * a Int) => Group f (Key InvertedInt t IntSet) t a

Withal (Key InvertedInt t IntSet) [Int] t

data InvertedHash

Instances

(Eq a, Hashable a) => IsKeyType InvertedHash (HashSet a)

(Applicative f, Gettable f) => Group f (Key InvertedHash t (HashSet a)) t a

(Eq a, Hashable a) => Withal (Key InvertedHash t (HashSet a)) [a] t

data AnIndex t k a where

This is used to store a single index.

Constructors

PrimaryMap :: Map (PKT t) t -> AnIndex t Primary a

CandidateIntMap :: IntMap t -> AnIndex t CandidateInt Int

CandidateHashMap :: (Eq a, Hashable a) => HashMap a t -> AnIndex t CandidateHash a

CandidateMap :: Ord a => Map a t -> AnIndex t Candidate a

InvertedIntMap :: IntMap [t] -> AnIndex t InvertedInt IntSet

InvertedHashMap :: (Eq a, Hashable a) => HashMap a [t] -> AnIndex t InvertedHash (HashSet a)

InvertedMap :: Ord a => Map a [t] -> AnIndex t Inverted (Set a)

SupplementalIntMap :: IntMap [t] -> AnIndex t SupplementalInt Int

SupplementalHashMap :: (Eq a, Hashable a) => HashMap a [t] -> AnIndex t SupplementalHash a

SupplementalMap :: Ord a => Map a [t] -> AnIndex t Supplemental a