graphql-engine-1.0.0: GraphQL API over Postgres
Safe HaskellSafe-Inferred
LanguageHaskell2010

Hasura.Backends.MSSQL.Types.Instances

Description

MSSQL Types Instances

Instances for types from Hasura.Backends.MSSQL.Types.Internal that're slow to compile.

Orphan instances

FromJSON ColumnName Source # 
Instance details

FromJSON ConstraintName Source # 
Instance details

FromJSON FieldName Source # 
Instance details

FromJSON FunctionName Source # 
Instance details

FromJSON NullsOrder Source # 
Instance details

FromJSON Order Source # 
Instance details

FromJSON ScalarType Source # 
Instance details

FromJSON SomeTableName Source # 
Instance details

FromJSON TableName Source # 
Instance details

FromJSON TempTableName Source # 
Instance details

FromJSON UnifiedArrayRelationship Source # 
Instance details

FromJSON UnifiedColumn Source # 
Instance details

FromJSON UnifiedObjectRelationship Source # 
Instance details

FromJSON UnifiedOn Source # 
Instance details

FromJSON UnifiedTableName Source # 
Instance details

FromJSON UnifiedUsing Source # 
Instance details

FromJSONKey ColumnName Source # 
Instance details

ToJSON ColumnName Source # 
Instance details

ToJSON ConstraintName Source # 
Instance details

ToJSON FieldName Source # 
Instance details

ToJSON FunctionName Source # 
Instance details

ToJSON NullsOrder Source # 
Instance details

ToJSON Order Source # 
Instance details

ToJSON ScalarType Source # 
Instance details

ToJSON TableName Source # 
Instance details

ToJSONKey ColumnName Source # 
Instance details

ToJSONKey FunctionName Source # 
Instance details

ToJSONKey ScalarType Source # 
Instance details

ToJSONKey TableName Source # 
Instance details

HasCodec ColumnName Source # 
Instance details

HasCodec FunctionName Source # 
Instance details

HasCodec ScalarType Source # 
Instance details

HasCodec SchemaName Source # 
Instance details

HasCodec TableName Source # 
Instance details

Data Aggregate Source # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Aggregate -> c Aggregate #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Aggregate #

toConstr :: Aggregate -> Constr #

dataTypeOf :: Aggregate -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Aggregate) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Aggregate) #

gmapT :: (forall b. Data b => b -> b) -> Aggregate -> Aggregate #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Aggregate -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Aggregate -> r #

gmapQ :: (forall d. Data d => d -> u) -> Aggregate -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Aggregate -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Aggregate -> m Aggregate #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Aggregate -> m Aggregate #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Aggregate -> m Aggregate #

Data CTEBody Source # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CTEBody -> c CTEBody #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c CTEBody #

toConstr :: CTEBody -> Constr #

dataTypeOf :: CTEBody -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c CTEBody) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CTEBody) #

gmapT :: (forall b. Data b => b -> b) -> CTEBody -> CTEBody #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CTEBody -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CTEBody -> r #

gmapQ :: (forall d. Data d => d -> u) -> CTEBody -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> CTEBody -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> CTEBody -> m CTEBody #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CTEBody -> m CTEBody #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CTEBody -> m CTEBody #

Data ColumnName Source # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ColumnName -> c ColumnName #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ColumnName #

toConstr :: ColumnName -> Constr #

dataTypeOf :: ColumnName -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ColumnName) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ColumnName) #

gmapT :: (forall b. Data b => b -> b) -> ColumnName -> ColumnName #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ColumnName -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ColumnName -> r #

gmapQ :: (forall d. Data d => d -> u) -> ColumnName -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ColumnName -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ColumnName -> m ColumnName #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ColumnName -> m ColumnName #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ColumnName -> m ColumnName #

Data ConstraintName Source # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ConstraintName -> c ConstraintName #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ConstraintName #

toConstr :: ConstraintName -> Constr #

dataTypeOf :: ConstraintName -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ConstraintName) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ConstraintName) #

gmapT :: (forall b. Data b => b -> b) -> ConstraintName -> ConstraintName #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ConstraintName -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ConstraintName -> r #

gmapQ :: (forall d. Data d => d -> u) -> ConstraintName -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ConstraintName -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ConstraintName -> m ConstraintName #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ConstraintName -> m ConstraintName #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ConstraintName -> m ConstraintName #

Data DataLength Source # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DataLength -> c DataLength #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DataLength #

toConstr :: DataLength -> Constr #

dataTypeOf :: DataLength -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c DataLength) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DataLength) #

gmapT :: (forall b. Data b => b -> b) -> DataLength -> DataLength #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DataLength -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DataLength -> r #

gmapQ :: (forall d. Data d => d -> u) -> DataLength -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> DataLength -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> DataLength -> m DataLength #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DataLength -> m DataLength #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DataLength -> m DataLength #

Data Delete Source # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Delete -> c Delete #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Delete #

toConstr :: Delete -> Constr #

dataTypeOf :: Delete -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Delete) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Delete) #

gmapT :: (forall b. Data b => b -> b) -> Delete -> Delete #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Delete -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Delete -> r #

gmapQ :: (forall d. Data d => d -> u) -> Delete -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Delete -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Delete -> m Delete #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Delete -> m Delete #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Delete -> m Delete #

Data DeleteOutput Source # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DeleteOutput -> c DeleteOutput #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DeleteOutput #

toConstr :: DeleteOutput -> Constr #

dataTypeOf :: DeleteOutput -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c DeleteOutput) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DeleteOutput) #

gmapT :: (forall b. Data b => b -> b) -> DeleteOutput -> DeleteOutput #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DeleteOutput -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DeleteOutput -> r #

gmapQ :: (forall d. Data d => d -> u) -> DeleteOutput -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> DeleteOutput -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> DeleteOutput -> m DeleteOutput #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DeleteOutput -> m DeleteOutput #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DeleteOutput -> m DeleteOutput #

Data Deleted Source # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Deleted -> c Deleted #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Deleted #

toConstr :: Deleted -> Constr #

dataTypeOf :: Deleted -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Deleted) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Deleted) #

gmapT :: (forall b. Data b => b -> b) -> Deleted -> Deleted #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Deleted -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Deleted -> r #

gmapQ :: (forall d. Data d => d -> u) -> Deleted -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Deleted -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Deleted -> m Deleted #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Deleted -> m Deleted #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Deleted -> m Deleted #

Data EntityAlias Source # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> EntityAlias -> c EntityAlias #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c EntityAlias #

toConstr :: EntityAlias -> Constr #

dataTypeOf :: EntityAlias -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c EntityAlias) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c EntityAlias) #

gmapT :: (forall b. Data b => b -> b) -> EntityAlias -> EntityAlias #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> EntityAlias -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> EntityAlias -> r #

gmapQ :: (forall d. Data d => d -> u) -> EntityAlias -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> EntityAlias -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> EntityAlias -> m EntityAlias #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> EntityAlias -> m EntityAlias #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> EntityAlias -> m EntityAlias #

Data Expression Source # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Expression -> c Expression #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Expression #

toConstr :: Expression -> Constr #

dataTypeOf :: Expression -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Expression) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Expression) #

gmapT :: (forall b. Data b => b -> b) -> Expression -> Expression #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Expression -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Expression -> r #

gmapQ :: (forall d. Data d => d -> u) -> Expression -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Expression -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Expression -> m Expression #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Expression -> m Expression #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Expression -> m Expression #

Data FieldName Source # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FieldName -> c FieldName #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c FieldName #

toConstr :: FieldName -> Constr #

dataTypeOf :: FieldName -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c FieldName) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FieldName) #

gmapT :: (forall b. Data b => b -> b) -> FieldName -> FieldName #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FieldName -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FieldName -> r #

gmapQ :: (forall d. Data d => d -> u) -> FieldName -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> FieldName -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> FieldName -> m FieldName #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FieldName -> m FieldName #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FieldName -> m FieldName #

Data For Source # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> For -> c For #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c For #

toConstr :: For -> Constr #

dataTypeOf :: For -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c For) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c For) #

gmapT :: (forall b. Data b => b -> b) -> For -> For #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> For -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> For -> r #

gmapQ :: (forall d. Data d => d -> u) -> For -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> For -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> For -> m For #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> For -> m For #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> For -> m For #

Data ForJson Source # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ForJson -> c ForJson #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ForJson #

toConstr :: ForJson -> Constr #

dataTypeOf :: ForJson -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ForJson) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ForJson) #

gmapT :: (forall b. Data b => b -> b) -> ForJson -> ForJson #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ForJson -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ForJson -> r #

gmapQ :: (forall d. Data d => d -> u) -> ForJson -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ForJson -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ForJson -> m ForJson #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ForJson -> m ForJson #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ForJson -> m ForJson #

