Safe Haskell	None
Language	Haskell2010

Database.Sql.Type.Scope

Synopsis

Documentation

type ColumnSet a = [(Maybe (RTableRef a), [RColumnRef a])] Source #

A ColumnSet records the table-bindings (if any) of columns.

Can be used to represent columns that are in ambient scope, which can be referenced, based on arcane and dialect specific rules. The fst component will be Nothing for collections of column aliases bound in a containing select statement (which thus have no corresponding Tablish), or for subqueries/lateral views with no table alias.

Can also be used to represent "what stars expand into".

data Bindings a Source #

Constructors

Bindings
Fields boundCTEs :: [(TableAlias a, [RColumnRef a])] boundColumns :: ColumnSet a

emptyBindings :: Bindings a Source #

data SelectScope a Source #

Constructors

SelectScope
Fields bindForHaving :: forall r m. MonadReader (ResolverInfo a) m => m r -> m r bindForWhere :: forall r m. MonadReader (ResolverInfo a) m => m r -> m r bindForOrder :: forall r m. MonadReader (ResolverInfo a) m => m r -> m r bindForGroup :: forall r m. MonadReader (ResolverInfo a) m => m r -> m r bindForNamedWindow :: forall r m. MonadReader (ResolverInfo a) m => m r -> m r

type FromColumns a = ColumnSet a Source #

type SelectionAliases a = [RColumnRef a] Source #

data ResolverInfo a Source #

Constructors

ResolverInfo
Fields catalog :: Catalog onCTECollision :: forall x. (x -> x) -> x -> x bindings :: Bindings a selectScope :: FromColumns a -> SelectionAliases a -> SelectScope a lcolumnsAreVisibleInLateralViews :: Bool

mapBindings :: (Bindings a -> Bindings a) -> ResolverInfo a -> ResolverInfo a Source #

bindColumns :: MonadReader (ResolverInfo a) m => ColumnSet a -> m r -> m r Source #

bindFromColumns :: MonadReader (ResolverInfo a) m => FromColumns a -> m r -> m r Source #

bindAliasedColumns :: MonadReader (ResolverInfo a) m => SelectionAliases a -> m r -> m r Source #

bindBothColumns :: MonadReader (ResolverInfo a) m => FromColumns a -> SelectionAliases a -> m r -> m r Source #

data RawNames Source #

Instances

Data RawNames Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RawNames -> c RawNames # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c RawNames # toConstr :: RawNames -> Constr # dataTypeOf :: RawNames -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c RawNames) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RawNames) # gmapT :: (forall b. Data b => b -> b) -> RawNames -> RawNames # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RawNames -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RawNames -> r # gmapQ :: (forall d. Data d => d -> u) -> RawNames -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> RawNames -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> RawNames -> m RawNames # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RawNames -> m RawNames # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RawNames -> m RawNames #
Resolution RawNames Source #
Associated Types type TableRef RawNames :: * -> * Source # type TableName RawNames :: * -> * Source # type CreateTableName RawNames :: * -> * Source # type DropTableName RawNames :: * -> * Source # type SchemaName RawNames :: * -> * Source # type CreateSchemaName RawNames :: * -> * Source # type ColumnRef RawNames :: * -> * Source # type NaturalColumns RawNames :: * -> * Source # type UsingColumn RawNames :: * -> * Source # type StarReferents RawNames :: * -> * Source # type PositionExpr RawNames :: * -> * Source # type ComposedQueryColumns RawNames :: * -> * Source #
type TableRef RawNames Source #
type TableRef RawNames = OQTableName
type TableName RawNames Source #
type TableName RawNames = OQTableName
type CreateTableName RawNames Source #
type CreateTableName RawNames = OQTableName
type DropTableName RawNames Source #
type DropTableName RawNames = OQTableName
type SchemaName RawNames Source #
type SchemaName RawNames = OQSchemaName
type CreateSchemaName RawNames Source #
type CreateSchemaName RawNames = OQSchemaName
type ColumnRef RawNames Source #
type ColumnRef RawNames = OQColumnName
type NaturalColumns RawNames Source #
type NaturalColumns RawNames = Unused
type UsingColumn RawNames Source #
type UsingColumn RawNames = UQColumnName
type StarReferents RawNames Source #
type StarReferents RawNames = Unused
type PositionExpr RawNames Source #
type PositionExpr RawNames = Unused
type ComposedQueryColumns RawNames Source #
type ComposedQueryColumns RawNames = Unused

data ResolvedNames Source #

Instances

