Safe Haskell	Safe-Inferred
Language	Haskell2010

Hasura.Backends.Postgres.SQL.DML

Description

Postgres SQL DML

Provide types and combinators for defining Postgres SQL queries and mutations.

Synopsis

data Select = Select [(TableAlias, InnerCTE)] (Maybe DistinctExpr) [Extractor] (Maybe FromExp) (Maybe WhereFrag) (Maybe GroupByExp) (Maybe HavingExp) (Maybe OrderByExp) (Maybe LimitExp) (Maybe OffsetExp)
mkSelect :: Select
dummySelectList :: [Extractor]
newtype LimitExp = LimitExp SQLExp
newtype OffsetExp = OffsetExp SQLExp
newtype OrderByExp = OrderByExp (NonEmpty OrderByItem)
data OrderByItem = OrderByItem SQLExp (Maybe OrderType) (Maybe NullsOrder)
data OrderType
- = OTAsc
- | OTDesc
data NullsOrder
- = NullsFirst
- | NullsLast
newtype GroupByExp = GroupByExp [SQLExp]
newtype FromExp = FromExp [FromItem]
mkIdenFromExp :: TableIdentifier -> FromExp
mkSimpleFromExp :: QualifiedTable -> FromExp
mkSelFromExp :: Bool -> Select -> TableName -> FromItem
mkRowExp :: [Extractor] -> SQLExp
newtype HavingExp = HavingExp BoolExp
newtype WhereFrag = WhereFrag BoolExp
mkSIdenExp :: IsIdentifier a => a -> SQLExp
mkQIdenExp :: IsIdentifier b => TableIdentifier -> b -> SQLExp
data Qual
- = QualifiedIdentifier TableIdentifier (Maybe TypeAnn)
- | QualTable QualifiedTable
- | QualVar Text
mkQual :: QualifiedTable -> Qual
mkQIdentifier :: IsIdentifier b => TableIdentifier -> b -> QIdentifier
mkQIdentifierTable :: IsIdentifier a => QualifiedTable -> a -> QIdentifier
mkIdentifierSQLExp :: forall a. IsIdentifier a => Qual -> a -> SQLExp
data QIdentifier = QIdentifier Qual Identifier
data ColumnOp = ColumnOp {
- _colOp :: SQLOp
- _colExp :: SQLExp
}
newtype SQLOp = SQLOp Text
incOp :: SQLOp
mulOp :: SQLOp
jsonbPathOp :: SQLOp
jsonbConcatOp :: SQLOp
jsonbDeleteOp :: SQLOp
jsonbDeleteAtPathOp :: SQLOp
newtype TypeAnn = TypeAnn Text
mkTypeAnn :: CollectableType PGScalarType -> TypeAnn
intTypeAnn :: TypeAnn
numericTypeAnn :: TypeAnn
textTypeAnn :: TypeAnn
textArrTypeAnn :: TypeAnn
jsonTypeAnn :: TypeAnn
jsonbTypeAnn :: TypeAnn
boolTypeAnn :: TypeAnn
data CountType columnType
- = CTStar
- | CTSimple [columnType]
- | CTDistinct [columnType]
newtype TupleExp = TupleExp [SQLExp]
data SQLExp
- = SEPrep Int
- | SENull
- | SELit Text
- | SEUnsafe Text
- | SESelect Select
- | SEStar (Maybe Qual)
- | SEIdentifier Identifier
- | SERowIdentifier Identifier
- | SEQIdentifier QIdentifier
- | SEFnApp Text [SQLExp] (Maybe OrderByExp)
- | SEOpApp SQLOp [SQLExp]
- | SETyAnn SQLExp TypeAnn
- | SECond BoolExp SQLExp SQLExp
- | SEBool BoolExp
- | SEExcluded Identifier
- | SEArray [SQLExp]
- | SEArrayIndex SQLExp SQLExp
- | SETuple TupleExp
- | SECount (CountType QIdentifier)
- | SENamedArg Identifier SQLExp
- | SEFunction FunctionExp
newtype ColumnAlias = ColumnAlias {
- getColumnAlias :: Identifier
}
mkColumnAlias :: Text -> ColumnAlias
tableIdentifierToColumnAlias :: TableIdentifier -> ColumnAlias
toColumnAlias :: IsIdentifier a => a -> ColumnAlias
newtype TableAlias = TableAlias {
- getTableAlias :: Identifier
}
mkTableAlias :: Text -> TableAlias
tableAliasToIdentifier :: TableAlias -> TableIdentifier
toTableAlias :: IsIdentifier a => a -> TableAlias
countStar :: SQLExp
intToSQLExp :: Int -> SQLExp
int64ToSQLExp :: Int64 -> SQLExp
data Extractor = Extractor SQLExp (Maybe ColumnAlias)
mkSQLOpExp :: SQLOp -> SQLExp -> SQLExp -> SQLExp
columnDefaultValue :: SQLExp
handleIfNull :: SQLExp -> SQLExp -> SQLExp
applyJsonBuildObj :: [SQLExp] -> SQLExp
applyJsonBuildArray :: [SQLExp] -> SQLExp
applyRowToJson :: [Extractor] -> SQLExp
applyUppercase :: SQLExp -> SQLExp
mkExtr :: IsIdentifier a => a -> Extractor
data DistinctExpr
- = DistinctSimple
- | DistinctOn [SQLExp]
data FunctionArgs = FunctionArgs [SQLExp] (HashMap Text SQLExp)
data FunctionDefinitionListItem = FunctionDefinitionListItem {
- _dliColumn :: ColumnAlias
- _dliType :: PGScalarType
}
data FunctionAlias = FunctionAlias TableAlias (Maybe [FunctionDefinitionListItem])
mkFunctionAlias :: QualifiedObject FunctionName -> Maybe [(ColumnAlias, PGScalarType)] -> FunctionAlias
data FunctionExp = FunctionExp QualifiedFunction FunctionArgs (Maybe FunctionAlias)
data FromItem
- = FISimple QualifiedTable (Maybe TableAlias)
- | FIIdentifier TableIdentifier
- | FIFunc FunctionExp
- | FIUnnest [SQLExp] TableAlias [ColumnAlias]
- | FISelect Lateral Select TableAlias
- | FISelectWith Lateral (SelectWithG Select) TableAlias
- | FIValues ValuesExp TableAlias (Maybe [ColumnAlias])
- | FIJoin JoinExpr
mkSelFromItem :: Select -> TableAlias -> FromItem
mkSelectWithFromItem :: SelectWithG Select -> TableAlias -> FromItem
mkLateralFromItem :: Select -> TableAlias -> FromItem
newtype Lateral = Lateral Bool
data JoinExpr = JoinExpr FromItem JoinType FromItem JoinCond
data JoinType
- = Inner
- | LeftOuter
data JoinCond
- = JoinOn BoolExp
- | JoinUsing [Identifier]
data BoolExp
- = BELit Bool
- | BEBin BinOp BoolExp BoolExp
- | BENot BoolExp
- | BECompare CompareOp SQLExp SQLExp
- | BECompareAny CompareOp SQLExp SQLExp
- | BENull SQLExp
- | BENotNull SQLExp
- | BEExists Select
- | BEIN SQLExp [SQLExp]
- | BEExp SQLExp
simplifyBoolExp :: BoolExp -> BoolExp
mkExists :: FromItem -> BoolExp -> BoolExp
data BinOp
- = AndOp
- | OrOp
data CompareOp
- = SEQ
- | SGT
- | SLT
- | SNE
- | SGTE
- | SLTE
- | SLIKE
- | SNLIKE
- | SILIKE
- | SNILIKE
- | SSIMILAR
- | SNSIMILAR
- | SREGEX
- | SIREGEX
- | SNREGEX
- | SNIREGEX
- | SContains
- | SContainedIn
- | SHasKey
- | SHasKeysAny
- | SHasKeysAll
- | SMatchesFulltext
data SQLDelete = SQLDelete QualifiedTable (Maybe UsingExp) (Maybe WhereFrag) (Maybe RetExp)
data SQLUpdate = SQLUpdate {
- upTable :: QualifiedTable
- upSet :: SetExp
- upFrom :: Maybe FromExp
- upWhere :: Maybe WhereFrag
- upRet :: Maybe RetExp
}
newtype SetExp = SetExp [SetExpItem]
newtype SetExpItem = SetExpItem (PGCol, SQLExp)
buildUpsertSetExp :: [PGCol] -> HashMap PGCol SQLExp -> SetExp
newtype RetExp = RetExp [Extractor]
selectStar :: Extractor
selectStar' :: Qual -> Extractor
returningStar :: RetExp
data SQLConflictTarget
- = SQLColumn [PGCol]
- | SQLConstraint ConstraintName
data SQLConflict
- = DoNothing (Maybe SQLConflictTarget)
- | Update SQLConflictTarget SetExp (Maybe WhereFrag)
newtype ValuesExp = ValuesExp [TupleExp]
data SQLInsert = SQLInsert {
- siTable :: QualifiedTable
- siCols :: [PGCol]
- siValues :: ValuesExp
- siConflict :: Maybe SQLConflict
- siRet :: Maybe RetExp
}
data TopLevelCTE
- = CTESelect Select
- | CTEInsert SQLInsert
- | CTEUpdate SQLUpdate
- | CTEDelete SQLDelete
- | CTEUnsafeRawSQL (InterpolatedQuery SQLExp)
data InnerCTE
- = ICTESelect Select
- | ICTEUnsafeRawSQL (InterpolatedQuery SQLExp)
data SelectWithG statement = SelectWith {
- swCTEs :: [(TableAlias, statement)]
- swSelect :: Select
}
type SelectWith = SelectWithG TopLevelCTE

Documentation

data Select Source #

An select statement that does not require mutation CTEs.

See SelectWithG or SelectWithG for select statements with mutations as CTEs.

Constructors

Select [(TableAlias, InnerCTE)] (Maybe DistinctExpr) [Extractor] (Maybe FromExp) (Maybe WhereFrag) (Maybe GroupByExp) (Maybe HavingExp) (Maybe OrderByExp) (Maybe LimitExp) (Maybe OffsetExp)

Instances

Instances details