Data From Source # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> From -> c From #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c From #

toConstr :: From -> Constr #

dataTypeOf :: From -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c From) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c From) #

gmapT :: (forall b. Data b => b -> b) -> From -> From #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> From -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> From -> r #

gmapQ :: (forall d. Data d => d -> u) -> From -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> From -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> From -> m From #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> From -> m From #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> From -> m From #

Data FunctionApplicationExpression Source # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FunctionApplicationExpression -> c FunctionApplicationExpression #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c FunctionApplicationExpression #

toConstr :: FunctionApplicationExpression -> Constr #

dataTypeOf :: FunctionApplicationExpression -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c FunctionApplicationExpression) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FunctionApplicationExpression) #

gmapT :: (forall b. Data b => b -> b) -> FunctionApplicationExpression -> FunctionApplicationExpression #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FunctionApplicationExpression -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FunctionApplicationExpression -> r #

gmapQ :: (forall d. Data d => d -> u) -> FunctionApplicationExpression -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> FunctionApplicationExpression -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> FunctionApplicationExpression -> m FunctionApplicationExpression #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FunctionApplicationExpression -> m FunctionApplicationExpression #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FunctionApplicationExpression -> m FunctionApplicationExpression #

Data FunctionName Source # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FunctionName -> c FunctionName #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c FunctionName #

toConstr :: FunctionName -> Constr #

dataTypeOf :: FunctionName -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c FunctionName) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FunctionName) #

gmapT :: (forall b. Data b => b -> b) -> FunctionName -> FunctionName #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FunctionName -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FunctionName -> r #

gmapQ :: (forall d. Data d => d -> u) -> FunctionName -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> FunctionName -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> FunctionName -> m FunctionName #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FunctionName -> m FunctionName #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FunctionName -> m FunctionName #

Data Insert Source # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Insert -> c Insert #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Insert #

toConstr :: Insert -> Constr #

dataTypeOf :: Insert -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Insert) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Insert) #

gmapT :: (forall b. Data b => b -> b) -> Insert -> Insert #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Insert -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Insert -> r #

gmapQ :: (forall d. Data d => d -> u) -> Insert -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Insert -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Insert -> m Insert #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Insert -> m Insert #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Insert -> m Insert #

Data InsertOutput Source # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> InsertOutput -> c InsertOutput #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c InsertOutput #

toConstr :: InsertOutput -> Constr #

dataTypeOf :: InsertOutput -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c InsertOutput) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c InsertOutput) #

gmapT :: (forall b. Data b => b -> b) -> InsertOutput -> InsertOutput #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> InsertOutput -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> InsertOutput -> r #

gmapQ :: (forall d. Data d => d -> u) -> InsertOutput -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> InsertOutput -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> InsertOutput -> m InsertOutput #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> InsertOutput -> m InsertOutput #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> InsertOutput -> m InsertOutput #

Data InsertValuesIntoTempTable Source # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> InsertValuesIntoTempTable -> c InsertValuesIntoTempTable #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c InsertValuesIntoTempTable #

toConstr :: InsertValuesIntoTempTable -> Constr #

dataTypeOf :: InsertValuesIntoTempTable -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c InsertValuesIntoTempTable) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c InsertValuesIntoTempTable) #

gmapT :: (forall b. Data b => b -> b) -> InsertValuesIntoTempTable -> InsertValuesIntoTempTable #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> InsertValuesIntoTempTable -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> InsertValuesIntoTempTable -> r #

gmapQ :: (forall d. Data d => d -> u) -> InsertValuesIntoTempTable -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> InsertValuesIntoTempTable -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> InsertValuesIntoTempTable -> m InsertValuesIntoTempTable #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> InsertValuesIntoTempTable -> m InsertValuesIntoTempTable #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> InsertValuesIntoTempTable -> m InsertValuesIntoTempTable #

Data Inserted Source # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Inserted -> c Inserted #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Inserted #

toConstr :: Inserted -> Constr #

dataTypeOf :: Inserted -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Inserted) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Inserted) #

gmapT :: (forall b. Data b => b -> b) -> Inserted -> Inserted #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Inserted -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Inserted -> r #

gmapQ :: (forall d. Data d => d -> u) -> Inserted -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Inserted -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Inserted -> m Inserted #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Inserted -> m Inserted #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Inserted -> m Inserted #

Data Join Source # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Join -> c Join #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Join #

toConstr :: Join -> Constr #

dataTypeOf :: Join -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Join) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Join) #

gmapT :: (forall b. Data b => b -> b) -> Join -> Join #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Join -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Join -> r #

gmapQ :: (forall d. Data d => d -> u) -> Join -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Join -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Join -> m Join #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Join -> m Join #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Join -> m Join #

Data JoinAlias Source # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> JoinAlias -> c JoinAlias #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c JoinAlias #

toConstr :: JoinAlias -> Constr #

dataTypeOf :: JoinAlias -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c JoinAlias) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c JoinAlias) #

gmapT :: (forall b. Data b => b -> b) -> JoinAlias -> JoinAlias #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> JoinAlias -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> JoinAlias -> r #

gmapQ :: (forall d. Data d => d -> u) -> JoinAlias -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> JoinAlias -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> JoinAlias -> m JoinAlias #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> JoinAlias -> m JoinAlias #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> JoinAlias -> m JoinAlias #

Data JoinSource Source # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> JoinSource -> c JoinSource #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c JoinSource #

toConstr :: JoinSource -> Constr #

dataTypeOf :: JoinSource -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c JoinSource) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c JoinSource) #

gmapT :: (forall b. Data b => b -> b) -> JoinSource -> JoinSource #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> JoinSource -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> JoinSource -> r #

gmapQ :: (forall d. Data d => d -> u) -> JoinSource -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> JoinSource -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> JoinSource -> m JoinSource #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> JoinSource -> m JoinSource #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> JoinSource -> m JoinSource #

Data JsonCardinality Source # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> JsonCardinality -> c JsonCardinality #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c JsonCardinality #

toConstr :: JsonCardinality -> Constr #

dataTypeOf :: JsonCardinality -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c JsonCardinality) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c JsonCardinality) #

gmapT :: (forall b. Data b => b -> b) -> JsonCardinality -> JsonCardinality #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> JsonCardinality -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> JsonCardinality -> r #

gmapQ :: (forall d. Data d => d -> u) -> JsonCardinality -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> JsonCardinality -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> JsonCardinality -> m JsonCardinality #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> JsonCardinality -> m JsonCardinality #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> JsonCardinality -> m JsonCardinality #

Data JsonFieldSpec Source # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> JsonFieldSpec -> c JsonFieldSpec #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c JsonFieldSpec #

toConstr :: JsonFieldSpec -> Constr #

dataTypeOf :: JsonFieldSpec -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c JsonFieldSpec) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c JsonFieldSpec) #

gmapT :: (forall b. Data b => b -> b) -> JsonFieldSpec -> JsonFieldSpec #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> JsonFieldSpec -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> JsonFieldSpec -> r #

gmapQ :: (forall d. Data d => d -> u) -> JsonFieldSpec -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> JsonFieldSpec -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> JsonFieldSpec -> m JsonFieldSpec #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> JsonFieldSpec -> m JsonFieldSpec #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> JsonFieldSpec -> m JsonFieldSpec #

Data JsonPath Source # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> JsonPath -> c JsonPath #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c JsonPath #

toConstr :: JsonPath -> Constr #

dataTypeOf :: JsonPath -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c JsonPath) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c JsonPath) #

gmapT :: (forall b. Data b => b -> b) -> JsonPath -> JsonPath #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> JsonPath -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> JsonPath -> r #

gmapQ :: (forall d. Data d => d -> u) -> JsonPath -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> JsonPath -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> JsonPath -> m JsonPath #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> JsonPath -> m JsonPath #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> JsonPath -> m JsonPath #

Data Merge Source # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Merge -> c Merge #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Merge #

toConstr :: Merge -> Constr #

dataTypeOf :: Merge -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Merge) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Merge) #

gmapT :: (forall b. Data b => b -> b) -> Merge -> Merge #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Merge -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Merge -> r #

gmapQ :: (forall d. Data d => d -> u) -> Merge -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Merge -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Merge -> m Merge #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Merge -> m Merge #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Merge -> m Merge #

Data MergeOn Source # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> MergeOn -> c MergeOn #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c MergeOn #

toConstr :: MergeOn -> Constr #

dataTypeOf :: MergeOn -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c MergeOn) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MergeOn) #

gmapT :: (forall b. Data b => b -> b) -> MergeOn -> MergeOn #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> MergeOn -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> MergeOn -> r #

gmapQ :: (forall d. Data d => d -> u) -> MergeOn -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> MergeOn -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> MergeOn -> m MergeOn #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> MergeOn -> m MergeOn #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> MergeOn -> m MergeOn #