Data ResolvedNames Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ResolvedNames -> c ResolvedNames # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ResolvedNames # toConstr :: ResolvedNames -> Constr # dataTypeOf :: ResolvedNames -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c ResolvedNames) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ResolvedNames) # gmapT :: (forall b. Data b => b -> b) -> ResolvedNames -> ResolvedNames # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ResolvedNames -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ResolvedNames -> r # gmapQ :: (forall d. Data d => d -> u) -> ResolvedNames -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ResolvedNames -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ResolvedNames -> m ResolvedNames # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ResolvedNames -> m ResolvedNames # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ResolvedNames -> m ResolvedNames #
Resolution ResolvedNames Source #
Associated Types type TableRef ResolvedNames :: * -> * Source # type TableName ResolvedNames :: * -> * Source # type CreateTableName ResolvedNames :: * -> * Source # type DropTableName ResolvedNames :: * -> * Source # type SchemaName ResolvedNames :: * -> * Source # type CreateSchemaName ResolvedNames :: * -> * Source # type ColumnRef ResolvedNames :: * -> * Source # type NaturalColumns ResolvedNames :: * -> * Source # type UsingColumn ResolvedNames :: * -> * Source # type StarReferents ResolvedNames :: * -> * Source # type PositionExpr ResolvedNames :: * -> * Source # type ComposedQueryColumns ResolvedNames :: * -> * Source #
Evaluation e => Evaluate e (Expr ResolvedNames Range) Source #
Associated Types type EvalResult e (Expr ResolvedNames Range) :: * Source # Methods eval :: Proxy * e -> Expr ResolvedNames Range -> EvalResult e (Expr ResolvedNames Range) Source #
Evaluation e => Evaluate e (Selection ResolvedNames Range) Source #
Associated Types type EvalResult e (Selection ResolvedNames Range) :: * Source # Methods eval :: Proxy * e -> Selection ResolvedNames Range -> EvalResult e (Selection ResolvedNames Range) Source #
Evaluation e => Evaluate e (SelectTimeseries ResolvedNames Range) Source #
Associated Types type EvalResult e (SelectTimeseries ResolvedNames Range) :: * Source # Methods eval :: Proxy * e -> SelectTimeseries ResolvedNames Range -> EvalResult e (SelectTimeseries ResolvedNames Range) Source #
Evaluation e => Evaluate e (SelectHaving ResolvedNames Range) Source #
Associated Types type EvalResult e (SelectHaving ResolvedNames Range) :: * Source # Methods eval :: Proxy * e -> SelectHaving ResolvedNames Range -> EvalResult e (SelectHaving ResolvedNames Range) Source #
Evaluation e => Evaluate e (SelectGroup ResolvedNames Range) Source #
Associated Types type EvalResult e (SelectGroup ResolvedNames Range) :: * Source # Methods eval :: Proxy * e -> SelectGroup ResolvedNames Range -> EvalResult e (SelectGroup ResolvedNames Range) Source #
Evaluation e => Evaluate e (SelectWhere ResolvedNames Range) Source #
Associated Types type EvalResult e (SelectWhere ResolvedNames Range) :: * Source # Methods eval :: Proxy * e -> SelectWhere ResolvedNames Range -> EvalResult e (SelectWhere ResolvedNames Range) Source #
Evaluation e => Evaluate e (SelectColumns ResolvedNames Range) Source #	SelectColumns tells us how to map from the records provided by the FROM to (unfiltered, &c) records provided by our select. Evaluating it gives us that function.
Associated Types type EvalResult e (SelectColumns ResolvedNames Range) :: * Source # Methods eval :: Proxy * e -> SelectColumns ResolvedNames Range -> EvalResult e (SelectColumns ResolvedNames Range) Source #
Evaluation e => Evaluate e (JoinCondition ResolvedNames Range) Source #
Associated Types type EvalResult e (JoinCondition ResolvedNames Range) :: * Source # Methods eval :: Proxy * e -> JoinCondition ResolvedNames Range -> EvalResult e (JoinCondition ResolvedNames Range) Source #
Evaluation e => Evaluate e (Tablish ResolvedNames Range) Source #
Associated Types type EvalResult e (Tablish ResolvedNames Range) :: * Source # Methods eval :: Proxy * e -> Tablish ResolvedNames Range -> EvalResult e (Tablish ResolvedNames Range) Source #
Evaluation e => Evaluate e (SelectFrom ResolvedNames Range) Source #
Associated Types type EvalResult e (SelectFrom ResolvedNames Range) :: * Source # Methods eval :: Proxy * e -> SelectFrom ResolvedNames Range -> EvalResult e (SelectFrom ResolvedNames Range) Source #
Evaluation e => Evaluate e (Select ResolvedNames Range) Source #
Associated Types type EvalResult e (Select ResolvedNames Range) :: * Source # Methods eval :: Proxy * e -> Select ResolvedNames Range -> EvalResult e (Select ResolvedNames Range) Source #
Evaluation e => Evaluate e (Query ResolvedNames Range) Source #
Associated Types type EvalResult e (Query ResolvedNames Range) :: * Source # Methods eval :: Proxy * e -> Query ResolvedNames Range -> EvalResult e (Query ResolvedNames Range) Source #
HasTables (NamedWindowExpr ResolvedNames a) Source #
Methods goTables :: NamedWindowExpr ResolvedNames a -> ReaderT * UsageMode (Writer (Set TableUse)) () Source #
HasTables (PartialWindowExpr ResolvedNames a) Source #
Methods goTables :: PartialWindowExpr ResolvedNames a -> ReaderT * UsageMode (Writer (Set TableUse)) () Source #
HasTables (WindowExpr ResolvedNames a) Source #
Methods goTables :: WindowExpr ResolvedNames a -> ReaderT * UsageMode (Writer (Set TableUse)) () Source #
HasTables (OverSubExpr ResolvedNames a) Source #
Methods goTables :: OverSubExpr ResolvedNames a -> ReaderT * UsageMode (Writer (Set TableUse)) () Source #
HasTables (Partition ResolvedNames a) Source #
Methods goTables :: Partition ResolvedNames a -> ReaderT * UsageMode (Writer (Set TableUse)) () Source #
HasTables (Filter ResolvedNames a) Source #
Methods goTables :: Filter ResolvedNames a -> ReaderT * UsageMode (Writer (Set TableUse)) () Source #
HasTables (Expr ResolvedNames a) Source #
Methods goTables :: Expr ResolvedNames a -> ReaderT * UsageMode (Writer (Set TableUse)) () Source #
HasTables (Selection ResolvedNames a) Source #
Methods goTables :: Selection ResolvedNames a -> ReaderT * UsageMode (Writer (Set TableUse)) () Source #
HasTables (Order ResolvedNames a) Source #
Methods goTables :: Order ResolvedNames a -> ReaderT * UsageMode (Writer (Set TableUse)) () Source #
HasTables (SelectNamedWindow ResolvedNames a) Source #
Methods goTables :: SelectNamedWindow ResolvedNames a -> ReaderT * UsageMode (Writer (Set TableUse)) () Source #
HasTables (SelectHaving ResolvedNames a) Source #
Methods goTables :: SelectHaving ResolvedNames a -> ReaderT * UsageMode (Writer (Set TableUse)) () Source #
HasTables (SelectGroup ResolvedNames a) Source #
Methods goTables :: SelectGroup ResolvedNames a -> ReaderT * UsageMode (Writer (Set TableUse)) () Source #
HasTables (GroupingElement ResolvedNames a) Source #
Methods goTables :: GroupingElement ResolvedNames a -> ReaderT * UsageMode (Writer (Set TableUse)) () Source #
HasTables (PositionOrExpr ResolvedNames a) Source #
Methods goTables :: PositionOrExpr ResolvedNames a -> ReaderT * UsageMode (Writer (Set TableUse)) () Source #
HasTables (SelectTimeseries ResolvedNames a) Source #
Methods goTables :: SelectTimeseries ResolvedNames a -> ReaderT * UsageMode (Writer (Set TableUse)) () Source #
HasTables (SelectWhere ResolvedNames a) Source #
Methods goTables :: SelectWhere ResolvedNames a -> ReaderT * UsageMode (Writer (Set TableUse)) () Source #
HasTables (Tablish ResolvedNames a) Source #
Methods goTables :: Tablish ResolvedNames a -> ReaderT * UsageMode (Writer (Set TableUse)) () Source #
HasTables (SelectFrom ResolvedNames a) Source #
Methods goTables :: SelectFrom ResolvedNames a -> ReaderT * UsageMode (Writer (Set TableUse)) () Source #
HasTables (SelectColumns ResolvedNames a) Source #
Methods goTables :: SelectColumns ResolvedNames a -> ReaderT * UsageMode (Writer (Set TableUse)) () Source #
HasTables (Select ResolvedNames a) Source #
Methods goTables :: Select ResolvedNames a -> ReaderT * UsageMode (Writer (Set TableUse)) () Source #
HasTables (Query ResolvedNames a) Source #
Methods goTables :: Query ResolvedNames a -> ReaderT * UsageMode (Writer (Set TableUse)) () Source #
HasTables (DropView ResolvedNames a) Source #
Methods goTables :: DropView ResolvedNames a -> ReaderT * UsageMode (Writer (Set TableUse)) () Source #
HasTables (CreateView ResolvedNames a) Source #
Methods goTables :: CreateView ResolvedNames a -> ReaderT * UsageMode (Writer (Set TableUse)) () Source #
HasTables (DropTable ResolvedNames a) Source #
Methods goTables :: DropTable ResolvedNames a -> ReaderT * UsageMode (Writer (Set TableUse)) () Source #
HasTables (AlterTable ResolvedNames a) Source #
Methods goTables :: AlterTable ResolvedNames a -> ReaderT * UsageMode (Writer (Set TableUse)) () Source #
HasTables (Truncate ResolvedNames a) Source #
Methods goTables :: Truncate ResolvedNames a -> ReaderT * UsageMode (Writer (Set TableUse)) () Source #
HasTables (Delete ResolvedNames a) Source #
Methods goTables :: Delete ResolvedNames a -> ReaderT * UsageMode (Writer (Set TableUse)) () Source #
HasTables (Update ResolvedNames a) Source #
Methods goTables :: Update ResolvedNames a -> ReaderT * UsageMode (Writer (Set TableUse)) () Source #
HasTables (DefaultExpr ResolvedNames a) Source #
Methods goTables :: DefaultExpr ResolvedNames a -> ReaderT * UsageMode (Writer (Set TableUse)) () Source #
HasTables (InsertValues ResolvedNames a) Source #
Methods goTables :: InsertValues ResolvedNames a -> ReaderT * UsageMode (Writer (Set TableUse)) () Source #
HasTables (Insert ResolvedNames a) Source #
Methods goTables :: Insert ResolvedNames a -> ReaderT * UsageMode (Writer (Set TableUse)) () Source #
HasSchemaChange (AlterTable ResolvedNames a) Source #
Methods getSchemaChange :: AlterTable ResolvedNames a -> [SchemaChange] Source #
HasColumns (NamedWindowExpr ResolvedNames a) Source #
Methods goColumns :: NamedWindowExpr ResolvedNames a -> Observer Source #
HasColumns (PartialWindowExpr ResolvedNames a) Source #
Methods goColumns :: PartialWindowExpr ResolvedNames a -> Observer Source #
HasColumns (WindowExpr ResolvedNames a) Source #
Methods goColumns :: WindowExpr ResolvedNames a -> Observer Source #
HasColumns (OverSubExpr ResolvedNames a) Source #
Methods goColumns :: OverSubExpr ResolvedNames a -> Observer Source #
HasColumns (Partition ResolvedNames a) Source #
Methods goColumns :: Partition ResolvedNames a -> Observer Source #
HasColumns (Filter ResolvedNames a) Source #
Methods goColumns :: Filter ResolvedNames a -> Observer Source #
HasColumns (Pattern ResolvedNames a) Source #
Methods goColumns :: Pattern ResolvedNames a -> Observer Source #
HasColumns (Escape ResolvedNames a) Source #
Methods goColumns :: Escape ResolvedNames a -> Observer Source #
HasColumns (Expr ResolvedNames a) Source #
Methods goColumns :: Expr ResolvedNames a -> Observer Source #
HasColumns (Selection ResolvedNames a) Source #
Methods goColumns :: Selection ResolvedNames a -> Observer Source #
HasColumns (SelectNamedWindow ResolvedNames a) Source #
Methods goColumns :: SelectNamedWindow ResolvedNames a -> Observer Source #
HasColumns (SelectHaving ResolvedNames a) Source #
Methods goColumns :: SelectHaving ResolvedNames a -> Observer Source #
HasColumns (SelectTimeseries ResolvedNames a) Source #
Methods goColumns :: SelectTimeseries ResolvedNames a -> Observer Source #
HasColumns (SelectWhere ResolvedNames a) Source #
Methods goColumns :: SelectWhere ResolvedNames a -> Observer Source #
HasColumns (LateralView ResolvedNames a) Source #
Methods goColumns :: LateralView ResolvedNames a -> Observer Source #
HasColumns (JoinCondition ResolvedNames a) Source #
Methods goColumns :: JoinCondition ResolvedNames a -> Observer Source #
HasColumns (Tablish ResolvedNames a) Source #
Methods goColumns :: Tablish ResolvedNames a -> Observer Source #
HasColumns (SelectFrom ResolvedNames a) Source #
Methods goColumns :: SelectFrom ResolvedNames a -> Observer Source #
HasColumns (SelectColumns ResolvedNames a) Source #
Methods goColumns :: SelectColumns ResolvedNames a -> Observer Source #
HasColumns (Select ResolvedNames a) Source #
Methods goColumns :: Select ResolvedNames a -> Observer Source #
HasColumns (CTE ResolvedNames a) Source #
Methods goColumns :: CTE ResolvedNames a -> Observer Source #
HasColumns (Query ResolvedNames a) Source #
Methods goColumns :: Query ResolvedNames a -> Observer Source #
HasColumns (CreateView ResolvedNames a) Source #
Methods goColumns :: CreateView ResolvedNames a -> Observer Source #
HasColumns (AlterTable ResolvedNames a) Source #
Methods goColumns :: AlterTable ResolvedNames a -> Observer Source #
HasColumns (Delete ResolvedNames a) Source #
Methods goColumns :: Delete ResolvedNames a -> Observer Source #
HasColumns (Update ResolvedNames a) Source #
Methods goColumns :: Update ResolvedNames a -> Observer Source #
HasColumns (DefaultExpr ResolvedNames a) Source #
Methods goColumns :: DefaultExpr ResolvedNames a -> Observer Source #
HasColumns (InsertValues ResolvedNames a) Source #
Methods goColumns :: InsertValues ResolvedNames a -> Observer Source #
HasColumns (Insert ResolvedNames a) Source #
Methods goColumns :: Insert ResolvedNames a -> Observer Source #
HasTables (ColumnDefinition d ResolvedNames a) Source #
Methods goTables :: ColumnDefinition d ResolvedNames a -> ReaderT * UsageMode (Writer (Set TableUse)) () Source #
HasTables (ColumnOrConstraint d ResolvedNames a) Source #
Methods goTables :: ColumnOrConstraint d ResolvedNames a -> ReaderT * UsageMode (Writer (Set TableUse)) () Source #
HasTables (TableDefinition d ResolvedNames a) Source #
Methods goTables :: TableDefinition d ResolvedNames a -> ReaderT * UsageMode (Writer (Set TableUse)) () Source #
HasTables (CreateTable d ResolvedNames a) Source #
Methods goTables :: CreateTable d ResolvedNames a -> ReaderT * UsageMode (Writer (Set TableUse)) () Source #
HasTables (Statement d ResolvedNames a) Source #
Methods goTables :: Statement d ResolvedNames a -> ReaderT * UsageMode (Writer (Set TableUse)) () Source #
HasSchemaChange (Statement d ResolvedNames a) Source #
Methods getSchemaChange :: Statement d ResolvedNames a -> [SchemaChange] Source #
HasTableLineage (Statement d ResolvedNames a) Source #
Methods getTableLineage :: Statement d ResolvedNames a -> TableLineage Source #
HasJoins (Statement d ResolvedNames a) Source #
Methods getJoins :: Statement d ResolvedNames a -> Set Join Source #
HasColumns (ColumnDefinition d ResolvedNames a) Source #
Methods goColumns :: ColumnDefinition d ResolvedNames a -> Observer Source #
HasColumns (ColumnOrConstraint d ResolvedNames a) Source #
Methods goColumns :: ColumnOrConstraint d ResolvedNames a -> Observer Source #
HasColumns (TableDefinition d ResolvedNames a) Source #
Methods goColumns :: TableDefinition d ResolvedNames a -> Observer Source #
HasColumns (CreateTable d ResolvedNames a) Source #
Methods goColumns :: CreateTable d ResolvedNames a -> Observer Source #
HasColumns (Statement d ResolvedNames a) Source #
Methods goColumns :: Statement d ResolvedNames a -> Observer Source #
HasColumnLineage (Statement d ResolvedNames Range) Source #
Methods getColumnLineage :: Statement d ResolvedNames Range -> (RecordSet ColumnLineage, ColumnLineagePlus) Source #
type TableRef ResolvedNames Source #
type TableRef ResolvedNames = RTableRef
type TableName ResolvedNames Source #
type TableName ResolvedNames = RTableName
type CreateTableName ResolvedNames Source #
type CreateTableName ResolvedNames = RCreateTableName
type DropTableName ResolvedNames Source #
type DropTableName ResolvedNames = RDropTableName
type SchemaName ResolvedNames Source #
type SchemaName ResolvedNames = FQSchemaName
type CreateSchemaName ResolvedNames Source #
type CreateSchemaName ResolvedNames = RCreateSchemaName
type ColumnRef ResolvedNames Source #
type ColumnRef ResolvedNames = RColumnRef
type NaturalColumns ResolvedNames Source #
type NaturalColumns ResolvedNames = RNaturalColumns
type UsingColumn ResolvedNames Source #
type UsingColumn ResolvedNames = RUsingColumn
type StarReferents ResolvedNames Source #
type StarReferents ResolvedNames = StarColumnNames
type PositionExpr ResolvedNames Source #
type PositionExpr ResolvedNames = Expr ResolvedNames
type ComposedQueryColumns ResolvedNames Source #
type ComposedQueryColumns ResolvedNames = ColumnAliasList
type EvalResult e (Expr ResolvedNames Range) Source #
type EvalResult e (Expr ResolvedNames Range) = EvalT e ExprContext (EvalMonad e) (EvalValue e)
type EvalResult e (Selection ResolvedNames Range) Source #
type EvalResult e (Selection ResolvedNames Range) = EvalT e ExprContext (EvalMonad e) [EvalValue e]
type EvalResult e (SelectTimeseries ResolvedNames Range) Source #
type EvalResult e (SelectTimeseries ResolvedNames Range) = RecordSet e -> EvalT e TableContext (EvalMonad e) (RecordSet e)
type EvalResult e (SelectHaving ResolvedNames Range) Source #
type EvalResult e (SelectHaving ResolvedNames Range) = EvalRow e (RecordSet e) -> EvalT e TableContext (EvalMonad e) (EvalRow e (RecordSet e))
type EvalResult e (SelectGroup ResolvedNames Range) Source #
type EvalResult e (SelectGroup ResolvedNames Range) = SelectColumns ResolvedNames Range -> RecordSet e -> EvalT e TableContext (EvalMonad e) (EvalRow e (RecordSet e))
type EvalResult e (SelectWhere ResolvedNames Range) Source #
type EvalResult e (SelectWhere ResolvedNames Range) = RecordSet e -> EvalT e TableContext (EvalMonad e) (RecordSet e)
type EvalResult e (SelectColumns ResolvedNames Range) Source #
type EvalResult e (SelectColumns ResolvedNames Range) = RecordSet e -> EvalT e TableContext (EvalMonad e) (RecordSet e)
type EvalResult e (JoinCondition ResolvedNames Range) Source #
type EvalResult e (JoinCondition ResolvedNames Range) = RecordSet e -> RecordSet e -> EvalT e TableContext (EvalMonad e) (RecordSet e)
type EvalResult e (Tablish ResolvedNames Range) Source #
type EvalResult e (Tablish ResolvedNames Range) = EvalT e TableContext (EvalMonad e) (RecordSet e)
type EvalResult e (SelectFrom ResolvedNames Range) Source #
type EvalResult e (SelectFrom ResolvedNames Range) = EvalT e TableContext (EvalMonad e) (RecordSet e)
type EvalResult e (Select ResolvedNames Range) Source #
type EvalResult e (Select ResolvedNames Range) = EvalT e TableContext (EvalMonad e) (RecordSet e)
type EvalResult e (Query ResolvedNames Range) Source #
type EvalResult e (Query ResolvedNames Range) = EvalT e TableContext (EvalMonad e) (RecordSet e)

