Safe Haskell	None
Language	Haskell2010

Hasura.RQL.IR.Select

Description

This modules defines the tree of Select types: how we represent a query internally, from its top level QueryDB down to each individual field. Most of those types have three type arguments:

b: BackendType The backend that is targeted by that specific select (Postgres Vanilla, MSSQL...); we use the type families in the Backend class to decide how different parts of the IR are represented in different backends.

v: Type The type of the leaf values in our AST; used almost exclusively for column values, over which queries can be parameterized. The output of the parser phase will use UnpreparedValue b for the leaves, and most backends will then transform the AST to interpret those values and consequently change v to be SQLExpression b

r: BackendType -> Type Joins across backends mean that the aforementioned b parameter won't be the same throughout the entire tree; at some point we will have an AnyBackend used to encapsulate a branch that uses a different b. We still want, however, to be able to parameterize the values of the leaves in that separate branch, and that's what the r parameter is for. We also use UnpreparedValue here during the parsing phase, meaning all leaf values will be UnpreparedValue b for their respective backend b, and most backends will then transform their AST, cutting all such remote branches, and therefore using Const Void for r.

Synopsis

data QueryDB (b :: BackendType) (r :: Type) v
- = QDBMultipleRows (AnnSimpleSelectG b r v)
- | QDBSingleRow (AnnSimpleSelectG b r v)
- | QDBAggregation (AnnAggregateSelectG b r v)
- | QDBConnection (ConnectionSelect b r v)
- | QDBStreamMultipleRows (AnnSimpleStreamSelectG b r v)
data AnnSelectG (b :: BackendType) (f :: Type -> Type) (v :: Type) = AnnSelectG {
- _asnFields :: Fields (f v)
- _asnFrom :: SelectFromG b v
- _asnPerm :: TablePermG b v
- _asnArgs :: SelectArgsG b v
- _asnStrfyNum :: StringifyNumbers
- _asnNamingConvention :: Maybe NamingCase
}
data AnnSelectStreamG (b :: BackendType) (f :: Type -> Type) (v :: Type) = AnnSelectStreamG {
- _assnXStreamingSubscription :: XStreamingSubscription b
- _assnFields :: Fields (f v)
- _assnFrom :: SelectFromG b v
- _assnPerm :: TablePermG b v
- _assnArgs :: SelectStreamArgsG b v
- _assnStrfyNum :: StringifyNumbers
}
type AnnSimpleSelectG b r v = AnnSelectG b (AnnFieldG b r) v
type AnnAggregateSelectG b r v = AnnSelectG b (TableAggregateFieldG b r) v
type AnnSimpleStreamSelectG b r v = AnnSelectStreamG b (AnnFieldG b r) v
type AnnSimpleSelect b = AnnSimpleSelectG b Void (SQLExpression b)
type AnnAggregateSelect b = AnnAggregateSelectG b Void (SQLExpression b)
type AnnSimpleStreamSelect b = AnnSimpleStreamSelectG b Void (SQLExpression b)
bifoldMapAnnSelectG :: (Backend b, Bifoldable (f b), Monoid m) => (r -> m) -> (v -> m) -> AnnSelectG b (f b r) v -> m
bifoldMapAnnSelectStreamG :: (Backend b, Bifoldable (f b), Monoid m) => (r -> m) -> (v -> m) -> AnnSelectStreamG b (f b r) v -> m
data ConnectionSelect (b :: BackendType) (r :: Type) v = ConnectionSelect {
- _csXRelay :: XRelay b
- _csPrimaryKeyColumns :: PrimaryKeyColumns b
- _csSplit :: Maybe (NonEmpty (ConnectionSplit b v))
- _csSlice :: Maybe ConnectionSlice
- _csSelect :: AnnSelectG b (ConnectionField b r) v
}
data ConnectionSplit (b :: BackendType) v = ConnectionSplit {
- _csKind :: ConnectionSplitKind
- _csValue :: v
- _csOrderBy :: OrderByItemG b (AnnotatedOrderByElement b v)
}
data ConnectionSlice
- = SliceFirst Int
- | SliceLast Int
data ConnectionSplitKind
- = CSKBefore
- | CSKAfter
newtype FIIdentifier = FIIdentifier {
- unFIIdentifier :: Text
}
data SelectFromG (b :: BackendType) v
- = FromTable (TableName b)
- | FromIdentifier FIIdentifier
- | FromFunction (FunctionName b) (FunctionArgsExp b v) (Maybe [(Column b, ScalarType b)])
type SelectFrom b = SelectFromG b (SQLExpression b)
data SelectStreamArgsG (b :: BackendType) v = SelectStreamArgsG {
- _ssaWhere :: Maybe (AnnBoolExp b v)
- _ssaBatchSize :: Int
- _ssaCursorArg :: StreamCursorItem b
}
type SelectStreamArgs b = SelectStreamArgsG b (SQLExpression b)
data SelectArgsG (b :: BackendType) v = SelectArgs {
- _saWhere :: Maybe (AnnBoolExp b v)
- _saOrderBy :: Maybe (NonEmpty (AnnotatedOrderByItemG b v))
- _saLimit :: Maybe Int
- _saOffset :: Maybe Int64
- _saDistinct :: Maybe (NonEmpty (Column b))
}
type SelectArgs b = SelectArgsG b (SQLExpression b)
noSelectArgs :: SelectArgsG backend v
data ComputedFieldOrderByElement (b :: BackendType) v
- = CFOBEScalar (ScalarType b)
- | CFOBETableAggregation (TableName b) (AnnBoolExp b v) (AnnotatedAggregateOrderBy b)
data ComputedFieldOrderBy (b :: BackendType) v = ComputedFieldOrderBy {
- _cfobXField :: XComputedField b
- _cfobName :: ComputedFieldName
- _cfobFunction :: FunctionName b
- _cfobFunctionArgsExp :: FunctionArgsExp b v
- _cfobOrderByElement :: ComputedFieldOrderByElement b v
}
data AnnotatedOrderByElement (b :: BackendType) v
- = AOCColumn (ColumnInfo b)
- | AOCObjectRelation (RelInfo b) (AnnBoolExp b v) (AnnotatedOrderByElement b v)
- | AOCArrayAggregation (RelInfo b) (AnnBoolExp b v) (AnnotatedAggregateOrderBy b)
- | AOCComputedField (ComputedFieldOrderBy b v)
data AnnotatedAggregateOrderBy (b :: BackendType)
- = AAOCount
- | AAOOp Text (ColumnInfo b)
type AnnotatedOrderByItemG b v = OrderByItemG b (AnnotatedOrderByElement b v)
type AnnotatedOrderByItem b = AnnotatedOrderByItemG b (SQLExpression b)
data StreamCursorItem (b :: BackendType) = StreamCursorItem {
- _sciOrdering :: CursorOrdering
- _sciColInfo :: ColumnInfo b
- _sciInitialValue :: ColumnValue b
}
data RemoteRelationshipSelect b r = RemoteRelationshipSelect {
- _rrsLHSJoinFields :: HashMap FieldName (DBJoinField b)
- _rrsRelationship :: r
}
data AnnFieldG (b :: BackendType) (r :: Type) v
- = AFColumn (AnnColumnField b v)
- | AFObjectRelation (ObjectRelationSelectG b r v)
- | AFArrayRelation (ArraySelectG b r v)
- | AFComputedField (XComputedField b) ComputedFieldName (ComputedFieldSelect b r v)
- | AFRemote (RemoteRelationshipSelect b r)
- | AFNodeId (XRelay b) SourceName (TableName b) (PrimaryKeyColumns b)
- | AFExpression Text
type AnnField b = AnnFieldG b Void (SQLExpression b)
type AnnFields b = AnnFieldsG b Void (SQLExpression b)
mkAnnColumnField :: Column backend -> ColumnType backend -> Maybe (AnnColumnCaseBoolExp backend v) -> Maybe (ScalarSelectionArguments backend) -> AnnFieldG backend r v
mkAnnColumnFieldAsText :: ColumnInfo backend -> AnnFieldG backend r v
traverseSourceRelationshipSelection :: (Applicative f, Backend backend) => (vf backend -> f (vg backend)) -> SourceRelationshipSelection backend r vf -> f (SourceRelationshipSelection backend r vg)
data TableAggregateFieldG (b :: BackendType) (r :: Type) v
- = TAFAgg (AggregateFields b)
- | TAFNodes (XNodesAgg b) (AnnFieldsG b r v)
- | TAFExp Text
data AggregateField (b :: BackendType)
- = AFCount (CountType b)
- | AFOp (AggregateOp b)
- | AFExp Text
data AggregateOp (b :: BackendType) = AggregateOp {
- _aoOp :: Text
- _aoFields :: ColumnFields b
}
data ColFld (b :: BackendType)
- = CFCol (Column b) (ColumnType b)
- | CFExp Text
type TableAggregateField b = TableAggregateFieldG b Void (SQLExpression b)
type TableAggregateFields b = TableAggregateFieldsG b Void (SQLExpression b)
type TableAggregateFieldsG b r v = Fields (TableAggregateFieldG b r v)
type ColumnFields b = Fields (ColFld b)
type AggregateFields b = Fields (AggregateField b)
type AnnFieldsG b r v = Fields (AnnFieldG b r v)
data ConnectionField (b :: BackendType) (r :: Type) v
- = ConnectionTypename Text
- | ConnectionPageInfo PageInfoFields
- | ConnectionEdges (EdgeFields b r v)
data PageInfoField
- = PageInfoTypename Text
- | PageInfoHasNextPage
- | PageInfoHasPreviousPage
- | PageInfoStartCursor
- | PageInfoEndCursor
data EdgeField (b :: BackendType) (r :: Type) v
- = EdgeTypename Text
- | EdgeCursor
- | EdgeNode (AnnFieldsG b r v)
type ConnectionFields b r v = Fields (ConnectionField b r v)
type PageInfoFields = Fields PageInfoField
type EdgeFields b r v = Fields (EdgeField b r v)
data AnnColumnField (b :: BackendType) v = AnnColumnField {
- _acfColumn :: Column b
- _acfType :: ColumnType b
- _acfAsText :: Bool
- _acfArguments :: Maybe (ScalarSelectionArguments b)
- _acfCaseBoolExpression :: Maybe (AnnColumnCaseBoolExp b v)
}
data ComputedFieldScalarSelect (b :: BackendType) v = ComputedFieldScalarSelect {
- _cfssFunction :: FunctionName b
- _cfssArguments :: FunctionArgsExp b v
- _cfssType :: ScalarType b
- _cfssScalarArguments :: Maybe (ScalarSelectionArguments b)
}
data ComputedFieldSelect (b :: BackendType) (r :: Type) v
- = CFSScalar (ComputedFieldScalarSelect b v) (Maybe (AnnColumnCaseBoolExp b v))
- | CFSTable JsonAggSelect (AnnSimpleSelectG b r v)
data AnnRelationSelectG (b :: BackendType) a = AnnRelationSelectG {
- _aarRelationshipName :: RelName
- _aarColumnMapping :: HashMap (Column b) (Column b)
- _aarAnnSelect :: a
}
type ArrayRelationSelectG b r v = AnnRelationSelectG b (AnnSimpleSelectG b r v)
type ArrayAggregateSelectG b r v = AnnRelationSelectG b (AnnAggregateSelectG b r v)
type ArrayConnectionSelect b r v = AnnRelationSelectG b (ConnectionSelect b r v)
type ArrayAggregateSelect b = ArrayAggregateSelectG b Void (SQLExpression b)
data AnnObjectSelectG (b :: BackendType) (r :: Type) v = AnnObjectSelectG {
- _aosFields :: AnnFieldsG b r v
- _aosTableFrom :: TableName b
- _aosTableFilter :: AnnBoolExp b v
}
type AnnObjectSelect b r = AnnObjectSelectG b r (SQLExpression b)
type ObjectRelationSelectG b r v = AnnRelationSelectG b (AnnObjectSelectG b r v)
type ObjectRelationSelect b = ObjectRelationSelectG b Void (SQLExpression b)
data ArraySelectG (b :: BackendType) (r :: Type) v
- = ASSimple (ArrayRelationSelectG b r v)
- | ASAggregate (ArrayAggregateSelectG b r v)
- | ASConnection (ArrayConnectionSelect b r v)
type ArraySelect b = ArraySelectG b Void (SQLExpression b)
type ArraySelectFieldsG b r v = Fields (ArraySelectG b r v)
data SourceRelationshipSelection (b :: BackendType) (r :: Type) (vf :: BackendType -> Type)
- = SourceRelationshipObject (AnnObjectSelectG b r (vf b))
- | SourceRelationshipArray (AnnSimpleSelectG b r (vf b))
- | SourceRelationshipArrayAggregate (AnnAggregateSelectG b r (vf b))
data RemoteSourceSelect (r :: Type) (vf :: BackendType -> Type) (tgt :: BackendType) = RemoteSourceSelect {
- _rssName :: SourceName
- _rssConfig :: SourceConfig tgt
- _rssSelection :: SourceRelationshipSelection tgt r vf
- _rssJoinMapping :: HashMap FieldName (ScalarType tgt, Column tgt)
}
data TablePermG (b :: BackendType) v = TablePerm {
- _tpFilter :: AnnBoolExp b v
- _tpLimit :: Maybe Int
}
type TablePerm b = TablePermG b (SQLExpression b)
noTablePermissions :: TablePermG backend v
insertFunctionArg :: FunctionArgName -> Int -> a -> FunctionArgsExpG a -> FunctionArgsExpG a
data CountDistinct
- = SelectCountDistinct
- | SelectCountNonDistinct
asnStrfyNum :: forall b f v. Lens' (AnnSelectG b f v) StringifyNumbers
asnPerm :: forall b f v. Lens' (AnnSelectG b f v) (TablePermG b v)
asnNamingConvention :: forall b f v. Lens' (AnnSelectG b f v) (Maybe NamingCase)
asnFrom :: forall b f v. Lens' (AnnSelectG b f v) (SelectFromG b v)
asnFields :: forall b f v f. Lens (AnnSelectG b f v) (AnnSelectG b f v) (Fields (f v)) (Fields (f v))
asnArgs :: forall b f v. Lens' (AnnSelectG b f v) (SelectArgsG b v)
aosTableFrom :: forall b r v. Lens' (AnnObjectSelectG b r v) (TableName b)
aosTableFilter :: forall b r v. Lens' (AnnObjectSelectG b r v) (AnnBoolExp b v)
aosFields :: forall b r v r. Lens (AnnObjectSelectG b r v) (AnnObjectSelectG b r v) (AnnFieldsG b r v) (AnnFieldsG b r v)
aarRelationshipName :: forall b a. Lens' (AnnRelationSelectG b a) RelName
aarColumnMapping :: forall b a b. Lens (AnnRelationSelectG b a) (AnnRelationSelectG b a) (HashMap (Column b) (Column b)) (HashMap (Column b) (Column b))
aarAnnSelect :: forall b a a. Lens (AnnRelationSelectG b a) (AnnRelationSelectG b a) a a
csXRelay :: forall b r v. Lens' (ConnectionSelect b r v) (XRelay b)
csSplit :: forall b r v. Lens' (ConnectionSelect b r v) (Maybe (NonEmpty (ConnectionSplit b v)))
csSlice :: forall b r v. Lens' (ConnectionSelect b r v) (Maybe ConnectionSlice)
csSelect :: forall b r v r. Lens (ConnectionSelect b r v) (ConnectionSelect b r v) (AnnSelectG b (ConnectionField b r) v) (AnnSelectG b (ConnectionField b r) v)
csPrimaryKeyColumns :: forall b r v. Lens' (ConnectionSelect b r v) (PrimaryKeyColumns b)
saWhere :: forall b v. Lens' (SelectArgsG b v) (Maybe (AnnBoolExp b v))
saOrderBy :: forall b v. Lens' (SelectArgsG b v) (Maybe (NonEmpty (AnnotatedOrderByItemG b v)))
saOffset :: forall b v. Lens' (SelectArgsG b v) (Maybe Int64)
saLimit :: forall b v. Lens' (SelectArgsG b v) (Maybe Int)
saDistinct :: forall b v. Lens' (SelectArgsG b v) (Maybe (NonEmpty (Column b)))
_AFExpression :: forall b r v. Prism' (AnnFieldG b r v) Text
_AFNodeId :: forall b r v. Prism' (AnnFieldG b r v) (XRelay b, SourceName, TableName b, PrimaryKeyColumns b)
_AFRemote :: forall b r v. Prism' (AnnFieldG b r v) (RemoteRelationshipSelect b r)
_AFComputedField :: forall b r v. Prism' (AnnFieldG b r v) (XComputedField b, ComputedFieldName, ComputedFieldSelect b r v)
_AFArrayRelation :: forall b r v. Prism' (AnnFieldG b r v) (ArraySelectG b r v)
_AFObjectRelation :: forall b r v. Prism' (AnnFieldG b r v) (ObjectRelationSelectG b r v)
_AFColumn :: forall b r v. Prism' (AnnFieldG b r v) (AnnColumnField b v)
_AOCComputedField :: forall b v. Prism' (AnnotatedOrderByElement b v) (ComputedFieldOrderBy b v)
_AOCArrayAggregation :: forall b v. Prism' (AnnotatedOrderByElement b v) (RelInfo b, AnnBoolExp b v, AnnotatedAggregateOrderBy b)
_AOCObjectRelation :: forall b v. Prism' (AnnotatedOrderByElement b v) (RelInfo b, AnnBoolExp b v, AnnotatedOrderByElement b v)
_AOCColumn :: forall b v. Prism' (AnnotatedOrderByElement b v) (ColumnInfo b)
_TAFExp :: forall b r v. Prism' (TableAggregateFieldG b r v) Text
_TAFNodes :: forall b r v r v. Prism (TableAggregateFieldG b r v) (TableAggregateFieldG b r v) (XNodesAgg b, AnnFieldsG b r v) (XNodesAgg b, AnnFieldsG b r v)
_TAFAgg :: forall b r v. Prism' (TableAggregateFieldG b r v) (AggregateFields b)
_ConnectionEdges :: forall b r v b r v. Prism (ConnectionField b r v) (ConnectionField b r v) (EdgeFields b r v) (EdgeFields b r v)
_ConnectionPageInfo :: forall b r v. Prism' (ConnectionField b r v) PageInfoFields
_ConnectionTypename :: forall b r v. Prism' (ConnectionField b r v) Text
_EdgeNode :: forall b r v b r v. Prism (EdgeField b r v) (EdgeField b r v) (AnnFieldsG b r v) (AnnFieldsG b r v)
_EdgeCursor :: forall b r v. Prism' (EdgeField b r v) ()
_EdgeTypename :: forall b r v. Prism' (EdgeField b r v) Text