Data MergeUsing Source # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> MergeUsing -> c MergeUsing #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c MergeUsing #

toConstr :: MergeUsing -> Constr #

dataTypeOf :: MergeUsing -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c MergeUsing) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MergeUsing) #

gmapT :: (forall b. Data b => b -> b) -> MergeUsing -> MergeUsing #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> MergeUsing -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> MergeUsing -> r #

gmapQ :: (forall d. Data d => d -> u) -> MergeUsing -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> MergeUsing -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> MergeUsing -> m MergeUsing #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> MergeUsing -> m MergeUsing #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> MergeUsing -> m MergeUsing #

Data MergeWhenMatched Source # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> MergeWhenMatched -> c MergeWhenMatched #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c MergeWhenMatched #

toConstr :: MergeWhenMatched -> Constr #

dataTypeOf :: MergeWhenMatched -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c MergeWhenMatched) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MergeWhenMatched) #

gmapT :: (forall b. Data b => b -> b) -> MergeWhenMatched -> MergeWhenMatched #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> MergeWhenMatched -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> MergeWhenMatched -> r #

gmapQ :: (forall d. Data d => d -> u) -> MergeWhenMatched -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> MergeWhenMatched -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> MergeWhenMatched -> m MergeWhenMatched #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> MergeWhenMatched -> m MergeWhenMatched #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> MergeWhenMatched -> m MergeWhenMatched #

Data MergeWhenNotMatched Source # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> MergeWhenNotMatched -> c MergeWhenNotMatched #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c MergeWhenNotMatched #

toConstr :: MergeWhenNotMatched -> Constr #

dataTypeOf :: MergeWhenNotMatched -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c MergeWhenNotMatched) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MergeWhenNotMatched) #

gmapT :: (forall b. Data b => b -> b) -> MergeWhenNotMatched -> MergeWhenNotMatched #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> MergeWhenNotMatched -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> MergeWhenNotMatched -> r #

gmapQ :: (forall d. Data d => d -> u) -> MergeWhenNotMatched -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> MergeWhenNotMatched -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> MergeWhenNotMatched -> m MergeWhenNotMatched #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> MergeWhenNotMatched -> m MergeWhenNotMatched #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> MergeWhenNotMatched -> m MergeWhenNotMatched #

Data MethodApplicationExpression Source # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> MethodApplicationExpression -> c MethodApplicationExpression #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c MethodApplicationExpression #

toConstr :: MethodApplicationExpression -> Constr #

dataTypeOf :: MethodApplicationExpression -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c MethodApplicationExpression) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MethodApplicationExpression) #

gmapT :: (forall b. Data b => b -> b) -> MethodApplicationExpression -> MethodApplicationExpression #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> MethodApplicationExpression -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> MethodApplicationExpression -> r #

gmapQ :: (forall d. Data d => d -> u) -> MethodApplicationExpression -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> MethodApplicationExpression -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> MethodApplicationExpression -> m MethodApplicationExpression #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> MethodApplicationExpression -> m MethodApplicationExpression #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> MethodApplicationExpression -> m MethodApplicationExpression #

Data NullsOrder Source # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> NullsOrder -> c NullsOrder #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c NullsOrder #

toConstr :: NullsOrder -> Constr #

dataTypeOf :: NullsOrder -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c NullsOrder) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NullsOrder) #

gmapT :: (forall b. Data b => b -> b) -> NullsOrder -> NullsOrder #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NullsOrder -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NullsOrder -> r #

gmapQ :: (forall d. Data d => d -> u) -> NullsOrder -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> NullsOrder -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> NullsOrder -> m NullsOrder #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NullsOrder -> m NullsOrder #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NullsOrder -> m NullsOrder #

Data Op Source # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Op -> c Op #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Op #

toConstr :: Op -> Constr #

dataTypeOf :: Op -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Op) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Op) #

gmapT :: (forall b. Data b => b -> b) -> Op -> Op #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Op -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Op -> r #

gmapQ :: (forall d. Data d => d -> u) -> Op -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Op -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Op -> m Op #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Op -> m Op #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Op -> m Op #

Data OpenJson Source # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> OpenJson -> c OpenJson #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c OpenJson #

toConstr :: OpenJson -> Constr #

dataTypeOf :: OpenJson -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c OpenJson) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OpenJson) #

gmapT :: (forall b. Data b => b -> b) -> OpenJson -> OpenJson #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> OpenJson -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> OpenJson -> r #

gmapQ :: (forall d. Data d => d -> u) -> OpenJson -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> OpenJson -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> OpenJson -> m OpenJson #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> OpenJson -> m OpenJson #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> OpenJson -> m OpenJson #

Data Order Source # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Order -> c Order #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Order #

toConstr :: Order -> Constr #

dataTypeOf :: Order -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Order) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Order) #

gmapT :: (forall b. Data b => b -> b) -> Order -> Order #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Order -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Order -> r #

gmapQ :: (forall d. Data d => d -> u) -> Order -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Order -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Order -> m Order #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Order -> m Order #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Order -> m Order #

Data OrderBy Source # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> OrderBy -> c OrderBy #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c OrderBy #

toConstr :: OrderBy -> Constr #

dataTypeOf :: OrderBy -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c OrderBy) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OrderBy) #

gmapT :: (forall b. Data b => b -> b) -> OrderBy -> OrderBy #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> OrderBy -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> OrderBy -> r #

gmapQ :: (forall d. Data d => d -> u) -> OrderBy -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> OrderBy -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> OrderBy -> m OrderBy #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> OrderBy -> m OrderBy #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> OrderBy -> m OrderBy #

Data OutputColumn Source # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> OutputColumn -> c OutputColumn #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c OutputColumn #

toConstr :: OutputColumn -> Constr #

dataTypeOf :: OutputColumn -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c OutputColumn) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OutputColumn) #

gmapT :: (forall b. Data b => b -> b) -> OutputColumn -> OutputColumn #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> OutputColumn -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> OutputColumn -> r #

gmapQ :: (forall d. Data d => d -> u) -> OutputColumn -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> OutputColumn -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> OutputColumn -> m OutputColumn #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> OutputColumn -> m OutputColumn #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> OutputColumn -> m OutputColumn #

Data Projection Source # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Projection -> c Projection #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Projection #

toConstr :: Projection -> Constr #

dataTypeOf :: Projection -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Projection) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Projection) #

gmapT :: (forall b. Data b => b -> b) -> Projection -> Projection #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Projection -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Projection -> r #

gmapQ :: (forall d. Data d => d -> u) -> Projection -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Projection -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Projection -> m Projection #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Projection -> m Projection #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Projection -> m Projection #

Data Reselect Source # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Reselect -> c Reselect #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Reselect #

toConstr :: Reselect -> Constr #

dataTypeOf :: Reselect -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Reselect) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Reselect) #

gmapT :: (forall b. Data b => b -> b) -> Reselect -> Reselect #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Reselect -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Reselect -> r #

gmapQ :: (forall d. Data d => d -> u) -> Reselect -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Reselect -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Reselect -> m Reselect #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Reselect -> m Reselect #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Reselect -> m Reselect #

Data Root Source # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Root -> c Root #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Root #

toConstr :: Root -> Constr #

dataTypeOf :: Root -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Root) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Root) #

gmapT :: (forall b. Data b => b -> b) -> Root -> Root #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Root -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Root -> r #

gmapQ :: (forall d. Data d => d -> u) -> Root -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Root -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Root -> m Root #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Root -> m Root #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Root -> m Root #

Data SITTConstraints Source # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SITTConstraints -> c SITTConstraints #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SITTConstraints #

toConstr :: SITTConstraints -> Constr #

dataTypeOf :: SITTConstraints -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SITTConstraints) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SITTConstraints) #

gmapT :: (forall b. Data b => b -> b) -> SITTConstraints -> SITTConstraints #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SITTConstraints -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SITTConstraints -> r #

gmapQ :: (forall d. Data d => d -> u) -> SITTConstraints -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> SITTConstraints -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> SITTConstraints -> m SITTConstraints #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SITTConstraints -> m SITTConstraints #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SITTConstraints -> m SITTConstraints #

Data ScalarType Source # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ScalarType -> c ScalarType #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ScalarType #

toConstr :: ScalarType -> Constr #

dataTypeOf :: ScalarType -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ScalarType) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ScalarType) #

gmapT :: (forall b. Data b => b -> b) -> ScalarType -> ScalarType #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ScalarType -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ScalarType -> r #

gmapQ :: (forall d. Data d => d -> u) -> ScalarType -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ScalarType -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ScalarType -> m ScalarType #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ScalarType -> m ScalarType #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ScalarType -> m ScalarType #

Data Select Source # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Select -> c Select #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Select #

toConstr :: Select -> Constr #