newtype StarColumnNames a Source #

Constructors

StarColumnNames [RColumnRef a]

Instances

Functor StarColumnNames Source #
Methods fmap :: (a -> b) -> StarColumnNames a -> StarColumnNames b # (<$) :: a -> StarColumnNames b -> StarColumnNames a #
Eq a => Eq (StarColumnNames a) Source #
Methods (==) :: StarColumnNames a -> StarColumnNames a -> Bool # (/=) :: StarColumnNames a -> StarColumnNames a -> Bool #
Data a => Data (StarColumnNames a) Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> StarColumnNames a -> c (StarColumnNames a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (StarColumnNames a) # toConstr :: StarColumnNames a -> Constr # dataTypeOf :: StarColumnNames a -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c (StarColumnNames a)) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (StarColumnNames a)) # gmapT :: (forall b. Data b => b -> b) -> StarColumnNames a -> StarColumnNames a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> StarColumnNames a -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> StarColumnNames a -> r # gmapQ :: (forall d. Data d => d -> u) -> StarColumnNames a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> StarColumnNames a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> StarColumnNames a -> m (StarColumnNames a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> StarColumnNames a -> m (StarColumnNames a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> StarColumnNames a -> m (StarColumnNames a) #
Ord a => Ord (StarColumnNames a) Source #
Methods compare :: StarColumnNames a -> StarColumnNames a -> Ordering # (<) :: StarColumnNames a -> StarColumnNames a -> Bool # (<=) :: StarColumnNames a -> StarColumnNames a -> Bool # (>) :: StarColumnNames a -> StarColumnNames a -> Bool # (>=) :: StarColumnNames a -> StarColumnNames a -> Bool # max :: StarColumnNames a -> StarColumnNames a -> StarColumnNames a # min :: StarColumnNames a -> StarColumnNames a -> StarColumnNames a #
Show a => Show (StarColumnNames a) Source #
Methods showsPrec :: Int -> StarColumnNames a -> ShowS # show :: StarColumnNames a -> String # showList :: [StarColumnNames a] -> ShowS #
Generic (StarColumnNames a) Source #
Associated Types type Rep (StarColumnNames a) :: * -> * # Methods from :: StarColumnNames a -> Rep (StarColumnNames a) x # to :: Rep (StarColumnNames a) x -> StarColumnNames a #
ToJSON a => ToJSON (StarColumnNames a) Source #
Methods toJSON :: StarColumnNames a -> Value # toEncoding :: StarColumnNames a -> Encoding # toJSONList :: [StarColumnNames a] -> Value # toEncodingList :: [StarColumnNames a] -> Encoding #
HasColumns (StarColumnNames a) Source #
Methods goColumns :: StarColumnNames a -> Observer Source #
type Rep (StarColumnNames a) Source #
type Rep (StarColumnNames a) = D1 * (MetaData "StarColumnNames" "Database.Sql.Type.Scope" "queryparser-0.1.0.1-L3r1ujeH5Ss7CLthXKM008" True) (C1 * (MetaCons "StarColumnNames" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [RColumnRef a])))

