Safe Haskell	None
Language	Haskell2010

TsWeb.Db

Description

This builds on TsWeb.Types.Db's read-only/read-write discrimination by providing query functions to perform read-only operations, and an execute function to run updates, inserts, and deletes (and also selects as appropriate). All of these are performed as TsActionCtxT actions so as to nicely integrate with Spock. Finally, because I'm not a fan of exceptions, all of these functions trap Postgres errors and convert them into sum-type results.

I'm not yet providing shortcuts for the beam-postgres specific functions. I'm not actually sure that I need to (IIRC they all build Pg actions), but I will be adding them if necessary.

Synopsis

class Typeable (a :: k)
class Generic a
class Monad m => MonadIO (m :: Type -> Type) where
- liftIO :: IO a -> m a
data Identity a
delete :: BeamSqlBackend be => DatabaseEntity be db (TableEntity table) -> (forall s. (forall s'. table (QExpr be s')) -> QExpr be s Bool) -> SqlDelete be table
dumpSqlSelect :: Projectible (MockSqlBackend SqlSyntaxBuilder) res => Q (MockSqlBackend SqlSyntaxBuilder) db QBaseScope res -> IO ()
insert :: (BeamSqlBackend be, ProjectibleWithPredicate AnyType () Text (table (QField s))) => DatabaseEntity be db (TableEntity table) -> SqlInsertValues be (table (QExpr be s)) -> SqlInsert be table
insertData :: (Projectible be r, BeamSqlBackend be) => [r] -> SqlInsertValues be r
insertExpressions :: (BeamSqlBackend be, Beamable table) => (forall s'. [table (QExpr be s')]) -> SqlInsertValues be (table (QExpr be s))
insertFrom :: (BeamSqlBackend be, HasQBuilder be, Projectible be r) => Q be db QBaseScope r -> SqlInsertValues be r
insertOnly :: (BeamSqlBackend be, ProjectibleWithPredicate AnyType () Text (QExprToField r)) => DatabaseEntity be db (TableEntity table) -> (table (QField s) -> QExprToField r) -> SqlInsertValues be r -> SqlInsert be table
insertValues :: (BeamSqlBackend be, Beamable table, FieldsFulfillConstraint (BeamSqlBackendCanSerialize be) table) => [table Identity] -> SqlInsertValues be (table (QExpr be s))
lookup_ :: (Database be db, Table table, BeamSqlBackend be, HasQBuilder be, SqlValableTable be (PrimaryKey table), HasTableEquality be (PrimaryKey table)) => DatabaseEntity be db (TableEntity table) -> PrimaryKey table Identity -> SqlSelect be (table Identity)
runDelete :: (BeamSqlBackend be, MonadBeam be m) => SqlDelete be table -> m ()
runInsert :: (BeamSqlBackend be, MonadBeam be m) => SqlInsert be table -> m ()
runUpdate :: (BeamSqlBackend be, MonadBeam be m) => SqlUpdate be tbl -> m ()
save :: (Table table, BeamSqlBackend be, SqlValableTable be (PrimaryKey table), SqlValableTable be table, HasTableEquality be (PrimaryKey table)) => DatabaseEntity be db (TableEntity table) -> table Identity -> SqlUpdate be table
select :: (BeamSqlBackend be, HasQBuilder be, Projectible be res) => Q be db QBaseScope res -> SqlSelect be (QExprToIdentity res)
selectWith :: (BeamSqlBackend be, BeamSql99CommonTableExpressionBackend be, HasQBuilder be, Projectible be res) => With be db (Q be db QBaseScope res) -> SqlSelect be (QExprToIdentity res)
set :: Beamable table => table (QFieldAssignment be table')
setFieldsTo :: Table table => (forall s. table (QExpr be s)) -> table (QFieldAssignment be table')
toNewValue :: (forall s. QExpr be s a) -> QFieldAssignment be table a
toOldValue :: QFieldAssignment be table a
toUpdatedValue :: (forall s. table (QExpr be s) -> QExpr be s a) -> QFieldAssignment be table a
toUpdatedValueMaybe :: (forall s. table (QExpr be s) -> Maybe (QExpr be s a)) -> QFieldAssignment be table a
update :: (BeamSqlBackend be, Beamable table) => DatabaseEntity be db (TableEntity table) -> (forall s. table (QField s) -> QAssignment be s) -> (forall s. table (QExpr be s) -> QExpr be s Bool) -> SqlUpdate be table
updateRow :: (BeamSqlBackend be, Table table, HasTableEquality be (PrimaryKey table), SqlValableTable be (PrimaryKey table)) => DatabaseEntity be db (TableEntity table) -> table Identity -> (forall s. table (QField s) -> QAssignment be s) -> SqlUpdate be table
updateTable :: (BeamSqlBackend be, Beamable table) => DatabaseEntity be db (TableEntity table) -> table (QFieldAssignment be table) -> (forall s. table (QExpr be s) -> QExpr be s Bool) -> SqlUpdate be table
updateTableRow :: (BeamSqlBackend be, Table table, HasTableEquality be (PrimaryKey table), SqlValableTable be (PrimaryKey table)) => DatabaseEntity be db (TableEntity table) -> table Identity -> table (QFieldAssignment be table) -> SqlUpdate be table
aggregate_ :: (BeamSqlBackend be, Aggregable be a, Projectible be r, Projectible be a, ContextRewritable a, ThreadRewritable (QNested s) (WithRewrittenContext a QValueContext)) => (r -> a) -> Q be db (QNested s) r -> Q be db s (WithRewrittenThread (QNested s) s (WithRewrittenContext a QValueContext))
allInGroupExplicitly_ :: IsSql92AggregationSetQuantifierSyntax s => Maybe s
allInGroup_ :: IsSql92AggregationSetQuantifierSyntax s => Maybe s
anyOver_ :: BeamSql99AggregationBackend be => Maybe (BeamSqlBackendAggregationQuantifierSyntax be) -> QExpr be s SqlBool -> QAgg be s SqlBool
any_ :: BeamSql99AggregationBackend be => QExpr be s SqlBool -> QAgg be s SqlBool
avgOver_ :: (BeamSqlBackend be, Num a) => Maybe (BeamSqlBackendAggregationQuantifierSyntax be) -> QExpr be s a -> QAgg be s (Maybe a)
avg_ :: (BeamSqlBackend be, Num a) => QExpr be s a -> QAgg be s (Maybe a)
countAll_ :: BeamSqlBackend be => QAgg be s Int
countOver_ :: (BeamSqlBackend be, Integral b) => Maybe (BeamSqlBackendAggregationQuantifierSyntax be) -> QExpr be s a -> QAgg be s b
count_ :: (BeamSqlBackend be, Integral b) => QExpr be s a -> QAgg be s b
cumeDist_ :: BeamSqlT612Backend be => QAgg be s Double
denseRank_ :: BeamSqlT612Backend be => QAgg be s Int
distinctInGroup_ :: IsSql92AggregationSetQuantifierSyntax s => Maybe s
everyOver_ :: BeamSql99AggregationBackend be => Maybe (BeamSqlBackendAggregationQuantifierSyntax be) -> QExpr be s SqlBool -> QAgg be s SqlBool
every_ :: BeamSql99AggregationBackend be => QExpr be s SqlBool -> QAgg be s SqlBool
filterWhere_ :: BeamSqlT611Backend be => QAgg be s a -> QExpr be s Bool -> QAgg be s a
filterWhere_' :: BeamSqlT611Backend be => QAgg be s a -> QExpr be s SqlBool -> QAgg be s a
maxOver_ :: BeamSqlBackend be => Maybe (BeamSqlBackendAggregationQuantifierSyntax be) -> QExpr be s a -> QAgg be s (Maybe a)
max_ :: BeamSqlBackend be => QExpr be s a -> QAgg be s (Maybe a)
minOver_ :: BeamSqlBackend be => Maybe (BeamSqlBackendAggregationQuantifierSyntax be) -> QExpr be s a -> QAgg be s (Maybe a)
min_ :: BeamSqlBackend be => QExpr be s a -> QAgg be s (Maybe a)
percentRank_ :: BeamSqlT612Backend be => QAgg be s Double
rank_ :: BeamSqlT611Backend be => QAgg be s Int
rowNumber_ :: BeamSql2003ExpressionBackend be => QAgg be s Int
someOver_ :: BeamSql99AggregationBackend be => Maybe (BeamSqlBackendAggregationQuantifierSyntax be) -> QExpr be s SqlBool -> QAgg be s SqlBool
some_ :: BeamSql99AggregationBackend be => QExpr be s SqlBool -> QAgg be s SqlBool
sumOver_ :: (BeamSqlBackend be, Num a) => Maybe (BeamSqlBackendAggregationQuantifierSyntax be) -> QExpr be s a -> QAgg be s (Maybe a)
sum_ :: (BeamSqlBackend be, Num a) => QExpr be s a -> QAgg be s (Maybe a)
reuse :: ReusableQ be db res -> Q be db s (WithRewrittenThread QAnyScope s res)
selecting :: (BeamSql99CommonTableExpressionBackend be, HasQBuilder be, Projectible be res, ThreadRewritable QAnyScope res) => Q be db QAnyScope res -> With be db (ReusableQ be db res)
(<|>.) :: (SqlJustable a (QGenExpr ctxt syntax s y), SqlDeconstructMaybe syntax (QGenExpr ctxt syntax s y) a s) => QGenExpr ctxt syntax s y -> QGenExpr ctxt syntax s y -> QGenExpr ctxt syntax s y
allFromView_ :: (Database be db, Beamable table, BeamSqlBackend be) => DatabaseEntity be db (ViewEntity table) -> Q be db s (table (QExpr be s))
all_ :: (Database be db, BeamSqlBackend be) => DatabaseEntity be db (TableEntity table) -> Q be db s (table (QExpr be s))
as_ :: QGenExpr ctxt be s a -> QGenExpr ctxt be s a
asc_ :: BeamSqlBackend be => QExpr be s a -> QOrd be s a
bitLength_ :: BeamSqlBackend be => QGenExpr context be s SqlBitString -> QGenExpr context be s Int
bounds_ :: BeamSql2003ExpressionBackend be => QFrameBound be -> Maybe (QFrameBound be) -> QFrameBounds be
charLength_ :: (BeamSqlBackend be, BeamSqlBackendIsString be text) => QGenExpr context be s text -> QGenExpr context be s Int
coalesce_ :: BeamSqlBackend be => [QGenExpr ctxt be s (Maybe a)] -> QGenExpr ctxt be s a -> QGenExpr ctxt be s a
currentTimestamp_ :: BeamSqlBackend be => QGenExpr ctxt be s LocalTime
current_ :: BeamSqlBackend be => QField s ty -> QExpr be s ty
default_ :: BeamSqlBackend be => QGenExpr ctxt be s a
desc_ :: BeamSqlBackend be => QExpr be s a -> QOrd be s a
distinct_ :: (BeamSqlBackend be, BeamSql99ExpressionBackend be, HasQBuilder be, Projectible be a) => Q be db s a -> QExpr be s Bool
else_ :: QGenExpr context be s a -> QIfElse context be s a
exceptAll_ :: (BeamSqlBackend be, Projectible be a, ThreadRewritable (QNested s) a) => Q be db (QNested s) a -> Q be db (QNested s) a -> Q be db s (WithRewrittenThread (QNested s) s a)
except_ :: (BeamSqlBackend be, Projectible be a, ThreadRewritable (QNested s) a) => Q be db (QNested s) a -> Q be db (QNested s) a -> Q be db s (WithRewrittenThread (QNested s) s a)
exists_ :: (BeamSqlBackend be, HasQBuilder be, Projectible be a) => Q be db s a -> QExpr be s Bool
filter_ :: BeamSqlBackend be => (r -> QExpr be s Bool) -> Q be db s r -> Q be db s r
filter_' :: BeamSqlBackend be => (r -> QExpr be s SqlBool) -> Q be db s r -> Q be db s r
frame_ :: (BeamSql2003ExpressionBackend be, SqlOrderable be ordering, Projectible be partition) => Maybe partition -> Maybe ordering -> QFrameBounds be -> QWindow be s
fromBound_ :: BeamSql2003ExpressionBackend be => QFrameBound be -> QFrameBounds be
fromMaybe_ :: BeamSqlBackend be => QGenExpr ctxt be s a -> QGenExpr ctxt be s (Maybe a) -> QGenExpr ctxt be s a
guard_ :: BeamSqlBackend be => QExpr be s Bool -> Q be db s ()
guard_' :: BeamSqlBackend be => QExpr be s SqlBool -> Q be db s ()
if_ :: BeamSqlBackend be => [QIfCond context be s a] -> QIfElse context be s a -> QGenExpr context be s a
intersectAll_ :: (BeamSqlBackend be, Projectible be a, ThreadRewritable (QNested s) a) => Q be db (QNested s) a -> Q be db (QNested s) a -> Q be db s (WithRewrittenThread (QNested s) s a)
intersect_ :: (BeamSqlBackend be, Projectible be a, ThreadRewritable (QNested s) a) => Q be db (QNested s) a -> Q be db (QNested s) a -> Q be db s (WithRewrittenThread (QNested s) s a)
join_ :: (Database be db, Table table, BeamSqlBackend be) => DatabaseEntity be db (TableEntity table) -> (table (QExpr be s) -> QExpr be s Bool) -> Q be db s (table (QExpr be s))
join_' :: (Database be db, Table table, BeamSqlBackend be) => DatabaseEntity be db (TableEntity table) -> (table (QExpr be s) -> QExpr be s SqlBool) -> Q be db s (table (QExpr be s))
leftJoin_ :: (BeamSqlBackend be, Projectible be r, ThreadRewritable (QNested s) r, Retaggable (QExpr be s) (WithRewrittenThread (QNested s) s r)) => Q be db (QNested s) r -> (WithRewrittenThread (QNested s) s r -> QExpr be s Bool) -> Q be db s (Retag Nullable (WithRewrittenThread (QNested s) s r))
leftJoin_' :: (BeamSqlBackend be, Projectible be r, ThreadRewritable (QNested s) r, Retaggable (QExpr be s) (WithRewrittenThread (QNested s) s r)) => Q be db (QNested s) r -> (WithRewrittenThread (QNested s) s r -> QExpr be s SqlBool) -> Q be db s (Retag Nullable (WithRewrittenThread (QNested s) s r))
limit_ :: (Projectible be a, ThreadRewritable (QNested s) a) => Integer -> Q be db (QNested s) a -> Q be db s (WithRewrittenThread (QNested s) s a)
lower_ :: (BeamSqlBackendIsString be text, BeamSqlBackend be) => QGenExpr context be s text -> QGenExpr context be s text
noBounds_ :: QFrameBounds be
noOrder_ :: Maybe (QOrd be s Int)
noPartition_ :: Maybe (QExpr be s Int)
nrows_ :: BeamSql2003ExpressionBackend be => Int -> QFrameBound be
nub_ :: (BeamSqlBackend be, Projectible be r) => Q be db s r -> Q be db s r
nullsFirst_ :: IsSql2003OrderingElementaryOLAPOperationsSyntax (BeamSqlBackendOrderingSyntax be) => QOrd be s a -> QOrd be s a
nullsLast_ :: IsSql2003OrderingElementaryOLAPOperationsSyntax (BeamSqlBackendOrderingSyntax be) => QOrd be s a -> QOrd be s a
octetLength_ :: (BeamSqlBackend be, BeamSqlBackendIsString be text) => QGenExpr context be s text -> QGenExpr context be s Int
offset_ :: (Projectible be a, ThreadRewritable (QNested s) a) => Integer -> Q be db (QNested s) a -> Q be db s (WithRewrittenThread (QNested s) s a)
orderBy_ :: (Projectible be a, SqlOrderable be ordering, ThreadRewritable (QNested s) a) => (a -> ordering) -> Q be db (QNested s) a -> Q be db s (WithRewrittenThread (QNested s) s a)
orderPartitionBy_ :: partition -> Maybe partition
outerJoin_ :: (BeamSqlBackend be, BeamSqlBackendSupportsOuterJoin be, Projectible be a, Projectible be b, ThreadRewritable (QNested s) a, ThreadRewritable (QNested s) b, Retaggable (QExpr be s) (WithRewrittenThread (QNested s) s a), Retaggable (QExpr be s) (WithRewrittenThread (QNested s) s b)) => Q be db (QNested s) a -> Q be db (QNested s) b -> ((WithRewrittenThread (QNested s) s a, WithRewrittenThread (QNested s) s b) -> QExpr be s Bool) -> Q be db s (Retag Nullable (WithRewrittenThread (QNested s) s a), Retag Nullable (WithRewrittenThread (QNested s) s b))
outerJoin_' :: (BeamSqlBackend be, BeamSqlBackendSupportsOuterJoin be, Projectible be a, Projectible be b, ThreadRewritable (QNested s) a, ThreadRewritable (QNested s) b, Retaggable (QExpr be s) (WithRewrittenThread (QNested s) s a), Retaggable (QExpr be s) (WithRewrittenThread (QNested s) s b)) => Q be db (QNested s) a -> Q be db (QNested s) b -> ((WithRewrittenThread (QNested s) s a, WithRewrittenThread (QNested s) s b) -> QExpr be s SqlBool) -> Q be db s (Retag Nullable (WithRewrittenThread (QNested s) s a), Retag Nullable (WithRewrittenThread (QNested s) s b))
over_ :: BeamSql2003ExpressionBackend be => QAgg be s a -> QWindow be s -> QWindowExpr be s a
partitionBy_ :: partition -> Maybe partition
perhaps_ :: (Projectible be r, BeamSqlBackend be, ThreadRewritable (QNested s) r, Retaggable (QExpr be s) (WithRewrittenThread (QNested s) s r)) => Q be db (QNested s) r -> Q be db s (Retag Nullable (WithRewrittenThread (QNested s) s r))
position_ :: (BeamSqlBackendIsString be text, BeamSqlBackend be, Integral b) => QExpr be s text -> QExpr be s text -> QExpr be s b
references_ :: (Table t, BeamSqlBackend be, HasTableEquality be (PrimaryKey t)) => PrimaryKey t (QGenExpr ctxt be s) -> t (QGenExpr ctxt be s) -> QGenExpr ctxt be s Bool
relatedBy_ :: (Database be db, Table rel, BeamSqlBackend be) => DatabaseEntity be db (TableEntity rel) -> (rel (QExpr be s) -> QExpr be s Bool) -> Q be db s (rel (QExpr be s))
relatedBy_' :: (Database be db, Table rel, BeamSqlBackend be) => DatabaseEntity be db (TableEntity rel) -> (rel (QExpr be s) -> QExpr be s SqlBool) -> Q be db s (rel (QExpr be s))
related_ :: (Database be db, Table rel, BeamSqlBackend be, HasTableEquality be (PrimaryKey rel)) => DatabaseEntity be db (TableEntity rel) -> PrimaryKey rel (QExpr be s) -> Q be db s (rel (QExpr be s))
subquery_ :: (BeamSqlBackend be, HasQBuilder be, Projectible be (QExpr be s a)) => Q be db s (QExpr be s a) -> QGenExpr ctxt be s a
subselect_ :: (ThreadRewritable (QNested s) r, Projectible be r) => Q be db (QNested s) r -> Q be db s (WithRewrittenThread (QNested s) s r)
then_ :: QGenExpr context be s Bool -> QGenExpr context be s a -> QIfCond context be s a
then_' :: QGenExpr context be s SqlBool -> QGenExpr context be s a -> QIfCond context be s a
trim_ :: (BeamSqlBackendIsString be text, BeamSqlBackend be) => QGenExpr context be s text -> QGenExpr context be s text
unbounded_ :: BeamSql2003ExpressionBackend be => QFrameBound be
unionAll_ :: (BeamSqlBackend be, Projectible be a, ThreadRewritable (QNested s) a) => Q be db (QNested s) a -> Q be db (QNested s) a -> Q be db s (WithRewrittenThread (QNested s) s a)
union_ :: (BeamSqlBackend be, Projectible be a, ThreadRewritable (QNested s) a) => Q be db (QNested s) a -> Q be db (QNested s) a -> Q be db s (WithRewrittenThread (QNested s) s a)
unique_ :: (BeamSqlBackend be, HasQBuilder be, Projectible be a) => Q be db s a -> QExpr be s Bool
upper_ :: (BeamSqlBackendIsString be text, BeamSqlBackend be) => QGenExpr context be s text -> QGenExpr context be s text
values_ :: (Projectible be a, BeamSqlBackend be) => [a] -> Q be db s a
withWindow_ :: (ProjectibleWithPredicate WindowFrameContext be (WithExprContext (BeamSqlBackendWindowFrameSyntax' be)) window, Projectible be r, Projectible be a, ContextRewritable a, ThreadRewritable (QNested s) (WithRewrittenContext a QValueContext)) => (r -> window) -> (r -> window -> a) -> Q be db (QNested s) r -> Q be db s (WithRewrittenThread (QNested s) s (WithRewrittenContext a QValueContext))
agg_ :: QAgg be s a -> QAgg be s a
valueExpr_ :: QExpr be s a -> QExpr be s a
array :: (Typeable a, BeamSql99DataTypeBackend be) => DataType be a -> Int -> DataType be (Vector a)
bigint :: (BeamSqlBackend be, BeamSqlT071Backend be, Integral a) => DataType be a
binary :: (BeamSqlBackend be, BeamSqlT021Backend be) => Maybe Word -> DataType be Integer
binaryLargeObject :: BeamSql99DataTypeBackend be => DataType be Text
boolean :: BeamSql99DataTypeBackend be => DataType be Bool
cast_ :: BeamSqlBackend be => QGenExpr ctxt be s a -> DataType be b -> QGenExpr ctxt be s b
char :: BeamSqlBackend be => Maybe Word -> DataType be Text
characterLargeObject :: BeamSql99DataTypeBackend be => DataType be Text
date :: BeamSqlBackend be => DataType be Day
double :: BeamSqlBackend be => DataType be Double
int :: (BeamSqlBackend be, Integral a) => DataType be a
maybeType :: DataType be a -> DataType be (Maybe a)
nationalChar :: BeamSqlBackend be => Maybe Word -> DataType be Text
nationalVarchar :: BeamSqlBackend be => Maybe Word -> DataType be Text
numeric :: BeamSqlBackend be => Maybe (Word, Maybe Word) -> DataType be Scientific
smallint :: (BeamSqlBackend be, Integral a) => DataType be a
time :: BeamSqlBackend be => Maybe Word -> DataType be TimeOfDay
timestamp :: BeamSqlBackend be => DataType be LocalTime
timestamptz :: BeamSqlBackend be => DataType be LocalTime
varbinary :: (BeamSqlBackend be, BeamSqlT021Backend be) => Maybe Word -> DataType be Integer
varchar :: BeamSqlBackend be => Maybe Word -> DataType be Text
(**.) :: (Floating a, BeamSqlBackend be, BeamSqlT621Backend be) => QGenExpr ctxt be s a -> QGenExpr ctxt be s a -> QGenExpr ctxt be s a
ceiling_ :: (RealFrac a, Integral b, BeamSqlBackend be, BeamSqlT621Backend be) => QGenExpr ctxt be s a -> QGenExpr ctxt be s b
corrOver_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => Maybe (BeamSqlBackendAggregationQuantifierSyntax be) -> QExpr be s a -> QExpr be s a -> QExpr be s b
corr_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => QExpr be s a -> QExpr be s a -> QExpr be s b
covarPopOver_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => Maybe (BeamSqlBackendAggregationQuantifierSyntax be) -> QExpr be s a -> QExpr be s a -> QExpr be s b
covarPop_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => QExpr be s a -> QExpr be s a -> QExpr be s b
covarSampOver_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => Maybe (BeamSqlBackendAggregationQuantifierSyntax be) -> QExpr be s a -> QExpr be s a -> QExpr be s b
covarSamp_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => QExpr be s a -> QExpr be s a -> QExpr be s b
exp_ :: (Floating a, BeamSqlBackend be, BeamSqlT621Backend be) => QGenExpr ctxt be s a -> QGenExpr ctxt be s a
firstValue_ :: (BeamSqlBackend be, BeamSqlT616Backend be) => QExpr be s a -> QAgg be s a
floor_ :: (RealFrac a, Integral b, BeamSqlBackend be, BeamSqlT621Backend be) => QGenExpr ctxt be s a -> QGenExpr ctxt be s b
lag1_ :: (BeamSqlBackend be, BeamSqlT615Backend be) => QExpr be s a -> QAgg be s a
lagWithDefault_ :: (BeamSqlBackend be, BeamSqlT615Backend be) => QExpr be s a -> QExpr be s Int -> QExpr be s a -> QAgg be s a
lag_ :: (BeamSqlBackend be, BeamSqlT615Backend be) => QExpr be s a -> QExpr be s Int -> QAgg be s a
lastValue_ :: (BeamSqlBackend be, BeamSqlT616Backend be) => QExpr be s a -> QAgg be s a
lead1_ :: (BeamSqlBackend be, BeamSqlT615Backend be) => QExpr be s a -> QAgg be s a
leadWithDefault_ :: (BeamSqlBackend be, BeamSqlT615Backend be) => QExpr be s a -> QExpr be s Int -> QExpr be s a -> QAgg be s a
lead_ :: (BeamSqlBackend be, BeamSqlT615Backend be) => QExpr be s a -> QExpr be s Int -> QAgg be s a
ln_ :: (Floating a, BeamSqlBackend be, BeamSqlT621Backend be) => QGenExpr ctxt be s a -> QGenExpr ctxt be s a
nthValue_ :: (BeamSqlBackend be, BeamSqlT618Backend be) => QExpr be s a -> QExpr be s Int -> QAgg be s a
ntile_ :: (BeamSqlBackend be, BeamSqlT614Backend be) => QExpr be s Int -> QAgg be s a
regrAvgXOver_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => Maybe (BeamSqlBackendAggregationQuantifierSyntax be) -> QExpr be s a -> QExpr be s a -> QExpr be s b
regrAvgX_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => QExpr be s a -> QExpr be s a -> QExpr be s b
regrAvgYOver_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => Maybe (BeamSqlBackendAggregationQuantifierSyntax be) -> QExpr be s a -> QExpr be s a -> QExpr be s b
regrAvgY_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => QExpr be s a -> QExpr be s a -> QExpr be s b
regrCountOver_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => Maybe (BeamSqlBackendAggregationQuantifierSyntax be) -> QExpr be s a -> QExpr be s a -> QExpr be s b
regrCount_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => QExpr be s a -> QExpr be s a -> QExpr be s b
regrInterceptOver_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => Maybe (BeamSqlBackendAggregationQuantifierSyntax be) -> QExpr be s a -> QExpr be s a -> QExpr be s b
regrIntercept_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => QExpr be s a -> QExpr be s a -> QExpr be s b
regrRSquaredOver_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => Maybe (BeamSqlBackendAggregationQuantifierSyntax be) -> QExpr be s a -> QExpr be s a -> QExpr be s b
regrRSquared_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => QExpr be s a -> QExpr be s a -> QExpr be s b
regrSXXOver_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => Maybe (BeamSqlBackendAggregationQuantifierSyntax be) -> QExpr be s a -> QExpr be s a -> QExpr be s b
regrSXX_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => QExpr be s a -> QExpr be s a -> QExpr be s b
regrSXYOver_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => Maybe (BeamSqlBackendAggregationQuantifierSyntax be) -> QExpr be s a -> QExpr be s a -> QExpr be s b
regrSXY_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => QExpr be s a -> QExpr be s a -> QExpr be s b
regrSYYOver_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => Maybe (BeamSqlBackendAggregationQuantifierSyntax be) -> QExpr be s a -> QExpr be s a -> QExpr be s b
regrSYY_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => QExpr be s a -> QExpr be s a -> QExpr be s b
regrSlopeOver_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => Maybe (BeamSqlBackendAggregationQuantifierSyntax be) -> QExpr be s a -> QExpr be s a -> QExpr be s b
regrSlope_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => QExpr be s a -> QExpr be s a -> QExpr be s b
sqrt_ :: (Floating a, BeamSqlBackend be, BeamSqlT621Backend be) => QGenExpr ctxt be s a -> QGenExpr ctxt be s a
stddevPopOver_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => Maybe (BeamSqlBackendAggregationQuantifierSyntax be) -> QExpr be s a -> QAgg be s b
stddevPop_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => QExpr be s a -> QAgg be s b
stddevSampOver_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => Maybe (BeamSqlBackendAggregationQuantifierSyntax be) -> QExpr be s a -> QAgg be s b
stddevSamp_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => QExpr be s a -> QAgg be s b
varPopOver_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => Maybe (BeamSqlBackendAggregationQuantifierSyntax be) -> QExpr be s a -> QAgg be s b
varPop_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => QExpr be s a -> QAgg be s b
varSampOver_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => Maybe (BeamSqlBackendAggregationQuantifierSyntax be) -> QExpr be s a -> QAgg be s b
varSamp_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => QExpr be s a -> QAgg be s b
day_ :: (BeamSqlBackend be, HasSqlDate tgt) => ExtractField be tgt Double
extract_ :: BeamSqlBackend be => ExtractField be tgt a -> QGenExpr ctxt be s tgt -> QGenExpr cxt be s a
hour_ :: (BeamSqlBackend be, HasSqlTime tgt) => ExtractField be tgt Double
minutes_ :: (BeamSqlBackend be, HasSqlTime tgt) => ExtractField be tgt Double
month_ :: (BeamSqlBackend be, HasSqlDate tgt) => ExtractField be tgt Double
seconds_ :: (BeamSqlBackend be, HasSqlTime tgt) => ExtractField be tgt Double
year_ :: (BeamSqlBackend be, HasSqlDate tgt) => ExtractField be tgt Double
(&&.) :: BeamSqlBackend be => QGenExpr context be s Bool -> QGenExpr context be s Bool -> QGenExpr context be s Bool
(&&?.) :: BeamSqlBackend be => QGenExpr context be s SqlBool -> QGenExpr context be s SqlBool -> QGenExpr context be s SqlBool
concat_ :: BeamSql99ConcatExpressionBackend be => [QGenExpr context be s Text] -> QGenExpr context be s Text
div_ :: (Integral a, BeamSqlBackend be) => QGenExpr context be s a -> QGenExpr context be s a -> QGenExpr context be s a
like_ :: (BeamSqlBackendIsString be text, BeamSqlBackend be) => QGenExpr ctxt be s text -> QGenExpr ctxt be s text -> QGenExpr ctxt be s Bool
mod_ :: (Integral a, BeamSqlBackend be) => QGenExpr context be s a -> QGenExpr context be s a -> QGenExpr context be s a
not_ :: BeamSqlBackend be => QGenExpr context be s Bool -> QGenExpr context be s Bool
similarTo_ :: (BeamSqlBackendIsString be text, BeamSql99ExpressionBackend be) => QGenExpr ctxt be s text -> QGenExpr ctxt be s text -> QGenExpr ctxt be s text
sqlNot_ :: BeamSqlBackend be => QGenExpr context be s SqlBool -> QGenExpr context be s SqlBool
(||.) :: BeamSqlBackend be => QGenExpr context be s Bool -> QGenExpr context be s Bool -> QGenExpr context be s Bool
(||?.) :: BeamSqlBackend be => QGenExpr context be s SqlBool -> QGenExpr context be s SqlBool -> QGenExpr context be s SqlBool
allIn_ :: BeamSqlBackend be => [QExpr be s a] -> QQuantified be s a
allOf_ :: (BeamSqlBackend be, HasQBuilder be) => Q be db (QNested s) (QExpr be (QNested s) a) -> QQuantified be s a
anyIn_ :: BeamSqlBackend be => [QExpr be s a] -> QQuantified be s a
anyOf_ :: (BeamSqlBackend be, HasQBuilder be) => Q be db (QNested s) (QExpr be (QNested s) a) -> QQuantified be s a
between_ :: BeamSqlBackend be => QGenExpr context be s a -> QGenExpr context be s a -> QGenExpr context be s a -> QGenExpr context be s Bool
fromPossiblyNullBool_ :: QGenExpr context be s (Maybe Bool) -> QGenExpr context be s SqlBool
in_ :: BeamSqlBackend be => QGenExpr context be s a -> [QGenExpr context be s a] -> QGenExpr context be s Bool
isFalse_ :: BeamSqlBackend be => QGenExpr context be s SqlBool -> QGenExpr context be s Bool
isNotFalse_ :: BeamSqlBackend be => QGenExpr context be s SqlBool -> QGenExpr context be s Bool
isNotTrue_ :: BeamSqlBackend be => QGenExpr context be s SqlBool -> QGenExpr context be s Bool
isNotUnknown_ :: BeamSqlBackend be => QGenExpr context be s SqlBool -> QGenExpr context be s Bool
isTrue_ :: BeamSqlBackend be => QGenExpr context be s SqlBool -> QGenExpr context be s Bool
isUnknown_ :: BeamSqlBackend be => QGenExpr context be s SqlBool -> QGenExpr context be s Bool
possiblyNullBool_ :: QGenExpr context be s SqlBool -> QGenExpr context be s (Maybe Bool)
sqlBool_ :: QGenExpr context syntax s Bool -> QGenExpr context syntax s SqlBool
unknownAs_ :: BeamSqlBackend be => Bool -> QGenExpr context be s SqlBool -> QGenExpr context be s Bool
manyToManyPassthrough_ :: (Database be db, Table joinThrough, Table left, Table right, BeamSqlBackend be, SqlEq (QExpr be s) (PrimaryKey left (QExpr be s)), SqlEq (QExpr be s) (PrimaryKey right (QExpr be s))) => DatabaseEntity be db (TableEntity joinThrough) -> (joinThrough (QExpr be s) -> PrimaryKey left (QExpr be s)) -> (joinThrough (QExpr be s) -> PrimaryKey right (QExpr be s)) -> Q be db s (left (QExpr be s)) -> Q be db s (right (QExpr be s)) -> Q be db s (joinThrough (QExpr be s), left (QExpr be s), right (QExpr be s))
manyToMany_ :: (Database be db, Table joinThrough, Table left, Table right, BeamSqlBackend be, SqlEq (QExpr be s) (PrimaryKey left (QExpr be s)), SqlEq (QExpr be s) (PrimaryKey right (QExpr be s))) => DatabaseEntity be db (TableEntity joinThrough) -> (joinThrough (QExpr be s) -> PrimaryKey left (QExpr be s)) -> (joinThrough (QExpr be s) -> PrimaryKey right (QExpr be s)) -> Q be db s (left (QExpr be s)) -> Q be db s (right (QExpr be s)) -> Q be db s (left (QExpr be s), right (QExpr be s))
oneToManyOptional_ :: (BeamSqlBackend be, Database be db, Table tbl, Table rel, HasTableEqualityNullable be (PrimaryKey tbl)) => DatabaseEntity be db (TableEntity rel) -> (rel (QExpr be s) -> PrimaryKey tbl (Nullable (QExpr be s))) -> tbl (QExpr be s) -> Q be db s (rel (Nullable (QExpr be s)))
oneToMany_ :: (Database be db, BeamSqlBackend be, HasTableEquality be (PrimaryKey tbl), Table tbl, Table rel) => DatabaseEntity be db (TableEntity rel) -> (rel (QExpr be s) -> PrimaryKey tbl (QExpr be s)) -> tbl (QExpr be s) -> Q be db s (rel (QExpr be s))
oneToMaybe_ :: (BeamSqlBackend be, Database be db, Table tbl, Table rel, HasTableEqualityNullable be (PrimaryKey tbl)) => DatabaseEntity be db (TableEntity rel) -> (rel (QExpr be s) -> PrimaryKey tbl (Nullable (QExpr be s))) -> tbl (QExpr be s) -> Q be db s (rel (Nullable (QExpr be s)))
oneToOne_ :: (Database be db, BeamSqlBackend be, HasTableEquality be (PrimaryKey tbl), Table tbl, Table rel) => DatabaseEntity be db (TableEntity rel) -> (rel (QExpr be s) -> PrimaryKey tbl (QExpr be s)) -> tbl (QExpr be s) -> Q be db s (rel (QExpr be s))
dbLenses :: (Generic (db (TableLens f db)), Generic (db f), GDatabaseLenses (db f) (Rep (db f)) (Rep (db (TableLens f db)))) => db (TableLens f db)
tableLenses :: (lensType ~ Lenses t f, Generic (t lensType), Generic (t f), GTableLenses t f (Rep (t f)) (Rep (t lensType))) => t (Lenses t f)
dbModification :: Database be db => DatabaseModification f be db
defTblFieldSettings :: (Generic (TableSettings table), GDefaultTableFieldSettings (Rep (TableSettings table) ())) => TableSettings table
defaultDbSettings :: (Generic (DatabaseSettings be db), GAutoDbSettings (Rep (DatabaseSettings be db) ())) => DatabaseSettings be db
fieldName :: Lens' (TableField table ty) Text
fieldNamed :: Text -> FieldModification (TableField tbl) a
modifyEntityName :: IsDatabaseEntity be entity => (Text -> Text) -> EntityModification (DatabaseEntity be db) be entity
modifyTable :: (Beamable tbl, Table tbl) => (Text -> Text) -> tbl (FieldModification (TableField tbl)) -> EntityModification (DatabaseEntity be db) be (TableEntity tbl)
modifyTableFields :: tbl (FieldModification (TableField tbl)) -> EntityModification (DatabaseEntity be db) be (TableEntity tbl)
pk :: Table t => t f -> PrimaryKey t f
setEntityName :: IsDatabaseEntity be entity => Text -> EntityModification (DatabaseEntity be db) be entity
tableModification :: Beamable tbl => tbl (FieldModification f)
withDbModification :: Database be db => db (entity be db) -> DatabaseModification (entity be db) be db -> db (entity be db)
withTableModification :: Beamable tbl => tbl (FieldModification f) -> tbl f -> tbl f
class (BeamBackend be, Monad m) => MonadBeam be (m :: Type -> Type) | m -> be where
- runReturningMany :: FromBackendRow be x => BeamSqlBackendSyntax be -> (m (Maybe x) -> m a) -> m a
- runNoReturn :: BeamSqlBackendSyntax be -> m ()
- runReturningOne :: FromBackendRow be x => BeamSqlBackendSyntax be -> m (Maybe x)
- runReturningList :: FromBackendRow be x => BeamSqlBackendSyntax be -> m [x]
class BeamBackend be => FromBackendRow be a where
- fromBackendRow :: FromBackendRowM be a
- valuesNeeded :: Proxy be -> Proxy a -> Int
data Nullable (c :: Type -> Type) x
data QBaseScope
type QExprTable be s (tbl :: (Type -> Type) -> Type) = QGenExprTable QValueContext be s tbl
type QGenExprTable ctxt be s (tbl :: (Type -> Type) -> Type) = tbl (QGenExpr ctxt be s)
data SqlDelete be (table :: (Type -> Type) -> Type) = SqlDelete !(TableSettings table) !(BeamSqlBackendDeleteSyntax be)
data SqlInsert be (table :: (Type -> Type) -> Type)
- = SqlInsert !(TableSettings table) !(BeamSqlBackendInsertSyntax be)
- | SqlInsertNoRows
data SqlInsertValues be proj
- = SqlInsertValues (BeamSqlBackendInsertValuesSyntax be)
- | SqlInsertValuesEmpty
newtype SqlSelect be a = SqlSelect (BeamSqlBackendSelectSyntax be)
data SqlUpdate be (table :: (Type -> Type) -> Type)
- = SqlUpdate !(TableSettings table) !(BeamSqlBackendUpdateSyntax be)
- | SqlIdentityUpdate
class QGroupable expr grouped | expr -> grouped, grouped -> expr where
- group_ :: expr -> grouped
data ReusableQ be (db :: (Type -> Type) -> Type) res
data With be (db :: (Type -> Type) -> Type) a
type family HaskellLiteralForQExpr x = (a :: Type)
data QIfCond context be s a
data QIfElse context be s a
class BeamSqlBackend be => SqlDeconstructMaybe be a nonNullA s | a s -> be, a -> nonNullA, a -> s, nonNullA -> s where
- isJust_ :: a -> QGenExpr ctxt be s Bool
- isNothing_ :: a -> QGenExpr ctxt be s Bool
- maybe_ :: QGenExpr ctxt be s y -> (nonNullA -> QGenExpr ctxt be s y) -> a -> QGenExpr ctxt be s y
class SqlJustable a b | b -> a where
- just_ :: a -> b
- nothing_ :: b
class SqlOrderable be a | a -> be
(<-.) :: SqlUpdatable be s lhs rhs => lhs -> rhs -> QAssignment be s
class SqlValable a where
- val_ :: HaskellLiteralForQExpr a -> a
type SqlValableTable be (table :: (Type -> Type) -> Type) = (Beamable table, FieldsFulfillConstraint (HasSqlValueSyntax (BeamSqlBackendValueSyntax be)) table)
class IsCustomExprFn fn res | res -> fn where
- customExpr_ :: fn -> res
class (Monoid (CustomSqlSyntax syntax), Semigroup (CustomSqlSyntax syntax), IsString (CustomSqlSyntax syntax)) => IsCustomSqlSyntax syntax where
- data CustomSqlSyntax syntax :: Type
- customExprSyntax :: CustomSqlSyntax syntax -> syntax
- renderSyntax :: syntax -> CustomSqlSyntax syntax
newtype DataType be a = DataType (BeamSqlBackendCastTargetSyntax be)
newtype ExtractField be tgt a = ExtractField (Sql92ExtractFieldSyntax (BeamSqlBackendSyntax be))
class HasSqlDate tgt
class HasSqlTime tgt
type Projectible be = ProjectibleWithPredicate AnyType be (WithExprContext (BeamSqlBackendExpressionSyntax' be))
data Q be (db :: (Type -> Type) -> Type) s a
data QAggregateContext
data QAssignment be s
type QExpr = QGenExpr QValueContext
data QField s ty
data QFieldAssignment be (tbl :: (Type -> Type) -> Type) a
newtype QGenExpr context be s t = QExpr (TablePrefix -> BeamSqlBackendExpressionSyntax be)
data QGroupingContext
data QValueContext
data QWindow be s
data QWindowFrameContext
data QWindowingContext
data SqlBool
class BeamSqlBackend be => HasSqlEqualityCheck be a where
- sqlEqE :: Proxy a -> Proxy be -> BeamSqlBackendExpressionSyntax be -> BeamSqlBackendExpressionSyntax be -> BeamSqlBackendExpressionSyntax be
- sqlNeqE :: Proxy a -> Proxy be -> BeamSqlBackendExpressionSyntax be -> BeamSqlBackendExpressionSyntax be -> BeamSqlBackendExpressionSyntax be
- sqlEqTriE :: Proxy a -> Proxy be -> BeamSqlBackendExpressionSyntax be -> BeamSqlBackendExpressionSyntax be -> BeamSqlBackendExpressionSyntax be
- sqlNeqTriE :: Proxy a -> Proxy be -> BeamSqlBackendExpressionSyntax be -> BeamSqlBackendExpressionSyntax be -> BeamSqlBackendExpressionSyntax be
class HasSqlEqualityCheck be a => HasSqlQuantifiedEqualityCheck be a where
- sqlQEqE :: Proxy a -> Proxy be -> Maybe (BeamSqlBackendExpressionQuantifierSyntax be) -> BeamSqlBackendExpressionSyntax be -> BeamSqlBackendExpressionSyntax be -> BeamSqlBackendExpressionSyntax be
- sqlQNeqE :: Proxy a -> Proxy be -> Maybe (BeamSqlBackendExpressionQuantifierSyntax be) -> BeamSqlBackendExpressionSyntax be -> BeamSqlBackendExpressionSyntax be -> BeamSqlBackendExpressionSyntax be
data QQuantified be s r
class SqlEq (expr :: Type -> Type) a | a -> expr where
- (==.) :: a -> a -> expr Bool
- (/=.) :: a -> a -> expr Bool
- (==?.) :: a -> a -> expr SqlBool
- (/=?.) :: a -> a -> expr SqlBool
class SqlEq expr a => SqlEqQuantified (expr :: Type -> Type) quantified a | a -> expr quantified where
- (==*.) :: a -> quantified -> expr SqlBool
- (/=*.) :: a -> quantified -> expr SqlBool
class SqlOrd (expr :: Type -> Type) e | e -> expr where
- (<.) :: e -> e -> expr Bool
- (>.) :: e -> e -> expr Bool
- (<=.) :: e -> e -> expr Bool
- (>=.) :: e -> e -> expr Bool
class SqlOrd expr e => SqlOrdQuantified (expr :: Type -> Type) quantified e | e -> expr quantified where
- (<*.) :: e -> quantified -> expr Bool
- (>*.) :: e -> quantified -> expr Bool
- (<=*.) :: e -> quantified -> expr Bool
- (>=*.) :: e -> quantified -> expr Bool
type ManyToMany be (db :: (Type -> Type) -> Type) (left :: (Type -> Type) -> Type) (right :: (Type -> Type) -> Type) = forall s. (BeamSqlBackend be, SqlEq (QExpr be s) (PrimaryKey left (QExpr be s)), SqlEq (QExpr be s) (PrimaryKey right (QExpr be s))) => Q be db s (left (QExpr be s)) -> Q be db s (right (QExpr be s)) -> Q be db s (left (QExpr be s), right (QExpr be s))
type ManyToManyThrough be (db :: (Type -> Type) -> Type) (through :: (Type -> Type) -> Type) (left :: (Type -> Type) -> Type) (right :: (Type -> Type) -> Type) = forall s. (BeamSqlBackend be, SqlEq (QExpr be s) (PrimaryKey left (QExpr be s)), SqlEq (QExpr be s) (PrimaryKey right (QExpr be s))) => Q be db s (left (QExpr be s)) -> Q be db s (right (QExpr be s)) -> Q be db s (through (QExpr be s), left (QExpr be s), right (QExpr be s))
type OneToMany be (db :: (Type -> Type) -> Type) s (one :: (Type -> Type) -> Type) (many :: (Type -> Type) -> Type) = BeamSqlBackend be -> BeamSqlBackendCanSerialize be Bool -> one (QExpr be s) -> Q be db s (many (QExpr be s))
type OneToManyOptional be (db :: (Type -> Type) -> Type) s (tbl :: (Type -> Type) -> Type) (rel :: (Type -> Type) -> Type) = BeamSqlBackend be -> BeamSqlBackendCanSerialize be Bool -> BeamSqlBackendCanSerialize be SqlNull -> tbl (QExpr be s) -> Q be db s (rel (Nullable (QExpr be s)))
type OneToMaybe be (db :: (Type -> Type) -> Type) s (tbl :: (Type -> Type) -> Type) (rel :: (Type -> Type) -> Type) = OneToManyOptional be db s tbl rel
type OneToOne be (db :: (Type -> Type) -> Type) s (one :: (Type -> Type) -> Type) (many :: (Type -> Type) -> Type) = OneToMany be db s one many
class BeamSqlBackend be => HasQBuilder be where
- buildSqlQuery :: Projectible be a => TablePrefix -> Q be db s a -> BeamSqlBackendSelectSyntax be
type family QExprToField x :: Type
type family QExprToIdentity x :: Type
newtype TableLens (f :: k -> Type) (db :: (k -> Type) -> Type) (x :: k) :: forall k. (k -> Type) -> ((k -> Type) -> Type) -> k -> Type = TableLens (Lens' (db f) (f x))
class Beamable (table :: (Type -> Type) -> Type)
type C (f :: Type -> Type) a = Columnar f a
type family Columnar (f :: Type -> Type) x :: Type where ...
data Columnar' (f :: Type -> Type) a
class Database be (db :: (Type -> Type) -> Type)
data DatabaseEntity be (db :: (Type -> Type) -> Type) entityType
type DatabaseModification (f :: Type -> Type) be (db :: (Type -> Type) -> Type) = db (EntityModification f be)
type DatabaseSettings be (db :: (Type -> Type) -> Type) = db (DatabaseEntity be db)
data EntityModification (f :: Type -> Type) be e
data FieldModification (f :: Type -> Type) a
type HaskellTable (table :: (Type -> Type) -> Type) = table Identity
data LensFor t x where
- LensFor :: forall t x. Generic t => Lens' t x -> LensFor t x
data Lenses (t :: (Type -> Type) -> Type) (f :: Type -> Type) x
class (Typeable table, Beamable table, Beamable (PrimaryKey table)) => Table (table :: (Type -> Type) -> Type) where
- data PrimaryKey (table :: (Type -> Type) -> Type) (column :: Type -> Type) :: Type
- primaryKey :: table column -> PrimaryKey table column
data TableEntity (tbl :: (Type -> Type) -> Type)
data TableField (table :: (Type -> Type) -> Type) ty
type TableSettings (table :: (Type -> Type) -> Type) = table (TableField table)
data TxOpt
- = NoTx
- | WithTx
data QueryResult a
- = QSimply a
- | QError SqlError
data ExecResult a
- = ESimply a
- | EConstraint SqlError ConstraintViolation
- | EError SqlError
runSelectReturningList :: (ReadOnlyM m, FromBackendRow Postgres a) => Sel a -> m [a]
runSelectReturningOne :: (ReadOnlyM m, FromBackendRow Postgres a) => Sel a -> m (Maybe a)
query :: ListContains n ReadOnlyPool xs => TxOpt -> RoPg a -> TsActionCtxT lts xs sessdata (QueryResult a)
queryMaybe :: (ListContains n ReadOnlyPool xs, FromBackendRow Postgres a) => Sel a -> TsActionCtxT lts xs sessdata (QueryResult (Maybe a))
queryList :: (ListContains n ReadOnlyPool xs, FromBackendRow Postgres a) => Sel a -> TsActionCtxT lts xs sessdata (QueryResult [a])
execute :: ListContains n ReadWritePool xs => TxOpt -> Pg a -> TsActionCtxT lts xs sessdata (ExecResult a)

Documentation

class Typeable (a :: k) #

The class Typeable allows a concrete representation of a type to be calculated.

Minimal complete definition

typeRep#

class Generic a #

Representable types of kind *. This class is derivable in GHC with the DeriveGeneric flag on.

A Generic instance must satisfy the following laws:

from . to ≡ id
to . from ≡ id

Minimal complete definition

from, to

Instances

Generic Bool
Instance details Defined in GHC.Generics Associated Types type Rep Bool :: Type -> Type # Methods from :: Bool -> Rep Bool x # to :: Rep Bool x -> Bool #
Generic Ordering
Instance details Defined in GHC.Generics Associated Types type Rep Ordering :: Type -> Type # Methods from :: Ordering -> Rep Ordering x # to :: Rep Ordering x -> Ordering #
Generic Exp
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Exp :: Type -> Type # Methods from :: Exp -> Rep Exp x # to :: Rep Exp x -> Exp #
Generic Match
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Match :: Type -> Type # Methods from :: Match -> Rep Match x # to :: Rep Match x -> Match #
Generic Clause
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Clause :: Type -> Type # Methods from :: Clause -> Rep Clause x # to :: Rep Clause x -> Clause #
Generic Pat
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Pat :: Type -> Type # Methods from :: Pat -> Rep Pat x # to :: Rep Pat x -> Pat #
Generic Type
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Type :: Type -> Type # Methods from :: Type -> Rep Type x # to :: Rep Type x -> Type #
Generic Dec
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Dec :: Type -> Type # Methods from :: Dec -> Rep Dec x # to :: Rep Dec x -> Dec #
Generic Name
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Name :: Type -> Type # Methods from :: Name -> Rep Name x # to :: Rep Name x -> Name #
Generic FunDep
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep FunDep :: Type -> Type # Methods from :: FunDep -> Rep FunDep x # to :: Rep FunDep x -> FunDep #
Generic InjectivityAnn
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep InjectivityAnn :: Type -> Type # Methods from :: InjectivityAnn -> Rep InjectivityAnn x # to :: Rep InjectivityAnn x -> InjectivityAnn #
Generic Overlap
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Overlap :: Type -> Type # Methods from :: Overlap -> Rep Overlap x # to :: Rep Overlap x -> Overlap #
Generic ()
Instance details Defined in GHC.Generics Associated Types type Rep () :: Type -> Type # Methods from :: () -> Rep () x # to :: Rep () x -> () #
Generic Void
Instance details Defined in Data.Void Associated Types type Rep Void :: Type -> Type # Methods from :: Void -> Rep Void x # to :: Rep Void x -> Void #
Generic Version
Instance details Defined in Data.Version Associated Types type Rep Version :: Type -> Type # Methods from :: Version -> Rep Version x # to :: Rep Version x -> Version #
Generic ExitCode
Instance details Defined in GHC.IO.Exception Associated Types type Rep ExitCode :: Type -> Type # Methods from :: ExitCode -> Rep ExitCode x # to :: Rep ExitCode x -> ExitCode #
Generic All
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep All :: Type -> Type # Methods from :: All -> Rep All x # to :: Rep All x -> All #
Generic Any
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep Any :: Type -> Type # Methods from :: Any -> Rep Any x # to :: Rep Any x -> Any #
Generic Fixity
Instance details Defined in GHC.Generics Associated Types type Rep Fixity :: Type -> Type # Methods from :: Fixity -> Rep Fixity x # to :: Rep Fixity x -> Fixity #
Generic Associativity
Instance details Defined in GHC.Generics Associated Types type Rep Associativity :: Type -> Type # Methods from :: Associativity -> Rep Associativity x # to :: Rep Associativity x -> Associativity #
Generic SourceUnpackedness
Instance details Defined in GHC.Generics Associated Types type Rep SourceUnpackedness :: Type -> Type # Methods from :: SourceUnpackedness -> Rep SourceUnpackedness x # to :: Rep SourceUnpackedness x -> SourceUnpackedness #
Generic SourceStrictness
Instance details Defined in GHC.Generics Associated Types type Rep SourceStrictness :: Type -> Type # Methods from :: SourceStrictness -> Rep SourceStrictness x # to :: Rep SourceStrictness x -> SourceStrictness #
Generic DecidedStrictness
Instance details Defined in GHC.Generics Associated Types type Rep DecidedStrictness :: Type -> Type # Methods from :: DecidedStrictness -> Rep DecidedStrictness x # to :: Rep DecidedStrictness x -> DecidedStrictness #
Generic Extension
Instance details Defined in GHC.LanguageExtensions.Type Associated Types type Rep Extension :: Type -> Type # Methods from :: Extension -> Rep Extension x # to :: Rep Extension x -> Extension #
Generic ForeignSrcLang
Instance details Defined in GHC.ForeignSrcLang.Type Associated Types type Rep ForeignSrcLang :: Type -> Type # Methods from :: ForeignSrcLang -> Rep ForeignSrcLang x # to :: Rep ForeignSrcLang x -> ForeignSrcLang #
Generic Doc
Instance details Defined in Text.PrettyPrint.HughesPJ Associated Types type Rep Doc :: Type -> Type # Methods from :: Doc -> Rep Doc x # to :: Rep Doc x -> Doc #
Generic TextDetails
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Associated Types type Rep TextDetails :: Type -> Type # Methods from :: TextDetails -> Rep TextDetails x # to :: Rep TextDetails x -> TextDetails #
Generic Style
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Associated Types type Rep Style :: Type -> Type # Methods from :: Style -> Rep Style x # to :: Rep Style x -> Style #
Generic Mode
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Associated Types type Rep Mode :: Type -> Type # Methods from :: Mode -> Rep Mode x # to :: Rep Mode x -> Mode #
Generic ModName
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep ModName :: Type -> Type # Methods from :: ModName -> Rep ModName x # to :: Rep ModName x -> ModName #
Generic PkgName
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep PkgName :: Type -> Type # Methods from :: PkgName -> Rep PkgName x # to :: Rep PkgName x -> PkgName #
Generic Module
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Module :: Type -> Type # Methods from :: Module -> Rep Module x # to :: Rep Module x -> Module #
Generic OccName
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep OccName :: Type -> Type # Methods from :: OccName -> Rep OccName x # to :: Rep OccName x -> OccName #
Generic NameFlavour
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep NameFlavour :: Type -> Type # Methods from :: NameFlavour -> Rep NameFlavour x # to :: Rep NameFlavour x -> NameFlavour #
Generic NameSpace
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep NameSpace :: Type -> Type # Methods from :: NameSpace -> Rep NameSpace x # to :: Rep NameSpace x -> NameSpace #
Generic Loc
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Loc :: Type -> Type # Methods from :: Loc -> Rep Loc x # to :: Rep Loc x -> Loc #
Generic Info
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Info :: Type -> Type # Methods from :: Info -> Rep Info x # to :: Rep Info x -> Info #
Generic ModuleInfo
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep ModuleInfo :: Type -> Type # Methods from :: ModuleInfo -> Rep ModuleInfo x # to :: Rep ModuleInfo x -> ModuleInfo #
Generic Fixity
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Fixity :: Type -> Type # Methods from :: Fixity -> Rep Fixity x # to :: Rep Fixity x -> Fixity #
Generic FixityDirection
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep FixityDirection :: Type -> Type # Methods from :: FixityDirection -> Rep FixityDirection x # to :: Rep FixityDirection x -> FixityDirection #
Generic Lit
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Lit :: Type -> Type # Methods from :: Lit -> Rep Lit x # to :: Rep Lit x -> Lit #
Generic Body
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Body :: Type -> Type # Methods from :: Body -> Rep Body x # to :: Rep Body x -> Body #
Generic Guard
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Guard :: Type -> Type # Methods from :: Guard -> Rep Guard x # to :: Rep Guard x -> Guard #
Generic Stmt
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Stmt :: Type -> Type # Methods from :: Stmt -> Rep Stmt x # to :: Rep Stmt x -> Stmt #
Generic Range
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Range :: Type -> Type # Methods from :: Range -> Rep Range x # to :: Rep Range x -> Range #
Generic DerivClause
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep DerivClause :: Type -> Type # Methods from :: DerivClause -> Rep DerivClause x # to :: Rep DerivClause x -> DerivClause #
Generic DerivStrategy
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep DerivStrategy :: Type -> Type # Methods from :: DerivStrategy -> Rep DerivStrategy x # to :: Rep DerivStrategy x -> DerivStrategy #
Generic TypeFamilyHead
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep TypeFamilyHead :: Type -> Type # Methods from :: TypeFamilyHead -> Rep TypeFamilyHead x # to :: Rep TypeFamilyHead x -> TypeFamilyHead #
Generic TySynEqn
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep TySynEqn :: Type -> Type # Methods from :: TySynEqn -> Rep TySynEqn x # to :: Rep TySynEqn x -> TySynEqn #
Generic Foreign
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Foreign :: Type -> Type # Methods from :: Foreign -> Rep Foreign x # to :: Rep Foreign x -> Foreign #
Generic Callconv
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Callconv :: Type -> Type # Methods from :: Callconv -> Rep Callconv x # to :: Rep Callconv x -> Callconv #
Generic Safety
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Safety :: Type -> Type # Methods from :: Safety -> Rep Safety x # to :: Rep Safety x -> Safety #
Generic Pragma
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Pragma :: Type -> Type # Methods from :: Pragma -> Rep Pragma x # to :: Rep Pragma x -> Pragma #
Generic Inline
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Inline :: Type -> Type # Methods from :: Inline -> Rep Inline x # to :: Rep Inline x -> Inline #
Generic RuleMatch
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep RuleMatch :: Type -> Type # Methods from :: RuleMatch -> Rep RuleMatch x # to :: Rep RuleMatch x -> RuleMatch #
Generic Phases
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Phases :: Type -> Type # Methods from :: Phases -> Rep Phases x # to :: Rep Phases x -> Phases #
Generic RuleBndr
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep RuleBndr :: Type -> Type # Methods from :: RuleBndr -> Rep RuleBndr x # to :: Rep RuleBndr x -> RuleBndr #
Generic AnnTarget
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep AnnTarget :: Type -> Type # Methods from :: AnnTarget -> Rep AnnTarget x # to :: Rep AnnTarget x -> AnnTarget #
Generic SourceUnpackedness
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep SourceUnpackedness :: Type -> Type # Methods from :: SourceUnpackedness -> Rep SourceUnpackedness x # to :: Rep SourceUnpackedness x -> SourceUnpackedness #
Generic SourceStrictness
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep SourceStrictness :: Type -> Type # Methods from :: SourceStrictness -> Rep SourceStrictness x # to :: Rep SourceStrictness x -> SourceStrictness #
Generic DecidedStrictness
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep DecidedStrictness :: Type -> Type # Methods from :: DecidedStrictness -> Rep DecidedStrictness x # to :: Rep DecidedStrictness x -> DecidedStrictness #
Generic Con
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Con :: Type -> Type # Methods from :: Con -> Rep Con x # to :: Rep Con x -> Con #
Generic Bang
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Bang :: Type -> Type # Methods from :: Bang -> Rep Bang x # to :: Rep Bang x -> Bang #
Generic PatSynDir
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep PatSynDir :: Type -> Type # Methods from :: PatSynDir -> Rep PatSynDir x # to :: Rep PatSynDir x -> PatSynDir #
Generic PatSynArgs
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep PatSynArgs :: Type -> Type # Methods from :: PatSynArgs -> Rep PatSynArgs x # to :: Rep PatSynArgs x -> PatSynArgs #
Generic TyVarBndr
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep TyVarBndr :: Type -> Type # Methods from :: TyVarBndr -> Rep TyVarBndr x # to :: Rep TyVarBndr x -> TyVarBndr #
Generic FamilyResultSig
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep FamilyResultSig :: Type -> Type # Methods from :: FamilyResultSig -> Rep FamilyResultSig x # to :: Rep FamilyResultSig x -> FamilyResultSig #
Generic TyLit
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep TyLit :: Type -> Type # Methods from :: TyLit -> Rep TyLit x # to :: Rep TyLit x -> TyLit #
Generic Role
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Role :: Type -> Type # Methods from :: Role -> Rep Role x # to :: Rep Role x -> Role #
Generic AnnLookup
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep AnnLookup :: Type -> Type # Methods from :: AnnLookup -> Rep AnnLookup x # to :: Rep AnnLookup x -> AnnLookup #
Generic Value
Instance details Defined in Data.Aeson.Types.Internal Associated Types type Rep Value :: Type -> Type # Methods from :: Value -> Rep Value x # to :: Rep Value x -> Value #
Generic MultiHeader
Instance details Defined in Web.Spock.Internal.Wire Associated Types type Rep MultiHeader :: Type -> Type # Methods from :: MultiHeader -> Rep MultiHeader x # to :: Rep MultiHeader x -> MultiHeader #
Generic SpockMethod
Instance details Defined in Web.Spock.Internal.Wire Associated Types type Rep SpockMethod :: Type -> Type # Methods from :: SpockMethod -> Rep SpockMethod x # to :: Rep SpockMethod x -> SpockMethod #
Generic HttpMethod
Instance details Defined in Web.Spock.Internal.Wire Associated Types type Rep HttpMethod :: Type -> Type # Methods from :: HttpMethod -> Rep HttpMethod x # to :: Rep HttpMethod x -> HttpMethod #
Generic IP
Instance details Defined in Data.IP.Addr Associated Types type Rep IP :: Type -> Type # Methods from :: IP -> Rep IP x # to :: Rep IP x -> IP #
Generic IPv4
Instance details Defined in Data.IP.Addr Associated Types type Rep IPv4 :: Type -> Type # Methods from :: IPv4 -> Rep IPv4 x # to :: Rep IPv4 x -> IPv4 #
Generic IPv6
Instance details Defined in Data.IP.Addr Associated Types type Rep IPv6 :: Type -> Type # Methods from :: IPv6 -> Rep IPv6 x # to :: Rep IPv6 x -> IPv6 #
Generic IPRange
Instance details Defined in Data.IP.Range Associated Types type Rep IPRange :: Type -> Type # Methods from :: IPRange -> Rep IPRange x # to :: Rep IPRange x -> IPRange #
Generic PgBoundType
Instance details Defined in Database.Beam.Postgres.PgSpecific Associated Types type Rep PgBoundType :: Type -> Type # Methods from :: PgBoundType -> Rep PgBoundType x # to :: Rep PgBoundType x -> PgBoundType #
Generic ConnectInfo
Instance details Defined in Database.PostgreSQL.Simple.Internal Associated Types type Rep ConnectInfo :: Type -> Type # Methods from :: ConnectInfo -> Rep ConnectInfo x # to :: Rep ConnectInfo x -> ConnectInfo #
Generic TableExistsPredicate
Instance details Defined in Database.Beam.Migrate.Checks Associated Types type Rep TableExistsPredicate :: Type -> Type # Methods from :: TableExistsPredicate -> Rep TableExistsPredicate x # to :: Rep TableExistsPredicate x -> TableExistsPredicate #
Generic PgDataTypeDescr
Instance details Defined in Database.Beam.Postgres.Syntax Associated Types type Rep PgDataTypeDescr :: Type -> Type # Methods from :: PgDataTypeDescr -> Rep PgDataTypeDescr x # to :: Rep PgDataTypeDescr x -> PgDataTypeDescr #
Generic HsDataType
Instance details Defined in Database.Beam.Haskell.Syntax Associated Types type Rep HsDataType :: Type -> Type # Methods from :: HsDataType -> Rep HsDataType x # to :: Rep HsDataType x -> HsDataType #
Generic HsConstraintDefinition
Instance details Defined in Database.Beam.Haskell.Syntax Associated Types type Rep HsConstraintDefinition :: Type -> Type # Methods from :: HsConstraintDefinition -> Rep HsConstraintDefinition x # to :: Rep HsConstraintDefinition x -> HsConstraintDefinition #
Generic HsExpr
Instance details Defined in Database.Beam.Haskell.Syntax Associated Types type Rep HsExpr :: Type -> Type # Methods from :: HsExpr -> Rep HsExpr x # to :: Rep HsExpr x -> HsExpr #
Generic HsImport
Instance details Defined in Database.Beam.Haskell.Syntax Associated Types type Rep HsImport :: Type -> Type # Methods from :: HsImport -> Rep HsImport x # to :: Rep HsImport x -> HsImport #
Generic HsNone
Instance details Defined in Database.Beam.Haskell.Syntax Associated Types type Rep HsNone :: Type -> Type # Methods from :: HsNone -> Rep HsNone x # to :: Rep HsNone x -> HsNone #
Generic HsType
Instance details Defined in Database.Beam.Haskell.Syntax Associated Types type Rep HsType :: Type -> Type # Methods from :: HsType -> Rep HsType x # to :: Rep HsType x -> HsType #
Generic Boxed
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep Boxed :: Type -> Type # Methods from :: Boxed -> Rep Boxed x # to :: Rep Boxed x -> Boxed #
Generic SrcSpanInfo
Instance details Defined in Language.Haskell.Exts.SrcLoc Associated Types type Rep SrcSpanInfo :: Type -> Type # Methods from :: SrcSpanInfo -> Rep SrcSpanInfo x # to :: Rep SrcSpanInfo x -> SrcSpanInfo #
Generic SrcLoc
Instance details Defined in Language.Haskell.Exts.SrcLoc Associated Types type Rep SrcLoc :: Type -> Type # Methods from :: SrcLoc -> Rep SrcLoc x # to :: Rep SrcLoc x -> SrcLoc #
Generic SrcSpan
Instance details Defined in Language.Haskell.Exts.SrcLoc Associated Types type Rep SrcSpan :: Type -> Type # Methods from :: SrcSpan -> Rep SrcSpan x # to :: Rep SrcSpan x -> SrcSpan #
Generic DatabaseStateSource
Instance details Defined in Database.Beam.Migrate.Actions Associated Types type Rep DatabaseStateSource :: Type -> Type # Methods from :: DatabaseStateSource -> Rep DatabaseStateSource x # to :: Rep DatabaseStateSource x -> DatabaseStateSource #
Generic TableHasPrimaryKey
Instance details Defined in Database.Beam.Migrate.Checks Associated Types type Rep TableHasPrimaryKey :: Type -> Type # Methods from :: TableHasPrimaryKey -> Rep TableHasPrimaryKey x # to :: Rep TableHasPrimaryKey x -> TableHasPrimaryKey #
Generic PredicateSpecificity
Instance details Defined in Database.Beam.Migrate.Types.Predicates Associated Types type Rep PredicateSpecificity :: Type -> Type # Methods from :: PredicateSpecificity -> Rep PredicateSpecificity x # to :: Rep PredicateSpecificity x -> PredicateSpecificity #
Generic PgHasEnum
Instance details Defined in Database.Beam.Postgres.Syntax Associated Types type Rep PgHasEnum :: Type -> Type # Methods from :: PgHasEnum -> Rep PgHasEnum x # to :: Rep PgHasEnum x -> PgHasEnum #
Generic PgHasExtension
Instance details Defined in Database.Beam.Postgres.Extensions Associated Types type Rep PgHasExtension :: Type -> Type # Methods from :: PgHasExtension -> Rep PgHasExtension x # to :: Rep PgHasExtension x -> PgHasExtension #
Generic PgSelectLockingOptions
Instance details Defined in Database.Beam.Postgres.Syntax Associated Types type Rep PgSelectLockingOptions :: Type -> Type # Methods from :: PgSelectLockingOptions -> Rep PgSelectLockingOptions x # to :: Rep PgSelectLockingOptions x -> PgSelectLockingOptions #
Generic PgSelectLockingStrength
Instance details Defined in Database.Beam.Postgres.Syntax Associated Types type Rep PgSelectLockingStrength :: Type -> Type # Methods from :: PgSelectLockingStrength -> Rep PgSelectLockingStrength x # to :: Rep PgSelectLockingStrength x -> PgSelectLockingStrength #
Generic PgNullOrdering
Instance details Defined in Database.Beam.Postgres.Syntax Associated Types type Rep PgNullOrdering :: Type -> Type # Methods from :: PgNullOrdering -> Rep PgNullOrdering x # to :: Rep PgNullOrdering x -> PgNullOrdering #
Generic Tool
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep Tool :: Type -> Type # Methods from :: Tool -> Rep Tool x # to :: Rep Tool x -> Tool #
Generic URI
Instance details Defined in Network.URI Associated Types type Rep URI :: Type -> Type # Methods from :: URI -> Rep URI x # to :: Rep URI x -> URI #
Generic [a]
Instance details Defined in GHC.Generics Associated Types type Rep [a] :: Type -> Type # Methods from :: [a] -> Rep [a] x # to :: Rep [a] x -> [a] #
Generic (Maybe a)
Instance details Defined in GHC.Generics Associated Types type Rep (Maybe a) :: Type -> Type # Methods from :: Maybe a -> Rep (Maybe a) x # to :: Rep (Maybe a) x -> Maybe a #
Generic (Par1 p)
Instance details Defined in GHC.Generics Associated Types type Rep (Par1 p) :: Type -> Type # Methods from :: Par1 p -> Rep (Par1 p) x # to :: Rep (Par1 p) x -> Par1 p #
Generic (Complex a)
Instance details Defined in Data.Complex Associated Types type Rep (Complex a) :: Type -> Type # Methods from :: Complex a -> Rep (Complex a) x # to :: Rep (Complex a) x -> Complex a #
Generic (Min a)
Instance details Defined in Data.Semigroup Associated Types type Rep (Min a) :: Type -> Type # Methods from :: Min a -> Rep (Min a) x # to :: Rep (Min a) x -> Min a #
Generic (Max a)
Instance details Defined in Data.Semigroup Associated Types type Rep (Max a) :: Type -> Type # Methods from :: Max a -> Rep (Max a) x # to :: Rep (Max a) x -> Max a #
Generic (First a)
Instance details Defined in Data.Semigroup Associated Types type Rep (First a) :: Type -> Type # Methods from :: First a -> Rep (First a) x # to :: Rep (First a) x -> First a #
Generic (Last a)
Instance details Defined in Data.Semigroup Associated Types type Rep (Last a) :: Type -> Type # Methods from :: Last a -> Rep (Last a) x # to :: Rep (Last a) x -> Last a #
Generic (WrappedMonoid m)
Instance details Defined in Data.Semigroup Associated Types type Rep (WrappedMonoid m) :: Type -> Type # Methods from :: WrappedMonoid m -> Rep (WrappedMonoid m) x # to :: Rep (WrappedMonoid m) x -> WrappedMonoid m #
Generic (Option a)
Instance details Defined in Data.Semigroup Associated Types type Rep (Option a) :: Type -> Type # Methods from :: Option a -> Rep (Option a) x # to :: Rep (Option a) x -> Option a #
Generic (ZipList a)
Instance details Defined in Control.Applicative Associated Types type Rep (ZipList a) :: Type -> Type # Methods from :: ZipList a -> Rep (ZipList a) x # to :: Rep (ZipList a) x -> ZipList a #
Generic (Identity a)
Instance details Defined in Data.Functor.Identity Associated Types type Rep (Identity a) :: Type -> Type # Methods from :: Identity a -> Rep (Identity a) x # to :: Rep (Identity a) x -> Identity a #
Generic (First a)
Instance details Defined in Data.Monoid Associated Types type Rep (First a) :: Type -> Type # Methods from :: First a -> Rep (First a) x # to :: Rep (First a) x -> First a #
Generic (Last a)
Instance details Defined in Data.Monoid Associated Types type Rep (Last a) :: Type -> Type # Methods from :: Last a -> Rep (Last a) x # to :: Rep (Last a) x -> Last a #
Generic (Dual a)
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep (Dual a) :: Type -> Type # Methods from :: Dual a -> Rep (Dual a) x # to :: Rep (Dual a) x -> Dual a #
Generic (Endo a)
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep (Endo a) :: Type -> Type # Methods from :: Endo a -> Rep (Endo a) x # to :: Rep (Endo a) x -> Endo a #
Generic (Sum a)
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep (Sum a) :: Type -> Type # Methods from :: Sum a -> Rep (Sum a) x # to :: Rep (Sum a) x -> Sum a #
Generic (Product a)
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep (Product a) :: Type -> Type # Methods from :: Product a -> Rep (Product a) x # to :: Rep (Product a) x -> Product a #
Generic (Down a)
Instance details Defined in GHC.Generics Associated Types type Rep (Down a) :: Type -> Type # Methods from :: Down a -> Rep (Down a) x # to :: Rep (Down a) x -> Down a #
Generic (NonEmpty a)
Instance details Defined in GHC.Generics Associated Types type Rep (NonEmpty a) :: Type -> Type # Methods from :: NonEmpty a -> Rep (NonEmpty a) x # to :: Rep (NonEmpty a) x -> NonEmpty a #
Generic (Tree a)
Instance details Defined in Data.Tree Associated Types type Rep (Tree a) :: Type -> Type # Methods from :: Tree a -> Rep (Tree a) x # to :: Rep (Tree a) x -> Tree a #
Generic (FingerTree a)
Instance details Defined in Data.Sequence.Internal Associated Types type Rep (FingerTree a) :: Type -> Type # Methods from :: FingerTree a -> Rep (FingerTree a) x # to :: Rep (FingerTree a) x -> FingerTree a #
Generic (Digit a)
Instance details Defined in Data.Sequence.Internal Associated Types type Rep (Digit a) :: Type -> Type # Methods from :: Digit a -> Rep (Digit a) x # to :: Rep (Digit a) x -> Digit a #
Generic (Node a)
Instance details Defined in Data.Sequence.Internal Associated Types type Rep (Node a) :: Type -> Type # Methods from :: Node a -> Rep (Node a) x # to :: Rep (Node a) x -> Node a #
Generic (Elem a)
Instance details Defined in Data.Sequence.Internal Associated Types type Rep (Elem a) :: Type -> Type # Methods from :: Elem a -> Rep (Elem a) x # to :: Rep (Elem a) x -> Elem a #
Generic (ViewL a)
Instance details Defined in Data.Sequence.Internal Associated Types type Rep (ViewL a) :: Type -> Type # Methods from :: ViewL a -> Rep (ViewL a) x # to :: Rep (ViewL a) x -> ViewL a #
Generic (ViewR a)
Instance details Defined in Data.Sequence.Internal Associated Types type Rep (ViewR a) :: Type -> Type # Methods from :: ViewR a -> Rep (ViewR a) x # to :: Rep (ViewR a) x -> ViewR a #
Generic (Doc a)
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Associated Types type Rep (Doc a) :: Type -> Type # Methods from :: Doc a -> Rep (Doc a) x # to :: Rep (Doc a) x -> Doc a #
Generic (Finite n)
Instance details Defined in Data.Finite.Internal Associated Types type Rep (Finite n) :: Type -> Type # Methods from :: Finite n -> Rep (Finite n) x # to :: Rep (Finite n) x -> Finite n #
Generic (Only a)
Instance details Defined in Data.Tuple.Only Associated Types type Rep (Only a) :: Type -> Type # Methods from :: Only a -> Rep (Only a) x # to :: Rep (Only a) x -> Only a #
Generic (AddrRange a)
Instance details Defined in Data.IP.Range Associated Types type Rep (AddrRange a) :: Type -> Type # Methods from :: AddrRange a -> Rep (AddrRange a) x # to :: Rep (AddrRange a) x -> AddrRange a #
Generic (PgJSONKey f)
Instance details Defined in Database.Beam.Postgres.PgSpecific Associated Types type Rep (PgJSONKey f) :: Type -> Type # Methods from :: PgJSONKey f -> Rep (PgJSONKey f) x # to :: Rep (PgJSONKey f) x -> PgJSONKey f #
Generic (PgRangeBound a)
Instance details Defined in Database.Beam.Postgres.PgSpecific Associated Types type Rep (PgRangeBound a) :: Type -> Type # Methods from :: PgRangeBound a -> Rep (PgRangeBound a) x # to :: Rep (PgRangeBound a) x -> PgRangeBound a #
Generic (TableColumnHasConstraint be)
Instance details Defined in Database.Beam.Migrate.Checks Associated Types type Rep (TableColumnHasConstraint be) :: Type -> Type # Methods from :: TableColumnHasConstraint be -> Rep (TableColumnHasConstraint be) x # to :: Rep (TableColumnHasConstraint be) x -> TableColumnHasConstraint be #
Generic (Exp l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Exp l) :: Type -> Type # Methods from :: Exp l -> Rep (Exp l) x # to :: Rep (Exp l) x -> Exp l #
Generic (Type l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Type l) :: Type -> Type # Methods from :: Type l -> Rep (Type l) x # to :: Rep (Type l) x -> Type l #
Generic (Asst l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Asst l) :: Type -> Type # Methods from :: Asst l -> Rep (Asst l) x # to :: Rep (Asst l) x -> Asst l #
Generic (ModuleName l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (ModuleName l) :: Type -> Type # Methods from :: ModuleName l -> Rep (ModuleName l) x # to :: Rep (ModuleName l) x -> ModuleName l #
Generic (Name l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Name l) :: Type -> Type # Methods from :: Name l -> Rep (Name l) x # to :: Rep (Name l) x -> Name l #
Generic (ImportSpec l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (ImportSpec l) :: Type -> Type # Methods from :: ImportSpec l -> Rep (ImportSpec l) x # to :: Rep (ImportSpec l) x -> ImportSpec l #
Generic (Activation l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Activation l) :: Type -> Type # Methods from :: Activation l -> Rep (Activation l) x # to :: Rep (Activation l) x -> Activation l #
Generic (Alt l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Alt l) :: Type -> Type # Methods from :: Alt l -> Rep (Alt l) x # to :: Rep (Alt l) x -> Alt l #
Generic (Annotation l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Annotation l) :: Type -> Type # Methods from :: Annotation l -> Rep (Annotation l) x # to :: Rep (Annotation l) x -> Annotation l #
Generic (Assoc l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Assoc l) :: Type -> Type # Methods from :: Assoc l -> Rep (Assoc l) x # to :: Rep (Assoc l) x -> Assoc l #
Generic (BangType l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (BangType l) :: Type -> Type # Methods from :: BangType l -> Rep (BangType l) x # to :: Rep (BangType l) x -> BangType l #
Generic (Binds l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Binds l) :: Type -> Type # Methods from :: Binds l -> Rep (Binds l) x # to :: Rep (Binds l) x -> Binds l #
Generic (BooleanFormula l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (BooleanFormula l) :: Type -> Type # Methods from :: BooleanFormula l -> Rep (BooleanFormula l) x # to :: Rep (BooleanFormula l) x -> BooleanFormula l #
Generic (Bracket l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Bracket l) :: Type -> Type # Methods from :: Bracket l -> Rep (Bracket l) x # to :: Rep (Bracket l) x -> Bracket l #
Generic (CName l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (CName l) :: Type -> Type # Methods from :: CName l -> Rep (CName l) x # to :: Rep (CName l) x -> CName l #
Generic (CallConv l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (CallConv l) :: Type -> Type # Methods from :: CallConv l -> Rep (CallConv l) x # to :: Rep (CallConv l) x -> CallConv l #
Generic (ClassDecl l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (ClassDecl l) :: Type -> Type # Methods from :: ClassDecl l -> Rep (ClassDecl l) x # to :: Rep (ClassDecl l) x -> ClassDecl l #
Generic (ConDecl l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (ConDecl l) :: Type -> Type # Methods from :: ConDecl l -> Rep (ConDecl l) x # to :: Rep (ConDecl l) x -> ConDecl l #
Generic (Context l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Context l) :: Type -> Type # Methods from :: Context l -> Rep (Context l) x # to :: Rep (Context l) x -> Context l #
Generic (DataOrNew l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (DataOrNew l) :: Type -> Type # Methods from :: DataOrNew l -> Rep (DataOrNew l) x # to :: Rep (DataOrNew l) x -> DataOrNew l #
Generic (Decl l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Decl l) :: Type -> Type # Methods from :: Decl l -> Rep (Decl l) x # to :: Rep (Decl l) x -> Decl l #
Generic (DeclHead l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (DeclHead l) :: Type -> Type # Methods from :: DeclHead l -> Rep (DeclHead l) x # to :: Rep (DeclHead l) x -> DeclHead l #
Generic (DerivStrategy l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (DerivStrategy l) :: Type -> Type # Methods from :: DerivStrategy l -> Rep (DerivStrategy l) x # to :: Rep (DerivStrategy l) x -> DerivStrategy l #
Generic (Deriving l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Deriving l) :: Type -> Type # Methods from :: Deriving l -> Rep (Deriving l) x # to :: Rep (Deriving l) x -> Deriving l #
Generic (FieldDecl l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (FieldDecl l) :: Type -> Type # Methods from :: FieldDecl l -> Rep (FieldDecl l) x # to :: Rep (FieldDecl l) x -> FieldDecl l #
Generic (FieldUpdate l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (FieldUpdate l) :: Type -> Type # Methods from :: FieldUpdate l -> Rep (FieldUpdate l) x # to :: Rep (FieldUpdate l) x -> FieldUpdate l #
Generic (FunDep l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (FunDep l) :: Type -> Type # Methods from :: FunDep l -> Rep (FunDep l) x # to :: Rep (FunDep l) x -> FunDep l #
Generic (GadtDecl l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (GadtDecl l) :: Type -> Type # Methods from :: GadtDecl l -> Rep (GadtDecl l) x # to :: Rep (GadtDecl l) x -> GadtDecl l #
Generic (GuardedRhs l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (GuardedRhs l) :: Type -> Type # Methods from :: GuardedRhs l -> Rep (GuardedRhs l) x # to :: Rep (GuardedRhs l) x -> GuardedRhs l #
Generic (Stmt l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Stmt l) :: Type -> Type # Methods from :: Stmt l -> Rep (Stmt l) x # to :: Rep (Stmt l) x -> Stmt l #
Generic (IPBind l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (IPBind l) :: Type -> Type # Methods from :: IPBind l -> Rep (IPBind l) x # to :: Rep (IPBind l) x -> IPBind l #
Generic (IPName l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (IPName l) :: Type -> Type # Methods from :: IPName l -> Rep (IPName l) x # to :: Rep (IPName l) x -> IPName l #
Generic (InjectivityInfo l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (InjectivityInfo l) :: Type -> Type # Methods from :: InjectivityInfo l -> Rep (InjectivityInfo l) x # to :: Rep (InjectivityInfo l) x -> InjectivityInfo l #
Generic (InstDecl l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (InstDecl l) :: Type -> Type # Methods from :: InstDecl l -> Rep (InstDecl l) x # to :: Rep (InstDecl l) x -> InstDecl l #
Generic (InstHead l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (InstHead l) :: Type -> Type # Methods from :: InstHead l -> Rep (InstHead l) x # to :: Rep (InstHead l) x -> InstHead l #
Generic (InstRule l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (InstRule l) :: Type -> Type # Methods from :: InstRule l -> Rep (InstRule l) x # to :: Rep (InstRule l) x -> InstRule l #
Generic (Literal l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Literal l) :: Type -> Type # Methods from :: Literal l -> Rep (Literal l) x # to :: Rep (Literal l) x -> Literal l #
Generic (Match l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Match l) :: Type -> Type # Methods from :: Match l -> Rep (Match l) x # to :: Rep (Match l) x -> Match l #
Generic (MaybePromotedName l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (MaybePromotedName l) :: Type -> Type # Methods from :: MaybePromotedName l -> Rep (MaybePromotedName l) x # to :: Rep (MaybePromotedName l) x -> MaybePromotedName l #
Generic (Namespace l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Namespace l) :: Type -> Type # Methods from :: Namespace l -> Rep (Namespace l) x # to :: Rep (Namespace l) x -> Namespace l #
Generic (Op l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Op l) :: Type -> Type # Methods from :: Op l -> Rep (Op l) x # to :: Rep (Op l) x -> Op l #
Generic (Overlap l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Overlap l) :: Type -> Type # Methods from :: Overlap l -> Rep (Overlap l) x # to :: Rep (Overlap l) x -> Overlap l #
Generic (PXAttr l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (PXAttr l) :: Type -> Type # Methods from :: PXAttr l -> Rep (PXAttr l) x # to :: Rep (PXAttr l) x -> PXAttr l #
Generic (Pat l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Pat l) :: Type -> Type # Methods from :: Pat l -> Rep (Pat l) x # to :: Rep (Pat l) x -> Pat l #
Generic (PatField l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (PatField l) :: Type -> Type # Methods from :: PatField l -> Rep (PatField l) x # to :: Rep (PatField l) x -> PatField l #
Generic (PatternSynDirection l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (PatternSynDirection l) :: Type -> Type # Methods from :: PatternSynDirection l -> Rep (PatternSynDirection l) x # to :: Rep (PatternSynDirection l) x -> PatternSynDirection l #
Generic (Promoted l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Promoted l) :: Type -> Type # Methods from :: Promoted l -> Rep (Promoted l) x # to :: Rep (Promoted l) x -> Promoted l #
Generic (QName l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (QName l) :: Type -> Type # Methods from :: QName l -> Rep (QName l) x # to :: Rep (QName l) x -> QName l #
Generic (QOp l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (QOp l) :: Type -> Type # Methods from :: QOp l -> Rep (QOp l) x # to :: Rep (QOp l) x -> QOp l #
Generic (QualConDecl l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (QualConDecl l) :: Type -> Type # Methods from :: QualConDecl l -> Rep (QualConDecl l) x # to :: Rep (QualConDecl l) x -> QualConDecl l #
Generic (QualStmt l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (QualStmt l) :: Type -> Type # Methods from :: QualStmt l -> Rep (QualStmt l) x # to :: Rep (QualStmt l) x -> QualStmt l #
Generic (RPat l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (RPat l) :: Type -> Type # Methods from :: RPat l -> Rep (RPat l) x # to :: Rep (RPat l) x -> RPat l #
Generic (RPatOp l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (RPatOp l) :: Type -> Type # Methods from :: RPatOp l -> Rep (RPatOp l) x # to :: Rep (RPatOp l) x -> RPatOp l #
Generic (ResultSig l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (ResultSig l) :: Type -> Type # Methods from :: ResultSig l -> Rep (ResultSig l) x # to :: Rep (ResultSig l) x -> ResultSig l #
Generic (Rhs l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Rhs l) :: Type -> Type # Methods from :: Rhs l -> Rep (Rhs l) x # to :: Rep (Rhs l) x -> Rhs l #
Generic (Role l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Role l) :: Type -> Type # Methods from :: Role l -> Rep (Role l) x # to :: Rep (Role l) x -> Role l #
Generic (Rule l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Rule l) :: Type -> Type # Methods from :: Rule l -> Rep (Rule l) x # to :: Rep (Rule l) x -> Rule l #
Generic (RuleVar l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (RuleVar l) :: Type -> Type # Methods from :: RuleVar l -> Rep (RuleVar l) x # to :: Rep (RuleVar l) x -> RuleVar l #
Generic (Safety l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Safety l) :: Type -> Type # Methods from :: Safety l -> Rep (Safety l) x # to :: Rep (Safety l) x -> Safety l #
Generic (Sign l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Sign l) :: Type -> Type # Methods from :: Sign l -> Rep (Sign l) x # to :: Rep (Sign l) x -> Sign l #
Generic (SpecialCon l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (SpecialCon l) :: Type -> Type # Methods from :: SpecialCon l -> Rep (SpecialCon l) x # to :: Rep (SpecialCon l) x -> SpecialCon l #
Generic (Splice l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Splice l) :: Type -> Type # Methods from :: Splice l -> Rep (Splice l) x # to :: Rep (Splice l) x -> Splice l #
Generic (TyVarBind l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (TyVarBind l) :: Type -> Type # Methods from :: TyVarBind l -> Rep (TyVarBind l) x # to :: Rep (TyVarBind l) x -> TyVarBind l #
Generic (TypeEqn l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (TypeEqn l) :: Type -> Type # Methods from :: TypeEqn l -> Rep (TypeEqn l) x # to :: Rep (TypeEqn l) x -> TypeEqn l #
Generic (Unpackedness l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Unpackedness l) :: Type -> Type # Methods from :: Unpackedness l -> Rep (Unpackedness l) x # to :: Rep (Unpackedness l) x -> Unpackedness l #
Generic (XAttr l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (XAttr l) :: Type -> Type # Methods from :: XAttr l -> Rep (XAttr l) x # to :: Rep (XAttr l) x -> XAttr l #
Generic (XName l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (XName l) :: Type -> Type # Methods from :: XName l -> Rep (XName l) x # to :: Rep (XName l) x -> XName l #
Generic (ExportSpec l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (ExportSpec l) :: Type -> Type # Methods from :: ExportSpec l -> Rep (ExportSpec l) x # to :: Rep (ExportSpec l) x -> ExportSpec l #
Generic (ModulePragma l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (ModulePragma l) :: Type -> Type # Methods from :: ModulePragma l -> Rep (ModulePragma l) x # to :: Rep (ModulePragma l) x -> ModulePragma l #
Generic (ModuleHead l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (ModuleHead l) :: Type -> Type # Methods from :: ModuleHead l -> Rep (ModuleHead l) x # to :: Rep (ModuleHead l) x -> ModuleHead l #
Generic (ImportDecl l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (ImportDecl l) :: Type -> Type # Methods from :: ImportDecl l -> Rep (ImportDecl l) x # to :: Rep (ImportDecl l) x -> ImportDecl l #
Generic (Module l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Module l) :: Type -> Type # Methods from :: Module l -> Rep (Module l) x # to :: Rep (Module l) x -> Module l #
Generic (MeasuredDatabaseState be)
Instance details Defined in Database.Beam.Migrate.Actions Associated Types type Rep (MeasuredDatabaseState be) :: Type -> Type # Methods from :: MeasuredDatabaseState be -> Rep (MeasuredDatabaseState be) x # to :: Rep (MeasuredDatabaseState be) x -> MeasuredDatabaseState be #
Generic (Loc a)
Instance details Defined in Language.Haskell.Exts.SrcLoc Associated Types type Rep (Loc a) :: Type -> Type # Methods from :: Loc a -> Rep (Loc a) x # to :: Rep (Loc a) x -> Loc a #
Generic (EWildcard l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (EWildcard l) :: Type -> Type # Methods from :: EWildcard l -> Rep (EWildcard l) x # to :: Rep (EWildcard l) x -> EWildcard l #
Generic (ExportSpecList l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (ExportSpecList l) :: Type -> Type # Methods from :: ExportSpecList l -> Rep (ExportSpecList l) x # to :: Rep (ExportSpecList l) x -> ExportSpecList l #
Generic (ImportSpecList l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (ImportSpecList l) :: Type -> Type # Methods from :: ImportSpecList l -> Rep (ImportSpecList l) x # to :: Rep (ImportSpecList l) x -> ImportSpecList l #
Generic (WarningText l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (WarningText l) :: Type -> Type # Methods from :: WarningText l -> Rep (WarningText l) x # to :: Rep (WarningText l) x -> WarningText l #
Generic (Db f) Source #
Instance details Defined in TsWeb.Tables.Session.Test Associated Types type Rep (Db f) :: Type -> Type # Methods from :: Db f -> Rep (Db f) x # to :: Rep (Db f) x -> Db f #
Generic (UsersMixin f) Source #
Instance details Defined in TsWeb.Tables.Session.Test Associated Types type Rep (UsersMixin f) :: Type -> Type # Methods from :: UsersMixin f -> Rep (UsersMixin f) x # to :: Rep (UsersMixin f) x -> UsersMixin f #
Generic (Either a b)
Instance details Defined in GHC.Generics Associated Types type Rep (Either a b) :: Type -> Type # Methods from :: Either a b -> Rep (Either a b) x # to :: Rep (Either a b) x -> Either a b #
Generic (V1 p)
Instance details Defined in GHC.Generics Associated Types type Rep (V1 p) :: Type -> Type # Methods from :: V1 p -> Rep (V1 p) x # to :: Rep (V1 p) x -> V1 p #
Generic (U1 p)
Instance details Defined in GHC.Generics Associated Types type Rep (U1 p) :: Type -> Type # Methods from :: U1 p -> Rep (U1 p) x # to :: Rep (U1 p) x -> U1 p #
Generic (a, b)
Instance details Defined in GHC.Generics Associated Types type Rep (a, b) :: Type -> Type # Methods from :: (a, b) -> Rep (a, b) x # to :: Rep (a, b) x -> (a, b) #
Generic (Arg a b)
Instance details Defined in Data.Semigroup Associated Types type Rep (Arg a b) :: Type -> Type # Methods from :: Arg a b -> Rep (Arg a b) x # to :: Rep (Arg a b) x -> Arg a b #
Generic (WrappedMonad m a)
Instance details Defined in Control.Applicative Associated Types type Rep (WrappedMonad m a) :: Type -> Type # Methods from :: WrappedMonad m a -> Rep (WrappedMonad m a) x # to :: Rep (WrappedMonad m a) x -> WrappedMonad m a #
Generic (Proxy t)
Instance details Defined in GHC.Generics Associated Types type Rep (Proxy t) :: Type -> Type # Methods from :: Proxy t -> Rep (Proxy t) x # to :: Rep (Proxy t) x -> Proxy t #
Generic (PrimaryKey (SessionT d) f) Source #
Instance details Defined in TsWeb.Tables.Session Associated Types type Rep (PrimaryKey (SessionT d) f) :: Type -> Type # Methods from :: PrimaryKey (SessionT d) f -> Rep (PrimaryKey (SessionT d) f) x # to :: Rep (PrimaryKey (SessionT d) f) x -> PrimaryKey (SessionT d) f #
Generic (SessionT d f) Source #
Instance details Defined in TsWeb.Tables.Session Associated Types type Rep (SessionT d f) :: Type -> Type # Methods from :: SessionT d f -> Rep (SessionT d f) x # to :: Rep (SessionT d f) x -> SessionT d f #
Generic (Cofree f a)
Instance details Defined in Control.Comonad.Cofree Associated Types type Rep (Cofree f a) :: Type -> Type # Methods from :: Cofree f a -> Rep (Cofree f a) x # to :: Rep (Cofree f a) x -> Cofree f a #
Generic (Free f a)
Instance details Defined in Control.Monad.Free Associated Types type Rep (Free f a) :: Type -> Type # Methods from :: Free f a -> Rep (Free f a) x # to :: Rep (Free f a) x -> Free f a #
Generic (PgJSONEach valType f)
Instance details Defined in Database.Beam.Postgres.PgSpecific Associated Types type Rep (PgJSONEach valType f) :: Type -> Type # Methods from :: PgJSONEach valType f -> Rep (PgJSONEach valType f) x # to :: Rep (PgJSONEach valType f) x -> PgJSONEach valType f #
Generic (PgJSONElement a f)
Instance details Defined in Database.Beam.Postgres.PgSpecific Associated Types type Rep (PgJSONElement a f) :: Type -> Type # Methods from :: PgJSONElement a f -> Rep (PgJSONElement a f) x # to :: Rep (PgJSONElement a f) x -> PgJSONElement a f #
Generic (PgRange n a)
Instance details Defined in Database.Beam.Postgres.PgSpecific Associated Types type Rep (PgRange n a) :: Type -> Type # Methods from :: PgRange n a -> Rep (PgRange n a) x # to :: Rep (PgRange n a) x -> PgRange n a #
Generic (PgUnnestArrayTbl a f)
Instance details Defined in Database.Beam.Postgres.PgSpecific Associated Types type Rep (PgUnnestArrayTbl a f) :: Type -> Type # Methods from :: PgUnnestArrayTbl a f -> Rep (PgUnnestArrayTbl a f) x # to :: Rep (PgUnnestArrayTbl a f) x -> PgUnnestArrayTbl a f #
Generic (PgUnnestArrayWithOrdinalityTbl a f)
Instance details Defined in Database.Beam.Postgres.PgSpecific Associated Types type Rep (PgUnnestArrayWithOrdinalityTbl a f) :: Type -> Type # Methods from :: PgUnnestArrayWithOrdinalityTbl a f -> Rep (PgUnnestArrayWithOrdinalityTbl a f) x # to :: Rep (PgUnnestArrayWithOrdinalityTbl a f) x -> PgUnnestArrayWithOrdinalityTbl a f #
Generic (Rec1 f p)
Instance details Defined in GHC.Generics Associated Types type Rep (Rec1 f p) :: Type -> Type # Methods from :: Rec1 f p -> Rep (Rec1 f p) x # to :: Rep (Rec1 f p) x -> Rec1 f p #
Generic (URec (Ptr ()) p)
Instance details Defined in GHC.Generics Associated Types type Rep (URec (Ptr ()) p) :: Type -> Type # Methods from :: URec (Ptr ()) p -> Rep (URec (Ptr ()) p) x # to :: Rep (URec (Ptr ()) p) x -> URec (Ptr ()) p #
Generic (URec Char p)
Instance details Defined in GHC.Generics Associated Types type Rep (URec Char p) :: Type -> Type # Methods from :: URec Char p -> Rep (URec Char p) x # to :: Rep (URec Char p) x -> URec Char p #
Generic (URec Double p)
Instance details Defined in GHC.Generics Associated Types type Rep (URec Double p) :: Type -> Type # Methods from :: URec Double p -> Rep (URec Double p) x # to :: Rep (URec Double p) x -> URec Double p #
Generic (URec Float p)
Instance details Defined in GHC.Generics Associated Types type Rep (URec Float p) :: Type -> Type # Methods from :: URec Float p -> Rep (URec Float p) x # to :: Rep (URec Float p) x -> URec Float p #
Generic (URec Int p)
Instance details Defined in GHC.Generics Associated Types type Rep (URec Int p) :: Type -> Type # Methods from :: URec Int p -> Rep (URec Int p) x # to :: Rep (URec Int p) x -> URec Int p #
Generic (URec Word p)
Instance details Defined in GHC.Generics Associated Types type Rep (URec Word p) :: Type -> Type # Methods from :: URec Word p -> Rep (URec Word p) x # to :: Rep (URec Word p) x -> URec Word p #
Generic (a, b, c)
Instance details Defined in GHC.Generics Associated Types type Rep (a, b, c) :: Type -> Type # Methods from :: (a, b, c) -> Rep (a, b, c) x # to :: Rep (a, b, c) x -> (a, b, c) #
Generic (WrappedArrow a b c)
Instance details Defined in Control.Applicative Associated Types type Rep (WrappedArrow a b c) :: Type -> Type # Methods from :: WrappedArrow a b c -> Rep (WrappedArrow a b c) x # to :: Rep (WrappedArrow a b c) x -> WrappedArrow a b c #
Generic (Const a b)
Instance details Defined in Data.Functor.Const Associated Types type Rep (Const a b) :: Type -> Type # Methods from :: Const a b -> Rep (Const a b) x # to :: Rep (Const a b) x -> Const a b #
Generic (Ap f a)
Instance details Defined in Data.Monoid Associated Types type Rep (Ap f a) :: Type -> Type # Methods from :: Ap f a -> Rep (Ap f a) x # to :: Rep (Ap f a) x -> Ap f a #
Generic (Alt f a)
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep (Alt f a) :: Type -> Type # Methods from :: Alt f a -> Rep (Alt f a) x # to :: Rep (Alt f a) x -> Alt f a #
Generic (Tagged s b)
Instance details Defined in Data.Tagged Associated Types type Rep (Tagged s b) :: Type -> Type # Methods from :: Tagged s b -> Rep (Tagged s b) x # to :: Rep (Tagged s b) x -> Tagged s b #
Generic (Vector v n a)
Instance details Defined in Data.Vector.Generic.Sized.Internal Associated Types type Rep (Vector v n a) :: Type -> Type # Methods from :: Vector v n a -> Rep (Vector v n a) x # to :: Rep (Vector v n a) x -> Vector v n a #
Generic (Join p a)
Instance details Defined in Data.Bifunctor.Join Associated Types type Rep (Join p a) :: Type -> Type # Methods from :: Join p a -> Rep (Join p a) x # to :: Rep (Join p a) x -> Join p a #
Generic (FreeF f a b)
Instance details Defined in Control.Monad.Trans.Free Associated Types type Rep (FreeF f a b) :: Type -> Type # Methods from :: FreeF f a b -> Rep (FreeF f a b) x # to :: Rep (FreeF f a b) x -> FreeF f a b #
Generic (K1 i c p)
Instance details Defined in GHC.Generics Associated Types type Rep (K1 i c p) :: Type -> Type # Methods from :: K1 i c p -> Rep (K1 i c p) x # to :: Rep (K1 i c p) x -> K1 i c p #
Generic ((f :+: g) p)
Instance details Defined in GHC.Generics Associated Types type Rep ((f :+: g) p) :: Type -> Type # Methods from :: (f :+: g) p -> Rep ((f :+: g) p) x # to :: Rep ((f :+: g) p) x -> (f :+: g) p #
Generic ((f :*: g) p)
Instance details Defined in GHC.Generics Associated Types type Rep ((f :: g) p) :: Type -> Type # Methods from :: (f :: g) p -> Rep ((f :: g) p) x # to :: Rep ((f :: g) p) x -> (f :*: g) p #
Generic (a, b, c, d)
Instance details Defined in GHC.Generics Associated Types type Rep (a, b, c, d) :: Type -> Type # Methods from :: (a, b, c, d) -> Rep (a, b, c, d) x # to :: Rep (a, b, c, d) x -> (a, b, c, d) #
Generic (Product f g a)
Instance details Defined in Data.Functor.Product Associated Types type Rep (Product f g a) :: Type -> Type # Methods from :: Product f g a -> Rep (Product f g a) x # to :: Rep (Product f g a) x -> Product f g a #
Generic (Sum f g a)
Instance details Defined in Data.Functor.Sum Associated Types type Rep (Sum f g a) :: Type -> Type # Methods from :: Sum f g a -> Rep (Sum f g a) x # to :: Rep (Sum f g a) x -> Sum f g a #
Generic (MVector v n s a)
Instance details Defined in Data.Vector.Generic.Mutable.Sized.Internal Associated Types type Rep (MVector v n s a) :: Type -> Type # Methods from :: MVector v n s a -> Rep (MVector v n s a) x # to :: Rep (MVector v n s a) x -> MVector v n s a #
Generic (M1 i c f p)
Instance details Defined in GHC.Generics Associated Types type Rep (M1 i c f p) :: Type -> Type # Methods from :: M1 i c f p -> Rep (M1 i c f p) x # to :: Rep (M1 i c f p) x -> M1 i c f p #
Generic ((f :.: g) p)
Instance details Defined in GHC.Generics Associated Types type Rep ((f :.: g) p) :: Type -> Type # Methods from :: (f :.: g) p -> Rep ((f :.: g) p) x # to :: Rep ((f :.: g) p) x -> (f :.: g) p #
Generic (a, b, c, d, e)
Instance details Defined in GHC.Generics Associated Types type Rep (a, b, c, d, e) :: Type -> Type # Methods from :: (a, b, c, d, e) -> Rep (a, b, c, d, e) x # to :: Rep (a, b, c, d, e) x -> (a, b, c, d, e) #
Generic (Compose f g a)
Instance details Defined in Data.Functor.Compose Associated Types type Rep (Compose f g a) :: Type -> Type # Methods from :: Compose f g a -> Rep (Compose f g a) x # to :: Rep (Compose f g a) x -> Compose f g a #
Generic (Clown f a b)
Instance details Defined in Data.Bifunctor.Clown Associated Types type Rep (Clown f a b) :: Type -> Type # Methods from :: Clown f a b -> Rep (Clown f a b) x # to :: Rep (Clown f a b) x -> Clown f a b #
Generic (Flip p a b)
Instance details Defined in Data.Bifunctor.Flip Associated Types type Rep (Flip p a b) :: Type -> Type # Methods from :: Flip p a b -> Rep (Flip p a b) x # to :: Rep (Flip p a b) x -> Flip p a b #
Generic (Joker g a b)
Instance details Defined in Data.Bifunctor.Joker Associated Types type Rep (Joker g a b) :: Type -> Type # Methods from :: Joker g a b -> Rep (Joker g a b) x # to :: Rep (Joker g a b) x -> Joker g a b #
Generic (WrappedBifunctor p a b)
Instance details Defined in Data.Bifunctor.Wrapped Associated Types type Rep (WrappedBifunctor p a b) :: Type -> Type # Methods from :: WrappedBifunctor p a b -> Rep (WrappedBifunctor p a b) x # to :: Rep (WrappedBifunctor p a b) x -> WrappedBifunctor p a b #
Generic (a, b, c, d, e, f)
Instance details Defined in GHC.Generics Associated Types type Rep (a, b, c, d, e, f) :: Type -> Type # Methods from :: (a, b, c, d, e, f) -> Rep (a, b, c, d, e, f) x # to :: Rep (a, b, c, d, e, f) x -> (a, b, c, d, e, f) #
Generic (Product f g a b)
Instance details Defined in Data.Bifunctor.Product Associated Types type Rep (Product f g a b) :: Type -> Type # Methods from :: Product f g a b -> Rep (Product f g a b) x # to :: Rep (Product f g a b) x -> Product f g a b #
Generic (Sum p q a b)
Instance details Defined in Data.Bifunctor.Sum Associated Types type Rep (Sum p q a b) :: Type -> Type # Methods from :: Sum p q a b -> Rep (Sum p q a b) x # to :: Rep (Sum p q a b) x -> Sum p q a b #
Generic (a, b, c, d, e, f, g)
Instance details Defined in GHC.Generics Associated Types type Rep (a, b, c, d, e, f, g) :: Type -> Type # Methods from :: (a, b, c, d, e, f, g) -> Rep (a, b, c, d, e, f, g) x # to :: Rep (a, b, c, d, e, f, g) x -> (a, b, c, d, e, f, g) #
Generic (Tannen f p a b)
Instance details Defined in Data.Bifunctor.Tannen Associated Types type Rep (Tannen f p a b) :: Type -> Type # Methods from :: Tannen f p a b -> Rep (Tannen f p a b) x # to :: Rep (Tannen f p a b) x -> Tannen f p a b #
Generic (Biff p f g a b)
Instance details Defined in Data.Bifunctor.Biff Associated Types type Rep (Biff p f g a b) :: Type -> Type # Methods from :: Biff p f g a b -> Rep (Biff p f g a b) x # to :: Rep (Biff p f g a b) x -> Biff p f g a b #

class Monad m => MonadIO (m :: Type -> Type) where #

Monads in which IO computations may be embedded. Any monad built by applying a sequence of monad transformers to the IO monad will be an instance of this class.

Instances should satisfy the following laws, which state that liftIO is a transformer of monads:

```
liftIO . return = return
```

liftIO (m >>= f) = liftIO m >>= (liftIO . f)

Methods

liftIO :: IO a -> m a #

Lift a computation from the IO monad.

Instances

MonadIO IO	Since: base-4.9.0.0
Instance details Defined in Control.Monad.IO.Class Methods liftIO :: IO a -> IO a #
MonadIO Q
Instance details Defined in Language.Haskell.TH.Syntax Methods liftIO :: IO a -> Q a #
MonadIO SqlSyntaxM
Instance details Defined in Database.Beam.Backend.SQL.Builder Methods liftIO :: IO a -> SqlSyntaxM a #
MonadIO Pg
Instance details Defined in Database.Beam.Postgres.Connection Methods liftIO :: IO a -> Pg a #
MonadIO m => MonadIO (ResourceT m)
Instance details Defined in Control.Monad.Trans.Resource.Internal Methods liftIO :: IO a -> ResourceT m a #
MonadIO m => MonadIO (ListT m)
Instance details Defined in ListT Methods liftIO :: IO a -> ListT m a #
(Error e, MonadIO m) => MonadIO (ErrorT e m)
Instance details Defined in Control.Monad.Trans.Error Methods liftIO :: IO a -> ErrorT e m a #
MonadIO m => MonadIO (ReaderT r m)
Instance details Defined in Control.Monad.Trans.Reader Methods liftIO :: IO a -> ReaderT r m a #
MonadIO m => MonadIO (StateT s m)
Instance details Defined in Control.Monad.Trans.State.Strict Methods liftIO :: IO a -> StateT s m a #
(Monoid w, MonadIO m) => MonadIO (WriterT w m)
Instance details Defined in Control.Monad.Trans.Writer.Lazy Methods liftIO :: IO a -> WriterT w m a #
(Functor f, MonadIO m) => MonadIO (FreeT f m)
Instance details Defined in Control.Monad.Trans.Free Methods liftIO :: IO a -> FreeT f m a #
MonadIO m => MonadIO (ActionCtxT ctx m)
Instance details Defined in Web.Spock.Internal.Wire Methods liftIO :: IO a -> ActionCtxT ctx m a #
MonadIO m => MonadIO (SpockCtxT ctx m)
Instance details Defined in Web.Spock.Core Methods liftIO :: IO a -> SpockCtxT ctx m a #
MonadIO m => MonadIO (WebStateT conn sess st m)
Instance details Defined in Web.Spock.Internal.Types Methods liftIO :: IO a -> WebStateT conn sess st m a #

data Identity a #

Identity functor and monad. (a non-strict monad)

Since: base-4.8.0.0

Instances

Monad Identity	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods (>>=) :: Identity a -> (a -> Identity b) -> Identity b # (>>) :: Identity a -> Identity b -> Identity b # return :: a -> Identity a # fail :: String -> Identity a #
Functor Identity	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods fmap :: (a -> b) -> Identity a -> Identity b # (<$) :: a -> Identity b -> Identity a #
MonadFix Identity	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods mfix :: (a -> Identity a) -> Identity a #
Applicative Identity	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods pure :: a -> Identity a # (<>) :: Identity (a -> b) -> Identity a -> Identity b # liftA2 :: (a -> b -> c) -> Identity a -> Identity b -> Identity c # (>) :: Identity a -> Identity b -> Identity b # (<*) :: Identity a -> Identity b -> Identity a #
Foldable Identity	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods fold :: Monoid m => Identity m -> m # foldMap :: Monoid m => (a -> m) -> Identity a -> m # foldr :: (a -> b -> b) -> b -> Identity a -> b # foldr' :: (a -> b -> b) -> b -> Identity a -> b # foldl :: (b -> a -> b) -> b -> Identity a -> b # foldl' :: (b -> a -> b) -> b -> Identity a -> b # foldr1 :: (a -> a -> a) -> Identity a -> a # foldl1 :: (a -> a -> a) -> Identity a -> a # toList :: Identity a -> [a] # null :: Identity a -> Bool # length :: Identity a -> Int # elem :: Eq a => a -> Identity a -> Bool # maximum :: Ord a => Identity a -> a # minimum :: Ord a => Identity a -> a # sum :: Num a => Identity a -> a # product :: Num a => Identity a -> a #
Traversable Identity	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Identity a -> f (Identity b) # sequenceA :: Applicative f => Identity (f a) -> f (Identity a) # mapM :: Monad m => (a -> m b) -> Identity a -> m (Identity b) # sequence :: Monad m => Identity (m a) -> m (Identity a) #
Eq1 Identity	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Classes Methods liftEq :: (a -> b -> Bool) -> Identity a -> Identity b -> Bool #
Ord1 Identity	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Classes Methods liftCompare :: (a -> b -> Ordering) -> Identity a -> Identity b -> Ordering #
Read1 Identity	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Classes Methods liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Identity a) # liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Identity a] # liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Identity a) # liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Identity a] #
Show1 Identity	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Classes Methods liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Identity a -> ShowS # liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Identity a] -> ShowS #
Representable Identity
Instance details Defined in Data.Functor.Rep Associated Types type Rep Identity :: Type Methods tabulate :: (Rep Identity -> a) -> Identity a index :: Identity a -> Rep Identity -> a
UserData Users Source #
Instance details Defined in TsWeb.Tables.Session.Test Methods rememberMe :: Users -> Bool Source #
MonadBaseControl Identity Identity
Instance details Defined in Control.Monad.Trans.Control Associated Types type StM Identity a :: Type Methods liftBaseWith :: (RunInBase Identity Identity -> Identity a) -> Identity a restoreM :: StM Identity a -> Identity a
(BeamBackend be, Generic (tbl Identity), Generic (tbl Exposed), GFromBackendRow be (Rep (tbl Exposed)) (Rep (tbl Identity))) => FromBackendRow be (tbl Identity)
Instance details Defined in Database.Beam.Backend.SQL.Row Methods fromBackendRow :: FromBackendRowM be (tbl Identity) # valuesNeeded :: Proxy be -> Proxy (tbl Identity) -> Int #
(BeamBackend be, Generic (tbl (Nullable Identity)), Generic (tbl (Nullable Exposed)), GFromBackendRow be (Rep (tbl (Nullable Exposed))) (Rep (tbl (Nullable Identity)))) => FromBackendRow be (tbl (Nullable Identity))
Instance details Defined in Database.Beam.Backend.SQL.Row Methods fromBackendRow :: FromBackendRowM be (tbl (Nullable Identity)) # valuesNeeded :: Proxy be -> Proxy (tbl (Nullable Identity)) -> Int #
FromBackendRow be (t Identity) => GFromBackendRow be (K1 R (t Exposed) :: Type -> Type) (K1 R (t Identity) :: Type -> Type)
Instance details Defined in Database.Beam.Backend.SQL.Row Methods gFromBackendRow :: Proxy (K1 R (t Exposed)) -> FromBackendRowM be (K1 R (t Identity) ()) gValuesNeeded :: Proxy be -> Proxy (K1 R (t Exposed)) -> Proxy (K1 R (t Identity)) -> Int
FromBackendRow be (t (Nullable Identity)) => GFromBackendRow be (K1 R (t (Nullable Exposed)) :: Type -> Type) (K1 R (t (Nullable Identity)) :: Type -> Type)
Instance details Defined in Database.Beam.Backend.SQL.Row Methods gFromBackendRow :: Proxy (K1 R (t (Nullable Exposed))) -> FromBackendRowM be (K1 R (t (Nullable Identity)) ()) gValuesNeeded :: Proxy be -> Proxy (K1 R (t (Nullable Exposed))) -> Proxy (K1 R (t (Nullable Identity))) -> Int
FieldsFulfillConstraintNullable c t => GFieldsFulfillConstraint c (K1 R (t (Nullable Exposed)) :: Type -> Type) (K1 R (t (Nullable Identity)) :: Type -> Type) (K1 R (t (Nullable (WithConstraint c))) :: Type -> Type)
Instance details Defined in Database.Beam.Schema.Tables Methods gWithConstrainedFields :: Proxy c -> Proxy (K1 R (t (Nullable Exposed))) -> K1 R (t (Nullable Identity)) () -> K1 R (t (Nullable (WithConstraint c))) ()
FieldsFulfillConstraint c t => GFieldsFulfillConstraint c (K1 R (t Exposed) :: Type -> Type) (K1 R (t Identity) :: Type -> Type) (K1 R (t (WithConstraint c)) :: Type -> Type)
Instance details Defined in Database.Beam.Schema.Tables Methods gWithConstrainedFields :: Proxy c -> Proxy (K1 R (t Exposed)) -> K1 R (t Identity) () -> K1 R (t (WithConstraint c)) ()
Bounded a => Bounded (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods minBound :: Identity a # maxBound :: Identity a #
Enum a => Enum (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods succ :: Identity a -> Identity a # pred :: Identity a -> Identity a # toEnum :: Int -> Identity a # fromEnum :: Identity a -> Int # enumFrom :: Identity a -> [Identity a] # enumFromThen :: Identity a -> Identity a -> [Identity a] # enumFromTo :: Identity a -> Identity a -> [Identity a] # enumFromThenTo :: Identity a -> Identity a -> Identity a -> [Identity a] #
Eq a => Eq (Identity a)	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods (==) :: Identity a -> Identity a -> Bool # (/=) :: Identity a -> Identity a -> Bool #
Floating a => Floating (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods pi :: Identity a # exp :: Identity a -> Identity a # log :: Identity a -> Identity a # sqrt :: Identity a -> Identity a # (**) :: Identity a -> Identity a -> Identity a # logBase :: Identity a -> Identity a -> Identity a # sin :: Identity a -> Identity a # cos :: Identity a -> Identity a # tan :: Identity a -> Identity a # asin :: Identity a -> Identity a # acos :: Identity a -> Identity a # atan :: Identity a -> Identity a # sinh :: Identity a -> Identity a # cosh :: Identity a -> Identity a # tanh :: Identity a -> Identity a # asinh :: Identity a -> Identity a # acosh :: Identity a -> Identity a # atanh :: Identity a -> Identity a # log1p :: Identity a -> Identity a # expm1 :: Identity a -> Identity a # log1pexp :: Identity a -> Identity a # log1mexp :: Identity a -> Identity a #
Fractional a => Fractional (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods (/) :: Identity a -> Identity a -> Identity a # recip :: Identity a -> Identity a # fromRational :: Rational -> Identity a #
Integral a => Integral (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods quot :: Identity a -> Identity a -> Identity a # rem :: Identity a -> Identity a -> Identity a # div :: Identity a -> Identity a -> Identity a # mod :: Identity a -> Identity a -> Identity a # quotRem :: Identity a -> Identity a -> (Identity a, Identity a) # divMod :: Identity a -> Identity a -> (Identity a, Identity a) # toInteger :: Identity a -> Integer #
Num a => Num (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods (+) :: Identity a -> Identity a -> Identity a # (-) :: Identity a -> Identity a -> Identity a # (*) :: Identity a -> Identity a -> Identity a # negate :: Identity a -> Identity a # abs :: Identity a -> Identity a # signum :: Identity a -> Identity a # fromInteger :: Integer -> Identity a #
Ord a => Ord (Identity a)	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods compare :: Identity a -> Identity a -> Ordering # (<) :: Identity a -> Identity a -> Bool # (<=) :: Identity a -> Identity a -> Bool # (>) :: Identity a -> Identity a -> Bool # (>=) :: Identity a -> Identity a -> Bool # max :: Identity a -> Identity a -> Identity a # min :: Identity a -> Identity a -> Identity a #
Read a => Read (Identity a)	This instance would be equivalent to the derived instances of the `Identity` newtype if the `runIdentity` field were removed Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods readsPrec :: Int -> ReadS (Identity a) # readList :: ReadS [Identity a] # readPrec :: ReadPrec (Identity a) # readListPrec :: ReadPrec [Identity a] #
Real a => Real (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods toRational :: Identity a -> Rational #
RealFloat a => RealFloat (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods floatRadix :: Identity a -> Integer # floatDigits :: Identity a -> Int # floatRange :: Identity a -> (Int, Int) # decodeFloat :: Identity a -> (Integer, Int) # encodeFloat :: Integer -> Int -> Identity a # exponent :: Identity a -> Int # significand :: Identity a -> Identity a # scaleFloat :: Int -> Identity a -> Identity a # isNaN :: Identity a -> Bool # isInfinite :: Identity a -> Bool # isDenormalized :: Identity a -> Bool # isNegativeZero :: Identity a -> Bool # isIEEE :: Identity a -> Bool # atan2 :: Identity a -> Identity a -> Identity a #
RealFrac a => RealFrac (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods properFraction :: Integral b => Identity a -> (b, Identity a) # truncate :: Integral b => Identity a -> b # round :: Integral b => Identity a -> b # ceiling :: Integral b => Identity a -> b # floor :: Integral b => Identity a -> b #
Show a => Show (Identity a)	This instance would be equivalent to the derived instances of the `Identity` newtype if the `runIdentity` field were removed Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods showsPrec :: Int -> Identity a -> ShowS # show :: Identity a -> String # showList :: [Identity a] -> ShowS #
Ix a => Ix (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods range :: (Identity a, Identity a) -> [Identity a] # index :: (Identity a, Identity a) -> Identity a -> Int # unsafeIndex :: (Identity a, Identity a) -> Identity a -> Int inRange :: (Identity a, Identity a) -> Identity a -> Bool # rangeSize :: (Identity a, Identity a) -> Int # unsafeRangeSize :: (Identity a, Identity a) -> Int
IsString a => IsString (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.String Methods fromString :: String -> Identity a #
Generic (Identity a)
Instance details Defined in Data.Functor.Identity Associated Types type Rep (Identity a) :: Type -> Type # Methods from :: Identity a -> Rep (Identity a) x # to :: Rep (Identity a) x -> Identity a #
Semigroup a => Semigroup (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods (<>) :: Identity a -> Identity a -> Identity a # sconcat :: NonEmpty (Identity a) -> Identity a # stimes :: Integral b => b -> Identity a -> Identity a #
Monoid a => Monoid (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods mempty :: Identity a # mappend :: Identity a -> Identity a -> Identity a # mconcat :: [Identity a] -> Identity a #
Storable a => Storable (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods sizeOf :: Identity a -> Int # alignment :: Identity a -> Int # peekElemOff :: Ptr (Identity a) -> Int -> IO (Identity a) # pokeElemOff :: Ptr (Identity a) -> Int -> Identity a -> IO () # peekByteOff :: Ptr b -> Int -> IO (Identity a) # pokeByteOff :: Ptr b -> Int -> Identity a -> IO () # peek :: Ptr (Identity a) -> IO (Identity a) # poke :: Ptr (Identity a) -> Identity a -> IO () #
Bits a => Bits (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods (.&.) :: Identity a -> Identity a -> Identity a # (.\|.) :: Identity a -> Identity a -> Identity a # xor :: Identity a -> Identity a -> Identity a # complement :: Identity a -> Identity a # shift :: Identity a -> Int -> Identity a # rotate :: Identity a -> Int -> Identity a # zeroBits :: Identity a # bit :: Int -> Identity a # setBit :: Identity a -> Int -> Identity a # clearBit :: Identity a -> Int -> Identity a # complementBit :: Identity a -> Int -> Identity a # testBit :: Identity a -> Int -> Bool # bitSizeMaybe :: Identity a -> Maybe Int # bitSize :: Identity a -> Int # isSigned :: Identity a -> Bool # shiftL :: Identity a -> Int -> Identity a # unsafeShiftL :: Identity a -> Int -> Identity a # shiftR :: Identity a -> Int -> Identity a # unsafeShiftR :: Identity a -> Int -> Identity a # rotateL :: Identity a -> Int -> Identity a # rotateR :: Identity a -> Int -> Identity a # popCount :: Identity a -> Int #
FiniteBits a => FiniteBits (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods finiteBitSize :: Identity a -> Int # countLeadingZeros :: Identity a -> Int # countTrailingZeros :: Identity a -> Int #
Generic1 Identity
Instance details Defined in Data.Functor.Identity Associated Types type Rep1 Identity :: k -> Type # Methods from1 :: Identity a -> Rep1 Identity a # to1 :: Rep1 Identity a -> Identity a #
Table t => SqlJustable (t Identity) (t (Nullable Identity))
Instance details Defined in Database.Beam.Query.Combinators Methods just_ :: t Identity -> t (Nullable Identity) # nothing_ :: t (Nullable Identity) #
Eq (PrimaryKey (SessionT d) Identity) Source #
Instance details Defined in TsWeb.Tables.Session Methods (==) :: PrimaryKey (SessionT d) Identity -> PrimaryKey (SessionT d) Identity -> Bool # (/=) :: PrimaryKey (SessionT d) Identity -> PrimaryKey (SessionT d) Identity -> Bool #
Eq (d Identity) => Eq (SessionT d Identity) Source #
Instance details Defined in TsWeb.Tables.Session Methods (==) :: SessionT d Identity -> SessionT d Identity -> Bool # (/=) :: SessionT d Identity -> SessionT d Identity -> Bool #
Ord (PrimaryKey (SessionT d) Identity) Source #
Instance details Defined in TsWeb.Tables.Session Methods compare :: PrimaryKey (SessionT d) Identity -> PrimaryKey (SessionT d) Identity -> Ordering # (<) :: PrimaryKey (SessionT d) Identity -> PrimaryKey (SessionT d) Identity -> Bool # (<=) :: PrimaryKey (SessionT d) Identity -> PrimaryKey (SessionT d) Identity -> Bool # (>) :: PrimaryKey (SessionT d) Identity -> PrimaryKey (SessionT d) Identity -> Bool # (>=) :: PrimaryKey (SessionT d) Identity -> PrimaryKey (SessionT d) Identity -> Bool # max :: PrimaryKey (SessionT d) Identity -> PrimaryKey (SessionT d) Identity -> PrimaryKey (SessionT d) Identity # min :: PrimaryKey (SessionT d) Identity -> PrimaryKey (SessionT d) Identity -> PrimaryKey (SessionT d) Identity #
Ord (d Identity) => Ord (SessionT d Identity) Source #
Instance details Defined in TsWeb.Tables.Session Methods compare :: SessionT d Identity -> SessionT d Identity -> Ordering # (<) :: SessionT d Identity -> SessionT d Identity -> Bool # (<=) :: SessionT d Identity -> SessionT d Identity -> Bool # (>) :: SessionT d Identity -> SessionT d Identity -> Bool # (>=) :: SessionT d Identity -> SessionT d Identity -> Bool # max :: SessionT d Identity -> SessionT d Identity -> SessionT d Identity # min :: SessionT d Identity -> SessionT d Identity -> SessionT d Identity #
Show (PrimaryKey (SessionT d) Identity) Source #
Instance details Defined in TsWeb.Tables.Session Methods showsPrec :: Int -> PrimaryKey (SessionT d) Identity -> ShowS # show :: PrimaryKey (SessionT d) Identity -> String # showList :: [PrimaryKey (SessionT d) Identity] -> ShowS #
Show (d Identity) => Show (SessionT d Identity) Source #
Instance details Defined in TsWeb.Tables.Session Methods showsPrec :: Int -> SessionT d Identity -> ShowS # show :: SessionT d Identity -> String # showList :: [SessionT d Identity] -> ShowS #
Table t => SqlJustable (PrimaryKey t Identity) (PrimaryKey t (Nullable Identity))
Instance details Defined in Database.Beam.Query.Combinators Methods just_ :: PrimaryKey t Identity -> PrimaryKey t (Nullable Identity) # nothing_ :: PrimaryKey t (Nullable Identity) #
type Rep Identity
Instance details Defined in Data.Functor.Rep type Rep Identity = ()
type StM Identity a
Instance details Defined in Control.Monad.Trans.Control type StM Identity a = a
type Rep (Identity a)	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity type Rep (Identity a) = D1 (MetaData "Identity" "Data.Functor.Identity" "base" True) (C1 (MetaCons "Identity" PrefixI True) (S1 (MetaSel (Just "runIdentity") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))
type Rep1 Identity	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity type Rep1 Identity = D1 (MetaData "Identity" "Data.Functor.Identity" "base" True) (C1 (MetaCons "Identity" PrefixI True) (S1 (MetaSel (Just "runIdentity") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

delete :: BeamSqlBackend be => DatabaseEntity be db (TableEntity table) -> (forall s. (forall s'. table (QExpr be s')) -> QExpr be s Bool) -> SqlDelete be table #

dumpSqlSelect :: Projectible (MockSqlBackend SqlSyntaxBuilder) res => Q (MockSqlBackend SqlSyntaxBuilder) db QBaseScope res -> IO () #

insert :: (BeamSqlBackend be, ProjectibleWithPredicate AnyType () Text (table (QField s))) => DatabaseEntity be db (TableEntity table) -> SqlInsertValues be (table (QExpr be s)) -> SqlInsert be table #

insertData :: (Projectible be r, BeamSqlBackend be) => [r] -> SqlInsertValues be r #

insertExpressions :: (BeamSqlBackend be, Beamable table) => (forall s'. [table (QExpr be s')]) -> SqlInsertValues be (table (QExpr be s)) #

insertFrom :: (BeamSqlBackend be, HasQBuilder be, Projectible be r) => Q be db QBaseScope r -> SqlInsertValues be r #

insertOnly :: (BeamSqlBackend be, ProjectibleWithPredicate AnyType () Text (QExprToField r)) => DatabaseEntity be db (TableEntity table) -> (table (QField s) -> QExprToField r) -> SqlInsertValues be r -> SqlInsert be table #

insertValues :: (BeamSqlBackend be, Beamable table, FieldsFulfillConstraint (BeamSqlBackendCanSerialize be) table) => [table Identity] -> SqlInsertValues be (table (QExpr be s)) #

lookup_ :: (Database be db, Table table, BeamSqlBackend be, HasQBuilder be, SqlValableTable be (PrimaryKey table), HasTableEquality be (PrimaryKey table)) => DatabaseEntity be db (TableEntity table) -> PrimaryKey table Identity -> SqlSelect be (table Identity) #

runDelete :: (BeamSqlBackend be, MonadBeam be m) => SqlDelete be table -> m () #

runInsert :: (BeamSqlBackend be, MonadBeam be m) => SqlInsert be table -> m () #

runUpdate :: (BeamSqlBackend be, MonadBeam be m) => SqlUpdate be tbl -> m () #

save :: (Table table, BeamSqlBackend be, SqlValableTable be (PrimaryKey table), SqlValableTable be table, HasTableEquality be (PrimaryKey table)) => DatabaseEntity be db (TableEntity table) -> table Identity -> SqlUpdate be table #

select :: (BeamSqlBackend be, HasQBuilder be, Projectible be res) => Q be db QBaseScope res -> SqlSelect be (QExprToIdentity res) #

selectWith :: (BeamSqlBackend be, BeamSql99CommonTableExpressionBackend be, HasQBuilder be, Projectible be res) => With be db (Q be db QBaseScope res) -> SqlSelect be (QExprToIdentity res) #

set :: Beamable table => table (QFieldAssignment be table') #

setFieldsTo :: Table table => (forall s. table (QExpr be s)) -> table (QFieldAssignment be table') #

toNewValue :: (forall s. QExpr be s a) -> QFieldAssignment be table a #

toOldValue :: QFieldAssignment be table a #

toUpdatedValue :: (forall s. table (QExpr be s) -> QExpr be s a) -> QFieldAssignment be table a #

toUpdatedValueMaybe :: (forall s. table (QExpr be s) -> Maybe (QExpr be s a)) -> QFieldAssignment be table a #

update :: (BeamSqlBackend be, Beamable table) => DatabaseEntity be db (TableEntity table) -> (forall s. table (QField s) -> QAssignment be s) -> (forall s. table (QExpr be s) -> QExpr be s Bool) -> SqlUpdate be table #

updateRow :: (BeamSqlBackend be, Table table, HasTableEquality be (PrimaryKey table), SqlValableTable be (PrimaryKey table)) => DatabaseEntity be db (TableEntity table) -> table Identity -> (forall s. table (QField s) -> QAssignment be s) -> SqlUpdate be table #

updateTable :: (BeamSqlBackend be, Beamable table) => DatabaseEntity be db (TableEntity table) -> table (QFieldAssignment be table) -> (forall s. table (QExpr be s) -> QExpr be s Bool) -> SqlUpdate be table #

updateTableRow :: (BeamSqlBackend be, Table table, HasTableEquality be (PrimaryKey table), SqlValableTable be (PrimaryKey table)) => DatabaseEntity be db (TableEntity table) -> table Identity -> table (QFieldAssignment be table) -> SqlUpdate be table #

aggregate_ :: (BeamSqlBackend be, Aggregable be a, Projectible be r, Projectible be a, ContextRewritable a, ThreadRewritable (QNested s) (WithRewrittenContext a QValueContext)) => (r -> a) -> Q be db (QNested s) r -> Q be db s (WithRewrittenThread (QNested s) s (WithRewrittenContext a QValueContext)) #

allInGroupExplicitly_ :: IsSql92AggregationSetQuantifierSyntax s => Maybe s #

allInGroup_ :: IsSql92AggregationSetQuantifierSyntax s => Maybe s #

anyOver_ :: BeamSql99AggregationBackend be => Maybe (BeamSqlBackendAggregationQuantifierSyntax be) -> QExpr be s SqlBool -> QAgg be s SqlBool #

any_ :: BeamSql99AggregationBackend be => QExpr be s SqlBool -> QAgg be s SqlBool #

avgOver_ :: (BeamSqlBackend be, Num a) => Maybe (BeamSqlBackendAggregationQuantifierSyntax be) -> QExpr be s a -> QAgg be s (Maybe a) #

avg_ :: (BeamSqlBackend be, Num a) => QExpr be s a -> QAgg be s (Maybe a) #

countAll_ :: BeamSqlBackend be => QAgg be s Int #

countOver_ :: (BeamSqlBackend be, Integral b) => Maybe (BeamSqlBackendAggregationQuantifierSyntax be) -> QExpr be s a -> QAgg be s b #

count_ :: (BeamSqlBackend be, Integral b) => QExpr be s a -> QAgg be s b #

cumeDist_ :: BeamSqlT612Backend be => QAgg be s Double #

denseRank_ :: BeamSqlT612Backend be => QAgg be s Int #

distinctInGroup_ :: IsSql92AggregationSetQuantifierSyntax s => Maybe s #

everyOver_ :: BeamSql99AggregationBackend be => Maybe (BeamSqlBackendAggregationQuantifierSyntax be) -> QExpr be s SqlBool -> QAgg be s SqlBool #

every_ :: BeamSql99AggregationBackend be => QExpr be s SqlBool -> QAgg be s SqlBool #

filterWhere_ :: BeamSqlT611Backend be => QAgg be s a -> QExpr be s Bool -> QAgg be s a #

filterWhere_' :: BeamSqlT611Backend be => QAgg be s a -> QExpr be s SqlBool -> QAgg be s a #

maxOver_ :: BeamSqlBackend be => Maybe (BeamSqlBackendAggregationQuantifierSyntax be) -> QExpr be s a -> QAgg be s (Maybe a) #

max_ :: BeamSqlBackend be => QExpr be s a -> QAgg be s (Maybe a) #

minOver_ :: BeamSqlBackend be => Maybe (BeamSqlBackendAggregationQuantifierSyntax be) -> QExpr be s a -> QAgg be s (Maybe a) #

min_ :: BeamSqlBackend be => QExpr be s a -> QAgg be s (Maybe a) #

percentRank_ :: BeamSqlT612Backend be => QAgg be s Double #

rank_ :: BeamSqlT611Backend be => QAgg be s Int #

rowNumber_ :: BeamSql2003ExpressionBackend be => QAgg be s Int #

someOver_ :: BeamSql99AggregationBackend be => Maybe (BeamSqlBackendAggregationQuantifierSyntax be) -> QExpr be s SqlBool -> QAgg be s SqlBool #

some_ :: BeamSql99AggregationBackend be => QExpr be s SqlBool -> QAgg be s SqlBool #

sumOver_ :: (BeamSqlBackend be, Num a) => Maybe (BeamSqlBackendAggregationQuantifierSyntax be) -> QExpr be s a -> QAgg be s (Maybe a) #

sum_ :: (BeamSqlBackend be, Num a) => QExpr be s a -> QAgg be s (Maybe a) #

reuse :: ReusableQ be db res -> Q be db s (WithRewrittenThread QAnyScope s res) #

selecting :: (BeamSql99CommonTableExpressionBackend be, HasQBuilder be, Projectible be res, ThreadRewritable QAnyScope res) => Q be db QAnyScope res -> With be db (ReusableQ be db res) #

(<|>.) :: (SqlJustable a (QGenExpr ctxt syntax s y), SqlDeconstructMaybe syntax (QGenExpr ctxt syntax s y) a s) => QGenExpr ctxt syntax s y -> QGenExpr ctxt syntax s y -> QGenExpr ctxt syntax s y #

allFromView_ :: (Database be db, Beamable table, BeamSqlBackend be) => DatabaseEntity be db (ViewEntity table) -> Q be db s (table (QExpr be s)) #

all_ :: (Database be db, BeamSqlBackend be) => DatabaseEntity be db (TableEntity table) -> Q be db s (table (QExpr be s)) #

as_ :: QGenExpr ctxt be s a -> QGenExpr ctxt be s a #

asc_ :: BeamSqlBackend be => QExpr be s a -> QOrd be s a #

bitLength_ :: BeamSqlBackend be => QGenExpr context be s SqlBitString -> QGenExpr context be s Int #

bounds_ :: BeamSql2003ExpressionBackend be => QFrameBound be -> Maybe (QFrameBound be) -> QFrameBounds be #

charLength_ :: (BeamSqlBackend be, BeamSqlBackendIsString be text) => QGenExpr context be s text -> QGenExpr context be s Int #

coalesce_ :: BeamSqlBackend be => [QGenExpr ctxt be s (Maybe a)] -> QGenExpr ctxt be s a -> QGenExpr ctxt be s a #

currentTimestamp_ :: BeamSqlBackend be => QGenExpr ctxt be s LocalTime #

current_ :: BeamSqlBackend be => QField s ty -> QExpr be s ty #

default_ :: BeamSqlBackend be => QGenExpr ctxt be s a #

desc_ :: BeamSqlBackend be => QExpr be s a -> QOrd be s a #

distinct_ :: (BeamSqlBackend be, BeamSql99ExpressionBackend be, HasQBuilder be, Projectible be a) => Q be db s a -> QExpr be s Bool #

else_ :: QGenExpr context be s a -> QIfElse context be s a #

exceptAll_ :: (BeamSqlBackend be, Projectible be a, ThreadRewritable (QNested s) a) => Q be db (QNested s) a -> Q be db (QNested s) a -> Q be db s (WithRewrittenThread (QNested s) s a) #

except_ :: (BeamSqlBackend be, Projectible be a, ThreadRewritable (QNested s) a) => Q be db (QNested s) a -> Q be db (QNested s) a -> Q be db s (WithRewrittenThread (QNested s) s a) #

exists_ :: (BeamSqlBackend be, HasQBuilder be, Projectible be a) => Q be db s a -> QExpr be s Bool #

filter_ :: BeamSqlBackend be => (r -> QExpr be s Bool) -> Q be db s r -> Q be db s r #

filter_' :: BeamSqlBackend be => (r -> QExpr be s SqlBool) -> Q be db s r -> Q be db s r #

frame_ :: (BeamSql2003ExpressionBackend be, SqlOrderable be ordering, Projectible be partition) => Maybe partition -> Maybe ordering -> QFrameBounds be -> QWindow be s #

fromBound_ :: BeamSql2003ExpressionBackend be => QFrameBound be -> QFrameBounds be #

fromMaybe_ :: BeamSqlBackend be => QGenExpr ctxt be s a -> QGenExpr ctxt be s (Maybe a) -> QGenExpr ctxt be s a #

guard_ :: BeamSqlBackend be => QExpr be s Bool -> Q be db s () #

guard_' :: BeamSqlBackend be => QExpr be s SqlBool -> Q be db s () #

if_ :: BeamSqlBackend be => [QIfCond context be s a] -> QIfElse context be s a -> QGenExpr context be s a #

intersectAll_ :: (BeamSqlBackend be, Projectible be a, ThreadRewritable (QNested s) a) => Q be db (QNested s) a -> Q be db (QNested s) a -> Q be db s (WithRewrittenThread (QNested s) s a) #

intersect_ :: (BeamSqlBackend be, Projectible be a, ThreadRewritable (QNested s) a) => Q be db (QNested s) a -> Q be db (QNested s) a -> Q be db s (WithRewrittenThread (QNested s) s a) #

join_ :: (Database be db, Table table, BeamSqlBackend be) => DatabaseEntity be db (TableEntity table) -> (table (QExpr be s) -> QExpr be s Bool) -> Q be db s (table (QExpr be s)) #

join_' :: (Database be db, Table table, BeamSqlBackend be) => DatabaseEntity be db (TableEntity table) -> (table (QExpr be s) -> QExpr be s SqlBool) -> Q be db s (table (QExpr be s)) #

leftJoin_ :: (BeamSqlBackend be, Projectible be r, ThreadRewritable (QNested s) r, Retaggable (QExpr be s) (WithRewrittenThread (QNested s) s r)) => Q be db (QNested s) r -> (WithRewrittenThread (QNested s) s r -> QExpr be s Bool) -> Q be db s (Retag Nullable (WithRewrittenThread (QNested s) s r)) #

leftJoin_' :: (BeamSqlBackend be, Projectible be r, ThreadRewritable (QNested s) r, Retaggable (QExpr be s) (WithRewrittenThread (QNested s) s r)) => Q be db (QNested s) r -> (WithRewrittenThread (QNested s) s r -> QExpr be s SqlBool) -> Q be db s (Retag Nullable (WithRewrittenThread (QNested s) s r)) #

limit_ :: (Projectible be a, ThreadRewritable (QNested s) a) => Integer -> Q be db (QNested s) a -> Q be db s (WithRewrittenThread (QNested s) s a) #

lower_ :: (BeamSqlBackendIsString be text, BeamSqlBackend be) => QGenExpr context be s text -> QGenExpr context be s text #

noBounds_ :: QFrameBounds be #

noOrder_ :: Maybe (QOrd be s Int) #

noPartition_ :: Maybe (QExpr be s Int) #

nrows_ :: BeamSql2003ExpressionBackend be => Int -> QFrameBound be #

nub_ :: (BeamSqlBackend be, Projectible be r) => Q be db s r -> Q be db s r #

nullsFirst_ :: IsSql2003OrderingElementaryOLAPOperationsSyntax (BeamSqlBackendOrderingSyntax be) => QOrd be s a -> QOrd be s a #

nullsLast_ :: IsSql2003OrderingElementaryOLAPOperationsSyntax (BeamSqlBackendOrderingSyntax be) => QOrd be s a -> QOrd be s a #

octetLength_ :: (BeamSqlBackend be, BeamSqlBackendIsString be text) => QGenExpr context be s text -> QGenExpr context be s Int #

offset_ :: (Projectible be a, ThreadRewritable (QNested s) a) => Integer -> Q be db (QNested s) a -> Q be db s (WithRewrittenThread (QNested s) s a) #

orderBy_ :: (Projectible be a, SqlOrderable be ordering, ThreadRewritable (QNested s) a) => (a -> ordering) -> Q be db (QNested s) a -> Q be db s (WithRewrittenThread (QNested s) s a) #

orderPartitionBy_ :: partition -> Maybe partition #

outerJoin_ :: (BeamSqlBackend be, BeamSqlBackendSupportsOuterJoin be, Projectible be a, Projectible be b, ThreadRewritable (QNested s) a, ThreadRewritable (QNested s) b, Retaggable (QExpr be s) (WithRewrittenThread (QNested s) s a), Retaggable (QExpr be s) (WithRewrittenThread (QNested s) s b)) => Q be db (QNested s) a -> Q be db (QNested s) b -> ((WithRewrittenThread (QNested s) s a, WithRewrittenThread (QNested s) s b) -> QExpr be s Bool) -> Q be db s (Retag Nullable (WithRewrittenThread (QNested s) s a), Retag Nullable (WithRewrittenThread (QNested s) s b)) #

outerJoin_' :: (BeamSqlBackend be, BeamSqlBackendSupportsOuterJoin be, Projectible be a, Projectible be b, ThreadRewritable (QNested s) a, ThreadRewritable (QNested s) b, Retaggable (QExpr be s) (WithRewrittenThread (QNested s) s a), Retaggable (QExpr be s) (WithRewrittenThread (QNested s) s b)) => Q be db (QNested s) a -> Q be db (QNested s) b -> ((WithRewrittenThread (QNested s) s a, WithRewrittenThread (QNested s) s b) -> QExpr be s SqlBool) -> Q be db s (Retag Nullable (WithRewrittenThread (QNested s) s a), Retag Nullable (WithRewrittenThread (QNested s) s b)) #

over_ :: BeamSql2003ExpressionBackend be => QAgg be s a -> QWindow be s -> QWindowExpr be s a #

partitionBy_ :: partition -> Maybe partition #

perhaps_ :: (Projectible be r, BeamSqlBackend be, ThreadRewritable (QNested s) r, Retaggable (QExpr be s) (WithRewrittenThread (QNested s) s r)) => Q be db (QNested s) r -> Q be db s (Retag Nullable (WithRewrittenThread (QNested s) s r)) #

position_ :: (BeamSqlBackendIsString be text, BeamSqlBackend be, Integral b) => QExpr be s text -> QExpr be s text -> QExpr be s b #

references_ :: (Table t, BeamSqlBackend be, HasTableEquality be (PrimaryKey t)) => PrimaryKey t (QGenExpr ctxt be s) -> t (QGenExpr ctxt be s) -> QGenExpr ctxt be s Bool #

relatedBy_ :: (Database be db, Table rel, BeamSqlBackend be) => DatabaseEntity be db (TableEntity rel) -> (rel (QExpr be s) -> QExpr be s Bool) -> Q be db s (rel (QExpr be s)) #

relatedBy_' :: (Database be db, Table rel, BeamSqlBackend be) => DatabaseEntity be db (TableEntity rel) -> (rel (QExpr be s) -> QExpr be s SqlBool) -> Q be db s (rel (QExpr be s)) #

related_ :: (Database be db, Table rel, BeamSqlBackend be, HasTableEquality be (PrimaryKey rel)) => DatabaseEntity be db (TableEntity rel) -> PrimaryKey rel (QExpr be s) -> Q be db s (rel (QExpr be s)) #

subquery_ :: (BeamSqlBackend be, HasQBuilder be, Projectible be (QExpr be s a)) => Q be db s (QExpr be s a) -> QGenExpr ctxt be s a #

subselect_ :: (ThreadRewritable (QNested s) r, Projectible be r) => Q be db (QNested s) r -> Q be db s (WithRewrittenThread (QNested s) s r) #

then_ :: QGenExpr context be s Bool -> QGenExpr context be s a -> QIfCond context be s a #

then_' :: QGenExpr context be s SqlBool -> QGenExpr context be s a -> QIfCond context be s a #

trim_ :: (BeamSqlBackendIsString be text, BeamSqlBackend be) => QGenExpr context be s text -> QGenExpr context be s text #

unbounded_ :: BeamSql2003ExpressionBackend be => QFrameBound be #

unionAll_ :: (BeamSqlBackend be, Projectible be a, ThreadRewritable (QNested s) a) => Q be db (QNested s) a -> Q be db (QNested s) a -> Q be db s (WithRewrittenThread (QNested s) s a) #

union_ :: (BeamSqlBackend be, Projectible be a, ThreadRewritable (QNested s) a) => Q be db (QNested s) a -> Q be db (QNested s) a -> Q be db s (WithRewrittenThread (QNested s) s a) #

unique_ :: (BeamSqlBackend be, HasQBuilder be, Projectible be a) => Q be db s a -> QExpr be s Bool #

upper_ :: (BeamSqlBackendIsString be text, BeamSqlBackend be) => QGenExpr context be s text -> QGenExpr context be s text #

values_ :: (Projectible be a, BeamSqlBackend be) => [a] -> Q be db s a #

withWindow_ :: (ProjectibleWithPredicate WindowFrameContext be (WithExprContext (BeamSqlBackendWindowFrameSyntax' be)) window, Projectible be r, Projectible be a, ContextRewritable a, ThreadRewritable (QNested s) (WithRewrittenContext a QValueContext)) => (r -> window) -> (r -> window -> a) -> Q be db (QNested s) r -> Q be db s (WithRewrittenThread (QNested s) s (WithRewrittenContext a QValueContext)) #

agg_ :: QAgg be s a -> QAgg be s a #

valueExpr_ :: QExpr be s a -> QExpr be s a #

array :: (Typeable a, BeamSql99DataTypeBackend be) => DataType be a -> Int -> DataType be (Vector a) #

bigint :: (BeamSqlBackend be, BeamSqlT071Backend be, Integral a) => DataType be a #

binary :: (BeamSqlBackend be, BeamSqlT021Backend be) => Maybe Word -> DataType be Integer #

binaryLargeObject :: BeamSql99DataTypeBackend be => DataType be Text #

boolean :: BeamSql99DataTypeBackend be => DataType be Bool #

cast_ :: BeamSqlBackend be => QGenExpr ctxt be s a -> DataType be b -> QGenExpr ctxt be s b #

char :: BeamSqlBackend be => Maybe Word -> DataType be Text #

characterLargeObject :: BeamSql99DataTypeBackend be => DataType be Text #

date :: BeamSqlBackend be => DataType be Day #

double :: BeamSqlBackend be => DataType be Double #

int :: (BeamSqlBackend be, Integral a) => DataType be a #

maybeType :: DataType be a -> DataType be (Maybe a) #

nationalChar :: BeamSqlBackend be => Maybe Word -> DataType be Text #

nationalVarchar :: BeamSqlBackend be => Maybe Word -> DataType be Text #

numeric :: BeamSqlBackend be => Maybe (Word, Maybe Word) -> DataType be Scientific #

smallint :: (BeamSqlBackend be, Integral a) => DataType be a #

time :: BeamSqlBackend be => Maybe Word -> DataType be TimeOfDay #

timestamp :: BeamSqlBackend be => DataType be LocalTime #

timestamptz :: BeamSqlBackend be => DataType be LocalTime #

varbinary :: (BeamSqlBackend be, BeamSqlT021Backend be) => Maybe Word -> DataType be Integer #

varchar :: BeamSqlBackend be => Maybe Word -> DataType be Text #

(**.) :: (Floating a, BeamSqlBackend be, BeamSqlT621Backend be) => QGenExpr ctxt be s a -> QGenExpr ctxt be s a -> QGenExpr ctxt be s a #

ceiling_ :: (RealFrac a, Integral b, BeamSqlBackend be, BeamSqlT621Backend be) => QGenExpr ctxt be s a -> QGenExpr ctxt be s b #

corrOver_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => Maybe (BeamSqlBackendAggregationQuantifierSyntax be) -> QExpr be s a -> QExpr be s a -> QExpr be s b #

corr_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => QExpr be s a -> QExpr be s a -> QExpr be s b #

covarPopOver_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => Maybe (BeamSqlBackendAggregationQuantifierSyntax be) -> QExpr be s a -> QExpr be s a -> QExpr be s b #

covarPop_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => QExpr be s a -> QExpr be s a -> QExpr be s b #

covarSampOver_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => Maybe (BeamSqlBackendAggregationQuantifierSyntax be) -> QExpr be s a -> QExpr be s a -> QExpr be s b #

covarSamp_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => QExpr be s a -> QExpr be s a -> QExpr be s b #

exp_ :: (Floating a, BeamSqlBackend be, BeamSqlT621Backend be) => QGenExpr ctxt be s a -> QGenExpr ctxt be s a #

firstValue_ :: (BeamSqlBackend be, BeamSqlT616Backend be) => QExpr be s a -> QAgg be s a #

floor_ :: (RealFrac a, Integral b, BeamSqlBackend be, BeamSqlT621Backend be) => QGenExpr ctxt be s a -> QGenExpr ctxt be s b #

lag1_ :: (BeamSqlBackend be, BeamSqlT615Backend be) => QExpr be s a -> QAgg be s a #

lagWithDefault_ :: (BeamSqlBackend be, BeamSqlT615Backend be) => QExpr be s a -> QExpr be s Int -> QExpr be s a -> QAgg be s a #

lag_ :: (BeamSqlBackend be, BeamSqlT615Backend be) => QExpr be s a -> QExpr be s Int -> QAgg be s a #

lastValue_ :: (BeamSqlBackend be, BeamSqlT616Backend be) => QExpr be s a -> QAgg be s a #

lead1_ :: (BeamSqlBackend be, BeamSqlT615Backend be) => QExpr be s a -> QAgg be s a #

leadWithDefault_ :: (BeamSqlBackend be, BeamSqlT615Backend be) => QExpr be s a -> QExpr be s Int -> QExpr be s a -> QAgg be s a #

lead_ :: (BeamSqlBackend be, BeamSqlT615Backend be) => QExpr be s a -> QExpr be s Int -> QAgg be s a #

ln_ :: (Floating a, BeamSqlBackend be, BeamSqlT621Backend be) => QGenExpr ctxt be s a -> QGenExpr ctxt be s a #

nthValue_ :: (BeamSqlBackend be, BeamSqlT618Backend be) => QExpr be s a -> QExpr be s Int -> QAgg be s a #

ntile_ :: (BeamSqlBackend be, BeamSqlT614Backend be) => QExpr be s Int -> QAgg be s a #

regrAvgXOver_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => Maybe (BeamSqlBackendAggregationQuantifierSyntax be) -> QExpr be s a -> QExpr be s a -> QExpr be s b #

regrAvgX_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => QExpr be s a -> QExpr be s a -> QExpr be s b #

regrAvgYOver_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => Maybe (BeamSqlBackendAggregationQuantifierSyntax be) -> QExpr be s a -> QExpr be s a -> QExpr be s b #

regrAvgY_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => QExpr be s a -> QExpr be s a -> QExpr be s b #

regrCountOver_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => Maybe (BeamSqlBackendAggregationQuantifierSyntax be) -> QExpr be s a -> QExpr be s a -> QExpr be s b #

regrCount_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => QExpr be s a -> QExpr be s a -> QExpr be s b #

regrInterceptOver_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => Maybe (BeamSqlBackendAggregationQuantifierSyntax be) -> QExpr be s a -> QExpr be s a -> QExpr be s b #

regrIntercept_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => QExpr be s a -> QExpr be s a -> QExpr be s b #

regrRSquaredOver_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => Maybe (BeamSqlBackendAggregationQuantifierSyntax be) -> QExpr be s a -> QExpr be s a -> QExpr be s b #

regrRSquared_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => QExpr be s a -> QExpr be s a -> QExpr be s b #

regrSXXOver_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => Maybe (BeamSqlBackendAggregationQuantifierSyntax be) -> QExpr be s a -> QExpr be s a -> QExpr be s b #

regrSXX_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => QExpr be s a -> QExpr be s a -> QExpr be s b #

regrSXYOver_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => Maybe (BeamSqlBackendAggregationQuantifierSyntax be) -> QExpr be s a -> QExpr be s a -> QExpr be s b #

regrSXY_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => QExpr be s a -> QExpr be s a -> QExpr be s b #

regrSYYOver_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => Maybe (BeamSqlBackendAggregationQuantifierSyntax be) -> QExpr be s a -> QExpr be s a -> QExpr be s b #

regrSYY_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => QExpr be s a -> QExpr be s a -> QExpr be s b #

regrSlopeOver_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => Maybe (BeamSqlBackendAggregationQuantifierSyntax be) -> QExpr be s a -> QExpr be s a -> QExpr be s b #

regrSlope_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => QExpr be s a -> QExpr be s a -> QExpr be s b #

sqrt_ :: (Floating a, BeamSqlBackend be, BeamSqlT621Backend be) => QGenExpr ctxt be s a -> QGenExpr ctxt be s a #

stddevPopOver_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => Maybe (BeamSqlBackendAggregationQuantifierSyntax be) -> QExpr be s a -> QAgg be s b #

stddevPop_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => QExpr be s a -> QAgg be s b #

stddevSampOver_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => Maybe (BeamSqlBackendAggregationQuantifierSyntax be) -> QExpr be s a -> QAgg be s b #

stddevSamp_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => QExpr be s a -> QAgg be s b #

varPopOver_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => Maybe (BeamSqlBackendAggregationQuantifierSyntax be) -> QExpr be s a -> QAgg be s b #

varPop_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => QExpr be s a -> QAgg be s b #

varSampOver_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => Maybe (BeamSqlBackendAggregationQuantifierSyntax be) -> QExpr be s a -> QAgg be s b #

varSamp_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => QExpr be s a -> QAgg be s b #

day_ :: (BeamSqlBackend be, HasSqlDate tgt) => ExtractField be tgt Double #

extract_ :: BeamSqlBackend be => ExtractField be tgt a -> QGenExpr ctxt be s tgt -> QGenExpr cxt be s a #

hour_ :: (BeamSqlBackend be, HasSqlTime tgt) => ExtractField be tgt Double #

minutes_ :: (BeamSqlBackend be, HasSqlTime tgt) => ExtractField be tgt Double #

month_ :: (BeamSqlBackend be, HasSqlDate tgt) => ExtractField be tgt Double #

seconds_ :: (BeamSqlBackend be, HasSqlTime tgt) => ExtractField be tgt Double #

year_ :: (BeamSqlBackend be, HasSqlDate tgt) => ExtractField be tgt Double #

(&&.) :: BeamSqlBackend be => QGenExpr context be s Bool -> QGenExpr context be s Bool -> QGenExpr context be s Bool #

(&&?.) :: BeamSqlBackend be => QGenExpr context be s SqlBool -> QGenExpr context be s SqlBool -> QGenExpr context be s SqlBool #

concat_ :: BeamSql99ConcatExpressionBackend be => [QGenExpr context be s Text] -> QGenExpr context be s Text #

div_ :: (Integral a, BeamSqlBackend be) => QGenExpr context be s a -> QGenExpr context be s a -> QGenExpr context be s a #

like_ :: (BeamSqlBackendIsString be text, BeamSqlBackend be) => QGenExpr ctxt be s text -> QGenExpr ctxt be s text -> QGenExpr ctxt be s Bool #

mod_ :: (Integral a, BeamSqlBackend be) => QGenExpr context be s a -> QGenExpr context be s a -> QGenExpr context be s a #

not_ :: BeamSqlBackend be => QGenExpr context be s Bool -> QGenExpr context be s Bool #

similarTo_ :: (BeamSqlBackendIsString be text, BeamSql99ExpressionBackend be) => QGenExpr ctxt be s text -> QGenExpr ctxt be s text -> QGenExpr ctxt be s text #

sqlNot_ :: BeamSqlBackend be => QGenExpr context be s SqlBool -> QGenExpr context be s SqlBool #

(||.) :: BeamSqlBackend be => QGenExpr context be s Bool -> QGenExpr context be s Bool -> QGenExpr context be s Bool #

(||?.) :: BeamSqlBackend be => QGenExpr context be s SqlBool -> QGenExpr context be s SqlBool -> QGenExpr context be s SqlBool #

allIn_ :: BeamSqlBackend be => [QExpr be s a] -> QQuantified be s a #

allOf_ :: (BeamSqlBackend be, HasQBuilder be) => Q be db (QNested s) (QExpr be (QNested s) a) -> QQuantified be s a #

anyIn_ :: BeamSqlBackend be => [QExpr be s a] -> QQuantified be s a #

anyOf_ :: (BeamSqlBackend be, HasQBuilder be) => Q be db (QNested s) (QExpr be (QNested s) a) -> QQuantified be s a #

between_ :: BeamSqlBackend be => QGenExpr context be s a -> QGenExpr context be s a -> QGenExpr context be s a -> QGenExpr context be s Bool #

fromPossiblyNullBool_ :: QGenExpr context be s (Maybe Bool) -> QGenExpr context be s SqlBool #

in_ :: BeamSqlBackend be => QGenExpr context be s a -> [QGenExpr context be s a] -> QGenExpr context be s Bool #

isFalse_ :: BeamSqlBackend be => QGenExpr context be s SqlBool -> QGenExpr context be s Bool #

isNotFalse_ :: BeamSqlBackend be => QGenExpr context be s SqlBool -> QGenExpr context be s Bool #

isNotTrue_ :: BeamSqlBackend be => QGenExpr context be s SqlBool -> QGenExpr context be s Bool #

isNotUnknown_ :: BeamSqlBackend be => QGenExpr context be s SqlBool -> QGenExpr context be s Bool #

isTrue_ :: BeamSqlBackend be => QGenExpr context be s SqlBool -> QGenExpr context be s Bool #

isUnknown_ :: BeamSqlBackend be => QGenExpr context be s SqlBool -> QGenExpr context be s Bool #

possiblyNullBool_ :: QGenExpr context be s SqlBool -> QGenExpr context be s (Maybe Bool) #

sqlBool_ :: QGenExpr context syntax s Bool -> QGenExpr context syntax s SqlBool #

unknownAs_ :: BeamSqlBackend be => Bool -> QGenExpr context be s SqlBool -> QGenExpr context be s Bool #

manyToManyPassthrough_ :: (Database be db, Table joinThrough, Table left, Table right, BeamSqlBackend be, SqlEq (QExpr be s) (PrimaryKey left (QExpr be s)), SqlEq (QExpr be s) (PrimaryKey right (QExpr be s))) => DatabaseEntity be db (TableEntity joinThrough) -> (joinThrough (QExpr be s) -> PrimaryKey left (QExpr be s)) -> (joinThrough (QExpr be s) -> PrimaryKey right (QExpr be s)) -> Q be db s (left (QExpr be s)) -> Q be db s (right (QExpr be s)) -> Q be db s (joinThrough (QExpr be s), left (QExpr be s), right (QExpr be s)) #

manyToMany_ :: (Database be db, Table joinThrough, Table left, Table right, BeamSqlBackend be, SqlEq (QExpr be s) (PrimaryKey left (QExpr be s)), SqlEq (QExpr be s) (PrimaryKey right (QExpr be s))) => DatabaseEntity be db (TableEntity joinThrough) -> (joinThrough (QExpr be s) -> PrimaryKey left (QExpr be s)) -> (joinThrough (QExpr be s) -> PrimaryKey right (QExpr be s)) -> Q be db s (left (QExpr be s)) -> Q be db s (right (QExpr be s)) -> Q be db s (left (QExpr be s), right (QExpr be s)) #

oneToManyOptional_ :: (BeamSqlBackend be, Database be db, Table tbl, Table rel, HasTableEqualityNullable be (PrimaryKey tbl)) => DatabaseEntity be db (TableEntity rel) -> (rel (QExpr be s) -> PrimaryKey tbl (Nullable (QExpr be s))) -> tbl (QExpr be s) -> Q be db s (rel (Nullable (QExpr be s))) #

oneToMany_ :: (Database be db, BeamSqlBackend be, HasTableEquality be (PrimaryKey tbl), Table tbl, Table rel) => DatabaseEntity be db (TableEntity rel) -> (rel (QExpr be s) -> PrimaryKey tbl (QExpr be s)) -> tbl (QExpr be s) -> Q be db s (rel (QExpr be s)) #

oneToMaybe_ :: (BeamSqlBackend be, Database be db, Table tbl, Table rel, HasTableEqualityNullable be (PrimaryKey tbl)) => DatabaseEntity be db (TableEntity rel) -> (rel (QExpr be s) -> PrimaryKey tbl (Nullable (QExpr be s))) -> tbl (QExpr be s) -> Q be db s (rel (Nullable (QExpr be s))) #

oneToOne_ :: (Database be db, BeamSqlBackend be, HasTableEquality be (PrimaryKey tbl), Table tbl, Table rel) => DatabaseEntity be db (TableEntity rel) -> (rel (QExpr be s) -> PrimaryKey tbl (QExpr be s)) -> tbl (QExpr be s) -> Q be db s (rel (QExpr be s)) #

dbLenses :: (Generic (db (TableLens f db)), Generic (db f), GDatabaseLenses (db f) (Rep (db f)) (Rep (db (TableLens f db)))) => db (TableLens f db) #

tableLenses :: (lensType ~ Lenses t f, Generic (t lensType), Generic (t f), GTableLenses t f (Rep (t f)) (Rep (t lensType))) => t (Lenses t f) #

dbModification :: Database be db => DatabaseModification f be db #

defTblFieldSettings :: (Generic (TableSettings table), GDefaultTableFieldSettings (Rep (TableSettings table) ())) => TableSettings table #

defaultDbSettings :: (Generic (DatabaseSettings be db), GAutoDbSettings (Rep (DatabaseSettings be db) ())) => DatabaseSettings be db #

fieldName :: Lens' (TableField table ty) Text #

fieldNamed :: Text -> FieldModification (TableField tbl) a #

modifyEntityName :: IsDatabaseEntity be entity => (Text -> Text) -> EntityModification (DatabaseEntity be db) be entity #

modifyTable :: (Beamable tbl, Table tbl) => (Text -> Text) -> tbl (FieldModification (TableField tbl)) -> EntityModification (DatabaseEntity be db) be (TableEntity tbl) #

modifyTableFields :: tbl (FieldModification (TableField tbl)) -> EntityModification (DatabaseEntity be db) be (TableEntity tbl) #

pk :: Table t => t f -> PrimaryKey t f #

setEntityName :: IsDatabaseEntity be entity => Text -> EntityModification (DatabaseEntity be db) be entity #

tableModification :: Beamable tbl => tbl (FieldModification f) #

withDbModification :: Database be db => db (entity be db) -> DatabaseModification (entity be db) be db -> db (entity be db) #

withTableModification :: Beamable tbl => tbl (FieldModification f) -> tbl f -> tbl f #

class (BeamBackend be, Monad m) => MonadBeam be (m :: Type -> Type) | m -> be where #

Minimal complete definition

runReturningMany

Methods

runReturningMany :: FromBackendRow be x => BeamSqlBackendSyntax be -> (m (Maybe x) -> m a) -> m a #

runNoReturn :: BeamSqlBackendSyntax be -> m () #

runReturningOne :: FromBackendRow be x => BeamSqlBackendSyntax be -> m (Maybe x) #

runReturningList :: FromBackendRow be x => BeamSqlBackendSyntax be -> m [x] #

Instances

MonadBeam Postgres Pg
Instance details Defined in Database.Beam.Postgres.Connection Methods runReturningMany :: FromBackendRow Postgres x => BeamSqlBackendSyntax Postgres -> (Pg (Maybe x) -> Pg a) -> Pg a # runNoReturn :: BeamSqlBackendSyntax Postgres -> Pg () # runReturningOne :: FromBackendRow Postgres x => BeamSqlBackendSyntax Postgres -> Pg (Maybe x) # runReturningList :: FromBackendRow Postgres x => BeamSqlBackendSyntax Postgres -> Pg [x] #
(MonadBeam be m, Monoid s) => MonadBeam be (WriterT s m)
Instance details Defined in Database.Beam.Backend.SQL Methods runReturningMany :: FromBackendRow be x => BeamSqlBackendSyntax be -> (WriterT s m (Maybe x) -> WriterT s m a) -> WriterT s m a # runNoReturn :: BeamSqlBackendSyntax be -> WriterT s m () # runReturningOne :: FromBackendRow be x => BeamSqlBackendSyntax be -> WriterT s m (Maybe x) # runReturningList :: FromBackendRow be x => BeamSqlBackendSyntax be -> WriterT s m [x] #
(MonadBeam be m, Monoid s) => MonadBeam be (WriterT s m)
Instance details Defined in Database.Beam.Backend.SQL Methods runReturningMany :: FromBackendRow be x => BeamSqlBackendSyntax be -> (WriterT s m (Maybe x) -> WriterT s m a) -> WriterT s m a # runNoReturn :: BeamSqlBackendSyntax be -> WriterT s m () # runReturningOne :: FromBackendRow be x => BeamSqlBackendSyntax be -> WriterT s m (Maybe x) # runReturningList :: FromBackendRow be x => BeamSqlBackendSyntax be -> WriterT s m [x] #
MonadBeam be m => MonadBeam be (StateT s m)
Instance details Defined in Database.Beam.Backend.SQL Methods runReturningMany :: FromBackendRow be x => BeamSqlBackendSyntax be -> (StateT s m (Maybe x) -> StateT s m a) -> StateT s m a # runNoReturn :: BeamSqlBackendSyntax be -> StateT s m () # runReturningOne :: FromBackendRow be x => BeamSqlBackendSyntax be -> StateT s m (Maybe x) # runReturningList :: FromBackendRow be x => BeamSqlBackendSyntax be -> StateT s m [x] #
MonadBeam be m => MonadBeam be (StateT s m)
Instance details Defined in Database.Beam.Backend.SQL Methods runReturningMany :: FromBackendRow be x => BeamSqlBackendSyntax be -> (StateT s m (Maybe x) -> StateT s m a) -> StateT s m a # runNoReturn :: BeamSqlBackendSyntax be -> StateT s m () # runReturningOne :: FromBackendRow be x => BeamSqlBackendSyntax be -> StateT s m (Maybe x) # runReturningList :: FromBackendRow be x => BeamSqlBackendSyntax be -> StateT s m [x] #
MonadBeam be m => MonadBeam be (ReaderT r m)
Instance details Defined in Database.Beam.Backend.SQL Methods runReturningMany :: FromBackendRow be x => BeamSqlBackendSyntax be -> (ReaderT r m (Maybe x) -> ReaderT r m a) -> ReaderT r m a # runNoReturn :: BeamSqlBackendSyntax be -> ReaderT r m () # runReturningOne :: FromBackendRow be x => BeamSqlBackendSyntax be -> ReaderT r m (Maybe x) # runReturningList :: FromBackendRow be x => BeamSqlBackendSyntax be -> ReaderT r m [x] #
MonadBeam be m => MonadBeam be (ExceptT e m)
Instance details Defined in Database.Beam.Backend.SQL Methods runReturningMany :: FromBackendRow be x => BeamSqlBackendSyntax be -> (ExceptT e m (Maybe x) -> ExceptT e m a) -> ExceptT e m a # runNoReturn :: BeamSqlBackendSyntax be -> ExceptT e m () # runReturningOne :: FromBackendRow be x => BeamSqlBackendSyntax be -> ExceptT e m (Maybe x) # runReturningList :: FromBackendRow be x => BeamSqlBackendSyntax be -> ExceptT e m [x] #
MonadBeam be m => MonadBeam be (ContT r m)
Instance details Defined in Database.Beam.Backend.SQL Methods runReturningMany :: FromBackendRow be x => BeamSqlBackendSyntax be -> (ContT r m (Maybe x) -> ContT r m a) -> ContT r m a # runNoReturn :: BeamSqlBackendSyntax be -> ContT r m () # runReturningOne :: FromBackendRow be x => BeamSqlBackendSyntax be -> ContT r m (Maybe x) # runReturningList :: FromBackendRow be x => BeamSqlBackendSyntax be -> ContT r m [x] #
(MonadBeam be m, Monoid w) => MonadBeam be (RWST r w s m)
Instance details Defined in Database.Beam.Backend.SQL Methods runReturningMany :: FromBackendRow be x => BeamSqlBackendSyntax be -> (RWST r w s m (Maybe x) -> RWST r w s m a) -> RWST r w s m a # runNoReturn :: BeamSqlBackendSyntax be -> RWST r w s m () # runReturningOne :: FromBackendRow be x => BeamSqlBackendSyntax be -> RWST r w s m (Maybe x) # runReturningList :: FromBackendRow be x => BeamSqlBackendSyntax be -> RWST r w s m [x] #
(MonadBeam be m, Monoid w) => MonadBeam be (RWST r w s m)
Instance details Defined in Database.Beam.Backend.SQL Methods runReturningMany :: FromBackendRow be x => BeamSqlBackendSyntax be -> (RWST r w s m (Maybe x) -> RWST r w s m a) -> RWST r w s m a # runNoReturn :: BeamSqlBackendSyntax be -> RWST r w s m () # runReturningOne :: FromBackendRow be x => BeamSqlBackendSyntax be -> RWST r w s m (Maybe x) # runReturningList :: FromBackendRow be x => BeamSqlBackendSyntax be -> RWST r w s m [x] #

class BeamBackend be => FromBackendRow be a where #

Minimal complete definition

Nothing

Methods

fromBackendRow :: FromBackendRowM be a #

valuesNeeded :: Proxy be -> Proxy a -> Int #

Instances

BeamBackend be => FromBackendRow be ()
Instance details Defined in Database.Beam.Backend.SQL.Row Methods fromBackendRow :: FromBackendRowM be () # valuesNeeded :: Proxy be -> Proxy () -> Int #
FromBackendRow Postgres Bool
Instance details Defined in Database.Beam.Postgres.Types Methods fromBackendRow :: FromBackendRowM Postgres Bool # valuesNeeded :: Proxy Postgres -> Proxy Bool -> Int #
FromBackendRow Postgres Char
Instance details Defined in Database.Beam.Postgres.Types Methods fromBackendRow :: FromBackendRowM Postgres Char # valuesNeeded :: Proxy Postgres -> Proxy Char -> Int #
FromBackendRow Postgres Double
Instance details Defined in Database.Beam.Postgres.Types Methods fromBackendRow :: FromBackendRowM Postgres Double # valuesNeeded :: Proxy Postgres -> Proxy Double -> Int #
FromBackendRow Postgres Int
Instance details Defined in Database.Beam.Postgres.Types Methods fromBackendRow :: FromBackendRowM Postgres Int # valuesNeeded :: Proxy Postgres -> Proxy Int -> Int #
FromBackendRow Postgres Int16
Instance details Defined in Database.Beam.Postgres.Types Methods fromBackendRow :: FromBackendRowM Postgres Int16 # valuesNeeded :: Proxy Postgres -> Proxy Int16 -> Int #
FromBackendRow Postgres Int32
Instance details Defined in Database.Beam.Postgres.Types Methods fromBackendRow :: FromBackendRowM Postgres Int32 # valuesNeeded :: Proxy Postgres -> Proxy Int32 -> Int #
FromBackendRow Postgres Int64
Instance details Defined in Database.Beam.Postgres.Types Methods fromBackendRow :: FromBackendRowM Postgres Int64 # valuesNeeded :: Proxy Postgres -> Proxy Int64 -> Int #
FromBackendRow Postgres Integer
Instance details Defined in Database.Beam.Postgres.Types Methods fromBackendRow :: FromBackendRowM Postgres Integer # valuesNeeded :: Proxy Postgres -> Proxy Integer -> Int #
FromBackendRow Postgres Word
Instance details Defined in Database.Beam.Postgres.Types Methods fromBackendRow :: FromBackendRowM Postgres Word # valuesNeeded :: Proxy Postgres -> Proxy Word -> Int #
FromBackendRow Postgres Word16
Instance details Defined in Database.Beam.Postgres.Types Methods fromBackendRow :: FromBackendRowM Postgres Word16 # valuesNeeded :: Proxy Postgres -> Proxy Word16 -> Int #
FromBackendRow Postgres Word32
Instance details Defined in Database.Beam.Postgres.Types Methods fromBackendRow :: FromBackendRowM Postgres Word32 # valuesNeeded :: Proxy Postgres -> Proxy Word32 -> Int #
FromBackendRow Postgres Word64
Instance details Defined in Database.Beam.Postgres.Types Methods fromBackendRow :: FromBackendRowM Postgres Word64 # valuesNeeded :: Proxy Postgres -> Proxy Word64 -> Int #
FromBackendRow Postgres ByteString
Instance details Defined in Database.Beam.Postgres.Types Methods fromBackendRow :: FromBackendRowM Postgres ByteString # valuesNeeded :: Proxy Postgres -> Proxy ByteString -> Int #
FromBackendRow Postgres ByteString
Instance details Defined in Database.Beam.Postgres.Types Methods fromBackendRow :: FromBackendRowM Postgres ByteString # valuesNeeded :: Proxy Postgres -> Proxy ByteString -> Int #
FromBackendRow Postgres Text
Instance details Defined in Database.Beam.Postgres.Types Methods fromBackendRow :: FromBackendRowM Postgres Text # valuesNeeded :: Proxy Postgres -> Proxy Text -> Int #
FromBackendRow Postgres Text
Instance details Defined in Database.Beam.Postgres.Types Methods fromBackendRow :: FromBackendRowM Postgres Text # valuesNeeded :: Proxy Postgres -> Proxy Text -> Int #
FromBackendRow Postgres LocalTime
Instance details Defined in Database.Beam.Postgres.Types Methods fromBackendRow :: FromBackendRowM Postgres LocalTime # valuesNeeded :: Proxy Postgres -> Proxy LocalTime -> Int #
FromBackendRow Postgres TimeOfDay
Instance details Defined in Database.Beam.Postgres.Types Methods fromBackendRow :: FromBackendRowM Postgres TimeOfDay # valuesNeeded :: Proxy Postgres -> Proxy TimeOfDay -> Int #
FromBackendRow Postgres UTCTime
Instance details Defined in Database.Beam.Postgres.Types Methods fromBackendRow :: FromBackendRowM Postgres UTCTime # valuesNeeded :: Proxy Postgres -> Proxy UTCTime -> Int #
FromBackendRow Postgres Day
Instance details Defined in Database.Beam.Postgres.Types Methods fromBackendRow :: FromBackendRowM Postgres Day # valuesNeeded :: Proxy Postgres -> Proxy Day -> Int #
FromBackendRow Postgres SqlNull
Instance details Defined in Database.Beam.Postgres.Types Methods fromBackendRow :: FromBackendRowM Postgres SqlNull # valuesNeeded :: Proxy Postgres -> Proxy SqlNull -> Int #
FromBackendRow Postgres Scientific
Instance details Defined in Database.Beam.Postgres.Types Methods fromBackendRow :: FromBackendRowM Postgres Scientific # valuesNeeded :: Proxy Postgres -> Proxy Scientific -> Int #
FromBackendRow Postgres Value
Instance details Defined in Database.Beam.Postgres.Types Methods fromBackendRow :: FromBackendRowM Postgres Value # valuesNeeded :: Proxy Postgres -> Proxy Value -> Int #
FromBackendRow Postgres UUID
Instance details Defined in Database.Beam.Postgres.Types Methods fromBackendRow :: FromBackendRowM Postgres UUID # valuesNeeded :: Proxy Postgres -> Proxy UUID -> Int #
FromBackendRow Postgres PgBox
Instance details Defined in Database.Beam.Postgres.PgSpecific Methods fromBackendRow :: FromBackendRowM Postgres PgBox # valuesNeeded :: Proxy Postgres -> Proxy PgBox -> Int #
FromBackendRow Postgres PgMoney
Instance details Defined in Database.Beam.Postgres.PgSpecific Methods fromBackendRow :: FromBackendRowM Postgres PgMoney # valuesNeeded :: Proxy Postgres -> Proxy PgMoney -> Int #
FromBackendRow Postgres PgPoint
Instance details Defined in Database.Beam.Postgres.PgSpecific Methods fromBackendRow :: FromBackendRowM Postgres PgPoint # valuesNeeded :: Proxy Postgres -> Proxy PgPoint -> Int #
FromBackendRow Postgres TsQuery
Instance details Defined in Database.Beam.Postgres.PgSpecific Methods fromBackendRow :: FromBackendRowM Postgres TsQuery # valuesNeeded :: Proxy Postgres -> Proxy TsQuery -> Int #
FromBackendRow Postgres TsVector
Instance details Defined in Database.Beam.Postgres.PgSpecific Methods fromBackendRow :: FromBackendRowM Postgres TsVector # valuesNeeded :: Proxy Postgres -> Proxy TsVector -> Int #
FromBackendRow Postgres Oid
Instance details Defined in Database.Beam.Postgres.Types Methods fromBackendRow :: FromBackendRowM Postgres Oid # valuesNeeded :: Proxy Postgres -> Proxy Oid -> Int #
FromBackendRow Postgres HStoreList
Instance details Defined in Database.Beam.Postgres.Types Methods fromBackendRow :: FromBackendRowM Postgres HStoreList # valuesNeeded :: Proxy Postgres -> Proxy HStoreList -> Int #
FromBackendRow Postgres HStoreMap
Instance details Defined in Database.Beam.Postgres.Types Methods fromBackendRow :: FromBackendRowM Postgres HStoreMap # valuesNeeded :: Proxy Postgres -> Proxy HStoreMap -> Int #
FromBackendRow Postgres Null
Instance details Defined in Database.Beam.Postgres.Types Methods fromBackendRow :: FromBackendRowM Postgres Null # valuesNeeded :: Proxy Postgres -> Proxy Null -> Int #
FromBackendRow Postgres LocalTimestamp
Instance details Defined in Database.Beam.Postgres.Types Methods fromBackendRow :: FromBackendRowM Postgres LocalTimestamp # valuesNeeded :: Proxy Postgres -> Proxy LocalTimestamp -> Int #
FromBackendRow Postgres UTCTimestamp
Instance details Defined in Database.Beam.Postgres.Types Methods fromBackendRow :: FromBackendRowM Postgres UTCTimestamp # valuesNeeded :: Proxy Postgres -> Proxy UTCTimestamp -> Int #
FromBackendRow Postgres ZonedTimestamp
Instance details Defined in Database.Beam.Postgres.Types Methods fromBackendRow :: FromBackendRowM Postgres ZonedTimestamp # valuesNeeded :: Proxy Postgres -> Proxy ZonedTimestamp -> Int #
FromBackendRow Postgres Date
Instance details Defined in Database.Beam.Postgres.Types Methods fromBackendRow :: FromBackendRowM Postgres Date # valuesNeeded :: Proxy Postgres -> Proxy Date -> Int #
FromBackendRow Postgres PgRawString
Instance details Defined in Database.Beam.Postgres.CustomTypes Methods fromBackendRow :: FromBackendRowM Postgres PgRawString # valuesNeeded :: Proxy Postgres -> Proxy PgRawString -> Int #
(BeamBackend be, Generic (tbl Identity), Generic (tbl Exposed), GFromBackendRow be (Rep (tbl Exposed)) (Rep (tbl Identity))) => FromBackendRow be (tbl Identity)
Instance details Defined in Database.Beam.Backend.SQL.Row Methods fromBackendRow :: FromBackendRowM be (tbl Identity) # valuesNeeded :: Proxy be -> Proxy (tbl Identity) -> Int #
(BeamBackend be, Generic (tbl (Nullable Identity)), Generic (tbl (Nullable Exposed)), GFromBackendRow be (Rep (tbl (Nullable Exposed))) (Rep (tbl (Nullable Identity)))) => FromBackendRow be (tbl (Nullable Identity))
Instance details Defined in Database.Beam.Backend.SQL.Row Methods fromBackendRow :: FromBackendRowM be (tbl (Nullable Identity)) # valuesNeeded :: Proxy be -> Proxy (tbl (Nullable Identity)) -> Int #
FromBackendRow be x => FromBackendRow be (SqlSerial x)
Instance details Defined in Database.Beam.Backend.SQL.Row Methods fromBackendRow :: FromBackendRowM be (SqlSerial x) # valuesNeeded :: Proxy be -> Proxy (SqlSerial x) -> Int #
(FromBackendRow be x, FromBackendRow be SqlNull) => FromBackendRow be (Maybe x)
Instance details Defined in Database.Beam.Backend.SQL.Row Methods fromBackendRow :: FromBackendRowM be (Maybe x) # valuesNeeded :: Proxy be -> Proxy (Maybe x) -> Int #
FromBackendRow Postgres [Char]
Instance details Defined in Database.Beam.Postgres.Types Methods fromBackendRow :: FromBackendRowM Postgres [Char] # valuesNeeded :: Proxy Postgres -> Proxy [Char] -> Int #
FromBackendRow Postgres (Ratio Integer)
Instance details Defined in Database.Beam.Postgres.Types Methods fromBackendRow :: FromBackendRowM Postgres (Ratio Integer) # valuesNeeded :: Proxy Postgres -> Proxy (Ratio Integer) -> Int #
(FromField a, Typeable a) => FromBackendRow Postgres (Vector a)
Instance details Defined in Database.Beam.Postgres.Types Methods fromBackendRow :: FromBackendRowM Postgres (Vector a) # valuesNeeded :: Proxy Postgres -> Proxy (Vector a) -> Int #
FromBackendRow Postgres (CI Text)
Instance details Defined in Database.Beam.Postgres.Types Methods fromBackendRow :: FromBackendRowM Postgres (CI Text) # valuesNeeded :: Proxy Postgres -> Proxy (CI Text) -> Int #
FromBackendRow Postgres (CI Text)
Instance details Defined in Database.Beam.Postgres.Types Methods fromBackendRow :: FromBackendRowM Postgres (CI Text) # valuesNeeded :: Proxy Postgres -> Proxy (CI Text) -> Int #
(Typeable a, FromJSON a) => FromBackendRow Postgres (PgJSON a)
Instance details Defined in Database.Beam.Postgres.PgSpecific Methods fromBackendRow :: FromBackendRowM Postgres (PgJSON a) # valuesNeeded :: Proxy Postgres -> Proxy (PgJSON a) -> Int #
(Typeable a, FromJSON a) => FromBackendRow Postgres (PgJSONB a)
Instance details Defined in Database.Beam.Postgres.PgSpecific Methods fromBackendRow :: FromBackendRowM Postgres (PgJSONB a) # valuesNeeded :: Proxy Postgres -> Proxy (PgJSONB a) -> Int #
FromBackendRow Postgres (Binary ByteString)
Instance details Defined in Database.Beam.Postgres.Types Methods fromBackendRow :: FromBackendRowM Postgres (Binary ByteString) # valuesNeeded :: Proxy Postgres -> Proxy (Binary ByteString) -> Int #
FromBackendRow Postgres (Binary ByteString)
Instance details Defined in Database.Beam.Postgres.Types Methods fromBackendRow :: FromBackendRowM Postgres (Binary ByteString) # valuesNeeded :: Proxy Postgres -> Proxy (Binary ByteString) -> Int #
(FromField a, Typeable a) => FromBackendRow Postgres (PGRange a)
Instance details Defined in Database.Beam.Postgres.Types Methods fromBackendRow :: FromBackendRowM Postgres (PGRange a) # valuesNeeded :: Proxy Postgres -> Proxy (PGRange a) -> Int #
(FromField a, Typeable a) => FromBackendRow Postgres (PGArray a)
Instance details Defined in Database.Beam.Postgres.Types Methods fromBackendRow :: FromBackendRowM Postgres (PGArray a) # valuesNeeded :: Proxy Postgres -> Proxy (PGArray a) -> Int #
(BeamBackend be, KnownNat n, FromBackendRow be a) => FromBackendRow be (Vector n a)
Instance details Defined in Database.Beam.Backend.SQL.Row Methods fromBackendRow :: FromBackendRowM be (Vector n a) # valuesNeeded :: Proxy be -> Proxy (Vector n a) -> Int #
(BeamBackend be, FromBackendRow be a, FromBackendRow be b) => FromBackendRow be (a, b)
Instance details Defined in Database.Beam.Backend.SQL.Row Methods fromBackendRow :: FromBackendRowM be (a, b) # valuesNeeded :: Proxy be -> Proxy (a, b) -> Int #
(FromField a, FromField b, Typeable a, Typeable b) => FromBackendRow Postgres (Either a b)
Instance details Defined in Database.Beam.Postgres.Types Methods fromBackendRow :: FromBackendRowM Postgres (Either a b) # valuesNeeded :: Proxy Postgres -> Proxy (Either a b) -> Int #
(FromField a, Typeable a, Typeable n, Ord a) => FromBackendRow Postgres (PgRange n a)
Instance details Defined in Database.Beam.Postgres.PgSpecific Methods fromBackendRow :: FromBackendRowM Postgres (PgRange n a) # valuesNeeded :: Proxy Postgres -> Proxy (PgRange n a) -> Int #
(BeamBackend be, FromBackendRow be t) => FromBackendRow be (Tagged tag t)
Instance details Defined in Database.Beam.Backend.SQL.Row Methods fromBackendRow :: FromBackendRowM be (Tagged tag t) # valuesNeeded :: Proxy be -> Proxy (Tagged tag t) -> Int #
(BeamBackend be, FromBackendRow be a, FromBackendRow be b, FromBackendRow be c) => FromBackendRow be (a, b, c)
Instance details Defined in Database.Beam.Backend.SQL.Row Methods fromBackendRow :: FromBackendRowM be (a, b, c) # valuesNeeded :: Proxy be -> Proxy (a, b, c) -> Int #
(BeamBackend be, FromBackendRow be a, FromBackendRow be b, FromBackendRow be c, FromBackendRow be d) => FromBackendRow be (a, b, c, d)
Instance details Defined in Database.Beam.Backend.SQL.Row Methods fromBackendRow :: FromBackendRowM be (a, b, c, d) # valuesNeeded :: Proxy be -> Proxy (a, b, c, d) -> Int #
(BeamBackend be, FromBackendRow be a, FromBackendRow be b, FromBackendRow be c, FromBackendRow be d, FromBackendRow be e) => FromBackendRow be (a, b, c, d, e)
Instance details Defined in Database.Beam.Backend.SQL.Row Methods fromBackendRow :: FromBackendRowM be (a, b, c, d, e) # valuesNeeded :: Proxy be -> Proxy (a, b, c, d, e) -> Int #
(BeamBackend be, FromBackendRow be a, FromBackendRow be b, FromBackendRow be c, FromBackendRow be d, FromBackendRow be e, FromBackendRow be f) => FromBackendRow be (a, b, c, d, e, f)
Instance details Defined in Database.Beam.Backend.SQL.Row Methods fromBackendRow :: FromBackendRowM be (a, b, c, d, e, f) # valuesNeeded :: Proxy be -> Proxy (a, b, c, d, e, f) -> Int #
(BeamBackend be, FromBackendRow be a, FromBackendRow be b, FromBackendRow be c, FromBackendRow be d, FromBackendRow be e, FromBackendRow be f, FromBackendRow be g) => FromBackendRow be (a, b, c, d, e, f, g)
Instance details Defined in Database.Beam.Backend.SQL.Row Methods fromBackendRow :: FromBackendRowM be (a, b, c, d, e, f, g) # valuesNeeded :: Proxy be -> Proxy (a, b, c, d, e, f, g) -> Int #
(BeamBackend be, FromBackendRow be a, FromBackendRow be b, FromBackendRow be c, FromBackendRow be d, FromBackendRow be e, FromBackendRow be f, FromBackendRow be g, FromBackendRow be h) => FromBackendRow be (a, b, c, d, e, f, g, h)
Instance details Defined in Database.Beam.Backend.SQL.Row Methods fromBackendRow :: FromBackendRowM be (a, b, c, d, e, f, g, h) # valuesNeeded :: Proxy be -> Proxy (a, b, c, d, e, f, g, h) -> Int #

data Nullable (c :: Type -> Type) x #

Instances

Beamable t => ProjectibleWithPredicate AnyType () Text (t (Nullable (QField s)))
Instance details Defined in Database.Beam.Query.Internal Methods project' :: Monad m => Proxy AnyType -> Proxy ((), Text) -> (forall context. AnyType context => Proxy context -> Proxy () -> Text -> m Text) -> t (Nullable (QField s)) -> m (t (Nullable (QField s))) projectSkeleton' :: Monad m => Proxy AnyType -> Proxy ((), Text) -> (forall context. AnyType context => Proxy context -> Proxy () -> m Text) -> m (t (Nullable (QField s)))
Beamable t => ProjectibleWithPredicate AnyType () Text (t (Nullable (Const Text :: Type -> Type)))
Instance details Defined in Database.Beam.Query.Internal Methods project' :: Monad m => Proxy AnyType -> Proxy ((), Text) -> (forall context. AnyType context => Proxy context -> Proxy () -> Text -> m Text) -> t (Nullable (Const Text)) -> m (t (Nullable (Const Text))) projectSkeleton' :: Monad m => Proxy AnyType -> Proxy ((), Text) -> (forall context. AnyType context => Proxy context -> Proxy () -> m Text) -> m (t (Nullable (Const Text)))
(Generic (sub (Nullable m)), Generic (sub (Nullable (Lenses t m))), GTableLenses t m (Rep (sub (Nullable m))) (Rep (sub (Nullable (Lenses t m))))) => GTableLenses t m (K1 R (sub (Nullable m)) :: k -> Type) (K1 R (sub (Nullable (Lenses t m))) :: Type -> Type)
Instance details Defined in Database.Beam.Schema.Lenses Methods gTableLenses :: Proxy (K1 R (sub (Nullable m))) -> Lens' (t m) (K1 R (sub (Nullable m)) p) -> K1 R (sub (Nullable (Lenses t m))) ()
Beamable tbl => GZipTables f g h (K1 R (tbl (Nullable Exposed)) :: Type -> Type) (K1 R (tbl (Nullable f)) :: Type -> Type) (K1 R (tbl (Nullable g)) :: Type -> Type) (K1 R (tbl (Nullable h)) :: Type -> Type)
Instance details Defined in Database.Beam.Schema.Tables Methods gZipTables :: Applicative m => Proxy (K1 R (tbl (Nullable Exposed))) -> (forall a. Columnar' f a -> Columnar' g a -> m (Columnar' h a)) -> K1 R (tbl (Nullable f)) () -> K1 R (tbl (Nullable g)) () -> m (K1 R (tbl (Nullable h)) ())
(BeamSqlBackend be, Beamable tbl) => SqlUpdatable be s (tbl (Nullable (QField s))) (tbl (Nullable (QExpr be s)))
Instance details Defined in Database.Beam.Query.Combinators Methods (<-.) :: tbl (Nullable (QField s)) -> tbl (Nullable (QExpr be s)) -> QAssignment be s #
(Beamable t, contextPredicate context) => ProjectibleWithPredicate contextPredicate be (WithExprContext (BeamSqlBackendExpressionSyntax' be)) (t (Nullable (QGenExpr context be s)))
Instance details Defined in Database.Beam.Query.Internal Methods project' :: Monad m => Proxy contextPredicate -> Proxy (be, WithExprContext (BeamSqlBackendExpressionSyntax' be)) -> (forall context0. contextPredicate context0 => Proxy context0 -> Proxy be -> WithExprContext (BeamSqlBackendExpressionSyntax' be) -> m (WithExprContext (BeamSqlBackendExpressionSyntax' be))) -> t (Nullable (QGenExpr context be s)) -> m (t (Nullable (QGenExpr context be s))) projectSkeleton' :: Monad m => Proxy contextPredicate -> Proxy (be, WithExprContext (BeamSqlBackendExpressionSyntax' be)) -> (forall context0. contextPredicate context0 => Proxy context0 -> Proxy be -> m (WithExprContext (BeamSqlBackendExpressionSyntax' be))) -> m (t (Nullable (QGenExpr context be s)))
(BeamBackend be, Generic (tbl (Nullable Identity)), Generic (tbl (Nullable Exposed)), GFromBackendRow be (Rep (tbl (Nullable Exposed))) (Rep (tbl (Nullable Identity)))) => FromBackendRow be (tbl (Nullable Identity))
Instance details Defined in Database.Beam.Backend.SQL.Row Methods fromBackendRow :: FromBackendRowM be (tbl (Nullable Identity)) # valuesNeeded :: Proxy be -> Proxy (tbl (Nullable Identity)) -> Int #
Beamable tbl => ThreadRewritable s (tbl (Nullable (QGenExpr ctxt syntax s)))
Instance details Defined in Database.Beam.Query.Internal Associated Types type WithRewrittenThread s s' (tbl (Nullable (QGenExpr ctxt syntax s))) :: Type Methods rewriteThread :: Proxy s' -> tbl (Nullable (QGenExpr ctxt syntax s)) -> WithRewrittenThread s s' (tbl (Nullable (QGenExpr ctxt syntax s)))
(BeamSqlBackend be, Beamable t) => SqlDeconstructMaybe be (t (Nullable (QGenExpr ctxt be s))) (t (QGenExpr ctxt be s)) s
Instance details Defined in Database.Beam.Query.Combinators Methods isJust_ :: t (Nullable (QGenExpr ctxt be s)) -> QGenExpr ctxt0 be s Bool # isNothing_ :: t (Nullable (QGenExpr ctxt be s)) -> QGenExpr ctxt0 be s Bool # maybe_ :: QGenExpr ctxt0 be s y -> (t (QGenExpr ctxt be s) -> QGenExpr ctxt0 be s y) -> t (Nullable (QGenExpr ctxt be s)) -> QGenExpr ctxt0 be s y #
FromBackendRow be (t (Nullable Identity)) => GFromBackendRow be (K1 R (t (Nullable Exposed)) :: Type -> Type) (K1 R (t (Nullable Identity)) :: Type -> Type)
Instance details Defined in Database.Beam.Backend.SQL.Row Methods gFromBackendRow :: Proxy (K1 R (t (Nullable Exposed))) -> FromBackendRowM be (K1 R (t (Nullable Identity)) ()) gValuesNeeded :: Proxy be -> Proxy (K1 R (t (Nullable Exposed))) -> Proxy (K1 R (t (Nullable Identity))) -> Int
FieldsFulfillConstraintNullable c t => GFieldsFulfillConstraint c (K1 R (t (Nullable Exposed)) :: Type -> Type) (K1 R (t (Nullable Identity)) :: Type -> Type) (K1 R (t (Nullable (WithConstraint c))) :: Type -> Type)
Instance details Defined in Database.Beam.Schema.Tables Methods gWithConstrainedFields :: Proxy c -> Proxy (K1 R (t (Nullable Exposed))) -> K1 R (t (Nullable Identity)) () -> K1 R (t (Nullable (WithConstraint c))) ()
(Beamable table, BeamSqlBackend be, FieldsFulfillConstraintNullable (BeamSqlBackendCanSerialize be) table) => SqlValable (table (Nullable (QGenExpr ctxt be s)))
Instance details Defined in Database.Beam.Query.Combinators Methods val_ :: HaskellLiteralForQExpr (table (Nullable (QGenExpr ctxt be s))) -> table (Nullable (QGenExpr ctxt be s)) #
Beamable tbl => ContextRewritable (tbl (Nullable (QGenExpr old syntax s)))
Instance details Defined in Database.Beam.Query.Internal Associated Types type WithRewrittenContext (tbl (Nullable (QGenExpr old syntax s))) ctxt :: Type Methods rewriteContext :: Proxy ctxt -> tbl (Nullable (QGenExpr old syntax s)) -> WithRewrittenContext (tbl (Nullable (QGenExpr old syntax s))) ctxt
TagReducesTo f f' => TagReducesTo (Nullable f) f'
Instance details Defined in Database.Beam.Schema.Tables Methods reduceTag :: Functor m => (Columnar' f' a' -> m (Columnar' f' a')) -> Columnar' (Nullable f) a -> m (Columnar' (Nullable f) a)
Beamable tbl => QGroupable (tbl (Nullable (QExpr be s))) (tbl (Nullable (QGroupExpr be s)))
Instance details Defined in Database.Beam.Query.Aggregate Methods group_ :: tbl (Nullable (QExpr be s)) -> tbl (Nullable (QGroupExpr be s)) #
(Table t, BeamSqlBackend be) => SqlJustable (t (QExpr be s)) (t (Nullable (QExpr be s)))
Instance details Defined in Database.Beam.Query.Combinators Methods just_ :: t (QExpr be s) -> t (Nullable (QExpr be s)) # nothing_ :: t (Nullable (QExpr be s)) #
Table t => SqlJustable (t Identity) (t (Nullable Identity))
Instance details Defined in Database.Beam.Query.Combinators Methods just_ :: t Identity -> t (Nullable Identity) # nothing_ :: t (Nullable Identity) #
(Table t, BeamSqlBackend be) => SqlJustable (PrimaryKey t (QExpr be s)) (PrimaryKey t (Nullable (QExpr be s)))
Instance details Defined in Database.Beam.Query.Combinators Methods just_ :: PrimaryKey t (QExpr be s) -> PrimaryKey t (Nullable (QExpr be s)) # nothing_ :: PrimaryKey t (Nullable (QExpr be s)) #
Table t => SqlJustable (PrimaryKey t Identity) (PrimaryKey t (Nullable Identity))
Instance details Defined in Database.Beam.Query.Combinators Methods just_ :: PrimaryKey t Identity -> PrimaryKey t (Nullable Identity) # nothing_ :: PrimaryKey t (Nullable Identity) #
Beamable tbl => GTableSkeleton (K1 R (tbl (Nullable Ignored)) :: Type -> Type)
Instance details Defined in Database.Beam.Schema.Tables Methods gTblSkeleton :: Proxy (K1 R (tbl (Nullable Ignored))) -> K1 R (tbl (Nullable Ignored)) ()
(BeamSqlBackend be, Beamable tbl, FieldsFulfillConstraintNullable (HasSqlEqualityCheck be) tbl) => SqlEq (QGenExpr context be s) (tbl (Nullable (QGenExpr context be s)))
Instance details Defined in Database.Beam.Query.Ord Methods (==.) :: tbl (Nullable (QGenExpr context be s)) -> tbl (Nullable (QGenExpr context be s)) -> QGenExpr context be s Bool # (/=.) :: tbl (Nullable (QGenExpr context be s)) -> tbl (Nullable (QGenExpr context be s)) -> QGenExpr context be s Bool # (==?.) :: tbl (Nullable (QGenExpr context be s)) -> tbl (Nullable (QGenExpr context be s)) -> QGenExpr context be s SqlBool # (/=?.) :: tbl (Nullable (QGenExpr context be s)) -> tbl (Nullable (QGenExpr context be s)) -> QGenExpr context be s SqlBool #
type WithRewrittenThread s s' (tbl (Nullable (QGenExpr ctxt syntax s)))
Instance details Defined in Database.Beam.Query.Internal type WithRewrittenThread s s' (tbl (Nullable (QGenExpr ctxt syntax s))) = tbl (Nullable (QGenExpr ctxt syntax s'))
type HaskellLiteralForQExpr (table (Nullable f))
Instance details Defined in Database.Beam.Query.Combinators type HaskellLiteralForQExpr (table (Nullable f)) = HaskellLiteralForQExpr_AddNullable (HaskellLiteralForQExpr (table f))
type QExprToField (table (Nullable (QGenExpr context syntax s)))
Instance details Defined in Database.Beam.Query.Types type QExprToField (table (Nullable (QGenExpr context syntax s))) = table (Nullable (QField s))
type QExprToIdentity (table (Nullable c))
Instance details Defined in Database.Beam.Query.Types type QExprToIdentity (table (Nullable c)) = Maybe (QExprToIdentity (table c))
type WithRewrittenContext (tbl (Nullable (QGenExpr old syntax s))) ctxt
Instance details Defined in Database.Beam.Query.Internal type WithRewrittenContext (tbl (Nullable (QGenExpr old syntax s))) ctxt = tbl (Nullable (QGenExpr ctxt syntax s))

data QBaseScope #

type QExprTable be s (tbl :: (Type -> Type) -> Type) = QGenExprTable QValueContext be s tbl #

type QGenExprTable ctxt be s (tbl :: (Type -> Type) -> Type) = tbl (QGenExpr ctxt be s) #

data SqlDelete be (table :: (Type -> Type) -> Type) #

Constructors

SqlDelete !(TableSettings table) !(BeamSqlBackendDeleteSyntax be)

Instances

PgReturning SqlDelete
Instance details Defined in Database.Beam.Postgres.Full Associated Types type PgReturningType SqlDelete :: Type -> Type Methods returning :: (Beamable tbl, Projectible Postgres a) => SqlDelete Postgres tbl -> (tbl (QExpr Postgres PostgresInaccessible) -> a) -> PgReturningType SqlDelete (QExprToIdentity a)
type PgReturningType SqlDelete
Instance details Defined in Database.Beam.Postgres.Full type PgReturningType SqlDelete = PgDeleteReturning

data SqlInsert be (table :: (Type -> Type) -> Type) #

Constructors

SqlInsert !(TableSettings table) !(BeamSqlBackendInsertSyntax be)
SqlInsertNoRows

Instances

PgReturning SqlInsert
Instance details Defined in Database.Beam.Postgres.Full Associated Types type PgReturningType SqlInsert :: Type -> Type Methods returning :: (Beamable tbl, Projectible Postgres a) => SqlInsert Postgres tbl -> (tbl (QExpr Postgres PostgresInaccessible) -> a) -> PgReturningType SqlInsert (QExprToIdentity a)
type PgReturningType SqlInsert
Instance details Defined in Database.Beam.Postgres.Full type PgReturningType SqlInsert = PgInsertReturning

data SqlInsertValues be proj #

Constructors

SqlInsertValues (BeamSqlBackendInsertValuesSyntax be)
SqlInsertValuesEmpty

newtype SqlSelect be a #

Constructors

SqlSelect (BeamSqlBackendSelectSyntax be)

data SqlUpdate be (table :: (Type -> Type) -> Type) #

Constructors

SqlUpdate !(TableSettings table) !(BeamSqlBackendUpdateSyntax be)
SqlIdentityUpdate

Instances

PgReturning SqlUpdate
Instance details Defined in Database.Beam.Postgres.Full Associated Types type PgReturningType SqlUpdate :: Type -> Type Methods returning :: (Beamable tbl, Projectible Postgres a) => SqlUpdate Postgres tbl -> (tbl (QExpr Postgres PostgresInaccessible) -> a) -> PgReturningType SqlUpdate (QExprToIdentity a)
type PgReturningType SqlUpdate
Instance details Defined in Database.Beam.Postgres.Full type PgReturningType SqlUpdate = PgUpdateReturning

class QGroupable expr grouped | expr -> grouped, grouped -> expr where #

Methods

group_ :: expr -> grouped #

Instances

Beamable tbl => QGroupable (tbl (QExpr be s)) (tbl (QGroupExpr be s))
Instance details Defined in Database.Beam.Query.Aggregate Methods group_ :: tbl (QExpr be s) -> tbl (QGroupExpr be s) #
Beamable tbl => QGroupable (tbl (Nullable (QExpr be s))) (tbl (Nullable (QGroupExpr be s)))
Instance details Defined in Database.Beam.Query.Aggregate Methods group_ :: tbl (Nullable (QExpr be s)) -> tbl (Nullable (QGroupExpr be s)) #
QGroupable (QExpr be s a) (QGroupExpr be s a)
Instance details Defined in Database.Beam.Query.Aggregate Methods group_ :: QExpr be s a -> QGroupExpr be s a #

data ReusableQ be (db :: (Type -> Type) -> Type) res #

data With be (db :: (Type -> Type) -> Type) a #

Instances

Monad (With be db)
Instance details Defined in Database.Beam.Query.CTE Methods (>>=) :: With be db a -> (a -> With be db b) -> With be db b # (>>) :: With be db a -> With be db b -> With be db b # return :: a -> With be db a # fail :: String -> With be db a #
Functor (With be db)
Instance details Defined in Database.Beam.Query.CTE Methods fmap :: (a -> b) -> With be db a -> With be db b # (<$) :: a -> With be db b -> With be db a #
IsSql99RecursiveCommonTableExpressionSelectSyntax (BeamSqlBackendSelectSyntax be) => MonadFix (With be db)
Instance details Defined in Database.Beam.Query.CTE Methods mfix :: (a -> With be db a) -> With be db a #
Applicative (With be db)
Instance details Defined in Database.Beam.Query.CTE Methods pure :: a -> With be db a # (<>) :: With be db (a -> b) -> With be db a -> With be db b # liftA2 :: (a -> b -> c) -> With be db a -> With be db b -> With be db c # (>) :: With be db a -> With be db b -> With be db b # (<*) :: With be db a -> With be db b -> With be db a #

type family HaskellLiteralForQExpr x = (a :: Type) #

Instances

type HaskellLiteralForQExpr (table (QGenExpr context be s))
Instance details Defined in Database.Beam.Query.Combinators type HaskellLiteralForQExpr (table (QGenExpr context be s)) = table Identity
type HaskellLiteralForQExpr (table (Nullable f))
Instance details Defined in Database.Beam.Query.Combinators type HaskellLiteralForQExpr (table (Nullable f)) = HaskellLiteralForQExpr_AddNullable (HaskellLiteralForQExpr (table f))
type HaskellLiteralForQExpr (QGenExpr context be s a)
Instance details Defined in Database.Beam.Query.Combinators type HaskellLiteralForQExpr (QGenExpr context be s a) = a

data QIfCond context be s a #

data QIfElse context be s a #

class BeamSqlBackend be => SqlDeconstructMaybe be a nonNullA s | a s -> be, a -> nonNullA, a -> s, nonNullA -> s where #

Methods

isJust_ :: a -> QGenExpr ctxt be s Bool #

isNothing_ :: a -> QGenExpr ctxt be s Bool #

maybe_ :: QGenExpr ctxt be s y -> (nonNullA -> QGenExpr ctxt be s y) -> a -> QGenExpr ctxt be s y #

Instances

(BeamSqlBackend be, Beamable t) => SqlDeconstructMaybe be (t (Nullable (QGenExpr ctxt be s))) (t (QGenExpr ctxt be s)) s
Instance details Defined in Database.Beam.Query.Combinators Methods isJust_ :: t (Nullable (QGenExpr ctxt be s)) -> QGenExpr ctxt0 be s Bool # isNothing_ :: t (Nullable (QGenExpr ctxt be s)) -> QGenExpr ctxt0 be s Bool # maybe_ :: QGenExpr ctxt0 be s y -> (t (QGenExpr ctxt be s) -> QGenExpr ctxt0 be s y) -> t (Nullable (QGenExpr ctxt be s)) -> QGenExpr ctxt0 be s y #
BeamSqlBackend be => SqlDeconstructMaybe be (QGenExpr ctxt be s (Maybe x)) (QGenExpr ctxt be s x) s
Instance details Defined in Database.Beam.Query.Combinators Methods isJust_ :: QGenExpr ctxt be s (Maybe x) -> QGenExpr ctxt0 be s Bool # isNothing_ :: QGenExpr ctxt be s (Maybe x) -> QGenExpr ctxt0 be s Bool # maybe_ :: QGenExpr ctxt0 be s y -> (QGenExpr ctxt be s x -> QGenExpr ctxt0 be s y) -> QGenExpr ctxt be s (Maybe x) -> QGenExpr ctxt0 be s y #

class SqlJustable a b | b -> a where #

Methods

just_ :: a -> b #

nothing_ :: b #

Instances

(Table t, BeamSqlBackend be) => SqlJustable (t (QExpr be s)) (t (Nullable (QExpr be s)))
Instance details Defined in Database.Beam.Query.Combinators Methods just_ :: t (QExpr be s) -> t (Nullable (QExpr be s)) # nothing_ :: t (Nullable (QExpr be s)) #
Table t => SqlJustable (t Identity) (t (Nullable Identity))
Instance details Defined in Database.Beam.Query.Combinators Methods just_ :: t Identity -> t (Nullable Identity) # nothing_ :: t (Nullable Identity) #
(Table t, BeamSqlBackend be) => SqlJustable (PrimaryKey t (QExpr be s)) (PrimaryKey t (Nullable (QExpr be s)))
Instance details Defined in Database.Beam.Query.Combinators Methods just_ :: PrimaryKey t (QExpr be s) -> PrimaryKey t (Nullable (QExpr be s)) # nothing_ :: PrimaryKey t (Nullable (QExpr be s)) #
Table t => SqlJustable (PrimaryKey t Identity) (PrimaryKey t (Nullable Identity))
Instance details Defined in Database.Beam.Query.Combinators Methods just_ :: PrimaryKey t Identity -> PrimaryKey t (Nullable Identity) # nothing_ :: PrimaryKey t (Nullable Identity) #
BeamSqlBackend be => SqlJustable (QExpr be s a) (QExpr be s (Maybe a))
Instance details Defined in Database.Beam.Query.Combinators Methods just_ :: QExpr be s a -> QExpr be s (Maybe a) # nothing_ :: QExpr be s (Maybe a) #

class SqlOrderable be a | a -> be #

Minimal complete definition

makeSQLOrdering

Instances

SqlOrderable be a => SqlOrderable be [a]
Instance details Defined in Database.Beam.Query.Combinators Methods makeSQLOrdering :: Proxy be -> [a] -> [WithExprContext (BeamSqlBackendOrderingSyntax be)]
(SqlOrderable be a, SqlOrderable be b) => SqlOrderable be (a, b)
Instance details Defined in Database.Beam.Query.Combinators Methods makeSQLOrdering :: Proxy be -> (a, b) -> [WithExprContext (BeamSqlBackendOrderingSyntax be)]
SqlOrderable be (QOrd be s a)
Instance details Defined in Database.Beam.Query.Combinators Methods makeSQLOrdering :: Proxy be -> QOrd be s a -> [WithExprContext (BeamSqlBackendOrderingSyntax be)]
(SqlOrderable be a, SqlOrderable be b, SqlOrderable be c) => SqlOrderable be (a, b, c)
Instance details Defined in Database.Beam.Query.Combinators Methods makeSQLOrdering :: Proxy be -> (a, b, c) -> [WithExprContext (BeamSqlBackendOrderingSyntax be)]
(SqlOrderable be a, SqlOrderable be b, SqlOrderable be c, SqlOrderable be d) => SqlOrderable be (a, b, c, d)
Instance details Defined in Database.Beam.Query.Combinators Methods makeSQLOrdering :: Proxy be -> (a, b, c, d) -> [WithExprContext (BeamSqlBackendOrderingSyntax be)]
(SqlOrderable be a, SqlOrderable be b, SqlOrderable be c, SqlOrderable be d, SqlOrderable be e) => SqlOrderable be (a, b, c, d, e)
Instance details Defined in Database.Beam.Query.Combinators Methods makeSQLOrdering :: Proxy be -> (a, b, c, d, e) -> [WithExprContext (BeamSqlBackendOrderingSyntax be)]
(SqlOrderable be a, SqlOrderable be b, SqlOrderable be c, SqlOrderable be d, SqlOrderable be e, SqlOrderable be f) => SqlOrderable be (a, b, c, d, e, f)
Instance details Defined in Database.Beam.Query.Combinators Methods makeSQLOrdering :: Proxy be -> (a, b, c, d, e, f) -> [WithExprContext (BeamSqlBackendOrderingSyntax be)]
(SqlOrderable be a, SqlOrderable be b, SqlOrderable be c, SqlOrderable be d, SqlOrderable be e, SqlOrderable be f, SqlOrderable be g) => SqlOrderable be (a, b, c, d, e, f, g)
Instance details Defined in Database.Beam.Query.Combinators Methods makeSQLOrdering :: Proxy be -> (a, b, c, d, e, f, g) -> [WithExprContext (BeamSqlBackendOrderingSyntax be)]
(SqlOrderable be a, SqlOrderable be b, SqlOrderable be c, SqlOrderable be d, SqlOrderable be e, SqlOrderable be f, SqlOrderable be g, SqlOrderable be h) => SqlOrderable be (a, b, c, d, e, f, g, h)
Instance details Defined in Database.Beam.Query.Combinators Methods makeSQLOrdering :: Proxy be -> (a, b, c, d, e, f, g, h) -> [WithExprContext (BeamSqlBackendOrderingSyntax be)]

(<-.) :: SqlUpdatable be s lhs rhs => lhs -> rhs -> QAssignment be s #

class SqlValable a where #

Methods

val_ :: HaskellLiteralForQExpr a -> a #

Instances

(Beamable table, BeamSqlBackend be, FieldsFulfillConstraint (BeamSqlBackendCanSerialize be) table) => SqlValable (table (QGenExpr ctxt be s))
Instance details Defined in Database.Beam.Query.Combinators Methods val_ :: HaskellLiteralForQExpr (table (QGenExpr ctxt be s)) -> table (QGenExpr ctxt be s) #
(Beamable table, BeamSqlBackend be, FieldsFulfillConstraintNullable (BeamSqlBackendCanSerialize be) table) => SqlValable (table (Nullable (QGenExpr ctxt be s)))
Instance details Defined in Database.Beam.Query.Combinators Methods val_ :: HaskellLiteralForQExpr (table (Nullable (QGenExpr ctxt be s))) -> table (Nullable (QGenExpr ctxt be s)) #
(BeamSqlBackendCanSerialize be a, BeamSqlBackend be) => SqlValable (QGenExpr ctxt be s a)
Instance details Defined in Database.Beam.Query.Combinators Methods val_ :: HaskellLiteralForQExpr (QGenExpr ctxt be s a) -> QGenExpr ctxt be s a #

type SqlValableTable be (table :: (Type -> Type) -> Type) = (Beamable table, FieldsFulfillConstraint (HasSqlValueSyntax (BeamSqlBackendValueSyntax be)) table) #

class IsCustomExprFn fn res | res -> fn where #

Methods

customExpr_ :: fn -> res #

Instances

BeamSqlBackendHasCustomSyntax be => IsCustomExprFn (CustomSqlSnippet be) (QGenExpr ctxt be s res)
Instance details Defined in Database.Beam.Query.CustomSQL Methods customExpr_ :: CustomSqlSnippet be -> QGenExpr ctxt be s res #
(IsCustomExprFn a res, BeamSqlBackendHasCustomSyntax be) => IsCustomExprFn (CustomSqlSnippet be -> a) (QGenExpr ctxt be s r -> res)
Instance details Defined in Database.Beam.Query.CustomSQL Methods customExpr_ :: (CustomSqlSnippet be -> a) -> QGenExpr ctxt be s r -> res #

class (Monoid (CustomSqlSyntax syntax), Semigroup (CustomSqlSyntax syntax), IsString (CustomSqlSyntax syntax)) => IsCustomSqlSyntax syntax where #

Associated Types

data CustomSqlSyntax syntax :: Type #

Methods

customExprSyntax :: CustomSqlSyntax syntax -> syntax #

renderSyntax :: syntax -> CustomSqlSyntax syntax #

Instances

IsCustomSqlSyntax SqlSyntaxBuilder
Instance details Defined in Database.Beam.Query.CustomSQL Associated Types data CustomSqlSyntax SqlSyntaxBuilder :: Type # Methods customExprSyntax :: CustomSqlSyntax SqlSyntaxBuilder -> SqlSyntaxBuilder # renderSyntax :: SqlSyntaxBuilder -> CustomSqlSyntax SqlSyntaxBuilder #
IsCustomSqlSyntax PgExpressionSyntax
Instance details Defined in Database.Beam.Postgres.Syntax Associated Types data CustomSqlSyntax PgExpressionSyntax :: Type # Methods customExprSyntax :: CustomSqlSyntax PgExpressionSyntax -> PgExpressionSyntax # renderSyntax :: PgExpressionSyntax -> CustomSqlSyntax PgExpressionSyntax #

newtype DataType be a #

Constructors

DataType (BeamSqlBackendCastTargetSyntax be)

Instances

Eq (BeamSqlBackendCastTargetSyntax be) => Eq (DataType be a)
Instance details Defined in Database.Beam.Query.DataTypes Methods (==) :: DataType be a -> DataType be a -> Bool # (/=) :: DataType be a -> DataType be a -> Bool #
Sql92DisplaySyntax (BeamSqlBackendCastTargetSyntax be) => Show (DataType be a)
Instance details Defined in Database.Beam.Query.DataTypes Methods showsPrec :: Int -> DataType be a -> ShowS # show :: DataType be a -> String # showList :: [DataType be a] -> ShowS #

newtype ExtractField be tgt a #

Constructors

ExtractField (Sql92ExtractFieldSyntax (BeamSqlBackendSyntax be))

class HasSqlDate tgt #

Instances

HasSqlDate LocalTime
Instance details Defined in Database.Beam.Query.Extract
HasSqlDate UTCTime
Instance details Defined in Database.Beam.Query.Extract
HasSqlDate Day
Instance details Defined in Database.Beam.Query.Extract

class HasSqlTime tgt #

Instances

HasSqlTime LocalTime
Instance details Defined in Database.Beam.Query.Extract
HasSqlTime TimeOfDay
Instance details Defined in Database.Beam.Query.Extract
HasSqlTime UTCTime
Instance details Defined in Database.Beam.Query.Extract

type Projectible be = ProjectibleWithPredicate AnyType be (WithExprContext (BeamSqlBackendExpressionSyntax' be)) #

data Q be (db :: (Type -> Type) -> Type) s a #

Instances

Monad (Q be db s)
Instance details Defined in Database.Beam.Query.Internal Methods (>>=) :: Q be db s a -> (a -> Q be db s b) -> Q be db s b # (>>) :: Q be db s a -> Q be db s b -> Q be db s b # return :: a -> Q be db s a # fail :: String -> Q be db s a #
Functor (Q be db s)
Instance details Defined in Database.Beam.Query.Internal Methods fmap :: (a -> b) -> Q be db s a -> Q be db s b # (<$) :: a -> Q be db s b -> Q be db s a #
Applicative (Q be db s)
Instance details Defined in Database.Beam.Query.Internal Methods pure :: a -> Q be db s a # (<>) :: Q be db s (a -> b) -> Q be db s a -> Q be db s b # liftA2 :: (a -> b -> c) -> Q be db s a -> Q be db s b -> Q be db s c # (>) :: Q be db s a -> Q be db s b -> Q be db s b # (<*) :: Q be db s a -> Q be db s b -> Q be db s a #

data QAggregateContext #

Instances

PgIsArrayContext QAggregateContext
Instance details Defined in Database.Beam.Postgres.PgSpecific Methods mkArraySyntax :: Proxy QAggregateContext -> PgSyntax -> PgSyntax
type ContextName QAggregateContext
Instance details Defined in Database.Beam.Query.Internal type ContextName QAggregateContext = "an aggregate"

data QAssignment be s #

Instances

Semigroup (QAssignment be s)
Instance details Defined in Database.Beam.Query.Internal Methods (<>) :: QAssignment be s -> QAssignment be s -> QAssignment be s # sconcat :: NonEmpty (QAssignment be s) -> QAssignment be s # stimes :: Integral b => b -> QAssignment be s -> QAssignment be s #
Monoid (QAssignment be s)
Instance details Defined in Database.Beam.Query.Internal Methods mempty :: QAssignment be s # mappend :: QAssignment be s -> QAssignment be s -> QAssignment be s # mconcat :: [QAssignment be s] -> QAssignment be s #

type QExpr = QGenExpr QValueContext #

data QField s ty #

Instances

Beamable t => ProjectibleWithPredicate AnyType () Text (t (QField s))
Instance details Defined in Database.Beam.Query.Internal Methods project' :: Monad m => Proxy AnyType -> Proxy ((), Text) -> (forall context. AnyType context => Proxy context -> Proxy () -> Text -> m Text) -> t (QField s) -> m (t (QField s)) projectSkeleton' :: Monad m => Proxy AnyType -> Proxy ((), Text) -> (forall context. AnyType context => Proxy context -> Proxy () -> m Text) -> m (t (QField s))
Beamable t => ProjectibleWithPredicate AnyType () Text (t (Nullable (QField s)))
Instance details Defined in Database.Beam.Query.Internal Methods project' :: Monad m => Proxy AnyType -> Proxy ((), Text) -> (forall context. AnyType context => Proxy context -> Proxy () -> Text -> m Text) -> t (Nullable (QField s)) -> m (t (Nullable (QField s))) projectSkeleton' :: Monad m => Proxy AnyType -> Proxy ((), Text) -> (forall context. AnyType context => Proxy context -> Proxy () -> m Text) -> m (t (Nullable (QField s)))
ProjectibleWithPredicate AnyType () Text (QField s a)
Instance details Defined in Database.Beam.Query.Internal Methods project' :: Monad m => Proxy AnyType -> Proxy ((), Text) -> (forall context. AnyType context => Proxy context -> Proxy () -> Text -> m Text) -> QField s a -> m (QField s a) projectSkeleton' :: Monad m => Proxy AnyType -> Proxy ((), Text) -> (forall context. AnyType context => Proxy context -> Proxy () -> m Text) -> m (QField s a)
(BeamSqlBackend be, Beamable tbl) => SqlUpdatable be s (tbl (QField s)) (tbl (QExpr be s))
Instance details Defined in Database.Beam.Query.Combinators Methods (<-.) :: tbl (QField s) -> tbl (QExpr be s) -> QAssignment be s #
(BeamSqlBackend be, Beamable tbl) => SqlUpdatable be s (tbl (Nullable (QField s))) (tbl (Nullable (QExpr be s)))
Instance details Defined in Database.Beam.Query.Combinators Methods (<-.) :: tbl (Nullable (QField s)) -> tbl (Nullable (QExpr be s)) -> QAssignment be s #
BeamSqlBackend be => SqlUpdatable be s (QField s a) (QExpr be s a)
Instance details Defined in Database.Beam.Query.Combinators Methods (<-.) :: QField s a -> QExpr be s a -> QAssignment be s #
Eq (QField s ty)
Instance details Defined in Database.Beam.Query.Internal Methods (==) :: QField s ty -> QField s ty -> Bool # (/=) :: QField s ty -> QField s ty -> Bool #
Ord (QField s ty)
Instance details Defined in Database.Beam.Query.Internal Methods compare :: QField s ty -> QField s ty -> Ordering # (<) :: QField s ty -> QField s ty -> Bool # (<=) :: QField s ty -> QField s ty -> Bool # (>) :: QField s ty -> QField s ty -> Bool # (>=) :: QField s ty -> QField s ty -> Bool # max :: QField s ty -> QField s ty -> QField s ty # min :: QField s ty -> QField s ty -> QField s ty #
Show (QField s ty)
Instance details Defined in Database.Beam.Query.Internal Methods showsPrec :: Int -> QField s ty -> ShowS # show :: QField s ty -> String # showList :: [QField s ty] -> ShowS #

data QFieldAssignment be (tbl :: (Type -> Type) -> Type) a #

newtype QGenExpr context be s t #

Constructors

QExpr (TablePrefix -> BeamSqlBackendExpressionSyntax be)

Instances

(BeamSqlBackend be, Beamable tbl) => SqlUpdatable be s (tbl (QField s)) (tbl (QExpr be s))
Instance details Defined in Database.Beam.Query.Combinators Methods (<-.) :: tbl (QField s) -> tbl (QExpr be s) -> QAssignment be s #
(BeamSqlBackend be, Beamable tbl) => SqlUpdatable be s (tbl (Nullable (QField s))) (tbl (Nullable (QExpr be s)))
Instance details Defined in Database.Beam.Query.Combinators Methods (<-.) :: tbl (Nullable (QField s)) -> tbl (Nullable (QExpr be s)) -> QAssignment be s #
(Beamable t, contextPredicate context) => ProjectibleWithPredicate contextPredicate be (WithExprContext (BeamSqlBackendExpressionSyntax' be)) (t (QGenExpr context be s))
Instance details Defined in Database.Beam.Query.Internal Methods project' :: Monad m => Proxy contextPredicate -> Proxy (be, WithExprContext (BeamSqlBackendExpressionSyntax' be)) -> (forall context0. contextPredicate context0 => Proxy context0 -> Proxy be -> WithExprContext (BeamSqlBackendExpressionSyntax' be) -> m (WithExprContext (BeamSqlBackendExpressionSyntax' be))) -> t (QGenExpr context be s) -> m (t (QGenExpr context be s)) projectSkeleton' :: Monad m => Proxy contextPredicate -> Proxy (be, WithExprContext (BeamSqlBackendExpressionSyntax' be)) -> (forall context0. contextPredicate context0 => Proxy context0 -> Proxy be -> m (WithExprContext (BeamSqlBackendExpressionSyntax' be))) -> m (t (QGenExpr context be s))
(Beamable t, contextPredicate context) => ProjectibleWithPredicate contextPredicate be (WithExprContext (BeamSqlBackendExpressionSyntax' be)) (t (Nullable (QGenExpr context be s)))
Instance details Defined in Database.Beam.Query.Internal Methods project' :: Monad m => Proxy contextPredicate -> Proxy (be, WithExprContext (BeamSqlBackendExpressionSyntax' be)) -> (forall context0. contextPredicate context0 => Proxy context0 -> Proxy be -> WithExprContext (BeamSqlBackendExpressionSyntax' be) -> m (WithExprContext (BeamSqlBackendExpressionSyntax' be))) -> t (Nullable (QGenExpr context be s)) -> m (t (Nullable (QGenExpr context be s))) projectSkeleton' :: Monad m => Proxy contextPredicate -> Proxy (be, WithExprContext (BeamSqlBackendExpressionSyntax' be)) -> (forall context0. contextPredicate context0 => Proxy context0 -> Proxy be -> m (WithExprContext (BeamSqlBackendExpressionSyntax' be))) -> m (t (Nullable (QGenExpr context be s)))
contextPredicate context => ProjectibleWithPredicate contextPredicate be (WithExprContext (BeamSqlBackendExpressionSyntax' be)) (QGenExpr context be s a)
Instance details Defined in Database.Beam.Query.Internal Methods project' :: Monad m => Proxy contextPredicate -> Proxy (be, WithExprContext (BeamSqlBackendExpressionSyntax' be)) -> (forall context0. contextPredicate context0 => Proxy context0 -> Proxy be -> WithExprContext (BeamSqlBackendExpressionSyntax' be) -> m (WithExprContext (BeamSqlBackendExpressionSyntax' be))) -> QGenExpr context be s a -> m (QGenExpr context be s a) projectSkeleton' :: Monad m => Proxy contextPredicate -> Proxy (be, WithExprContext (BeamSqlBackendExpressionSyntax' be)) -> (forall context0. contextPredicate context0 => Proxy context0 -> Proxy be -> m (WithExprContext (BeamSqlBackendExpressionSyntax' be))) -> m (QGenExpr context be s a)
BeamSqlBackend be => SqlUpdatable be s (QField s a) (QExpr be s a)
Instance details Defined in Database.Beam.Query.Combinators Methods (<-.) :: QField s a -> QExpr be s a -> QAssignment be s #
Beamable tbl => ThreadRewritable s (tbl (QGenExpr ctxt syntax s))
Instance details Defined in Database.Beam.Query.Internal Associated Types type WithRewrittenThread s s' (tbl (QGenExpr ctxt syntax s)) :: Type Methods rewriteThread :: Proxy s' -> tbl (QGenExpr ctxt syntax s) -> WithRewrittenThread s s' (tbl (QGenExpr ctxt syntax s))
Beamable tbl => ThreadRewritable s (tbl (Nullable (QGenExpr ctxt syntax s)))
Instance details Defined in Database.Beam.Query.Internal Associated Types type WithRewrittenThread s s' (tbl (Nullable (QGenExpr ctxt syntax s))) :: Type Methods rewriteThread :: Proxy s' -> tbl (Nullable (QGenExpr ctxt syntax s)) -> WithRewrittenThread s s' (tbl (Nullable (QGenExpr ctxt syntax s)))
(BeamSqlBackend be, Beamable t) => SqlDeconstructMaybe be (t (Nullable (QGenExpr ctxt be s))) (t (QGenExpr ctxt be s)) s
Instance details Defined in Database.Beam.Query.Combinators Methods isJust_ :: t (Nullable (QGenExpr ctxt be s)) -> QGenExpr ctxt0 be s Bool # isNothing_ :: t (Nullable (QGenExpr ctxt be s)) -> QGenExpr ctxt0 be s Bool # maybe_ :: QGenExpr ctxt0 be s y -> (t (QGenExpr ctxt be s) -> QGenExpr ctxt0 be s y) -> t (Nullable (QGenExpr ctxt be s)) -> QGenExpr ctxt0 be s y #
ThreadRewritable s (QGenExpr ctxt syntax s a)
Instance details Defined in Database.Beam.Query.Internal Associated Types type WithRewrittenThread s s' (QGenExpr ctxt syntax s a) :: Type Methods rewriteThread :: Proxy s' -> QGenExpr ctxt syntax s a -> WithRewrittenThread s s' (QGenExpr ctxt syntax s a)
BeamSqlBackend be => SqlDeconstructMaybe be (QGenExpr ctxt be s (Maybe x)) (QGenExpr ctxt be s x) s
Instance details Defined in Database.Beam.Query.Combinators Methods isJust_ :: QGenExpr ctxt be s (Maybe x) -> QGenExpr ctxt0 be s Bool # isNothing_ :: QGenExpr ctxt be s (Maybe x) -> QGenExpr ctxt0 be s Bool # maybe_ :: QGenExpr ctxt0 be s y -> (QGenExpr ctxt be s x -> QGenExpr ctxt0 be s y) -> QGenExpr ctxt be s (Maybe x) -> QGenExpr ctxt0 be s y #
(Beamable table, BeamSqlBackend be, FieldsFulfillConstraint (BeamSqlBackendCanSerialize be) table) => SqlValable (table (QGenExpr ctxt be s))
Instance details Defined in Database.Beam.Query.Combinators Methods val_ :: HaskellLiteralForQExpr (table (QGenExpr ctxt be s)) -> table (QGenExpr ctxt be s) #
(Beamable table, BeamSqlBackend be, FieldsFulfillConstraintNullable (BeamSqlBackendCanSerialize be) table) => SqlValable (table (Nullable (QGenExpr ctxt be s)))
Instance details Defined in Database.Beam.Query.Combinators Methods val_ :: HaskellLiteralForQExpr (table (Nullable (QGenExpr ctxt be s))) -> table (Nullable (QGenExpr ctxt be s)) #
Beamable tbl => ContextRewritable (tbl (QGenExpr old syntax s))
Instance details Defined in Database.Beam.Query.Internal Associated Types type WithRewrittenContext (tbl (QGenExpr old syntax s)) ctxt :: Type Methods rewriteContext :: Proxy ctxt -> tbl (QGenExpr old syntax s) -> WithRewrittenContext (tbl (QGenExpr old syntax s)) ctxt
Beamable tbl => ContextRewritable (tbl (Nullable (QGenExpr old syntax s)))
Instance details Defined in Database.Beam.Query.Internal Associated Types type WithRewrittenContext (tbl (Nullable (QGenExpr old syntax s))) ctxt :: Type Methods rewriteContext :: Proxy ctxt -> tbl (Nullable (QGenExpr old syntax s)) -> WithRewrittenContext (tbl (Nullable (QGenExpr old syntax s))) ctxt
Beamable tbl => QGroupable (tbl (QExpr be s)) (tbl (QGroupExpr be s))
Instance details Defined in Database.Beam.Query.Aggregate Methods group_ :: tbl (QExpr be s) -> tbl (QGroupExpr be s) #
Beamable tbl => QGroupable (tbl (Nullable (QExpr be s))) (tbl (Nullable (QGroupExpr be s)))
Instance details Defined in Database.Beam.Query.Aggregate Methods group_ :: tbl (Nullable (QExpr be s)) -> tbl (Nullable (QGroupExpr be s)) #
(Table t, BeamSqlBackend be) => SqlJustable (t (QExpr be s)) (t (Nullable (QExpr be s)))
Instance details Defined in Database.Beam.Query.Combinators Methods just_ :: t (QExpr be s) -> t (Nullable (QExpr be s)) # nothing_ :: t (Nullable (QExpr be s)) #
BeamSqlBackendHasCustomSyntax be => IsCustomExprFn (CustomSqlSnippet be) (QGenExpr ctxt be s res)
Instance details Defined in Database.Beam.Query.CustomSQL Methods customExpr_ :: CustomSqlSnippet be -> QGenExpr ctxt be s res #
(Table t, BeamSqlBackend be) => SqlJustable (PrimaryKey t (QExpr be s)) (PrimaryKey t (Nullable (QExpr be s)))
Instance details Defined in Database.Beam.Query.Combinators Methods just_ :: PrimaryKey t (QExpr be s) -> PrimaryKey t (Nullable (QExpr be s)) # nothing_ :: PrimaryKey t (Nullable (QExpr be s)) #
(IsCustomExprFn a res, BeamSqlBackendHasCustomSyntax be) => IsCustomExprFn (CustomSqlSnippet be -> a) (QGenExpr ctxt be s r -> res)
Instance details Defined in Database.Beam.Query.CustomSQL Methods customExpr_ :: (CustomSqlSnippet be -> a) -> QGenExpr ctxt be s r -> res #
(BeamSqlBackend be, Beamable tbl, FieldsFulfillConstraint (HasSqlEqualityCheck be) tbl) => SqlEq (QGenExpr context be s) (tbl (QGenExpr context be s))
Instance details Defined in Database.Beam.Query.Ord Methods (==.) :: tbl (QGenExpr context be s) -> tbl (QGenExpr context be s) -> QGenExpr context be s Bool # (/=.) :: tbl (QGenExpr context be s) -> tbl (QGenExpr context be s) -> QGenExpr context be s Bool # (==?.) :: tbl (QGenExpr context be s) -> tbl (QGenExpr context be s) -> QGenExpr context be s SqlBool # (/=?.) :: tbl (QGenExpr context be s) -> tbl (QGenExpr context be s) -> QGenExpr context be s SqlBool #
(BeamSqlBackend be, Beamable tbl, FieldsFulfillConstraintNullable (HasSqlEqualityCheck be) tbl) => SqlEq (QGenExpr context be s) (tbl (Nullable (QGenExpr context be s)))
Instance details Defined in Database.Beam.Query.Ord Methods (==.) :: tbl (Nullable (QGenExpr context be s)) -> tbl (Nullable (QGenExpr context be s)) -> QGenExpr context be s Bool # (/=.) :: tbl (Nullable (QGenExpr context be s)) -> tbl (Nullable (QGenExpr context be s)) -> QGenExpr context be s Bool # (==?.) :: tbl (Nullable (QGenExpr context be s)) -> tbl (Nullable (QGenExpr context be s)) -> QGenExpr context be s SqlBool # (/=?.) :: tbl (Nullable (QGenExpr context be s)) -> tbl (Nullable (QGenExpr context be s)) -> QGenExpr context be s SqlBool #
QGroupable (QExpr be s a) (QGroupExpr be s a)
Instance details Defined in Database.Beam.Query.Aggregate Methods group_ :: QExpr be s a -> QGroupExpr be s a #
BeamSqlBackend be => SqlJustable (QExpr be s a) (QExpr be s (Maybe a))
Instance details Defined in Database.Beam.Query.Combinators Methods just_ :: QExpr be s a -> QExpr be s (Maybe a) # nothing_ :: QExpr be s (Maybe a) #
(BeamSqlBackend be, HasSqlQuantifiedEqualityCheck be a) => SqlEqQuantified (QGenExpr context be s) (QQuantified be s a) (QGenExpr context be s a)
Instance details Defined in Database.Beam.Query.Ord Methods (==.) :: QGenExpr context be s a -> QQuantified be s a -> QGenExpr context be s SqlBool # (/=.) :: QGenExpr context be s a -> QQuantified be s a -> QGenExpr context be s SqlBool #
BeamSqlBackend be => SqlOrdQuantified (QGenExpr context be s) (QQuantified be s a) (QGenExpr context be s a)
Instance details Defined in Database.Beam.Query.Ord Methods (<.) :: QGenExpr context be s a -> QQuantified be s a -> QGenExpr context be s Bool # (>.) :: QGenExpr context be s a -> QQuantified be s a -> QGenExpr context be s Bool # (<=.) :: QGenExpr context be s a -> QQuantified be s a -> QGenExpr context be s Bool # (>=.) :: QGenExpr context be s a -> QQuantified be s a -> QGenExpr context be s Bool #
(BeamSqlBackend be, HasSqlEqualityCheck be a) => SqlEq (QGenExpr context be s) (QGenExpr context be s a)
Instance details Defined in Database.Beam.Query.Ord Methods (==.) :: QGenExpr context be s a -> QGenExpr context be s a -> QGenExpr context be s Bool # (/=.) :: QGenExpr context be s a -> QGenExpr context be s a -> QGenExpr context be s Bool # (==?.) :: QGenExpr context be s a -> QGenExpr context be s a -> QGenExpr context be s SqlBool # (/=?.) :: QGenExpr context be s a -> QGenExpr context be s a -> QGenExpr context be s SqlBool #
BeamSqlBackend be => SqlOrd (QGenExpr context be s) (QGenExpr context be s a)
Instance details Defined in Database.Beam.Query.Ord Methods (<.) :: QGenExpr context be s a -> QGenExpr context be s a -> QGenExpr context be s Bool # (>.) :: QGenExpr context be s a -> QGenExpr context be s a -> QGenExpr context be s Bool # (<=.) :: QGenExpr context be s a -> QGenExpr context be s a -> QGenExpr context be s Bool # (>=.) :: QGenExpr context be s a -> QGenExpr context be s a -> QGenExpr context be s Bool #
Retaggable (QGenExpr ctxt expr s) (QGenExpr ctxt expr s t)
Instance details Defined in Database.Beam.Query.Internal Associated Types type Retag tag (QGenExpr ctxt expr s t) :: Type Methods retag :: (forall a. Columnar' (QGenExpr ctxt expr s) a -> Columnar' (tag (QGenExpr ctxt expr s)) a) -> QGenExpr ctxt expr s t -> Retag tag (QGenExpr ctxt expr s t)
BeamSqlBackend be => Eq (QGenExpr context be s t)
Instance details Defined in Database.Beam.Query.Internal Methods (==) :: QGenExpr context be s t -> QGenExpr context be s t -> Bool # (/=) :: QGenExpr context be s t -> QGenExpr context be s t -> Bool #
(Fractional a, BeamSqlBackend be, BeamSqlBackendCanSerialize be a) => Fractional (QGenExpr context be s a)
Instance details Defined in Database.Beam.Query.Internal Methods (/) :: QGenExpr context be s a -> QGenExpr context be s a -> QGenExpr context be s a # recip :: QGenExpr context be s a -> QGenExpr context be s a # fromRational :: Rational -> QGenExpr context be s a #
(Num a, BeamSqlBackend be, BeamSqlBackendCanSerialize be a) => Num (QGenExpr context be s a)
Instance details Defined in Database.Beam.Query.Internal Methods (+) :: QGenExpr context be s a -> QGenExpr context be s a -> QGenExpr context be s a # (-) :: QGenExpr context be s a -> QGenExpr context be s a -> QGenExpr context be s a # (*) :: QGenExpr context be s a -> QGenExpr context be s a -> QGenExpr context be s a # negate :: QGenExpr context be s a -> QGenExpr context be s a # abs :: QGenExpr context be s a -> QGenExpr context be s a # signum :: QGenExpr context be s a -> QGenExpr context be s a # fromInteger :: Integer -> QGenExpr context be s a #
(BeamSqlBackend backend, BeamSqlBackendCanSerialize backend [Char]) => IsString (QGenExpr context backend s Text)
Instance details Defined in Database.Beam.Query.Internal Methods fromString :: String -> QGenExpr context backend s Text #
(BeamSqlBackendCanSerialize be a, BeamSqlBackend be) => SqlValable (QGenExpr ctxt be s a)
Instance details Defined in Database.Beam.Query.Combinators Methods val_ :: HaskellLiteralForQExpr (QGenExpr ctxt be s a) -> QGenExpr ctxt be s a #
ContextRewritable (QGenExpr old syntax s a)
Instance details Defined in Database.Beam.Query.Internal Associated Types type WithRewrittenContext (QGenExpr old syntax s a) ctxt :: Type Methods rewriteContext :: Proxy ctxt -> QGenExpr old syntax s a -> WithRewrittenContext (QGenExpr old syntax s a) ctxt
type WithRewrittenThread s s' (tbl (Nullable (QGenExpr ctxt syntax s)))
Instance details Defined in Database.Beam.Query.Internal type WithRewrittenThread s s' (tbl (Nullable (QGenExpr ctxt syntax s))) = tbl (Nullable (QGenExpr ctxt syntax s'))
type WithRewrittenThread s s' (tbl (QGenExpr ctxt syntax s))
Instance details Defined in Database.Beam.Query.Internal type WithRewrittenThread s s' (tbl (QGenExpr ctxt syntax s)) = tbl (QGenExpr ctxt syntax s')
type WithRewrittenThread s s' (QGenExpr ctxt syntax s a)
Instance details Defined in Database.Beam.Query.Internal type WithRewrittenThread s s' (QGenExpr ctxt syntax s a) = QGenExpr ctxt syntax s' a
type Retag tag (QGenExpr ctxt expr s t)
Instance details Defined in Database.Beam.Query.Internal type Retag tag (QGenExpr ctxt expr s t) = Columnar (tag (QGenExpr ctxt expr s)) t
type HaskellLiteralForQExpr (table (QGenExpr context be s))
Instance details Defined in Database.Beam.Query.Combinators type HaskellLiteralForQExpr (table (QGenExpr context be s)) = table Identity
type QExprToField (table (Nullable (QGenExpr context syntax s)))
Instance details Defined in Database.Beam.Query.Types type QExprToField (table (Nullable (QGenExpr context syntax s))) = table (Nullable (QField s))
type QExprToField (table (QGenExpr context syntax s))
Instance details Defined in Database.Beam.Query.Types type QExprToField (table (QGenExpr context syntax s)) = table (QField s)
type QExprToIdentity (table (QGenExpr context syntax s))
Instance details Defined in Database.Beam.Query.Types type QExprToIdentity (table (QGenExpr context syntax s)) = table Identity
type WithRewrittenContext (tbl (Nullable (QGenExpr old syntax s))) ctxt
Instance details Defined in Database.Beam.Query.Internal type WithRewrittenContext (tbl (Nullable (QGenExpr old syntax s))) ctxt = tbl (Nullable (QGenExpr ctxt syntax s))
type WithRewrittenContext (tbl (QGenExpr old syntax s)) ctxt
Instance details Defined in Database.Beam.Query.Internal type WithRewrittenContext (tbl (QGenExpr old syntax s)) ctxt = tbl (QGenExpr ctxt syntax s)
type HaskellLiteralForQExpr (QGenExpr context be s a)
Instance details Defined in Database.Beam.Query.Combinators type HaskellLiteralForQExpr (QGenExpr context be s a) = a
type QExprToField (QGenExpr ctxt syntax s a)
Instance details Defined in Database.Beam.Query.Types type QExprToField (QGenExpr ctxt syntax s a) = QField s a
type QExprToIdentity (QGenExpr context syntax s a)
Instance details Defined in Database.Beam.Query.Types type QExprToIdentity (QGenExpr context syntax s a) = a
type WithRewrittenContext (QGenExpr old syntax s a) ctxt
Instance details Defined in Database.Beam.Query.Internal type WithRewrittenContext (QGenExpr old syntax s a) ctxt = QGenExpr ctxt syntax s a

data QGroupingContext #

Instances

Beamable tbl => QGroupable (tbl (QExpr be s)) (tbl (QGroupExpr be s))
Instance details Defined in Database.Beam.Query.Aggregate Methods group_ :: tbl (QExpr be s) -> tbl (QGroupExpr be s) #
Beamable tbl => QGroupable (tbl (Nullable (QExpr be s))) (tbl (Nullable (QGroupExpr be s)))
Instance details Defined in Database.Beam.Query.Aggregate Methods group_ :: tbl (Nullable (QExpr be s)) -> tbl (Nullable (QGroupExpr be s)) #
QGroupable (QExpr be s a) (QGroupExpr be s a)
Instance details Defined in Database.Beam.Query.Aggregate Methods group_ :: QExpr be s a -> QGroupExpr be s a #
type ContextName QGroupingContext
Instance details Defined in Database.Beam.Query.Internal type ContextName QGroupingContext = "an aggregate grouping"

data QValueContext #

Instances

(BeamSqlBackend be, Beamable tbl) => SqlUpdatable be s (tbl (QField s)) (tbl (QExpr be s))
Instance details Defined in Database.Beam.Query.Combinators Methods (<-.) :: tbl (QField s) -> tbl (QExpr be s) -> QAssignment be s #
(BeamSqlBackend be, Beamable tbl) => SqlUpdatable be s (tbl (Nullable (QField s))) (tbl (Nullable (QExpr be s)))
Instance details Defined in Database.Beam.Query.Combinators Methods (<-.) :: tbl (Nullable (QField s)) -> tbl (Nullable (QExpr be s)) -> QAssignment be s #
BeamSqlBackend be => SqlUpdatable be s (QField s a) (QExpr be s a)
Instance details Defined in Database.Beam.Query.Combinators Methods (<-.) :: QField s a -> QExpr be s a -> QAssignment be s #
PgIsArrayContext QValueContext
Instance details Defined in Database.Beam.Postgres.PgSpecific Methods mkArraySyntax :: Proxy QValueContext -> PgSyntax -> PgSyntax
Beamable tbl => QGroupable (tbl (QExpr be s)) (tbl (QGroupExpr be s))
Instance details Defined in Database.Beam.Query.Aggregate Methods group_ :: tbl (QExpr be s) -> tbl (QGroupExpr be s) #
Beamable tbl => QGroupable (tbl (Nullable (QExpr be s))) (tbl (Nullable (QGroupExpr be s)))
Instance details Defined in Database.Beam.Query.Aggregate Methods group_ :: tbl (Nullable (QExpr be s)) -> tbl (Nullable (QGroupExpr be s)) #
(Table t, BeamSqlBackend be) => SqlJustable (t (QExpr be s)) (t (Nullable (QExpr be s)))
Instance details Defined in Database.Beam.Query.Combinators Methods just_ :: t (QExpr be s) -> t (Nullable (QExpr be s)) # nothing_ :: t (Nullable (QExpr be s)) #
(Table t, BeamSqlBackend be) => SqlJustable (PrimaryKey t (QExpr be s)) (PrimaryKey t (Nullable (QExpr be s)))
Instance details Defined in Database.Beam.Query.Combinators Methods just_ :: PrimaryKey t (QExpr be s) -> PrimaryKey t (Nullable (QExpr be s)) # nothing_ :: PrimaryKey t (Nullable (QExpr be s)) #
QGroupable (QExpr be s a) (QGroupExpr be s a)
Instance details Defined in Database.Beam.Query.Aggregate Methods group_ :: QExpr be s a -> QGroupExpr be s a #
BeamSqlBackend be => SqlJustable (QExpr be s a) (QExpr be s (Maybe a))
Instance details Defined in Database.Beam.Query.Combinators Methods just_ :: QExpr be s a -> QExpr be s (Maybe a) # nothing_ :: QExpr be s (Maybe a) #
type ContextName QValueContext
Instance details Defined in Database.Beam.Query.Internal type ContextName QValueContext = "a value"

data QWindow be s #

Instances

contextPredicate QWindowFrameContext => ProjectibleWithPredicate contextPredicate be (WithExprContext (BeamSqlBackendWindowFrameSyntax' be)) (QWindow be s)

Instance details

Defined in Database.Beam.Query.Internal

Methods

project' :: Monad m => Proxy contextPredicate -> Proxy (be, WithExprContext (BeamSqlBackendWindowFrameSyntax' be)) -> (forall context. contextPredicate context => Proxy context -> Proxy be -> WithExprContext (BeamSqlBackendWindowFrameSyntax' be) -> m (WithExprContext (BeamSqlBackendWindowFrameSyntax' be))) -> QWindow be s -> m (QWindow be s)

projectSkeleton' :: Monad m => Proxy contextPredicate -> Proxy (be, WithExprContext (BeamSqlBackendWindowFrameSyntax' be)) -> (forall context. contextPredicate context => Proxy context -> Proxy be -> m (WithExprContext (BeamSqlBackendWindowFrameSyntax' be))) -> m (QWindow be s)

data QWindowFrameContext #

Instances

type ContextName QWindowFrameContext
Instance details Defined in Database.Beam.Query.Internal type ContextName QWindowFrameContext = "a window frame"

data QWindowingContext #

Instances

PgIsArrayContext QWindowingContext
Instance details Defined in Database.Beam.Postgres.PgSpecific Methods mkArraySyntax :: Proxy QWindowingContext -> PgSyntax -> PgSyntax
type ContextName QWindowingContext
Instance details Defined in Database.Beam.Query.Internal type ContextName QWindowingContext = "a window expression"

data SqlBool #

class BeamSqlBackend be => HasSqlEqualityCheck be a where #

Minimal complete definition

Nothing

Methods

sqlEqE :: Proxy a -> Proxy be -> BeamSqlBackendExpressionSyntax be -> BeamSqlBackendExpressionSyntax be -> BeamSqlBackendExpressionSyntax be #

sqlNeqE :: Proxy a -> Proxy be -> BeamSqlBackendExpressionSyntax be -> BeamSqlBackendExpressionSyntax be -> BeamSqlBackendExpressionSyntax be #

sqlEqTriE :: Proxy a -> Proxy be -> BeamSqlBackendExpressionSyntax be -> BeamSqlBackendExpressionSyntax be -> BeamSqlBackendExpressionSyntax be #

sqlNeqTriE :: Proxy a -> Proxy be -> BeamSqlBackendExpressionSyntax be -> BeamSqlBackendExpressionSyntax be -> BeamSqlBackendExpressionSyntax be #

Instances

HasSqlEqualityCheck Postgres Bool
Instance details Defined in Database.Beam.Postgres.Types Methods sqlEqE :: Proxy Bool -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqE :: Proxy Bool -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlEqTriE :: Proxy Bool -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqTriE :: Proxy Bool -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlEqualityCheck Postgres Double
Instance details Defined in Database.Beam.Postgres.Types Methods sqlEqE :: Proxy Double -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqE :: Proxy Double -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlEqTriE :: Proxy Double -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqTriE :: Proxy Double -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlEqualityCheck Postgres Float
Instance details Defined in Database.Beam.Postgres.Types Methods sqlEqE :: Proxy Float -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqE :: Proxy Float -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlEqTriE :: Proxy Float -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqTriE :: Proxy Float -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlEqualityCheck Postgres Int
Instance details Defined in Database.Beam.Postgres.Types Methods sqlEqE :: Proxy Int -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqE :: Proxy Int -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlEqTriE :: Proxy Int -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqTriE :: Proxy Int -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlEqualityCheck Postgres Int8
Instance details Defined in Database.Beam.Postgres.Types Methods sqlEqE :: Proxy Int8 -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqE :: Proxy Int8 -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlEqTriE :: Proxy Int8 -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqTriE :: Proxy Int8 -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlEqualityCheck Postgres Int16
Instance details Defined in Database.Beam.Postgres.Types Methods sqlEqE :: Proxy Int16 -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqE :: Proxy Int16 -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlEqTriE :: Proxy Int16 -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqTriE :: Proxy Int16 -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlEqualityCheck Postgres Int32
Instance details Defined in Database.Beam.Postgres.Types Methods sqlEqE :: Proxy Int32 -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqE :: Proxy Int32 -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlEqTriE :: Proxy Int32 -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqTriE :: Proxy Int32 -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlEqualityCheck Postgres Int64
Instance details Defined in Database.Beam.Postgres.Types Methods sqlEqE :: Proxy Int64 -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqE :: Proxy Int64 -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlEqTriE :: Proxy Int64 -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqTriE :: Proxy Int64 -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlEqualityCheck Postgres Integer
Instance details Defined in Database.Beam.Postgres.Types Methods sqlEqE :: Proxy Integer -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqE :: Proxy Integer -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlEqTriE :: Proxy Integer -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqTriE :: Proxy Integer -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlEqualityCheck Postgres Word
Instance details Defined in Database.Beam.Postgres.Types Methods sqlEqE :: Proxy Word -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqE :: Proxy Word -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlEqTriE :: Proxy Word -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqTriE :: Proxy Word -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlEqualityCheck Postgres Word8
Instance details Defined in Database.Beam.Postgres.Types Methods sqlEqE :: Proxy Word8 -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqE :: Proxy Word8 -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlEqTriE :: Proxy Word8 -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqTriE :: Proxy Word8 -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlEqualityCheck Postgres Word16
Instance details Defined in Database.Beam.Postgres.Types Methods sqlEqE :: Proxy Word16 -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqE :: Proxy Word16 -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlEqTriE :: Proxy Word16 -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqTriE :: Proxy Word16 -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlEqualityCheck Postgres Word32
Instance details Defined in Database.Beam.Postgres.Types Methods sqlEqE :: Proxy Word32 -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqE :: Proxy Word32 -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlEqTriE :: Proxy Word32 -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqTriE :: Proxy Word32 -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlEqualityCheck Postgres Word64
Instance details Defined in Database.Beam.Postgres.Types Methods sqlEqE :: Proxy Word64 -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqE :: Proxy Word64 -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlEqTriE :: Proxy Word64 -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqTriE :: Proxy Word64 -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlEqualityCheck Postgres ByteString
Instance details Defined in Database.Beam.Postgres.Types Methods sqlEqE :: Proxy ByteString -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqE :: Proxy ByteString -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlEqTriE :: Proxy ByteString -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqTriE :: Proxy ByteString -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlEqualityCheck Postgres ByteString
Instance details Defined in Database.Beam.Postgres.Types Methods sqlEqE :: Proxy ByteString -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqE :: Proxy ByteString -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlEqTriE :: Proxy ByteString -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqTriE :: Proxy ByteString -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlEqualityCheck Postgres Text
Instance details Defined in Database.Beam.Postgres.Types Methods sqlEqE :: Proxy Text -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqE :: Proxy Text -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlEqTriE :: Proxy Text -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqTriE :: Proxy Text -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlEqualityCheck Postgres Text
Instance details Defined in Database.Beam.Postgres.Types Methods sqlEqE :: Proxy Text -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqE :: Proxy Text -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlEqTriE :: Proxy Text -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqTriE :: Proxy Text -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlEqualityCheck Postgres ZonedTime
Instance details Defined in Database.Beam.Postgres.Types Methods sqlEqE :: Proxy ZonedTime -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqE :: Proxy ZonedTime -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlEqTriE :: Proxy ZonedTime -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqTriE :: Proxy ZonedTime -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlEqualityCheck Postgres LocalTime
Instance details Defined in Database.Beam.Postgres.Types Methods sqlEqE :: Proxy LocalTime -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqE :: Proxy LocalTime -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlEqTriE :: Proxy LocalTime -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqTriE :: Proxy LocalTime -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlEqualityCheck Postgres TimeOfDay
Instance details Defined in Database.Beam.Postgres.Types Methods sqlEqE :: Proxy TimeOfDay -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqE :: Proxy TimeOfDay -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlEqTriE :: Proxy TimeOfDay -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqTriE :: Proxy TimeOfDay -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlEqualityCheck Postgres UTCTime
Instance details Defined in Database.Beam.Postgres.Types Methods sqlEqE :: Proxy UTCTime -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqE :: Proxy UTCTime -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlEqTriE :: Proxy UTCTime -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqTriE :: Proxy UTCTime -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlEqualityCheck Postgres NominalDiffTime
Instance details Defined in Database.Beam.Postgres.Types Methods sqlEqE :: Proxy NominalDiffTime -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqE :: Proxy NominalDiffTime -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlEqTriE :: Proxy NominalDiffTime -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqTriE :: Proxy NominalDiffTime -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlEqualityCheck Postgres Day
Instance details Defined in Database.Beam.Postgres.Types Methods sqlEqE :: Proxy Day -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqE :: Proxy Day -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlEqTriE :: Proxy Day -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqTriE :: Proxy Day -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlEqualityCheck Postgres Scientific
Instance details Defined in Database.Beam.Postgres.Types Methods sqlEqE :: Proxy Scientific -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqE :: Proxy Scientific -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlEqTriE :: Proxy Scientific -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqTriE :: Proxy Scientific -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlEqualityCheck Postgres Value
Instance details Defined in Database.Beam.Postgres.Types Methods sqlEqE :: Proxy Value -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqE :: Proxy Value -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlEqTriE :: Proxy Value -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqTriE :: Proxy Value -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlEqualityCheck Postgres UUID
Instance details Defined in Database.Beam.Postgres.Types Methods sqlEqE :: Proxy UUID -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqE :: Proxy UUID -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlEqTriE :: Proxy UUID -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqTriE :: Proxy UUID -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlEqualityCheck Postgres PgMoney
Instance details Defined in Database.Beam.Postgres.PgSpecific Methods sqlEqE :: Proxy PgMoney -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqE :: Proxy PgMoney -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlEqTriE :: Proxy PgMoney -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqTriE :: Proxy PgMoney -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlEqualityCheck Postgres TsQuery
Instance details Defined in Database.Beam.Postgres.PgSpecific Methods sqlEqE :: Proxy TsQuery -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqE :: Proxy TsQuery -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlEqTriE :: Proxy TsQuery -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqTriE :: Proxy TsQuery -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlEqualityCheck Postgres TsVector
Instance details Defined in Database.Beam.Postgres.PgSpecific Methods sqlEqE :: Proxy TsVector -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqE :: Proxy TsVector -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlEqTriE :: Proxy TsVector -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqTriE :: Proxy TsVector -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlEqualityCheck Postgres TsVectorConfig
Instance details Defined in Database.Beam.Postgres.PgSpecific Methods sqlEqE :: Proxy TsVectorConfig -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqE :: Proxy TsVectorConfig -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlEqTriE :: Proxy TsVectorConfig -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqTriE :: Proxy TsVectorConfig -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlEqualityCheck Postgres Oid
Instance details Defined in Database.Beam.Postgres.Types Methods sqlEqE :: Proxy Oid -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqE :: Proxy Oid -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlEqTriE :: Proxy Oid -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqTriE :: Proxy Oid -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlEqualityCheck Postgres HStoreList
Instance details Defined in Database.Beam.Postgres.Types Methods sqlEqE :: Proxy HStoreList -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqE :: Proxy HStoreList -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlEqTriE :: Proxy HStoreList -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqTriE :: Proxy HStoreList -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlEqualityCheck Postgres HStoreMap
Instance details Defined in Database.Beam.Postgres.Types Methods sqlEqE :: Proxy HStoreMap -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqE :: Proxy HStoreMap -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlEqTriE :: Proxy HStoreMap -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqTriE :: Proxy HStoreMap -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlEqualityCheck Postgres LocalTimestamp
Instance details Defined in Database.Beam.Postgres.Types Methods sqlEqE :: Proxy LocalTimestamp -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqE :: Proxy LocalTimestamp -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlEqTriE :: Proxy LocalTimestamp -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqTriE :: Proxy LocalTimestamp -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlEqualityCheck Postgres UTCTimestamp
Instance details Defined in Database.Beam.Postgres.Types Methods sqlEqE :: Proxy UTCTimestamp -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqE :: Proxy UTCTimestamp -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlEqTriE :: Proxy UTCTimestamp -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqTriE :: Proxy UTCTimestamp -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlEqualityCheck Postgres ZonedTimestamp
Instance details Defined in Database.Beam.Postgres.Types Methods sqlEqE :: Proxy ZonedTimestamp -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqE :: Proxy ZonedTimestamp -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlEqTriE :: Proxy ZonedTimestamp -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqTriE :: Proxy ZonedTimestamp -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlEqualityCheck Postgres Date
Instance details Defined in Database.Beam.Postgres.Types Methods sqlEqE :: Proxy Date -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqE :: Proxy Date -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlEqTriE :: Proxy Date -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqTriE :: Proxy Date -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlEqualityCheck be a => HasSqlEqualityCheck be (SqlSerial a)
Instance details Defined in Database.Beam.Query.Ord Methods sqlEqE :: Proxy (SqlSerial a) -> Proxy be -> BeamSqlBackendExpressionSyntax be -> BeamSqlBackendExpressionSyntax be -> BeamSqlBackendExpressionSyntax be # sqlNeqE :: Proxy (SqlSerial a) -> Proxy be -> BeamSqlBackendExpressionSyntax be -> BeamSqlBackendExpressionSyntax be -> BeamSqlBackendExpressionSyntax be # sqlEqTriE :: Proxy (SqlSerial a) -> Proxy be -> BeamSqlBackendExpressionSyntax be -> BeamSqlBackendExpressionSyntax be -> BeamSqlBackendExpressionSyntax be # sqlNeqTriE :: Proxy (SqlSerial a) -> Proxy be -> BeamSqlBackendExpressionSyntax be -> BeamSqlBackendExpressionSyntax be -> BeamSqlBackendExpressionSyntax be #
(HasSqlEqualityCheck be a, CanCheckMaybeEquality a) => HasSqlEqualityCheck be (Maybe a)
Instance details Defined in Database.Beam.Query.Ord Methods sqlEqE :: Proxy (Maybe a) -> Proxy be -> BeamSqlBackendExpressionSyntax be -> BeamSqlBackendExpressionSyntax be -> BeamSqlBackendExpressionSyntax be # sqlNeqE :: Proxy (Maybe a) -> Proxy be -> BeamSqlBackendExpressionSyntax be -> BeamSqlBackendExpressionSyntax be -> BeamSqlBackendExpressionSyntax be # sqlEqTriE :: Proxy (Maybe a) -> Proxy be -> BeamSqlBackendExpressionSyntax be -> BeamSqlBackendExpressionSyntax be -> BeamSqlBackendExpressionSyntax be # sqlNeqTriE :: Proxy (Maybe a) -> Proxy be -> BeamSqlBackendExpressionSyntax be -> BeamSqlBackendExpressionSyntax be -> BeamSqlBackendExpressionSyntax be #
HasSqlEqualityCheck Postgres [Char]
Instance details Defined in Database.Beam.Postgres.Types Methods sqlEqE :: Proxy [Char] -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqE :: Proxy [Char] -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlEqTriE :: Proxy [Char] -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqTriE :: Proxy [Char] -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlEqualityCheck Postgres (Vector a)
Instance details Defined in Database.Beam.Postgres.Types Methods sqlEqE :: Proxy (Vector a) -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqE :: Proxy (Vector a) -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlEqTriE :: Proxy (Vector a) -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqTriE :: Proxy (Vector a) -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlEqualityCheck Postgres (CI Text)
Instance details Defined in Database.Beam.Postgres.Types Methods sqlEqE :: Proxy (CI Text) -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqE :: Proxy (CI Text) -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlEqTriE :: Proxy (CI Text) -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqTriE :: Proxy (CI Text) -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlEqualityCheck Postgres (CI Text)
Instance details Defined in Database.Beam.Postgres.Types Methods sqlEqE :: Proxy (CI Text) -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqE :: Proxy (CI Text) -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlEqTriE :: Proxy (CI Text) -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqTriE :: Proxy (CI Text) -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlEqualityCheck Postgres (PgJSON a)
Instance details Defined in Database.Beam.Postgres.PgSpecific Methods sqlEqE :: Proxy (PgJSON a) -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqE :: Proxy (PgJSON a) -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlEqTriE :: Proxy (PgJSON a) -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqTriE :: Proxy (PgJSON a) -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlEqualityCheck Postgres (PgJSONB a)
Instance details Defined in Database.Beam.Postgres.PgSpecific Methods sqlEqE :: Proxy (PgJSONB a) -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqE :: Proxy (PgJSONB a) -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlEqTriE :: Proxy (PgJSONB a) -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqTriE :: Proxy (PgJSONB a) -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlEqualityCheck Postgres (PgRange n a)
Instance details Defined in Database.Beam.Postgres.PgSpecific Methods sqlEqE :: Proxy (PgRange n a) -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqE :: Proxy (PgRange n a) -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlEqTriE :: Proxy (PgRange n a) -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqTriE :: Proxy (PgRange n a) -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlEqualityCheck Postgres a => HasSqlEqualityCheck Postgres (Tagged t a)
Instance details Defined in Database.Beam.Postgres.Types Methods sqlEqE :: Proxy (Tagged t a) -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqE :: Proxy (Tagged t a) -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlEqTriE :: Proxy (Tagged t a) -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlNeqTriE :: Proxy (Tagged t a) -> Proxy Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
BeamSqlBackend (MockSqlBackend cmd) => HasSqlEqualityCheck (MockSqlBackend cmd) Word8
Instance details Defined in Database.Beam.Query.Ord Methods sqlEqE :: Proxy Word8 -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) # sqlNeqE :: Proxy Word8 -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) # sqlEqTriE :: Proxy Word8 -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) # sqlNeqTriE :: Proxy Word8 -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) #
BeamSqlBackend (MockSqlBackend cmd) => HasSqlEqualityCheck (MockSqlBackend cmd) Word64
Instance details Defined in Database.Beam.Query.Ord Methods sqlEqE :: Proxy Word64 -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) # sqlNeqE :: Proxy Word64 -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) # sqlEqTriE :: Proxy Word64 -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) # sqlNeqTriE :: Proxy Word64 -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) #
BeamSqlBackend (MockSqlBackend cmd) => HasSqlEqualityCheck (MockSqlBackend cmd) Word32
Instance details Defined in Database.Beam.Query.Ord Methods sqlEqE :: Proxy Word32 -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) # sqlNeqE :: Proxy Word32 -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) # sqlEqTriE :: Proxy Word32 -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) # sqlNeqTriE :: Proxy Word32 -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) #
BeamSqlBackend (MockSqlBackend cmd) => HasSqlEqualityCheck (MockSqlBackend cmd) Word16
Instance details Defined in Database.Beam.Query.Ord Methods sqlEqE :: Proxy Word16 -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) # sqlNeqE :: Proxy Word16 -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) # sqlEqTriE :: Proxy Word16 -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) # sqlNeqTriE :: Proxy Word16 -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) #
BeamSqlBackend (MockSqlBackend cmd) => HasSqlEqualityCheck (MockSqlBackend cmd) Word
Instance details Defined in Database.Beam.Query.Ord Methods sqlEqE :: Proxy Word -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) # sqlNeqE :: Proxy Word -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) # sqlEqTriE :: Proxy Word -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) # sqlNeqTriE :: Proxy Word -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) #
BeamSqlBackend (MockSqlBackend cmd) => HasSqlEqualityCheck (MockSqlBackend cmd) UTCTime
Instance details Defined in Database.Beam.Query.Ord Methods sqlEqE :: Proxy UTCTime -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) # sqlNeqE :: Proxy UTCTime -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) # sqlEqTriE :: Proxy UTCTime -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) # sqlNeqTriE :: Proxy UTCTime -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) #
BeamSqlBackend (MockSqlBackend cmd) => HasSqlEqualityCheck (MockSqlBackend cmd) TimeOfDay
Instance details Defined in Database.Beam.Query.Ord Methods sqlEqE :: Proxy TimeOfDay -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) # sqlNeqE :: Proxy TimeOfDay -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) # sqlEqTriE :: Proxy TimeOfDay -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) # sqlNeqTriE :: Proxy TimeOfDay -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) #
BeamSqlBackend (MockSqlBackend cmd) => HasSqlEqualityCheck (MockSqlBackend cmd) Text
Instance details Defined in Database.Beam.Query.Ord Methods sqlEqE :: Proxy Text -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) # sqlNeqE :: Proxy Text -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) # sqlEqTriE :: Proxy Text -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) # sqlNeqTriE :: Proxy Text -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) #
BeamSqlBackend (MockSqlBackend cmd) => HasSqlEqualityCheck (MockSqlBackend cmd) LocalTime
Instance details Defined in Database.Beam.Query.Ord Methods sqlEqE :: Proxy LocalTime -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) # sqlNeqE :: Proxy LocalTime -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) # sqlEqTriE :: Proxy LocalTime -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) # sqlNeqTriE :: Proxy LocalTime -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) #
BeamSqlBackend (MockSqlBackend cmd) => HasSqlEqualityCheck (MockSqlBackend cmd) Integer
Instance details Defined in Database.Beam.Query.Ord Methods sqlEqE :: Proxy Integer -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) # sqlNeqE :: Proxy Integer -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) # sqlEqTriE :: Proxy Integer -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) # sqlNeqTriE :: Proxy Integer -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) #
BeamSqlBackend (MockSqlBackend cmd) => HasSqlEqualityCheck (MockSqlBackend cmd) Int8
Instance details Defined in Database.Beam.Query.Ord Methods sqlEqE :: Proxy Int8 -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) # sqlNeqE :: Proxy Int8 -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) # sqlEqTriE :: Proxy Int8 -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) # sqlNeqTriE :: Proxy Int8 -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) #
BeamSqlBackend (MockSqlBackend cmd) => HasSqlEqualityCheck (MockSqlBackend cmd) Int64
Instance details Defined in Database.Beam.Query.Ord Methods sqlEqE :: Proxy Int64 -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) # sqlNeqE :: Proxy Int64 -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) # sqlEqTriE :: Proxy Int64 -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) # sqlNeqTriE :: Proxy Int64 -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) #
BeamSqlBackend (MockSqlBackend cmd) => HasSqlEqualityCheck (MockSqlBackend cmd) Int32
Instance details Defined in Database.Beam.Query.Ord Methods sqlEqE :: Proxy Int32 -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) # sqlNeqE :: Proxy Int32 -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) # sqlEqTriE :: Proxy Int32 -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) # sqlNeqTriE :: Proxy Int32 -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) #
BeamSqlBackend (MockSqlBackend cmd) => HasSqlEqualityCheck (MockSqlBackend cmd) Int16
Instance details Defined in Database.Beam.Query.Ord Methods sqlEqE :: Proxy Int16 -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) # sqlNeqE :: Proxy Int16 -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) # sqlEqTriE :: Proxy Int16 -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) # sqlNeqTriE :: Proxy Int16 -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) #
BeamSqlBackend (MockSqlBackend cmd) => HasSqlEqualityCheck (MockSqlBackend cmd) Int
Instance details Defined in Database.Beam.Query.Ord Methods sqlEqE :: Proxy Int -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) # sqlNeqE :: Proxy Int -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) # sqlEqTriE :: Proxy Int -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) # sqlNeqTriE :: Proxy Int -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) #
BeamSqlBackend (MockSqlBackend cmd) => HasSqlEqualityCheck (MockSqlBackend cmd) Float
Instance details Defined in Database.Beam.Query.Ord Methods sqlEqE :: Proxy Float -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) # sqlNeqE :: Proxy Float -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) # sqlEqTriE :: Proxy Float -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) # sqlNeqTriE :: Proxy Float -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) #
BeamSqlBackend (MockSqlBackend cmd) => HasSqlEqualityCheck (MockSqlBackend cmd) Double
Instance details Defined in Database.Beam.Query.Ord Methods sqlEqE :: Proxy Double -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) # sqlNeqE :: Proxy Double -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) # sqlEqTriE :: Proxy Double -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) # sqlNeqTriE :: Proxy Double -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) #
BeamSqlBackend (MockSqlBackend cmd) => HasSqlEqualityCheck (MockSqlBackend cmd) Day
Instance details Defined in Database.Beam.Query.Ord Methods sqlEqE :: Proxy Day -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) # sqlNeqE :: Proxy Day -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) # sqlEqTriE :: Proxy Day -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) # sqlNeqTriE :: Proxy Day -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) #
BeamSqlBackend (MockSqlBackend cmd) => HasSqlEqualityCheck (MockSqlBackend cmd) Bool
Instance details Defined in Database.Beam.Query.Ord Methods sqlEqE :: Proxy Bool -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) # sqlNeqE :: Proxy Bool -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) # sqlEqTriE :: Proxy Bool -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) # sqlNeqTriE :: Proxy Bool -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) #
(BeamSqlBackend (MockSqlBackend cmd), HasSqlEqualityCheck (MockSqlBackend cmd) a) => HasSqlEqualityCheck (MockSqlBackend cmd) (Tagged t a)
Instance details Defined in Database.Beam.Query.Ord Methods sqlEqE :: Proxy (Tagged t a) -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) # sqlNeqE :: Proxy (Tagged t a) -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) # sqlEqTriE :: Proxy (Tagged t a) -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) # sqlNeqTriE :: Proxy (Tagged t a) -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) #

class HasSqlEqualityCheck be a => HasSqlQuantifiedEqualityCheck be a where #

Minimal complete definition

Nothing

Methods

sqlQEqE :: Proxy a -> Proxy be -> Maybe (BeamSqlBackendExpressionQuantifierSyntax be) -> BeamSqlBackendExpressionSyntax be -> BeamSqlBackendExpressionSyntax be -> BeamSqlBackendExpressionSyntax be #

sqlQNeqE :: Proxy a -> Proxy be -> Maybe (BeamSqlBackendExpressionQuantifierSyntax be) -> BeamSqlBackendExpressionSyntax be -> BeamSqlBackendExpressionSyntax be -> BeamSqlBackendExpressionSyntax be #

Instances

HasSqlQuantifiedEqualityCheck Postgres Bool
Instance details Defined in Database.Beam.Postgres.Types Methods sqlQEqE :: Proxy Bool -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlQNeqE :: Proxy Bool -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlQuantifiedEqualityCheck Postgres Double
Instance details Defined in Database.Beam.Postgres.Types Methods sqlQEqE :: Proxy Double -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlQNeqE :: Proxy Double -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlQuantifiedEqualityCheck Postgres Float
Instance details Defined in Database.Beam.Postgres.Types Methods sqlQEqE :: Proxy Float -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlQNeqE :: Proxy Float -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlQuantifiedEqualityCheck Postgres Int
Instance details Defined in Database.Beam.Postgres.Types Methods sqlQEqE :: Proxy Int -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlQNeqE :: Proxy Int -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlQuantifiedEqualityCheck Postgres Int8
Instance details Defined in Database.Beam.Postgres.Types Methods sqlQEqE :: Proxy Int8 -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlQNeqE :: Proxy Int8 -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlQuantifiedEqualityCheck Postgres Int16
Instance details Defined in Database.Beam.Postgres.Types Methods sqlQEqE :: Proxy Int16 -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlQNeqE :: Proxy Int16 -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlQuantifiedEqualityCheck Postgres Int32
Instance details Defined in Database.Beam.Postgres.Types Methods sqlQEqE :: Proxy Int32 -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlQNeqE :: Proxy Int32 -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlQuantifiedEqualityCheck Postgres Int64
Instance details Defined in Database.Beam.Postgres.Types Methods sqlQEqE :: Proxy Int64 -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlQNeqE :: Proxy Int64 -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlQuantifiedEqualityCheck Postgres Integer
Instance details Defined in Database.Beam.Postgres.Types Methods sqlQEqE :: Proxy Integer -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlQNeqE :: Proxy Integer -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlQuantifiedEqualityCheck Postgres Word
Instance details Defined in Database.Beam.Postgres.Types Methods sqlQEqE :: Proxy Word -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlQNeqE :: Proxy Word -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlQuantifiedEqualityCheck Postgres Word8
Instance details Defined in Database.Beam.Postgres.Types Methods sqlQEqE :: Proxy Word8 -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlQNeqE :: Proxy Word8 -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlQuantifiedEqualityCheck Postgres Word16
Instance details Defined in Database.Beam.Postgres.Types Methods sqlQEqE :: Proxy Word16 -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlQNeqE :: Proxy Word16 -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlQuantifiedEqualityCheck Postgres Word32
Instance details Defined in Database.Beam.Postgres.Types Methods sqlQEqE :: Proxy Word32 -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlQNeqE :: Proxy Word32 -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlQuantifiedEqualityCheck Postgres Word64
Instance details Defined in Database.Beam.Postgres.Types Methods sqlQEqE :: Proxy Word64 -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlQNeqE :: Proxy Word64 -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlQuantifiedEqualityCheck Postgres ByteString
Instance details Defined in Database.Beam.Postgres.Types Methods sqlQEqE :: Proxy ByteString -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlQNeqE :: Proxy ByteString -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlQuantifiedEqualityCheck Postgres ByteString
Instance details Defined in Database.Beam.Postgres.Types Methods sqlQEqE :: Proxy ByteString -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlQNeqE :: Proxy ByteString -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlQuantifiedEqualityCheck Postgres Text
Instance details Defined in Database.Beam.Postgres.Types Methods sqlQEqE :: Proxy Text -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlQNeqE :: Proxy Text -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlQuantifiedEqualityCheck Postgres Text
Instance details Defined in Database.Beam.Postgres.Types Methods sqlQEqE :: Proxy Text -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlQNeqE :: Proxy Text -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlQuantifiedEqualityCheck Postgres ZonedTime
Instance details Defined in Database.Beam.Postgres.Types Methods sqlQEqE :: Proxy ZonedTime -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlQNeqE :: Proxy ZonedTime -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlQuantifiedEqualityCheck Postgres LocalTime
Instance details Defined in Database.Beam.Postgres.Types Methods sqlQEqE :: Proxy LocalTime -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlQNeqE :: Proxy LocalTime -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlQuantifiedEqualityCheck Postgres TimeOfDay
Instance details Defined in Database.Beam.Postgres.Types Methods sqlQEqE :: Proxy TimeOfDay -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlQNeqE :: Proxy TimeOfDay -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlQuantifiedEqualityCheck Postgres UTCTime
Instance details Defined in Database.Beam.Postgres.Types Methods sqlQEqE :: Proxy UTCTime -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlQNeqE :: Proxy UTCTime -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlQuantifiedEqualityCheck Postgres NominalDiffTime
Instance details Defined in Database.Beam.Postgres.Types Methods sqlQEqE :: Proxy NominalDiffTime -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlQNeqE :: Proxy NominalDiffTime -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlQuantifiedEqualityCheck Postgres Day
Instance details Defined in Database.Beam.Postgres.Types Methods sqlQEqE :: Proxy Day -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlQNeqE :: Proxy Day -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlQuantifiedEqualityCheck Postgres Scientific
Instance details Defined in Database.Beam.Postgres.Types Methods sqlQEqE :: Proxy Scientific -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlQNeqE :: Proxy Scientific -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlQuantifiedEqualityCheck Postgres Value
Instance details Defined in Database.Beam.Postgres.Types Methods sqlQEqE :: Proxy Value -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlQNeqE :: Proxy Value -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlQuantifiedEqualityCheck Postgres UUID
Instance details Defined in Database.Beam.Postgres.Types Methods sqlQEqE :: Proxy UUID -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlQNeqE :: Proxy UUID -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlQuantifiedEqualityCheck Postgres PgMoney
Instance details Defined in Database.Beam.Postgres.PgSpecific Methods sqlQEqE :: Proxy PgMoney -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlQNeqE :: Proxy PgMoney -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlQuantifiedEqualityCheck Postgres TsQuery
Instance details Defined in Database.Beam.Postgres.PgSpecific Methods sqlQEqE :: Proxy TsQuery -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlQNeqE :: Proxy TsQuery -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlQuantifiedEqualityCheck Postgres TsVector
Instance details Defined in Database.Beam.Postgres.PgSpecific Methods sqlQEqE :: Proxy TsVector -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlQNeqE :: Proxy TsVector -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlQuantifiedEqualityCheck Postgres TsVectorConfig
Instance details Defined in Database.Beam.Postgres.PgSpecific Methods sqlQEqE :: Proxy TsVectorConfig -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlQNeqE :: Proxy TsVectorConfig -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlQuantifiedEqualityCheck Postgres Oid
Instance details Defined in Database.Beam.Postgres.Types Methods sqlQEqE :: Proxy Oid -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlQNeqE :: Proxy Oid -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlQuantifiedEqualityCheck Postgres HStoreList
Instance details Defined in Database.Beam.Postgres.Types Methods sqlQEqE :: Proxy HStoreList -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlQNeqE :: Proxy HStoreList -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlQuantifiedEqualityCheck Postgres HStoreMap
Instance details Defined in Database.Beam.Postgres.Types Methods sqlQEqE :: Proxy HStoreMap -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlQNeqE :: Proxy HStoreMap -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlQuantifiedEqualityCheck Postgres LocalTimestamp
Instance details Defined in Database.Beam.Postgres.Types Methods sqlQEqE :: Proxy LocalTimestamp -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlQNeqE :: Proxy LocalTimestamp -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlQuantifiedEqualityCheck Postgres UTCTimestamp
Instance details Defined in Database.Beam.Postgres.Types Methods sqlQEqE :: Proxy UTCTimestamp -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlQNeqE :: Proxy UTCTimestamp -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlQuantifiedEqualityCheck Postgres ZonedTimestamp
Instance details Defined in Database.Beam.Postgres.Types Methods sqlQEqE :: Proxy ZonedTimestamp -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlQNeqE :: Proxy ZonedTimestamp -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlQuantifiedEqualityCheck Postgres Date
Instance details Defined in Database.Beam.Postgres.Types Methods sqlQEqE :: Proxy Date -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlQNeqE :: Proxy Date -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlQuantifiedEqualityCheck syntax a => HasSqlQuantifiedEqualityCheck syntax (SqlSerial a)
Instance details Defined in Database.Beam.Query.Ord Methods sqlQEqE :: Proxy (SqlSerial a) -> Proxy syntax -> Maybe (BeamSqlBackendExpressionQuantifierSyntax syntax) -> BeamSqlBackendExpressionSyntax syntax -> BeamSqlBackendExpressionSyntax syntax -> BeamSqlBackendExpressionSyntax syntax # sqlQNeqE :: Proxy (SqlSerial a) -> Proxy syntax -> Maybe (BeamSqlBackendExpressionQuantifierSyntax syntax) -> BeamSqlBackendExpressionSyntax syntax -> BeamSqlBackendExpressionSyntax syntax -> BeamSqlBackendExpressionSyntax syntax #
(HasSqlQuantifiedEqualityCheck syntax a, CanCheckMaybeEquality a) => HasSqlQuantifiedEqualityCheck syntax (Maybe a)
Instance details Defined in Database.Beam.Query.Ord Methods sqlQEqE :: Proxy (Maybe a) -> Proxy syntax -> Maybe (BeamSqlBackendExpressionQuantifierSyntax syntax) -> BeamSqlBackendExpressionSyntax syntax -> BeamSqlBackendExpressionSyntax syntax -> BeamSqlBackendExpressionSyntax syntax # sqlQNeqE :: Proxy (Maybe a) -> Proxy syntax -> Maybe (BeamSqlBackendExpressionQuantifierSyntax syntax) -> BeamSqlBackendExpressionSyntax syntax -> BeamSqlBackendExpressionSyntax syntax -> BeamSqlBackendExpressionSyntax syntax #
HasSqlQuantifiedEqualityCheck Postgres [Char]
Instance details Defined in Database.Beam.Postgres.Types Methods sqlQEqE :: Proxy [Char] -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlQNeqE :: Proxy [Char] -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlQuantifiedEqualityCheck Postgres (Vector a)
Instance details Defined in Database.Beam.Postgres.Types Methods sqlQEqE :: Proxy (Vector a) -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlQNeqE :: Proxy (Vector a) -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlQuantifiedEqualityCheck Postgres (CI Text)
Instance details Defined in Database.Beam.Postgres.Types Methods sqlQEqE :: Proxy (CI Text) -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlQNeqE :: Proxy (CI Text) -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlQuantifiedEqualityCheck Postgres (CI Text)
Instance details Defined in Database.Beam.Postgres.Types Methods sqlQEqE :: Proxy (CI Text) -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlQNeqE :: Proxy (CI Text) -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlQuantifiedEqualityCheck Postgres (PgJSON a)
Instance details Defined in Database.Beam.Postgres.PgSpecific Methods sqlQEqE :: Proxy (PgJSON a) -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlQNeqE :: Proxy (PgJSON a) -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlQuantifiedEqualityCheck Postgres (PgJSONB a)
Instance details Defined in Database.Beam.Postgres.PgSpecific Methods sqlQEqE :: Proxy (PgJSONB a) -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlQNeqE :: Proxy (PgJSONB a) -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlQuantifiedEqualityCheck Postgres (PgRange n a)
Instance details Defined in Database.Beam.Postgres.PgSpecific Methods sqlQEqE :: Proxy (PgRange n a) -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlQNeqE :: Proxy (PgRange n a) -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
HasSqlQuantifiedEqualityCheck Postgres a => HasSqlQuantifiedEqualityCheck Postgres (Tagged t a)
Instance details Defined in Database.Beam.Postgres.Types Methods sqlQEqE :: Proxy (Tagged t a) -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres # sqlQNeqE :: Proxy (Tagged t a) -> Proxy Postgres -> Maybe (BeamSqlBackendExpressionQuantifierSyntax Postgres) -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres -> BeamSqlBackendExpressionSyntax Postgres #
BeamSqlBackend (MockSqlBackend cmd) => HasSqlQuantifiedEqualityCheck (MockSqlBackend cmd) Word8
Instance details Defined in Database.Beam.Query.Ord Methods sqlQEqE :: Proxy Word8 -> Proxy (MockSqlBackend cmd) -> Maybe (BeamSqlBackendExpressionQuantifierSyntax (MockSqlBackend cmd)) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) # sqlQNeqE :: Proxy Word8 -> Proxy (MockSqlBackend cmd) -> Maybe (BeamSqlBackendExpressionQuantifierSyntax (MockSqlBackend cmd)) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) #
BeamSqlBackend (MockSqlBackend cmd) => HasSqlQuantifiedEqualityCheck (MockSqlBackend cmd) Word64
Instance details Defined in Database.Beam.Query.Ord Methods sqlQEqE :: Proxy Word64 -> Proxy (MockSqlBackend cmd) -> Maybe (BeamSqlBackendExpressionQuantifierSyntax (MockSqlBackend cmd)) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) # sqlQNeqE :: Proxy Word64 -> Proxy (MockSqlBackend cmd) -> Maybe (BeamSqlBackendExpressionQuantifierSyntax (MockSqlBackend cmd)) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) #
BeamSqlBackend (MockSqlBackend cmd) => HasSqlQuantifiedEqualityCheck (MockSqlBackend cmd) Word32
Instance details Defined in Database.Beam.Query.Ord Methods sqlQEqE :: Proxy Word32 -> Proxy (MockSqlBackend cmd) -> Maybe (BeamSqlBackendExpressionQuantifierSyntax (MockSqlBackend cmd)) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) # sqlQNeqE :: Proxy Word32 -> Proxy (MockSqlBackend cmd) -> Maybe (BeamSqlBackendExpressionQuantifierSyntax (MockSqlBackend cmd)) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) #
BeamSqlBackend (MockSqlBackend cmd) => HasSqlQuantifiedEqualityCheck (MockSqlBackend cmd) Word16
Instance details Defined in Database.Beam.Query.Ord Methods sqlQEqE :: Proxy Word16 -> Proxy (MockSqlBackend cmd) -> Maybe (BeamSqlBackendExpressionQuantifierSyntax (MockSqlBackend cmd)) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) # sqlQNeqE :: Proxy Word16 -> Proxy (MockSqlBackend cmd) -> Maybe (BeamSqlBackendExpressionQuantifierSyntax (MockSqlBackend cmd)) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) #
BeamSqlBackend (MockSqlBackend cmd) => HasSqlQuantifiedEqualityCheck (MockSqlBackend cmd) Word
Instance details Defined in Database.Beam.Query.Ord Methods sqlQEqE :: Proxy Word -> Proxy (MockSqlBackend cmd) -> Maybe (BeamSqlBackendExpressionQuantifierSyntax (MockSqlBackend cmd)) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) # sqlQNeqE :: Proxy Word -> Proxy (MockSqlBackend cmd) -> Maybe (BeamSqlBackendExpressionQuantifierSyntax (MockSqlBackend cmd)) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) #
BeamSqlBackend (MockSqlBackend cmd) => HasSqlQuantifiedEqualityCheck (MockSqlBackend cmd) UTCTime
Instance details Defined in Database.Beam.Query.Ord Methods sqlQEqE :: Proxy UTCTime -> Proxy (MockSqlBackend cmd) -> Maybe (BeamSqlBackendExpressionQuantifierSyntax (MockSqlBackend cmd)) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) # sqlQNeqE :: Proxy UTCTime -> Proxy (MockSqlBackend cmd) -> Maybe (BeamSqlBackendExpressionQuantifierSyntax (MockSqlBackend cmd)) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) #
BeamSqlBackend (MockSqlBackend cmd) => HasSqlQuantifiedEqualityCheck (MockSqlBackend cmd) TimeOfDay
Instance details Defined in Database.Beam.Query.Ord Methods sqlQEqE :: Proxy TimeOfDay -> Proxy (MockSqlBackend cmd) -> Maybe (BeamSqlBackendExpressionQuantifierSyntax (MockSqlBackend cmd)) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) # sqlQNeqE :: Proxy TimeOfDay -> Proxy (MockSqlBackend cmd) -> Maybe (BeamSqlBackendExpressionQuantifierSyntax (MockSqlBackend cmd)) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) #
BeamSqlBackend (MockSqlBackend cmd) => HasSqlQuantifiedEqualityCheck (MockSqlBackend cmd) Text
Instance details Defined in Database.Beam.Query.Ord Methods sqlQEqE :: Proxy Text -> Proxy (MockSqlBackend cmd) -> Maybe (BeamSqlBackendExpressionQuantifierSyntax (MockSqlBackend cmd)) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) # sqlQNeqE :: Proxy Text -> Proxy (MockSqlBackend cmd) -> Maybe (BeamSqlBackendExpressionQuantifierSyntax (MockSqlBackend cmd)) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) #
BeamSqlBackend (MockSqlBackend cmd) => HasSqlQuantifiedEqualityCheck (MockSqlBackend cmd) LocalTime
Instance details Defined in Database.Beam.Query.Ord Methods sqlQEqE :: Proxy LocalTime -> Proxy (MockSqlBackend cmd) -> Maybe (BeamSqlBackendExpressionQuantifierSyntax (MockSqlBackend cmd)) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) # sqlQNeqE :: Proxy LocalTime -> Proxy (MockSqlBackend cmd) -> Maybe (BeamSqlBackendExpressionQuantifierSyntax (MockSqlBackend cmd)) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) #
BeamSqlBackend (MockSqlBackend cmd) => HasSqlQuantifiedEqualityCheck (MockSqlBackend cmd) Integer
Instance details Defined in Database.Beam.Query.Ord Methods sqlQEqE :: Proxy Integer -> Proxy (MockSqlBackend cmd) -> Maybe (BeamSqlBackendExpressionQuantifierSyntax (MockSqlBackend cmd)) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) # sqlQNeqE :: Proxy Integer -> Proxy (MockSqlBackend cmd) -> Maybe (BeamSqlBackendExpressionQuantifierSyntax (MockSqlBackend cmd)) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) #
BeamSqlBackend (MockSqlBackend cmd) => HasSqlQuantifiedEqualityCheck (MockSqlBackend cmd) Int8
Instance details Defined in Database.Beam.Query.Ord Methods sqlQEqE :: Proxy Int8 -> Proxy (MockSqlBackend cmd) -> Maybe (BeamSqlBackendExpressionQuantifierSyntax (MockSqlBackend cmd)) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) # sqlQNeqE :: Proxy Int8 -> Proxy (MockSqlBackend cmd) -> Maybe (BeamSqlBackendExpressionQuantifierSyntax (MockSqlBackend cmd)) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) #
BeamSqlBackend (MockSqlBackend cmd) => HasSqlQuantifiedEqualityCheck (MockSqlBackend cmd) Int64
Instance details Defined in Database.Beam.Query.Ord Methods sqlQEqE :: Proxy Int64 -> Proxy (MockSqlBackend cmd) -> Maybe (BeamSqlBackendExpressionQuantifierSyntax (MockSqlBackend cmd)) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) # sqlQNeqE :: Proxy Int64 -> Proxy (MockSqlBackend cmd) -> Maybe (BeamSqlBackendExpressionQuantifierSyntax (MockSqlBackend cmd)) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) #
BeamSqlBackend (MockSqlBackend cmd) => HasSqlQuantifiedEqualityCheck (MockSqlBackend cmd) Int32
Instance details Defined in Database.Beam.Query.Ord Methods sqlQEqE :: Proxy Int32 -> Proxy (MockSqlBackend cmd) -> Maybe (BeamSqlBackendExpressionQuantifierSyntax (MockSqlBackend cmd)) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) # sqlQNeqE :: Proxy Int32 -> Proxy (MockSqlBackend cmd) -> Maybe (BeamSqlBackendExpressionQuantifierSyntax (MockSqlBackend cmd)) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) #
BeamSqlBackend (MockSqlBackend cmd) => HasSqlQuantifiedEqualityCheck (MockSqlBackend cmd) Int16
Instance details Defined in Database.Beam.Query.Ord Methods sqlQEqE :: Proxy Int16 -> Proxy (MockSqlBackend cmd) -> Maybe (BeamSqlBackendExpressionQuantifierSyntax (MockSqlBackend cmd)) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) # sqlQNeqE :: Proxy Int16 -> Proxy (MockSqlBackend cmd) -> Maybe (BeamSqlBackendExpressionQuantifierSyntax (MockSqlBackend cmd)) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) #
BeamSqlBackend (MockSqlBackend cmd) => HasSqlQuantifiedEqualityCheck (MockSqlBackend cmd) Int
Instance details Defined in Database.Beam.Query.Ord Methods sqlQEqE :: Proxy Int -> Proxy (MockSqlBackend cmd) -> Maybe (BeamSqlBackendExpressionQuantifierSyntax (MockSqlBackend cmd)) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) # sqlQNeqE :: Proxy Int -> Proxy (MockSqlBackend cmd) -> Maybe (BeamSqlBackendExpressionQuantifierSyntax (MockSqlBackend cmd)) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) #
BeamSqlBackend (MockSqlBackend cmd) => HasSqlQuantifiedEqualityCheck (MockSqlBackend cmd) Float
Instance details Defined in Database.Beam.Query.Ord Methods sqlQEqE :: Proxy Float -> Proxy (MockSqlBackend cmd) -> Maybe (BeamSqlBackendExpressionQuantifierSyntax (MockSqlBackend cmd)) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) # sqlQNeqE :: Proxy Float -> Proxy (MockSqlBackend cmd) -> Maybe (BeamSqlBackendExpressionQuantifierSyntax (MockSqlBackend cmd)) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) #
BeamSqlBackend (MockSqlBackend cmd) => HasSqlQuantifiedEqualityCheck (MockSqlBackend cmd) Double
Instance details Defined in Database.Beam.Query.Ord Methods sqlQEqE :: Proxy Double -> Proxy (MockSqlBackend cmd) -> Maybe (BeamSqlBackendExpressionQuantifierSyntax (MockSqlBackend cmd)) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) # sqlQNeqE :: Proxy Double -> Proxy (MockSqlBackend cmd) -> Maybe (BeamSqlBackendExpressionQuantifierSyntax (MockSqlBackend cmd)) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) #
BeamSqlBackend (MockSqlBackend cmd) => HasSqlQuantifiedEqualityCheck (MockSqlBackend cmd) Day
Instance details Defined in Database.Beam.Query.Ord Methods sqlQEqE :: Proxy Day -> Proxy (MockSqlBackend cmd) -> Maybe (BeamSqlBackendExpressionQuantifierSyntax (MockSqlBackend cmd)) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) # sqlQNeqE :: Proxy Day -> Proxy (MockSqlBackend cmd) -> Maybe (BeamSqlBackendExpressionQuantifierSyntax (MockSqlBackend cmd)) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) #
BeamSqlBackend (MockSqlBackend cmd) => HasSqlQuantifiedEqualityCheck (MockSqlBackend cmd) Bool
Instance details Defined in Database.Beam.Query.Ord Methods sqlQEqE :: Proxy Bool -> Proxy (MockSqlBackend cmd) -> Maybe (BeamSqlBackendExpressionQuantifierSyntax (MockSqlBackend cmd)) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) # sqlQNeqE :: Proxy Bool -> Proxy (MockSqlBackend cmd) -> Maybe (BeamSqlBackendExpressionQuantifierSyntax (MockSqlBackend cmd)) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) #
(BeamSqlBackend (MockSqlBackend cmd), HasSqlQuantifiedEqualityCheck (MockSqlBackend cmd) a) => HasSqlQuantifiedEqualityCheck (MockSqlBackend cmd) (Tagged t a)
Instance details Defined in Database.Beam.Query.Ord Methods sqlQEqE :: Proxy (Tagged t a) -> Proxy (MockSqlBackend cmd) -> Maybe (BeamSqlBackendExpressionQuantifierSyntax (MockSqlBackend cmd)) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) # sqlQNeqE :: Proxy (Tagged t a) -> Proxy (MockSqlBackend cmd) -> Maybe (BeamSqlBackendExpressionQuantifierSyntax (MockSqlBackend cmd)) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) #

data QQuantified be s r #

Instances

(BeamSqlBackend be, HasSqlQuantifiedEqualityCheck be a) => SqlEqQuantified (QGenExpr context be s) (QQuantified be s a) (QGenExpr context be s a)
Instance details Defined in Database.Beam.Query.Ord Methods (==.) :: QGenExpr context be s a -> QQuantified be s a -> QGenExpr context be s SqlBool # (/=.) :: QGenExpr context be s a -> QQuantified be s a -> QGenExpr context be s SqlBool #
BeamSqlBackend be => SqlOrdQuantified (QGenExpr context be s) (QQuantified be s a) (QGenExpr context be s a)
Instance details Defined in Database.Beam.Query.Ord Methods (<.) :: QGenExpr context be s a -> QQuantified be s a -> QGenExpr context be s Bool # (>.) :: QGenExpr context be s a -> QQuantified be s a -> QGenExpr context be s Bool # (<=.) :: QGenExpr context be s a -> QQuantified be s a -> QGenExpr context be s Bool # (>=.) :: QGenExpr context be s a -> QQuantified be s a -> QGenExpr context be s Bool #

class SqlEq (expr :: Type -> Type) a | a -> expr where #

Methods

(==.) :: a -> a -> expr Bool #

(/=.) :: a -> a -> expr Bool #

(==?.) :: a -> a -> expr SqlBool #

(/=?.) :: a -> a -> expr SqlBool #

Instances

(BeamSqlBackend be, Beamable tbl, FieldsFulfillConstraint (HasSqlEqualityCheck be) tbl) => SqlEq (QGenExpr context be s) (tbl (QGenExpr context be s))
Instance details Defined in Database.Beam.Query.Ord Methods (==.) :: tbl (QGenExpr context be s) -> tbl (QGenExpr context be s) -> QGenExpr context be s Bool # (/=.) :: tbl (QGenExpr context be s) -> tbl (QGenExpr context be s) -> QGenExpr context be s Bool # (==?.) :: tbl (QGenExpr context be s) -> tbl (QGenExpr context be s) -> QGenExpr context be s SqlBool # (/=?.) :: tbl (QGenExpr context be s) -> tbl (QGenExpr context be s) -> QGenExpr context be s SqlBool #
(BeamSqlBackend be, Beamable tbl, FieldsFulfillConstraintNullable (HasSqlEqualityCheck be) tbl) => SqlEq (QGenExpr context be s) (tbl (Nullable (QGenExpr context be s)))
Instance details Defined in Database.Beam.Query.Ord Methods (==.) :: tbl (Nullable (QGenExpr context be s)) -> tbl (Nullable (QGenExpr context be s)) -> QGenExpr context be s Bool # (/=.) :: tbl (Nullable (QGenExpr context be s)) -> tbl (Nullable (QGenExpr context be s)) -> QGenExpr context be s Bool # (==?.) :: tbl (Nullable (QGenExpr context be s)) -> tbl (Nullable (QGenExpr context be s)) -> QGenExpr context be s SqlBool # (/=?.) :: tbl (Nullable (QGenExpr context be s)) -> tbl (Nullable (QGenExpr context be s)) -> QGenExpr context be s SqlBool #
(BeamSqlBackend be, HasSqlEqualityCheck be a) => SqlEq (QGenExpr context be s) (QGenExpr context be s a)
Instance details Defined in Database.Beam.Query.Ord Methods (==.) :: QGenExpr context be s a -> QGenExpr context be s a -> QGenExpr context be s Bool # (/=.) :: QGenExpr context be s a -> QGenExpr context be s a -> QGenExpr context be s Bool # (==?.) :: QGenExpr context be s a -> QGenExpr context be s a -> QGenExpr context be s SqlBool # (/=?.) :: QGenExpr context be s a -> QGenExpr context be s a -> QGenExpr context be s SqlBool #

class SqlEq expr a => SqlEqQuantified (expr :: Type -> Type) quantified a | a -> expr quantified where #

Methods

(==*.) :: a -> quantified -> expr SqlBool #

(/=*.) :: a -> quantified -> expr SqlBool #

Instances

(BeamSqlBackend be, HasSqlQuantifiedEqualityCheck be a) => SqlEqQuantified (QGenExpr context be s) (QQuantified be s a) (QGenExpr context be s a)
Instance details Defined in Database.Beam.Query.Ord Methods (==.) :: QGenExpr context be s a -> QQuantified be s a -> QGenExpr context be s SqlBool # (/=.) :: QGenExpr context be s a -> QQuantified be s a -> QGenExpr context be s SqlBool #

class SqlOrd (expr :: Type -> Type) e | e -> expr where #

Methods

(<.) :: e -> e -> expr Bool #

(>.) :: e -> e -> expr Bool #

(<=.) :: e -> e -> expr Bool #

(>=.) :: e -> e -> expr Bool #

Instances

BeamSqlBackend be => SqlOrd (QGenExpr context be s) (QGenExpr context be s a)

Instance details

Defined in Database.Beam.Query.Ord

Methods

(<.) :: QGenExpr context be s a -> QGenExpr context be s a -> QGenExpr context be s Bool #

(>.) :: QGenExpr context be s a -> QGenExpr context be s a -> QGenExpr context be s Bool #

(<=.) :: QGenExpr context be s a -> QGenExpr context be s a -> QGenExpr context be s Bool #

(>=.) :: QGenExpr context be s a -> QGenExpr context be s a -> QGenExpr context be s Bool #

class SqlOrd expr e => SqlOrdQuantified (expr :: Type -> Type) quantified e | e -> expr quantified where #

Methods

(<*.) :: e -> quantified -> expr Bool #

(>*.) :: e -> quantified -> expr Bool #

(<=*.) :: e -> quantified -> expr Bool #

(>=*.) :: e -> quantified -> expr Bool #

Instances

BeamSqlBackend be => SqlOrdQuantified (QGenExpr context be s) (QQuantified be s a) (QGenExpr context be s a)

Instance details

Defined in Database.Beam.Query.Ord

Methods

(<*.) :: QGenExpr context be s a -> QQuantified be s a -> QGenExpr context be s Bool #

(>*.) :: QGenExpr context be s a -> QQuantified be s a -> QGenExpr context be s Bool #

(<=*.) :: QGenExpr context be s a -> QQuantified be s a -> QGenExpr context be s Bool #

(>=*.) :: QGenExpr context be s a -> QQuantified be s a -> QGenExpr context be s Bool #

type ManyToMany be (db :: (Type -> Type) -> Type) (left :: (Type -> Type) -> Type) (right :: (Type -> Type) -> Type) = forall s. (BeamSqlBackend be, SqlEq (QExpr be s) (PrimaryKey left (QExpr be s)), SqlEq (QExpr be s) (PrimaryKey right (QExpr be s))) => Q be db s (left (QExpr be s)) -> Q be db s (right (QExpr be s)) -> Q be db s (left (QExpr be s), right (QExpr be s)) #

type ManyToManyThrough be (db :: (Type -> Type) -> Type) (through :: (Type -> Type) -> Type) (left :: (Type -> Type) -> Type) (right :: (Type -> Type) -> Type) = forall s. (BeamSqlBackend be, SqlEq (QExpr be s) (PrimaryKey left (QExpr be s)), SqlEq (QExpr be s) (PrimaryKey right (QExpr be s))) => Q be db s (left (QExpr be s)) -> Q be db s (right (QExpr be s)) -> Q be db s (through (QExpr be s), left (QExpr be s), right (QExpr be s)) #

type OneToMany be (db :: (Type -> Type) -> Type) s (one :: (Type -> Type) -> Type) (many :: (Type -> Type) -> Type) = BeamSqlBackend be -> BeamSqlBackendCanSerialize be Bool -> one (QExpr be s) -> Q be db s (many (QExpr be s)) #

type OneToManyOptional be (db :: (Type -> Type) -> Type) s (tbl :: (Type -> Type) -> Type) (rel :: (Type -> Type) -> Type) = BeamSqlBackend be -> BeamSqlBackendCanSerialize be Bool -> BeamSqlBackendCanSerialize be SqlNull -> tbl (QExpr be s) -> Q be db s (rel (Nullable (QExpr be s))) #

type OneToMaybe be (db :: (Type -> Type) -> Type) s (tbl :: (Type -> Type) -> Type) (rel :: (Type -> Type) -> Type) = OneToManyOptional be db s tbl rel #

type OneToOne be (db :: (Type -> Type) -> Type) s (one :: (Type -> Type) -> Type) (many :: (Type -> Type) -> Type) = OneToMany be db s one many #

class BeamSqlBackend be => HasQBuilder be where #

Methods

buildSqlQuery :: Projectible be a => TablePrefix -> Q be db s a -> BeamSqlBackendSelectSyntax be #

Instances

HasQBuilder Postgres
Instance details Defined in Database.Beam.Postgres.Types Methods buildSqlQuery :: Projectible Postgres a => TablePrefix -> Q Postgres db s a -> BeamSqlBackendSelectSyntax Postgres #
BeamSqlBackend (MockSqlBackend cmd) => HasQBuilder (MockSqlBackend cmd)
Instance details Defined in Database.Beam.Query.Types Methods buildSqlQuery :: Projectible (MockSqlBackend cmd) a => TablePrefix -> Q (MockSqlBackend cmd) db s a -> BeamSqlBackendSelectSyntax (MockSqlBackend cmd) #

type family QExprToField x :: Type #

Instances

type QExprToField ()
Instance details Defined in Database.Beam.Query.Types type QExprToField () = ()
type QExprToField (table (Nullable (QGenExpr context syntax s)))
Instance details Defined in Database.Beam.Query.Types type QExprToField (table (Nullable (QGenExpr context syntax s))) = table (Nullable (QField s))
type QExprToField (table (QGenExpr context syntax s))
Instance details Defined in Database.Beam.Query.Types type QExprToField (table (QGenExpr context syntax s)) = table (QField s)
type QExprToField (a, b)
Instance details Defined in Database.Beam.Query.Types type QExprToField (a, b) = (QExprToField a, QExprToField b)
type QExprToField (Vector n a)
Instance details Defined in Database.Beam.Query.Types type QExprToField (Vector n a) = Vector n (QExprToField a)
type QExprToField (a, b, c)
Instance details Defined in Database.Beam.Query.Types type QExprToField (a, b, c) = (QExprToField a, QExprToField b, QExprToField c)
type QExprToField (a, b, c, d)
Instance details Defined in Database.Beam.Query.Types type QExprToField (a, b, c, d) = (QExprToField a, QExprToField b, QExprToField c, QExprToField d)
type QExprToField (QGenExpr ctxt syntax s a)
Instance details Defined in Database.Beam.Query.Types type QExprToField (QGenExpr ctxt syntax s a) = QField s a
type QExprToField (a, b, c, d, e)
Instance details Defined in Database.Beam.Query.Types type QExprToField (a, b, c, d, e) = (QExprToField a, QExprToField b, QExprToField c, QExprToField d, QExprToField e)
type QExprToField (a, b, c, d, e, f)
Instance details Defined in Database.Beam.Query.Types type QExprToField (a, b, c, d, e, f) = (QExprToField a, QExprToField b, QExprToField c, QExprToField d, QExprToField e, QExprToField f)
type QExprToField (a, b, c, d, e, f, g)
Instance details Defined in Database.Beam.Query.Types type QExprToField (a, b, c, d, e, f, g) = (QExprToField a, QExprToField b, QExprToField c, QExprToField d, QExprToField e, QExprToField f, QExprToField g)
type QExprToField (a, b, c, d, e, f, g, h)
Instance details Defined in Database.Beam.Query.Types type QExprToField (a, b, c, d, e, f, g, h) = (QExprToField a, QExprToField b, QExprToField c, QExprToField d, QExprToField e, QExprToField f, QExprToField g, QExprToField h)

type family QExprToIdentity x :: Type #

Instances

type QExprToIdentity ()
Instance details Defined in Database.Beam.Query.Types type QExprToIdentity () = ()
type QExprToIdentity (table (Nullable c))
Instance details Defined in Database.Beam.Query.Types type QExprToIdentity (table (Nullable c)) = Maybe (QExprToIdentity (table c))
type QExprToIdentity (table (QGenExpr context syntax s))
Instance details Defined in Database.Beam.Query.Types type QExprToIdentity (table (QGenExpr context syntax s)) = table Identity
type QExprToIdentity (a, b)
Instance details Defined in Database.Beam.Query.Types type QExprToIdentity (a, b) = (QExprToIdentity a, QExprToIdentity b)
type QExprToIdentity (Vector n a)
Instance details Defined in Database.Beam.Query.Types type QExprToIdentity (Vector n a) = Vector n (QExprToIdentity a)
type QExprToIdentity (a, b, c)
Instance details Defined in Database.Beam.Query.Types type QExprToIdentity (a, b, c) = (QExprToIdentity a, QExprToIdentity b, QExprToIdentity c)
type QExprToIdentity (a, b, c, d)
Instance details Defined in Database.Beam.Query.Types type QExprToIdentity (a, b, c, d) = (QExprToIdentity a, QExprToIdentity b, QExprToIdentity c, QExprToIdentity d)
type QExprToIdentity (QGenExpr context syntax s a)
Instance details Defined in Database.Beam.Query.Types type QExprToIdentity (QGenExpr context syntax s a) = a
type QExprToIdentity (a, b, c, d, e)
Instance details Defined in Database.Beam.Query.Types type QExprToIdentity (a, b, c, d, e) = (QExprToIdentity a, QExprToIdentity b, QExprToIdentity c, QExprToIdentity d, QExprToIdentity e)
type QExprToIdentity (a, b, c, d, e, f)
Instance details Defined in Database.Beam.Query.Types type QExprToIdentity (a, b, c, d, e, f) = (QExprToIdentity a, QExprToIdentity b, QExprToIdentity c, QExprToIdentity d, QExprToIdentity e, QExprToIdentity f)
type QExprToIdentity (a, b, c, d, e, f, g)
Instance details Defined in Database.Beam.Query.Types type QExprToIdentity (a, b, c, d, e, f, g) = (QExprToIdentity a, QExprToIdentity b, QExprToIdentity c, QExprToIdentity d, QExprToIdentity e, QExprToIdentity f, QExprToIdentity g)
type QExprToIdentity (a, b, c, d, e, f, g, h)
Instance details Defined in Database.Beam.Query.Types type QExprToIdentity (a, b, c, d, e, f, g, h) = (QExprToIdentity a, QExprToIdentity b, QExprToIdentity c, QExprToIdentity d, QExprToIdentity e, QExprToIdentity f, QExprToIdentity g, QExprToIdentity h)

newtype TableLens (f :: k -> Type) (db :: (k -> Type) -> Type) (x :: k) :: forall k. (k -> Type) -> ((k -> Type) -> Type) -> k -> Type #

Constructors

TableLens (Lens' (db f) (f x))

Instances

GDatabaseLenses (db f) (K1 R (f x) :: k1 -> Type) (K1 R (TableLens f db x) :: Type -> Type)
Instance details Defined in Database.Beam.Schema.Lenses Methods gDatabaseLenses :: Lens' (db f) (K1 R (f x) p) -> K1 R (TableLens f db x) ()

class Beamable (table :: (Type -> Type) -> Type) #

Instances

Beamable PgJSONKey
Instance details Defined in Database.Beam.Postgres.PgSpecific Methods zipBeamFieldsM :: Applicative m => (forall a. Columnar' f a -> Columnar' g a -> m (Columnar' h a)) -> PgJSONKey f -> PgJSONKey g -> m (PgJSONKey h) tblSkeleton :: TableSkeleton PgJSONKey
Beamable UsersMixin Source #
Instance details Defined in TsWeb.Tables.Session.Test Methods zipBeamFieldsM :: Applicative m => (forall a. Columnar' f a -> Columnar' g a -> m (Columnar' h a)) -> UsersMixin f -> UsersMixin g -> m (UsersMixin h) tblSkeleton :: TableSkeleton UsersMixin
Beamable (PrimaryKey (SessionT d)) Source #
Instance details Defined in TsWeb.Tables.Session Methods zipBeamFieldsM :: Applicative m => (forall a. Columnar' f a -> Columnar' g a -> m (Columnar' h a)) -> PrimaryKey (SessionT d) f -> PrimaryKey (SessionT d) g -> m (PrimaryKey (SessionT d) h) tblSkeleton :: TableSkeleton (PrimaryKey (SessionT d))
Beamable d => Beamable (SessionT d) Source #
Instance details Defined in TsWeb.Tables.Session Methods zipBeamFieldsM :: Applicative m => (forall a. Columnar' f a -> Columnar' g a -> m (Columnar' h a)) -> SessionT d f -> SessionT d g -> m (SessionT d h) tblSkeleton :: TableSkeleton (SessionT d)
Beamable (PgJSONEach valType)
Instance details Defined in Database.Beam.Postgres.PgSpecific Methods zipBeamFieldsM :: Applicative m => (forall a. Columnar' f a -> Columnar' g a -> m (Columnar' h a)) -> PgJSONEach valType f -> PgJSONEach valType g -> m (PgJSONEach valType h) tblSkeleton :: TableSkeleton (PgJSONEach valType)
Beamable (PgJSONElement a)
Instance details Defined in Database.Beam.Postgres.PgSpecific Methods zipBeamFieldsM :: Applicative m => (forall a0. Columnar' f a0 -> Columnar' g a0 -> m (Columnar' h a0)) -> PgJSONElement a f -> PgJSONElement a g -> m (PgJSONElement a h) tblSkeleton :: TableSkeleton (PgJSONElement a)
Beamable (PgUnnestArrayTbl a)
Instance details Defined in Database.Beam.Postgres.PgSpecific Methods zipBeamFieldsM :: Applicative m => (forall a0. Columnar' f a0 -> Columnar' g a0 -> m (Columnar' h a0)) -> PgUnnestArrayTbl a f -> PgUnnestArrayTbl a g -> m (PgUnnestArrayTbl a h) tblSkeleton :: TableSkeleton (PgUnnestArrayTbl a)
Beamable (PgUnnestArrayWithOrdinalityTbl a)
Instance details Defined in Database.Beam.Postgres.PgSpecific Methods zipBeamFieldsM :: Applicative m => (forall a0. Columnar' f a0 -> Columnar' g a0 -> m (Columnar' h a0)) -> PgUnnestArrayWithOrdinalityTbl a f -> PgUnnestArrayWithOrdinalityTbl a g -> m (PgUnnestArrayWithOrdinalityTbl a h) tblSkeleton :: TableSkeleton (PgUnnestArrayWithOrdinalityTbl a)

type C (f :: Type -> Type) a = Columnar f a #

type family Columnar (f :: Type -> Type) x :: Type where ... #

Equations

Columnar Exposed x = Exposed x
Columnar Identity x = x
Columnar (Lenses t f) x = LensFor (t f) (Columnar f x)
Columnar (Nullable c) x = Columnar c (Maybe x)
Columnar f x = f x

data Columnar' (f :: Type -> Type) a #

class Database be (db :: (Type -> Type) -> Type) #

Instances

Database be Db Source #
Instance details Defined in TsWeb.Tables.Session.Test Methods zipTables :: Monad m => Proxy be -> (forall tbl. (IsDatabaseEntity be tbl, DatabaseEntityRegularRequirements be tbl) => f tbl -> g tbl -> m (h tbl)) -> Db f -> Db g -> m (Db h)

data DatabaseEntity be (db :: (Type -> Type) -> Type) entityType #

Instances

Database be db => RenamableWithRule (db (EntityModification (DatabaseEntity be db) be))
Instance details Defined in Database.Beam.Schema.Tables Methods renamingFields :: (NonEmpty Text -> Text) -> db (EntityModification (DatabaseEntity be db) be)
IsDatabaseEntity be entity => RenamableWithRule (EntityModification (DatabaseEntity be db) be entity)
Instance details Defined in Database.Beam.Schema.Tables Methods renamingFields :: (NonEmpty Text -> Text) -> EntityModification (DatabaseEntity be db) be entity
(Selector f, IsDatabaseEntity be x, DatabaseEntityDefaultRequirements be x) => GAutoDbSettings (S1 f (K1 R (DatabaseEntity be db x) :: Type -> Type) p)
Instance details Defined in Database.Beam.Schema.Tables Methods autoDbSettings' :: S1 f (K1 R (DatabaseEntity be db x)) p

type DatabaseModification (f :: Type -> Type) be (db :: (Type -> Type) -> Type) = db (EntityModification f be) #

type DatabaseSettings be (db :: (Type -> Type) -> Type) = db (DatabaseEntity be db) #

data EntityModification (f :: Type -> Type) be e #

Instances

Database be db => RenamableWithRule (db (EntityModification (DatabaseEntity be db) be))
Instance details Defined in Database.Beam.Schema.Tables Methods renamingFields :: (NonEmpty Text -> Text) -> db (EntityModification (DatabaseEntity be db) be)
Semigroup (EntityModification f be e)
Instance details Defined in Database.Beam.Schema.Tables Methods (<>) :: EntityModification f be e -> EntityModification f be e -> EntityModification f be e # sconcat :: NonEmpty (EntityModification f be e) -> EntityModification f be e # stimes :: Integral b => b -> EntityModification f be e -> EntityModification f be e #
Monoid (EntityModification f be e)
Instance details Defined in Database.Beam.Schema.Tables Methods mempty :: EntityModification f be e # mappend :: EntityModification f be e -> EntityModification f be e -> EntityModification f be e # mconcat :: [EntityModification f be e] -> EntityModification f be e #
IsDatabaseEntity be entity => RenamableWithRule (EntityModification (DatabaseEntity be db) be entity)
Instance details Defined in Database.Beam.Schema.Tables Methods renamingFields :: (NonEmpty Text -> Text) -> EntityModification (DatabaseEntity be db) be entity

data FieldModification (f :: Type -> Type) a #

Instances

(Beamable tbl, RenamableField f) => RenamableWithRule (tbl (FieldModification f))
Instance details Defined in Database.Beam.Schema.Tables Methods renamingFields :: (NonEmpty Text -> Text) -> tbl (FieldModification f)
IsString (FieldModification (TableField tbl) a)
Instance details Defined in Database.Beam.Schema.Tables Methods fromString :: String -> FieldModification (TableField tbl) a #

type HaskellTable (table :: (Type -> Type) -> Type) = table Identity #

data LensFor t x where #

Constructors

LensFor :: forall t x. Generic t => Lens' t x -> LensFor t x

Instances

Generic (t m) => GTableLenses t m (K1 R x :: k -> Type) (K1 R (LensFor (t m) x) :: Type -> Type)
Instance details Defined in Database.Beam.Schema.Lenses Methods gTableLenses :: Proxy (K1 R x) -> Lens' (t m) (K1 R x p) -> K1 R (LensFor (t m) x) ()

data Lenses (t :: (Type -> Type) -> Type) (f :: Type -> Type) x #

Instances

(Generic (sub m), Generic (sub (Lenses t m)), GTableLenses t m (Rep (sub m)) (Rep (sub (Lenses t m)))) => GTableLenses t m (K1 R (sub m) :: k -> Type) (K1 R (sub (Lenses t m)) :: Type -> Type)
Instance details Defined in Database.Beam.Schema.Lenses Methods gTableLenses :: Proxy (K1 R (sub m)) -> Lens' (t m) (K1 R (sub m) p) -> K1 R (sub (Lenses t m)) ()
(Generic (sub (Nullable m)), Generic (sub (Nullable (Lenses t m))), GTableLenses t m (Rep (sub (Nullable m))) (Rep (sub (Nullable (Lenses t m))))) => GTableLenses t m (K1 R (sub (Nullable m)) :: k -> Type) (K1 R (sub (Nullable (Lenses t m))) :: Type -> Type)
Instance details Defined in Database.Beam.Schema.Lenses Methods gTableLenses :: Proxy (K1 R (sub (Nullable m))) -> Lens' (t m) (K1 R (sub (Nullable m)) p) -> K1 R (sub (Nullable (Lenses t m))) ()

class (Typeable table, Beamable table, Beamable (PrimaryKey table)) => Table (table :: (Type -> Type) -> Type) where #

Associated Types

data PrimaryKey (table :: (Type -> Type) -> Type) (column :: Type -> Type) :: Type #

Methods

primaryKey :: table column -> PrimaryKey table column #

Instances

(Beamable d, Typeable d) => Table (SessionT d) Source #
Instance details Defined in TsWeb.Tables.Session Associated Types data PrimaryKey (SessionT d) column :: Type # Methods primaryKey :: SessionT d column -> PrimaryKey (SessionT d) column #

data TableEntity (tbl :: (Type -> Type) -> Type) #

Instances

Beamable tbl => IsDatabaseEntity be (TableEntity tbl)
Instance details Defined in Database.Beam.Schema.Tables Associated Types data DatabaseEntityDescriptor be (TableEntity tbl) :: Type type DatabaseEntityDefaultRequirements be (TableEntity tbl) :: Constraint type DatabaseEntityRegularRequirements be (TableEntity tbl) :: Constraint Methods dbEntityName :: Lens' (DatabaseEntityDescriptor be (TableEntity tbl)) Text dbEntitySchema :: Traversal' (DatabaseEntityDescriptor be (TableEntity tbl)) (Maybe Text) dbEntityAuto :: Text -> DatabaseEntityDescriptor be (TableEntity tbl)
Beamable tbl => IsCheckedDatabaseEntity be (TableEntity tbl)
Instance details Defined in Database.Beam.Migrate.Types.CheckedEntities Associated Types data CheckedDatabaseEntityDescriptor be (TableEntity tbl) :: Type type CheckedDatabaseEntityDefaultRequirements be (TableEntity tbl) :: Constraint Methods unCheck :: CheckedDatabaseEntityDescriptor be (TableEntity tbl) -> DatabaseEntityDescriptor be (TableEntity tbl) unChecked :: Lens' (CheckedDatabaseEntityDescriptor be (TableEntity tbl)) (DatabaseEntityDescriptor be (TableEntity tbl)) collectEntityChecks :: CheckedDatabaseEntityDescriptor be (TableEntity tbl) -> [SomeDatabasePredicate] checkedDbEntityAuto :: Text -> CheckedDatabaseEntityDescriptor be (TableEntity tbl)
Beamable tbl => RenamableWithRule (FieldRenamer (DatabaseEntityDescriptor be (TableEntity tbl)))
Instance details Defined in Database.Beam.Schema.Tables Methods renamingFields :: (NonEmpty Text -> Text) -> FieldRenamer (DatabaseEntityDescriptor be (TableEntity tbl))
data DatabaseEntityDescriptor be (TableEntity tbl)
Instance details Defined in Database.Beam.Schema.Tables data DatabaseEntityDescriptor be (TableEntity tbl) where DatabaseTable :: forall be (tbl :: (Type -> Type) -> Type). Table tbl => {..} -> DatabaseEntityDescriptor be (TableEntity tbl)
type DatabaseEntityDefaultRequirements be (TableEntity tbl)
Instance details Defined in Database.Beam.Schema.Tables type DatabaseEntityDefaultRequirements be (TableEntity tbl) = (GDefaultTableFieldSettings (Rep (TableSettings tbl) ()), Generic (TableSettings tbl), Table tbl, Beamable tbl)
type DatabaseEntityRegularRequirements be (TableEntity tbl)
Instance details Defined in Database.Beam.Schema.Tables type DatabaseEntityRegularRequirements be (TableEntity tbl) = (Table tbl, Beamable tbl)
data CheckedDatabaseEntityDescriptor be (TableEntity tbl)
Instance details Defined in Database.Beam.Migrate.Types.CheckedEntities data CheckedDatabaseEntityDescriptor be (TableEntity tbl) where CheckedDatabaseTable :: forall be (tbl :: (Type -> Type) -> Type). Table tbl => DatabaseEntityDescriptor be (TableEntity tbl) -> [TableCheck] -> tbl (Const [FieldCheck] :: Type -> Type) -> CheckedDatabaseEntityDescriptor be (TableEntity tbl)
type CheckedDatabaseEntityDefaultRequirements be (TableEntity tbl)
Instance details Defined in Database.Beam.Migrate.Types.CheckedEntities type CheckedDatabaseEntityDefaultRequirements be (TableEntity tbl) = (DatabaseEntityDefaultRequirements be (TableEntity tbl), Generic (tbl (Const [FieldCheck] :: Type -> Type)), GMigratableTableSettings be (Rep (tbl Identity)) (Rep (tbl (Const [FieldCheck] :: Type -> Type))), BeamSqlBackend be)

data TableField (table :: (Type -> Type) -> Type) ty #

Instances

RenamableField (TableField tbl)
Instance details Defined in Database.Beam.Schema.Tables Methods renameField :: Proxy (TableField tbl) -> Proxy a -> (NonEmpty Text -> Text) -> Columnar (TableField tbl) a -> Columnar (TableField tbl) a
TagReducesTo (TableField tbl) (TableField tbl)
Instance details Defined in Database.Beam.Schema.Tables Methods reduceTag :: Functor m => (Columnar' (TableField tbl) a' -> m (Columnar' (TableField tbl) a')) -> Columnar' (TableField tbl) a -> m (Columnar' (TableField tbl) a)
Eq (TableField table ty)
Instance details Defined in Database.Beam.Schema.Tables Methods (==) :: TableField table ty -> TableField table ty -> Bool # (/=) :: TableField table ty -> TableField table ty -> Bool #
Show (TableField table ty)
Instance details Defined in Database.Beam.Schema.Tables Methods showsPrec :: Int -> TableField table ty -> ShowS # show :: TableField table ty -> String # showList :: [TableField table ty] -> ShowS #
IsString (FieldModification (TableField tbl) a)
Instance details Defined in Database.Beam.Schema.Tables Methods fromString :: String -> FieldModification (TableField tbl) a #
Selector f => GDefaultTableFieldSettings (S1 f (K1 R (TableField table field) :: Type -> Type) p)
Instance details Defined in Database.Beam.Schema.Tables Methods gDefTblFieldSettings :: Proxy (S1 f (K1 R (TableField table field)) p) -> S1 f (K1 R (TableField table field)) p

type TableSettings (table :: (Type -> Type) -> Type) = table (TableField table) #

data TxOpt Source #

Transaction option: provide WithTx to wrap operations in BEGIN/COMMIT, or NoTx to skip that.

Constructors

NoTx
WithTx

Instances

Bounded TxOpt Source #
Instance details Defined in TsWeb.Db Methods minBound :: TxOpt # maxBound :: TxOpt #
Enum TxOpt Source #
Instance details Defined in TsWeb.Db Methods succ :: TxOpt -> TxOpt # pred :: TxOpt -> TxOpt # toEnum :: Int -> TxOpt # fromEnum :: TxOpt -> Int # enumFrom :: TxOpt -> [TxOpt] # enumFromThen :: TxOpt -> TxOpt -> [TxOpt] # enumFromTo :: TxOpt -> TxOpt -> [TxOpt] # enumFromThenTo :: TxOpt -> TxOpt -> TxOpt -> [TxOpt] #
Eq TxOpt Source #
Instance details Defined in TsWeb.Db Methods (==) :: TxOpt -> TxOpt -> Bool # (/=) :: TxOpt -> TxOpt -> Bool #
Ord TxOpt Source #
Instance details Defined in TsWeb.Db Methods compare :: TxOpt -> TxOpt -> Ordering # (<) :: TxOpt -> TxOpt -> Bool # (<=) :: TxOpt -> TxOpt -> Bool # (>) :: TxOpt -> TxOpt -> Bool # (>=) :: TxOpt -> TxOpt -> Bool # max :: TxOpt -> TxOpt -> TxOpt # min :: TxOpt -> TxOpt -> TxOpt #
Show TxOpt Source #
Instance details Defined in TsWeb.Db Methods showsPrec :: Int -> TxOpt -> ShowS # show :: TxOpt -> String # showList :: [TxOpt] -> ShowS #

data QueryResult a Source #

Result of a select operation. This will either succeed with a QSimply, or fail with a QError (probably then an error in the db connection or table definitions).

Constructors

QSimply a
QError SqlError

Instances

Eq a => Eq (QueryResult a) Source #
Instance details Defined in TsWeb.Db Methods (==) :: QueryResult a -> QueryResult a -> Bool # (/=) :: QueryResult a -> QueryResult a -> Bool #
Show a => Show (QueryResult a) Source #
Instance details Defined in TsWeb.Db Methods showsPrec :: Int -> QueryResult a -> ShowS # show :: QueryResult a -> String # showList :: [QueryResult a] -> ShowS #

data ExecResult a Source #

The result of a select, insert, update, or delete operation. This adds a constraint error to the QueryResult, making it nicer to filter out conflicts when handling errors.

Constructors

ESimply a
EConstraint SqlError ConstraintViolation
EError SqlError

Instances

Eq a => Eq (ExecResult a) Source #
Instance details Defined in TsWeb.Db Methods (==) :: ExecResult a -> ExecResult a -> Bool # (/=) :: ExecResult a -> ExecResult a -> Bool #
Show a => Show (ExecResult a) Source #
Instance details Defined in TsWeb.Db Methods showsPrec :: Int -> ExecResult a -> ShowS # show :: ExecResult a -> String # showList :: [ExecResult a] -> ShowS #

runSelectReturningList :: (ReadOnlyM m, FromBackendRow Postgres a) => Sel a -> m [a] Source #

runSelectReturningOne :: (ReadOnlyM m, FromBackendRow Postgres a) => Sel a -> m (Maybe a) Source #

query :: ListContains n ReadOnlyPool xs => TxOpt -> RoPg a -> TsActionCtxT lts xs sessdata (QueryResult a) Source #

Run one or many Beam runSelectReturningList or runSelectReturningOne operation(s) against a view's ReadOnlyPool.

queryMaybe :: (ListContains n ReadOnlyPool xs, FromBackendRow Postgres a) => Sel a -> TsActionCtxT lts xs sessdata (QueryResult (Maybe a)) Source #

Run a single Beam select, returning a single (Maybe) value

queryList :: (ListContains n ReadOnlyPool xs, FromBackendRow Postgres a) => Sel a -> TsActionCtxT lts xs sessdata (QueryResult [a]) Source #

Run a single Beam select, returning a list of values

execute :: ListContains n ReadWritePool xs => TxOpt -> Pg a -> TsActionCtxT lts xs sessdata (ExecResult a) Source #

Run any arbitrary Pg monad in the context of a view, returning an ExecResult