dataTypeOf :: Select -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Select) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Select) #

gmapT :: (forall b. Data b => b -> b) -> Select -> Select #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Select -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Select -> r #

gmapQ :: (forall d. Data d => d -> u) -> Select -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Select -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Select -> m Select #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Select -> m Select #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Select -> m Select #

Data SelectIntoTempTable Source # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SelectIntoTempTable -> c SelectIntoTempTable #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SelectIntoTempTable #

toConstr :: SelectIntoTempTable -> Constr #

dataTypeOf :: SelectIntoTempTable -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SelectIntoTempTable) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SelectIntoTempTable) #

gmapT :: (forall b. Data b => b -> b) -> SelectIntoTempTable -> SelectIntoTempTable #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SelectIntoTempTable -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SelectIntoTempTable -> r #

gmapQ :: (forall d. Data d => d -> u) -> SelectIntoTempTable -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> SelectIntoTempTable -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> SelectIntoTempTable -> m SelectIntoTempTable #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SelectIntoTempTable -> m SelectIntoTempTable #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SelectIntoTempTable -> m SelectIntoTempTable #

Data SomeTableName Source # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SomeTableName -> c SomeTableName #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SomeTableName #

toConstr :: SomeTableName -> Constr #

dataTypeOf :: SomeTableName -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SomeTableName) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SomeTableName) #

gmapT :: (forall b. Data b => b -> b) -> SomeTableName -> SomeTableName #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SomeTableName -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SomeTableName -> r #

gmapQ :: (forall d. Data d => d -> u) -> SomeTableName -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> SomeTableName -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> SomeTableName -> m SomeTableName #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SomeTableName -> m SomeTableName #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SomeTableName -> m SomeTableName #

Data SpatialOp Source # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SpatialOp -> c SpatialOp #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SpatialOp #

toConstr :: SpatialOp -> Constr #

dataTypeOf :: SpatialOp -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SpatialOp) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SpatialOp) #

gmapT :: (forall b. Data b => b -> b) -> SpatialOp -> SpatialOp #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SpatialOp -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SpatialOp -> r #

gmapQ :: (forall d. Data d => d -> u) -> SpatialOp -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> SpatialOp -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> SpatialOp -> m SpatialOp #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SpatialOp -> m SpatialOp #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SpatialOp -> m SpatialOp #

Data TableName Source # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TableName -> c TableName #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TableName #

toConstr :: TableName -> Constr #

dataTypeOf :: TableName -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c TableName) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TableName) #

gmapT :: (forall b. Data b => b -> b) -> TableName -> TableName #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TableName -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TableName -> r #

gmapQ :: (forall d. Data d => d -> u) -> TableName -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> TableName -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> TableName -> m TableName #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TableName -> m TableName #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TableName -> m TableName #

Data TempTable Source # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TempTable -> c TempTable #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TempTable #

toConstr :: TempTable -> Constr #

dataTypeOf :: TempTable -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c TempTable) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TempTable) #

gmapT :: (forall b. Data b => b -> b) -> TempTable -> TempTable #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TempTable -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TempTable -> r #

gmapQ :: (forall d. Data d => d -> u) -> TempTable -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> TempTable -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> TempTable -> m TempTable #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TempTable -> m TempTable #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TempTable -> m TempTable #

Data TempTableName Source # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TempTableName -> c TempTableName #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TempTableName #

toConstr :: TempTableName -> Constr #

dataTypeOf :: TempTableName -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c TempTableName) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TempTableName) #

gmapT :: (forall b. Data b => b -> b) -> TempTableName -> TempTableName #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TempTableName -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TempTableName -> r #

gmapQ :: (forall d. Data d => d -> u) -> TempTableName -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> TempTableName -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> TempTableName -> m TempTableName #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TempTableName -> m TempTableName #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TempTableName -> m TempTableName #

Data Top Source # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Top -> c Top #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Top #

toConstr :: Top -> Constr #

dataTypeOf :: Top -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Top) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Top) #

gmapT :: (forall b. Data b => b -> b) -> Top -> Top #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Top -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Top -> r #

gmapQ :: (forall d. Data d => d -> u) -> Top -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Top -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Top -> m Top #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Top -> m Top #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Top -> m Top #

Data UnifiedArrayRelationship Source # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UnifiedArrayRelationship -> c UnifiedArrayRelationship #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c UnifiedArrayRelationship #

toConstr :: UnifiedArrayRelationship -> Constr #

dataTypeOf :: UnifiedArrayRelationship -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c UnifiedArrayRelationship) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c UnifiedArrayRelationship) #

gmapT :: (forall b. Data b => b -> b) -> UnifiedArrayRelationship -> UnifiedArrayRelationship #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UnifiedArrayRelationship -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UnifiedArrayRelationship -> r #

gmapQ :: (forall d. Data d => d -> u) -> UnifiedArrayRelationship -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UnifiedArrayRelationship -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UnifiedArrayRelationship -> m UnifiedArrayRelationship #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UnifiedArrayRelationship -> m UnifiedArrayRelationship #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UnifiedArrayRelationship -> m UnifiedArrayRelationship #

Data UnifiedColumn Source # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UnifiedColumn -> c UnifiedColumn #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c UnifiedColumn #

toConstr :: UnifiedColumn -> Constr #

dataTypeOf :: UnifiedColumn -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c UnifiedColumn) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c UnifiedColumn) #

gmapT :: (forall b. Data b => b -> b) -> UnifiedColumn -> UnifiedColumn #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UnifiedColumn -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UnifiedColumn -> r #

gmapQ :: (forall d. Data d => d -> u) -> UnifiedColumn -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UnifiedColumn -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UnifiedColumn -> m UnifiedColumn #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UnifiedColumn -> m UnifiedColumn #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UnifiedColumn -> m UnifiedColumn #

Data UnifiedObjectRelationship Source # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UnifiedObjectRelationship -> c UnifiedObjectRelationship #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c UnifiedObjectRelationship #

toConstr :: UnifiedObjectRelationship -> Constr #

dataTypeOf :: UnifiedObjectRelationship -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c UnifiedObjectRelationship) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c UnifiedObjectRelationship) #

gmapT :: (forall b. Data b => b -> b) -> UnifiedObjectRelationship -> UnifiedObjectRelationship #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UnifiedObjectRelationship -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UnifiedObjectRelationship -> r #

gmapQ :: (forall d. Data d => d -> u) -> UnifiedObjectRelationship -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UnifiedObjectRelationship -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UnifiedObjectRelationship -> m UnifiedObjectRelationship #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UnifiedObjectRelationship -> m UnifiedObjectRelationship #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UnifiedObjectRelationship -> m UnifiedObjectRelationship #

Data UnifiedOn Source # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UnifiedOn -> c UnifiedOn #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c UnifiedOn #

toConstr :: UnifiedOn -> Constr #

dataTypeOf :: UnifiedOn -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c UnifiedOn) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c UnifiedOn) #

gmapT :: (forall b. Data b => b -> b) -> UnifiedOn -> UnifiedOn #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UnifiedOn -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UnifiedOn -> r #

gmapQ :: (forall d. Data d => d -> u) -> UnifiedOn -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UnifiedOn -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UnifiedOn -> m UnifiedOn #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UnifiedOn -> m UnifiedOn #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UnifiedOn -> m UnifiedOn #

Data UnifiedTableName Source # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UnifiedTableName -> c UnifiedTableName #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c UnifiedTableName #

toConstr :: UnifiedTableName -> Constr #

dataTypeOf :: UnifiedTableName -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c UnifiedTableName) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c UnifiedTableName) #

gmapT :: (forall b. Data b => b -> b) -> UnifiedTableName -> UnifiedTableName #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UnifiedTableName -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UnifiedTableName -> r #

gmapQ :: (forall d. Data d => d -> u) -> UnifiedTableName -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UnifiedTableName -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UnifiedTableName -> m UnifiedTableName #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UnifiedTableName -> m UnifiedTableName #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UnifiedTableName -> m UnifiedTableName #

Data UnifiedUsing Source # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UnifiedUsing -> c UnifiedUsing #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c UnifiedUsing #

toConstr :: UnifiedUsing -> Constr #

dataTypeOf :: UnifiedUsing -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c UnifiedUsing) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c UnifiedUsing) #

gmapT :: (forall b. Data b => b -> b) -> UnifiedUsing -> UnifiedUsing #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UnifiedUsing -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UnifiedUsing -> r #

gmapQ :: (forall d. Data d => d -> u) -> UnifiedUsing -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UnifiedUsing -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UnifiedUsing -> m UnifiedUsing #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UnifiedUsing -> m UnifiedUsing #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UnifiedUsing -> m UnifiedUsing #

Data Values Source # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Values -> c Values #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Values #

toConstr :: Values -> Constr #