newtype ColumnAliasList a Source #

Constructors

ColumnAliasList [ColumnAlias a]

Instances

Functor ColumnAliasList Source #
Methods fmap :: (a -> b) -> ColumnAliasList a -> ColumnAliasList b # (<$) :: a -> ColumnAliasList b -> ColumnAliasList a #
Eq a => Eq (ColumnAliasList a) Source #
Methods (==) :: ColumnAliasList a -> ColumnAliasList a -> Bool # (/=) :: ColumnAliasList a -> ColumnAliasList a -> Bool #
Data a => Data (ColumnAliasList a) Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ColumnAliasList a -> c (ColumnAliasList a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ColumnAliasList a) # toConstr :: ColumnAliasList a -> Constr # dataTypeOf :: ColumnAliasList a -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c (ColumnAliasList a)) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ColumnAliasList a)) # gmapT :: (forall b. Data b => b -> b) -> ColumnAliasList a -> ColumnAliasList a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ColumnAliasList a -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ColumnAliasList a -> r # gmapQ :: (forall d. Data d => d -> u) -> ColumnAliasList a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ColumnAliasList a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ColumnAliasList a -> m (ColumnAliasList a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ColumnAliasList a -> m (ColumnAliasList a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ColumnAliasList a -> m (ColumnAliasList a) #
Ord a => Ord (ColumnAliasList a) Source #
Methods compare :: ColumnAliasList a -> ColumnAliasList a -> Ordering # (<) :: ColumnAliasList a -> ColumnAliasList a -> Bool # (<=) :: ColumnAliasList a -> ColumnAliasList a -> Bool # (>) :: ColumnAliasList a -> ColumnAliasList a -> Bool # (>=) :: ColumnAliasList a -> ColumnAliasList a -> Bool # max :: ColumnAliasList a -> ColumnAliasList a -> ColumnAliasList a # min :: ColumnAliasList a -> ColumnAliasList a -> ColumnAliasList a #
Show a => Show (ColumnAliasList a) Source #
Methods showsPrec :: Int -> ColumnAliasList a -> ShowS # show :: ColumnAliasList a -> String # showList :: [ColumnAliasList a] -> ShowS #
Generic (ColumnAliasList a) Source #
Associated Types type Rep (ColumnAliasList a) :: * -> * # Methods from :: ColumnAliasList a -> Rep (ColumnAliasList a) x # to :: Rep (ColumnAliasList a) x -> ColumnAliasList a #
ToJSON a => ToJSON (ColumnAliasList a) Source #
Methods toJSON :: ColumnAliasList a -> Value # toEncoding :: ColumnAliasList a -> Encoding # toJSONList :: [ColumnAliasList a] -> Value # toEncodingList :: [ColumnAliasList a] -> Encoding #
type Rep (ColumnAliasList a) Source #
type Rep (ColumnAliasList a) = D1 * (MetaData "ColumnAliasList" "Database.Sql.Type.Scope" "queryparser-0.1.0.1-L3r1ujeH5Ss7CLthXKM008" True) (C1 * (MetaCons "ColumnAliasList" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [ColumnAlias a])))