Documentation

data QueryDB (b :: BackendType) (r :: Type) v Source #

Constructors

QDBMultipleRows (AnnSimpleSelectG b r v)
QDBSingleRow (AnnSimpleSelectG b r v)
QDBAggregation (AnnAggregateSelectG b r v)
QDBConnection (ConnectionSelect b r v)
QDBStreamMultipleRows (AnnSimpleStreamSelectG b r v)

Instances

Instances details

Backend b => Bifoldable (QueryDB b) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods bifold :: Monoid m => QueryDB b m m -> m # bifoldMap :: Monoid m => (a -> m) -> (b0 -> m) -> QueryDB b a b0 -> m # bifoldr :: (a -> c -> c) -> (b0 -> c -> c) -> c -> QueryDB b a b0 -> c # bifoldl :: (c -> a -> c) -> (c -> b0 -> c) -> c -> QueryDB b a b0 -> c #
Backend b => Functor (QueryDB b r) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods fmap :: (a -> b0) -> QueryDB b r a -> QueryDB b r b0 # (<$) :: a -> QueryDB b r b0 -> QueryDB b r a #
Backend b => Foldable (QueryDB b r) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods fold :: Monoid m => QueryDB b r m -> m # foldMap :: Monoid m => (a -> m) -> QueryDB b r a -> m # foldMap' :: Monoid m => (a -> m) -> QueryDB b r a -> m # foldr :: (a -> b0 -> b0) -> b0 -> QueryDB b r a -> b0 # foldr' :: (a -> b0 -> b0) -> b0 -> QueryDB b r a -> b0 # foldl :: (b0 -> a -> b0) -> b0 -> QueryDB b r a -> b0 # foldl' :: (b0 -> a -> b0) -> b0 -> QueryDB b r a -> b0 # foldr1 :: (a -> a -> a) -> QueryDB b r a -> a # foldl1 :: (a -> a -> a) -> QueryDB b r a -> a # toList :: QueryDB b r a -> [a] # null :: QueryDB b r a -> Bool # length :: QueryDB b r a -> Int # elem :: Eq a => a -> QueryDB b r a -> Bool # maximum :: Ord a => QueryDB b r a -> a # minimum :: Ord a => QueryDB b r a -> a # sum :: Num a => QueryDB b r a -> a # product :: Num a => QueryDB b r a -> a #
Backend b => Traversable (QueryDB b r) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods traverse :: Applicative f => (a -> f b0) -> QueryDB b r a -> f (QueryDB b r b0) # sequenceA :: Applicative f => QueryDB b r (f a) -> f (QueryDB b r a) # mapM :: Monad m => (a -> m b0) -> QueryDB b r a -> m (QueryDB b r b0) # sequence :: Monad m => QueryDB b r (m a) -> m (QueryDB b r a) #
Generic (QueryDB b r v) Source #
Instance details Defined in Hasura.RQL.IR.Select Associated Types type Rep (QueryDB b r v) :: Type -> Type # Methods from :: QueryDB b r v -> Rep (QueryDB b r v) x # to :: Rep (QueryDB b r v) x -> QueryDB b r v #
type Rep (QueryDB b r v) Source #
Instance details Defined in Hasura.RQL.IR.Select type Rep (QueryDB b r v) = D1 ('MetaData "QueryDB" "Hasura.RQL.IR.Select" "graphql-engine-1.0.0-inplace" 'False) ((C1 ('MetaCons "QDBMultipleRows" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (AnnSimpleSelectG b r v))) :+: C1 ('MetaCons "QDBSingleRow" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (AnnSimpleSelectG b r v)))) :+: (C1 ('MetaCons "QDBAggregation" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (AnnAggregateSelectG b r v))) :+: (C1 ('MetaCons "QDBConnection" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (ConnectionSelect b r v))) :+: C1 ('MetaCons "QDBStreamMultipleRows" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (AnnSimpleStreamSelectG b r v))))))

data AnnSelectG (b :: BackendType) (f :: Type -> Type) (v :: Type) Source #

Constructors

AnnSelectG
Fields _asnFields :: Fields (f v) _asnFrom :: SelectFromG b v _asnPerm :: TablePermG b v _asnArgs :: SelectArgsG b v _asnStrfyNum :: StringifyNumbers _asnNamingConvention :: Maybe NamingCase

Instances

Instances details

(Backend b, Functor f) => Functor (AnnSelectG b f) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods fmap :: (a -> b0) -> AnnSelectG b f a -> AnnSelectG b f b0 # (<$) :: a -> AnnSelectG b f b0 -> AnnSelectG b f a #
(Backend b, Foldable f) => Foldable (AnnSelectG b f) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods fold :: Monoid m => AnnSelectG b f m -> m # foldMap :: Monoid m => (a -> m) -> AnnSelectG b f a -> m # foldMap' :: Monoid m => (a -> m) -> AnnSelectG b f a -> m # foldr :: (a -> b0 -> b0) -> b0 -> AnnSelectG b f a -> b0 # foldr' :: (a -> b0 -> b0) -> b0 -> AnnSelectG b f a -> b0 # foldl :: (b0 -> a -> b0) -> b0 -> AnnSelectG b f a -> b0 # foldl' :: (b0 -> a -> b0) -> b0 -> AnnSelectG b f a -> b0 # foldr1 :: (a -> a -> a) -> AnnSelectG b f a -> a # foldl1 :: (a -> a -> a) -> AnnSelectG b f a -> a # toList :: AnnSelectG b f a -> [a] # null :: AnnSelectG b f a -> Bool # length :: AnnSelectG b f a -> Int # elem :: Eq a => a -> AnnSelectG b f a -> Bool # maximum :: Ord a => AnnSelectG b f a -> a # minimum :: Ord a => AnnSelectG b f a -> a # sum :: Num a => AnnSelectG b f a -> a # product :: Num a => AnnSelectG b f a -> a #
(Backend b, Traversable f) => Traversable (AnnSelectG b f) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods traverse :: Applicative f0 => (a -> f0 b0) -> AnnSelectG b f a -> f0 (AnnSelectG b f b0) # sequenceA :: Applicative f0 => AnnSelectG b f (f0 a) -> f0 (AnnSelectG b f a) # mapM :: Monad m => (a -> m b0) -> AnnSelectG b f a -> m (AnnSelectG b f b0) # sequence :: Monad m => AnnSelectG b f (m a) -> m (AnnSelectG b f a) #
(Backend b, Eq (Fields (f v)), Eq (SelectArgsG b v), Eq (SelectFromG b v), Eq (TablePermG b v)) => Eq (AnnSelectG b f v) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods (==) :: AnnSelectG b f v -> AnnSelectG b f v -> Bool # (/=) :: AnnSelectG b f v -> AnnSelectG b f v -> Bool #
(Backend b, Show (Fields (f v)), Show (SelectArgsG b v), Show (SelectFromG b v), Show (TablePermG b v)) => Show (AnnSelectG b f v) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods showsPrec :: Int -> AnnSelectG b f v -> ShowS # show :: AnnSelectG b f v -> String # showList :: [AnnSelectG b f v] -> ShowS #

data AnnSelectStreamG (b :: BackendType) (f :: Type -> Type) (v :: Type) Source #

IR type representing nodes for streaming subscriptions

Constructors

AnnSelectStreamG

Fields

_assnXStreamingSubscription :: XStreamingSubscription b
type to indicate if streaming subscription has been enabled in the BackendType. This type helps avoiding missing case match patterns for backends where it's disabled.
_assnFields :: Fields (f v)
output selection fields
_assnFrom :: SelectFromG b v
table information to select from
_assnPerm :: TablePermG b v
select permissions
_assnArgs :: SelectStreamArgsG b v
streaming arguments
_assnStrfyNum :: StringifyNumbers

Instances

Instances details

(Backend b, Functor f) => Functor (AnnSelectStreamG b f) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods fmap :: (a -> b0) -> AnnSelectStreamG b f a -> AnnSelectStreamG b f b0 # (<$) :: a -> AnnSelectStreamG b f b0 -> AnnSelectStreamG b f a #
(Backend b, Foldable f) => Foldable (AnnSelectStreamG b f) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods fold :: Monoid m => AnnSelectStreamG b f m -> m # foldMap :: Monoid m => (a -> m) -> AnnSelectStreamG b f a -> m # foldMap' :: Monoid m => (a -> m) -> AnnSelectStreamG b f a -> m # foldr :: (a -> b0 -> b0) -> b0 -> AnnSelectStreamG b f a -> b0 # foldr' :: (a -> b0 -> b0) -> b0 -> AnnSelectStreamG b f a -> b0 # foldl :: (b0 -> a -> b0) -> b0 -> AnnSelectStreamG b f a -> b0 # foldl' :: (b0 -> a -> b0) -> b0 -> AnnSelectStreamG b f a -> b0 # foldr1 :: (a -> a -> a) -> AnnSelectStreamG b f a -> a # foldl1 :: (a -> a -> a) -> AnnSelectStreamG b f a -> a # toList :: AnnSelectStreamG b f a -> [a] # null :: AnnSelectStreamG b f a -> Bool # length :: AnnSelectStreamG b f a -> Int # elem :: Eq a => a -> AnnSelectStreamG b f a -> Bool # maximum :: Ord a => AnnSelectStreamG b f a -> a # minimum :: Ord a => AnnSelectStreamG b f a -> a # sum :: Num a => AnnSelectStreamG b f a -> a # product :: Num a => AnnSelectStreamG b f a -> a #
(Backend b, Traversable f) => Traversable (AnnSelectStreamG b f) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods traverse :: Applicative f0 => (a -> f0 b0) -> AnnSelectStreamG b f a -> f0 (AnnSelectStreamG b f b0) # sequenceA :: Applicative f0 => AnnSelectStreamG b f (f0 a) -> f0 (AnnSelectStreamG b f a) # mapM :: Monad m => (a -> m b0) -> AnnSelectStreamG b f a -> m (AnnSelectStreamG b f b0) # sequence :: Monad m => AnnSelectStreamG b f (m a) -> m (AnnSelectStreamG b f a) #
(Backend b, Eq (SelectFromG b v), Eq (TablePermG b v), Eq (SelectStreamArgsG b v), Eq (f v)) => Eq (AnnSelectStreamG b f v) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods (==) :: AnnSelectStreamG b f v -> AnnSelectStreamG b f v -> Bool # (/=) :: AnnSelectStreamG b f v -> AnnSelectStreamG b f v -> Bool #
(Backend b, Show (SelectFromG b v), Show (TablePermG b v), Show (SelectStreamArgsG b v), Show (f v)) => Show (AnnSelectStreamG b f v) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods showsPrec :: Int -> AnnSelectStreamG b f v -> ShowS # show :: AnnSelectStreamG b f v -> String # showList :: [AnnSelectStreamG b f v] -> ShowS #

type AnnSimpleSelectG b r v = AnnSelectG b (AnnFieldG b r) v Source #

type AnnAggregateSelectG b r v = AnnSelectG b (TableAggregateFieldG b r) v Source #

type AnnSimpleStreamSelectG b r v = AnnSelectStreamG b (AnnFieldG b r) v Source #

type AnnSimpleSelect b = AnnSimpleSelectG b Void (SQLExpression b) Source #

type AnnAggregateSelect b = AnnAggregateSelectG b Void (SQLExpression b) Source #

type AnnSimpleStreamSelect b = AnnSimpleStreamSelectG b Void (SQLExpression b) Source #

bifoldMapAnnSelectG :: (Backend b, Bifoldable (f b), Monoid m) => (r -> m) -> (v -> m) -> AnnSelectG b (f b r) v -> m Source #

We can't write a Bifoldable instance for AnnSelectG because the types don't line up. Instead, we provide this function which can be used to help define Bifoldable instances of other types containing AnnSelectG values.

bifoldMapAnnSelectStreamG :: (Backend b, Bifoldable (f b), Monoid m) => (r -> m) -> (v -> m) -> AnnSelectStreamG b (f b r) v -> m Source #

data ConnectionSelect (b :: BackendType) (r :: Type) v Source #

Constructors

ConnectionSelect
Fields _csXRelay :: XRelay b _csPrimaryKeyColumns :: PrimaryKeyColumns b _csSplit :: Maybe (NonEmpty (ConnectionSplit b v)) _csSlice :: Maybe ConnectionSlice _csSelect :: AnnSelectG b (ConnectionField b r) v

Instances

Instances details

Backend b => Bifoldable (ConnectionSelect b) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods bifold :: Monoid m => ConnectionSelect b m m -> m # bifoldMap :: Monoid m => (a -> m) -> (b0 -> m) -> ConnectionSelect b a b0 -> m # bifoldr :: (a -> c -> c) -> (b0 -> c -> c) -> c -> ConnectionSelect b a b0 -> c # bifoldl :: (c -> a -> c) -> (c -> b0 -> c) -> c -> ConnectionSelect b a b0 -> c #
Backend b => Functor (ConnectionSelect b r) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods fmap :: (a -> b0) -> ConnectionSelect b r a -> ConnectionSelect b r b0 # (<$) :: a -> ConnectionSelect b r b0 -> ConnectionSelect b r a #
Backend b => Foldable (ConnectionSelect b r) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods fold :: Monoid m => ConnectionSelect b r m -> m # foldMap :: Monoid m => (a -> m) -> ConnectionSelect b r a -> m # foldMap' :: Monoid m => (a -> m) -> ConnectionSelect b r a -> m # foldr :: (a -> b0 -> b0) -> b0 -> ConnectionSelect b r a -> b0 # foldr' :: (a -> b0 -> b0) -> b0 -> ConnectionSelect b r a -> b0 # foldl :: (b0 -> a -> b0) -> b0 -> ConnectionSelect b r a -> b0 # foldl' :: (b0 -> a -> b0) -> b0 -> ConnectionSelect b r a -> b0 # foldr1 :: (a -> a -> a) -> ConnectionSelect b r a -> a # foldl1 :: (a -> a -> a) -> ConnectionSelect b r a -> a # toList :: ConnectionSelect b r a -> [a] # null :: ConnectionSelect b r a -> Bool # length :: ConnectionSelect b r a -> Int # elem :: Eq a => a -> ConnectionSelect b r a -> Bool # maximum :: Ord a => ConnectionSelect b r a -> a # minimum :: Ord a => ConnectionSelect b r a -> a # sum :: Num a => ConnectionSelect b r a -> a # product :: Num a => ConnectionSelect b r a -> a #
Backend b => Traversable (ConnectionSelect b r) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods traverse :: Applicative f => (a -> f b0) -> ConnectionSelect b r a -> f (ConnectionSelect b r b0) # sequenceA :: Applicative f => ConnectionSelect b r (f a) -> f (ConnectionSelect b r a) # mapM :: Monad m => (a -> m b0) -> ConnectionSelect b r a -> m (ConnectionSelect b r b0) # sequence :: Monad m => ConnectionSelect b r (m a) -> m (ConnectionSelect b r a) #
(Backend b, Eq (AnnSelectG b (ConnectionField b r) v), Eq ConnectionSlice, Eq (ConnectionSplit b v), Eq (PrimaryKeyColumns b)) => Eq (ConnectionSelect b r v) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods (==) :: ConnectionSelect b r v -> ConnectionSelect b r v -> Bool # (/=) :: ConnectionSelect b r v -> ConnectionSelect b r v -> Bool #
(Backend b, Show (AnnSelectG b (ConnectionField b r) v), Show ConnectionSlice, Show (ConnectionSplit b v), Show (PrimaryKeyColumns b)) => Show (ConnectionSelect b r v) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods showsPrec :: Int -> ConnectionSelect b r v -> ShowS # show :: ConnectionSelect b r v -> String # showList :: [ConnectionSelect b r v] -> ShowS #

data ConnectionSplit (b :: BackendType) v Source #

Constructors

ConnectionSplit
Fields _csKind :: ConnectionSplitKind _csValue :: v _csOrderBy :: OrderByItemG b (AnnotatedOrderByElement b v)

Instances

Instances details

Backend b => Functor (ConnectionSplit b) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods fmap :: (a -> b0) -> ConnectionSplit b a -> ConnectionSplit b b0 # (<$) :: a -> ConnectionSplit b b0 -> ConnectionSplit b a #
Backend b => Foldable (ConnectionSplit b) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods fold :: Monoid m => ConnectionSplit b m -> m # foldMap :: Monoid m => (a -> m) -> ConnectionSplit b a -> m # foldMap' :: Monoid m => (a -> m) -> ConnectionSplit b a -> m # foldr :: (a -> b0 -> b0) -> b0 -> ConnectionSplit b a -> b0 # foldr' :: (a -> b0 -> b0) -> b0 -> ConnectionSplit b a -> b0 # foldl :: (b0 -> a -> b0) -> b0 -> ConnectionSplit b a -> b0 # foldl' :: (b0 -> a -> b0) -> b0 -> ConnectionSplit b a -> b0 # foldr1 :: (a -> a -> a) -> ConnectionSplit b a -> a # foldl1 :: (a -> a -> a) -> ConnectionSplit b a -> a # toList :: ConnectionSplit b a -> [a] # null :: ConnectionSplit b a -> Bool # length :: ConnectionSplit b a -> Int # elem :: Eq a => a -> ConnectionSplit b a -> Bool # maximum :: Ord a => ConnectionSplit b a -> a # minimum :: Ord a => ConnectionSplit b a -> a # sum :: Num a => ConnectionSplit b a -> a # product :: Num a => ConnectionSplit b a -> a #
Backend b => Traversable (ConnectionSplit b) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods traverse :: Applicative f => (a -> f b0) -> ConnectionSplit b a -> f (ConnectionSplit b b0) # sequenceA :: Applicative f => ConnectionSplit b (f a) -> f (ConnectionSplit b a) # mapM :: Monad m => (a -> m b0) -> ConnectionSplit b a -> m (ConnectionSplit b b0) # sequence :: Monad m => ConnectionSplit b (m a) -> m (ConnectionSplit b a) #
(Backend b, Eq v, Eq (OrderByItemG b (AnnotatedOrderByElement b v))) => Eq (ConnectionSplit b v) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods (==) :: ConnectionSplit b v -> ConnectionSplit b v -> Bool # (/=) :: ConnectionSplit b v -> ConnectionSplit b v -> Bool #
(Backend b, Show v, Show (OrderByItemG b (AnnotatedOrderByElement b v))) => Show (ConnectionSplit b v) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods showsPrec :: Int -> ConnectionSplit b v -> ShowS # show :: ConnectionSplit b v -> String # showList :: [ConnectionSplit b v] -> ShowS #
Generic (ConnectionSplit b v) Source #
Instance details Defined in Hasura.RQL.IR.Select Associated Types type Rep (ConnectionSplit b v) :: Type -> Type # Methods from :: ConnectionSplit b v -> Rep (ConnectionSplit b v) x # to :: Rep (ConnectionSplit b v) x -> ConnectionSplit b v #
(Backend b, Hashable v, Hashable (OrderByItemG b (AnnotatedOrderByElement b v))) => Hashable (ConnectionSplit b v) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods hashWithSalt :: Int -> ConnectionSplit b v -> Int hash :: ConnectionSplit b v -> Int
type Rep (ConnectionSplit b v) Source #
Instance details Defined in Hasura.RQL.IR.Select type Rep (ConnectionSplit b v) = D1 ('MetaData "ConnectionSplit" "Hasura.RQL.IR.Select" "graphql-engine-1.0.0-inplace" 'False) (C1 ('MetaCons "ConnectionSplit" 'PrefixI 'True) (S1 ('MetaSel ('Just "_csKind") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 ConnectionSplitKind) :: (S1 ('MetaSel ('Just "_csValue") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 v) :: S1 ('MetaSel ('Just "_csOrderBy") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (OrderByItemG b (AnnotatedOrderByElement b v))))))

data ConnectionSlice Source #

Constructors

SliceFirst Int
SliceLast Int

Instances

Instances details

Eq ConnectionSlice Source #
Instance details Defined in Hasura.RQL.IR.Select Methods (==) :: ConnectionSlice -> ConnectionSlice -> Bool # (/=) :: ConnectionSlice -> ConnectionSlice -> Bool #
Show ConnectionSlice Source #
Instance details Defined in Hasura.RQL.IR.Select Methods showsPrec :: Int -> ConnectionSlice -> ShowS # show :: ConnectionSlice -> String # showList :: [ConnectionSlice] -> ShowS #
Generic ConnectionSlice Source #
Instance details Defined in Hasura.RQL.IR.Select Associated Types type Rep ConnectionSlice :: Type -> Type # Methods from :: ConnectionSlice -> Rep ConnectionSlice x # to :: Rep ConnectionSlice x -> ConnectionSlice #
Hashable ConnectionSlice Source #
Instance details Defined in Hasura.RQL.IR.Select Methods hashWithSalt :: Int -> ConnectionSlice -> Int hash :: ConnectionSlice -> Int
type Rep ConnectionSlice Source #
Instance details Defined in Hasura.RQL.IR.Select type Rep ConnectionSlice = D1 ('MetaData "ConnectionSlice" "Hasura.RQL.IR.Select" "graphql-engine-1.0.0-inplace" 'False) (C1 ('MetaCons "SliceFirst" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Int)) :+: C1 ('MetaCons "SliceLast" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Int)))

data ConnectionSplitKind Source #

Constructors

CSKBefore
CSKAfter

Instances

Instances details

Eq ConnectionSplitKind Source #
Instance details Defined in Hasura.RQL.IR.Select Methods (==) :: ConnectionSplitKind -> ConnectionSplitKind -> Bool # (/=) :: ConnectionSplitKind -> ConnectionSplitKind -> Bool #
Show ConnectionSplitKind Source #
Instance details Defined in Hasura.RQL.IR.Select Methods showsPrec :: Int -> ConnectionSplitKind -> ShowS # show :: ConnectionSplitKind -> String # showList :: [ConnectionSplitKind] -> ShowS #
Generic ConnectionSplitKind Source #
Instance details Defined in Hasura.RQL.IR.Select Associated Types type Rep ConnectionSplitKind :: Type -> Type # Methods from :: ConnectionSplitKind -> Rep ConnectionSplitKind x # to :: Rep ConnectionSplitKind x -> ConnectionSplitKind #
Hashable ConnectionSplitKind Source #
Instance details Defined in Hasura.RQL.IR.Select Methods hashWithSalt :: Int -> ConnectionSplitKind -> Int hash :: ConnectionSplitKind -> Int
type Rep ConnectionSplitKind Source #
Instance details Defined in Hasura.RQL.IR.Select type Rep ConnectionSplitKind = D1 ('MetaData "ConnectionSplitKind" "Hasura.RQL.IR.Select" "graphql-engine-1.0.0-inplace" 'False) (C1 ('MetaCons "CSKBefore" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "CSKAfter" 'PrefixI 'False) (U1 :: Type -> Type))

newtype FIIdentifier Source #

Identifier used exclusively as the argument to FromIdentifier

Constructors

FIIdentifier
Fields unFIIdentifier :: Text

Instances

Instances details

Eq FIIdentifier Source #
Instance details Defined in Hasura.RQL.IR.Select Methods (==) :: FIIdentifier -> FIIdentifier -> Bool # (/=) :: FIIdentifier -> FIIdentifier -> Bool #
Show FIIdentifier Source #
Instance details Defined in Hasura.RQL.IR.Select Methods showsPrec :: Int -> FIIdentifier -> ShowS # show :: FIIdentifier -> String # showList :: [FIIdentifier] -> ShowS #
Generic FIIdentifier Source #
Instance details Defined in Hasura.RQL.IR.Select Associated Types type Rep FIIdentifier :: Type -> Type # Methods from :: FIIdentifier -> Rep FIIdentifier x # to :: Rep FIIdentifier x -> FIIdentifier #
Hashable FIIdentifier Source #
Instance details Defined in Hasura.RQL.IR.Select Methods hashWithSalt :: Int -> FIIdentifier -> Int hash :: FIIdentifier -> Int
IsIdentifier FIIdentifier Source #
Instance details Defined in Hasura.RQL.IR.Select Methods toIdentifier :: FIIdentifier -> Identifier Source #
type Rep FIIdentifier Source #
Instance details Defined in Hasura.RQL.IR.Select type Rep FIIdentifier = D1 ('MetaData "FIIdentifier" "Hasura.RQL.IR.Select" "graphql-engine-1.0.0-inplace" 'True) (C1 ('MetaCons "FIIdentifier" 'PrefixI 'True) (S1 ('MetaSel ('Just "unFIIdentifier") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Text)))

data SelectFromG (b :: BackendType) v Source #

Constructors

FromTable (TableName b)
FromIdentifier FIIdentifier
FromFunction (FunctionName b) (FunctionArgsExp b v) (Maybe [(Column b, ScalarType b)])

Instances

Instances details

Backend b => Functor (SelectFromG b) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods fmap :: (a -> b0) -> SelectFromG b a -> SelectFromG b b0 # (<$) :: a -> SelectFromG b b0 -> SelectFromG b a #
Backend b => Foldable (SelectFromG b) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods fold :: Monoid m => SelectFromG b m -> m # foldMap :: Monoid m => (a -> m) -> SelectFromG b a -> m # foldMap' :: Monoid m => (a -> m) -> SelectFromG b a -> m # foldr :: (a -> b0 -> b0) -> b0 -> SelectFromG b a -> b0 # foldr' :: (a -> b0 -> b0) -> b0 -> SelectFromG b a -> b0 # foldl :: (b0 -> a -> b0) -> b0 -> SelectFromG b a -> b0 # foldl' :: (b0 -> a -> b0) -> b0 -> SelectFromG b a -> b0 # foldr1 :: (a -> a -> a) -> SelectFromG b a -> a # foldl1 :: (a -> a -> a) -> SelectFromG b a -> a # toList :: SelectFromG b a -> [a] # null :: SelectFromG b a -> Bool # length :: SelectFromG b a -> Int # elem :: Eq a => a -> SelectFromG b a -> Bool # maximum :: Ord a => SelectFromG b a -> a # minimum :: Ord a => SelectFromG b a -> a # sum :: Num a => SelectFromG b a -> a # product :: Num a => SelectFromG b a -> a #
Backend b => Traversable (SelectFromG b) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods traverse :: Applicative f => (a -> f b0) -> SelectFromG b a -> f (SelectFromG b b0) # sequenceA :: Applicative f => SelectFromG b (f a) -> f (SelectFromG b a) # mapM :: Monad m => (a -> m b0) -> SelectFromG b a -> m (SelectFromG b b0) # sequence :: Monad m => SelectFromG b (m a) -> m (SelectFromG b a) #
(Backend b, Eq v, Eq (FunctionArgumentExp b v)) => Eq (SelectFromG b v) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods (==) :: SelectFromG b v -> SelectFromG b v -> Bool # (/=) :: SelectFromG b v -> SelectFromG b v -> Bool #
(Backend b, Show v, Show (FunctionArgumentExp b v)) => Show (SelectFromG b v) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods showsPrec :: Int -> SelectFromG b v -> ShowS # show :: SelectFromG b v -> String # showList :: [SelectFromG b v] -> ShowS #
Generic (SelectFromG b v) Source #
Instance details Defined in Hasura.RQL.IR.Select Associated Types type Rep (SelectFromG b v) :: Type -> Type # Methods from :: SelectFromG b v -> Rep (SelectFromG b v) x # to :: Rep (SelectFromG b v) x -> SelectFromG b v #
(Backend b, Hashable v, Hashable (FunctionArgumentExp b v)) => Hashable (SelectFromG b v) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods hashWithSalt :: Int -> SelectFromG b v -> Int hash :: SelectFromG b v -> Int
type Rep (SelectFromG b v) Source #
Instance details Defined in Hasura.RQL.IR.Select type Rep (SelectFromG b v) = D1 ('MetaData "SelectFromG" "Hasura.RQL.IR.Select" "graphql-engine-1.0.0-inplace" 'False) (C1 ('MetaCons "FromTable" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (TableName b))) :+: (C1 ('MetaCons "FromIdentifier" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 FIIdentifier)) :+: C1 ('MetaCons "FromFunction" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (FunctionName b)) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (FunctionArgsExp b v)) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (Maybe [(Column b, ScalarType b)]))))))

type SelectFrom b = SelectFromG b (SQLExpression b) Source #

data SelectStreamArgsG (b :: BackendType) v Source #

Constructors

SelectStreamArgsG
Fields _ssaWhere :: Maybe (AnnBoolExp b v) optional filter to filter the stream results _ssaBatchSize :: Int maximum number of rows to be returned in a single fetch _ssaCursorArg :: StreamCursorItem b info related to the cursor column, a single item data type currently because only single column cursors are supported

Instances

Instances details

Backend b => Functor (SelectStreamArgsG b) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods fmap :: (a -> b0) -> SelectStreamArgsG b a -> SelectStreamArgsG b b0 # (<$) :: a -> SelectStreamArgsG b b0 -> SelectStreamArgsG b a #
Backend b => Foldable (SelectStreamArgsG b) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods fold :: Monoid m => SelectStreamArgsG b m -> m # foldMap :: Monoid m => (a -> m) -> SelectStreamArgsG b a -> m # foldMap' :: Monoid m => (a -> m) -> SelectStreamArgsG b a -> m # foldr :: (a -> b0 -> b0) -> b0 -> SelectStreamArgsG b a -> b0 # foldr' :: (a -> b0 -> b0) -> b0 -> SelectStreamArgsG b a -> b0 # foldl :: (b0 -> a -> b0) -> b0 -> SelectStreamArgsG b a -> b0 # foldl' :: (b0 -> a -> b0) -> b0 -> SelectStreamArgsG b a -> b0 # foldr1 :: (a -> a -> a) -> SelectStreamArgsG b a -> a # foldl1 :: (a -> a -> a) -> SelectStreamArgsG b a -> a # toList :: SelectStreamArgsG b a -> [a] # null :: SelectStreamArgsG b a -> Bool # length :: SelectStreamArgsG b a -> Int # elem :: Eq a => a -> SelectStreamArgsG b a -> Bool # maximum :: Ord a => SelectStreamArgsG b a -> a # minimum :: Ord a => SelectStreamArgsG b a -> a # sum :: Num a => SelectStreamArgsG b a -> a # product :: Num a => SelectStreamArgsG b a -> a #
Backend b => Traversable (SelectStreamArgsG b) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods traverse :: Applicative f => (a -> f b0) -> SelectStreamArgsG b a -> f (SelectStreamArgsG b b0) # sequenceA :: Applicative f => SelectStreamArgsG b (f a) -> f (SelectStreamArgsG b a) # mapM :: Monad m => (a -> m b0) -> SelectStreamArgsG b a -> m (SelectStreamArgsG b b0) # sequence :: Monad m => SelectStreamArgsG b (m a) -> m (SelectStreamArgsG b a) #
(Backend b, Eq (AnnBoolExp b v), Eq v) => Eq (SelectStreamArgsG b v) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods (==) :: SelectStreamArgsG b v -> SelectStreamArgsG b v -> Bool # (/=) :: SelectStreamArgsG b v -> SelectStreamArgsG b v -> Bool #
(Backend b, Show (AnnBoolExp b v), Show v) => Show (SelectStreamArgsG b v) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods showsPrec :: Int -> SelectStreamArgsG b v -> ShowS # show :: SelectStreamArgsG b v -> String # showList :: [SelectStreamArgsG b v] -> ShowS #
Generic (SelectStreamArgsG b v) Source #
Instance details Defined in Hasura.RQL.IR.Select Associated Types type Rep (SelectStreamArgsG b v) :: Type -> Type # Methods from :: SelectStreamArgsG b v -> Rep (SelectStreamArgsG b v) x # to :: Rep (SelectStreamArgsG b v) x -> SelectStreamArgsG b v #
type Rep (SelectStreamArgsG b v) Source #
Instance details Defined in Hasura.RQL.IR.Select type Rep (SelectStreamArgsG b v) = D1 ('MetaData "SelectStreamArgsG" "Hasura.RQL.IR.Select" "graphql-engine-1.0.0-inplace" 'False) (C1 ('MetaCons "SelectStreamArgsG" 'PrefixI 'True) (S1 ('MetaSel ('Just "_ssaWhere") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (Maybe (AnnBoolExp b v))) :: (S1 ('MetaSel ('Just "_ssaBatchSize") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Int) :: S1 ('MetaSel ('Just "_ssaCursorArg") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (StreamCursorItem b)))))

type SelectStreamArgs b = SelectStreamArgsG b (SQLExpression b) Source #

data SelectArgsG (b :: BackendType) v Source #

Constructors

SelectArgs
Fields _saWhere :: Maybe (AnnBoolExp b v) _saOrderBy :: Maybe (NonEmpty (AnnotatedOrderByItemG b v)) _saLimit :: Maybe Int _saOffset :: Maybe Int64 _saDistinct :: Maybe (NonEmpty (Column b))

Instances

Instances details

Backend b => Functor (SelectArgsG b) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods fmap :: (a -> b0) -> SelectArgsG b a -> SelectArgsG b b0 # (<$) :: a -> SelectArgsG b b0 -> SelectArgsG b a #
Backend b => Foldable (SelectArgsG b) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods fold :: Monoid m => SelectArgsG b m -> m # foldMap :: Monoid m => (a -> m) -> SelectArgsG b a -> m # foldMap' :: Monoid m => (a -> m) -> SelectArgsG b a -> m # foldr :: (a -> b0 -> b0) -> b0 -> SelectArgsG b a -> b0 # foldr' :: (a -> b0 -> b0) -> b0 -> SelectArgsG b a -> b0 # foldl :: (b0 -> a -> b0) -> b0 -> SelectArgsG b a -> b0 # foldl' :: (b0 -> a -> b0) -> b0 -> SelectArgsG b a -> b0 # foldr1 :: (a -> a -> a) -> SelectArgsG b a -> a # foldl1 :: (a -> a -> a) -> SelectArgsG b a -> a # toList :: SelectArgsG b a -> [a] # null :: SelectArgsG b a -> Bool # length :: SelectArgsG b a -> Int # elem :: Eq a => a -> SelectArgsG b a -> Bool # maximum :: Ord a => SelectArgsG b a -> a # minimum :: Ord a => SelectArgsG b a -> a # sum :: Num a => SelectArgsG b a -> a # product :: Num a => SelectArgsG b a -> a #
Backend b => Traversable (SelectArgsG b) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods traverse :: Applicative f => (a -> f b0) -> SelectArgsG b a -> f (SelectArgsG b b0) # sequenceA :: Applicative f => SelectArgsG b (f a) -> f (SelectArgsG b a) # mapM :: Monad m => (a -> m b0) -> SelectArgsG b a -> m (SelectArgsG b b0) # sequence :: Monad m => SelectArgsG b (m a) -> m (SelectArgsG b a) #
(Backend b, Eq (AnnBoolExp b v), Eq (AnnotatedOrderByItemG b v)) => Eq (SelectArgsG b v) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods (==) :: SelectArgsG b v -> SelectArgsG b v -> Bool # (/=) :: SelectArgsG b v -> SelectArgsG b v -> Bool #
(Backend b, Show (AnnBoolExp b v), Show (AnnotatedOrderByItemG b v)) => Show (SelectArgsG b v) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods showsPrec :: Int -> SelectArgsG b v -> ShowS # show :: SelectArgsG b v -> String # showList :: [SelectArgsG b v] -> ShowS #
Generic (SelectArgsG b v) Source #
Instance details Defined in Hasura.RQL.IR.Select Associated Types type Rep (SelectArgsG b v) :: Type -> Type # Methods from :: SelectArgsG b v -> Rep (SelectArgsG b v) x # to :: Rep (SelectArgsG b v) x -> SelectArgsG b v #
(Backend b, Hashable (AnnBoolExp b v), Hashable (AnnotatedOrderByItemG b v)) => Hashable (SelectArgsG b v) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods hashWithSalt :: Int -> SelectArgsG b v -> Int hash :: SelectArgsG b v -> Int
type Rep (SelectArgsG b v) Source #
Instance details Defined in Hasura.RQL.IR.Select type Rep (SelectArgsG b v) = D1 ('MetaData "SelectArgsG" "Hasura.RQL.IR.Select" "graphql-engine-1.0.0-inplace" 'False) (C1 ('MetaCons "SelectArgs" 'PrefixI 'True) ((S1 ('MetaSel ('Just "_saWhere") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (Maybe (AnnBoolExp b v))) :: S1 ('MetaSel ('Just "_saOrderBy") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (Maybe (NonEmpty (AnnotatedOrderByItemG b v))))) :: (S1 ('MetaSel ('Just "_saLimit") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (Maybe Int)) :: (S1 ('MetaSel ('Just "_saOffset") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (Maybe Int64)) :: S1 ('MetaSel ('Just "_saDistinct") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (Maybe (NonEmpty (Column b))))))))

type SelectArgs b = SelectArgsG b (SQLExpression b) Source #

noSelectArgs :: SelectArgsG backend v Source #

data ComputedFieldOrderByElement (b :: BackendType) v Source #

The order by element for a computed field based on its return type

Constructors

CFOBEScalar (ScalarType b)	Sort by the scalar computed field
CFOBETableAggregation
Fields (TableName b) (AnnBoolExp b v) Permission filter of the retuning table (AnnotatedAggregateOrderBy b) Sort by aggregation fields of table rows returned by computed field

Instances

Instances details

Backend b => Functor (ComputedFieldOrderByElement b) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods fmap :: (a -> b0) -> ComputedFieldOrderByElement b a -> ComputedFieldOrderByElement b b0 # (<$) :: a -> ComputedFieldOrderByElement b b0 -> ComputedFieldOrderByElement b a #
Backend b => Foldable (ComputedFieldOrderByElement b) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods fold :: Monoid m => ComputedFieldOrderByElement b m -> m # foldMap :: Monoid m => (a -> m) -> ComputedFieldOrderByElement b a -> m # foldMap' :: Monoid m => (a -> m) -> ComputedFieldOrderByElement b a -> m # foldr :: (a -> b0 -> b0) -> b0 -> ComputedFieldOrderByElement b a -> b0 # foldr' :: (a -> b0 -> b0) -> b0 -> ComputedFieldOrderByElement b a -> b0 # foldl :: (b0 -> a -> b0) -> b0 -> ComputedFieldOrderByElement b a -> b0 # foldl' :: (b0 -> a -> b0) -> b0 -> ComputedFieldOrderByElement b a -> b0 # foldr1 :: (a -> a -> a) -> ComputedFieldOrderByElement b a -> a # foldl1 :: (a -> a -> a) -> ComputedFieldOrderByElement b a -> a # toList :: ComputedFieldOrderByElement b a -> [a] # null :: ComputedFieldOrderByElement b a -> Bool # length :: ComputedFieldOrderByElement b a -> Int # elem :: Eq a => a -> ComputedFieldOrderByElement b a -> Bool # maximum :: Ord a => ComputedFieldOrderByElement b a -> a # minimum :: Ord a => ComputedFieldOrderByElement b a -> a # sum :: Num a => ComputedFieldOrderByElement b a -> a # product :: Num a => ComputedFieldOrderByElement b a -> a #
Backend b => Traversable (ComputedFieldOrderByElement b) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods traverse :: Applicative f => (a -> f b0) -> ComputedFieldOrderByElement b a -> f (ComputedFieldOrderByElement b b0) # sequenceA :: Applicative f => ComputedFieldOrderByElement b (f a) -> f (ComputedFieldOrderByElement b a) # mapM :: Monad m => (a -> m b0) -> ComputedFieldOrderByElement b a -> m (ComputedFieldOrderByElement b b0) # sequence :: Monad m => ComputedFieldOrderByElement b (m a) -> m (ComputedFieldOrderByElement b a) #
(Backend b, Eq (AnnBoolExp b v), Eq (AnnotatedAggregateOrderBy b)) => Eq (ComputedFieldOrderByElement b v) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods (==) :: ComputedFieldOrderByElement b v -> ComputedFieldOrderByElement b v -> Bool # (/=) :: ComputedFieldOrderByElement b v -> ComputedFieldOrderByElement b v -> Bool #
(Backend b, Show v, Show (AnnBoolExp b v), Show (AnnotatedAggregateOrderBy b)) => Show (ComputedFieldOrderByElement b v) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods showsPrec :: Int -> ComputedFieldOrderByElement b v -> ShowS # show :: ComputedFieldOrderByElement b v -> String # showList :: [ComputedFieldOrderByElement b v] -> ShowS #
Generic (ComputedFieldOrderByElement b v) Source #
Instance details Defined in Hasura.RQL.IR.Select Associated Types type Rep (ComputedFieldOrderByElement b v) :: Type -> Type # Methods from :: ComputedFieldOrderByElement b v -> Rep (ComputedFieldOrderByElement b v) x # to :: Rep (ComputedFieldOrderByElement b v) x -> ComputedFieldOrderByElement b v #
(Backend b, Hashable (AnnBoolExp b v), Hashable (AnnotatedAggregateOrderBy b)) => Hashable (ComputedFieldOrderByElement b v) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods hashWithSalt :: Int -> ComputedFieldOrderByElement b v -> Int hash :: ComputedFieldOrderByElement b v -> Int
type Rep (ComputedFieldOrderByElement b v) Source #
Instance details Defined in Hasura.RQL.IR.Select type Rep (ComputedFieldOrderByElement b v) = D1 ('MetaData "ComputedFieldOrderByElement" "Hasura.RQL.IR.Select" "graphql-engine-1.0.0-inplace" 'False) (C1 ('MetaCons "CFOBEScalar" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (ScalarType b))) :+: C1 ('MetaCons "CFOBETableAggregation" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (TableName b)) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (AnnBoolExp b v)) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (AnnotatedAggregateOrderBy b)))))

data ComputedFieldOrderBy (b :: BackendType) v Source #

Constructors

ComputedFieldOrderBy
Fields _cfobXField :: XComputedField b _cfobName :: ComputedFieldName _cfobFunction :: FunctionName b _cfobFunctionArgsExp :: FunctionArgsExp b v _cfobOrderByElement :: ComputedFieldOrderByElement b v

Instances

Instances details

Backend b => Functor (ComputedFieldOrderBy b) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods fmap :: (a -> b0) -> ComputedFieldOrderBy b a -> ComputedFieldOrderBy b b0 # (<$) :: a -> ComputedFieldOrderBy b b0 -> ComputedFieldOrderBy b a #
Backend b => Foldable (ComputedFieldOrderBy b) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods fold :: Monoid m => ComputedFieldOrderBy b m -> m # foldMap :: Monoid m => (a -> m) -> ComputedFieldOrderBy b a -> m # foldMap' :: Monoid m => (a -> m) -> ComputedFieldOrderBy b a -> m # foldr :: (a -> b0 -> b0) -> b0 -> ComputedFieldOrderBy b a -> b0 # foldr' :: (a -> b0 -> b0) -> b0 -> ComputedFieldOrderBy b a -> b0 # foldl :: (b0 -> a -> b0) -> b0 -> ComputedFieldOrderBy b a -> b0 # foldl' :: (b0 -> a -> b0) -> b0 -> ComputedFieldOrderBy b a -> b0 # foldr1 :: (a -> a -> a) -> ComputedFieldOrderBy b a -> a # foldl1 :: (a -> a -> a) -> ComputedFieldOrderBy b a -> a # toList :: ComputedFieldOrderBy b a -> [a] # null :: ComputedFieldOrderBy b a -> Bool # length :: ComputedFieldOrderBy b a -> Int # elem :: Eq a => a -> ComputedFieldOrderBy b a -> Bool # maximum :: Ord a => ComputedFieldOrderBy b a -> a # minimum :: Ord a => ComputedFieldOrderBy b a -> a # sum :: Num a => ComputedFieldOrderBy b a -> a # product :: Num a => ComputedFieldOrderBy b a -> a #
Backend b => Traversable (ComputedFieldOrderBy b) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods traverse :: Applicative f => (a -> f b0) -> ComputedFieldOrderBy b a -> f (ComputedFieldOrderBy b b0) # sequenceA :: Applicative f => ComputedFieldOrderBy b (f a) -> f (ComputedFieldOrderBy b a) # mapM :: Monad m => (a -> m b0) -> ComputedFieldOrderBy b a -> m (ComputedFieldOrderBy b b0) # sequence :: Monad m => ComputedFieldOrderBy b (m a) -> m (ComputedFieldOrderBy b a) #
(Backend b, Eq (ComputedFieldOrderByElement b v), Eq (FunctionArgsExp b v)) => Eq (ComputedFieldOrderBy b v) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods (==) :: ComputedFieldOrderBy b v -> ComputedFieldOrderBy b v -> Bool # (/=) :: ComputedFieldOrderBy b v -> ComputedFieldOrderBy b v -> Bool #
(Backend b, Show (ComputedFieldOrderByElement b v), Show (FunctionArgsExp b v)) => Show (ComputedFieldOrderBy b v) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods showsPrec :: Int -> ComputedFieldOrderBy b v -> ShowS # show :: ComputedFieldOrderBy b v -> String # showList :: [ComputedFieldOrderBy b v] -> ShowS #
Generic (ComputedFieldOrderBy b v) Source #
Instance details Defined in Hasura.RQL.IR.Select Associated Types type Rep (ComputedFieldOrderBy b v) :: Type -> Type # Methods from :: ComputedFieldOrderBy b v -> Rep (ComputedFieldOrderBy b v) x # to :: Rep (ComputedFieldOrderBy b v) x -> ComputedFieldOrderBy b v #
(Backend b, Hashable (ComputedFieldOrderByElement b v), Hashable (FunctionArgsExp b v)) => Hashable (ComputedFieldOrderBy b v) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods hashWithSalt :: Int -> ComputedFieldOrderBy b v -> Int hash :: ComputedFieldOrderBy b v -> Int
type Rep (ComputedFieldOrderBy b v) Source #
Instance details Defined in Hasura.RQL.IR.Select type Rep (ComputedFieldOrderBy b v) = D1 ('MetaData "ComputedFieldOrderBy" "Hasura.RQL.IR.Select" "graphql-engine-1.0.0-inplace" 'False) (C1 ('MetaCons "ComputedFieldOrderBy" 'PrefixI 'True) ((S1 ('MetaSel ('Just "_cfobXField") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (XComputedField b)) :: S1 ('MetaSel ('Just "_cfobName") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 ComputedFieldName)) :: (S1 ('MetaSel ('Just "_cfobFunction") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (FunctionName b)) :: (S1 ('MetaSel ('Just "_cfobFunctionArgsExp") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (FunctionArgsExp b v)) :: S1 ('MetaSel ('Just "_cfobOrderByElement") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (ComputedFieldOrderByElement b v))))))

data AnnotatedOrderByElement (b :: BackendType) v Source #

Constructors

AOCColumn (ColumnInfo b)
AOCObjectRelation
Fields (RelInfo b) (AnnBoolExp b v) Permission filter of the remote table to which the relationship is defined (AnnotatedOrderByElement b v)
AOCArrayAggregation
Fields (RelInfo b) (AnnBoolExp b v) Permission filter of the remote table to which the relationship is defined (AnnotatedAggregateOrderBy b)
AOCComputedField (ComputedFieldOrderBy b v)

Instances

Instances details

Backend b => Functor (AnnotatedOrderByElement b) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods fmap :: (a -> b0) -> AnnotatedOrderByElement b a -> AnnotatedOrderByElement b b0 # (<$) :: a -> AnnotatedOrderByElement b b0 -> AnnotatedOrderByElement b a #
Backend b => Foldable (AnnotatedOrderByElement b) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods fold :: Monoid m => AnnotatedOrderByElement b m -> m # foldMap :: Monoid m => (a -> m) -> AnnotatedOrderByElement b a -> m # foldMap' :: Monoid m => (a -> m) -> AnnotatedOrderByElement b a -> m # foldr :: (a -> b0 -> b0) -> b0 -> AnnotatedOrderByElement b a -> b0 # foldr' :: (a -> b0 -> b0) -> b0 -> AnnotatedOrderByElement b a -> b0 # foldl :: (b0 -> a -> b0) -> b0 -> AnnotatedOrderByElement b a -> b0 # foldl' :: (b0 -> a -> b0) -> b0 -> AnnotatedOrderByElement b a -> b0 # foldr1 :: (a -> a -> a) -> AnnotatedOrderByElement b a -> a # foldl1 :: (a -> a -> a) -> AnnotatedOrderByElement b a -> a # toList :: AnnotatedOrderByElement b a -> [a] # null :: AnnotatedOrderByElement b a -> Bool # length :: AnnotatedOrderByElement b a -> Int # elem :: Eq a => a -> AnnotatedOrderByElement b a -> Bool # maximum :: Ord a => AnnotatedOrderByElement b a -> a # minimum :: Ord a => AnnotatedOrderByElement b a -> a # sum :: Num a => AnnotatedOrderByElement b a -> a # product :: Num a => AnnotatedOrderByElement b a -> a #
Backend b => Traversable (AnnotatedOrderByElement b) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods traverse :: Applicative f => (a -> f b0) -> AnnotatedOrderByElement b a -> f (AnnotatedOrderByElement b b0) # sequenceA :: Applicative f => AnnotatedOrderByElement b (f a) -> f (AnnotatedOrderByElement b a) # mapM :: Monad m => (a -> m b0) -> AnnotatedOrderByElement b a -> m (AnnotatedOrderByElement b b0) # sequence :: Monad m => AnnotatedOrderByElement b (m a) -> m (AnnotatedOrderByElement b a) #
(Backend b, Eq (AnnBoolExp b v), Eq (AnnotatedAggregateOrderBy b), Eq (ComputedFieldOrderBy b v)) => Eq (AnnotatedOrderByElement b v) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods (==) :: AnnotatedOrderByElement b v -> AnnotatedOrderByElement b v -> Bool # (/=) :: AnnotatedOrderByElement b v -> AnnotatedOrderByElement b v -> Bool #
(Backend b, Show (AnnBoolExp b v), Show (AnnotatedAggregateOrderBy b), Show (ComputedFieldOrderBy b v)) => Show (AnnotatedOrderByElement b v) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods showsPrec :: Int -> AnnotatedOrderByElement b v -> ShowS # show :: AnnotatedOrderByElement b v -> String # showList :: [AnnotatedOrderByElement b v] -> ShowS #
Generic (AnnotatedOrderByElement b v) Source #
Instance details Defined in Hasura.RQL.IR.Select Associated Types type Rep (AnnotatedOrderByElement b v) :: Type -> Type # Methods from :: AnnotatedOrderByElement b v -> Rep (AnnotatedOrderByElement b v) x # to :: Rep (AnnotatedOrderByElement b v) x -> AnnotatedOrderByElement b v #
(Backend b, Hashable (AnnBoolExp b v), Hashable (AnnotatedAggregateOrderBy b), Hashable (ComputedFieldOrderBy b v)) => Hashable (AnnotatedOrderByElement b v) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods hashWithSalt :: Int -> AnnotatedOrderByElement b v -> Int hash :: AnnotatedOrderByElement b v -> Int
type Rep (AnnotatedOrderByElement b v) Source #
Instance details Defined in Hasura.RQL.IR.Select type Rep (AnnotatedOrderByElement b v) = D1 ('MetaData "AnnotatedOrderByElement" "Hasura.RQL.IR.Select" "graphql-engine-1.0.0-inplace" 'False) ((C1 ('MetaCons "AOCColumn" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (ColumnInfo b))) :+: C1 ('MetaCons "AOCObjectRelation" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (RelInfo b)) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (AnnBoolExp b v)) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (AnnotatedOrderByElement b v))))) :+: (C1 ('MetaCons "AOCArrayAggregation" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (RelInfo b)) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (AnnBoolExp b v)) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (AnnotatedAggregateOrderBy b)))) :+: C1 ('MetaCons "AOCComputedField" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (ComputedFieldOrderBy b v)))))

data AnnotatedAggregateOrderBy (b :: BackendType) Source #

Constructors

AAOCount
AAOOp Text (ColumnInfo b)

Instances

Instances details

Backend b => Eq (AnnotatedAggregateOrderBy b) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods (==) :: AnnotatedAggregateOrderBy b -> AnnotatedAggregateOrderBy b -> Bool # (/=) :: AnnotatedAggregateOrderBy b -> AnnotatedAggregateOrderBy b -> Bool #
Backend b => Show (AnnotatedAggregateOrderBy b) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods showsPrec :: Int -> AnnotatedAggregateOrderBy b -> ShowS # show :: AnnotatedAggregateOrderBy b -> String # showList :: [AnnotatedAggregateOrderBy b] -> ShowS #
Generic (AnnotatedAggregateOrderBy b) Source #
Instance details Defined in Hasura.RQL.IR.Select Associated Types type Rep (AnnotatedAggregateOrderBy b) :: Type -> Type # Methods from :: AnnotatedAggregateOrderBy b -> Rep (AnnotatedAggregateOrderBy b) x # to :: Rep (AnnotatedAggregateOrderBy b) x -> AnnotatedAggregateOrderBy b #
Backend b => Hashable (AnnotatedAggregateOrderBy b) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods hashWithSalt :: Int -> AnnotatedAggregateOrderBy b -> Int hash :: AnnotatedAggregateOrderBy b -> Int
type Rep (AnnotatedAggregateOrderBy b) Source #
Instance details Defined in Hasura.RQL.IR.Select type Rep (AnnotatedAggregateOrderBy b) = D1 ('MetaData "AnnotatedAggregateOrderBy" "Hasura.RQL.IR.Select" "graphql-engine-1.0.0-inplace" 'False) (C1 ('MetaCons "AAOCount" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "AAOOp" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Text) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (ColumnInfo b))))

type AnnotatedOrderByItemG b v = OrderByItemG b (AnnotatedOrderByElement b v) Source #

type AnnotatedOrderByItem b = AnnotatedOrderByItemG b (SQLExpression b) Source #

data StreamCursorItem (b :: BackendType) Source #

Cursor for streaming subscription

Constructors

StreamCursorItem
Fields _sciOrdering :: CursorOrdering Specifies how the cursor item should be ordered _sciColInfo :: ColumnInfo b Column info of the cursor item _sciInitialValue :: ColumnValue b Initial value of the cursor item from where the streaming should start

Instances

Instances details

Backend b => Eq (StreamCursorItem b) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods (==) :: StreamCursorItem b -> StreamCursorItem b -> Bool # (/=) :: StreamCursorItem b -> StreamCursorItem b -> Bool #
Backend b => Show (StreamCursorItem b) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods showsPrec :: Int -> StreamCursorItem b -> ShowS # show :: StreamCursorItem b -> String # showList :: [StreamCursorItem b] -> ShowS #
Generic (StreamCursorItem b) Source #
Instance details Defined in Hasura.RQL.IR.Select Associated Types type Rep (StreamCursorItem b) :: Type -> Type # Methods from :: StreamCursorItem b -> Rep (StreamCursorItem b) x # to :: Rep (StreamCursorItem b) x -> StreamCursorItem b #
type Rep (StreamCursorItem b) Source #
Instance details Defined in Hasura.RQL.IR.Select type Rep (StreamCursorItem b) = D1 ('MetaData "StreamCursorItem" "Hasura.RQL.IR.Select" "graphql-engine-1.0.0-inplace" 'False) (C1 ('MetaCons "StreamCursorItem" 'PrefixI 'True) (S1 ('MetaSel ('Just "_sciOrdering") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 CursorOrdering) :: (S1 ('MetaSel ('Just "_sciColInfo") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (ColumnInfo b)) :: S1 ('MetaSel ('Just "_sciInitialValue") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (ColumnValue b)))))

data RemoteRelationshipSelect b r Source #

captures a remote relationship's selection and the necessary context

Constructors

RemoteRelationshipSelect

Fields

_rrsLHSJoinFields :: HashMap FieldName (DBJoinField b)
The fields on the table that are required for the join condition of the remote relationship
_rrsRelationship :: r
The field that captures the relationship r ~ (RemoteRelationshipField UnpreparedValue) when the AST is emitted by the parser. r ~ Void when an execution tree is constructed so that a backend is absolved of dealing with remote relationships.

Instances

Instances details

Functor (RemoteRelationshipSelect b) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods fmap :: (a -> b0) -> RemoteRelationshipSelect b a -> RemoteRelationshipSelect b b0 # (<$) :: a -> RemoteRelationshipSelect b b0 -> RemoteRelationshipSelect b a #
Foldable (RemoteRelationshipSelect b) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods fold :: Monoid m => RemoteRelationshipSelect b m -> m # foldMap :: Monoid m => (a -> m) -> RemoteRelationshipSelect b a -> m # foldMap' :: Monoid m => (a -> m) -> RemoteRelationshipSelect b a -> m # foldr :: (a -> b0 -> b0) -> b0 -> RemoteRelationshipSelect b a -> b0 # foldr' :: (a -> b0 -> b0) -> b0 -> RemoteRelationshipSelect b a -> b0 # foldl :: (b0 -> a -> b0) -> b0 -> RemoteRelationshipSelect b a -> b0 # foldl' :: (b0 -> a -> b0) -> b0 -> RemoteRelationshipSelect b a -> b0 # foldr1 :: (a -> a -> a) -> RemoteRelationshipSelect b a -> a # foldl1 :: (a -> a -> a) -> RemoteRelationshipSelect b a -> a # toList :: RemoteRelationshipSelect b a -> [a] # null :: RemoteRelationshipSelect b a -> Bool # length :: RemoteRelationshipSelect b a -> Int # elem :: Eq a => a -> RemoteRelationshipSelect b a -> Bool # maximum :: Ord a => RemoteRelationshipSelect b a -> a # minimum :: Ord a => RemoteRelationshipSelect b a -> a # sum :: Num a => RemoteRelationshipSelect b a -> a # product :: Num a => RemoteRelationshipSelect b a -> a #
Traversable (RemoteRelationshipSelect b) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods traverse :: Applicative f => (a -> f b0) -> RemoteRelationshipSelect b a -> f (RemoteRelationshipSelect b b0) # sequenceA :: Applicative f => RemoteRelationshipSelect b (f a) -> f (RemoteRelationshipSelect b a) # mapM :: Monad m => (a -> m b0) -> RemoteRelationshipSelect b a -> m (RemoteRelationshipSelect b b0) # sequence :: Monad m => RemoteRelationshipSelect b (m a) -> m (RemoteRelationshipSelect b a) #
(Backend b, Eq r) => Eq (RemoteRelationshipSelect b r) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods (==) :: RemoteRelationshipSelect b r -> RemoteRelationshipSelect b r -> Bool # (/=) :: RemoteRelationshipSelect b r -> RemoteRelationshipSelect b r -> Bool #
(Backend b, Show r) => Show (RemoteRelationshipSelect b r) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods showsPrec :: Int -> RemoteRelationshipSelect b r -> ShowS # show :: RemoteRelationshipSelect b r -> String # showList :: [RemoteRelationshipSelect b r] -> ShowS #

data AnnFieldG (b :: BackendType) (r :: Type) v Source #

Constructors

AFColumn (AnnColumnField b v)
AFObjectRelation (ObjectRelationSelectG b r v)
AFArrayRelation (ArraySelectG b r v)
AFComputedField (XComputedField b) ComputedFieldName (ComputedFieldSelect b r v)
AFRemote (RemoteRelationshipSelect b r)	A remote relationship field
AFNodeId (XRelay b) SourceName (TableName b) (PrimaryKeyColumns b)
AFExpression Text

Instances

Instances details

Backend b => Bifoldable (AnnFieldG b) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods bifold :: Monoid m => AnnFieldG b m m -> m # bifoldMap :: Monoid m => (a -> m) -> (b0 -> m) -> AnnFieldG b a b0 -> m # bifoldr :: (a -> c -> c) -> (b0 -> c -> c) -> c -> AnnFieldG b a b0 -> c # bifoldl :: (c -> a -> c) -> (c -> b0 -> c) -> c -> AnnFieldG b a b0 -> c #
Backend b => Functor (AnnFieldG b r) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods fmap :: (a -> b0) -> AnnFieldG b r a -> AnnFieldG b r b0 # (<$) :: a -> AnnFieldG b r b0 -> AnnFieldG b r a #
Backend b => Foldable (AnnFieldG b r) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods fold :: Monoid m => AnnFieldG b r m -> m # foldMap :: Monoid m => (a -> m) -> AnnFieldG b r a -> m # foldMap' :: Monoid m => (a -> m) -> AnnFieldG b r a -> m # foldr :: (a -> b0 -> b0) -> b0 -> AnnFieldG b r a -> b0 # foldr' :: (a -> b0 -> b0) -> b0 -> AnnFieldG b r a -> b0 # foldl :: (b0 -> a -> b0) -> b0 -> AnnFieldG b r a -> b0 # foldl' :: (b0 -> a -> b0) -> b0 -> AnnFieldG b r a -> b0 # foldr1 :: (a -> a -> a) -> AnnFieldG b r a -> a # foldl1 :: (a -> a -> a) -> AnnFieldG b r a -> a # toList :: AnnFieldG b r a -> [a] # null :: AnnFieldG b r a -> Bool # length :: AnnFieldG b r a -> Int # elem :: Eq a => a -> AnnFieldG b r a -> Bool # maximum :: Ord a => AnnFieldG b r a -> a # minimum :: Ord a => AnnFieldG b r a -> a # sum :: Num a => AnnFieldG b r a -> a # product :: Num a => AnnFieldG b r a -> a #
Backend b => Traversable (AnnFieldG b r) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods traverse :: Applicative f => (a -> f b0) -> AnnFieldG b r a -> f (AnnFieldG b r b0) # sequenceA :: Applicative f => AnnFieldG b r (f a) -> f (AnnFieldG b r a) # mapM :: Monad m => (a -> m b0) -> AnnFieldG b r a -> m (AnnFieldG b r b0) # sequence :: Monad m => AnnFieldG b r (m a) -> m (AnnFieldG b r a) #
(Backend b, Eq (AnnColumnField b v), Eq (ArraySelectG b r v), Eq (ComputedFieldSelect b r v), Eq (ObjectRelationSelectG b r v), Eq (RemoteRelationshipSelect b r)) => Eq (AnnFieldG b r v) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods (==) :: AnnFieldG b r v -> AnnFieldG b r v -> Bool # (/=) :: AnnFieldG b r v -> AnnFieldG b r v -> Bool #
(Backend b, Show (AnnColumnField b v), Show (ArraySelectG b r v), Show (ComputedFieldSelect b r v), Show (ObjectRelationSelectG b r v), Show (RemoteRelationshipSelect b r)) => Show (AnnFieldG b r v) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods showsPrec :: Int -> AnnFieldG b r v -> ShowS # show :: AnnFieldG b r v -> String # showList :: [AnnFieldG b r v] -> ShowS #

type AnnField b = AnnFieldG b Void (SQLExpression b) Source #

type AnnFields b = AnnFieldsG b Void (SQLExpression b) Source #

mkAnnColumnField :: Column backend -> ColumnType backend -> Maybe (AnnColumnCaseBoolExp backend v) -> Maybe (ScalarSelectionArguments backend) -> AnnFieldG backend r v Source #

mkAnnColumnFieldAsText :: ColumnInfo backend -> AnnFieldG backend r v Source #

traverseSourceRelationshipSelection :: (Applicative f, Backend backend) => (vf backend -> f (vg backend)) -> SourceRelationshipSelection backend r vf -> f (SourceRelationshipSelection backend r vg) Source #

data TableAggregateFieldG (b :: BackendType) (r :: Type) v Source #

Constructors

TAFAgg (AggregateFields b)
TAFNodes (XNodesAgg b) (AnnFieldsG b r v)
TAFExp Text

Instances

Instances details

Backend b => Bifoldable (TableAggregateFieldG b) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods bifold :: Monoid m => TableAggregateFieldG b m m -> m # bifoldMap :: Monoid m => (a -> m) -> (b0 -> m) -> TableAggregateFieldG b a b0 -> m # bifoldr :: (a -> c -> c) -> (b0 -> c -> c) -> c -> TableAggregateFieldG b a b0 -> c # bifoldl :: (c -> a -> c) -> (c -> b0 -> c) -> c -> TableAggregateFieldG b a b0 -> c #
Backend b => Functor (TableAggregateFieldG b r) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods fmap :: (a -> b0) -> TableAggregateFieldG b r a -> TableAggregateFieldG b r b0 # (<$) :: a -> TableAggregateFieldG b r b0 -> TableAggregateFieldG b r a #
Backend b => Foldable (TableAggregateFieldG b r) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods fold :: Monoid m => TableAggregateFieldG b r m -> m # foldMap :: Monoid m => (a -> m) -> TableAggregateFieldG b r a -> m # foldMap' :: Monoid m => (a -> m) -> TableAggregateFieldG b r a -> m # foldr :: (a -> b0 -> b0) -> b0 -> TableAggregateFieldG b r a -> b0 # foldr' :: (a -> b0 -> b0) -> b0 -> TableAggregateFieldG b r a -> b0 # foldl :: (b0 -> a -> b0) -> b0 -> TableAggregateFieldG b r a -> b0 # foldl' :: (b0 -> a -> b0) -> b0 -> TableAggregateFieldG b r a -> b0 # foldr1 :: (a -> a -> a) -> TableAggregateFieldG b r a -> a # foldl1 :: (a -> a -> a) -> TableAggregateFieldG b r a -> a # toList :: TableAggregateFieldG b r a -> [a] # null :: TableAggregateFieldG b r a -> Bool # length :: TableAggregateFieldG b r a -> Int # elem :: Eq a => a -> TableAggregateFieldG b r a -> Bool # maximum :: Ord a => TableAggregateFieldG b r a -> a # minimum :: Ord a => TableAggregateFieldG b r a -> a # sum :: Num a => TableAggregateFieldG b r a -> a # product :: Num a => TableAggregateFieldG b r a -> a #
Backend b => Traversable (TableAggregateFieldG b r) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods traverse :: Applicative f => (a -> f b0) -> TableAggregateFieldG b r a -> f (TableAggregateFieldG b r b0) # sequenceA :: Applicative f => TableAggregateFieldG b r (f a) -> f (TableAggregateFieldG b r a) # mapM :: Monad m => (a -> m b0) -> TableAggregateFieldG b r a -> m (TableAggregateFieldG b r b0) # sequence :: Monad m => TableAggregateFieldG b r (m a) -> m (TableAggregateFieldG b r a) #
(Backend b, Eq (AggregateFields b), Eq (AnnFieldsG b r v)) => Eq (TableAggregateFieldG b r v) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods (==) :: TableAggregateFieldG b r v -> TableAggregateFieldG b r v -> Bool # (/=) :: TableAggregateFieldG b r v -> TableAggregateFieldG b r v -> Bool #
(Backend b, Show (AggregateFields b), Show (AnnFieldsG b r v)) => Show (TableAggregateFieldG b r v) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods showsPrec :: Int -> TableAggregateFieldG b r v -> ShowS # show :: TableAggregateFieldG b r v -> String # showList :: [TableAggregateFieldG b r v] -> ShowS #

data AggregateField (b :: BackendType) Source #

Constructors

AFCount (CountType b)
AFOp (AggregateOp b)
AFExp Text

Instances

Instances details

Backend b => Eq (AggregateField b) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods (==) :: AggregateField b -> AggregateField b -> Bool # (/=) :: AggregateField b -> AggregateField b -> Bool #
Backend b => Show (AggregateField b) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods showsPrec :: Int -> AggregateField b -> ShowS # show :: AggregateField b -> String # showList :: [AggregateField b] -> ShowS #

data AggregateOp (b :: BackendType) Source #

Constructors

AggregateOp
Fields _aoOp :: Text _aoFields :: ColumnFields b

Instances

Instances details

Backend b => Eq (AggregateOp b) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods (==) :: AggregateOp b -> AggregateOp b -> Bool # (/=) :: AggregateOp b -> AggregateOp b -> Bool #
Backend b => Show (AggregateOp b) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods showsPrec :: Int -> AggregateOp b -> ShowS # show :: AggregateOp b -> String # showList :: [AggregateOp b] -> ShowS #

data ColFld (b :: BackendType) Source #

Constructors

CFCol (Column b) (ColumnType b)
CFExp Text

Instances

Instances details

Backend b => Eq (ColFld b) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods (==) :: ColFld b -> ColFld b -> Bool # (/=) :: ColFld b -> ColFld b -> Bool #
Backend b => Show (ColFld b) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods showsPrec :: Int -> ColFld b -> ShowS # show :: ColFld b -> String # showList :: [ColFld b] -> ShowS #

type TableAggregateField b = TableAggregateFieldG b Void (SQLExpression b) Source #

type TableAggregateFields b = TableAggregateFieldsG b Void (SQLExpression b) Source #

type TableAggregateFieldsG b r v = Fields (TableAggregateFieldG b r v) Source #

type ColumnFields b = Fields (ColFld b) Source #

type AggregateFields b = Fields (AggregateField b) Source #

type AnnFieldsG b r v = Fields (AnnFieldG b r v) Source #

data ConnectionField (b :: BackendType) (r :: Type) v Source #

Constructors

ConnectionTypename Text
ConnectionPageInfo PageInfoFields
ConnectionEdges (EdgeFields b r v)

Instances

Instances details

Backend b => Bifoldable (ConnectionField b) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods bifold :: Monoid m => ConnectionField b m m -> m # bifoldMap :: Monoid m => (a -> m) -> (b0 -> m) -> ConnectionField b a b0 -> m # bifoldr :: (a -> c -> c) -> (b0 -> c -> c) -> c -> ConnectionField b a b0 -> c # bifoldl :: (c -> a -> c) -> (c -> b0 -> c) -> c -> ConnectionField b a b0 -> c #
Backend b => Functor (ConnectionField b r) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods fmap :: (a -> b0) -> ConnectionField b r a -> ConnectionField b r b0 # (<$) :: a -> ConnectionField b r b0 -> ConnectionField b r a #
Backend b => Foldable (ConnectionField b r) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods fold :: Monoid m => ConnectionField b r m -> m # foldMap :: Monoid m => (a -> m) -> ConnectionField b r a -> m # foldMap' :: Monoid m => (a -> m) -> ConnectionField b r a -> m # foldr :: (a -> b0 -> b0) -> b0 -> ConnectionField b r a -> b0 # foldr' :: (a -> b0 -> b0) -> b0 -> ConnectionField b r a -> b0 # foldl :: (b0 -> a -> b0) -> b0 -> ConnectionField b r a -> b0 # foldl' :: (b0 -> a -> b0) -> b0 -> ConnectionField b r a -> b0 # foldr1 :: (a -> a -> a) -> ConnectionField b r a -> a # foldl1 :: (a -> a -> a) -> ConnectionField b r a -> a # toList :: ConnectionField b r a -> [a] # null :: ConnectionField b r a -> Bool # length :: ConnectionField b r a -> Int # elem :: Eq a => a -> ConnectionField b r a -> Bool # maximum :: Ord a => ConnectionField b r a -> a # minimum :: Ord a => ConnectionField b r a -> a # sum :: Num a => ConnectionField b r a -> a # product :: Num a => ConnectionField b r a -> a #
Backend b => Traversable (ConnectionField b r) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods traverse :: Applicative f => (a -> f b0) -> ConnectionField b r a -> f (ConnectionField b r b0) # sequenceA :: Applicative f => ConnectionField b r (f a) -> f (ConnectionField b r a) # mapM :: Monad m => (a -> m b0) -> ConnectionField b r a -> m (ConnectionField b r b0) # sequence :: Monad m => ConnectionField b r (m a) -> m (ConnectionField b r a) #
Eq (EdgeFields b r v) => Eq (ConnectionField b r v) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods (==) :: ConnectionField b r v -> ConnectionField b r v -> Bool # (/=) :: ConnectionField b r v -> ConnectionField b r v -> Bool #
Show (EdgeFields b r v) => Show (ConnectionField b r v) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods showsPrec :: Int -> ConnectionField b r v -> ShowS # show :: ConnectionField b r v -> String # showList :: [ConnectionField b r v] -> ShowS #

data PageInfoField Source #

Constructors

PageInfoTypename Text
PageInfoHasNextPage
PageInfoHasPreviousPage
PageInfoStartCursor
PageInfoEndCursor

Instances

Instances details

Eq PageInfoField Source #
Instance details Defined in Hasura.RQL.IR.Select Methods (==) :: PageInfoField -> PageInfoField -> Bool # (/=) :: PageInfoField -> PageInfoField -> Bool #
Show PageInfoField Source #
Instance details Defined in Hasura.RQL.IR.Select Methods showsPrec :: Int -> PageInfoField -> ShowS # show :: PageInfoField -> String # showList :: [PageInfoField] -> ShowS #

data EdgeField (b :: BackendType) (r :: Type) v Source #

Constructors

EdgeTypename Text
EdgeCursor
EdgeNode (AnnFieldsG b r v)

Instances

Instances details

Backend b => Bifoldable (EdgeField b) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods bifold :: Monoid m => EdgeField b m m -> m # bifoldMap :: Monoid m => (a -> m) -> (b0 -> m) -> EdgeField b a b0 -> m # bifoldr :: (a -> c -> c) -> (b0 -> c -> c) -> c -> EdgeField b a b0 -> c # bifoldl :: (c -> a -> c) -> (c -> b0 -> c) -> c -> EdgeField b a b0 -> c #
Backend b => Functor (EdgeField b r) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods fmap :: (a -> b0) -> EdgeField b r a -> EdgeField b r b0 # (<$) :: a -> EdgeField b r b0 -> EdgeField b r a #
Backend b => Foldable (EdgeField b r) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods fold :: Monoid m => EdgeField b r m -> m # foldMap :: Monoid m => (a -> m) -> EdgeField b r a -> m # foldMap' :: Monoid m => (a -> m) -> EdgeField b r a -> m # foldr :: (a -> b0 -> b0) -> b0 -> EdgeField b r a -> b0 # foldr' :: (a -> b0 -> b0) -> b0 -> EdgeField b r a -> b0 # foldl :: (b0 -> a -> b0) -> b0 -> EdgeField b r a -> b0 # foldl' :: (b0 -> a -> b0) -> b0 -> EdgeField b r a -> b0 # foldr1 :: (a -> a -> a) -> EdgeField b r a -> a # foldl1 :: (a -> a -> a) -> EdgeField b r a -> a # toList :: EdgeField b r a -> [a] # null :: EdgeField b r a -> Bool # length :: EdgeField b r a -> Int # elem :: Eq a => a -> EdgeField b r a -> Bool # maximum :: Ord a => EdgeField b r a -> a # minimum :: Ord a => EdgeField b r a -> a # sum :: Num a => EdgeField b r a -> a # product :: Num a => EdgeField b r a -> a #
Backend b => Traversable (EdgeField b r) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods traverse :: Applicative f => (a -> f b0) -> EdgeField b r a -> f (EdgeField b r b0) # sequenceA :: Applicative f => EdgeField b r (f a) -> f (EdgeField b r a) # mapM :: Monad m => (a -> m b0) -> EdgeField b r a -> m (EdgeField b r b0) # sequence :: Monad m => EdgeField b r (m a) -> m (EdgeField b r a) #
Eq (AnnFieldsG b r v) => Eq (EdgeField b r v) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods (==) :: EdgeField b r v -> EdgeField b r v -> Bool # (/=) :: EdgeField b r v -> EdgeField b r v -> Bool #
Show (AnnFieldsG b r v) => Show (EdgeField b r v) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods showsPrec :: Int -> EdgeField b r v -> ShowS # show :: EdgeField b r v -> String # showList :: [EdgeField b r v] -> ShowS #

type ConnectionFields b r v = Fields (ConnectionField b r v) Source #

type PageInfoFields = Fields PageInfoField Source #

type EdgeFields b r v = Fields (EdgeField b r v) Source #

data AnnColumnField (b :: BackendType) v Source #

Constructors

AnnColumnField

Fields

_acfColumn :: Column b
_acfType :: ColumnType b
_acfAsText :: Bool
If this field is True, columns are explicitly casted to text when fetched, which avoids an issue that occurs because we don’t currently have proper support for array types. See https://github.com/hasura/graphql-engine/pull/3198 for more details.
_acfArguments :: Maybe (ScalarSelectionArguments b)
Arguments of this column's selection. See ScalarSelectionArguments
_acfCaseBoolExpression :: Maybe (AnnColumnCaseBoolExp b v)
This type is used to determine whether the column should be nullified. When the value is Nothing, the column value will be outputted as computed and when the value is `Just c`, the column will be outputted when c evaluates to true and null when c evaluates to false.

Instances

Instances details

Backend b => Functor (AnnColumnField b) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods fmap :: (a -> b0) -> AnnColumnField b a -> AnnColumnField b b0 # (<$) :: a -> AnnColumnField b b0 -> AnnColumnField b a #
Backend b => Foldable (AnnColumnField b) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods fold :: Monoid m => AnnColumnField b m -> m # foldMap :: Monoid m => (a -> m) -> AnnColumnField b a -> m # foldMap' :: Monoid m => (a -> m) -> AnnColumnField b a -> m # foldr :: (a -> b0 -> b0) -> b0 -> AnnColumnField b a -> b0 # foldr' :: (a -> b0 -> b0) -> b0 -> AnnColumnField b a -> b0 # foldl :: (b0 -> a -> b0) -> b0 -> AnnColumnField b a -> b0 # foldl' :: (b0 -> a -> b0) -> b0 -> AnnColumnField b a -> b0 # foldr1 :: (a -> a -> a) -> AnnColumnField b a -> a # foldl1 :: (a -> a -> a) -> AnnColumnField b a -> a # toList :: AnnColumnField b a -> [a] # null :: AnnColumnField b a -> Bool # length :: AnnColumnField b a -> Int # elem :: Eq a => a -> AnnColumnField b a -> Bool # maximum :: Ord a => AnnColumnField b a -> a # minimum :: Ord a => AnnColumnField b a -> a # sum :: Num a => AnnColumnField b a -> a # product :: Num a => AnnColumnField b a -> a #
Backend b => Traversable (AnnColumnField b) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods traverse :: Applicative f => (a -> f b0) -> AnnColumnField b a -> f (AnnColumnField b b0) # sequenceA :: Applicative f => AnnColumnField b (f a) -> f (AnnColumnField b a) # mapM :: Monad m => (a -> m b0) -> AnnColumnField b a -> m (AnnColumnField b b0) # sequence :: Monad m => AnnColumnField b (m a) -> m (AnnColumnField b a) #
(Backend b, Eq (AnnColumnCaseBoolExp b v), Eq (ScalarSelectionArguments b)) => Eq (AnnColumnField b v) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods (==) :: AnnColumnField b v -> AnnColumnField b v -> Bool # (/=) :: AnnColumnField b v -> AnnColumnField b v -> Bool #
(Backend b, Show (AnnColumnCaseBoolExp b v), Show (ScalarSelectionArguments b)) => Show (AnnColumnField b v) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods showsPrec :: Int -> AnnColumnField b v -> ShowS # show :: AnnColumnField b v -> String # showList :: [AnnColumnField b v] -> ShowS #

data ComputedFieldScalarSelect (b :: BackendType) v Source #

Constructors

ComputedFieldScalarSelect
Fields _cfssFunction :: FunctionName b _cfssArguments :: FunctionArgsExp b v _cfssType :: ScalarType b _cfssScalarArguments :: Maybe (ScalarSelectionArguments b)

Instances

Instances details

Backend b => Functor (ComputedFieldScalarSelect b) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods fmap :: (a -> b0) -> ComputedFieldScalarSelect b a -> ComputedFieldScalarSelect b b0 # (<$) :: a -> ComputedFieldScalarSelect b b0 -> ComputedFieldScalarSelect b a #
Backend b => Foldable (ComputedFieldScalarSelect b) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods fold :: Monoid m => ComputedFieldScalarSelect b m -> m # foldMap :: Monoid m => (a -> m) -> ComputedFieldScalarSelect b a -> m # foldMap' :: Monoid m => (a -> m) -> ComputedFieldScalarSelect b a -> m # foldr :: (a -> b0 -> b0) -> b0 -> ComputedFieldScalarSelect b a -> b0 # foldr' :: (a -> b0 -> b0) -> b0 -> ComputedFieldScalarSelect b a -> b0 # foldl :: (b0 -> a -> b0) -> b0 -> ComputedFieldScalarSelect b a -> b0 # foldl' :: (b0 -> a -> b0) -> b0 -> ComputedFieldScalarSelect b a -> b0 # foldr1 :: (a -> a -> a) -> ComputedFieldScalarSelect b a -> a # foldl1 :: (a -> a -> a) -> ComputedFieldScalarSelect b a -> a # toList :: ComputedFieldScalarSelect b a -> [a] # null :: ComputedFieldScalarSelect b a -> Bool # length :: ComputedFieldScalarSelect b a -> Int # elem :: Eq a => a -> ComputedFieldScalarSelect b a -> Bool # maximum :: Ord a => ComputedFieldScalarSelect b a -> a # minimum :: Ord a => ComputedFieldScalarSelect b a -> a # sum :: Num a => ComputedFieldScalarSelect b a -> a # product :: Num a => ComputedFieldScalarSelect b a -> a #
Backend b => Traversable (ComputedFieldScalarSelect b) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods traverse :: Applicative f => (a -> f b0) -> ComputedFieldScalarSelect b a -> f (ComputedFieldScalarSelect b b0) # sequenceA :: Applicative f => ComputedFieldScalarSelect b (f a) -> f (ComputedFieldScalarSelect b a) # mapM :: Monad m => (a -> m b0) -> ComputedFieldScalarSelect b a -> m (ComputedFieldScalarSelect b b0) # sequence :: Monad m => ComputedFieldScalarSelect b (m a) -> m (ComputedFieldScalarSelect b a) #
(Backend b, Eq v, Eq (FunctionArgumentExp b v)) => Eq (ComputedFieldScalarSelect b v) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods (==) :: ComputedFieldScalarSelect b v -> ComputedFieldScalarSelect b v -> Bool # (/=) :: ComputedFieldScalarSelect b v -> ComputedFieldScalarSelect b v -> Bool #
(Backend b, Show v, Show (FunctionArgumentExp b v)) => Show (ComputedFieldScalarSelect b v) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods showsPrec :: Int -> ComputedFieldScalarSelect b v -> ShowS # show :: ComputedFieldScalarSelect b v -> String # showList :: [ComputedFieldScalarSelect b v] -> ShowS #

data ComputedFieldSelect (b :: BackendType) (r :: Type) v Source #

Constructors

CFSScalar
Fields (ComputedFieldScalarSelect b v) Type containing info about the computed field (Maybe (AnnColumnCaseBoolExp b v)) This type is used to determine if whether the scalar computed field should be nullified. When the value is `Nothing`, the scalar computed value will be outputted as computed and when the value is `Just c`, the scalar computed field will be outputted when `c` evaluates to `true` and `null` when `c` evaluates to `false`
CFSTable JsonAggSelect (AnnSimpleSelectG b r v)

Instances

Instances details

Backend b => Bifoldable (ComputedFieldSelect b) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods bifold :: Monoid m => ComputedFieldSelect b m m -> m # bifoldMap :: Monoid m => (a -> m) -> (b0 -> m) -> ComputedFieldSelect b a b0 -> m # bifoldr :: (a -> c -> c) -> (b0 -> c -> c) -> c -> ComputedFieldSelect b a b0 -> c # bifoldl :: (c -> a -> c) -> (c -> b0 -> c) -> c -> ComputedFieldSelect b a b0 -> c #
Backend b => Functor (ComputedFieldSelect b r) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods fmap :: (a -> b0) -> ComputedFieldSelect b r a -> ComputedFieldSelect b r b0 # (<$) :: a -> ComputedFieldSelect b r b0 -> ComputedFieldSelect b r a #
Backend b => Foldable (ComputedFieldSelect b r) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods fold :: Monoid m => ComputedFieldSelect b r m -> m # foldMap :: Monoid m => (a -> m) -> ComputedFieldSelect b r a -> m # foldMap' :: Monoid m => (a -> m) -> ComputedFieldSelect b r a -> m # foldr :: (a -> b0 -> b0) -> b0 -> ComputedFieldSelect b r a -> b0 # foldr' :: (a -> b0 -> b0) -> b0 -> ComputedFieldSelect b r a -> b0 # foldl :: (b0 -> a -> b0) -> b0 -> ComputedFieldSelect b r a -> b0 # foldl' :: (b0 -> a -> b0) -> b0 -> ComputedFieldSelect b r a -> b0 # foldr1 :: (a -> a -> a) -> ComputedFieldSelect b r a -> a # foldl1 :: (a -> a -> a) -> ComputedFieldSelect b r a -> a # toList :: ComputedFieldSelect b r a -> [a] # null :: ComputedFieldSelect b r a -> Bool # length :: ComputedFieldSelect b r a -> Int # elem :: Eq a => a -> ComputedFieldSelect b r a -> Bool # maximum :: Ord a => ComputedFieldSelect b r a -> a # minimum :: Ord a => ComputedFieldSelect b r a -> a # sum :: Num a => ComputedFieldSelect b r a -> a # product :: Num a => ComputedFieldSelect b r a -> a #
Backend b => Traversable (ComputedFieldSelect b r) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods traverse :: Applicative f => (a -> f b0) -> ComputedFieldSelect b r a -> f (ComputedFieldSelect b r b0) # sequenceA :: Applicative f => ComputedFieldSelect b r (f a) -> f (ComputedFieldSelect b r a) # mapM :: Monad m => (a -> m b0) -> ComputedFieldSelect b r a -> m (ComputedFieldSelect b r b0) # sequence :: Monad m => ComputedFieldSelect b r (m a) -> m (ComputedFieldSelect b r a) #
(Backend b, Eq (AnnColumnCaseBoolExp b v), Eq (AnnSimpleSelectG b r v), Eq (ComputedFieldScalarSelect b v)) => Eq (ComputedFieldSelect b r v) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods (==) :: ComputedFieldSelect b r v -> ComputedFieldSelect b r v -> Bool # (/=) :: ComputedFieldSelect b r v -> ComputedFieldSelect b r v -> Bool #
(Backend b, Show (AnnColumnCaseBoolExp b v), Show (AnnSimpleSelectG b r v), Show (ComputedFieldScalarSelect b v)) => Show (ComputedFieldSelect b r v) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods showsPrec :: Int -> ComputedFieldSelect b r v -> ShowS # show :: ComputedFieldSelect b r v -> String # showList :: [ComputedFieldSelect b r v] -> ShowS #

data AnnRelationSelectG (b :: BackendType) a Source #

Constructors

AnnRelationSelectG
Fields _aarRelationshipName :: RelName _aarColumnMapping :: HashMap (Column b) (Column b) _aarAnnSelect :: a

Instances

Instances details

Functor (AnnRelationSelectG b) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods fmap :: (a -> b0) -> AnnRelationSelectG b a -> AnnRelationSelectG b b0 # (<$) :: a -> AnnRelationSelectG b b0 -> AnnRelationSelectG b a #
Foldable (AnnRelationSelectG b) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods fold :: Monoid m => AnnRelationSelectG b m -> m # foldMap :: Monoid m => (a -> m) -> AnnRelationSelectG b a -> m # foldMap' :: Monoid m => (a -> m) -> AnnRelationSelectG b a -> m # foldr :: (a -> b0 -> b0) -> b0 -> AnnRelationSelectG b a -> b0 # foldr' :: (a -> b0 -> b0) -> b0 -> AnnRelationSelectG b a -> b0 # foldl :: (b0 -> a -> b0) -> b0 -> AnnRelationSelectG b a -> b0 # foldl' :: (b0 -> a -> b0) -> b0 -> AnnRelationSelectG b a -> b0 # foldr1 :: (a -> a -> a) -> AnnRelationSelectG b a -> a # foldl1 :: (a -> a -> a) -> AnnRelationSelectG b a -> a # toList :: AnnRelationSelectG b a -> [a] # null :: AnnRelationSelectG b a -> Bool # length :: AnnRelationSelectG b a -> Int # elem :: Eq a => a -> AnnRelationSelectG b a -> Bool # maximum :: Ord a => AnnRelationSelectG b a -> a # minimum :: Ord a => AnnRelationSelectG b a -> a # sum :: Num a => AnnRelationSelectG b a -> a # product :: Num a => AnnRelationSelectG b a -> a #
Traversable (AnnRelationSelectG b) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods traverse :: Applicative f => (a -> f b0) -> AnnRelationSelectG b a -> f (AnnRelationSelectG b b0) # sequenceA :: Applicative f => AnnRelationSelectG b (f a) -> f (AnnRelationSelectG b a) # mapM :: Monad m => (a -> m b0) -> AnnRelationSelectG b a -> m (AnnRelationSelectG b b0) # sequence :: Monad m => AnnRelationSelectG b (m a) -> m (AnnRelationSelectG b a) #
(Backend b, Eq v) => Eq (AnnRelationSelectG b v) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods (==) :: AnnRelationSelectG b v -> AnnRelationSelectG b v -> Bool # (/=) :: AnnRelationSelectG b v -> AnnRelationSelectG b v -> Bool #
(Backend b, Show v) => Show (AnnRelationSelectG b v) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods showsPrec :: Int -> AnnRelationSelectG b v -> ShowS # show :: AnnRelationSelectG b v -> String # showList :: [AnnRelationSelectG b v] -> ShowS #

type ArrayRelationSelectG b r v = AnnRelationSelectG b (AnnSimpleSelectG b r v) Source #

type ArrayAggregateSelectG b r v = AnnRelationSelectG b (AnnAggregateSelectG b r v) Source #

type ArrayConnectionSelect b r v = AnnRelationSelectG b (ConnectionSelect b r v) Source #

type ArrayAggregateSelect b = ArrayAggregateSelectG b Void (SQLExpression b) Source #

data AnnObjectSelectG (b :: BackendType) (r :: Type) v Source #

Constructors

AnnObjectSelectG
Fields _aosFields :: AnnFieldsG b r v _aosTableFrom :: TableName b _aosTableFilter :: AnnBoolExp b v

Instances

Instances details

Backend b => Bifoldable (AnnObjectSelectG b) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods bifold :: Monoid m => AnnObjectSelectG b m m -> m # bifoldMap :: Monoid m => (a -> m) -> (b0 -> m) -> AnnObjectSelectG b a b0 -> m # bifoldr :: (a -> c -> c) -> (b0 -> c -> c) -> c -> AnnObjectSelectG b a b0 -> c # bifoldl :: (c -> a -> c) -> (c -> b0 -> c) -> c -> AnnObjectSelectG b a b0 -> c #
Backend b => Functor (AnnObjectSelectG b r) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods fmap :: (a -> b0) -> AnnObjectSelectG b r a -> AnnObjectSelectG b r b0 # (<$) :: a -> AnnObjectSelectG b r b0 -> AnnObjectSelectG b r a #
Backend b => Foldable (AnnObjectSelectG b r) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods fold :: Monoid m => AnnObjectSelectG b r m -> m # foldMap :: Monoid m => (a -> m) -> AnnObjectSelectG b r a -> m # foldMap' :: Monoid m => (a -> m) -> AnnObjectSelectG b r a -> m # foldr :: (a -> b0 -> b0) -> b0 -> AnnObjectSelectG b r a -> b0 # foldr' :: (a -> b0 -> b0) -> b0 -> AnnObjectSelectG b r a -> b0 # foldl :: (b0 -> a -> b0) -> b0 -> AnnObjectSelectG b r a -> b0 # foldl' :: (b0 -> a -> b0) -> b0 -> AnnObjectSelectG b r a -> b0 # foldr1 :: (a -> a -> a) -> AnnObjectSelectG b r a -> a # foldl1 :: (a -> a -> a) -> AnnObjectSelectG b r a -> a # toList :: AnnObjectSelectG b r a -> [a] # null :: AnnObjectSelectG b r a -> Bool # length :: AnnObjectSelectG b r a -> Int # elem :: Eq a => a -> AnnObjectSelectG b r a -> Bool # maximum :: Ord a => AnnObjectSelectG b r a -> a # minimum :: Ord a => AnnObjectSelectG b r a -> a # sum :: Num a => AnnObjectSelectG b r a -> a # product :: Num a => AnnObjectSelectG b r a -> a #
Backend b => Traversable (AnnObjectSelectG b r) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods traverse :: Applicative f => (a -> f b0) -> AnnObjectSelectG b r a -> f (AnnObjectSelectG b r b0) # sequenceA :: Applicative f => AnnObjectSelectG b r (f a) -> f (AnnObjectSelectG b r a) # mapM :: Monad m => (a -> m b0) -> AnnObjectSelectG b r a -> m (AnnObjectSelectG b r b0) # sequence :: Monad m => AnnObjectSelectG b r (m a) -> m (AnnObjectSelectG b r a) #
(Backend b, Eq (AnnBoolExp b v), Eq (AnnFieldsG b r v)) => Eq (AnnObjectSelectG b r v) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods (==) :: AnnObjectSelectG b r v -> AnnObjectSelectG b r v -> Bool # (/=) :: AnnObjectSelectG b r v -> AnnObjectSelectG b r v -> Bool #
(Backend b, Show (AnnBoolExp b v), Show (AnnFieldsG b r v)) => Show (AnnObjectSelectG b r v) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods showsPrec :: Int -> AnnObjectSelectG b r v -> ShowS # show :: AnnObjectSelectG b r v -> String # showList :: [AnnObjectSelectG b r v] -> ShowS #

type AnnObjectSelect b r = AnnObjectSelectG b r (SQLExpression b) Source #

type ObjectRelationSelectG b r v = AnnRelationSelectG b (AnnObjectSelectG b r v) Source #

type ObjectRelationSelect b = ObjectRelationSelectG b Void (SQLExpression b) Source #

data ArraySelectG (b :: BackendType) (r :: Type) v Source #

Constructors

ASSimple (ArrayRelationSelectG b r v)
ASAggregate (ArrayAggregateSelectG b r v)
ASConnection (ArrayConnectionSelect b r v)

Instances

Instances details

Backend b => Bifoldable (ArraySelectG b) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods bifold :: Monoid m => ArraySelectG b m m -> m # bifoldMap :: Monoid m => (a -> m) -> (b0 -> m) -> ArraySelectG b a b0 -> m # bifoldr :: (a -> c -> c) -> (b0 -> c -> c) -> c -> ArraySelectG b a b0 -> c # bifoldl :: (c -> a -> c) -> (c -> b0 -> c) -> c -> ArraySelectG b a b0 -> c #
Backend b => Functor (ArraySelectG b r) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods fmap :: (a -> b0) -> ArraySelectG b r a -> ArraySelectG b r b0 # (<$) :: a -> ArraySelectG b r b0 -> ArraySelectG b r a #
Backend b => Foldable (ArraySelectG b r) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods fold :: Monoid m => ArraySelectG b r m -> m # foldMap :: Monoid m => (a -> m) -> ArraySelectG b r a -> m # foldMap' :: Monoid m => (a -> m) -> ArraySelectG b r a -> m # foldr :: (a -> b0 -> b0) -> b0 -> ArraySelectG b r a -> b0 # foldr' :: (a -> b0 -> b0) -> b0 -> ArraySelectG b r a -> b0 # foldl :: (b0 -> a -> b0) -> b0 -> ArraySelectG b r a -> b0 # foldl' :: (b0 -> a -> b0) -> b0 -> ArraySelectG b r a -> b0 # foldr1 :: (a -> a -> a) -> ArraySelectG b r a -> a # foldl1 :: (a -> a -> a) -> ArraySelectG b r a -> a # toList :: ArraySelectG b r a -> [a] # null :: ArraySelectG b r a -> Bool # length :: ArraySelectG b r a -> Int # elem :: Eq a => a -> ArraySelectG b r a -> Bool # maximum :: Ord a => ArraySelectG b r a -> a # minimum :: Ord a => ArraySelectG b r a -> a # sum :: Num a => ArraySelectG b r a -> a # product :: Num a => ArraySelectG b r a -> a #
Backend b => Traversable (ArraySelectG b r) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods traverse :: Applicative f => (a -> f b0) -> ArraySelectG b r a -> f (ArraySelectG b r b0) # sequenceA :: Applicative f => ArraySelectG b r (f a) -> f (ArraySelectG b r a) # mapM :: Monad m => (a -> m b0) -> ArraySelectG b r a -> m (ArraySelectG b r b0) # sequence :: Monad m => ArraySelectG b r (m a) -> m (ArraySelectG b r a) #
(Eq (ArrayRelationSelectG b r v), Eq (ArrayAggregateSelectG b r v), Eq (ArrayConnectionSelect b r v)) => Eq (ArraySelectG b r v) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods (==) :: ArraySelectG b r v -> ArraySelectG b r v -> Bool # (/=) :: ArraySelectG b r v -> ArraySelectG b r v -> Bool #
(Show (ArrayRelationSelectG b r v), Show (ArrayAggregateSelectG b r v), Show (ArrayConnectionSelect b r v)) => Show (ArraySelectG b r v) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods showsPrec :: Int -> ArraySelectG b r v -> ShowS # show :: ArraySelectG b r v -> String # showList :: [ArraySelectG b r v] -> ShowS #

type ArraySelect b = ArraySelectG b Void (SQLExpression b) Source #

type ArraySelectFieldsG b r v = Fields (ArraySelectG b r v) Source #

data SourceRelationshipSelection (b :: BackendType) (r :: Type) (vf :: BackendType -> Type) Source #

Captures the selection set of a remote source relationship.

Constructors

SourceRelationshipObject (AnnObjectSelectG b r (vf b))
SourceRelationshipArray (AnnSimpleSelectG b r (vf b))
SourceRelationshipArrayAggregate (AnnAggregateSelectG b r (vf b))

Instances

Instances details

(Backend b, Eq (AnnAggregateSelectG b r (vf b)), Eq (AnnObjectSelectG b r (vf b)), Eq (AnnSimpleSelectG b r (vf b))) => Eq (SourceRelationshipSelection b r vf) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods (==) :: SourceRelationshipSelection b r vf -> SourceRelationshipSelection b r vf -> Bool # (/=) :: SourceRelationshipSelection b r vf -> SourceRelationshipSelection b r vf -> Bool #
(Backend b, Show (AnnAggregateSelectG b r (vf b)), Show (AnnObjectSelectG b r (vf b)), Show (AnnSimpleSelectG b r (vf b))) => Show (SourceRelationshipSelection b r vf) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods showsPrec :: Int -> SourceRelationshipSelection b r vf -> ShowS # show :: SourceRelationshipSelection b r vf -> String # showList :: [SourceRelationshipSelection b r vf] -> ShowS #

data RemoteSourceSelect (r :: Type) (vf :: BackendType -> Type) (tgt :: BackendType) Source #

A relationship to a remote source. vf (could use a better name) is analogous to v in other IR types such as AnnFieldG. vf's kind is (BackendType -> Type) instead of v's Type so that v of AnnFieldG can be specific to the backend that it captures (b of an AnnFieldG changes as we walk down the IR branches which capture relationships to other databases)

Constructors

RemoteSourceSelect

Fields

_rssName :: SourceName
_rssConfig :: SourceConfig tgt
_rssSelection :: SourceRelationshipSelection tgt r vf
_rssJoinMapping :: HashMap FieldName (ScalarType tgt, Column tgt)
Additional information about the source's join columns: (ScalarType tgt) so that the remote can interpret the join values coming from src (Column tgt) so that an appropriate join condition / IN clause can be built by the remote

Instances

Instances details

(Backend tgt, Eq (SourceRelationshipSelection tgt r vf)) => Eq (RemoteSourceSelect r vf tgt) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods (==) :: RemoteSourceSelect r vf tgt -> RemoteSourceSelect r vf tgt -> Bool # (/=) :: RemoteSourceSelect r vf tgt -> RemoteSourceSelect r vf tgt -> Bool #

data TablePermG (b :: BackendType) v Source #

Constructors

TablePerm
Fields _tpFilter :: AnnBoolExp b v _tpLimit :: Maybe Int

Instances

Instances details

Backend b => Functor (TablePermG b) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods fmap :: (a -> b0) -> TablePermG b a -> TablePermG b b0 # (<$) :: a -> TablePermG b b0 -> TablePermG b a #
Backend b => Foldable (TablePermG b) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods fold :: Monoid m => TablePermG b m -> m # foldMap :: Monoid m => (a -> m) -> TablePermG b a -> m # foldMap' :: Monoid m => (a -> m) -> TablePermG b a -> m # foldr :: (a -> b0 -> b0) -> b0 -> TablePermG b a -> b0 # foldr' :: (a -> b0 -> b0) -> b0 -> TablePermG b a -> b0 # foldl :: (b0 -> a -> b0) -> b0 -> TablePermG b a -> b0 # foldl' :: (b0 -> a -> b0) -> b0 -> TablePermG b a -> b0 # foldr1 :: (a -> a -> a) -> TablePermG b a -> a # foldl1 :: (a -> a -> a) -> TablePermG b a -> a # toList :: TablePermG b a -> [a] # null :: TablePermG b a -> Bool # length :: TablePermG b a -> Int # elem :: Eq a => a -> TablePermG b a -> Bool # maximum :: Ord a => TablePermG b a -> a # minimum :: Ord a => TablePermG b a -> a # sum :: Num a => TablePermG b a -> a # product :: Num a => TablePermG b a -> a #
Backend b => Traversable (TablePermG b) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods traverse :: Applicative f => (a -> f b0) -> TablePermG b a -> f (TablePermG b b0) # sequenceA :: Applicative f => TablePermG b (f a) -> f (TablePermG b a) # mapM :: Monad m => (a -> m b0) -> TablePermG b a -> m (TablePermG b b0) # sequence :: Monad m => TablePermG b (m a) -> m (TablePermG b a) #
(Backend b, Eq (AnnBoolExp b v)) => Eq (TablePermG b v) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods (==) :: TablePermG b v -> TablePermG b v -> Bool # (/=) :: TablePermG b v -> TablePermG b v -> Bool #
(Backend b, Show (AnnBoolExp b v)) => Show (TablePermG b v) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods showsPrec :: Int -> TablePermG b v -> ShowS # show :: TablePermG b v -> String # showList :: [TablePermG b v] -> ShowS #
Generic (TablePermG b v) Source #
Instance details Defined in Hasura.RQL.IR.Select Associated Types type Rep (TablePermG b v) :: Type -> Type # Methods from :: TablePermG b v -> Rep (TablePermG b v) x # to :: Rep (TablePermG b v) x -> TablePermG b v #
(Backend b, Hashable (AnnBoolExp b v)) => Hashable (TablePermG b v) Source #
Instance details Defined in Hasura.RQL.IR.Select Methods hashWithSalt :: Int -> TablePermG b v -> Int hash :: TablePermG b v -> Int
type Rep (TablePermG b v) Source #
Instance details Defined in Hasura.RQL.IR.Select type Rep (TablePermG b v) = D1 ('MetaData "TablePermG" "Hasura.RQL.IR.Select" "graphql-engine-1.0.0-inplace" 'False) (C1 ('MetaCons "TablePerm" 'PrefixI 'True) (S1 ('MetaSel ('Just "_tpFilter") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (AnnBoolExp b v)) :*: S1 ('MetaSel ('Just "_tpLimit") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (Maybe Int))))

type TablePerm b = TablePermG b (SQLExpression b) Source #

noTablePermissions :: TablePermG backend v Source #

insertFunctionArg :: FunctionArgName -> Int -> a -> FunctionArgsExpG a -> FunctionArgsExpG a Source #

If argument positional index is less than or equal to length of positional arguments then insert the value in positional arguments else insert the value with argument name in named arguments

data CountDistinct Source #

The "distinct" input field inside "count" aggregate field

count ( distinct: Boolean ): Int

Constructors

SelectCountDistinct
SelectCountNonDistinct

asnStrfyNum :: forall b f v. Lens' (AnnSelectG b f v) StringifyNumbers Source #

asnPerm :: forall b f v. Lens' (AnnSelectG b f v) (TablePermG b v) Source #

asnNamingConvention :: forall b f v. Lens' (AnnSelectG b f v) (Maybe NamingCase) Source #

asnFrom :: forall b f v. Lens' (AnnSelectG b f v) (SelectFromG b v) Source #

asnFields :: forall b f v f. Lens (AnnSelectG b f v) (AnnSelectG b f v) (Fields (f v)) (Fields (f v)) Source #

asnArgs :: forall b f v. Lens' (AnnSelectG b f v) (SelectArgsG b v) Source #

aosTableFrom :: forall b r v. Lens' (AnnObjectSelectG b r v) (TableName b) Source #

aosTableFilter :: forall b r v. Lens' (AnnObjectSelectG b r v) (AnnBoolExp b v) Source #

aosFields :: forall b r v r. Lens (AnnObjectSelectG b r v) (AnnObjectSelectG b r v) (AnnFieldsG b r v) (AnnFieldsG b r v) Source #

aarRelationshipName :: forall b a. Lens' (AnnRelationSelectG b a) RelName Source #

aarColumnMapping :: forall b a b. Lens (AnnRelationSelectG b a) (AnnRelationSelectG b a) (HashMap (Column b) (Column b)) (HashMap (Column b) (Column b)) Source #

aarAnnSelect :: forall b a a. Lens (AnnRelationSelectG b a) (AnnRelationSelectG b a) a a Source #

csXRelay :: forall b r v. Lens' (ConnectionSelect b r v) (XRelay b) Source #

csSplit :: forall b r v. Lens' (ConnectionSelect b r v) (Maybe (NonEmpty (ConnectionSplit b v))) Source #

csSlice :: forall b r v. Lens' (ConnectionSelect b r v) (Maybe ConnectionSlice) Source #

csSelect :: forall b r v r. Lens (ConnectionSelect b r v) (ConnectionSelect b r v) (AnnSelectG b (ConnectionField b r) v) (AnnSelectG b (ConnectionField b r) v) Source #

csPrimaryKeyColumns :: forall b r v. Lens' (ConnectionSelect b r v) (PrimaryKeyColumns b) Source #

saWhere :: forall b v. Lens' (SelectArgsG b v) (Maybe (AnnBoolExp b v)) Source #

saOrderBy :: forall b v. Lens' (SelectArgsG b v) (Maybe (NonEmpty (AnnotatedOrderByItemG b v))) Source #

saOffset :: forall b v. Lens' (SelectArgsG b v) (Maybe Int64) Source #

saLimit :: forall b v. Lens' (SelectArgsG b v) (Maybe Int) Source #

saDistinct :: forall b v. Lens' (SelectArgsG b v) (Maybe (NonEmpty (Column b))) Source #

_AFExpression :: forall b r v. Prism' (AnnFieldG b r v) Text Source #

_AFNodeId :: forall b r v. Prism' (AnnFieldG b r v) (XRelay b, SourceName, TableName b, PrimaryKeyColumns b) Source #

_AFRemote :: forall b r v. Prism' (AnnFieldG b r v) (RemoteRelationshipSelect b r) Source #

_AFComputedField :: forall b r v. Prism' (AnnFieldG b r v) (XComputedField b, ComputedFieldName, ComputedFieldSelect b r v) Source #

_AFArrayRelation :: forall b r v. Prism' (AnnFieldG b r v) (ArraySelectG b r v) Source #

_AFObjectRelation :: forall b r v. Prism' (AnnFieldG b r v) (ObjectRelationSelectG b r v) Source #

_AFColumn :: forall b r v. Prism' (AnnFieldG b r v) (AnnColumnField b v) Source #

_AOCComputedField :: forall b v. Prism' (AnnotatedOrderByElement b v) (ComputedFieldOrderBy b v) Source #

_AOCArrayAggregation :: forall b v. Prism' (AnnotatedOrderByElement b v) (RelInfo b, AnnBoolExp b v, AnnotatedAggregateOrderBy b) Source #

_AOCObjectRelation :: forall b v. Prism' (AnnotatedOrderByElement b v) (RelInfo b, AnnBoolExp b v, AnnotatedOrderByElement b v) Source #

_AOCColumn :: forall b v. Prism' (AnnotatedOrderByElement b v) (ColumnInfo b) Source #

_TAFExp :: forall b r v. Prism' (TableAggregateFieldG b r v) Text Source #

_TAFNodes :: forall b r v r v. Prism (TableAggregateFieldG b r v) (TableAggregateFieldG b r v) (XNodesAgg b, AnnFieldsG b r v) (XNodesAgg b, AnnFieldsG b r v) Source #

_TAFAgg :: forall b r v. Prism' (TableAggregateFieldG b r v) (AggregateFields b) Source #

_ConnectionEdges :: forall b r v b r v. Prism (ConnectionField b r v) (ConnectionField b r v) (EdgeFields b r v) (EdgeFields b r v) Source #

_ConnectionPageInfo :: forall b r v. Prism' (ConnectionField b r v) PageInfoFields Source #

_ConnectionTypename :: forall b r v. Prism' (ConnectionField b r v) Text Source #

_EdgeNode :: forall b r v b r v. Prism (EdgeField b r v) (EdgeField b r v) (AnnFieldsG b r v) (AnnFieldsG b r v) Source #

_EdgeCursor :: forall b r v. Prism' (EdgeField b r v) () Source #

_EdgeTypename :: forall b r v. Prism' (EdgeField b r v) Text Source #