dataTypeOf :: Values -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Values) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Values) #

gmapT :: (forall b. Data b => b -> b) -> Values -> Values #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Values -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Values -> r #

gmapQ :: (forall d. Data d => d -> u) -> Values -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Values -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Values -> m Values #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Values -> m Values #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Values -> m Values #

Data Where Source # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Where -> c Where #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Where #

toConstr :: Where -> Constr #

dataTypeOf :: Where -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Where) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Where) #

gmapT :: (forall b. Data b => b -> b) -> Where -> Where #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Where -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Where -> r #

gmapQ :: (forall d. Data d => d -> u) -> Where -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Where -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Where -> m Where #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Where -> m Where #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Where -> m Where #

Data With Source # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> With -> c With #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c With #

toConstr :: With -> Constr #

dataTypeOf :: With -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c With) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c With) #

gmapT :: (forall b. Data b => b -> b) -> With -> With #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> With -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> With -> r #

gmapQ :: (forall d. Data d => d -> u) -> With -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> With -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> With -> m With #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> With -> m With #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> With -> m With #

Foldable BooleanOperators Source # 
Instance details

Methods

fold :: Monoid m => BooleanOperators m -> m #

foldMap :: Monoid m => (a -> m) -> BooleanOperators a -> m #

foldMap' :: Monoid m => (a -> m) -> BooleanOperators a -> m #

foldr :: (a -> b -> b) -> b -> BooleanOperators a -> b #

foldr' :: (a -> b -> b) -> b -> BooleanOperators a -> b #

foldl :: (b -> a -> b) -> b -> BooleanOperators a -> b #

foldl' :: (b -> a -> b) -> b -> BooleanOperators a -> b #

foldr1 :: (a -> a -> a) -> BooleanOperators a -> a #

foldl1 :: (a -> a -> a) -> BooleanOperators a -> a #

toList :: BooleanOperators a -> [a] #

null :: BooleanOperators a -> Bool #

length :: BooleanOperators a -> Int #

elem :: Eq a => a -> BooleanOperators a -> Bool #

maximum :: Ord a => BooleanOperators a -> a #

minimum :: Ord a => BooleanOperators a -> a #

sum :: Num a => BooleanOperators a -> a #

product :: Num a => BooleanOperators a -> a #

Traversable BooleanOperators Source # 
Instance details

Methods

traverse :: Applicative f => (a -> f b) -> BooleanOperators a -> f (BooleanOperators b) #

sequenceA :: Applicative f => BooleanOperators (f a) -> f (BooleanOperators a) #

mapM :: Monad m => (a -> m b) -> BooleanOperators a -> m (BooleanOperators b) #

sequence :: Monad m => BooleanOperators (m a) -> m (BooleanOperators a) #

Functor Aliased Source # 
Instance details

Methods

fmap :: (a -> b) -> Aliased a -> Aliased b #

(<$) :: a -> Aliased b -> Aliased a #

Functor BooleanOperators Source # 
Instance details

Methods

fmap :: (a -> b) -> BooleanOperators a -> BooleanOperators b #

(<$) :: a -> BooleanOperators b -> BooleanOperators a #

Monoid Top Source # 
Instance details

Methods

mempty :: Top #

mappend :: Top -> Top -> Top #

mconcat :: [Top] -> Top #

Monoid Where Source # 
Instance details

Methods

mempty :: Where #

mappend :: Where -> Where -> Where #

mconcat :: [Where] -> Where #

Semigroup Top Source # 
Instance details

Methods

(<>) :: Top -> Top -> Top #

sconcat :: NonEmpty Top -> Top #

stimes :: Integral b => b -> Top -> Top #

Semigroup Where Source # 
Instance details

Methods

(<>) :: Where -> Where -> Where #

sconcat :: NonEmpty Where -> Where #

stimes :: Integral b => b -> Where -> Where #

Generic Aggregate Source # 
Instance details

Associated Types

type Rep Aggregate :: Type -> Type #

Generic CTEBody Source # 
Instance details

Associated Types

type Rep CTEBody :: Type -> Type #

Methods

from :: CTEBody -> Rep CTEBody x #

to :: Rep CTEBody x -> CTEBody #

Generic ColumnName Source # 
Instance details

Associated Types

type Rep ColumnName :: Type -> Type #

Generic ConstraintName Source # 
Instance details

Associated Types

type Rep ConstraintName :: Type -> Type #

Generic DataLength Source # 
Instance details

Associated Types

type Rep DataLength :: Type -> Type #

Generic Delete Source # 
Instance details

Associated Types

type Rep Delete :: Type -> Type #

Methods

from :: Delete -> Rep Delete x #

to :: Rep Delete x -> Delete #

Generic DeleteOutput Source # 
Instance details

Associated Types

type Rep DeleteOutput :: Type -> Type #

Generic Deleted Source # 
Instance details

Associated Types

type Rep Deleted :: Type -> Type #

Methods

from :: Deleted -> Rep Deleted x #

to :: Rep Deleted x -> Deleted #

Generic EntityAlias Source # 
Instance details

Associated Types

type Rep EntityAlias :: Type -> Type #

Generic Expression Source # 
Instance details

Associated Types

type Rep Expression :: Type -> Type #

Generic FieldName Source # 
Instance details

Associated Types

type Rep FieldName :: Type -> Type #

Generic For Source # 
Instance details

Associated Types

type Rep For :: Type -> Type #

Methods

from :: For -> Rep For x #

to :: Rep For x -> For #

Generic ForJson Source # 
Instance details

Associated Types

type Rep ForJson :: Type -> Type #

Methods

from :: ForJson -> Rep ForJson x #

to :: Rep ForJson x -> ForJson #

Generic From Source # 
Instance details

Associated Types

type Rep From :: Type -> Type #

Methods

from :: From -> Rep From x #

to :: Rep From x -> From #

Generic FunctionApplicationExpression Source # 
Instance details

Associated Types

type Rep FunctionApplicationExpression :: Type -> Type #

Generic FunctionName Source # 
Instance details

Associated Types

type Rep FunctionName :: Type -> Type #

Generic Insert Source # 
Instance details

Associated Types

type Rep Insert :: Type -> Type #

Methods

from :: Insert -> Rep Insert x #

to :: Rep Insert x -> Insert #

Generic InsertOutput Source # 
Instance details

Associated Types

type Rep InsertOutput :: Type -> Type #

Generic InsertValuesIntoTempTable Source # 
Instance details

Associated Types

type Rep InsertValuesIntoTempTable :: Type -> Type #

Generic Inserted Source # 
Instance details

Associated Types

type Rep Inserted :: Type -> Type #

Methods

from :: Inserted -> Rep Inserted x #

to :: Rep Inserted x -> Inserted #

Generic Join Source # 
Instance details

Associated Types

type Rep Join :: Type -> Type #

Methods

from :: Join -> Rep Join x #

to :: Rep Join x -> Join #

Generic JoinAlias Source # 
Instance details

Associated Types

type Rep JoinAlias :: Type -> Type #

Generic JoinSource Source # 
Instance details

Associated Types

type Rep JoinSource :: Type -> Type #

Generic JsonCardinality Source # 
Instance details

Associated Types

type Rep JsonCardinality :: Type -> Type #

Generic JsonFieldSpec Source # 
Instance details

Associated Types

type Rep JsonFieldSpec :: Type -> Type #

Generic JsonPath Source # 
Instance details

Associated Types

type Rep JsonPath :: Type -> Type #

Methods

from :: JsonPath -> Rep JsonPath x #

to :: Rep JsonPath x -> JsonPath #

Generic Merge Source # 
Instance details

Associated Types

type Rep Merge :: Type -> Type #

Methods

from :: Merge -> Rep Merge x #

to :: Rep Merge x -> Merge #

Generic MergeOn Source # 
Instance details

Associated Types

type Rep MergeOn :: Type -> Type #

Methods

from :: MergeOn -> Rep MergeOn x #

to :: Rep MergeOn x -> MergeOn #

Generic MergeUsing Source # 
Instance details

Associated Types

type Rep MergeUsing :: Type -> Type #

Generic MergeWhenMatched Source # 
Instance details

Associated Types

type Rep MergeWhenMatched :: Type -> Type #

Generic MergeWhenNotMatched Source # 
Instance details

Associated Types

type Rep MergeWhenNotMatched :: Type -> Type #

Generic MethodApplicationExpression Source # 
Instance details

Associated Types

type Rep MethodApplicationExpression :: Type -> Type #

Generic NullsOrder Source # 
Instance details

Associated Types

type Rep NullsOrder :: Type -> Type #

Generic Op Source # 
Instance details

Associated Types

type Rep Op :: Type -> Type #

Methods

from :: Op -> Rep Op x #

to :: Rep Op x -> Op #