type Resolver r a = StateT Integer (ReaderT (ResolverInfo a) (CatalogObjectResolver a)) (r a) Source #

data SchemaMember Source #

Constructors

SchemaMember
Fields tableType :: TableType persistence :: Persistence () columnsList :: [UQColumnName ()] viewQuery :: Maybe (Query ResolvedNames ())

Instances

Eq SchemaMember Source #
Methods (==) :: SchemaMember -> SchemaMember -> Bool # (/=) :: SchemaMember -> SchemaMember -> Bool #
Data SchemaMember Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SchemaMember -> c SchemaMember # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SchemaMember # toConstr :: SchemaMember -> Constr # dataTypeOf :: SchemaMember -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c SchemaMember) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SchemaMember) # gmapT :: (forall b. Data b => b -> b) -> SchemaMember -> SchemaMember # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SchemaMember -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SchemaMember -> r # gmapQ :: (forall d. Data d => d -> u) -> SchemaMember -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SchemaMember -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SchemaMember -> m SchemaMember # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SchemaMember -> m SchemaMember # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SchemaMember -> m SchemaMember #
Ord SchemaMember Source #
Methods compare :: SchemaMember -> SchemaMember -> Ordering # (<) :: SchemaMember -> SchemaMember -> Bool # (<=) :: SchemaMember -> SchemaMember -> Bool # (>) :: SchemaMember -> SchemaMember -> Bool # (>=) :: SchemaMember -> SchemaMember -> Bool # max :: SchemaMember -> SchemaMember -> SchemaMember # min :: SchemaMember -> SchemaMember -> SchemaMember #
Show SchemaMember Source #
Methods showsPrec :: Int -> SchemaMember -> ShowS # show :: SchemaMember -> String # showList :: [SchemaMember] -> ShowS #
Generic SchemaMember Source #
Associated Types type Rep SchemaMember :: * -> * # Methods from :: SchemaMember -> Rep SchemaMember x # to :: Rep SchemaMember x -> SchemaMember #
Arbitrary CatalogMap Source #
Methods arbitrary :: Gen CatalogMap # shrink :: CatalogMap -> [CatalogMap] #
Arbitrary DatabaseMap Source #
Methods arbitrary :: Gen DatabaseMap # shrink :: DatabaseMap -> [DatabaseMap] #
Arbitrary SchemaMap Source #
Methods arbitrary :: Gen SchemaMap # shrink :: SchemaMap -> [SchemaMap] #
Arbitrary SchemaMember Source #
Methods arbitrary :: Gen SchemaMember # shrink :: SchemaMember -> [SchemaMember] #
type Rep SchemaMember Source #
type Rep SchemaMember = D1 * (MetaData "SchemaMember" "Database.Sql.Type.Scope" "queryparser-0.1.0.1-L3r1ujeH5Ss7CLthXKM008" False) (C1 * (MetaCons "SchemaMember" PrefixI True) ((::) ((::) (S1 * (MetaSel (Just Symbol "tableType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * TableType)) (S1 * (MetaSel (Just Symbol "persistence") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Persistence ())))) ((::) (S1 * (MetaSel (Just Symbol "columnsList") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [UQColumnName ()])) (S1 * (MetaSel (Just Symbol "viewQuery") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe (Query ResolvedNames ())))))))

persistentTable :: [UQColumnName ()] -> SchemaMember Source #

type SchemaMap = HashMap (UQTableName ()) SchemaMember Source #

type DatabaseMap = HashMap (UQSchemaName ()) SchemaMap Source #

type CatalogMap = HashMap (DatabaseName ()) DatabaseMap Source #

type Path = [UQSchemaName ()] Source #

type CurrentDatabase = DatabaseName () Source #

data Catalog Source #

Constructors

Catalog

Fields

catalogResolveSchemaName :: forall a. OQSchemaName a -> CatalogObjectResolver a (FQSchemaName a)
catalogResolveTableName :: forall a. OQTableName a -> CatalogObjectResolver a (RTableName a)
catalogHasDatabase :: DatabaseName () -> Existence
catalogHasSchema :: UQSchemaName () -> Existence
catalogHasTable :: UQTableName () -> Existence
catalogResolveTableRef :: forall a. [(TableAlias a, [RColumnRef a])] -> OQTableName a -> CatalogObjectResolver a (WithColumns RTableRef a)
nb DoesNotExist does not imply that we can't resolve to this name (defaulting)
catalogResolveCreateSchemaName :: forall a. OQSchemaName a -> CatalogObjectResolver a (RCreateSchemaName a)
catalogResolveCreateTableName :: forall a. OQTableName a -> CatalogObjectResolver a (RCreateTableName a)
catalogResolveColumnName :: forall a. [(Maybe (RTableRef a), [RColumnRef a])] -> OQColumnName a -> CatalogObjectResolver a (RColumnRef a)
overCatalogMap :: forall a. (CatalogMap -> (CatalogMap, a)) -> (Catalog, a)
catalogMap :: !CatalogMap
catalogWithPath :: Path -> Catalog
catalogWithDatabase :: CurrentDatabase -> Catalog

Instances

Eq Catalog Source #
Methods (==) :: Catalog -> Catalog -> Bool # (/=) :: Catalog -> Catalog -> Bool #
Show Catalog Source #
Methods showsPrec :: Int -> Catalog -> ShowS # show :: Catalog -> String # showList :: [Catalog] -> ShowS #

type CatalogObjectResolver a = ExceptT (ResolutionError a) (Writer [Either (ResolutionError a) (ResolutionSuccess a)]) Source #

data ResolutionError a Source #

Constructors

MissingDatabase (DatabaseName a)
MissingSchema (OQSchemaName a)
MissingTable (OQTableName a)
AmbiguousTable (OQTableName a)
MissingColumn (OQColumnName a)
AmbiguousColumn (OQColumnName a)
UnintroducedTable (OQTableName a)
UnexpectedTable (FQTableName a)
UnexpectedSchema (FQSchemaName a)
BadPositionalReference a Int

Instances

Functor ResolutionError Source #
Methods fmap :: (a -> b) -> ResolutionError a -> ResolutionError b # (<$) :: a -> ResolutionError b -> ResolutionError a #
Eq a => Eq (ResolutionError a) Source #
Methods (==) :: ResolutionError a -> ResolutionError a -> Bool # (/=) :: ResolutionError a -> ResolutionError a -> Bool #
Show a => Show (ResolutionError a) Source #
Methods showsPrec :: Int -> ResolutionError a -> ShowS # show :: ResolutionError a -> String # showList :: [ResolutionError a] -> ShowS #
HasSchemaChange (ResolutionError a) Source #
Methods getSchemaChange :: ResolutionError a -> [SchemaChange] Source #

data ResolutionSuccess a Source #

Constructors

TableNameResolved (OQTableName a) (RTableName a)
TableNameDefaulted (OQTableName a) (RTableName a)
CreateTableNameResolved (OQTableName a) (RCreateTableName a)
CreateSchemaNameResolved (OQSchemaName a) (RCreateSchemaName a)
TableRefResolved (OQTableName a) (RTableRef a)
TableRefDefaulted (OQTableName a) (RTableRef a)
ColumnRefResolved (OQColumnName a) (RColumnRef a)
ColumnRefDefaulted (OQColumnName a) (RColumnRef a)

Instances

Functor ResolutionSuccess Source #
Methods fmap :: (a -> b) -> ResolutionSuccess a -> ResolutionSuccess b # (<$) :: a -> ResolutionSuccess b -> ResolutionSuccess a #
Eq a => Eq (ResolutionSuccess a) Source #
Methods (==) :: ResolutionSuccess a -> ResolutionSuccess a -> Bool # (/=) :: ResolutionSuccess a -> ResolutionSuccess a -> Bool #
Show a => Show (ResolutionSuccess a) Source #
Methods showsPrec :: Int -> ResolutionSuccess a -> ShowS # show :: ResolutionSuccess a -> String # showList :: [ResolutionSuccess a] -> ShowS #
HasSchemaChange (ResolutionSuccess a) Source #
Methods getSchemaChange :: ResolutionSuccess a -> [SchemaChange] Source #

isGuess :: ResolutionSuccess a -> Bool Source #

isCertain :: ResolutionSuccess a -> Bool Source #

data WithColumns r a Source #

Constructors

WithColumns
Fields withColumnsValue :: r a withColumnsColumns :: ColumnSet a

data WithColumnsAndOrders r a Source #

Constructors

WithColumnsAndOrders (r a) (ColumnSet a) [Order ResolvedNames a]

data RTableRef a Source #

Constructors

RTableRef (FQTableName a) SchemaMember
RTableAlias (TableAlias a)

Instances

Functor RTableRef Source #
Methods fmap :: (a -> b) -> RTableRef a -> RTableRef b # (<$) :: a -> RTableRef b -> RTableRef a #
Foldable RTableRef Source #
Methods fold :: Monoid m => RTableRef m -> m # foldMap :: Monoid m => (a -> m) -> RTableRef a -> m # foldr :: (a -> b -> b) -> b -> RTableRef a -> b # foldr' :: (a -> b -> b) -> b -> RTableRef a -> b # foldl :: (b -> a -> b) -> b -> RTableRef a -> b # foldl' :: (b -> a -> b) -> b -> RTableRef a -> b # foldr1 :: (a -> a -> a) -> RTableRef a -> a # foldl1 :: (a -> a -> a) -> RTableRef a -> a # toList :: RTableRef a -> [a] # null :: RTableRef a -> Bool # length :: RTableRef a -> Int # elem :: Eq a => a -> RTableRef a -> Bool # maximum :: Ord a => RTableRef a -> a # minimum :: Ord a => RTableRef a -> a # sum :: Num a => RTableRef a -> a # product :: Num a => RTableRef a -> a #
Traversable RTableRef Source #
Methods traverse :: Applicative f => (a -> f b) -> RTableRef a -> f (RTableRef b) # sequenceA :: Applicative f => RTableRef (f a) -> f (RTableRef a) # mapM :: Monad m => (a -> m b) -> RTableRef a -> m (RTableRef b) # sequence :: Monad m => RTableRef (m a) -> m (RTableRef a) #
Eq a => Eq (RTableRef a) Source #
Methods (==) :: RTableRef a -> RTableRef a -> Bool # (/=) :: RTableRef a -> RTableRef a -> Bool #
Data a => Data (RTableRef a) Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RTableRef a -> c (RTableRef a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (RTableRef a) # toConstr :: RTableRef a -> Constr # dataTypeOf :: RTableRef a -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c (RTableRef a)) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (RTableRef a)) # gmapT :: (forall b. Data b => b -> b) -> RTableRef a -> RTableRef a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RTableRef a -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RTableRef a -> r # gmapQ :: (forall d. Data d => d -> u) -> RTableRef a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> RTableRef a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> RTableRef a -> m (RTableRef a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RTableRef a -> m (RTableRef a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RTableRef a -> m (RTableRef a) #
Ord a => Ord (RTableRef a) Source #
Methods compare :: RTableRef a -> RTableRef a -> Ordering # (<) :: RTableRef a -> RTableRef a -> Bool # (<=) :: RTableRef a -> RTableRef a -> Bool # (>) :: RTableRef a -> RTableRef a -> Bool # (>=) :: RTableRef a -> RTableRef a -> Bool # max :: RTableRef a -> RTableRef a -> RTableRef a # min :: RTableRef a -> RTableRef a -> RTableRef a #
Show a => Show (RTableRef a) Source #
Methods showsPrec :: Int -> RTableRef a -> ShowS # show :: RTableRef a -> String # showList :: [RTableRef a] -> ShowS #
Generic (RTableRef a) Source #
Associated Types type Rep (RTableRef a) :: * -> * # Methods from :: RTableRef a -> Rep (RTableRef a) x # to :: Rep (RTableRef a) x -> RTableRef a #
ToJSON a => ToJSON (RTableRef a) Source #
Methods toJSON :: RTableRef a -> Value # toEncoding :: RTableRef a -> Encoding # toJSONList :: [RTableRef a] -> Value # toEncodingList :: [RTableRef a] -> Encoding #
Semigroup a => HasInfo (RTableRef a) Source #
Associated Types type Info (RTableRef a) :: * Source # Methods getInfo :: RTableRef a -> Info (RTableRef a) Source #
type Rep (RTableRef a) Source #
type Rep (RTableRef a) = D1 * (MetaData "RTableRef" "Database.Sql.Type.Scope" "queryparser-0.1.0.1-L3r1ujeH5Ss7CLthXKM008" False) ((:+:) * (C1 * (MetaCons "RTableRef" PrefixI False) ((::) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (FQTableName a))) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * SchemaMember)))) (C1 * (MetaCons "RTableAlias" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (TableAlias a)))))
type Info (RTableRef a) Source #
type Info (RTableRef a) = a

resolvedTableHasName :: QTableName f a -> RTableRef a -> Bool Source #

resolvedTableHasSchema :: QSchemaName f a -> RTableRef a -> Bool Source #

resolvedTableHasDatabase :: DatabaseName a -> RTableRef a -> Bool Source #

data RTableName a Source #

Constructors

RTableName (FQTableName a) SchemaMember

Instances

Functor RTableName Source #
Methods fmap :: (a -> b) -> RTableName a -> RTableName b # (<$) :: a -> RTableName b -> RTableName a #
Foldable RTableName Source #
Methods fold :: Monoid m => RTableName m -> m # foldMap :: Monoid m => (a -> m) -> RTableName a -> m # foldr :: (a -> b -> b) -> b -> RTableName a -> b # foldr' :: (a -> b -> b) -> b -> RTableName a -> b # foldl :: (b -> a -> b) -> b -> RTableName a -> b # foldl' :: (b -> a -> b) -> b -> RTableName a -> b # foldr1 :: (a -> a -> a) -> RTableName a -> a # foldl1 :: (a -> a -> a) -> RTableName a -> a # toList :: RTableName a -> [a] # null :: RTableName a -> Bool # length :: RTableName a -> Int # elem :: Eq a => a -> RTableName a -> Bool # maximum :: Ord a => RTableName a -> a # minimum :: Ord a => RTableName a -> a # sum :: Num a => RTableName a -> a # product :: Num a => RTableName a -> a #
Traversable RTableName Source #
Methods traverse :: Applicative f => (a -> f b) -> RTableName a -> f (RTableName b) # sequenceA :: Applicative f => RTableName (f a) -> f (RTableName a) # mapM :: Monad m => (a -> m b) -> RTableName a -> m (RTableName b) # sequence :: Monad m => RTableName (m a) -> m (RTableName a) #
Eq a => Eq (RTableName a) Source #
Methods (==) :: RTableName a -> RTableName a -> Bool # (/=) :: RTableName a -> RTableName a -> Bool #
Data a => Data (RTableName a) Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RTableName a -> c (RTableName a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (RTableName a) # toConstr :: RTableName a -> Constr # dataTypeOf :: RTableName a -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c (RTableName a)) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (RTableName a)) # gmapT :: (forall b. Data b => b -> b) -> RTableName a -> RTableName a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RTableName a -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RTableName a -> r # gmapQ :: (forall d. Data d => d -> u) -> RTableName a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> RTableName a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> RTableName a -> m (RTableName a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RTableName a -> m (RTableName a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RTableName a -> m (RTableName a) #
Ord a => Ord (RTableName a) Source #
Methods compare :: RTableName a -> RTableName a -> Ordering # (<) :: RTableName a -> RTableName a -> Bool # (<=) :: RTableName a -> RTableName a -> Bool # (>) :: RTableName a -> RTableName a -> Bool # (>=) :: RTableName a -> RTableName a -> Bool # max :: RTableName a -> RTableName a -> RTableName a # min :: RTableName a -> RTableName a -> RTableName a #
Show a => Show (RTableName a) Source #
Methods showsPrec :: Int -> RTableName a -> ShowS # show :: RTableName a -> String # showList :: [RTableName a] -> ShowS #
Generic (RTableName a) Source #
Associated Types type Rep (RTableName a) :: * -> * # Methods from :: RTableName a -> Rep (RTableName a) x # to :: Rep (RTableName a) x -> RTableName a #
ToJSON a => ToJSON (RTableName a) Source #
Methods toJSON :: RTableName a -> Value # toEncoding :: RTableName a -> Encoding # toJSONList :: [RTableName a] -> Value # toEncodingList :: [RTableName a] -> Encoding #
HasTables (RTableName a) Source #
Methods goTables :: RTableName a -> ReaderT * UsageMode (Writer (Set TableUse)) () Source #
Semigroup a => HasInfo (RTableName a) Source #
Associated Types type Info (RTableName a) :: * Source # Methods getInfo :: RTableName a -> Info (RTableName a) Source #
type Rep (RTableName a) Source #
type Rep (RTableName a) = D1 * (MetaData "RTableName" "Database.Sql.Type.Scope" "queryparser-0.1.0.1-L3r1ujeH5Ss7CLthXKM008" False) (C1 * (MetaCons "RTableName" PrefixI False) ((::) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (FQTableName a))) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * SchemaMember))))
type Info (RTableName a) Source #
type Info (RTableName a) = a

