Internal.Data.Basic.Types

Synopsis

• data VarContext
  • = Filtering
  • | Updating
  • | Sorting
  • | Grouping
  • | Folding
  • | Mapping
• newtype Var (ctx :: VarContext) (a :: *) = Var Int
• newtype Key = Key Int
• data MissingField
  • = Required Symbol
  • | DynamicDefault Symbol
• data Cached
  • = Live
  • | Cached
• data EntityKind
  • = Fresh [MissingField]
  • | FromDb Cached
• newtype Entity (entKind :: EntityKind) a = Entity {
  • _getEntity :: a
  }
• getEntity :: forall entKind a entKind a. Iso (Entity entKind a) (Entity entKind a) a a
• toFreshEntity :: forall fs c a. Entity (FromDb c) a -> Entity (Fresh fs) a
• reorderMissingFieldsTo :: forall fs2 fs1 a. SetEqual fs1 fs2 => Entity (Fresh fs1) a -> Entity (Fresh fs2) a
• data FieldConstraint
  • = Unique Symbol
  • | ForeignKey Symbol
• type family MissingFields (entKind :: EntityKind) :: [MissingField] where ...
• type SetFields (missing :: [MissingField]) (table :: *) = TableFields table `Without` MissingFieldsNames missing
• type family TableFieldTypes (a :: *) (fs :: [Symbol]) :: [*] where ...
• class KnownSymbol (CapsName t s) => HasCapsFieldName t (s :: Symbol) where
• class AllSatisfy (TableField table) fields => AllTypesSatisfy (c :: * -> Symbol -> Constraint) (table :: *) (fields :: [Symbol]) where
• class (KnownSymbol n, ToJSON a) => JSONableField a (n :: Symbol)
• class GetEntityFromValue (fs :: [Symbol]) a where
  • type MissingFieldsFromValue fs a :: [MissingField]