Generic OpenJson Source # 
Instance details

Associated Types

type Rep OpenJson :: Type -> Type #

Methods

from :: OpenJson -> Rep OpenJson x #

to :: Rep OpenJson x -> OpenJson #

Generic Order Source # 
Instance details

Associated Types

type Rep Order :: Type -> Type #

Methods

from :: Order -> Rep Order x #

to :: Rep Order x -> Order #

Generic OrderBy Source # 
Instance details

Associated Types

type Rep OrderBy :: Type -> Type #

Methods

from :: OrderBy -> Rep OrderBy x #

to :: Rep OrderBy x -> OrderBy #

Generic OutputColumn Source # 
Instance details

Associated Types

type Rep OutputColumn :: Type -> Type #

Generic Projection Source # 
Instance details

Associated Types

type Rep Projection :: Type -> Type #

Generic Reselect Source # 
Instance details

Associated Types

type Rep Reselect :: Type -> Type #

Methods

from :: Reselect -> Rep Reselect x #

to :: Rep Reselect x -> Reselect #

Generic Root Source # 
Instance details

Associated Types

type Rep Root :: Type -> Type #

Methods

from :: Root -> Rep Root x #

to :: Rep Root x -> Root #

Generic SITTConstraints Source # 
Instance details

Associated Types

type Rep SITTConstraints :: Type -> Type #

Generic ScalarType Source # 
Instance details

Associated Types

type Rep ScalarType :: Type -> Type #

Generic Select Source # 
Instance details

Associated Types

type Rep Select :: Type -> Type #

Methods

from :: Select -> Rep Select x #

to :: Rep Select x -> Select #

Generic SelectIntoTempTable Source # 
Instance details

Associated Types

type Rep SelectIntoTempTable :: Type -> Type #

Generic SomeTableName Source # 
Instance details

Associated Types

type Rep SomeTableName :: Type -> Type #

Generic SpatialOp Source # 
Instance details

Associated Types

type Rep SpatialOp :: Type -> Type #

Generic TableName Source # 
Instance details

Associated Types

type Rep TableName :: Type -> Type #

Generic TempTable Source # 
Instance details

Associated Types

type Rep TempTable :: Type -> Type #

Generic TempTableName Source # 
Instance details

Associated Types

type Rep TempTableName :: Type -> Type #

Generic Top Source # 
Instance details

Associated Types

type Rep Top :: Type -> Type #

Methods

from :: Top -> Rep Top x #

to :: Rep Top x -> Top #

Generic UnifiedArrayRelationship Source # 
Instance details

Associated Types

type Rep UnifiedArrayRelationship :: Type -> Type #

Generic UnifiedColumn Source # 
Instance details

Associated Types

type Rep UnifiedColumn :: Type -> Type #

Generic UnifiedObjectRelationship Source # 
Instance details

Associated Types

type Rep UnifiedObjectRelationship :: Type -> Type #

Generic UnifiedOn Source # 
Instance details

Associated Types

type Rep UnifiedOn :: Type -> Type #

Generic UnifiedTableName Source # 
Instance details

Associated Types

type Rep UnifiedTableName :: Type -> Type #

Generic UnifiedUsing Source # 
Instance details

Associated Types

type Rep UnifiedUsing :: Type -> Type #

Generic Values Source # 
Instance details

Associated Types

type Rep Values :: Type -> Type #

Methods

from :: Values -> Rep Values x #

to :: Rep Values x -> Values #

Generic Where Source # 
Instance details

Associated Types

type Rep Where :: Type -> Type #

Methods

from :: Where -> Rep Where x #

to :: Rep Where x -> Where #

Generic With Source # 
Instance details

Associated Types

type Rep With :: Type -> Type #

Methods

from :: With -> Rep With x #

to :: Rep With x -> With #

Generic TimeZone Source # 
Instance details

Associated Types

type Rep TimeZone :: Type -> Type #

Methods

from :: TimeZone -> Rep TimeZone x #

to :: Rep TimeZone x -> TimeZone #

Show Aggregate Source # 
Instance details

Show CTEBody Source # 
Instance details

Show ColumnName Source # 
Instance details

Show ConstraintName Source # 
Instance details

Show DataLength Source # 
Instance details

Show Delete Source # 
Instance details

Show DeleteOutput Source # 
Instance details

Show Deleted Source # 
Instance details

Show EntityAlias Source # 
Instance details

Show Expression Source # 
Instance details

Show FieldName Source # 
Instance details

Show For Source # 
Instance details

Methods

showsPrec :: Int -> For -> ShowS #

show :: For -> String #

showList :: [For] -> ShowS #

Show ForJson Source # 
Instance details

Show From Source # 
Instance details

Methods

showsPrec :: Int -> From -> ShowS #

show :: From -> String #

showList :: [From] -> ShowS #

Show FunctionApplicationExpression Source # 
Instance details

Show FunctionName Source # 
Instance details

Show Insert Source # 
Instance details

Show InsertOutput Source # 
Instance details

Show InsertValuesIntoTempTable Source # 
Instance details

Show Inserted Source # 
Instance details

Show Join Source # 
Instance details

Methods

showsPrec :: Int -> Join -> ShowS #

show :: Join -> String #

showList :: [Join] -> ShowS #

Show JoinAlias Source # 
Instance details

Show JoinSource Source # 
Instance details

Show JsonCardinality Source # 
Instance details

Show JsonFieldSpec Source # 
Instance details

Show JsonPath Source # 
Instance details

Show Merge Source # 
Instance details

Methods

showsPrec :: Int -> Merge -> ShowS #

show :: Merge -> String #

showList :: [Merge] -> ShowS #

Show MergeOn Source # 
Instance details

Show MergeUsing Source # 
Instance details

Show MergeWhenMatched Source # 
Instance details

Show MergeWhenNotMatched Source # 
Instance details

Show MethodApplicationExpression Source # 
Instance details

Show NullsOrder Source # 
Instance details

Show Op Source # 
Instance details

Methods

showsPrec :: Int -> Op -> ShowS #

show :: Op -> String #

showList :: [Op] -> ShowS #

Show OpenJson Source # 
Instance details

Show Order Source # 
Instance details

Methods

showsPrec :: Int -> Order -> ShowS #

show :: Order -> String #

showList :: [Order] -> ShowS #

Show OrderBy Source # 
Instance details

Show OutputColumn Source # 
Instance details

Show Projection Source # 
Instance details

Show Reselect Source # 
Instance details

Show Root Source # 
Instance details

Methods

showsPrec :: Int -> Root -> ShowS #

show :: Root -> String #

showList :: [Root] -> ShowS #

Show SITTConstraints Source # 
Instance details

Show ScalarType Source # 
Instance details

Show Select Source # 
Instance details

Show SelectIntoTempTable Source # 
Instance details

Show SomeTableName Source # 
Instance details

Show SpatialOp Source # 
Instance details

Show TableName Source # 
Instance details

Show TempTable Source # 
Instance details

Show TempTableName Source # 
Instance details

Show Top Source # 
Instance details

Methods

showsPrec :: Int -> Top -> ShowS #

show :: Top -> String #

showList :: [Top] -> ShowS #

Show UnifiedArrayRelationship Source # 
Instance details

Show UnifiedColumn Source # 
Instance details

Show UnifiedObjectRelationship Source # 
Instance details

Show UnifiedOn Source # 
Instance details

Show UnifiedTableName Source # 
Instance details

Show UnifiedUsing Source # 
Instance details

Show Values Source # 
Instance details

Show Where Source # 
Instance details

Methods

showsPrec :: Int -> Where -> ShowS #

show :: Where -> String #

showList :: [Where] -> ShowS #

Show With Source # 
Instance details

Methods

showsPrec :: Int -> With -> ShowS #

show :: With -> String #

showList :: [With] -> ShowS #

NFData Aggregate Source # 
Instance details

Methods

rnf :: Aggregate -> () #

NFData CTEBody Source # 
Instance details

Methods

rnf :: CTEBody -> () #

NFData ColumnName Source # 
Instance details

Methods

rnf :: ColumnName -> () #

NFData ConstraintName Source # 
Instance details

Methods

rnf :: ConstraintName -> () #

NFData DataLength Source # 
Instance details

Methods

rnf :: DataLength -> () #

NFData Delete Source # 
Instance details

Methods

rnf :: Delete -> () #

NFData DeleteOutput Source # 
Instance details

Methods

rnf :: DeleteOutput -> () #

NFData Deleted Source # 
Instance details

Methods

rnf :: Deleted -> () #

NFData EntityAlias Source # 
Instance details

Methods

rnf :: EntityAlias -> () #

NFData Expression Source # 
Instance details

Methods

rnf :: Expression -> () #

NFData FieldName Source # 
Instance details

Methods

rnf :: FieldName -> () #