Data Select Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Select -> c Select # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Select # toConstr :: Select -> Constr # dataTypeOf :: Select -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Select) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Select) # gmapT :: (forall b. Data b => b -> b) -> Select -> Select # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Select -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Select -> r # gmapQ :: (forall d. Data d => d -> u) -> Select -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Select -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Select -> m Select # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Select -> m Select # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Select -> m Select #
Generic Select Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Associated Types type Rep Select :: Type -> Type # Methods from :: Select -> Rep Select x # to :: Rep Select x -> Select #
Show Select Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods showsPrec :: Int -> Select -> ShowS # show :: Select -> String # showList :: [Select] -> ShowS #
NFData Select Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods rnf :: Select -> () #
Eq Select Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods (==) :: Select -> Select -> Bool # (/=) :: Select -> Select -> Bool #
ToSQL Select Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods toSQL :: Select -> Builder Source #
Hashable Select Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods hashWithSalt :: Int -> Select -> Int Source # hash :: Select -> Int Source #
type Rep Select Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML type Rep Select = D1 ('MetaData "Select" "Hasura.Backends.Postgres.SQL.DML" "graphql-engine-1.0.0-inplace" 'False) (C1 ('MetaCons "Select" 'PrefixI 'True) (((S1 ('MetaSel ('Just "selCTEs") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 [(TableAlias, InnerCTE)]) :: S1 ('MetaSel ('Just "selDistinct") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (Maybe DistinctExpr))) :: (S1 ('MetaSel ('Just "selExtr") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 [Extractor]) :: (S1 ('MetaSel ('Just "selFrom") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (Maybe FromExp)) :: S1 ('MetaSel ('Just "selWhere") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (Maybe WhereFrag))))) :: ((S1 ('MetaSel ('Just "selGroupBy") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (Maybe GroupByExp)) :: S1 ('MetaSel ('Just "selHaving") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (Maybe HavingExp))) :: (S1 ('MetaSel ('Just "selOrderBy") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (Maybe OrderByExp)) :: (S1 ('MetaSel ('Just "selLimit") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (Maybe LimitExp)) :*: S1 ('MetaSel ('Just "selOffset") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (Maybe OffsetExp)))))))

mkSelect :: Select Source #

An empty select statement.

dummySelectList :: [Extractor] Source #

A dummy select list to avoid an empty select list, which doesn't work for cockroach db. This is just the value 1 without an alias.

newtype LimitExp Source #

Constructors

LimitExp SQLExp

Instances

Instances details

Data LimitExp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> LimitExp -> c LimitExp # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c LimitExp # toConstr :: LimitExp -> Constr # dataTypeOf :: LimitExp -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c LimitExp) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c LimitExp) # gmapT :: (forall b. Data b => b -> b) -> LimitExp -> LimitExp # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> LimitExp -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> LimitExp -> r # gmapQ :: (forall d. Data d => d -> u) -> LimitExp -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> LimitExp -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> LimitExp -> m LimitExp # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> LimitExp -> m LimitExp # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> LimitExp -> m LimitExp #
Show LimitExp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods showsPrec :: Int -> LimitExp -> ShowS # show :: LimitExp -> String # showList :: [LimitExp] -> ShowS #
NFData LimitExp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods rnf :: LimitExp -> () #
Eq LimitExp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods (==) :: LimitExp -> LimitExp -> Bool # (/=) :: LimitExp -> LimitExp -> Bool #
ToSQL LimitExp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods toSQL :: LimitExp -> Builder Source #
Hashable LimitExp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods hashWithSalt :: Int -> LimitExp -> Int Source # hash :: LimitExp -> Int Source #

newtype OffsetExp Source #

Constructors

OffsetExp SQLExp

Instances

Instances details

Data OffsetExp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> OffsetExp -> c OffsetExp # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c OffsetExp # toConstr :: OffsetExp -> Constr # dataTypeOf :: OffsetExp -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c OffsetExp) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OffsetExp) # gmapT :: (forall b. Data b => b -> b) -> OffsetExp -> OffsetExp # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> OffsetExp -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> OffsetExp -> r # gmapQ :: (forall d. Data d => d -> u) -> OffsetExp -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> OffsetExp -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> OffsetExp -> m OffsetExp # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> OffsetExp -> m OffsetExp # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> OffsetExp -> m OffsetExp #
Show OffsetExp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods showsPrec :: Int -> OffsetExp -> ShowS # show :: OffsetExp -> String # showList :: [OffsetExp] -> ShowS #
NFData OffsetExp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods rnf :: OffsetExp -> () #
Eq OffsetExp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods (==) :: OffsetExp -> OffsetExp -> Bool # (/=) :: OffsetExp -> OffsetExp -> Bool #
ToSQL OffsetExp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods toSQL :: OffsetExp -> Builder Source #
Hashable OffsetExp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods hashWithSalt :: Int -> OffsetExp -> Int Source # hash :: OffsetExp -> Int Source #

newtype OrderByExp Source #

Constructors

OrderByExp (NonEmpty OrderByItem)

Instances

Instances details

Data OrderByExp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> OrderByExp -> c OrderByExp # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c OrderByExp # toConstr :: OrderByExp -> Constr # dataTypeOf :: OrderByExp -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c OrderByExp) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OrderByExp) # gmapT :: (forall b. Data b => b -> b) -> OrderByExp -> OrderByExp # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> OrderByExp -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> OrderByExp -> r # gmapQ :: (forall d. Data d => d -> u) -> OrderByExp -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> OrderByExp -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> OrderByExp -> m OrderByExp # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> OrderByExp -> m OrderByExp # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> OrderByExp -> m OrderByExp #
Show OrderByExp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods showsPrec :: Int -> OrderByExp -> ShowS # show :: OrderByExp -> String # showList :: [OrderByExp] -> ShowS #
NFData OrderByExp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods rnf :: OrderByExp -> () #
Eq OrderByExp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods (==) :: OrderByExp -> OrderByExp -> Bool # (/=) :: OrderByExp -> OrderByExp -> Bool #
ToSQL OrderByExp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods toSQL :: OrderByExp -> Builder Source #
Hashable OrderByExp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods hashWithSalt :: Int -> OrderByExp -> Int Source # hash :: OrderByExp -> Int Source #

data OrderByItem Source #

Constructors

OrderByItem SQLExp (Maybe OrderType) (Maybe NullsOrder)

Instances

Instances details

Data OrderByItem Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> OrderByItem -> c OrderByItem # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c OrderByItem # toConstr :: OrderByItem -> Constr # dataTypeOf :: OrderByItem -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c OrderByItem) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OrderByItem) # gmapT :: (forall b. Data b => b -> b) -> OrderByItem -> OrderByItem # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> OrderByItem -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> OrderByItem -> r # gmapQ :: (forall d. Data d => d -> u) -> OrderByItem -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> OrderByItem -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> OrderByItem -> m OrderByItem # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> OrderByItem -> m OrderByItem # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> OrderByItem -> m OrderByItem #
Generic OrderByItem Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Associated Types type Rep OrderByItem :: Type -> Type # Methods from :: OrderByItem -> Rep OrderByItem x # to :: Rep OrderByItem x -> OrderByItem #
Show OrderByItem Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods showsPrec :: Int -> OrderByItem -> ShowS # show :: OrderByItem -> String # showList :: [OrderByItem] -> ShowS #
NFData OrderByItem Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods rnf :: OrderByItem -> () #
Eq OrderByItem Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods (==) :: OrderByItem -> OrderByItem -> Bool # (/=) :: OrderByItem -> OrderByItem -> Bool #
ToSQL OrderByItem Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods toSQL :: OrderByItem -> Builder Source #
Hashable OrderByItem Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods hashWithSalt :: Int -> OrderByItem -> Int Source # hash :: OrderByItem -> Int Source #
type Rep OrderByItem Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML type Rep OrderByItem = D1 ('MetaData "OrderByItem" "Hasura.Backends.Postgres.SQL.DML" "graphql-engine-1.0.0-inplace" 'False) (C1 ('MetaCons "OrderByItem" 'PrefixI 'True) (S1 ('MetaSel ('Just "oExpression") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 SQLExp) :: (S1 ('MetaSel ('Just "oOrdering") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (Maybe OrderType)) :: S1 ('MetaSel ('Just "oNullsOrder") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (Maybe NullsOrder)))))

data OrderType Source #

Order by ascending or descending

Constructors

OTAsc
OTDesc

Instances

Instances details

FromJSON OrderType Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods parseJSON :: Value -> Parser OrderType Source # parseJSONList :: Value -> Parser [OrderType] Source #
ToJSON OrderType Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods toJSON :: OrderType -> Value Source # toEncoding :: OrderType -> Encoding Source # toJSONList :: [OrderType] -> Value Source # toEncodingList :: [OrderType] -> Encoding Source #
Data OrderType Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> OrderType -> c OrderType # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c OrderType # toConstr :: OrderType -> Constr # dataTypeOf :: OrderType -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c OrderType) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OrderType) # gmapT :: (forall b. Data b => b -> b) -> OrderType -> OrderType # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> OrderType -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> OrderType -> r # gmapQ :: (forall d. Data d => d -> u) -> OrderType -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> OrderType -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> OrderType -> m OrderType # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> OrderType -> m OrderType # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> OrderType -> m OrderType #
Generic OrderType Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Associated Types type Rep OrderType :: Type -> Type # Methods from :: OrderType -> Rep OrderType x # to :: Rep OrderType x -> OrderType #
Show OrderType Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods showsPrec :: Int -> OrderType -> ShowS # show :: OrderType -> String # showList :: [OrderType] -> ShowS #
NFData OrderType Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods rnf :: OrderType -> () #
Eq OrderType Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods (==) :: OrderType -> OrderType -> Bool # (/=) :: OrderType -> OrderType -> Bool #
ToSQL OrderType Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods toSQL :: OrderType -> Builder Source #
Hashable OrderType Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods hashWithSalt :: Int -> OrderType -> Int Source # hash :: OrderType -> Int Source #
type Rep OrderType Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML type Rep OrderType = D1 ('MetaData "OrderType" "Hasura.Backends.Postgres.SQL.DML" "graphql-engine-1.0.0-inplace" 'False) (C1 ('MetaCons "OTAsc" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "OTDesc" 'PrefixI 'False) (U1 :: Type -> Type))

data NullsOrder Source #

Constructors

NullsFirst
NullsLast

Instances

Instances details

FromJSON NullsOrder Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods parseJSON :: Value -> Parser NullsOrder Source # parseJSONList :: Value -> Parser [NullsOrder] Source #
ToJSON NullsOrder Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods toJSON :: NullsOrder -> Value Source # toEncoding :: NullsOrder -> Encoding Source # toJSONList :: [NullsOrder] -> Value Source # toEncodingList :: [NullsOrder] -> Encoding Source #
Data NullsOrder Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> NullsOrder -> c NullsOrder # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c NullsOrder # toConstr :: NullsOrder -> Constr # dataTypeOf :: NullsOrder -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c NullsOrder) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NullsOrder) # gmapT :: (forall b. Data b => b -> b) -> NullsOrder -> NullsOrder # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NullsOrder -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NullsOrder -> r # gmapQ :: (forall d. Data d => d -> u) -> NullsOrder -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> NullsOrder -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> NullsOrder -> m NullsOrder # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NullsOrder -> m NullsOrder # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NullsOrder -> m NullsOrder #
Generic NullsOrder Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Associated Types type Rep NullsOrder :: Type -> Type # Methods from :: NullsOrder -> Rep NullsOrder x # to :: Rep NullsOrder x -> NullsOrder #
Show NullsOrder Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods showsPrec :: Int -> NullsOrder -> ShowS # show :: NullsOrder -> String # showList :: [NullsOrder] -> ShowS #
NFData NullsOrder Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods rnf :: NullsOrder -> () #
Eq NullsOrder Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods (==) :: NullsOrder -> NullsOrder -> Bool # (/=) :: NullsOrder -> NullsOrder -> Bool #
ToSQL NullsOrder Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods toSQL :: NullsOrder -> Builder Source #
Hashable NullsOrder Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods hashWithSalt :: Int -> NullsOrder -> Int Source # hash :: NullsOrder -> Int Source #
type Rep NullsOrder Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML type Rep NullsOrder = D1 ('MetaData "NullsOrder" "Hasura.Backends.Postgres.SQL.DML" "graphql-engine-1.0.0-inplace" 'False) (C1 ('MetaCons "NullsFirst" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "NullsLast" 'PrefixI 'False) (U1 :: Type -> Type))

newtype GroupByExp Source #

Constructors

GroupByExp [SQLExp]

Instances

Instances details

Data GroupByExp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> GroupByExp -> c GroupByExp # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c GroupByExp # toConstr :: GroupByExp -> Constr # dataTypeOf :: GroupByExp -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c GroupByExp) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c GroupByExp) # gmapT :: (forall b. Data b => b -> b) -> GroupByExp -> GroupByExp # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> GroupByExp -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> GroupByExp -> r # gmapQ :: (forall d. Data d => d -> u) -> GroupByExp -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> GroupByExp -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> GroupByExp -> m GroupByExp # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> GroupByExp -> m GroupByExp # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> GroupByExp -> m GroupByExp #
Show GroupByExp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods showsPrec :: Int -> GroupByExp -> ShowS # show :: GroupByExp -> String # showList :: [GroupByExp] -> ShowS #
NFData GroupByExp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods rnf :: GroupByExp -> () #
Eq GroupByExp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods (==) :: GroupByExp -> GroupByExp -> Bool # (/=) :: GroupByExp -> GroupByExp -> Bool #
ToSQL GroupByExp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods toSQL :: GroupByExp -> Builder Source #
Hashable GroupByExp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods hashWithSalt :: Int -> GroupByExp -> Int Source # hash :: GroupByExp -> Int Source #

newtype FromExp Source #

Constructors

FromExp [FromItem]

Instances

Instances details

Data FromExp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FromExp -> c FromExp # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c FromExp # toConstr :: FromExp -> Constr # dataTypeOf :: FromExp -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c FromExp) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FromExp) # gmapT :: (forall b. Data b => b -> b) -> FromExp -> FromExp # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FromExp -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FromExp -> r # gmapQ :: (forall d. Data d => d -> u) -> FromExp -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> FromExp -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> FromExp -> m FromExp # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FromExp -> m FromExp # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FromExp -> m FromExp #
Show FromExp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods showsPrec :: Int -> FromExp -> ShowS # show :: FromExp -> String # showList :: [FromExp] -> ShowS #
NFData FromExp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods rnf :: FromExp -> () #
Eq FromExp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods (==) :: FromExp -> FromExp -> Bool # (/=) :: FromExp -> FromExp -> Bool #
ToSQL FromExp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods toSQL :: FromExp -> Builder Source #
Hashable FromExp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods hashWithSalt :: Int -> FromExp -> Int Source # hash :: FromExp -> Int Source #

mkIdenFromExp :: TableIdentifier -> FromExp Source #

mkSimpleFromExp :: QualifiedTable -> FromExp Source #

mkSelFromExp :: Bool -> Select -> TableName -> FromItem Source #

mkRowExp :: [Extractor] -> SQLExp Source #

newtype HavingExp Source #

Constructors

HavingExp BoolExp

Instances

Instances details

Data HavingExp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HavingExp -> c HavingExp # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HavingExp # toConstr :: HavingExp -> Constr # dataTypeOf :: HavingExp -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HavingExp) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HavingExp) # gmapT :: (forall b. Data b => b -> b) -> HavingExp -> HavingExp # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HavingExp -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HavingExp -> r # gmapQ :: (forall d. Data d => d -> u) -> HavingExp -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> HavingExp -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HavingExp -> m HavingExp # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HavingExp -> m HavingExp # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HavingExp -> m HavingExp #
Show HavingExp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods showsPrec :: Int -> HavingExp -> ShowS # show :: HavingExp -> String # showList :: [HavingExp] -> ShowS #
NFData HavingExp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods rnf :: HavingExp -> () #
Eq HavingExp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods (==) :: HavingExp -> HavingExp -> Bool # (/=) :: HavingExp -> HavingExp -> Bool #
ToSQL HavingExp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods toSQL :: HavingExp -> Builder Source #
Hashable HavingExp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods hashWithSalt :: Int -> HavingExp -> Int Source # hash :: HavingExp -> Int Source #

newtype WhereFrag Source #

Constructors

WhereFrag BoolExp

Instances

Instances details

Data WhereFrag Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> WhereFrag -> c WhereFrag # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c WhereFrag # toConstr :: WhereFrag -> Constr # dataTypeOf :: WhereFrag -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c WhereFrag) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c WhereFrag) # gmapT :: (forall b. Data b => b -> b) -> WhereFrag -> WhereFrag # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> WhereFrag -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> WhereFrag -> r # gmapQ :: (forall d. Data d => d -> u) -> WhereFrag -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> WhereFrag -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> WhereFrag -> m WhereFrag # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> WhereFrag -> m WhereFrag # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> WhereFrag -> m WhereFrag #
Show WhereFrag Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods showsPrec :: Int -> WhereFrag -> ShowS # show :: WhereFrag -> String # showList :: [WhereFrag] -> ShowS #
NFData WhereFrag Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods rnf :: WhereFrag -> () #
Eq WhereFrag Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods (==) :: WhereFrag -> WhereFrag -> Bool # (/=) :: WhereFrag -> WhereFrag -> Bool #
ToSQL WhereFrag Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods toSQL :: WhereFrag -> Builder Source #
Hashable WhereFrag Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods hashWithSalt :: Int -> WhereFrag -> Int Source # hash :: WhereFrag -> Int Source #

mkSIdenExp :: IsIdentifier a => a -> SQLExp Source #

mkQIdenExp :: IsIdentifier b => TableIdentifier -> b -> SQLExp Source #

data Qual Source #

Constructors

QualifiedIdentifier TableIdentifier (Maybe TypeAnn)
QualTable QualifiedTable
QualVar Text

Instances

Instances details

Data Qual Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Qual -> c Qual # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Qual # toConstr :: Qual -> Constr # dataTypeOf :: Qual -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Qual) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Qual) # gmapT :: (forall b. Data b => b -> b) -> Qual -> Qual # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Qual -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Qual -> r # gmapQ :: (forall d. Data d => d -> u) -> Qual -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Qual -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Qual -> m Qual # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Qual -> m Qual # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Qual -> m Qual #
Generic Qual Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Associated Types type Rep Qual :: Type -> Type # Methods from :: Qual -> Rep Qual x # to :: Rep Qual x -> Qual #
Show Qual Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods showsPrec :: Int -> Qual -> ShowS # show :: Qual -> String # showList :: [Qual] -> ShowS #
NFData Qual Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods rnf :: Qual -> () #
Eq Qual Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods (==) :: Qual -> Qual -> Bool # (/=) :: Qual -> Qual -> Bool #
ToSQL Qual Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods toSQL :: Qual -> Builder Source #
Hashable Qual Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods hashWithSalt :: Int -> Qual -> Int Source # hash :: Qual -> Int Source #
type Rep Qual Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML type Rep Qual = D1 ('MetaData "Qual" "Hasura.Backends.Postgres.SQL.DML" "graphql-engine-1.0.0-inplace" 'False) (C1 ('MetaCons "QualifiedIdentifier" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 TableIdentifier) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (Maybe TypeAnn))) :+: (C1 ('MetaCons "QualTable" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 QualifiedTable)) :+: C1 ('MetaCons "QualVar" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Text))))

mkQual :: QualifiedTable -> Qual Source #

mkQIdentifier :: IsIdentifier b => TableIdentifier -> b -> QIdentifier Source #

mkQIdentifierTable :: IsIdentifier a => QualifiedTable -> a -> QIdentifier Source #

mkIdentifierSQLExp :: forall a. IsIdentifier a => Qual -> a -> SQLExp Source #

data QIdentifier Source #

Constructors

QIdentifier Qual Identifier

Instances

Instances details

Data QIdentifier Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> QIdentifier -> c QIdentifier # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c QIdentifier # toConstr :: QIdentifier -> Constr # dataTypeOf :: QIdentifier -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c QIdentifier) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c QIdentifier) # gmapT :: (forall b. Data b => b -> b) -> QIdentifier -> QIdentifier # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> QIdentifier -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> QIdentifier -> r # gmapQ :: (forall d. Data d => d -> u) -> QIdentifier -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> QIdentifier -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> QIdentifier -> m QIdentifier # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> QIdentifier -> m QIdentifier # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> QIdentifier -> m QIdentifier #
Generic QIdentifier Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Associated Types type Rep QIdentifier :: Type -> Type # Methods from :: QIdentifier -> Rep QIdentifier x # to :: Rep QIdentifier x -> QIdentifier #
Show QIdentifier Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods showsPrec :: Int -> QIdentifier -> ShowS # show :: QIdentifier -> String # showList :: [QIdentifier] -> ShowS #
NFData QIdentifier Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods rnf :: QIdentifier -> () #
Eq QIdentifier Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods (==) :: QIdentifier -> QIdentifier -> Bool # (/=) :: QIdentifier -> QIdentifier -> Bool #
ToSQL QIdentifier Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods toSQL :: QIdentifier -> Builder Source #
Hashable QIdentifier Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods hashWithSalt :: Int -> QIdentifier -> Int Source # hash :: QIdentifier -> Int Source #
ToSQL (CountType QIdentifier) Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods toSQL :: CountType QIdentifier -> Builder Source #
type Rep QIdentifier Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML type Rep QIdentifier = D1 ('MetaData "QIdentifier" "Hasura.Backends.Postgres.SQL.DML" "graphql-engine-1.0.0-inplace" 'False) (C1 ('MetaCons "QIdentifier" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Qual) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Identifier)))

data ColumnOp Source #

Constructors

ColumnOp
Fields _colOp :: SQLOp _colExp :: SQLExp

Instances

Instances details

Data ColumnOp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ColumnOp -> c ColumnOp # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ColumnOp # toConstr :: ColumnOp -> Constr # dataTypeOf :: ColumnOp -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ColumnOp) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ColumnOp) # gmapT :: (forall b. Data b => b -> b) -> ColumnOp -> ColumnOp # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ColumnOp -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ColumnOp -> r # gmapQ :: (forall d. Data d => d -> u) -> ColumnOp -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ColumnOp -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ColumnOp -> m ColumnOp # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ColumnOp -> m ColumnOp # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ColumnOp -> m ColumnOp #
Generic ColumnOp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Associated Types type Rep ColumnOp :: Type -> Type # Methods from :: ColumnOp -> Rep ColumnOp x # to :: Rep ColumnOp x -> ColumnOp #
Show ColumnOp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods showsPrec :: Int -> ColumnOp -> ShowS # show :: ColumnOp -> String # showList :: [ColumnOp] -> ShowS #
NFData ColumnOp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods rnf :: ColumnOp -> () #
Eq ColumnOp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods (==) :: ColumnOp -> ColumnOp -> Bool # (/=) :: ColumnOp -> ColumnOp -> Bool #
Hashable ColumnOp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods hashWithSalt :: Int -> ColumnOp -> Int Source # hash :: ColumnOp -> Int Source #
type Rep ColumnOp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML type Rep ColumnOp = D1 ('MetaData "ColumnOp" "Hasura.Backends.Postgres.SQL.DML" "graphql-engine-1.0.0-inplace" 'False) (C1 ('MetaCons "ColumnOp" 'PrefixI 'True) (S1 ('MetaSel ('Just "_colOp") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 SQLOp) :*: S1 ('MetaSel ('Just "_colExp") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 SQLExp)))

newtype SQLOp Source #

Constructors

SQLOp Text

Instances

Instances details

Data SQLOp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SQLOp -> c SQLOp # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SQLOp # toConstr :: SQLOp -> Constr # dataTypeOf :: SQLOp -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SQLOp) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SQLOp) # gmapT :: (forall b. Data b => b -> b) -> SQLOp -> SQLOp # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SQLOp -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SQLOp -> r # gmapQ :: (forall d. Data d => d -> u) -> SQLOp -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SQLOp -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SQLOp -> m SQLOp # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SQLOp -> m SQLOp # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SQLOp -> m SQLOp #
Show SQLOp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods showsPrec :: Int -> SQLOp -> ShowS # show :: SQLOp -> String # showList :: [SQLOp] -> ShowS #
NFData SQLOp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods rnf :: SQLOp -> () #
Eq SQLOp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods (==) :: SQLOp -> SQLOp -> Bool # (/=) :: SQLOp -> SQLOp -> Bool #
Hashable SQLOp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods hashWithSalt :: Int -> SQLOp -> Int Source # hash :: SQLOp -> Int Source #

incOp :: SQLOp Source #

mulOp :: SQLOp Source #

jsonbPathOp :: SQLOp Source #

jsonbConcatOp :: SQLOp Source #

jsonbDeleteOp :: SQLOp Source #

jsonbDeleteAtPathOp :: SQLOp Source #

newtype TypeAnn Source #

Constructors

TypeAnn Text

Instances

Instances details

Data TypeAnn Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TypeAnn -> c TypeAnn # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TypeAnn # toConstr :: TypeAnn -> Constr # dataTypeOf :: TypeAnn -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c TypeAnn) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TypeAnn) # gmapT :: (forall b. Data b => b -> b) -> TypeAnn -> TypeAnn # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TypeAnn -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TypeAnn -> r # gmapQ :: (forall d. Data d => d -> u) -> TypeAnn -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> TypeAnn -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> TypeAnn -> m TypeAnn # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TypeAnn -> m TypeAnn # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TypeAnn -> m TypeAnn #
Show TypeAnn Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods showsPrec :: Int -> TypeAnn -> ShowS # show :: TypeAnn -> String # showList :: [TypeAnn] -> ShowS #
NFData TypeAnn Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods rnf :: TypeAnn -> () #
Eq TypeAnn Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods (==) :: TypeAnn -> TypeAnn -> Bool # (/=) :: TypeAnn -> TypeAnn -> Bool #
ToSQL TypeAnn Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods toSQL :: TypeAnn -> Builder Source #
Hashable TypeAnn Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods hashWithSalt :: Int -> TypeAnn -> Int Source # hash :: TypeAnn -> Int Source #

mkTypeAnn :: CollectableType PGScalarType -> TypeAnn Source #

intTypeAnn :: TypeAnn Source #

numericTypeAnn :: TypeAnn Source #

textTypeAnn :: TypeAnn Source #

textArrTypeAnn :: TypeAnn Source #

jsonTypeAnn :: TypeAnn Source #

jsonbTypeAnn :: TypeAnn Source #

boolTypeAnn :: TypeAnn Source #

data CountType columnType Source #

Constructors

CTStar
CTSimple [columnType]
CTDistinct [columnType]

Instances

Instances details

Foldable CountType Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods fold :: Monoid m => CountType m -> m # foldMap :: Monoid m => (a -> m) -> CountType a -> m # foldMap' :: Monoid m => (a -> m) -> CountType a -> m # foldr :: (a -> b -> b) -> b -> CountType a -> b # foldr' :: (a -> b -> b) -> b -> CountType a -> b # foldl :: (b -> a -> b) -> b -> CountType a -> b # foldl' :: (b -> a -> b) -> b -> CountType a -> b # foldr1 :: (a -> a -> a) -> CountType a -> a # foldl1 :: (a -> a -> a) -> CountType a -> a # toList :: CountType a -> [a] # null :: CountType a -> Bool # length :: CountType a -> Int # elem :: Eq a => a -> CountType a -> Bool # maximum :: Ord a => CountType a -> a # minimum :: Ord a => CountType a -> a # sum :: Num a => CountType a -> a # product :: Num a => CountType a -> a #
Traversable CountType Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods traverse :: Applicative f => (a -> f b) -> CountType a -> f (CountType b) # sequenceA :: Applicative f => CountType (f a) -> f (CountType a) # mapM :: Monad m => (a -> m b) -> CountType a -> m (CountType b) # sequence :: Monad m => CountType (m a) -> m (CountType a) #
Functor CountType Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods fmap :: (a -> b) -> CountType a -> CountType b # (<$) :: a -> CountType b -> CountType a #
Data columnType => Data (CountType columnType) Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CountType columnType -> c (CountType columnType) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (CountType columnType) # toConstr :: CountType columnType -> Constr # dataTypeOf :: CountType columnType -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (CountType columnType)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (CountType columnType)) # gmapT :: (forall b. Data b => b -> b) -> CountType columnType -> CountType columnType # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CountType columnType -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CountType columnType -> r # gmapQ :: (forall d. Data d => d -> u) -> CountType columnType -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> CountType columnType -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> CountType columnType -> m (CountType columnType) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CountType columnType -> m (CountType columnType) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CountType columnType -> m (CountType columnType) #
Generic (CountType columnType) Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Associated Types type Rep (CountType columnType) :: Type -> Type # Methods from :: CountType columnType -> Rep (CountType columnType) x # to :: Rep (CountType columnType) x -> CountType columnType #
Show columnType => Show (CountType columnType) Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods showsPrec :: Int -> CountType columnType -> ShowS # show :: CountType columnType -> String # showList :: [CountType columnType] -> ShowS #
NFData columnType => NFData (CountType columnType) Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods rnf :: CountType columnType -> () #
Eq columnType => Eq (CountType columnType) Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods (==) :: CountType columnType -> CountType columnType -> Bool # (/=) :: CountType columnType -> CountType columnType -> Bool #
ToSQL (CountType QIdentifier) Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods toSQL :: CountType QIdentifier -> Builder Source #
Hashable columnType => Hashable (CountType columnType) Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods hashWithSalt :: Int -> CountType columnType -> Int Source # hash :: CountType columnType -> Int Source #
type Rep (CountType columnType) Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML type Rep (CountType columnType) = D1 ('MetaData "CountType" "Hasura.Backends.Postgres.SQL.DML" "graphql-engine-1.0.0-inplace" 'False) (C1 ('MetaCons "CTStar" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "CTSimple" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 [columnType])) :+: C1 ('MetaCons "CTDistinct" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 [columnType]))))

newtype TupleExp Source #

Constructors

TupleExp [SQLExp]

Instances

Instances details

Data TupleExp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TupleExp -> c TupleExp # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TupleExp # toConstr :: TupleExp -> Constr # dataTypeOf :: TupleExp -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c TupleExp) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TupleExp) # gmapT :: (forall b. Data b => b -> b) -> TupleExp -> TupleExp # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TupleExp -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TupleExp -> r # gmapQ :: (forall d. Data d => d -> u) -> TupleExp -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> TupleExp -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> TupleExp -> m TupleExp # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TupleExp -> m TupleExp # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TupleExp -> m TupleExp #
Show TupleExp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods showsPrec :: Int -> TupleExp -> ShowS # show :: TupleExp -> String # showList :: [TupleExp] -> ShowS #
NFData TupleExp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods rnf :: TupleExp -> () #
Eq TupleExp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods (==) :: TupleExp -> TupleExp -> Bool # (/=) :: TupleExp -> TupleExp -> Bool #
ToSQL TupleExp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods toSQL :: TupleExp -> Builder Source #
Hashable TupleExp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods hashWithSalt :: Int -> TupleExp -> Int Source # hash :: TupleExp -> Int Source #

data SQLExp Source #

Constructors

SEPrep Int
SENull
SELit Text
SEUnsafe Text
SESelect Select
SEStar (Maybe Qual)	all fields (``) or all fields from relation (`iden.`)
SEIdentifier Identifier	A column name
SERowIdentifier Identifier	SEIdentifier and SERowIdentifier are distinguished for easier rewrite rules
SEQIdentifier QIdentifier	A qualified column name
SEFnApp Text [SQLExp] (Maybe OrderByExp)	this is used to apply a sql function to an expression. The `Text` is the function name
SEOpApp SQLOp [SQLExp]
SETyAnn SQLExp TypeAnn
SECond BoolExp SQLExp SQLExp
SEBool BoolExp
SEExcluded Identifier
SEArray [SQLExp]
SEArrayIndex SQLExp SQLExp
SETuple TupleExp
SECount (CountType QIdentifier)
SENamedArg Identifier SQLExp
SEFunction FunctionExp

Instances

Instances details

ToJSON SQLExp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods toJSON :: SQLExp -> Value Source # toEncoding :: SQLExp -> Encoding Source # toJSONList :: [SQLExp] -> Value Source # toEncodingList :: [SQLExp] -> Encoding Source #
Data SQLExp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SQLExp -> c SQLExp # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SQLExp # toConstr :: SQLExp -> Constr # dataTypeOf :: SQLExp -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SQLExp) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SQLExp) # gmapT :: (forall b. Data b => b -> b) -> SQLExp -> SQLExp # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SQLExp -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SQLExp -> r # gmapQ :: (forall d. Data d => d -> u) -> SQLExp -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SQLExp -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SQLExp -> m SQLExp # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SQLExp -> m SQLExp # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SQLExp -> m SQLExp #
Generic SQLExp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Associated Types type Rep SQLExp :: Type -> Type # Methods from :: SQLExp -> Rep SQLExp x # to :: Rep SQLExp x -> SQLExp #
Show SQLExp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods showsPrec :: Int -> SQLExp -> ShowS # show :: SQLExp -> String # showList :: [SQLExp] -> ShowS #
NFData SQLExp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods rnf :: SQLExp -> () #
Eq SQLExp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods (==) :: SQLExp -> SQLExp -> Bool # (/=) :: SQLExp -> SQLExp -> Bool #
ToSQL SQLExp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods toSQL :: SQLExp -> Builder Source #
Hashable SQLExp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods hashWithSalt :: Int -> SQLExp -> Int Source # hash :: SQLExp -> Int Source #
type Rep SQLExp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML type Rep SQLExp = D1 ('MetaData "SQLExp" "Hasura.Backends.Postgres.SQL.DML" "graphql-engine-1.0.0-inplace" 'False) ((((C1 ('MetaCons "SEPrep" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Int)) :+: C1 ('MetaCons "SENull" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "SELit" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Text)) :+: (C1 ('MetaCons "SEUnsafe" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Text)) :+: C1 ('MetaCons "SESelect" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Select))))) :+: ((C1 ('MetaCons "SEStar" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (Maybe Qual))) :+: C1 ('MetaCons "SEIdentifier" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Identifier))) :+: (C1 ('MetaCons "SERowIdentifier" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Identifier)) :+: (C1 ('MetaCons "SEQIdentifier" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 QIdentifier)) :+: C1 ('MetaCons "SEFnApp" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Text) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 [SQLExp]) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (Maybe OrderByExp)))))))) :+: (((C1 ('MetaCons "SEOpApp" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 SQLOp) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 [SQLExp])) :+: C1 ('MetaCons "SETyAnn" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 SQLExp) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 TypeAnn))) :+: (C1 ('MetaCons "SECond" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 BoolExp) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 SQLExp) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 SQLExp))) :+: (C1 ('MetaCons "SEBool" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 BoolExp)) :+: C1 ('MetaCons "SEExcluded" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Identifier))))) :+: ((C1 ('MetaCons "SEArray" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 [SQLExp])) :+: (C1 ('MetaCons "SEArrayIndex" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 SQLExp) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 SQLExp)) :+: C1 ('MetaCons "SETuple" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 TupleExp)))) :+: (C1 ('MetaCons "SECount" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (CountType QIdentifier))) :+: (C1 ('MetaCons "SENamedArg" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Identifier) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 SQLExp)) :+: C1 ('MetaCons "SEFunction" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 FunctionExp)))))))

newtype ColumnAlias Source #

Represents an alias assignment for a column

Constructors

ColumnAlias
Fields getColumnAlias :: Identifier

Instances

Instances details

Data ColumnAlias Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ColumnAlias -> c ColumnAlias # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ColumnAlias # toConstr :: ColumnAlias -> Constr # dataTypeOf :: ColumnAlias -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ColumnAlias) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ColumnAlias) # gmapT :: (forall b. Data b => b -> b) -> ColumnAlias -> ColumnAlias # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ColumnAlias -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ColumnAlias -> r # gmapQ :: (forall d. Data d => d -> u) -> ColumnAlias -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ColumnAlias -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ColumnAlias -> m ColumnAlias # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ColumnAlias -> m ColumnAlias # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ColumnAlias -> m ColumnAlias #
IsString ColumnAlias Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods fromString :: String -> ColumnAlias #
Semigroup ColumnAlias Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods (<>) :: ColumnAlias -> ColumnAlias -> ColumnAlias # sconcat :: NonEmpty ColumnAlias -> ColumnAlias # stimes :: Integral b => b -> ColumnAlias -> ColumnAlias #
Show ColumnAlias Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods showsPrec :: Int -> ColumnAlias -> ShowS # show :: ColumnAlias -> String # showList :: [ColumnAlias] -> ShowS #
NFData ColumnAlias Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods rnf :: ColumnAlias -> () #
Eq ColumnAlias Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods (==) :: ColumnAlias -> ColumnAlias -> Bool # (/=) :: ColumnAlias -> ColumnAlias -> Bool #
IsIdentifier ColumnAlias Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods toIdentifier :: ColumnAlias -> Identifier Source #
Hashable ColumnAlias Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods hashWithSalt :: Int -> ColumnAlias -> Int Source # hash :: ColumnAlias -> Int Source #

mkColumnAlias :: Text -> ColumnAlias Source #

tableIdentifierToColumnAlias :: TableIdentifier -> ColumnAlias Source #

toColumnAlias :: IsIdentifier a => a -> ColumnAlias Source #

newtype TableAlias Source #

Represents an alias assignment for a table, relation or row

Constructors

TableAlias
Fields getTableAlias :: Identifier

Instances

Instances details

Data TableAlias Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TableAlias -> c TableAlias # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TableAlias # toConstr :: TableAlias -> Constr # dataTypeOf :: TableAlias -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c TableAlias) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TableAlias) # gmapT :: (forall b. Data b => b -> b) -> TableAlias -> TableAlias # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TableAlias -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TableAlias -> r # gmapQ :: (forall d. Data d => d -> u) -> TableAlias -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> TableAlias -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> TableAlias -> m TableAlias # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TableAlias -> m TableAlias # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TableAlias -> m TableAlias #
IsString TableAlias Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods fromString :: String -> TableAlias #
Semigroup TableAlias Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods (<>) :: TableAlias -> TableAlias -> TableAlias # sconcat :: NonEmpty TableAlias -> TableAlias # stimes :: Integral b => b -> TableAlias -> TableAlias #
Generic TableAlias Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Associated Types type Rep TableAlias :: Type -> Type # Methods from :: TableAlias -> Rep TableAlias x # to :: Rep TableAlias x -> TableAlias #
Show TableAlias Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods showsPrec :: Int -> TableAlias -> ShowS # show :: TableAlias -> String # showList :: [TableAlias] -> ShowS #
NFData TableAlias Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods rnf :: TableAlias -> () #
Eq TableAlias Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods (==) :: TableAlias -> TableAlias -> Bool # (/=) :: TableAlias -> TableAlias -> Bool #
IsIdentifier TableAlias Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods toIdentifier :: TableAlias -> Identifier Source #
Hashable TableAlias Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods hashWithSalt :: Int -> TableAlias -> Int Source # hash :: TableAlias -> Int Source #
type Rep TableAlias Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML type Rep TableAlias = D1 ('MetaData "TableAlias" "Hasura.Backends.Postgres.SQL.DML" "graphql-engine-1.0.0-inplace" 'True) (C1 ('MetaCons "TableAlias" 'PrefixI 'True) (S1 ('MetaSel ('Just "getTableAlias") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Identifier)))

mkTableAlias :: Text -> TableAlias Source #

Create a table alias.

tableAliasToIdentifier :: TableAlias -> TableIdentifier Source #

Create a table identifier from a table alias.

toTableAlias :: IsIdentifier a => a -> TableAlias Source #

countStar :: SQLExp Source #

intToSQLExp :: Int -> SQLExp Source #

int64ToSQLExp :: Int64 -> SQLExp Source #

data Extractor Source #

Extractor can be used to apply Postgres alias to a column

Constructors

Extractor SQLExp (Maybe ColumnAlias)

Instances

Instances details

Data Extractor Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Extractor -> c Extractor # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Extractor # toConstr :: Extractor -> Constr # dataTypeOf :: Extractor -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Extractor) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Extractor) # gmapT :: (forall b. Data b => b -> b) -> Extractor -> Extractor # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Extractor -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Extractor -> r # gmapQ :: (forall d. Data d => d -> u) -> Extractor -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Extractor -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Extractor -> m Extractor # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Extractor -> m Extractor # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Extractor -> m Extractor #
Generic Extractor Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Associated Types type Rep Extractor :: Type -> Type # Methods from :: Extractor -> Rep Extractor x # to :: Rep Extractor x -> Extractor #
Show Extractor Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods showsPrec :: Int -> Extractor -> ShowS # show :: Extractor -> String # showList :: [Extractor] -> ShowS #
NFData Extractor Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods rnf :: Extractor -> () #
Eq Extractor Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods (==) :: Extractor -> Extractor -> Bool # (/=) :: Extractor -> Extractor -> Bool #
ToSQL Extractor Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods toSQL :: Extractor -> Builder Source #
Hashable Extractor Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods hashWithSalt :: Int -> Extractor -> Int Source # hash :: Extractor -> Int Source #
type Rep Extractor Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML type Rep Extractor = D1 ('MetaData "Extractor" "Hasura.Backends.Postgres.SQL.DML" "graphql-engine-1.0.0-inplace" 'False) (C1 ('MetaCons "Extractor" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 SQLExp) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (Maybe ColumnAlias))))

mkSQLOpExp :: SQLOp -> SQLExp -> SQLExp -> SQLExp Source #

columnDefaultValue :: SQLExp Source #

handleIfNull :: SQLExp -> SQLExp -> SQLExp Source #

applyJsonBuildObj :: [SQLExp] -> SQLExp Source #

applyJsonBuildArray :: [SQLExp] -> SQLExp Source #

applyRowToJson :: [Extractor] -> SQLExp Source #

applyUppercase :: SQLExp -> SQLExp Source #

mkExtr :: IsIdentifier a => a -> Extractor Source #

data DistinctExpr Source #

Constructors

DistinctSimple
DistinctOn [SQLExp]

Instances

Instances details

Data DistinctExpr Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DistinctExpr -> c DistinctExpr # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DistinctExpr # toConstr :: DistinctExpr -> Constr # dataTypeOf :: DistinctExpr -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c DistinctExpr) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DistinctExpr) # gmapT :: (forall b. Data b => b -> b) -> DistinctExpr -> DistinctExpr # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DistinctExpr -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DistinctExpr -> r # gmapQ :: (forall d. Data d => d -> u) -> DistinctExpr -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> DistinctExpr -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> DistinctExpr -> m DistinctExpr # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DistinctExpr -> m DistinctExpr # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DistinctExpr -> m DistinctExpr #
Generic DistinctExpr Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Associated Types type Rep DistinctExpr :: Type -> Type # Methods from :: DistinctExpr -> Rep DistinctExpr x # to :: Rep DistinctExpr x -> DistinctExpr #
Show DistinctExpr Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods showsPrec :: Int -> DistinctExpr -> ShowS # show :: DistinctExpr -> String # showList :: [DistinctExpr] -> ShowS #
NFData DistinctExpr Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods rnf :: DistinctExpr -> () #
Eq DistinctExpr Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods (==) :: DistinctExpr -> DistinctExpr -> Bool # (/=) :: DistinctExpr -> DistinctExpr -> Bool #
ToSQL DistinctExpr Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods toSQL :: DistinctExpr -> Builder Source #
Hashable DistinctExpr Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods hashWithSalt :: Int -> DistinctExpr -> Int Source # hash :: DistinctExpr -> Int Source #
type Rep DistinctExpr Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML type Rep DistinctExpr = D1 ('MetaData "DistinctExpr" "Hasura.Backends.Postgres.SQL.DML" "graphql-engine-1.0.0-inplace" 'False) (C1 ('MetaCons "DistinctSimple" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "DistinctOn" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 [SQLExp])))

data FunctionArgs Source #

Constructors

FunctionArgs [SQLExp] (HashMap Text SQLExp)

Instances

Instances details

Data FunctionArgs Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FunctionArgs -> c FunctionArgs # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c FunctionArgs # toConstr :: FunctionArgs -> Constr # dataTypeOf :: FunctionArgs -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c FunctionArgs) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FunctionArgs) # gmapT :: (forall b. Data b => b -> b) -> FunctionArgs -> FunctionArgs # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FunctionArgs -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FunctionArgs -> r # gmapQ :: (forall d. Data d => d -> u) -> FunctionArgs -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> FunctionArgs -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> FunctionArgs -> m FunctionArgs # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FunctionArgs -> m FunctionArgs # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FunctionArgs -> m FunctionArgs #
Generic FunctionArgs Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Associated Types type Rep FunctionArgs :: Type -> Type # Methods from :: FunctionArgs -> Rep FunctionArgs x # to :: Rep FunctionArgs x -> FunctionArgs #
Show FunctionArgs Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods showsPrec :: Int -> FunctionArgs -> ShowS # show :: FunctionArgs -> String # showList :: [FunctionArgs] -> ShowS #
NFData FunctionArgs Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods rnf :: FunctionArgs -> () #
Eq FunctionArgs Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods (==) :: FunctionArgs -> FunctionArgs -> Bool # (/=) :: FunctionArgs -> FunctionArgs -> Bool #
ToSQL FunctionArgs Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods toSQL :: FunctionArgs -> Builder Source #
Hashable FunctionArgs Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods hashWithSalt :: Int -> FunctionArgs -> Int Source # hash :: FunctionArgs -> Int Source #
type Rep FunctionArgs Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML type Rep FunctionArgs = D1 ('MetaData "FunctionArgs" "Hasura.Backends.Postgres.SQL.DML" "graphql-engine-1.0.0-inplace" 'False) (C1 ('MetaCons "FunctionArgs" 'PrefixI 'True) (S1 ('MetaSel ('Just "fasPostional") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 [SQLExp]) :*: S1 ('MetaSel ('Just "fasNamed") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (HashMap Text SQLExp))))

data FunctionDefinitionListItem Source #

Constructors

FunctionDefinitionListItem
Fields _dliColumn :: ColumnAlias _dliType :: PGScalarType

Instances

Instances details

Data FunctionDefinitionListItem Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FunctionDefinitionListItem -> c FunctionDefinitionListItem # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c FunctionDefinitionListItem # toConstr :: FunctionDefinitionListItem -> Constr # dataTypeOf :: FunctionDefinitionListItem -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c FunctionDefinitionListItem) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FunctionDefinitionListItem) # gmapT :: (forall b. Data b => b -> b) -> FunctionDefinitionListItem -> FunctionDefinitionListItem # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FunctionDefinitionListItem -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FunctionDefinitionListItem -> r # gmapQ :: (forall d. Data d => d -> u) -> FunctionDefinitionListItem -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> FunctionDefinitionListItem -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> FunctionDefinitionListItem -> m FunctionDefinitionListItem # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FunctionDefinitionListItem -> m FunctionDefinitionListItem # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FunctionDefinitionListItem -> m FunctionDefinitionListItem #
Generic FunctionDefinitionListItem Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Associated Types type Rep FunctionDefinitionListItem :: Type -> Type # Methods from :: FunctionDefinitionListItem -> Rep FunctionDefinitionListItem x # to :: Rep FunctionDefinitionListItem x -> FunctionDefinitionListItem #
Show FunctionDefinitionListItem Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods showsPrec :: Int -> FunctionDefinitionListItem -> ShowS # show :: FunctionDefinitionListItem -> String # showList :: [FunctionDefinitionListItem] -> ShowS #
NFData FunctionDefinitionListItem Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods rnf :: FunctionDefinitionListItem -> () #
Eq FunctionDefinitionListItem Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods (==) :: FunctionDefinitionListItem -> FunctionDefinitionListItem -> Bool # (/=) :: FunctionDefinitionListItem -> FunctionDefinitionListItem -> Bool #
ToSQL FunctionDefinitionListItem Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods toSQL :: FunctionDefinitionListItem -> Builder Source #
Hashable FunctionDefinitionListItem Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods hashWithSalt :: Int -> FunctionDefinitionListItem -> Int Source # hash :: FunctionDefinitionListItem -> Int Source #
type Rep FunctionDefinitionListItem Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML type Rep FunctionDefinitionListItem = D1 ('MetaData "FunctionDefinitionListItem" "Hasura.Backends.Postgres.SQL.DML" "graphql-engine-1.0.0-inplace" 'False) (C1 ('MetaCons "FunctionDefinitionListItem" 'PrefixI 'True) (S1 ('MetaSel ('Just "_dliColumn") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 ColumnAlias) :*: S1 ('MetaSel ('Just "_dliType") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 PGScalarType)))

data FunctionAlias Source #

We can alias the result of a function call that returns a SETOF RECORD by naming the result relation, and the columns and their types. For example:

SELECT * FROM
function_returns_record(arg1, arg2 ...) AS relation_name(column_1 column_1_type, column_2 column_2_type, ...)

Note: a function that returns a table (instead of a record) cannot name the types as seen in the above example.

Constructors

FunctionAlias TableAlias (Maybe [FunctionDefinitionListItem])

Instances

Instances details

Data FunctionAlias Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FunctionAlias -> c FunctionAlias # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c FunctionAlias # toConstr :: FunctionAlias -> Constr # dataTypeOf :: FunctionAlias -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c FunctionAlias) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FunctionAlias) # gmapT :: (forall b. Data b => b -> b) -> FunctionAlias -> FunctionAlias # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FunctionAlias -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FunctionAlias -> r # gmapQ :: (forall d. Data d => d -> u) -> FunctionAlias -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> FunctionAlias -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> FunctionAlias -> m FunctionAlias # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FunctionAlias -> m FunctionAlias # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FunctionAlias -> m FunctionAlias #
Generic FunctionAlias Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Associated Types type Rep FunctionAlias :: Type -> Type # Methods from :: FunctionAlias -> Rep FunctionAlias x # to :: Rep FunctionAlias x -> FunctionAlias #
Show FunctionAlias Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods showsPrec :: Int -> FunctionAlias -> ShowS # show :: FunctionAlias -> String # showList :: [FunctionAlias] -> ShowS #
NFData FunctionAlias Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods rnf :: FunctionAlias -> () #
Eq FunctionAlias Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods (==) :: FunctionAlias -> FunctionAlias -> Bool # (/=) :: FunctionAlias -> FunctionAlias -> Bool #
ToSQL FunctionAlias Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods toSQL :: FunctionAlias -> Builder Source #
Hashable FunctionAlias Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods hashWithSalt :: Int -> FunctionAlias -> Int Source # hash :: FunctionAlias -> Int Source #
type Rep FunctionAlias Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML type Rep FunctionAlias = D1 ('MetaData "FunctionAlias" "Hasura.Backends.Postgres.SQL.DML" "graphql-engine-1.0.0-inplace" 'False) (C1 ('MetaCons "FunctionAlias" 'PrefixI 'True) (S1 ('MetaSel ('Just "_faIdentifier") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 TableAlias) :*: S1 ('MetaSel ('Just "_faDefinitionList") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (Maybe [FunctionDefinitionListItem]))))

mkFunctionAlias :: QualifiedObject FunctionName -> Maybe [(ColumnAlias, PGScalarType)] -> FunctionAlias Source #

Construct a function alias which represents the "relation signature" for the function invocation, Using the function name as the relation name, and the columns as the relation schema.

data FunctionExp Source #

A function call

Constructors

FunctionExp QualifiedFunction FunctionArgs (Maybe FunctionAlias)

Instances

Instances details

Data FunctionExp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FunctionExp -> c FunctionExp # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c FunctionExp # toConstr :: FunctionExp -> Constr # dataTypeOf :: FunctionExp -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c FunctionExp) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FunctionExp) # gmapT :: (forall b. Data b => b -> b) -> FunctionExp -> FunctionExp # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FunctionExp -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FunctionExp -> r # gmapQ :: (forall d. Data d => d -> u) -> FunctionExp -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> FunctionExp -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> FunctionExp -> m FunctionExp # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FunctionExp -> m FunctionExp # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FunctionExp -> m FunctionExp #
Generic FunctionExp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Associated Types type Rep FunctionExp :: Type -> Type # Methods from :: FunctionExp -> Rep FunctionExp x # to :: Rep FunctionExp x -> FunctionExp #
Show FunctionExp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods showsPrec :: Int -> FunctionExp -> ShowS # show :: FunctionExp -> String # showList :: [FunctionExp] -> ShowS #
NFData FunctionExp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods rnf :: FunctionExp -> () #
Eq FunctionExp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods (==) :: FunctionExp -> FunctionExp -> Bool # (/=) :: FunctionExp -> FunctionExp -> Bool #
ToSQL FunctionExp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods toSQL :: FunctionExp -> Builder Source #
Hashable FunctionExp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods hashWithSalt :: Int -> FunctionExp -> Int Source # hash :: FunctionExp -> Int Source #
type Rep FunctionExp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML type Rep FunctionExp = D1 ('MetaData "FunctionExp" "Hasura.Backends.Postgres.SQL.DML" "graphql-engine-1.0.0-inplace" 'False) (C1 ('MetaCons "FunctionExp" 'PrefixI 'True) (S1 ('MetaSel ('Just "feName") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 QualifiedFunction) :: (S1 ('MetaSel ('Just "feArgs") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 FunctionArgs) :: S1 ('MetaSel ('Just "feAlias") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (Maybe FunctionAlias)))))

data FromItem Source #

See from_item in https://www.postgresql.org/docs/current/sql-select.html

Constructors

FISimple QualifiedTable (Maybe TableAlias)	A simple table
FIIdentifier TableIdentifier	An identifier (from CTEs)
FIFunc FunctionExp	A function call (that should return a relation (`SETOF`) and not a scalar)
FIUnnest [SQLExp] TableAlias [ColumnAlias]	`unnest` converts (an) array(s) to a relation. We have: * The unnest function arguments * The relation alias * A list of column aliases See `unnest` in https://www.postgresql.org/docs/current/functions-array.html.
FISelect Lateral Select TableAlias
FISelectWith Lateral (SelectWithG Select) TableAlias
FIValues ValuesExp TableAlias (Maybe [ColumnAlias])
FIJoin JoinExpr

Instances

Instances details

Data FromItem Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FromItem -> c FromItem # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c FromItem # toConstr :: FromItem -> Constr # dataTypeOf :: FromItem -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c FromItem) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FromItem) # gmapT :: (forall b. Data b => b -> b) -> FromItem -> FromItem # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FromItem -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FromItem -> r # gmapQ :: (forall d. Data d => d -> u) -> FromItem -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> FromItem -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> FromItem -> m FromItem # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FromItem -> m FromItem # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FromItem -> m FromItem #
Generic FromItem Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Associated Types type Rep FromItem :: Type -> Type # Methods from :: FromItem -> Rep FromItem x # to :: Rep FromItem x -> FromItem #
Show FromItem Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods showsPrec :: Int -> FromItem -> ShowS # show :: FromItem -> String # showList :: [FromItem] -> ShowS #
NFData FromItem Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods rnf :: FromItem -> () #
Eq FromItem Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods (==) :: FromItem -> FromItem -> Bool # (/=) :: FromItem -> FromItem -> Bool #
ToSQL FromItem Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods toSQL :: FromItem -> Builder Source #
Hashable FromItem Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods hashWithSalt :: Int -> FromItem -> Int Source # hash :: FromItem -> Int Source #
type Rep FromItem Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML type Rep FromItem = D1 ('MetaData "FromItem" "Hasura.Backends.Postgres.SQL.DML" "graphql-engine-1.0.0-inplace" 'False) (((C1 ('MetaCons "FISimple" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 QualifiedTable) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (Maybe TableAlias))) :+: C1 ('MetaCons "FIIdentifier" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 TableIdentifier))) :+: (C1 ('MetaCons "FIFunc" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 FunctionExp)) :+: C1 ('MetaCons "FIUnnest" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 [SQLExp]) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 TableAlias) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 [ColumnAlias]))))) :+: ((C1 ('MetaCons "FISelect" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Lateral) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Select) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 TableAlias))) :+: C1 ('MetaCons "FISelectWith" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Lateral) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (SelectWithG Select)) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 TableAlias)))) :+: (C1 ('MetaCons "FIValues" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 ValuesExp) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 TableAlias) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (Maybe [ColumnAlias])))) :+: C1 ('MetaCons "FIJoin" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 JoinExpr)))))

mkSelFromItem :: Select -> TableAlias -> FromItem Source #

mkSelectWithFromItem :: SelectWithG Select -> TableAlias -> FromItem Source #

mkLateralFromItem :: Select -> TableAlias -> FromItem Source #

newtype Lateral Source #

Constructors

Lateral Bool

Instances

Instances details

Data Lateral Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Lateral -> c Lateral # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Lateral # toConstr :: Lateral -> Constr # dataTypeOf :: Lateral -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Lateral) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Lateral) # gmapT :: (forall b. Data b => b -> b) -> Lateral -> Lateral # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Lateral -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Lateral -> r # gmapQ :: (forall d. Data d => d -> u) -> Lateral -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Lateral -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Lateral -> m Lateral # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Lateral -> m Lateral # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Lateral -> m Lateral #
Show Lateral Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods showsPrec :: Int -> Lateral -> ShowS # show :: Lateral -> String # showList :: [Lateral] -> ShowS #
NFData Lateral Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods rnf :: Lateral -> () #
Eq Lateral Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods (==) :: Lateral -> Lateral -> Bool # (/=) :: Lateral -> Lateral -> Bool #
ToSQL Lateral Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods toSQL :: Lateral -> Builder Source #
Hashable Lateral Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods hashWithSalt :: Int -> Lateral -> Int Source # hash :: Lateral -> Int Source #

data JoinExpr Source #

Constructors

JoinExpr FromItem JoinType FromItem JoinCond

Instances

Instances details

Data JoinExpr Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> JoinExpr -> c JoinExpr # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c JoinExpr # toConstr :: JoinExpr -> Constr # dataTypeOf :: JoinExpr -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c JoinExpr) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c JoinExpr) # gmapT :: (forall b. Data b => b -> b) -> JoinExpr -> JoinExpr # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> JoinExpr -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> JoinExpr -> r # gmapQ :: (forall d. Data d => d -> u) -> JoinExpr -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> JoinExpr -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> JoinExpr -> m JoinExpr # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> JoinExpr -> m JoinExpr # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> JoinExpr -> m JoinExpr #
Generic JoinExpr Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Associated Types type Rep JoinExpr :: Type -> Type # Methods from :: JoinExpr -> Rep JoinExpr x # to :: Rep JoinExpr x -> JoinExpr #
Show JoinExpr Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods showsPrec :: Int -> JoinExpr -> ShowS # show :: JoinExpr -> String # showList :: [JoinExpr] -> ShowS #
NFData JoinExpr Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods rnf :: JoinExpr -> () #
Eq JoinExpr Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods (==) :: JoinExpr -> JoinExpr -> Bool # (/=) :: JoinExpr -> JoinExpr -> Bool #
ToSQL JoinExpr Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods toSQL :: JoinExpr -> Builder Source #
Hashable JoinExpr Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods hashWithSalt :: Int -> JoinExpr -> Int Source # hash :: JoinExpr -> Int Source #
type Rep JoinExpr Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML type Rep JoinExpr = D1 ('MetaData "JoinExpr" "Hasura.Backends.Postgres.SQL.DML" "graphql-engine-1.0.0-inplace" 'False) (C1 ('MetaCons "JoinExpr" 'PrefixI 'True) ((S1 ('MetaSel ('Just "tjeLeft") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 FromItem) :: S1 ('MetaSel ('Just "tjeType") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 JoinType)) :: (S1 ('MetaSel ('Just "tjeRight") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 FromItem) :*: S1 ('MetaSel ('Just "tjeJC") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 JoinCond))))

data JoinType Source #

Constructors

Inner
LeftOuter

Instances

Instances details

Data JoinType Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> JoinType -> c JoinType # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c JoinType # toConstr :: JoinType -> Constr # dataTypeOf :: JoinType -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c JoinType) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c JoinType) # gmapT :: (forall b. Data b => b -> b) -> JoinType -> JoinType # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> JoinType -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> JoinType -> r # gmapQ :: (forall d. Data d => d -> u) -> JoinType -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> JoinType -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> JoinType -> m JoinType # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> JoinType -> m JoinType # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> JoinType -> m JoinType #
Generic JoinType Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Associated Types type Rep JoinType :: Type -> Type # Methods from :: JoinType -> Rep JoinType x # to :: Rep JoinType x -> JoinType #
Show JoinType Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods showsPrec :: Int -> JoinType -> ShowS # show :: JoinType -> String # showList :: [JoinType] -> ShowS #
NFData JoinType Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods rnf :: JoinType -> () #
Eq JoinType Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods (==) :: JoinType -> JoinType -> Bool # (/=) :: JoinType -> JoinType -> Bool #
ToSQL JoinType Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods toSQL :: JoinType -> Builder Source #
Hashable JoinType Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods hashWithSalt :: Int -> JoinType -> Int Source # hash :: JoinType -> Int Source #
type Rep JoinType Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML type Rep JoinType = D1 ('MetaData "JoinType" "Hasura.Backends.Postgres.SQL.DML" "graphql-engine-1.0.0-inplace" 'False) ((C1 ('MetaCons "Inner" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "LeftOuter" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "RightOuter" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "FullOuter" 'PrefixI 'False) (U1 :: Type -> Type)))

data JoinCond Source #

Constructors

JoinOn BoolExp
JoinUsing [Identifier]

Instances

Instances details

Data JoinCond Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> JoinCond -> c JoinCond # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c JoinCond # toConstr :: JoinCond -> Constr # dataTypeOf :: JoinCond -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c JoinCond) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c JoinCond) # gmapT :: (forall b. Data b => b -> b) -> JoinCond -> JoinCond # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> JoinCond -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> JoinCond -> r # gmapQ :: (forall d. Data d => d -> u) -> JoinCond -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> JoinCond -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> JoinCond -> m JoinCond # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> JoinCond -> m JoinCond # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> JoinCond -> m JoinCond #
Generic JoinCond Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Associated Types type Rep JoinCond :: Type -> Type # Methods from :: JoinCond -> Rep JoinCond x # to :: Rep JoinCond x -> JoinCond #
Show JoinCond Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods showsPrec :: Int -> JoinCond -> ShowS # show :: JoinCond -> String # showList :: [JoinCond] -> ShowS #
NFData JoinCond Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods rnf :: JoinCond -> () #
Eq JoinCond Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods (==) :: JoinCond -> JoinCond -> Bool # (/=) :: JoinCond -> JoinCond -> Bool #
ToSQL JoinCond Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods toSQL :: JoinCond -> Builder Source #
Hashable JoinCond Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods hashWithSalt :: Int -> JoinCond -> Int Source # hash :: JoinCond -> Int Source #
type Rep JoinCond Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML type Rep JoinCond = D1 ('MetaData "JoinCond" "Hasura.Backends.Postgres.SQL.DML" "graphql-engine-1.0.0-inplace" 'False) (C1 ('MetaCons "JoinOn" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 BoolExp)) :+: C1 ('MetaCons "JoinUsing" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 [Identifier])))

data BoolExp Source #

Instances

Instances details

Data BoolExp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> BoolExp -> c BoolExp # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c BoolExp # toConstr :: BoolExp -> Constr # dataTypeOf :: BoolExp -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c BoolExp) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BoolExp) # gmapT :: (forall b. Data b => b -> b) -> BoolExp -> BoolExp # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> BoolExp -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> BoolExp -> r # gmapQ :: (forall d. Data d => d -> u) -> BoolExp -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> BoolExp -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> BoolExp -> m BoolExp # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> BoolExp -> m BoolExp # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> BoolExp -> m BoolExp #
Generic BoolExp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Associated Types type Rep BoolExp :: Type -> Type # Methods from :: BoolExp -> Rep BoolExp x # to :: Rep BoolExp x -> BoolExp #
Show BoolExp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods showsPrec :: Int -> BoolExp -> ShowS # show :: BoolExp -> String # showList :: [BoolExp] -> ShowS #
NFData BoolExp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods rnf :: BoolExp -> () #
Eq BoolExp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods (==) :: BoolExp -> BoolExp -> Bool # (/=) :: BoolExp -> BoolExp -> Bool #
ToSQL BoolExp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods toSQL :: BoolExp -> Builder Source #
Hashable BoolExp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods hashWithSalt :: Int -> BoolExp -> Int Source # hash :: BoolExp -> Int Source #
type Rep BoolExp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML type Rep BoolExp = D1 ('MetaData "BoolExp" "Hasura.Backends.Postgres.SQL.DML" "graphql-engine-1.0.0-inplace" 'False) (((C1 ('MetaCons "BELit" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Bool)) :+: C1 ('MetaCons "BEBin" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 BinOp) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 BoolExp) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 BoolExp)))) :+: (C1 ('MetaCons "BENot" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 BoolExp)) :+: (C1 ('MetaCons "BECompare" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 CompareOp) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 SQLExp) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 SQLExp))) :+: C1 ('MetaCons "BECompareAny" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 CompareOp) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 SQLExp) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 SQLExp)))))) :+: ((C1 ('MetaCons "BENull" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 SQLExp)) :+: C1 ('MetaCons "BENotNull" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 SQLExp))) :+: (C1 ('MetaCons "BEExists" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Select)) :+: (C1 ('MetaCons "BEIN" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 SQLExp) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 [SQLExp])) :+: C1 ('MetaCons "BEExp" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 SQLExp))))))

simplifyBoolExp :: BoolExp -> BoolExp Source #

mkExists :: FromItem -> BoolExp -> BoolExp Source #

data BinOp Source #

Constructors

AndOp
OrOp

Instances

Instances details

Data BinOp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> BinOp -> c BinOp # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c BinOp # toConstr :: BinOp -> Constr # dataTypeOf :: BinOp -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c BinOp) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BinOp) # gmapT :: (forall b. Data b => b -> b) -> BinOp -> BinOp # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> BinOp -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> BinOp -> r # gmapQ :: (forall d. Data d => d -> u) -> BinOp -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> BinOp -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> BinOp -> m BinOp # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> BinOp -> m BinOp # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> BinOp -> m BinOp #
Generic BinOp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Associated Types type Rep BinOp :: Type -> Type # Methods from :: BinOp -> Rep BinOp x # to :: Rep BinOp x -> BinOp #
Show BinOp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods showsPrec :: Int -> BinOp -> ShowS # show :: BinOp -> String # showList :: [BinOp] -> ShowS #
NFData BinOp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods rnf :: BinOp -> () #
Eq BinOp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods (==) :: BinOp -> BinOp -> Bool # (/=) :: BinOp -> BinOp -> Bool #
ToSQL BinOp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods toSQL :: BinOp -> Builder Source #
Hashable BinOp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods hashWithSalt :: Int -> BinOp -> Int Source # hash :: BinOp -> Int Source #
type Rep BinOp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML type Rep BinOp = D1 ('MetaData "BinOp" "Hasura.Backends.Postgres.SQL.DML" "graphql-engine-1.0.0-inplace" 'False) (C1 ('MetaCons "AndOp" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "OrOp" 'PrefixI 'False) (U1 :: Type -> Type))

data CompareOp Source #

Instances

Instances details

Data CompareOp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CompareOp -> c CompareOp # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c CompareOp # toConstr :: CompareOp -> Constr # dataTypeOf :: CompareOp -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c CompareOp) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CompareOp) # gmapT :: (forall b. Data b => b -> b) -> CompareOp -> CompareOp # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CompareOp -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CompareOp -> r # gmapQ :: (forall d. Data d => d -> u) -> CompareOp -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> CompareOp -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> CompareOp -> m CompareOp # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CompareOp -> m CompareOp # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CompareOp -> m CompareOp #
Generic CompareOp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Associated Types type Rep CompareOp :: Type -> Type # Methods from :: CompareOp -> Rep CompareOp x # to :: Rep CompareOp x -> CompareOp #
Show CompareOp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods showsPrec :: Int -> CompareOp -> ShowS # show :: CompareOp -> String # showList :: [CompareOp] -> ShowS #
NFData CompareOp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods rnf :: CompareOp -> () #
Eq CompareOp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods (==) :: CompareOp -> CompareOp -> Bool # (/=) :: CompareOp -> CompareOp -> Bool #
ToSQL CompareOp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods toSQL :: CompareOp -> Builder Source #
Hashable CompareOp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods hashWithSalt :: Int -> CompareOp -> Int Source # hash :: CompareOp -> Int Source #
type Rep CompareOp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML type Rep CompareOp = D1 ('MetaData "CompareOp" "Hasura.Backends.Postgres.SQL.DML" "graphql-engine-1.0.0-inplace" 'False) ((((C1 ('MetaCons "SEQ" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "SGT" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "SLT" 'PrefixI 'False) (U1 :: Type -> Type))) :+: (C1 ('MetaCons "SIN" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "SNE" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "SGTE" 'PrefixI 'False) (U1 :: Type -> Type)))) :+: ((C1 ('MetaCons "SLTE" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "SNIN" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "SLIKE" 'PrefixI 'False) (U1 :: Type -> Type))) :+: (C1 ('MetaCons "SNLIKE" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "SILIKE" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "SNILIKE" 'PrefixI 'False) (U1 :: Type -> Type))))) :+: (((C1 ('MetaCons "SSIMILAR" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "SNSIMILAR" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "SREGEX" 'PrefixI 'False) (U1 :: Type -> Type))) :+: (C1 ('MetaCons "SIREGEX" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "SNREGEX" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "SNIREGEX" 'PrefixI 'False) (U1 :: Type -> Type)))) :+: ((C1 ('MetaCons "SContains" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "SContainedIn" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "SHasKey" 'PrefixI 'False) (U1 :: Type -> Type))) :+: (C1 ('MetaCons "SHasKeysAny" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "SHasKeysAll" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "SMatchesFulltext" 'PrefixI 'False) (U1 :: Type -> Type))))))

data SQLDelete Source #

Constructors

SQLDelete QualifiedTable (Maybe UsingExp) (Maybe WhereFrag) (Maybe RetExp)

Instances

Instances details

Show SQLDelete Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods showsPrec :: Int -> SQLDelete -> ShowS # show :: SQLDelete -> String # showList :: [SQLDelete] -> ShowS #
Eq SQLDelete Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods (==) :: SQLDelete -> SQLDelete -> Bool # (/=) :: SQLDelete -> SQLDelete -> Bool #
ToSQL SQLDelete Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods toSQL :: SQLDelete -> Builder Source #

data SQLUpdate Source #

Constructors

SQLUpdate
Fields upTable :: QualifiedTable upSet :: SetExp upFrom :: Maybe FromExp upWhere :: Maybe WhereFrag upRet :: Maybe RetExp

Instances

Instances details

Show SQLUpdate Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods showsPrec :: Int -> SQLUpdate -> ShowS # show :: SQLUpdate -> String # showList :: [SQLUpdate] -> ShowS #
Eq SQLUpdate Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods (==) :: SQLUpdate -> SQLUpdate -> Bool # (/=) :: SQLUpdate -> SQLUpdate -> Bool #
ToSQL SQLUpdate Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods toSQL :: SQLUpdate -> Builder Source #

newtype SetExp Source #

Constructors

SetExp [SetExpItem]

Instances

Instances details

Show SetExp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods showsPrec :: Int -> SetExp -> ShowS # show :: SetExp -> String # showList :: [SetExp] -> ShowS #
Eq SetExp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods (==) :: SetExp -> SetExp -> Bool # (/=) :: SetExp -> SetExp -> Bool #
ToSQL SetExp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods toSQL :: SetExp -> Builder Source #

newtype SetExpItem Source #

Constructors

SetExpItem (PGCol, SQLExp)

Instances

Instances details

Show SetExpItem Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods showsPrec :: Int -> SetExpItem -> ShowS # show :: SetExpItem -> String # showList :: [SetExpItem] -> ShowS #
Eq SetExpItem Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods (==) :: SetExpItem -> SetExpItem -> Bool # (/=) :: SetExpItem -> SetExpItem -> Bool #
ToSQL SetExpItem Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods toSQL :: SetExpItem -> Builder Source #

buildUpsertSetExp :: [PGCol] -> HashMap PGCol SQLExp -> SetExp Source #

newtype RetExp Source #

Constructors

RetExp [Extractor]

Instances

Instances details

Show RetExp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods showsPrec :: Int -> RetExp -> ShowS # show :: RetExp -> String # showList :: [RetExp] -> ShowS #
Eq RetExp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods (==) :: RetExp -> RetExp -> Bool # (/=) :: RetExp -> RetExp -> Bool #
ToSQL RetExp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods toSQL :: RetExp -> Builder Source #

selectStar :: Extractor Source #

selectStar' :: Qual -> Extractor Source #

returningStar :: RetExp Source #

data SQLConflictTarget Source #

Constructors

SQLColumn [PGCol]
SQLConstraint ConstraintName

Instances

Instances details

Show SQLConflictTarget Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods showsPrec :: Int -> SQLConflictTarget -> ShowS # show :: SQLConflictTarget -> String # showList :: [SQLConflictTarget] -> ShowS #
Eq SQLConflictTarget Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods (==) :: SQLConflictTarget -> SQLConflictTarget -> Bool # (/=) :: SQLConflictTarget -> SQLConflictTarget -> Bool #
ToSQL SQLConflictTarget Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods toSQL :: SQLConflictTarget -> Builder Source #

data SQLConflict Source #

Constructors

DoNothing (Maybe SQLConflictTarget)
Update SQLConflictTarget SetExp (Maybe WhereFrag)

Instances

Instances details

Show SQLConflict Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods showsPrec :: Int -> SQLConflict -> ShowS # show :: SQLConflict -> String # showList :: [SQLConflict] -> ShowS #
Eq SQLConflict Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods (==) :: SQLConflict -> SQLConflict -> Bool # (/=) :: SQLConflict -> SQLConflict -> Bool #
ToSQL SQLConflict Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods toSQL :: SQLConflict -> Builder Source #

newtype ValuesExp Source #

Constructors

ValuesExp [TupleExp]

Instances

Instances details

Data ValuesExp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ValuesExp -> c ValuesExp # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ValuesExp # toConstr :: ValuesExp -> Constr # dataTypeOf :: ValuesExp -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ValuesExp) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ValuesExp) # gmapT :: (forall b. Data b => b -> b) -> ValuesExp -> ValuesExp # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ValuesExp -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ValuesExp -> r # gmapQ :: (forall d. Data d => d -> u) -> ValuesExp -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ValuesExp -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ValuesExp -> m ValuesExp # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ValuesExp -> m ValuesExp # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ValuesExp -> m ValuesExp #
Show ValuesExp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods showsPrec :: Int -> ValuesExp -> ShowS # show :: ValuesExp -> String # showList :: [ValuesExp] -> ShowS #
NFData ValuesExp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods rnf :: ValuesExp -> () #
Eq ValuesExp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods (==) :: ValuesExp -> ValuesExp -> Bool # (/=) :: ValuesExp -> ValuesExp -> Bool #
ToSQL ValuesExp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods toSQL :: ValuesExp -> Builder Source #
Hashable ValuesExp Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods hashWithSalt :: Int -> ValuesExp -> Int Source # hash :: ValuesExp -> Int Source #

data SQLInsert Source #

Constructors

SQLInsert
Fields siTable :: QualifiedTable siCols :: [PGCol] siValues :: ValuesExp siConflict :: Maybe SQLConflict siRet :: Maybe RetExp

Instances

Instances details

Show SQLInsert Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods showsPrec :: Int -> SQLInsert -> ShowS # show :: SQLInsert -> String # showList :: [SQLInsert] -> ShowS #
Eq SQLInsert Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods (==) :: SQLInsert -> SQLInsert -> Bool # (/=) :: SQLInsert -> SQLInsert -> Bool #
ToSQL SQLInsert Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods toSQL :: SQLInsert -> Builder Source #

data TopLevelCTE Source #

Top-level Common Table Expression statement.

A top level CTE can be a query or a mutation statement.

Postgres supports mutations only in top-level CTEs. See https://www.postgresql.org/docs/current/queries-with.html#QUERIES-WITH-MODIFYING

Constructors

CTESelect Select
CTEInsert SQLInsert
CTEUpdate SQLUpdate
CTEDelete SQLDelete
CTEUnsafeRawSQL (InterpolatedQuery SQLExp)

Instances

Instances details

Show TopLevelCTE Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods showsPrec :: Int -> TopLevelCTE -> ShowS # show :: TopLevelCTE -> String # showList :: [TopLevelCTE] -> ShowS #
Eq TopLevelCTE Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods (==) :: TopLevelCTE -> TopLevelCTE -> Bool # (/=) :: TopLevelCTE -> TopLevelCTE -> Bool #
ToSQL TopLevelCTE Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods toSQL :: TopLevelCTE -> Builder Source #

data InnerCTE Source #

Represents a common table expresion that can be used in nested selects.

Constructors

ICTESelect Select
ICTEUnsafeRawSQL (InterpolatedQuery SQLExp)

Instances

Instances details

Data InnerCTE Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> InnerCTE -> c InnerCTE # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c InnerCTE # toConstr :: InnerCTE -> Constr # dataTypeOf :: InnerCTE -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c InnerCTE) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c InnerCTE) # gmapT :: (forall b. Data b => b -> b) -> InnerCTE -> InnerCTE # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> InnerCTE -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> InnerCTE -> r # gmapQ :: (forall d. Data d => d -> u) -> InnerCTE -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> InnerCTE -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> InnerCTE -> m InnerCTE # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> InnerCTE -> m InnerCTE # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> InnerCTE -> m InnerCTE #
Generic InnerCTE Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Associated Types type Rep InnerCTE :: Type -> Type # Methods from :: InnerCTE -> Rep InnerCTE x # to :: Rep InnerCTE x -> InnerCTE #
Show InnerCTE Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods showsPrec :: Int -> InnerCTE -> ShowS # show :: InnerCTE -> String # showList :: [InnerCTE] -> ShowS #
NFData InnerCTE Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods rnf :: InnerCTE -> () #
Eq InnerCTE Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods (==) :: InnerCTE -> InnerCTE -> Bool # (/=) :: InnerCTE -> InnerCTE -> Bool #
Hashable InnerCTE Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods hashWithSalt :: Int -> InnerCTE -> Int Source # hash :: InnerCTE -> Int Source #
type Rep InnerCTE Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML type Rep InnerCTE = D1 ('MetaData "InnerCTE" "Hasura.Backends.Postgres.SQL.DML" "graphql-engine-1.0.0-inplace" 'False) (C1 ('MetaCons "ICTESelect" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Select)) :+: C1 ('MetaCons "ICTEUnsafeRawSQL" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (InterpolatedQuery SQLExp))))

data SelectWithG statement Source #

A SELECT statement with Common Table Expressions. https://www.postgresql.org/docs/current/queries-with.html

These CTEs are determined by the statement parameter. Currently they are either TopLevelCTE, which allow for a query or mutation statement, or Select, which only allow for querying results.

The distinction is required because Postgres only supports mutations in CTEs at the top level. See https://www.postgresql.org/docs/current/queries-with.html#QUERIES-WITH-MODIFYING

Constructors

SelectWith
Fields swCTEs :: [(TableAlias, statement)] swSelect :: Select

Instances

Instances details

Data statement => Data (SelectWithG statement) Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SelectWithG statement -> c (SelectWithG statement) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (SelectWithG statement) # toConstr :: SelectWithG statement -> Constr # dataTypeOf :: SelectWithG statement -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (SelectWithG statement)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (SelectWithG statement)) # gmapT :: (forall b. Data b => b -> b) -> SelectWithG statement -> SelectWithG statement # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SelectWithG statement -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SelectWithG statement -> r # gmapQ :: (forall d. Data d => d -> u) -> SelectWithG statement -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SelectWithG statement -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SelectWithG statement -> m (SelectWithG statement) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SelectWithG statement -> m (SelectWithG statement) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SelectWithG statement -> m (SelectWithG statement) #
Generic (SelectWithG statement) Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Associated Types type Rep (SelectWithG statement) :: Type -> Type # Methods from :: SelectWithG statement -> Rep (SelectWithG statement) x # to :: Rep (SelectWithG statement) x -> SelectWithG statement #
Show statement => Show (SelectWithG statement) Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods showsPrec :: Int -> SelectWithG statement -> ShowS # show :: SelectWithG statement -> String # showList :: [SelectWithG statement] -> ShowS #
NFData v => NFData (SelectWithG v) Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods rnf :: SelectWithG v -> () #
Eq statement => Eq (SelectWithG statement) Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods (==) :: SelectWithG statement -> SelectWithG statement -> Bool # (/=) :: SelectWithG statement -> SelectWithG statement -> Bool #
ToSQL v => ToSQL (SelectWithG v) Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods toSQL :: SelectWithG v -> Builder Source #
Hashable v => Hashable (SelectWithG v) Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML Methods hashWithSalt :: Int -> SelectWithG v -> Int Source # hash :: SelectWithG v -> Int Source #
type Rep (SelectWithG statement) Source #
Instance details Defined in Hasura.Backends.Postgres.SQL.DML type Rep (SelectWithG statement) = D1 ('MetaData "SelectWithG" "Hasura.Backends.Postgres.SQL.DML" "graphql-engine-1.0.0-inplace" 'False) (C1 ('MetaCons "SelectWith" 'PrefixI 'True) (S1 ('MetaSel ('Just "swCTEs") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 [(TableAlias, statement)]) :*: S1 ('MetaSel ('Just "swSelect") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Select)))

type SelectWith = SelectWithG TopLevelCTE Source #

A top-level select with CTEs.

BELit Bool
BEBin BinOp BoolExp BoolExp
BENot BoolExp
BECompare CompareOp SQLExp SQLExp
BECompareAny CompareOp SQLExp SQLExp
BENull SQLExp
BENotNull SQLExp
BEExists Select
BEIN SQLExp [SQLExp]
BEExp SQLExp

SEQ
SGT
SLT
SNE
SGTE
SLTE
SLIKE
SNLIKE
SILIKE
SNILIKE
SSIMILAR
SNSIMILAR
SREGEX
SIREGEX
SNREGEX
SNIREGEX
SContains
SContainedIn
SHasKey
SHasKeysAny
SHasKeysAll
SMatchesFulltext