• class (TableField table field, Ord (TableFieldType table field)) => OrdableField table field
• class (TableField table field, Eq (TableFieldType table field)) => EqableField table field
• class TableFieldTypes a fs ~ ts => FoldCompositeIntoEntity fs ts a where
• compositeToEntity :: forall a fs ts. (fs ~ TableFields a, ts ~ TableFieldTypes a fs, FoldCompositeIntoEntity fs ts a, Table a) => Composite ts -> Entity (Fresh '[]) a
• type family SameTypes toTable (toFields :: [Symbol]) fromTable (fromFields :: [Symbol]) :: Constraint where ...
• class (KnownSymbol (TableName table), AllSatisfy (TableField table) (TableFields table), AllSatisfy KnownSymbol (TableFields table), AllSatisfy (ValidConstraint table) (TableConstraints table), AllTypesSatisfy (TypeSatisfies ToField) table (TableFields table), OnMaybe (() :: Constraint) PrimaryKeyConstraint (TablePrimaryKey table), FromRow table) => Table table where
  • type TableName table = (name :: Symbol) | name -> table
  • type TableFields table :: [Symbol]
  • type TableConstraints table :: [FieldConstraint]
  • type TablePrimaryKey table :: Maybe Symbol
  • type TableRequiredFields table :: [MissingField]
• class ValidConstraint (table :: *) (constr :: FieldConstraint)
• getDbFields :: forall table. Table table => [Text]
• type family IsDbExp a :: Bool where ...
• type family KindOfDbExp a :: ExpressionKind where ...
• type family IsDbStatement (m :: k -> *) :: Bool where ...
• class ValueAsDbExp' (IsDbExp a) a b => ValueAsDbExp a b where
• class ValueAsDbExp' (isDbExp :: Bool) a b where
• type family CapsName table name where ...
• type family CapsName' name capsName where ...
• class (KnownSymbol name, KnownSymbol (CapsName table name), IsDbExp (TableFieldType table name) ~ False) => TableField (table :: *) (name :: Symbol) where
  • type TableFieldType table name :: *
  • type TableFieldCapsName table name :: Maybe Symbol
• class (UniqueConstraint name, AllTypesSatisfy NotNull (UniqueTable name) (UniqueFields name)) => PrimaryKeyConstraint (name :: Symbol)
• class (AllSatisfy (TableField (UniqueTable name)) (UniqueFields name), KnownSymbol name) => UniqueConstraint (name :: Symbol) where
  • type UniqueTable name :: *
  • type UniqueFields name :: [Symbol]
• class (KnownSymbol name, AllSatisfy (TableField (ForeignKeyFrom name)) (ForeignKeyFromFields name), AllSatisfy (TableField (ForeignKeyTo name)) (ForeignKeyToFields name), SameTypes (ForeignKeyTo name) (ForeignKeyToFields name) (ForeignKeyFrom name) (ForeignKeyFromFields name)) => ForeignKeyConstraint (name :: Symbol) where
  • type ForeignKeyFrom name :: *
  • type ForeignKeyTo name :: *
  • type ForeignKeyFromFields name :: [Symbol]
  • type ForeignKeyToFields name :: [Symbol]
• type family MissingFieldName (f :: MissingField) :: Symbol where ...
• type family MissingFieldsNames (fs :: [MissingField]) :: [Symbol] where ...
• type family WithFieldSet (field :: Symbol) (entKind :: EntityKind) :: EntityKind where ...
• type family WithFieldsSet (fields :: [Symbol]) (entKind :: EntityKind) :: EntityKind where ...
• type family WithoutMissingField (name :: Symbol) (fs :: [MissingField]) :: [MissingField] where ...
• type family WithoutMissingFields (fields :: [Symbol]) (fs :: [MissingField]) :: [MissingField] where ...
• type CanInsert entKind table = (Table table, CanInsertFresh (MissingFields entKind) table)
• type family CanInsert' (entKind :: EntityKind) (table :: *) :: Constraint where ...
• type CanInsertFresh (missing :: [MissingField]) (table :: *) = (CanInsertMissing missing, SetFields missing table `IsSubset` SetFields missing table, AllSatisfy (HasCapsFieldName table) (SetFields missing table), AllTypesSatisfy (TypeSatisfies ToField) table (SetFields missing table))
• type family CanInsertMissing (fs :: [MissingField]) :: Constraint where ...
• type CanUpdate table pk = (KnownSymbol pk, Table table, SetFields '[] table `IsSubset` SetFields '[] table)
• type DbResult list = ListToTuple (Entity (FromDb Live)) list
• type Variables ctx list = ListToTuple (Var ctx) list
• class TableSetVars ctx (tables :: [*]) where
• data BoolOp
  • = And
  • | Or
• data ResultType
  • = Filtered
  • | Unfiltered
  • | Inserted
  • | Deleted
  • | Updated
  • | Sorted
  • | Limited
  • | Grouped
  • | Mapped
  • | Folded
  • | RawQueried
• type family Selection (t :: ResultType) :: Constraint where ...
• type family CanTake (t :: ResultType) :: Constraint where ...
• type family CanAggregate (t :: ResultType) :: Constraint where ...
• type family CanMap (f :: ResultType) :: Constraint where ...
• type FieldIsGettableBool field missing = Not (field `Elem` MissingFieldsNames missing)
• type FieldIsGettable field missing = CheckWithError (FieldIsGettableBool field missing) ((ErrorText "Field " :<>: ShowType field) :<>: ErrorText " is not set")
• type FieldIsNotSet field setFields = CheckWithError (Not (Elem field setFields)) ((ErrorText "Cannot update the field " :<>: ShowType field) :<>: ErrorText " because it's already updated in this expression")
• varFromUpdateExp :: UpdateExp fields t -> Var Updating t
• type family ListToSimpleTuple (l :: [*]) :: * where ...
• type family TupleToList (map :: *) :: [*] where ...
• type FlattenTuple t = ListToSimpleTuple (TupleToList t)
• data DbStatement (resultType :: ResultType) (ts :: [*]) where
  • Table :: Table table => proxy (TableName table) -> DbStatement Unfiltered '[table]
  • Filter :: (TableSetVars Filtering tables, Selection f) => (Variables Filtering tables -> ConditionExp) -> DbStatement f tables -> DbStatement Filtered tables
  • Join :: DbStatement Unfiltered tables1 -> DbStatement Unfiltered tables2 -> DbStatement Unfiltered (tables1 ++ tables2)
  • Raw :: ToRow r => Text -> r -> DbStatement RawQueried a
  • Execute :: ToRow r => Text -> r -> DbStatement RawQueried '[]
  • Insert :: CanInsert missing table => Entity missing table -> DbStatement Inserted '[table]
  • Delete :: (Selection f, Table table) => DbStatement f '[table] -> DbStatement Deleted '[table]
  • Update :: Selection f => (Var Updating table -> UpdateExp fields table) -> DbStatement f '[table] -> DbStatement Updated '[a]
  • SortOn :: (Selection f, TableSetVars Sorting tables, Sortable ord) => (Variables Sorting tables -> ord) -> DbStatement f tables -> DbStatement Sorted tables
  • Take :: CanTake f => Int -> DbStatement f tables -> DbStatement Limited tables
  • Map :: (Mappable map, CanMap f, TableSetVars Mapping tables) => (Variables Mapping tables -> map) -> DbStatement f tables -> DbStatement Mapped '[MapResult map]
  • AsGroup :: TableSetVars Grouping tables => DbStatement f tables -> DbStatement Grouped tables
  • GroupMap :: GroupMappable map => ((AsAggregate group, DbStatement Grouped tables) -> map) -> GroupStatement group tables -> DbStatement Folded '[GroupMapResult map]
• data GroupStatement group tables where
  • GroupOn :: (Selection f, TableSetVars Grouping tables, Groupable group) => (Variables Grouping tables -> group) -> DbStatement f tables -> GroupStatement group tables
• data AM = AM
• data AggregateStatement aggr (marker :: AM) where
  • Aggregate :: (Aggregatable aggr, CanAggregate f, TableSetVars Folding tables) => (Variables Folding tables -> aggr) -> DbStatement f tables -> AggregateStatement aggr AM
• data UpdateExp (fields :: [Symbol]) (table :: *) where
  • NoUpdate :: Var Updating table -> UpdateExp '[] table
  • SetField :: (TableField table fieldName, FieldIsNotSet fieldName fields) => proxy fieldName -> UpdateExp fields table -> DbExp k (TableFieldType table fieldName) -> UpdateExp (fieldName ': fields) table
• data ConditionExp where
  • Compare :: Ord a => Comparison -> DbExp k1 a -> DbExp k2 a -> ConditionExp
  • BoolOp :: BoolOp -> ConditionExp -> ConditionExp -> ConditionExp
  • IsNull :: DbExp FieldExp (Maybe a) -> ConditionExp
  • IsNotNull :: DbExp FieldExp (Maybe a) -> ConditionExp
  • In :: LiteralCollection collection a => DbExp k a -> collection -> ConditionExp
  • Like :: Bool -> DbExp FieldExp Text -> Text -> ConditionExp
  • BoolLit :: Bool -> ConditionExp
• data ExpressionKind
  • = FieldExp
  • | LiteralExp
• data DbExp (kind :: ExpressionKind) a where
  • Field :: TableField table fieldName => proxy1 table -> proxy2 fieldName -> Var anyCtx table -> DbExp FieldExp (TableFieldType table fieldName)
  • Literal :: ToField a => a -> DbExp LiteralExp a
• data SomeDbExp where
  • SomeDbExp :: DbExp k a -> SomeDbExp
  • SomeVar :: Var k a -> SomeDbExp
• class Sortable ord where
• class LiteralCollection collection a | collection -> a where
• class Groupable group where
  • type AsAggregate group :: *
• data GroupMappableThing res (am :: AM) where
  • GroupMappableDbExp :: DbExp k a -> GroupMappableThing a AM
  • GroupMappableVar :: Var k a -> GroupMappableThing (Entity (FromDb Live) a) AM
  • GroupMappableAggr :: Aggregatable aggr => AggregateStatement aggr AM -> GroupMappableThing (AggregationResult aggr) AM
• type family GroupMapResultBase a where ...
• class GroupMappableBase map where
• type family GroupMapResult (map :: *) :: * where ...
• class GroupMappable map where
• type family InterpretAsGroupMap (a :: *) :: Bool where ...
• class MappableBase map where
  • type MapResultBase map :: *
• type family MapResult (map :: *) :: * where ...
• class Mappable map where
• getAggr :: AggregateStatement aggr AM -> aggr
• newtype Avg a = Avg a
• newtype Count a = Count a
• newtype Only a = Only a
• newtype List a = List a
• class AggregatableBase aggr where
  • type AggregationBaseResult aggr :: *
• type family BadAggregateBaseError where ...
• type family AggregationResult (aggr :: *) where ...
• class Aggregatable aggr where
• nameText :: forall name. KnownSymbol name => Text
• module Internal.Data.Basic.TypeLevel
• newtype Max a :: * -> * = Max {
  • getMax :: a
  }
• newtype Min a :: * -> * = Min {
  • getMin :: a
  }
• newtype Sum a :: * -> * = Sum {
  • getSum :: a
  }

Documentation