NFData For Source # 
Instance details

Methods

rnf :: For -> () #

NFData ForJson Source # 
Instance details

Methods

rnf :: ForJson -> () #

NFData From Source # 
Instance details

Methods

rnf :: From -> () #

NFData FunctionApplicationExpression Source # 
Instance details

NFData FunctionName Source # 
Instance details

Methods

rnf :: FunctionName -> () #

NFData Insert Source # 
Instance details

Methods

rnf :: Insert -> () #

NFData InsertOutput Source # 
Instance details

Methods

rnf :: InsertOutput -> () #

NFData InsertValuesIntoTempTable Source # 
Instance details

NFData Inserted Source # 
Instance details

Methods

rnf :: Inserted -> () #

NFData Join Source # 
Instance details

Methods

rnf :: Join -> () #

NFData JoinAlias Source # 
Instance details

Methods

rnf :: JoinAlias -> () #

NFData JoinSource Source # 
Instance details

Methods

rnf :: JoinSource -> () #

NFData JsonCardinality Source # 
Instance details

Methods

rnf :: JsonCardinality -> () #

NFData JsonFieldSpec Source # 
Instance details

Methods

rnf :: JsonFieldSpec -> () #

NFData JsonPath Source # 
Instance details

Methods

rnf :: JsonPath -> () #

NFData Merge Source # 
Instance details

Methods

rnf :: Merge -> () #

NFData MergeOn Source # 
Instance details

Methods

rnf :: MergeOn -> () #

NFData MergeUsing Source # 
Instance details

Methods

rnf :: MergeUsing -> () #

NFData MergeWhenMatched Source # 
Instance details

Methods

rnf :: MergeWhenMatched -> () #

NFData MergeWhenNotMatched Source # 
Instance details

Methods

rnf :: MergeWhenNotMatched -> () #

NFData MethodApplicationExpression Source # 
Instance details

NFData NullsOrder Source # 
Instance details

Methods

rnf :: NullsOrder -> () #

NFData Op Source # 
Instance details

Methods

rnf :: Op -> () #

NFData OpenJson Source # 
Instance details

Methods

rnf :: OpenJson -> () #

NFData Order Source # 
Instance details

Methods

rnf :: Order -> () #

NFData OrderBy Source # 
Instance details

Methods

rnf :: OrderBy -> () #

NFData OutputColumn Source # 
Instance details

Methods

rnf :: OutputColumn -> () #

NFData Projection Source # 
Instance details

Methods

rnf :: Projection -> () #

NFData Reselect Source # 
Instance details

Methods

rnf :: Reselect -> () #

NFData Root Source # 
Instance details

Methods

rnf :: Root -> () #

NFData SITTConstraints Source # 
Instance details

Methods

rnf :: SITTConstraints -> () #

NFData ScalarType Source # 
Instance details

Methods

rnf :: ScalarType -> () #

NFData Select Source # 
Instance details

Methods

rnf :: Select -> () #

NFData SelectIntoTempTable Source # 
Instance details

Methods

rnf :: SelectIntoTempTable -> () #

NFData SomeTableName Source # 
Instance details

Methods

rnf :: SomeTableName -> () #

NFData SpatialOp Source # 
Instance details

Methods

rnf :: SpatialOp -> () #

NFData TableName Source # 
Instance details

Methods

rnf :: TableName -> () #

NFData TempTable Source # 
Instance details

Methods

rnf :: TempTable -> () #

NFData TempTableName Source # 
Instance details

Methods

rnf :: TempTableName -> () #

NFData Top Source # 
Instance details

Methods

rnf :: Top -> () #

NFData UnifiedArrayRelationship Source # 
Instance details

NFData UnifiedColumn Source # 
Instance details

Methods

rnf :: UnifiedColumn -> () #

NFData UnifiedObjectRelationship Source # 
Instance details

NFData UnifiedOn Source # 
Instance details

Methods

rnf :: UnifiedOn -> () #

NFData UnifiedTableName Source # 
Instance details

Methods

rnf :: UnifiedTableName -> () #

NFData UnifiedUsing Source # 
Instance details

Methods

rnf :: UnifiedUsing -> () #

NFData Values Source # 
Instance details

Methods

rnf :: Values -> () #

NFData Where Source # 
Instance details

Methods

rnf :: Where -> () #

NFData With Source # 
Instance details

Methods

rnf :: With -> () #

Eq Aggregate Source # 
Instance details

Eq CTEBody Source # 
Instance details

Methods

(==) :: CTEBody -> CTEBody -> Bool #

(/=) :: CTEBody -> CTEBody -> Bool #

Eq ColumnName Source # 
Instance details

Eq ConstraintName Source # 
Instance details

Eq DataLength Source # 
Instance details

Eq Delete Source # 
Instance details

Methods

(==) :: Delete -> Delete -> Bool #

(/=) :: Delete -> Delete -> Bool #

Eq DeleteOutput Source # 
Instance details

Eq Deleted Source # 
Instance details

Methods

(==) :: Deleted -> Deleted -> Bool #

(/=) :: Deleted -> Deleted -> Bool #

Eq EntityAlias Source # 
Instance details

Eq Expression Source # 
Instance details

Eq FieldName Source # 
Instance details

Eq For Source # 
Instance details

Methods

(==) :: For -> For -> Bool #

(/=) :: For -> For -> Bool #

Eq ForJson Source # 
Instance details

Methods

(==) :: ForJson -> ForJson -> Bool #

(/=) :: ForJson -> ForJson -> Bool #

Eq From Source # 
Instance details

Methods

(==) :: From -> From -> Bool #

(/=) :: From -> From -> Bool #

Eq FunctionApplicationExpression Source # 
Instance details

Eq FunctionName Source # 
Instance details

Eq Insert Source # 
Instance details

Methods

(==) :: Insert -> Insert -> Bool #

(/=) :: Insert -> Insert -> Bool #

Eq InsertOutput Source # 
Instance details

Eq InsertValuesIntoTempTable Source # 
Instance details

Eq Inserted Source # 
Instance details

Eq Join Source # 
Instance details

Methods

(==) :: Join -> Join -> Bool #

(/=) :: Join -> Join -> Bool #

Eq JoinAlias Source # 
Instance details

Eq JoinSource Source # 
Instance details

Eq JsonCardinality Source # 
Instance details

Eq JsonFieldSpec Source # 
Instance details

Eq JsonPath Source # 
Instance details

Eq Merge Source # 
Instance details

Methods

(==) :: Merge -> Merge -> Bool #

(/=) :: Merge -> Merge -> Bool #

Eq MergeOn Source # 
Instance details

Methods

(==) :: MergeOn -> MergeOn -> Bool #

(/=) :: MergeOn -> MergeOn -> Bool #

Eq MergeUsing Source # 
Instance details

Eq MergeWhenMatched Source # 
Instance details

Eq MergeWhenNotMatched Source # 
Instance details

Eq MethodApplicationExpression Source # 
Instance details

Eq NullsOrder Source # 
Instance details

Eq Op Source # 
Instance details

Methods

(==) :: Op -> Op -> Bool #

(/=) :: Op -> Op -> Bool #

Eq OpenJson Source # 
Instance details

Eq Order Source # 
Instance details

Methods

(==) :: Order -> Order -> Bool #

(/=) :: Order -> Order -> Bool #

Eq OrderBy Source # 
Instance details

Methods

(==) :: OrderBy -> OrderBy -> Bool #

(/=) :: OrderBy -> OrderBy -> Bool #

Eq OutputColumn Source # 
Instance details

Eq Projection Source # 
Instance details

Eq Reselect Source # 
Instance details

Eq Root Source # 
Instance details

Methods

(==) :: Root -> Root -> Bool #

(/=) :: Root -> Root -> Bool #

Eq SITTConstraints Source # 
Instance details

Eq ScalarType Source # 
Instance details

Eq Select Source # 
Instance details

Methods

(==) :: Select -> Select -> Bool #

(/=) :: Select -> Select -> Bool #

Eq SelectIntoTempTable Source # 
Instance details

Eq SomeTableName Source # 
Instance details

Eq SpatialOp Source # 
Instance details

Eq TableName Source # 
Instance details

Eq TempTable Source # 
Instance details

Eq TempTableName Source # 
Instance details

Eq Top Source # 
Instance details

Methods

(==) :: Top -> Top -> Bool #

(/=) :: Top -> Top -> Bool #

Eq UnifiedArrayRelationship Source # 
Instance details

Eq UnifiedColumn Source # 
Instance details

Eq UnifiedObjectRelationship Source # 
Instance details

Eq UnifiedOn Source # 
Instance details

Eq UnifiedTableName Source # 
Instance details

Eq UnifiedUsing Source # 
Instance details

Eq Values Source # 
Instance details

Methods