data RDropTableName a Source #

Constructors

RDropExistingTableName (FQTableName a) SchemaMember
RDropMissingTableName (OQTableName a)

Instances

Functor RDropTableName Source #
Methods fmap :: (a -> b) -> RDropTableName a -> RDropTableName b # (<$) :: a -> RDropTableName b -> RDropTableName a #
Foldable RDropTableName Source #
Methods fold :: Monoid m => RDropTableName m -> m # foldMap :: Monoid m => (a -> m) -> RDropTableName a -> m # foldr :: (a -> b -> b) -> b -> RDropTableName a -> b # foldr' :: (a -> b -> b) -> b -> RDropTableName a -> b # foldl :: (b -> a -> b) -> b -> RDropTableName a -> b # foldl' :: (b -> a -> b) -> b -> RDropTableName a -> b # foldr1 :: (a -> a -> a) -> RDropTableName a -> a # foldl1 :: (a -> a -> a) -> RDropTableName a -> a # toList :: RDropTableName a -> [a] # null :: RDropTableName a -> Bool # length :: RDropTableName a -> Int # elem :: Eq a => a -> RDropTableName a -> Bool # maximum :: Ord a => RDropTableName a -> a # minimum :: Ord a => RDropTableName a -> a # sum :: Num a => RDropTableName a -> a # product :: Num a => RDropTableName a -> a #
Traversable RDropTableName Source #
Methods traverse :: Applicative f => (a -> f b) -> RDropTableName a -> f (RDropTableName b) # sequenceA :: Applicative f => RDropTableName (f a) -> f (RDropTableName a) # mapM :: Monad m => (a -> m b) -> RDropTableName a -> m (RDropTableName b) # sequence :: Monad m => RDropTableName (m a) -> m (RDropTableName a) #
Eq a => Eq (RDropTableName a) Source #
Methods (==) :: RDropTableName a -> RDropTableName a -> Bool # (/=) :: RDropTableName a -> RDropTableName a -> Bool #
Data a => Data (RDropTableName a) Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RDropTableName a -> c (RDropTableName a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (RDropTableName a) # toConstr :: RDropTableName a -> Constr # dataTypeOf :: RDropTableName a -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c (RDropTableName a)) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (RDropTableName a)) # gmapT :: (forall b. Data b => b -> b) -> RDropTableName a -> RDropTableName a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RDropTableName a -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RDropTableName a -> r # gmapQ :: (forall d. Data d => d -> u) -> RDropTableName a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> RDropTableName a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> RDropTableName a -> m (RDropTableName a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RDropTableName a -> m (RDropTableName a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RDropTableName a -> m (RDropTableName a) #
Ord a => Ord (RDropTableName a) Source #
Methods compare :: RDropTableName a -> RDropTableName a -> Ordering # (<) :: RDropTableName a -> RDropTableName a -> Bool # (<=) :: RDropTableName a -> RDropTableName a -> Bool # (>) :: RDropTableName a -> RDropTableName a -> Bool # (>=) :: RDropTableName a -> RDropTableName a -> Bool # max :: RDropTableName a -> RDropTableName a -> RDropTableName a # min :: RDropTableName a -> RDropTableName a -> RDropTableName a #
Show a => Show (RDropTableName a) Source #
Methods showsPrec :: Int -> RDropTableName a -> ShowS # show :: RDropTableName a -> String # showList :: [RDropTableName a] -> ShowS #
Generic (RDropTableName a) Source #
Associated Types type Rep (RDropTableName a) :: * -> * # Methods from :: RDropTableName a -> Rep (RDropTableName a) x # to :: Rep (RDropTableName a) x -> RDropTableName a #
ToJSON a => ToJSON (RDropTableName a) Source #
Methods toJSON :: RDropTableName a -> Value # toEncoding :: RDropTableName a -> Encoding # toJSONList :: [RDropTableName a] -> Value # toEncodingList :: [RDropTableName a] -> Encoding #
type Rep (RDropTableName a) Source #
type Rep (RDropTableName a) = D1 * (MetaData "RDropTableName" "Database.Sql.Type.Scope" "queryparser-0.1.0.1-L3r1ujeH5Ss7CLthXKM008" False) ((:+:) * (C1 * (MetaCons "RDropExistingTableName" PrefixI False) ((::) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (FQTableName a))) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * SchemaMember)))) (C1 * (MetaCons "RDropMissingTableName" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (OQTableName a)))))

