Selda

Operator alias for Selda.expEq (left-associative / precedence 4)

expEq :: forall a s. Col s a -> Col s a -> Col s Boolean

Operator alias for Selda.expGt (left-associative / precedence 4)

expGt :: forall a s. Col s a -> Col s a -> Col s Boolean

Operator alias for Selda.expOr (right-associative / precedence 2)

expOr :: forall s. Col s Boolean -> Col s Boolean -> Col s Boolean

count :: forall a s. Col s a -> Aggr s String

returns String because the value might not fit in the underlying js float

max_ :: forall a s. Col s a -> Aggr s (Maybe a)

returns Maybe in case of empty set aggregation

sum_ :: forall a s. Col s a -> Aggr s (Maybe String)

not_ :: forall s. Col s Boolean -> Col s Boolean

inArray :: forall a s. Col s a -> Array (Col s a) -> Col s Boolean

asc :: Order

desc :: Order

newtype Col s a

Constructors

• Col (Expr a)

Instances

• Newtype (Col s a) _
• Mapping (ToCols_ s) (Column a) (Col s a)
• (IsSymbol sym) => FoldingWithIndex ExtractCols (SProxy sym) (Array (Tuple String (Exists Expr))) (Col s a) (Array (Tuple String (Exists Expr)))

class Lit a  where

Members

• lit :: forall s. a -> Col s a

Instances

• Lit Boolean
• Lit String
• Lit Int
• (Lit a) => Lit (Maybe a)

showUpdate :: forall r' s r. TableToColsWithoutAlias r r' => GetCols r' => Table r -> (Record r' -> Col s Boolean) -> (Record r' -> Record r') -> String

showQuery :: forall s i. GetCols i => FullQuery s (Record i) -> String

showInsert1 :: forall rlcols t. CanInsertColumnsIntoTable rlcols t => TableColumnNames rlcols => RowListLength rlcols => Table t -> RLProxy rlcols -> String

showDeleteFrom :: forall r' s r. TableToColsWithoutAlias r r' => Table r -> (Record r' -> Col s Boolean) -> String

class (MonadAff m, MonadError PGError m, MonadReader Connection m) <= MonadSelda m 

Instances

• (MonadAff m, MonadError PGError m, MonadReader Connection m) => MonadSelda m

update :: forall m r' s r. TableToColsWithoutAlias r r' => GetCols r' => MonadSelda m => Table r -> (Record r' -> Col s Boolean) -> (Record r' -> Record r') -> m Unit

query :: forall m s tup i o. ColsToPGHandler s i tup o => GetCols i => FromSQLRow tup => MonadSelda m => FullQuery s (Record i) -> m (Array (Record o))

insert_ :: forall m tup rlcols t r. RowToList r rlcols => CanInsertColumnsIntoTable rlcols t => TableColumnNames rlcols => RowListLength rlcols => FromSQLRow tup => ToSQLRow tup => MkTupleToRecord tup r => HFoldl RecordToTuple Unit (Record r) tup => MonadSelda m => Table t -> Array (Record r) -> m Unit

Executes an insert query for each input record.

insert :: forall m tup rlcols t r. RowToList r rlcols => CanInsertColumnsIntoTable rlcols t => TableColumnNames rlcols => RowListLength rlcols => FromSQLRow tup => ToSQLRow tup => MkTupleToRecord tup r => HFoldl RecordToTuple Unit (Record r) tup => MonadSelda m => Table t -> Array (Record r) -> m (Array (Record r))

Executes an insert query for each input record. Records to be inserted needs to have columns without constraints, Default ale optional, Auto must be missing

deleteFrom :: forall m r' s r. TableToColsWithoutAlias r r' => MonadSelda m => Table r -> (Record r' -> Col s Boolean) -> m Unit

selectFrom_ :: forall reso resi s inner. FromSubQuery s inner resi => FullQuery (Inner s) (Record inner) -> (Record resi -> Query s (Record reso)) -> FullQuery s (Record reso)

selectFrom :: forall res cols s r. FromTable s r cols => Table r -> (Record cols -> Query s (Record res)) -> FullQuery s (Record res)

restrict :: forall s. Col s Boolean -> Query s Unit

orderBy :: forall a s. Order -> Col s a -> Query s Unit

notNull :: forall a s. Col s (Maybe a) -> Query s (Col s a)

limit :: forall s. Int -> Query s Unit

leftJoin_ :: forall inner mres res s. FromSubQuery s inner res => HMap WrapWithMaybe (Record res) (Record mres) => (Record res -> Col s Boolean) -> FullQuery (Inner s) (Record inner) -> Query s (Record mres)

leftJoin_ on q run sub query q; with this execute on to get JOIN constraint; add sub query to sources; return previously mapped record with each value in Col wrapped in Maybe (because LEFT JOIN can return null for each column)

leftJoin :: forall mres res s r. FromTable s r res => HMap WrapWithMaybe (Record res) (Record mres) => Table r -> (Record res -> Col s Boolean) -> Query s (Record mres)

groupBy' :: forall s o i. GetCols i => HMap WrapWithAggr (Record i) (Record o) => Record i -> Query s (Record o)

groupBy :: forall a s. Col s a -> Query s (Aggr s a)

crossJoin_ :: forall res s inner. FromSubQuery s inner res => FullQuery (Inner s) (Record inner) -> Query s (Record res)

crossJoin :: forall res r s. FromTable s r res => Table r -> Query s (Record res)

aggregate :: forall res aggr s. HMapWithIndex UnAggr (Record aggr) (Record res) => FullQuery s (Record aggr) -> FullQuery s (Record res)

newtype Query s a

Represents an intermediate query state. Before being wrapped with FullQuery this state represents SQL query without FROM component, but having every other including JOIN[s]

Constructors

• Query (State GenState a)

Instances

• Functor (Query s)
• Apply (Query s)
• Applicative (Query s)
• Bind (Query s)
• Monad (Query s)

newtype FullQuery s a

wrapper for query that is ready for SQL generation This could be simple record { head ∷ SQL, st ∷ GenState } where st is state from wrapped query

Constructors

• FullQuery (Query s a)

Instances

• Newtype (FullQuery s a) _
• Functor (FullQuery s)

newtype Table (r :: Row Type)

Constructors

• Table { name :: String }