(==) :: Values -> Values -> Bool #

(/=) :: Values -> Values -> Bool #

Eq Where Source # 
Instance details

Methods

(==) :: Where -> Where -> Bool #

(/=) :: Where -> Where -> Bool #

Eq With Source # 
Instance details

Methods

(==) :: With -> With -> Bool #

(/=) :: With -> With -> Bool #

Ord ColumnName Source # 
Instance details

Ord ConstraintName Source # 
Instance details

Ord FunctionName Source # 
Instance details

Ord ScalarType Source # 
Instance details

Ord SomeTableName Source # 
Instance details

Ord TableName Source # 
Instance details

Ord TempTableName Source # 
Instance details

Ord UnifiedArrayRelationship Source # 
Instance details

Ord UnifiedColumn Source # 
Instance details

Ord UnifiedObjectRelationship Source # 
Instance details

Ord UnifiedOn Source # 
Instance details

Ord UnifiedTableName Source # 
Instance details

Ord UnifiedUsing Source # 
Instance details

Hashable Aggregate Source # 
Instance details

Hashable CTEBody Source # 
Instance details

Hashable ColumnName Source # 
Instance details

Hashable ConstraintName Source # 
Instance details

Hashable DataLength Source # 
Instance details

Hashable Delete Source # 
Instance details

Hashable DeleteOutput Source # 
Instance details

Hashable Deleted Source # 
Instance details

Hashable EntityAlias Source # 
Instance details

Hashable Expression Source # 
Instance details

Hashable FieldName Source # 
Instance details

Hashable For Source # 
Instance details

Methods

hashWithSalt :: Int -> For -> Int Source #

hash :: For -> Int Source #

Hashable ForJson Source # 
Instance details

Hashable From Source # 
Instance details

Hashable FunctionApplicationExpression Source # 
Instance details

Hashable FunctionName Source # 
Instance details

Hashable Insert Source # 
Instance details

Hashable InsertOutput Source # 
Instance details

Hashable InsertValuesIntoTempTable Source # 
Instance details

Hashable Inserted Source # 
Instance details

Hashable Join Source # 
Instance details

Hashable JoinAlias Source # 
Instance details

Hashable JoinSource Source # 
Instance details

Hashable JsonCardinality Source # 
Instance details

Hashable JsonFieldSpec Source # 
Instance details

Hashable JsonPath Source # 
Instance details

Hashable Merge Source # 
Instance details

Hashable MergeOn Source # 
Instance details

Hashable MergeUsing Source # 
Instance details

Hashable MergeWhenMatched Source # 
Instance details

Hashable MergeWhenNotMatched Source # 
Instance details

Hashable MethodApplicationExpression Source # 
Instance details

Hashable NullsOrder Source # 
Instance details

Hashable Op Source # 
Instance details

Methods

hashWithSalt :: Int -> Op -> Int Source #

hash :: Op -> Int Source #

Hashable OpenJson Source # 
Instance details

Hashable Order Source # 
Instance details

Hashable OrderBy Source # 
Instance details

Hashable OutputColumn Source # 
Instance details

Hashable Projection Source # 
Instance details

Hashable Reselect Source # 
Instance details

Hashable Root Source # 
Instance details

Hashable SITTConstraints Source # 
Instance details

Hashable ScalarType Source # 
Instance details

Hashable Select Source # 
Instance details

Hashable SelectIntoTempTable Source # 
Instance details

Hashable SomeTableName Source # 
Instance details

Hashable SpatialOp Source # 
Instance details

Hashable TableName Source # 
Instance details

Hashable TempTable Source # 
Instance details

Hashable TempTableName Source # 
Instance details

Hashable Top Source # 
Instance details

Methods

hashWithSalt :: Int -> Top -> Int Source #

hash :: Top -> Int Source #

Hashable UnifiedArrayRelationship Source # 
Instance details

Hashable UnifiedColumn Source # 
Instance details

Hashable UnifiedObjectRelationship Source # 
Instance details

Hashable UnifiedOn Source # 
Instance details

Hashable UnifiedTableName Source # 
Instance details

Hashable UnifiedUsing Source # 
Instance details

Hashable Values Source # 
Instance details

Hashable Where Source # 
Instance details

Hashable With Source # 
Instance details

ToErrorValue ColumnName Source # 
Instance details

ToErrorValue ConstraintName Source # 
Instance details

ToErrorValue FunctionName Source # 
Instance details

ToErrorValue ScalarType Source # 
Instance details

ToErrorValue TableName Source # 
Instance details

ToTxt ColumnName Source # 
Instance details

ToTxt ConstraintName Source # 
Instance details

ToTxt FunctionName Source # 
Instance details

ToTxt ScalarType Source # 
Instance details

ToTxt TableName Source # 
Instance details

Methods

toTxt :: TableName -> Text Source #

Lift FunctionName Source # 
Instance details

Methods

lift :: Quote m => FunctionName -> m Exp #

liftTyped :: forall (m :: Type -> Type). Quote m => FunctionName -> Code m FunctionName #

Lift NullsOrder Source # 
Instance details

Methods

lift :: Quote m => NullsOrder -> m Exp #

liftTyped :: forall (m :: Type -> Type). Quote m => NullsOrder -> Code m NullsOrder #

Lift Order Source # 
Instance details

Methods

lift :: Quote m => Order -> m Exp #

liftTyped :: forall (m :: Type -> Type). Quote m => Order -> Code m Order #

Lift TableName Source # 
Instance details

Methods

lift :: Quote m => TableName -> m Exp #

liftTyped :: forall (m :: Type -> Type). Quote m => TableName -> Code m TableName #

FromJSON n => FromJSON (Countable n) Source # 
Instance details

ToJSON n => ToJSON (Countable n) Source # 
Instance details

Data a => Data (Aliased a) Source # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Aliased a -> c (Aliased a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Aliased a) #

toConstr :: Aliased a -> Constr #

dataTypeOf :: Aliased a -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Aliased a)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Aliased a)) #

gmapT :: (forall b. Data b => b -> b) -> Aliased a -> Aliased a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Aliased a -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Aliased a -> r #

gmapQ :: (forall d. Data d => d -> u) -> Aliased a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Aliased a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Aliased a -> m (Aliased a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Aliased a -> m (Aliased a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Aliased a -> m (Aliased a) #

Data n => Data (Countable n) Source # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Countable n -> c (Countable n) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Countable n) #

toConstr :: Countable n -> Constr #

dataTypeOf :: Countable n -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Countable n)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Countable n)) #

gmapT :: (forall b. Data b => b -> b) -> Countable n -> Countable n #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Countable n -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Countable n -> r #

gmapQ :: (forall d. Data d => d -> u) -> Countable n -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Countable n -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Countable n -> m (Countable n) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Countable n -> m (Countable n) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Countable n -> m (Countable n) #

Generic (Aliased a) Source # 
Instance details

Associated Types

type Rep (Aliased a) :: Type -> Type #

Methods

from :: Aliased a -> Rep (Aliased a) x #

to :: Rep (Aliased a) x -> Aliased a #

Generic (BooleanOperators a) Source # 
Instance details

Associated Types

type Rep (BooleanOperators a) :: Type -> Type #

Generic (Countable n) Source # 
Instance details

Associated Types

type Rep (Countable n) :: Type -> Type #

Methods

from :: Countable n -> Rep (Countable n) x #

to :: Rep (Countable n) x -> Countable n #

Show a => Show (Aliased a) Source # 
Instance details

Methods

showsPrec :: Int -> Aliased a -> ShowS #

show :: Aliased a -> String #

showList :: [Aliased a] -> ShowS #

Show a => Show (BooleanOperators a) Source # 
Instance details

Show n => Show (Countable n) Source # 
Instance details

NFData a => NFData (Aliased a) Source # 
Instance details

Methods

rnf :: Aliased a -> () #

NFData a => NFData (BooleanOperators a) Source # 
Instance details

Methods

rnf :: BooleanOperators a -> () #

NFData n => NFData (Countable n) Source # 
Instance details

Methods

rnf :: Countable n -> () #

Eq a => Eq (Aliased a) Source # 
Instance details

Methods

(==) :: Aliased a -> Aliased a -> Bool #

(/=) :: Aliased a -> Aliased a -> Bool #

Eq a => Eq (BooleanOperators a) Source # 
Instance details

Eq n => Eq (Countable n) Source # 
Instance details

Methods

(==) :: Countable n -> Countable n -> Bool #

(/=) :: Countable n -> Countable n -> Bool #

Hashable a => Hashable (Aliased a) Source # 
Instance details

Hashable a => Hashable (BooleanOperators a) Source # 
Instance details

Hashable n => Hashable (Countable n) Source # 
Instance details

ToJSON a => ToJSONKeyValue (BooleanOperators a) Source # 
Instance details