data RCreateTableName a Source #

Constructors

RCreateTableName (FQTableName a) Existence

Instances

Functor RCreateTableName Source #
Methods fmap :: (a -> b) -> RCreateTableName a -> RCreateTableName b # (<$) :: a -> RCreateTableName b -> RCreateTableName a #
Foldable RCreateTableName Source #
Methods fold :: Monoid m => RCreateTableName m -> m # foldMap :: Monoid m => (a -> m) -> RCreateTableName a -> m # foldr :: (a -> b -> b) -> b -> RCreateTableName a -> b # foldr' :: (a -> b -> b) -> b -> RCreateTableName a -> b # foldl :: (b -> a -> b) -> b -> RCreateTableName a -> b # foldl' :: (b -> a -> b) -> b -> RCreateTableName a -> b # foldr1 :: (a -> a -> a) -> RCreateTableName a -> a # foldl1 :: (a -> a -> a) -> RCreateTableName a -> a # toList :: RCreateTableName a -> [a] # null :: RCreateTableName a -> Bool # length :: RCreateTableName a -> Int # elem :: Eq a => a -> RCreateTableName a -> Bool # maximum :: Ord a => RCreateTableName a -> a # minimum :: Ord a => RCreateTableName a -> a # sum :: Num a => RCreateTableName a -> a # product :: Num a => RCreateTableName a -> a #
Traversable RCreateTableName Source #
Methods traverse :: Applicative f => (a -> f b) -> RCreateTableName a -> f (RCreateTableName b) # sequenceA :: Applicative f => RCreateTableName (f a) -> f (RCreateTableName a) # mapM :: Monad m => (a -> m b) -> RCreateTableName a -> m (RCreateTableName b) # sequence :: Monad m => RCreateTableName (m a) -> m (RCreateTableName a) #
Eq a => Eq (RCreateTableName a) Source #
Methods (==) :: RCreateTableName a -> RCreateTableName a -> Bool # (/=) :: RCreateTableName a -> RCreateTableName a -> Bool #
Data a => Data (RCreateTableName a) Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RCreateTableName a -> c (RCreateTableName a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (RCreateTableName a) # toConstr :: RCreateTableName a -> Constr # dataTypeOf :: RCreateTableName a -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c (RCreateTableName a)) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (RCreateTableName a)) # gmapT :: (forall b. Data b => b -> b) -> RCreateTableName a -> RCreateTableName a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RCreateTableName a -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RCreateTableName a -> r # gmapQ :: (forall d. Data d => d -> u) -> RCreateTableName a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> RCreateTableName a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> RCreateTableName a -> m (RCreateTableName a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RCreateTableName a -> m (RCreateTableName a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RCreateTableName a -> m (RCreateTableName a) #
Ord a => Ord (RCreateTableName a) Source #
Methods compare :: RCreateTableName a -> RCreateTableName a -> Ordering # (<) :: RCreateTableName a -> RCreateTableName a -> Bool # (<=) :: RCreateTableName a -> RCreateTableName a -> Bool # (>) :: RCreateTableName a -> RCreateTableName a -> Bool # (>=) :: RCreateTableName a -> RCreateTableName a -> Bool # max :: RCreateTableName a -> RCreateTableName a -> RCreateTableName a # min :: RCreateTableName a -> RCreateTableName a -> RCreateTableName a #
Show a => Show (RCreateTableName a) Source #
Methods showsPrec :: Int -> RCreateTableName a -> ShowS # show :: RCreateTableName a -> String # showList :: [RCreateTableName a] -> ShowS #
Generic (RCreateTableName a) Source #
Associated Types type Rep (RCreateTableName a) :: * -> * # Methods from :: RCreateTableName a -> Rep (RCreateTableName a) x # to :: Rep (RCreateTableName a) x -> RCreateTableName a #
ToJSON a => ToJSON (RCreateTableName a) Source #
Methods toJSON :: RCreateTableName a -> Value # toEncoding :: RCreateTableName a -> Encoding # toJSONList :: [RCreateTableName a] -> Value # toEncodingList :: [RCreateTableName a] -> Encoding #
type Rep (RCreateTableName a) Source #
type Rep (RCreateTableName a) = D1 * (MetaData "RCreateTableName" "Database.Sql.Type.Scope" "queryparser-0.1.0.1-L3r1ujeH5Ss7CLthXKM008" False) (C1 * (MetaCons "RCreateTableName" PrefixI False) ((::) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (FQTableName a))) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Existence))))

data RCreateSchemaName a Source #

Constructors

RCreateSchemaName (FQSchemaName a) Existence

Instances

Functor RCreateSchemaName Source #
Methods fmap :: (a -> b) -> RCreateSchemaName a -> RCreateSchemaName b # (<$) :: a -> RCreateSchemaName b -> RCreateSchemaName a #
Foldable RCreateSchemaName Source #
Methods fold :: Monoid m => RCreateSchemaName m -> m # foldMap :: Monoid m => (a -> m) -> RCreateSchemaName a -> m # foldr :: (a -> b -> b) -> b -> RCreateSchemaName a -> b # foldr' :: (a -> b -> b) -> b -> RCreateSchemaName a -> b # foldl :: (b -> a -> b) -> b -> RCreateSchemaName a -> b # foldl' :: (b -> a -> b) -> b -> RCreateSchemaName a -> b # foldr1 :: (a -> a -> a) -> RCreateSchemaName a -> a # foldl1 :: (a -> a -> a) -> RCreateSchemaName a -> a # toList :: RCreateSchemaName a -> [a] # null :: RCreateSchemaName a -> Bool # length :: RCreateSchemaName a -> Int # elem :: Eq a => a -> RCreateSchemaName a -> Bool # maximum :: Ord a => RCreateSchemaName a -> a # minimum :: Ord a => RCreateSchemaName a -> a # sum :: Num a => RCreateSchemaName a -> a # product :: Num a => RCreateSchemaName a -> a #
Traversable RCreateSchemaName Source #
Methods traverse :: Applicative f => (a -> f b) -> RCreateSchemaName a -> f (RCreateSchemaName b) # sequenceA :: Applicative f => RCreateSchemaName (f a) -> f (RCreateSchemaName a) # mapM :: Monad m => (a -> m b) -> RCreateSchemaName a -> m (RCreateSchemaName b) # sequence :: Monad m => RCreateSchemaName (m a) -> m (RCreateSchemaName a) #
Eq a => Eq (RCreateSchemaName a) Source #
Methods (==) :: RCreateSchemaName a -> RCreateSchemaName a -> Bool # (/=) :: RCreateSchemaName a -> RCreateSchemaName a -> Bool #
Data a => Data (RCreateSchemaName a) Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RCreateSchemaName a -> c (RCreateSchemaName a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (RCreateSchemaName a) # toConstr :: RCreateSchemaName a -> Constr # dataTypeOf :: RCreateSchemaName a -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c (RCreateSchemaName a)) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (RCreateSchemaName a)) # gmapT :: (forall b. Data b => b -> b) -> RCreateSchemaName a -> RCreateSchemaName a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RCreateSchemaName a -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RCreateSchemaName a -> r # gmapQ :: (forall d. Data d => d -> u) -> RCreateSchemaName a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> RCreateSchemaName a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> RCreateSchemaName a -> m (RCreateSchemaName a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RCreateSchemaName a -> m (RCreateSchemaName a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RCreateSchemaName a -> m (RCreateSchemaName a) #
Ord a => Ord (RCreateSchemaName a) Source #
Methods compare :: RCreateSchemaName a -> RCreateSchemaName a -> Ordering # (<) :: RCreateSchemaName a -> RCreateSchemaName a -> Bool # (<=) :: RCreateSchemaName a -> RCreateSchemaName a -> Bool # (>) :: RCreateSchemaName a -> RCreateSchemaName a -> Bool # (>=) :: RCreateSchemaName a -> RCreateSchemaName a -> Bool # max :: RCreateSchemaName a -> RCreateSchemaName a -> RCreateSchemaName a # min :: RCreateSchemaName a -> RCreateSchemaName a -> RCreateSchemaName a #
Show a => Show (RCreateSchemaName a) Source #
Methods showsPrec :: Int -> RCreateSchemaName a -> ShowS # show :: RCreateSchemaName a -> String # showList :: [RCreateSchemaName a] -> ShowS #
Generic (RCreateSchemaName a) Source #
Associated Types type Rep (RCreateSchemaName a) :: * -> * # Methods from :: RCreateSchemaName a -> Rep (RCreateSchemaName a) x # to :: Rep (RCreateSchemaName a) x -> RCreateSchemaName a #
ToJSON a => ToJSON (RCreateSchemaName a) Source #
Methods toJSON :: RCreateSchemaName a -> Value # toEncoding :: RCreateSchemaName a -> Encoding # toJSONList :: [RCreateSchemaName a] -> Value # toEncodingList :: [RCreateSchemaName a] -> Encoding #
type Rep (RCreateSchemaName a) Source #
type Rep (RCreateSchemaName a) = D1 * (MetaData "RCreateSchemaName" "Database.Sql.Type.Scope" "queryparser-0.1.0.1-L3r1ujeH5Ss7CLthXKM008" False) (C1 * (MetaCons "RCreateSchemaName" PrefixI False) ((::) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (FQSchemaName a))) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Existence))))

shrinkHashMap :: (Eq k, Hashable k) => forall v. HashMap k v -> [HashMap k v] Source #