queryparser-0.1.0.1: Analysis and parsing library for SQL queries.

Safe HaskellNone
LanguageHaskell2010

Database.Sql.Type.Query

Documentation

data Query r a Source #

Constructors

QuerySelect a (Select r a) 
QueryExcept a (ComposedQueryColumns r a) (Query r a) (Query r a) 
QueryUnion a Distinct (ComposedQueryColumns r a) (Query r a) (Query r a) 
QueryIntersect a (ComposedQueryColumns r a) (Query r a) (Query r a) 
QueryWith a [CTE r a] (Query r a) 
QueryOrder a [Order r a] (Query r a) 
QueryLimit a (Limit a) (Query r a) 
QueryOffset a (Offset a) (Query r a) 

Instances

Evaluation e => Evaluate e (Query ResolvedNames Range) Source # 
ConstrainSASNames Functor r => Functor (Query r) Source # 

Methods

fmap :: (a -> b) -> Query r a -> Query r b #

(<$) :: a -> Query r b -> Query r a #

ConstrainSASNames Foldable r => Foldable (Query r) Source # 

Methods

fold :: Monoid m => Query r m -> m #

foldMap :: Monoid m => (a -> m) -> Query r a -> m #

foldr :: (a -> b -> b) -> b -> Query r a -> b #

foldr' :: (a -> b -> b) -> b -> Query r a -> b #

foldl :: (b -> a -> b) -> b -> Query r a -> b #

foldl' :: (b -> a -> b) -> b -> Query r a -> b #

foldr1 :: (a -> a -> a) -> Query r a -> a #

foldl1 :: (a -> a -> a) -> Query r a -> a #

toList :: Query r a -> [a] #

null :: Query r a -> Bool #

length :: Query r a -> Int #

elem :: Eq a => a -> Query r a -> Bool #

maximum :: Ord a => Query r a -> a #

minimum :: Ord a => Query r a -> a #

sum :: Num a => Query r a -> a #

product :: Num a => Query r a -> a #

ConstrainSASNames Traversable r => Traversable (Query r) Source # 

Methods

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

sequenceA :: Applicative f => Query r (f a) -> f (Query r a) #

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

sequence :: Monad m => Query r (m a) -> m (Query r a) #

ConstrainSNames Eq r a => Eq (Query r a) Source # 

Methods

(==) :: Query r a -> Query r a -> Bool #

(/=) :: Query r a -> Query r a -> Bool #

(ConstrainSNames Data r a, Data r) => Data (Query r a) Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Query r a -> c (Query r a) #

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

toConstr :: Query r a -> Constr #

dataTypeOf :: Query r a -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Query r a)) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Query r a)) #

gmapT :: (forall b. Data b => b -> b) -> Query r a -> Query r a #

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

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

gmapQ :: (forall d. Data d => d -> u) -> Query r a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Query r a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Query r a -> m (Query r a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Query r a -> m (Query r a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Query r a -> m (Query r a) #

ConstrainSNames Ord r a => Ord (Query r a) Source # 

Methods

compare :: Query r a -> Query r a -> Ordering #

(<) :: Query r a -> Query r a -> Bool #

(<=) :: Query r a -> Query r a -> Bool #

(>) :: Query r a -> Query r a -> Bool #

(>=) :: Query r a -> Query r a -> Bool #

max :: Query r a -> Query r a -> Query r a #

min :: Query r a -> Query r a -> Query r a #

ConstrainSNames Show r a => Show (Query r a) Source # 

Methods

showsPrec :: Int -> Query r a -> ShowS #

show :: Query r a -> String #

showList :: [Query r a] -> ShowS #

Generic (Query r a) Source # 

Associated Types

type Rep (Query r a) :: * -> * #

Methods

from :: Query r a -> Rep (Query r a) x #

to :: Rep (Query r a) x -> Query r a #

ConstrainSNames ToJSON r a => ToJSON (Query r a) Source # 

Methods

toJSON :: Query r a -> Value #

toEncoding :: Query r a -> Encoding #

toJSONList :: [Query r a] -> Value #

toEncodingList :: [Query r a] -> Encoding #

ConstrainSNames FromJSON r a => FromJSON (Query r a) Source # 

Methods

parseJSON :: Value -> Parser (Query r a) #

parseJSONList :: Value -> Parser [Query r a] #

HasTables (Query ResolvedNames a) Source # 
HasColumns (Query ResolvedNames a) Source # 

Methods

goColumns :: Query ResolvedNames a -> Observer Source #

HasInfo (Query r a) Source # 

Associated Types

type Info (Query r a) :: * Source #

Methods

getInfo :: Query r a -> Info (Query r a) Source #

type EvalResult e (Query ResolvedNames Range) Source # 
type Rep (Query r a) Source # 
type Rep (Query r a) = D1 * (MetaData "Query" "Database.Sql.Type.Query" "queryparser-0.1.0.1-L3r1ujeH5Ss7CLthXKM008" False) ((:+:) * ((:+:) * ((:+:) * (C1 * (MetaCons "QuerySelect" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Select r a))))) (C1 * (MetaCons "QueryExcept" PrefixI False) ((:*:) * ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (ComposedQueryColumns r a)))) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Query r a))) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Query r a))))))) ((:+:) * (C1 * (MetaCons "QueryUnion" PrefixI False) ((:*:) * ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Distinct))) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (ComposedQueryColumns r a))) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Query r a))) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Query r a))))))) (C1 * (MetaCons "QueryIntersect" PrefixI False) ((:*:) * ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (ComposedQueryColumns r a)))) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Query r a))) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Query r a)))))))) ((:+:) * ((:+:) * (C1 * (MetaCons "QueryWith" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a)) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [CTE r a])) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Query r a)))))) (C1 * (MetaCons "QueryOrder" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a)) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [Order r a])) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Query r a))))))) ((:+:) * (C1 * (MetaCons "QueryLimit" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a)) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Limit a))) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Query r a)))))) (C1 * (MetaCons "QueryOffset" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a)) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Offset a))) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Query r a)))))))))
type Info (Query r a) Source # 
type Info (Query r a) = a

newtype Distinct Source #

Constructors

Distinct Bool 

Instances

Eq Distinct Source # 
Data Distinct Source # 

Methods

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

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

toConstr :: Distinct -> Constr #

dataTypeOf :: Distinct -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord Distinct Source # 
Show Distinct Source # 
Generic Distinct Source # 

Associated Types

type Rep Distinct :: * -> * #

Methods

from :: Distinct -> Rep Distinct x #

to :: Rep Distinct x -> Distinct #

Arbitrary Distinct Source # 
ToJSON Distinct Source # 
FromJSON Distinct Source # 
type Rep Distinct Source # 
type Rep Distinct = D1 * (MetaData "Distinct" "Database.Sql.Type.Query" "queryparser-0.1.0.1-L3r1ujeH5Ss7CLthXKM008" True) (C1 * (MetaCons "Distinct" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Bool)))

data CTE r a Source #

Constructors

CTE 

Fields

Instances

ConstrainSASNames Functor r => Functor (CTE r) Source # 

Methods

fmap :: (a -> b) -> CTE r a -> CTE r b #

(<$) :: a -> CTE r b -> CTE r a #

ConstrainSASNames Foldable r => Foldable (CTE r) Source # 

Methods

fold :: Monoid m => CTE r m -> m #

foldMap :: Monoid m => (a -> m) -> CTE r a -> m #

foldr :: (a -> b -> b) -> b -> CTE r a -> b #

foldr' :: (a -> b -> b) -> b -> CTE r a -> b #

foldl :: (b -> a -> b) -> b -> CTE r a -> b #

foldl' :: (b -> a -> b) -> b -> CTE r a -> b #

foldr1 :: (a -> a -> a) -> CTE r a -> a #

foldl1 :: (a -> a -> a) -> CTE r a -> a #

toList :: CTE r a -> [a] #

null :: CTE r a -> Bool #

length :: CTE r a -> Int #

elem :: Eq a => a -> CTE r a -> Bool #

maximum :: Ord a => CTE r a -> a #

minimum :: Ord a => CTE r a -> a #

sum :: Num a => CTE r a -> a #

product :: Num a => CTE r a -> a #

ConstrainSASNames Traversable r => Traversable (CTE r) Source # 

Methods

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

sequenceA :: Applicative f => CTE r (f a) -> f (CTE r a) #

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

sequence :: Monad m => CTE r (m a) -> m (CTE r a) #

ConstrainSNames Eq r a => Eq (CTE r a) Source # 

Methods

(==) :: CTE r a -> CTE r a -> Bool #

(/=) :: CTE r a -> CTE r a -> Bool #

(ConstrainSNames Data r a, Data r) => Data (CTE r a) Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CTE r a -> c (CTE r a) #

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

toConstr :: CTE r a -> Constr #

dataTypeOf :: CTE r a -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (CTE r a)) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (CTE r a)) #

gmapT :: (forall b. Data b => b -> b) -> CTE r a -> CTE r a #

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

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

gmapQ :: (forall d. Data d => d -> u) -> CTE r a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> CTE r a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> CTE r a -> m (CTE r a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CTE r a -> m (CTE r a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CTE r a -> m (CTE r a) #

ConstrainSNames Ord r a => Ord (CTE r a) Source # 

Methods

compare :: CTE r a -> CTE r a -> Ordering #

(<) :: CTE r a -> CTE r a -> Bool #

(<=) :: CTE r a -> CTE r a -> Bool #

(>) :: CTE r a -> CTE r a -> Bool #

(>=) :: CTE r a -> CTE r a -> Bool #

max :: CTE r a -> CTE r a -> CTE r a #

min :: CTE r a -> CTE r a -> CTE r a #

ConstrainSNames Show r a => Show (CTE r a) Source # 

Methods

showsPrec :: Int -> CTE r a -> ShowS #

show :: CTE r a -> String #

showList :: [CTE r a] -> ShowS #

Generic (CTE r a) Source # 

Associated Types

type Rep (CTE r a) :: * -> * #

Methods

from :: CTE r a -> Rep (CTE r a) x #

to :: Rep (CTE r a) x -> CTE r a #

ConstrainSNames ToJSON r a => ToJSON (CTE r a) Source # 

Methods

toJSON :: CTE r a -> Value #

toEncoding :: CTE r a -> Encoding #

toJSONList :: [CTE r a] -> Value #

toEncodingList :: [CTE r a] -> Encoding #

ConstrainSNames FromJSON r a => FromJSON (CTE r a) Source # 

Methods

parseJSON :: Value -> Parser (CTE r a) #

parseJSONList :: Value -> Parser [CTE r a] #

HasColumns (CTE ResolvedNames a) Source # 

Methods

goColumns :: CTE ResolvedNames a -> Observer Source #

type Rep (CTE r a) Source # 
type Rep (CTE r a) = D1 * (MetaData "CTE" "Database.Sql.Type.Query" "queryparser-0.1.0.1-L3r1ujeH5Ss7CLthXKM008" False) (C1 * (MetaCons "CTE" PrefixI True) ((:*:) * ((:*:) * (S1 * (MetaSel (Just Symbol "cteInfo") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a)) (S1 * (MetaSel (Just Symbol "cteAlias") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (TableAlias a)))) ((:*:) * (S1 * (MetaSel (Just Symbol "cteColumns") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [ColumnAlias a])) (S1 * (MetaSel (Just Symbol "cteQuery") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Query r a))))))

data Select r a Source #

Instances

Evaluation e => Evaluate e (Select ResolvedNames Range) Source # 
ConstrainSASNames Functor r => Functor (Select r) Source # 

Methods

fmap :: (a -> b) -> Select r a -> Select r b #

(<$) :: a -> Select r b -> Select r a #

ConstrainSASNames Foldable r => Foldable (Select r) Source # 

Methods

fold :: Monoid m => Select r m -> m #

foldMap :: Monoid m => (a -> m) -> Select r a -> m #

foldr :: (a -> b -> b) -> b -> Select r a -> b #

foldr' :: (a -> b -> b) -> b -> Select r a -> b #

foldl :: (b -> a -> b) -> b -> Select r a -> b #

foldl' :: (b -> a -> b) -> b -> Select r a -> b #

foldr1 :: (a -> a -> a) -> Select r a -> a #

foldl1 :: (a -> a -> a) -> Select r a -> a #

toList :: Select r a -> [a] #

null :: Select r a -> Bool #

length :: Select r a -> Int #

elem :: Eq a => a -> Select r a -> Bool #

maximum :: Ord a => Select r a -> a #

minimum :: Ord a => Select r a -> a #

sum :: Num a => Select r a -> a #

product :: Num a => Select r a -> a #

ConstrainSASNames Traversable r => Traversable (Select r) Source # 

Methods

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

sequenceA :: Applicative f => Select r (f a) -> f (Select r a) #

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

sequence :: Monad m => Select r (m a) -> m (Select r a) #

ConstrainSNames Eq r a => Eq (Select r a) Source # 

Methods

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

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

(ConstrainSNames Data r a, Data r) => Data (Select r a) Source # 

Methods

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

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

toConstr :: Select r a -> Constr #

dataTypeOf :: Select r a -> DataType #

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

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

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

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

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

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

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

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

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

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

ConstrainSNames Ord r a => Ord (Select r a) Source # 

Methods

compare :: Select r a -> Select r a -> Ordering #

(<) :: Select r a -> Select r a -> Bool #

(<=) :: Select r a -> Select r a -> Bool #

(>) :: Select r a -> Select r a -> Bool #

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

max :: Select r a -> Select r a -> Select r a #

min :: Select r a -> Select r a -> Select r a #

ConstrainSNames Show r a => Show (Select r a) Source # 

Methods

showsPrec :: Int -> Select r a -> ShowS #

show :: Select r a -> String #

showList :: [Select r a] -> ShowS #

Generic (Select r a) Source # 

Associated Types

type Rep (Select r a) :: * -> * #

Methods

from :: Select r a -> Rep (Select r a) x #

to :: Rep (Select r a) x -> Select r a #

ConstrainSNames ToJSON r a => ToJSON (Select r a) Source # 

Methods

toJSON :: Select r a -> Value #

toEncoding :: Select r a -> Encoding #

toJSONList :: [Select r a] -> Value #

toEncodingList :: [Select r a] -> Encoding #

ConstrainSNames FromJSON r a => FromJSON (Select r a) Source # 

Methods

parseJSON :: Value -> Parser (Select r a) #

parseJSONList :: Value -> Parser [Select r a] #

HasTables (Select ResolvedNames a) Source # 
HasColumns (Select ResolvedNames a) Source # 

Methods

goColumns :: Select ResolvedNames a -> Observer Source #

HasInfo (Select r a) Source # 

Associated Types

type Info (Select r a) :: * Source #

Methods

getInfo :: Select r a -> Info (Select r a) Source #

type EvalResult e (Select ResolvedNames Range) Source # 
type Rep (Select r a) Source # 
type Info (Select r a) Source # 
type Info (Select r a) = a

data SelectColumns r a Source #

Constructors

SelectColumns 

Instances

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.

ConstrainSASNames Functor r => Functor (SelectColumns r) Source # 

Methods

fmap :: (a -> b) -> SelectColumns r a -> SelectColumns r b #

(<$) :: a -> SelectColumns r b -> SelectColumns r a #

ConstrainSASNames Foldable r => Foldable (SelectColumns r) Source # 

Methods

fold :: Monoid m => SelectColumns r m -> m #

foldMap :: Monoid m => (a -> m) -> SelectColumns r a -> m #

foldr :: (a -> b -> b) -> b -> SelectColumns r a -> b #

foldr' :: (a -> b -> b) -> b -> SelectColumns r a -> b #

foldl :: (b -> a -> b) -> b -> SelectColumns r a -> b #

foldl' :: (b -> a -> b) -> b -> SelectColumns r a -> b #

foldr1 :: (a -> a -> a) -> SelectColumns r a -> a #

foldl1 :: (a -> a -> a) -> SelectColumns r a -> a #

toList :: SelectColumns r a -> [a] #

null :: SelectColumns r a -> Bool #

length :: SelectColumns r a -> Int #

elem :: Eq a => a -> SelectColumns r a -> Bool #

maximum :: Ord a => SelectColumns r a -> a #

minimum :: Ord a => SelectColumns r a -> a #

sum :: Num a => SelectColumns r a -> a #

product :: Num a => SelectColumns r a -> a #

ConstrainSASNames Traversable r => Traversable (SelectColumns r) Source # 

Methods

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

sequenceA :: Applicative f => SelectColumns r (f a) -> f (SelectColumns r a) #

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

sequence :: Monad m => SelectColumns r (m a) -> m (SelectColumns r a) #

ConstrainSNames Eq r a => Eq (SelectColumns r a) Source # 

Methods

(==) :: SelectColumns r a -> SelectColumns r a -> Bool #

(/=) :: SelectColumns r a -> SelectColumns r a -> Bool #

(ConstrainSNames Data r a, Data r) => Data (SelectColumns r a) Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SelectColumns r a -> c (SelectColumns r a) #

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

toConstr :: SelectColumns r a -> Constr #

dataTypeOf :: SelectColumns r a -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (SelectColumns r a)) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (SelectColumns r a)) #

gmapT :: (forall b. Data b => b -> b) -> SelectColumns r a -> SelectColumns r a #

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

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

gmapQ :: (forall d. Data d => d -> u) -> SelectColumns r a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> SelectColumns r a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> SelectColumns r a -> m (SelectColumns r a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SelectColumns r a -> m (SelectColumns r a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SelectColumns r a -> m (SelectColumns r a) #

ConstrainSNames Ord r a => Ord (SelectColumns r a) Source # 
ConstrainSNames Show r a => Show (SelectColumns r a) Source # 
Generic (SelectColumns r a) Source # 

Associated Types

type Rep (SelectColumns r a) :: * -> * #

Methods

from :: SelectColumns r a -> Rep (SelectColumns r a) x #

to :: Rep (SelectColumns r a) x -> SelectColumns r a #

ConstrainSNames ToJSON r a => ToJSON (SelectColumns r a) Source # 
ConstrainSNames FromJSON r a => FromJSON (SelectColumns r a) Source # 
HasTables (SelectColumns ResolvedNames a) Source # 
HasColumns (SelectColumns ResolvedNames a) Source # 

Methods

goColumns :: SelectColumns ResolvedNames a -> Observer Source #

HasInfo (SelectColumns r a) Source # 

Associated Types

type Info (SelectColumns r a) :: * Source #

type EvalResult e (SelectColumns ResolvedNames Range) Source # 
type Rep (SelectColumns r a) Source # 
type Rep (SelectColumns r a) = D1 * (MetaData "SelectColumns" "Database.Sql.Type.Query" "queryparser-0.1.0.1-L3r1ujeH5Ss7CLthXKM008" False) (C1 * (MetaCons "SelectColumns" PrefixI True) ((:*:) * (S1 * (MetaSel (Just Symbol "selectColumnsInfo") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a)) (S1 * (MetaSel (Just Symbol "selectColumnsList") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [Selection r a]))))
type Info (SelectColumns r a) Source # 
type Info (SelectColumns r a) = a

data SelectFrom r a Source #

Constructors

SelectFrom a [Tablish r a] 

Instances

Evaluation e => Evaluate e (SelectFrom ResolvedNames Range) Source # 
ConstrainSASNames Functor r => Functor (SelectFrom r) Source # 

Methods

fmap :: (a -> b) -> SelectFrom r a -> SelectFrom r b #

(<$) :: a -> SelectFrom r b -> SelectFrom r a #

ConstrainSASNames Foldable r => Foldable (SelectFrom r) Source # 

Methods

fold :: Monoid m => SelectFrom r m -> m #

foldMap :: Monoid m => (a -> m) -> SelectFrom r a -> m #

foldr :: (a -> b -> b) -> b -> SelectFrom r a -> b #

foldr' :: (a -> b -> b) -> b -> SelectFrom r a -> b #

foldl :: (b -> a -> b) -> b -> SelectFrom r a -> b #

foldl' :: (b -> a -> b) -> b -> SelectFrom r a -> b #

foldr1 :: (a -> a -> a) -> SelectFrom r a -> a #

foldl1 :: (a -> a -> a) -> SelectFrom r a -> a #

toList :: SelectFrom r a -> [a] #

null :: SelectFrom r a -> Bool #

length :: SelectFrom r a -> Int #

elem :: Eq a => a -> SelectFrom r a -> Bool #

maximum :: Ord a => SelectFrom r a -> a #

minimum :: Ord a => SelectFrom r a -> a #

sum :: Num a => SelectFrom r a -> a #

product :: Num a => SelectFrom r a -> a #

ConstrainSASNames Traversable r => Traversable (SelectFrom r) Source # 

Methods

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

sequenceA :: Applicative f => SelectFrom r (f a) -> f (SelectFrom r a) #

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

sequence :: Monad m => SelectFrom r (m a) -> m (SelectFrom r a) #

ConstrainSNames Eq r a => Eq (SelectFrom r a) Source # 

Methods

(==) :: SelectFrom r a -> SelectFrom r a -> Bool #

(/=) :: SelectFrom r a -> SelectFrom r a -> Bool #

(ConstrainSNames Data r a, Data r) => Data (SelectFrom r a) Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SelectFrom r a -> c (SelectFrom r a) #

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

toConstr :: SelectFrom r a -> Constr #

dataTypeOf :: SelectFrom r a -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (SelectFrom r a)) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (SelectFrom r a)) #

gmapT :: (forall b. Data b => b -> b) -> SelectFrom r a -> SelectFrom r a #

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

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

gmapQ :: (forall d. Data d => d -> u) -> SelectFrom r a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> SelectFrom r a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> SelectFrom r a -> m (SelectFrom r a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SelectFrom r a -> m (SelectFrom r a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SelectFrom r a -> m (SelectFrom r a) #

ConstrainSNames Ord r a => Ord (SelectFrom r a) Source # 

Methods

compare :: SelectFrom r a -> SelectFrom r a -> Ordering #

(<) :: SelectFrom r a -> SelectFrom r a -> Bool #

(<=) :: SelectFrom r a -> SelectFrom r a -> Bool #

(>) :: SelectFrom r a -> SelectFrom r a -> Bool #

(>=) :: SelectFrom r a -> SelectFrom r a -> Bool #

max :: SelectFrom r a -> SelectFrom r a -> SelectFrom r a #

min :: SelectFrom r a -> SelectFrom r a -> SelectFrom r a #

ConstrainSNames Show r a => Show (SelectFrom r a) Source # 

Methods

showsPrec :: Int -> SelectFrom r a -> ShowS #

show :: SelectFrom r a -> String #

showList :: [SelectFrom r a] -> ShowS #

Generic (SelectFrom r a) Source # 

Associated Types

type Rep (SelectFrom r a) :: * -> * #

Methods

from :: SelectFrom r a -> Rep (SelectFrom r a) x #

to :: Rep (SelectFrom r a) x -> SelectFrom r a #

ConstrainSNames ToJSON r a => ToJSON (SelectFrom r a) Source # 
ConstrainSNames FromJSON r a => FromJSON (SelectFrom r a) Source # 
HasTables (SelectFrom ResolvedNames a) Source # 
HasColumns (SelectFrom ResolvedNames a) Source # 

Methods

goColumns :: SelectFrom ResolvedNames a -> Observer Source #

HasInfo (SelectFrom r a) Source # 

Associated Types

type Info (SelectFrom r a) :: * Source #

Methods

getInfo :: SelectFrom r a -> Info (SelectFrom r a) Source #

type EvalResult e (SelectFrom ResolvedNames Range) Source # 
type Rep (SelectFrom r a) Source # 
type Rep (SelectFrom r a) = D1 * (MetaData "SelectFrom" "Database.Sql.Type.Query" "queryparser-0.1.0.1-L3r1ujeH5Ss7CLthXKM008" False) (C1 * (MetaCons "SelectFrom" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [Tablish r a]))))
type Info (SelectFrom r a) Source # 
type Info (SelectFrom r a) = a

data TablishAliases a Source #

Instances

Functor TablishAliases Source # 

Methods

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

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

Foldable TablishAliases Source # 

Methods

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

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

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

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

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

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

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

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

toList :: TablishAliases a -> [a] #

null :: TablishAliases a -> Bool #

length :: TablishAliases a -> Int #

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

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

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

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

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

Traversable TablishAliases Source # 

Methods

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

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

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

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

Eq a => Eq (TablishAliases a) Source # 
Data a => Data (TablishAliases a) Source # 

Methods

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

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

toConstr :: TablishAliases a -> Constr #

dataTypeOf :: TablishAliases a -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord a => Ord (TablishAliases a) Source # 
Show a => Show (TablishAliases a) Source # 
Generic (TablishAliases a) Source # 

Associated Types

type Rep (TablishAliases a) :: * -> * #

ToJSON a => ToJSON (TablishAliases a) Source # 
FromJSON a => FromJSON (TablishAliases a) Source # 
type Rep (TablishAliases a) Source # 
type Rep (TablishAliases a) = D1 * (MetaData "TablishAliases" "Database.Sql.Type.Query" "queryparser-0.1.0.1-L3r1ujeH5Ss7CLthXKM008" False) ((:+:) * (C1 * (MetaCons "TablishAliasesNone" PrefixI False) (U1 *)) ((:+:) * (C1 * (MetaCons "TablishAliasesT" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (TableAlias a)))) (C1 * (MetaCons "TablishAliasesTC" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (TableAlias a))) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [ColumnAlias a]))))))

data Tablish r a Source #

Instances

Evaluation e => Evaluate e (Tablish ResolvedNames Range) Source # 
ConstrainSASNames Functor r => Functor (Tablish r) Source # 

Methods

fmap :: (a -> b) -> Tablish r a -> Tablish r b #

(<$) :: a -> Tablish r b -> Tablish r a #

ConstrainSASNames Foldable r => Foldable (Tablish r) Source # 

Methods

fold :: Monoid m => Tablish r m -> m #

foldMap :: Monoid m => (a -> m) -> Tablish r a -> m #

foldr :: (a -> b -> b) -> b -> Tablish r a -> b #

foldr' :: (a -> b -> b) -> b -> Tablish r a -> b #

foldl :: (b -> a -> b) -> b -> Tablish r a -> b #

foldl' :: (b -> a -> b) -> b -> Tablish r a -> b #

foldr1 :: (a -> a -> a) -> Tablish r a -> a #

foldl1 :: (a -> a -> a) -> Tablish r a -> a #

toList :: Tablish r a -> [a] #

null :: Tablish r a -> Bool #

length :: Tablish r a -> Int #

elem :: Eq a => a -> Tablish r a -> Bool #

maximum :: Ord a => Tablish r a -> a #

minimum :: Ord a => Tablish r a -> a #

sum :: Num a => Tablish r a -> a #

product :: Num a => Tablish r a -> a #

ConstrainSASNames Traversable r => Traversable (Tablish r) Source # 

Methods

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

sequenceA :: Applicative f => Tablish r (f a) -> f (Tablish r a) #

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

sequence :: Monad m => Tablish r (m a) -> m (Tablish r a) #

ConstrainSNames Eq r a => Eq (Tablish r a) Source # 

Methods

(==) :: Tablish r a -> Tablish r a -> Bool #

(/=) :: Tablish r a -> Tablish r a -> Bool #

(ConstrainSNames Data r a, Data r) => Data (Tablish r a) Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Tablish r a -> c (Tablish r a) #

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

toConstr :: Tablish r a -> Constr #

dataTypeOf :: Tablish r a -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Tablish r a)) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Tablish r a)) #

gmapT :: (forall b. Data b => b -> b) -> Tablish r a -> Tablish r a #

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

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

gmapQ :: (forall d. Data d => d -> u) -> Tablish r a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Tablish r a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Tablish r a -> m (Tablish r a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Tablish r a -> m (Tablish r a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Tablish r a -> m (Tablish r a) #

ConstrainSNames Ord r a => Ord (Tablish r a) Source # 

Methods

compare :: Tablish r a -> Tablish r a -> Ordering #

(<) :: Tablish r a -> Tablish r a -> Bool #

(<=) :: Tablish r a -> Tablish r a -> Bool #

(>) :: Tablish r a -> Tablish r a -> Bool #

(>=) :: Tablish r a -> Tablish r a -> Bool #

max :: Tablish r a -> Tablish r a -> Tablish r a #

min :: Tablish r a -> Tablish r a -> Tablish r a #

ConstrainSNames Show r a => Show (Tablish r a) Source # 

Methods

showsPrec :: Int -> Tablish r a -> ShowS #

show :: Tablish r a -> String #

showList :: [Tablish r a] -> ShowS #

Generic (Tablish r a) Source # 

Associated Types

type Rep (Tablish r a) :: * -> * #

Methods

from :: Tablish r a -> Rep (Tablish r a) x #

to :: Rep (Tablish r a) x -> Tablish r a #

ConstrainSNames ToJSON r a => ToJSON (Tablish r a) Source # 
ConstrainSNames FromJSON r a => FromJSON (Tablish r a) Source # 
HasTables (Tablish ResolvedNames a) Source # 
HasColumns (Tablish ResolvedNames a) Source # 

Methods

goColumns :: Tablish ResolvedNames a -> Observer Source #

HasInfo (Tablish r a) Source # 

Associated Types

type Info (Tablish r a) :: * Source #

Methods

getInfo :: Tablish r a -> Info (Tablish r a) Source #

type EvalResult e (Tablish ResolvedNames Range) Source # 
type Rep (Tablish r a) Source # 
type Rep (Tablish r a) = D1 * (MetaData "Tablish" "Database.Sql.Type.Query" "queryparser-0.1.0.1-L3r1ujeH5Ss7CLthXKM008" False) ((:+:) * ((:+:) * (C1 * (MetaCons "TablishTable" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a)) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (TablishAliases a))) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (TableRef r a)))))) (C1 * (MetaCons "TablishSubQuery" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a)) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (TablishAliases a))) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Query r a))))))) ((:+:) * (C1 * (MetaCons "TablishJoin" PrefixI False) ((:*:) * ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (JoinType a)))) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (JoinCondition r a))) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Tablish r a))) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Tablish r a))))))) (C1 * (MetaCons "TablishLateralView" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a)) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (LateralView r a))) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe (Tablish r a)))))))))
type Info (Tablish r a) Source # 
type Info (Tablish r a) = a

data JoinType a Source #

Constructors

JoinInner a 
JoinLeft a 
JoinRight a 
JoinFull a 
JoinSemi a 

Instances

Functor JoinType Source # 

Methods

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

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

Foldable JoinType Source # 

Methods

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

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

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

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

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

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

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

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

toList :: JoinType a -> [a] #

null :: JoinType a -> Bool #

length :: JoinType a -> Int #

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

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

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

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

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

Traversable JoinType Source # 

Methods

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

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

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

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

Eq a => Eq (JoinType a) Source # 

Methods

(==) :: JoinType a -> JoinType a -> Bool #

(/=) :: JoinType a -> JoinType a -> Bool #

Data a => Data (JoinType a) Source # 

Methods

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

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

toConstr :: JoinType a -> Constr #

dataTypeOf :: JoinType a -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord a => Ord (JoinType a) Source # 

Methods

compare :: JoinType a -> JoinType a -> Ordering #

(<) :: JoinType a -> JoinType a -> Bool #

(<=) :: JoinType a -> JoinType a -> Bool #

(>) :: JoinType a -> JoinType a -> Bool #

(>=) :: JoinType a -> JoinType a -> Bool #

max :: JoinType a -> JoinType a -> JoinType a #

min :: JoinType a -> JoinType a -> JoinType a #

Show a => Show (JoinType a) Source # 

Methods

showsPrec :: Int -> JoinType a -> ShowS #

show :: JoinType a -> String #

showList :: [JoinType a] -> ShowS #

Generic (JoinType a) Source # 

Associated Types

type Rep (JoinType a) :: * -> * #

Methods

from :: JoinType a -> Rep (JoinType a) x #

to :: Rep (JoinType a) x -> JoinType a #

ToJSON a => ToJSON (JoinType a) Source # 
FromJSON a => FromJSON (JoinType a) Source # 
HasInfo (JoinType a) Source # 

Associated Types

type Info (JoinType a) :: * Source #

Methods

getInfo :: JoinType a -> Info (JoinType a) Source #

type Rep (JoinType a) Source # 
type Info (JoinType a) Source # 
type Info (JoinType a) = a

data JoinCondition r a Source #

Constructors

JoinNatural a (NaturalColumns r a) 
JoinOn (Expr r a) 
JoinUsing a [UsingColumn r a] 

Instances

Evaluation e => Evaluate e (JoinCondition ResolvedNames Range) Source # 
ConstrainSASNames Functor r => Functor (JoinCondition r) Source # 

Methods

fmap :: (a -> b) -> JoinCondition r a -> JoinCondition r b #

(<$) :: a -> JoinCondition r b -> JoinCondition r a #

ConstrainSASNames Foldable r => Foldable (JoinCondition r) Source # 

Methods

fold :: Monoid m => JoinCondition r m -> m #

foldMap :: Monoid m => (a -> m) -> JoinCondition r a -> m #

foldr :: (a -> b -> b) -> b -> JoinCondition r a -> b #

foldr' :: (a -> b -> b) -> b -> JoinCondition r a -> b #

foldl :: (b -> a -> b) -> b -> JoinCondition r a -> b #

foldl' :: (b -> a -> b) -> b -> JoinCondition r a -> b #

foldr1 :: (a -> a -> a) -> JoinCondition r a -> a #

foldl1 :: (a -> a -> a) -> JoinCondition r a -> a #

toList :: JoinCondition r a -> [a] #

null :: JoinCondition r a -> Bool #

length :: JoinCondition r a -> Int #

elem :: Eq a => a -> JoinCondition r a -> Bool #

maximum :: Ord a => JoinCondition r a -> a #

minimum :: Ord a => JoinCondition r a -> a #

sum :: Num a => JoinCondition r a -> a #

product :: Num a => JoinCondition r a -> a #

ConstrainSASNames Traversable r => Traversable (JoinCondition r) Source # 

Methods

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

sequenceA :: Applicative f => JoinCondition r (f a) -> f (JoinCondition r a) #

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

sequence :: Monad m => JoinCondition r (m a) -> m (JoinCondition r a) #

ConstrainSNames Eq r a => Eq (JoinCondition r a) Source # 

Methods

(==) :: JoinCondition r a -> JoinCondition r a -> Bool #

(/=) :: JoinCondition r a -> JoinCondition r a -> Bool #

(ConstrainSNames Data r a, Data r) => Data (JoinCondition r a) Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> JoinCondition r a -> c (JoinCondition r a) #

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

toConstr :: JoinCondition r a -> Constr #

dataTypeOf :: JoinCondition r a -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (JoinCondition r a)) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (JoinCondition r a)) #

gmapT :: (forall b. Data b => b -> b) -> JoinCondition r a -> JoinCondition r a #

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

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

gmapQ :: (forall d. Data d => d -> u) -> JoinCondition r a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> JoinCondition r a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> JoinCondition r a -> m (JoinCondition r a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> JoinCondition r a -> m (JoinCondition r a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> JoinCondition r a -> m (JoinCondition r a) #

ConstrainSNames Ord r a => Ord (JoinCondition r a) Source # 
ConstrainSNames Show r a => Show (JoinCondition r a) Source # 
Generic (JoinCondition r a) Source # 

Associated Types

type Rep (JoinCondition r a) :: * -> * #

Methods

from :: JoinCondition r a -> Rep (JoinCondition r a) x #

to :: Rep (JoinCondition r a) x -> JoinCondition r a #

ConstrainSNames ToJSON r a => ToJSON (JoinCondition r a) Source # 
ConstrainSNames FromJSON r a => FromJSON (JoinCondition r a) Source # 
HasColumns (JoinCondition ResolvedNames a) Source # 

Methods

goColumns :: JoinCondition ResolvedNames a -> Observer Source #

HasInfo (JoinCondition r a) Source # 

Associated Types

type Info (JoinCondition r a) :: * Source #

type EvalResult e (JoinCondition ResolvedNames Range) Source # 
type Rep (JoinCondition r a) Source # 
type Info (JoinCondition r a) Source # 
type Info (JoinCondition r a) = a

data LateralView r a Source #

Instances

ConstrainSASNames Functor r => Functor (LateralView r) Source # 

Methods

fmap :: (a -> b) -> LateralView r a -> LateralView r b #

(<$) :: a -> LateralView r b -> LateralView r a #

ConstrainSASNames Foldable r => Foldable (LateralView r) Source # 

Methods

fold :: Monoid m => LateralView r m -> m #

foldMap :: Monoid m => (a -> m) -> LateralView r a -> m #

foldr :: (a -> b -> b) -> b -> LateralView r a -> b #

foldr' :: (a -> b -> b) -> b -> LateralView r a -> b #

foldl :: (b -> a -> b) -> b -> LateralView r a -> b #

foldl' :: (b -> a -> b) -> b -> LateralView r a -> b #

foldr1 :: (a -> a -> a) -> LateralView r a -> a #

foldl1 :: (a -> a -> a) -> LateralView r a -> a #

toList :: LateralView r a -> [a] #

null :: LateralView r a -> Bool #

length :: LateralView r a -> Int #

elem :: Eq a => a -> LateralView r a -> Bool #

maximum :: Ord a => LateralView r a -> a #

minimum :: Ord a => LateralView r a -> a #

sum :: Num a => LateralView r a -> a #

product :: Num a => LateralView r a -> a #

ConstrainSASNames Traversable r => Traversable (LateralView r) Source # 

Methods

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

sequenceA :: Applicative f => LateralView r (f a) -> f (LateralView r a) #

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

sequence :: Monad m => LateralView r (m a) -> m (LateralView r a) #

ConstrainSNames Eq r a => Eq (LateralView r a) Source # 

Methods

(==) :: LateralView r a -> LateralView r a -> Bool #

(/=) :: LateralView r a -> LateralView r a -> Bool #

(ConstrainSNames Data r a, Data r) => Data (LateralView r a) Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> LateralView r a -> c (LateralView r a) #

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

toConstr :: LateralView r a -> Constr #

dataTypeOf :: LateralView r a -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (LateralView r a)) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (LateralView r a)) #

gmapT :: (forall b. Data b => b -> b) -> LateralView r a -> LateralView r a #

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

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

gmapQ :: (forall d. Data d => d -> u) -> LateralView r a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> LateralView r a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> LateralView r a -> m (LateralView r a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> LateralView r a -> m (LateralView r a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> LateralView r a -> m (LateralView r a) #

ConstrainSNames Ord r a => Ord (LateralView r a) Source # 

Methods

compare :: LateralView r a -> LateralView r a -> Ordering #

(<) :: LateralView r a -> LateralView r a -> Bool #

(<=) :: LateralView r a -> LateralView r a -> Bool #

(>) :: LateralView r a -> LateralView r a -> Bool #

(>=) :: LateralView r a -> LateralView r a -> Bool #

max :: LateralView r a -> LateralView r a -> LateralView r a #

min :: LateralView r a -> LateralView r a -> LateralView r a #

ConstrainSNames Show r a => Show (LateralView r a) Source # 

Methods

showsPrec :: Int -> LateralView r a -> ShowS #

show :: LateralView r a -> String #

showList :: [LateralView r a] -> ShowS #

Generic (LateralView r a) Source # 

Associated Types

type Rep (LateralView r a) :: * -> * #

Methods

from :: LateralView r a -> Rep (LateralView r a) x #

to :: Rep (LateralView r a) x -> LateralView r a #

ConstrainSNames ToJSON r a => ToJSON (LateralView r a) Source # 
ConstrainSNames FromJSON r a => FromJSON (LateralView r a) Source # 
HasColumns (LateralView ResolvedNames a) Source # 

Methods

goColumns :: LateralView ResolvedNames a -> Observer Source #

type Rep (LateralView r a) Source # 
type Rep (LateralView r a) = D1 * (MetaData "LateralView" "Database.Sql.Type.Query" "queryparser-0.1.0.1-L3r1ujeH5Ss7CLthXKM008" False) (C1 * (MetaCons "LateralView" PrefixI True) ((:*:) * ((:*:) * (S1 * (MetaSel (Just Symbol "lateralViewInfo") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a)) (S1 * (MetaSel (Just Symbol "lateralViewOuter") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe a)))) ((:*:) * (S1 * (MetaSel (Just Symbol "lateralViewExprs") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [Expr r a])) ((:*:) * (S1 * (MetaSel (Just Symbol "lateralViewWithOrdinality") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Bool)) (S1 * (MetaSel (Just Symbol "lateralViewAliases") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (TablishAliases a)))))))

data SelectWhere r a Source #

Constructors

SelectWhere a (Expr r a) 

Instances

Evaluation e => Evaluate e (SelectWhere ResolvedNames Range) Source # 
ConstrainSASNames Functor r => Functor (SelectWhere r) Source # 

Methods

fmap :: (a -> b) -> SelectWhere r a -> SelectWhere r b #

(<$) :: a -> SelectWhere r b -> SelectWhere r a #

ConstrainSASNames Foldable r => Foldable (SelectWhere r) Source # 

Methods

fold :: Monoid m => SelectWhere r m -> m #

foldMap :: Monoid m => (a -> m) -> SelectWhere r a -> m #

foldr :: (a -> b -> b) -> b -> SelectWhere r a -> b #

foldr' :: (a -> b -> b) -> b -> SelectWhere r a -> b #

foldl :: (b -> a -> b) -> b -> SelectWhere r a -> b #

foldl' :: (b -> a -> b) -> b -> SelectWhere r a -> b #

foldr1 :: (a -> a -> a) -> SelectWhere r a -> a #

foldl1 :: (a -> a -> a) -> SelectWhere r a -> a #

toList :: SelectWhere r a -> [a] #

null :: SelectWhere r a -> Bool #

length :: SelectWhere r a -> Int #

elem :: Eq a => a -> SelectWhere r a -> Bool #

maximum :: Ord a => SelectWhere r a -> a #

minimum :: Ord a => SelectWhere r a -> a #

sum :: Num a => SelectWhere r a -> a #

product :: Num a => SelectWhere r a -> a #

ConstrainSASNames Traversable r => Traversable (SelectWhere r) Source # 

Methods

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

sequenceA :: Applicative f => SelectWhere r (f a) -> f (SelectWhere r a) #

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

sequence :: Monad m => SelectWhere r (m a) -> m (SelectWhere r a) #

ConstrainSNames Eq r a => Eq (SelectWhere r a) Source # 

Methods

(==) :: SelectWhere r a -> SelectWhere r a -> Bool #

(/=) :: SelectWhere r a -> SelectWhere r a -> Bool #

(ConstrainSNames Data r a, Data r) => Data (SelectWhere r a) Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SelectWhere r a -> c (SelectWhere r a) #

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

toConstr :: SelectWhere r a -> Constr #

dataTypeOf :: SelectWhere r a -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (SelectWhere r a)) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (SelectWhere r a)) #

gmapT :: (forall b. Data b => b -> b) -> SelectWhere r a -> SelectWhere r a #

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

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

gmapQ :: (forall d. Data d => d -> u) -> SelectWhere r a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> SelectWhere r a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> SelectWhere r a -> m (SelectWhere r a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SelectWhere r a -> m (SelectWhere r a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SelectWhere r a -> m (SelectWhere r a) #

ConstrainSNames Ord r a => Ord (SelectWhere r a) Source # 

Methods

compare :: SelectWhere r a -> SelectWhere r a -> Ordering #

(<) :: SelectWhere r a -> SelectWhere r a -> Bool #

(<=) :: SelectWhere r a -> SelectWhere r a -> Bool #

(>) :: SelectWhere r a -> SelectWhere r a -> Bool #

(>=) :: SelectWhere r a -> SelectWhere r a -> Bool #

max :: SelectWhere r a -> SelectWhere r a -> SelectWhere r a #

min :: SelectWhere r a -> SelectWhere r a -> SelectWhere r a #

ConstrainSNames Show r a => Show (SelectWhere r a) Source # 

Methods

showsPrec :: Int -> SelectWhere r a -> ShowS #

show :: SelectWhere r a -> String #

showList :: [SelectWhere r a] -> ShowS #

Generic (SelectWhere r a) Source # 

Associated Types

type Rep (SelectWhere r a) :: * -> * #

Methods

from :: SelectWhere r a -> Rep (SelectWhere r a) x #

to :: Rep (SelectWhere r a) x -> SelectWhere r a #

ConstrainSNames ToJSON r a => ToJSON (SelectWhere r a) Source # 
ConstrainSNames FromJSON r a => FromJSON (SelectWhere r a) Source # 
HasTables (SelectWhere ResolvedNames a) Source # 
HasColumns (SelectWhere ResolvedNames a) Source # 

Methods

goColumns :: SelectWhere ResolvedNames a -> Observer Source #

HasInfo (SelectWhere r a) Source # 

Associated Types

type Info (SelectWhere r a) :: * Source #

Methods

getInfo :: SelectWhere r a -> Info (SelectWhere r a) Source #

type EvalResult e (SelectWhere ResolvedNames Range) Source # 
type Rep (SelectWhere r a) Source # 
type Rep (SelectWhere r a) = D1 * (MetaData "SelectWhere" "Database.Sql.Type.Query" "queryparser-0.1.0.1-L3r1ujeH5Ss7CLthXKM008" False) (C1 * (MetaCons "SelectWhere" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Expr r a)))))
type Info (SelectWhere r a) Source # 
type Info (SelectWhere r a) = a

data SelectTimeseries r a Source #

Instances

Evaluation e => Evaluate e (SelectTimeseries ResolvedNames Range) Source # 
ConstrainSASNames Functor r => Functor (SelectTimeseries r) Source # 

Methods

fmap :: (a -> b) -> SelectTimeseries r a -> SelectTimeseries r b #

(<$) :: a -> SelectTimeseries r b -> SelectTimeseries r a #

ConstrainSASNames Foldable r => Foldable (SelectTimeseries r) Source # 

Methods

fold :: Monoid m => SelectTimeseries r m -> m #

foldMap :: Monoid m => (a -> m) -> SelectTimeseries r a -> m #

foldr :: (a -> b -> b) -> b -> SelectTimeseries r a -> b #

foldr' :: (a -> b -> b) -> b -> SelectTimeseries r a -> b #

foldl :: (b -> a -> b) -> b -> SelectTimeseries r a -> b #

foldl' :: (b -> a -> b) -> b -> SelectTimeseries r a -> b #

foldr1 :: (a -> a -> a) -> SelectTimeseries r a -> a #

foldl1 :: (a -> a -> a) -> SelectTimeseries r a -> a #

toList :: SelectTimeseries r a -> [a] #

null :: SelectTimeseries r a -> Bool #

length :: SelectTimeseries r a -> Int #

elem :: Eq a => a -> SelectTimeseries r a -> Bool #

maximum :: Ord a => SelectTimeseries r a -> a #

minimum :: Ord a => SelectTimeseries r a -> a #

sum :: Num a => SelectTimeseries r a -> a #

product :: Num a => SelectTimeseries r a -> a #

ConstrainSASNames Traversable r => Traversable (SelectTimeseries r) Source # 

Methods

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

sequenceA :: Applicative f => SelectTimeseries r (f a) -> f (SelectTimeseries r a) #

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

sequence :: Monad m => SelectTimeseries r (m a) -> m (SelectTimeseries r a) #

ConstrainSNames Eq r a => Eq (SelectTimeseries r a) Source # 
(ConstrainSNames Data r a, Data r) => Data (SelectTimeseries r a) Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SelectTimeseries r a -> c (SelectTimeseries r a) #

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

toConstr :: SelectTimeseries r a -> Constr #

dataTypeOf :: SelectTimeseries r a -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (SelectTimeseries r a)) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (SelectTimeseries r a)) #

gmapT :: (forall b. Data b => b -> b) -> SelectTimeseries r a -> SelectTimeseries r a #

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

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

gmapQ :: (forall d. Data d => d -> u) -> SelectTimeseries r a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> SelectTimeseries r a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> SelectTimeseries r a -> m (SelectTimeseries r a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SelectTimeseries r a -> m (SelectTimeseries r a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SelectTimeseries r a -> m (SelectTimeseries r a) #

ConstrainSNames Ord r a => Ord (SelectTimeseries r a) Source # 
ConstrainSNames Show r a => Show (SelectTimeseries r a) Source # 
Generic (SelectTimeseries r a) Source # 

Associated Types

type Rep (SelectTimeseries r a) :: * -> * #

ConstrainSNames ToJSON r a => ToJSON (SelectTimeseries r a) Source # 
ConstrainSNames FromJSON r a => FromJSON (SelectTimeseries r a) Source # 
HasTables (SelectTimeseries ResolvedNames a) Source # 
HasColumns (SelectTimeseries ResolvedNames a) Source # 
HasInfo (SelectTimeseries r a) Source # 

Associated Types

type Info (SelectTimeseries r a) :: * Source #

type EvalResult e (SelectTimeseries ResolvedNames Range) Source # 
type Rep (SelectTimeseries r a) Source # 
type Rep (SelectTimeseries r a) = D1 * (MetaData "SelectTimeseries" "Database.Sql.Type.Query" "queryparser-0.1.0.1-L3r1ujeH5Ss7CLthXKM008" False) (C1 * (MetaCons "SelectTimeseries" PrefixI True) ((:*:) * ((:*:) * (S1 * (MetaSel (Just Symbol "selectTimeseriesInfo") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a)) (S1 * (MetaSel (Just Symbol "selectTimeseriesSliceName") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (ColumnAlias a)))) ((:*:) * (S1 * (MetaSel (Just Symbol "selectTimeseriesInterval") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Constant a))) ((:*:) * (S1 * (MetaSel (Just Symbol "selectTimeseriesPartition") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe (Partition r a)))) (S1 * (MetaSel (Just Symbol "selectTimeseriesOrder") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Expr r a)))))))
type Info (SelectTimeseries r a) Source # 
type Info (SelectTimeseries r a) = a

data PositionOrExpr r a Source #

Instances

ConstrainSASNames Functor r => Functor (PositionOrExpr r) Source # 

Methods

fmap :: (a -> b) -> PositionOrExpr r a -> PositionOrExpr r b #

(<$) :: a -> PositionOrExpr r b -> PositionOrExpr r a #

ConstrainSASNames Foldable r => Foldable (PositionOrExpr r) Source # 

Methods

fold :: Monoid m => PositionOrExpr r m -> m #

foldMap :: Monoid m => (a -> m) -> PositionOrExpr r a -> m #

foldr :: (a -> b -> b) -> b -> PositionOrExpr r a -> b #

foldr' :: (a -> b -> b) -> b -> PositionOrExpr r a -> b #

foldl :: (b -> a -> b) -> b -> PositionOrExpr r a -> b #

foldl' :: (b -> a -> b) -> b -> PositionOrExpr r a -> b #

foldr1 :: (a -> a -> a) -> PositionOrExpr r a -> a #

foldl1 :: (a -> a -> a) -> PositionOrExpr r a -> a #

toList :: PositionOrExpr r a -> [a] #

null :: PositionOrExpr r a -> Bool #

length :: PositionOrExpr r a -> Int #

elem :: Eq a => a -> PositionOrExpr r a -> Bool #

maximum :: Ord a => PositionOrExpr r a -> a #

minimum :: Ord a => PositionOrExpr r a -> a #

sum :: Num a => PositionOrExpr r a -> a #

product :: Num a => PositionOrExpr r a -> a #

ConstrainSASNames Traversable r => Traversable (PositionOrExpr r) Source # 

Methods

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

sequenceA :: Applicative f => PositionOrExpr r (f a) -> f (PositionOrExpr r a) #

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

sequence :: Monad m => PositionOrExpr r (m a) -> m (PositionOrExpr r a) #

ConstrainSNames Eq r a => Eq (PositionOrExpr r a) Source # 
(ConstrainSNames Data r a, Data r) => Data (PositionOrExpr r a) Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> PositionOrExpr r a -> c (PositionOrExpr r a) #

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

toConstr :: PositionOrExpr r a -> Constr #

dataTypeOf :: PositionOrExpr r a -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (PositionOrExpr r a)) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (PositionOrExpr r a)) #

gmapT :: (forall b. Data b => b -> b) -> PositionOrExpr r a -> PositionOrExpr r a #

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

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

gmapQ :: (forall d. Data d => d -> u) -> PositionOrExpr r a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> PositionOrExpr r a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> PositionOrExpr r a -> m (PositionOrExpr r a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> PositionOrExpr r a -> m (PositionOrExpr r a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> PositionOrExpr r a -> m (PositionOrExpr r a) #

ConstrainSNames Ord r a => Ord (PositionOrExpr r a) Source # 
ConstrainSNames Show r a => Show (PositionOrExpr r a) Source # 
Generic (PositionOrExpr r a) Source # 

Associated Types

type Rep (PositionOrExpr r a) :: * -> * #

Methods

from :: PositionOrExpr r a -> Rep (PositionOrExpr r a) x #

to :: Rep (PositionOrExpr r a) x -> PositionOrExpr r a #

(Arbitrary (PositionExpr r a), Arbitrary a) => Arbitrary (PositionOrExpr r a) Source # 
ConstrainSNames ToJSON r a => ToJSON (PositionOrExpr r a) Source # 
ConstrainSNames FromJSON r a => FromJSON (PositionOrExpr r a) Source # 
HasTables (PositionOrExpr ResolvedNames a) Source # 
HasInfo (PositionOrExpr r a) Source # 

Associated Types

type Info (PositionOrExpr r a) :: * Source #

type Rep (PositionOrExpr r a) Source # 
type Info (PositionOrExpr r a) Source # 
type Info (PositionOrExpr r a) = a

data GroupingElement r a Source #

Instances

ConstrainSASNames Functor r => Functor (GroupingElement r) Source # 

Methods

fmap :: (a -> b) -> GroupingElement r a -> GroupingElement r b #

(<$) :: a -> GroupingElement r b -> GroupingElement r a #

ConstrainSASNames Foldable r => Foldable (GroupingElement r) Source # 

Methods

fold :: Monoid m => GroupingElement r m -> m #

foldMap :: Monoid m => (a -> m) -> GroupingElement r a -> m #

foldr :: (a -> b -> b) -> b -> GroupingElement r a -> b #

foldr' :: (a -> b -> b) -> b -> GroupingElement r a -> b #

foldl :: (b -> a -> b) -> b -> GroupingElement r a -> b #

foldl' :: (b -> a -> b) -> b -> GroupingElement r a -> b #

foldr1 :: (a -> a -> a) -> GroupingElement r a -> a #

foldl1 :: (a -> a -> a) -> GroupingElement r a -> a #

toList :: GroupingElement r a -> [a] #

null :: GroupingElement r a -> Bool #

length :: GroupingElement r a -> Int #

elem :: Eq a => a -> GroupingElement r a -> Bool #

maximum :: Ord a => GroupingElement r a -> a #

minimum :: Ord a => GroupingElement r a -> a #

sum :: Num a => GroupingElement r a -> a #

product :: Num a => GroupingElement r a -> a #

ConstrainSASNames Traversable r => Traversable (GroupingElement r) Source # 

Methods

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

sequenceA :: Applicative f => GroupingElement r (f a) -> f (GroupingElement r a) #

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

sequence :: Monad m => GroupingElement r (m a) -> m (GroupingElement r a) #

ConstrainSNames Eq r a => Eq (GroupingElement r a) Source # 
(ConstrainSNames Data r a, Data r) => Data (GroupingElement r a) Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> GroupingElement r a -> c (GroupingElement r a) #

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

toConstr :: GroupingElement r a -> Constr #

dataTypeOf :: GroupingElement r a -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (GroupingElement r a)) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (GroupingElement r a)) #

gmapT :: (forall b. Data b => b -> b) -> GroupingElement r a -> GroupingElement r a #

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

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

gmapQ :: (forall d. Data d => d -> u) -> GroupingElement r a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> GroupingElement r a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> GroupingElement r a -> m (GroupingElement r a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> GroupingElement r a -> m (GroupingElement r a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> GroupingElement r a -> m (GroupingElement r a) #

ConstrainSNames Ord r a => Ord (GroupingElement r a) Source # 
ConstrainSNames Show r a => Show (GroupingElement r a) Source # 
Generic (GroupingElement r a) Source # 

Associated Types

type Rep (GroupingElement r a) :: * -> * #

Methods

from :: GroupingElement r a -> Rep (GroupingElement r a) x #

to :: Rep (GroupingElement r a) x -> GroupingElement r a #

ConstrainSNames ToJSON r a => ToJSON (GroupingElement r a) Source # 
ConstrainSNames FromJSON r a => FromJSON (GroupingElement r a) Source # 
HasTables (GroupingElement ResolvedNames a) Source # 
HasInfo (GroupingElement r a) Source # 

Associated Types

type Info (GroupingElement r a) :: * Source #

type Rep (GroupingElement r a) Source # 
type Info (GroupingElement r a) Source # 
type Info (GroupingElement r a) = a

data SelectGroup r a Source #

Instances

Evaluation e => Evaluate e (SelectGroup ResolvedNames Range) Source # 
ConstrainSASNames Functor r => Functor (SelectGroup r) Source # 

Methods

fmap :: (a -> b) -> SelectGroup r a -> SelectGroup r b #

(<$) :: a -> SelectGroup r b -> SelectGroup r a #

ConstrainSASNames Foldable r => Foldable (SelectGroup r) Source # 

Methods

fold :: Monoid m => SelectGroup r m -> m #

foldMap :: Monoid m => (a -> m) -> SelectGroup r a -> m #

foldr :: (a -> b -> b) -> b -> SelectGroup r a -> b #

foldr' :: (a -> b -> b) -> b -> SelectGroup r a -> b #

foldl :: (b -> a -> b) -> b -> SelectGroup r a -> b #

foldl' :: (b -> a -> b) -> b -> SelectGroup r a -> b #

foldr1 :: (a -> a -> a) -> SelectGroup r a -> a #

foldl1 :: (a -> a -> a) -> SelectGroup r a -> a #

toList :: SelectGroup r a -> [a] #

null :: SelectGroup r a -> Bool #

length :: SelectGroup r a -> Int #

elem :: Eq a => a -> SelectGroup r a -> Bool #

maximum :: Ord a => SelectGroup r a -> a #

minimum :: Ord a => SelectGroup r a -> a #

sum :: Num a => SelectGroup r a -> a #

product :: Num a => SelectGroup r a -> a #

ConstrainSASNames Traversable r => Traversable (SelectGroup r) Source # 

Methods

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

sequenceA :: Applicative f => SelectGroup r (f a) -> f (SelectGroup r a) #

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

sequence :: Monad m => SelectGroup r (m a) -> m (SelectGroup r a) #

ConstrainSNames Eq r a => Eq (SelectGroup r a) Source # 

Methods

(==) :: SelectGroup r a -> SelectGroup r a -> Bool #

(/=) :: SelectGroup r a -> SelectGroup r a -> Bool #

(ConstrainSNames Data r a, Data r) => Data (SelectGroup r a) Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SelectGroup r a -> c (SelectGroup r a) #

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

toConstr :: SelectGroup r a -> Constr #

dataTypeOf :: SelectGroup r a -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (SelectGroup r a)) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (SelectGroup r a)) #

gmapT :: (forall b. Data b => b -> b) -> SelectGroup r a -> SelectGroup r a #

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

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

gmapQ :: (forall d. Data d => d -> u) -> SelectGroup r a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> SelectGroup r a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> SelectGroup r a -> m (SelectGroup r a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SelectGroup r a -> m (SelectGroup r a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SelectGroup r a -> m (SelectGroup r a) #

ConstrainSNames Ord r a => Ord (SelectGroup r a) Source # 

Methods

compare :: SelectGroup r a -> SelectGroup r a -> Ordering #

(<) :: SelectGroup r a -> SelectGroup r a -> Bool #

(<=) :: SelectGroup r a -> SelectGroup r a -> Bool #

(>) :: SelectGroup r a -> SelectGroup r a -> Bool #

(>=) :: SelectGroup r a -> SelectGroup r a -> Bool #

max :: SelectGroup r a -> SelectGroup r a -> SelectGroup r a #

min :: SelectGroup r a -> SelectGroup r a -> SelectGroup r a #

ConstrainSNames Show r a => Show (SelectGroup r a) Source # 

Methods

showsPrec :: Int -> SelectGroup r a -> ShowS #

show :: SelectGroup r a -> String #

showList :: [SelectGroup r a] -> ShowS #

Generic (SelectGroup r a) Source # 

Associated Types

type Rep (SelectGroup r a) :: * -> * #

Methods

from :: SelectGroup r a -> Rep (SelectGroup r a) x #

to :: Rep (SelectGroup r a) x -> SelectGroup r a #

ConstrainSNames ToJSON r a => ToJSON (SelectGroup r a) Source # 
ConstrainSNames FromJSON r a => FromJSON (SelectGroup r a) Source # 
HasTables (SelectGroup ResolvedNames a) Source # 
HasInfo (SelectGroup r a) Source # 

Associated Types

type Info (SelectGroup r a) :: * Source #

Methods

getInfo :: SelectGroup r a -> Info (SelectGroup r a) Source #

type EvalResult e (SelectGroup ResolvedNames Range) Source # 
type Rep (SelectGroup r a) Source # 
type Rep (SelectGroup r a) = D1 * (MetaData "SelectGroup" "Database.Sql.Type.Query" "queryparser-0.1.0.1-L3r1ujeH5Ss7CLthXKM008" False) (C1 * (MetaCons "SelectGroup" PrefixI True) ((:*:) * (S1 * (MetaSel (Just Symbol "selectGroupInfo") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a)) (S1 * (MetaSel (Just Symbol "selectGroupGroupingElements") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [GroupingElement r a]))))
type Info (SelectGroup r a) Source # 
type Info (SelectGroup r a) = a

data SelectHaving r a Source #

Constructors

SelectHaving a [Expr r a] 

Instances

Evaluation e => Evaluate e (SelectHaving ResolvedNames Range) Source # 
ConstrainSASNames Functor r => Functor (SelectHaving r) Source # 

Methods

fmap :: (a -> b) -> SelectHaving r a -> SelectHaving r b #

(<$) :: a -> SelectHaving r b -> SelectHaving r a #

ConstrainSASNames Foldable r => Foldable (SelectHaving r) Source # 

Methods

fold :: Monoid m => SelectHaving r m -> m #

foldMap :: Monoid m => (a -> m) -> SelectHaving r a -> m #

foldr :: (a -> b -> b) -> b -> SelectHaving r a -> b #

foldr' :: (a -> b -> b) -> b -> SelectHaving r a -> b #

foldl :: (b -> a -> b) -> b -> SelectHaving r a -> b #

foldl' :: (b -> a -> b) -> b -> SelectHaving r a -> b #

foldr1 :: (a -> a -> a) -> SelectHaving r a -> a #

foldl1 :: (a -> a -> a) -> SelectHaving r a -> a #

toList :: SelectHaving r a -> [a] #

null :: SelectHaving r a -> Bool #

length :: SelectHaving r a -> Int #

elem :: Eq a => a -> SelectHaving r a -> Bool #

maximum :: Ord a => SelectHaving r a -> a #

minimum :: Ord a => SelectHaving r a -> a #

sum :: Num a => SelectHaving r a -> a #

product :: Num a => SelectHaving r a -> a #

ConstrainSASNames Traversable r => Traversable (SelectHaving r) Source # 

Methods

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

sequenceA :: Applicative f => SelectHaving r (f a) -> f (SelectHaving r a) #

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

sequence :: Monad m => SelectHaving r (m a) -> m (SelectHaving r a) #

ConstrainSNames Eq r a => Eq (SelectHaving r a) Source # 

Methods

(==) :: SelectHaving r a -> SelectHaving r a -> Bool #

(/=) :: SelectHaving r a -> SelectHaving r a -> Bool #

(ConstrainSNames Data r a, Data r) => Data (SelectHaving r a) Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SelectHaving r a -> c (SelectHaving r a) #

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

toConstr :: SelectHaving r a -> Constr #

dataTypeOf :: SelectHaving r a -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (SelectHaving r a)) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (SelectHaving r a)) #

gmapT :: (forall b. Data b => b -> b) -> SelectHaving r a -> SelectHaving r a #

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

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

gmapQ :: (forall d. Data d => d -> u) -> SelectHaving r a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> SelectHaving r a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> SelectHaving r a -> m (SelectHaving r a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SelectHaving r a -> m (SelectHaving r a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SelectHaving r a -> m (SelectHaving r a) #

ConstrainSNames Ord r a => Ord (SelectHaving r a) Source # 
ConstrainSNames Show r a => Show (SelectHaving r a) Source # 
Generic (SelectHaving r a) Source # 

Associated Types

type Rep (SelectHaving r a) :: * -> * #

Methods

from :: SelectHaving r a -> Rep (SelectHaving r a) x #

to :: Rep (SelectHaving r a) x -> SelectHaving r a #

ConstrainSNames ToJSON r a => ToJSON (SelectHaving r a) Source # 
ConstrainSNames FromJSON r a => FromJSON (SelectHaving r a) Source # 
HasTables (SelectHaving ResolvedNames a) Source # 
HasColumns (SelectHaving ResolvedNames a) Source # 

Methods

goColumns :: SelectHaving ResolvedNames a -> Observer Source #

HasInfo (SelectHaving r a) Source # 

Associated Types

type Info (SelectHaving r a) :: * Source #

Methods

getInfo :: SelectHaving r a -> Info (SelectHaving r a) Source #

type EvalResult e (SelectHaving ResolvedNames Range) Source # 
type Rep (SelectHaving r a) Source # 
type Rep (SelectHaving r a) = D1 * (MetaData "SelectHaving" "Database.Sql.Type.Query" "queryparser-0.1.0.1-L3r1ujeH5Ss7CLthXKM008" False) (C1 * (MetaCons "SelectHaving" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [Expr r a]))))
type Info (SelectHaving r a) Source # 
type Info (SelectHaving r a) = a

data SelectNamedWindow r a Source #

Constructors

SelectNamedWindow a [NamedWindowExpr r a] 

Instances

ConstrainSASNames Functor r => Functor (SelectNamedWindow r) Source # 

Methods

fmap :: (a -> b) -> SelectNamedWindow r a -> SelectNamedWindow r b #

(<$) :: a -> SelectNamedWindow r b -> SelectNamedWindow r a #

ConstrainSASNames Foldable r => Foldable (SelectNamedWindow r) Source # 

Methods

fold :: Monoid m => SelectNamedWindow r m -> m #

foldMap :: Monoid m => (a -> m) -> SelectNamedWindow r a -> m #

foldr :: (a -> b -> b) -> b -> SelectNamedWindow r a -> b #

foldr' :: (a -> b -> b) -> b -> SelectNamedWindow r a -> b #

foldl :: (b -> a -> b) -> b -> SelectNamedWindow r a -> b #

foldl' :: (b -> a -> b) -> b -> SelectNamedWindow r a -> b #

foldr1 :: (a -> a -> a) -> SelectNamedWindow r a -> a #

foldl1 :: (a -> a -> a) -> SelectNamedWindow r a -> a #

toList :: SelectNamedWindow r a -> [a] #

null :: SelectNamedWindow r a -> Bool #

length :: SelectNamedWindow r a -> Int #

elem :: Eq a => a -> SelectNamedWindow r a -> Bool #

maximum :: Ord a => SelectNamedWindow r a -> a #

minimum :: Ord a => SelectNamedWindow r a -> a #

sum :: Num a => SelectNamedWindow r a -> a #

product :: Num a => SelectNamedWindow r a -> a #

ConstrainSASNames Traversable r => Traversable (SelectNamedWindow r) Source # 

Methods

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

sequenceA :: Applicative f => SelectNamedWindow r (f a) -> f (SelectNamedWindow r a) #

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

sequence :: Monad m => SelectNamedWindow r (m a) -> m (SelectNamedWindow r a) #

ConstrainSNames Eq r a => Eq (SelectNamedWindow r a) Source # 
(ConstrainSNames Data r a, Data r) => Data (SelectNamedWindow r a) Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SelectNamedWindow r a -> c (SelectNamedWindow r a) #

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

toConstr :: SelectNamedWindow r a -> Constr #

dataTypeOf :: SelectNamedWindow r a -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (SelectNamedWindow r a)) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (SelectNamedWindow r a)) #

gmapT :: (forall b. Data b => b -> b) -> SelectNamedWindow r a -> SelectNamedWindow r a #

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

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

gmapQ :: (forall d. Data d => d -> u) -> SelectNamedWindow r a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> SelectNamedWindow r a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> SelectNamedWindow r a -> m (SelectNamedWindow r a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SelectNamedWindow r a -> m (SelectNamedWindow r a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SelectNamedWindow r a -> m (SelectNamedWindow r a) #

ConstrainSNames Ord r a => Ord (SelectNamedWindow r a) Source # 
ConstrainSNames Show r a => Show (SelectNamedWindow r a) Source # 
Generic (SelectNamedWindow r a) Source # 

Associated Types

type Rep (SelectNamedWindow r a) :: * -> * #

ConstrainSNames ToJSON r a => ToJSON (SelectNamedWindow r a) Source # 
ConstrainSNames FromJSON r a => FromJSON (SelectNamedWindow r a) Source # 
HasTables (SelectNamedWindow ResolvedNames a) Source # 
HasColumns (SelectNamedWindow ResolvedNames a) Source # 
HasInfo (SelectNamedWindow r a) Source # 

Associated Types

type Info (SelectNamedWindow r a) :: * Source #

type Rep (SelectNamedWindow r a) Source # 
type Rep (SelectNamedWindow r a) = D1 * (MetaData "SelectNamedWindow" "Database.Sql.Type.Query" "queryparser-0.1.0.1-L3r1ujeH5Ss7CLthXKM008" False) (C1 * (MetaCons "SelectNamedWindow" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [NamedWindowExpr r a]))))
type Info (SelectNamedWindow r a) Source # 
type Info (SelectNamedWindow r a) = a

data Order r a Source #

Constructors

Order a (PositionOrExpr r a) (OrderDirection (Maybe a)) (NullPosition (Maybe a)) 

Instances

ConstrainSASNames Functor r => Functor (Order r) Source # 

Methods

fmap :: (a -> b) -> Order r a -> Order r b #

(<$) :: a -> Order r b -> Order r a #

ConstrainSASNames Foldable r => Foldable (Order r) Source # 

Methods

fold :: Monoid m => Order r m -> m #

foldMap :: Monoid m => (a -> m) -> Order r a -> m #

foldr :: (a -> b -> b) -> b -> Order r a -> b #

foldr' :: (a -> b -> b) -> b -> Order r a -> b #

foldl :: (b -> a -> b) -> b -> Order r a -> b #

foldl' :: (b -> a -> b) -> b -> Order r a -> b #

foldr1 :: (a -> a -> a) -> Order r a -> a #

foldl1 :: (a -> a -> a) -> Order r a -> a #

toList :: Order r a -> [a] #

null :: Order r a -> Bool #

length :: Order r a -> Int #

elem :: Eq a => a -> Order r a -> Bool #

maximum :: Ord a => Order r a -> a #

minimum :: Ord a => Order r a -> a #

sum :: Num a => Order r a -> a #

product :: Num a => Order r a -> a #

ConstrainSASNames Traversable r => Traversable (Order r) Source # 

Methods

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

sequenceA :: Applicative f => Order r (f a) -> f (Order r a) #

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

sequence :: Monad m => Order r (m a) -> m (Order r a) #

ConstrainSNames Eq r a => Eq (Order r a) Source # 

Methods

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

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

(ConstrainSNames Data r a, Data r) => Data (Order r a) Source # 

Methods

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

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

toConstr :: Order r a -> Constr #

dataTypeOf :: Order r a -> DataType #

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

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

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

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

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

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

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

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

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

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

ConstrainSNames Ord r a => Ord (Order r a) Source # 

Methods

compare :: Order r a -> Order r a -> Ordering #

(<) :: Order r a -> Order r a -> Bool #

(<=) :: Order r a -> Order r a -> Bool #

(>) :: Order r a -> Order r a -> Bool #

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

max :: Order r a -> Order r a -> Order r a #

min :: Order r a -> Order r a -> Order r a #

ConstrainSNames Show r a => Show (Order r a) Source # 

Methods

showsPrec :: Int -> Order r a -> ShowS #

show :: Order r a -> String #

showList :: [Order r a] -> ShowS #

Generic (Order r a) Source # 

Associated Types

type Rep (Order r a) :: * -> * #

Methods

from :: Order r a -> Rep (Order r a) x #

to :: Rep (Order r a) x -> Order r a #

(Arbitrary (PositionExpr r a), Arbitrary a) => Arbitrary (Order r a) Source # 

Methods

arbitrary :: Gen (Order r a) #

shrink :: Order r a -> [Order r a] #

ConstrainSNames ToJSON r a => ToJSON (Order r a) Source # 

Methods

toJSON :: Order r a -> Value #

toEncoding :: Order r a -> Encoding #

toJSONList :: [Order r a] -> Value #

toEncodingList :: [Order r a] -> Encoding #

ConstrainSNames FromJSON r a => FromJSON (Order r a) Source # 

Methods

parseJSON :: Value -> Parser (Order r a) #

parseJSONList :: Value -> Parser [Order r a] #

HasTables (Order ResolvedNames a) Source # 
HasInfo (Order r a) Source # 

Associated Types

type Info (Order r a) :: * Source #

Methods

getInfo :: Order r a -> Info (Order r a) Source #

type Rep (Order r a) Source # 
type Info (Order r a) Source # 
type Info (Order r a) = a

data OrderDirection a Source #

Constructors

OrderAsc a 
OrderDesc a 

Instances

Functor OrderDirection Source # 

Methods

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

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

Foldable OrderDirection Source # 

Methods

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

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

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

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

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

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

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

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

toList :: OrderDirection a -> [a] #

null :: OrderDirection a -> Bool #

length :: OrderDirection a -> Int #

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

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

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

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

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

Traversable OrderDirection Source # 

Methods

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

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

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

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

Eq a => Eq (OrderDirection a) Source # 
Data a => Data (OrderDirection a) Source # 

Methods

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

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

toConstr :: OrderDirection a -> Constr #

dataTypeOf :: OrderDirection a -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord a => Ord (OrderDirection a) Source # 
Show a => Show (OrderDirection a) Source # 
Generic (OrderDirection a) Source # 

Associated Types

type Rep (OrderDirection a) :: * -> * #

Arbitrary a => Arbitrary (OrderDirection a) Source # 
ToJSON a => ToJSON (OrderDirection a) Source # 
FromJSON a => FromJSON (OrderDirection a) Source # 
HasInfo (OrderDirection a) Source # 

Associated Types

type Info (OrderDirection a) :: * Source #

type Rep (OrderDirection a) Source # 
type Rep (OrderDirection a) = D1 * (MetaData "OrderDirection" "Database.Sql.Type.Query" "queryparser-0.1.0.1-L3r1ujeH5Ss7CLthXKM008" False) ((:+:) * (C1 * (MetaCons "OrderAsc" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a))) (C1 * (MetaCons "OrderDesc" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a))))
type Info (OrderDirection a) Source # 
type Info (OrderDirection a) = a

data NullPosition a Source #

Constructors

NullsFirst a 
NullsLast a 
NullsAuto a 

Instances

Functor NullPosition Source # 

Methods

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

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

Foldable NullPosition Source # 

Methods

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

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

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

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

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

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

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

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

toList :: NullPosition a -> [a] #

null :: NullPosition a -> Bool #

length :: NullPosition a -> Int #

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

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

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

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

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

Traversable NullPosition Source # 

Methods

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

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

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

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

Eq a => Eq (NullPosition a) Source # 
Data a => Data (NullPosition a) Source # 

Methods

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

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

toConstr :: NullPosition a -> Constr #

dataTypeOf :: NullPosition a -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord a => Ord (NullPosition a) Source # 
Show a => Show (NullPosition a) Source # 
Generic (NullPosition a) Source # 

Associated Types

type Rep (NullPosition a) :: * -> * #

Methods

from :: NullPosition a -> Rep (NullPosition a) x #

to :: Rep (NullPosition a) x -> NullPosition a #

Arbitrary a => Arbitrary (NullPosition a) Source # 
ToJSON a => ToJSON (NullPosition a) Source # 
FromJSON a => FromJSON (NullPosition a) Source # 
HasInfo (NullPosition a) Source # 

Associated Types

type Info (NullPosition a) :: * Source #

type Rep (NullPosition a) Source # 
type Rep (NullPosition a) = D1 * (MetaData "NullPosition" "Database.Sql.Type.Query" "queryparser-0.1.0.1-L3r1ujeH5Ss7CLthXKM008" False) ((:+:) * (C1 * (MetaCons "NullsFirst" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a))) ((:+:) * (C1 * (MetaCons "NullsLast" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a))) (C1 * (MetaCons "NullsAuto" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a)))))
type Info (NullPosition a) Source # 
type Info (NullPosition a) = a

data Offset a Source #

Constructors

Offset a Text 

Instances

Functor Offset Source # 

Methods

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

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

Foldable Offset Source # 

Methods

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

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

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

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

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

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

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

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

toList :: Offset a -> [a] #

null :: Offset a -> Bool #

length :: Offset a -> Int #

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

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

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

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

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

Traversable Offset Source # 

Methods

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

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

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

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

Evaluation e => Evaluate e (Offset a) Source # 

Associated Types

type EvalResult e (Offset a) :: * Source #

Methods

eval :: Proxy * e -> Offset a -> EvalResult e (Offset a) Source #

Eq a => Eq (Offset a) Source # 

Methods

(==) :: Offset a -> Offset a -> Bool #

(/=) :: Offset a -> Offset a -> Bool #

Data a => Data (Offset a) Source # 

Methods

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

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

toConstr :: Offset a -> Constr #

dataTypeOf :: Offset a -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord a => Ord (Offset a) Source # 

Methods

compare :: Offset a -> Offset a -> Ordering #

(<) :: Offset a -> Offset a -> Bool #

(<=) :: Offset a -> Offset a -> Bool #

(>) :: Offset a -> Offset a -> Bool #

(>=) :: Offset a -> Offset a -> Bool #

max :: Offset a -> Offset a -> Offset a #

min :: Offset a -> Offset a -> Offset a #

Show a => Show (Offset a) Source # 

Methods

showsPrec :: Int -> Offset a -> ShowS #

show :: Offset a -> String #

showList :: [Offset a] -> ShowS #

Generic (Offset a) Source # 

Associated Types

type Rep (Offset a) :: * -> * #

Methods

from :: Offset a -> Rep (Offset a) x #

to :: Rep (Offset a) x -> Offset a #

ToJSON a => ToJSON (Offset a) Source # 
FromJSON a => FromJSON (Offset a) Source # 
HasInfo (Offset a) Source # 

Associated Types

type Info (Offset a) :: * Source #

Methods

getInfo :: Offset a -> Info (Offset a) Source #

type EvalResult e (Offset a) Source # 
type EvalResult e (Offset a) = RecordSet e -> RecordSet e
type Rep (Offset a) Source # 
type Rep (Offset a) = D1 * (MetaData "Offset" "Database.Sql.Type.Query" "queryparser-0.1.0.1-L3r1ujeH5Ss7CLthXKM008" False) (C1 * (MetaCons "Offset" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Text))))
type Info (Offset a) Source # 
type Info (Offset a) = a

data Limit a Source #

Constructors

Limit a Text 

Instances

Functor Limit Source # 

Methods

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

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

Foldable Limit Source # 

Methods

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

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

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

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

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

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

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

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

toList :: Limit a -> [a] #

null :: Limit a -> Bool #

length :: Limit a -> Int #

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

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

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

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

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

Traversable Limit Source # 

Methods

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

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

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

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

Evaluation e => Evaluate e (Limit a) Source # 

Associated Types

type EvalResult e (Limit a) :: * Source #

Methods

eval :: Proxy * e -> Limit a -> EvalResult e (Limit a) Source #

Eq a => Eq (Limit a) Source # 

Methods

(==) :: Limit a -> Limit a -> Bool #

(/=) :: Limit a -> Limit a -> Bool #

Data a => Data (Limit a) Source # 

Methods

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

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

toConstr :: Limit a -> Constr #

dataTypeOf :: Limit a -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord a => Ord (Limit a) Source # 

Methods

compare :: Limit a -> Limit a -> Ordering #

(<) :: Limit a -> Limit a -> Bool #

(<=) :: Limit a -> Limit a -> Bool #

(>) :: Limit a -> Limit a -> Bool #

(>=) :: Limit a -> Limit a -> Bool #

max :: Limit a -> Limit a -> Limit a #

min :: Limit a -> Limit a -> Limit a #

Show a => Show (Limit a) Source # 

Methods

showsPrec :: Int -> Limit a -> ShowS #

show :: Limit a -> String #

showList :: [Limit a] -> ShowS #

Generic (Limit a) Source # 

Associated Types

type Rep (Limit a) :: * -> * #

Methods

from :: Limit a -> Rep (Limit a) x #

to :: Rep (Limit a) x -> Limit a #

ToJSON a => ToJSON (Limit a) Source # 
FromJSON a => FromJSON (Limit a) Source # 
HasInfo (Limit a) Source # 

Associated Types

type Info (Limit a) :: * Source #

Methods

getInfo :: Limit a -> Info (Limit a) Source #

type EvalResult e (Limit a) Source # 
type EvalResult e (Limit a) = RecordSet e -> RecordSet e
type Rep (Limit a) Source # 
type Rep (Limit a) = D1 * (MetaData "Limit" "Database.Sql.Type.Query" "queryparser-0.1.0.1-L3r1ujeH5Ss7CLthXKM008" False) (C1 * (MetaCons "Limit" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Text))))
type Info (Limit a) Source # 
type Info (Limit a) = a

data Selection r a Source #

Constructors

SelectStar a (Maybe (TableRef r a)) (StarReferents r a) 
SelectExpr a [ColumnAlias a] (Expr r a) 

Instances

Evaluation e => Evaluate e (Selection ResolvedNames Range) Source # 
ConstrainSASNames Functor r => Functor (Selection r) Source # 

Methods

fmap :: (a -> b) -> Selection r a -> Selection r b #

(<$) :: a -> Selection r b -> Selection r a #

ConstrainSASNames Foldable r => Foldable (Selection r) Source # 

Methods

fold :: Monoid m => Selection r m -> m #

foldMap :: Monoid m => (a -> m) -> Selection r a -> m #

foldr :: (a -> b -> b) -> b -> Selection r a -> b #

foldr' :: (a -> b -> b) -> b -> Selection r a -> b #

foldl :: (b -> a -> b) -> b -> Selection r a -> b #

foldl' :: (b -> a -> b) -> b -> Selection r a -> b #

foldr1 :: (a -> a -> a) -> Selection r a -> a #

foldl1 :: (a -> a -> a) -> Selection r a -> a #

toList :: Selection r a -> [a] #

null :: Selection r a -> Bool #

length :: Selection r a -> Int #

elem :: Eq a => a -> Selection r a -> Bool #

maximum :: Ord a => Selection r a -> a #

minimum :: Ord a => Selection r a -> a #

sum :: Num a => Selection r a -> a #

product :: Num a => Selection r a -> a #

ConstrainSASNames Traversable r => Traversable (Selection r) Source # 

Methods

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

sequenceA :: Applicative f => Selection r (f a) -> f (Selection r a) #

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

sequence :: Monad m => Selection r (m a) -> m (Selection r a) #

ConstrainSNames Eq r a => Eq (Selection r a) Source # 

Methods

(==) :: Selection r a -> Selection r a -> Bool #

(/=) :: Selection r a -> Selection r a -> Bool #

(ConstrainSNames Data r a, Data r) => Data (Selection r a) Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Selection r a -> c (Selection r a) #

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

toConstr :: Selection r a -> Constr #

dataTypeOf :: Selection r a -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Selection r a)) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Selection r a)) #

gmapT :: (forall b. Data b => b -> b) -> Selection r a -> Selection r a #

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

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

gmapQ :: (forall d. Data d => d -> u) -> Selection r a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Selection r a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Selection r a -> m (Selection r a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Selection r a -> m (Selection r a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Selection r a -> m (Selection r a) #

ConstrainSNames Ord r a => Ord (Selection r a) Source # 

Methods

compare :: Selection r a -> Selection r a -> Ordering #

(<) :: Selection r a -> Selection r a -> Bool #

(<=) :: Selection r a -> Selection r a -> Bool #

(>) :: Selection r a -> Selection r a -> Bool #

(>=) :: Selection r a -> Selection r a -> Bool #

max :: Selection r a -> Selection r a -> Selection r a #

min :: Selection r a -> Selection r a -> Selection r a #

ConstrainSNames Show r a => Show (Selection r a) Source # 

Methods

showsPrec :: Int -> Selection r a -> ShowS #

show :: Selection r a -> String #

showList :: [Selection r a] -> ShowS #

Generic (Selection r a) Source # 

Associated Types

type Rep (Selection r a) :: * -> * #

Methods

from :: Selection r a -> Rep (Selection r a) x #

to :: Rep (Selection r a) x -> Selection r a #

ConstrainSNames ToJSON r a => ToJSON (Selection r a) Source # 
ConstrainSNames FromJSON r a => FromJSON (Selection r a) Source # 
HasTables (Selection ResolvedNames a) Source # 
HasColumns (Selection ResolvedNames a) Source # 

Methods

goColumns :: Selection ResolvedNames a -> Observer Source #

HasInfo (Selection r a) Source # 

Associated Types

type Info (Selection r a) :: * Source #

Methods

getInfo :: Selection r a -> Info (Selection r a) Source #

type EvalResult e (Selection ResolvedNames Range) Source # 
type Rep (Selection r a) Source # 
type Info (Selection r a) Source # 
type Info (Selection r a) = a

data Constant a Source #

Constructors

StringConstant a ByteString

nb: Encoding *probably* matches server encoding, but there are ways to cram arbitrary byte sequences into strings on both Hive and Vertica.

NumericConstant a Text 
NullConstant a 
BooleanConstant a Bool 
TypedConstant a Text (DataType a) 
ParameterConstant a 

Instances

Functor Constant Source # 

Methods

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

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

Foldable Constant Source # 

Methods

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

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

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

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

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

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

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

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

toList :: Constant a -> [a] #

null :: Constant a -> Bool #

length :: Constant a -> Int #

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

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

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

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

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

Traversable Constant Source # 

Methods

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

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

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

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

Evaluation e => Evaluate e (Constant a) Source # 

Associated Types

type EvalResult e (Constant a) :: * Source #

Methods

eval :: Proxy * e -> Constant a -> EvalResult e (Constant a) Source #

Eq a => Eq (Constant a) Source # 

Methods

(==) :: Constant a -> Constant a -> Bool #

(/=) :: Constant a -> Constant a -> Bool #

Data a => Data (Constant a) Source # 

Methods

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

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

toConstr :: Constant a -> Constr #

dataTypeOf :: Constant a -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord a => Ord (Constant a) Source # 

Methods

compare :: Constant a -> Constant a -> Ordering #

(<) :: Constant a -> Constant a -> Bool #

(<=) :: Constant a -> Constant a -> Bool #

(>) :: Constant a -> Constant a -> Bool #

(>=) :: Constant a -> Constant a -> Bool #

max :: Constant a -> Constant a -> Constant a #

min :: Constant a -> Constant a -> Constant a #

Show a => Show (Constant a) Source # 

Methods

showsPrec :: Int -> Constant a -> ShowS #

show :: Constant a -> String #

showList :: [Constant a] -> ShowS #

Generic (Constant a) Source # 

Associated Types

type Rep (Constant a) :: * -> * #

Methods

from :: Constant a -> Rep (Constant a) x #

to :: Rep (Constant a) x -> Constant a #

Arbitrary a => Arbitrary (Constant a) Source # 

Methods

arbitrary :: Gen (Constant a) #

shrink :: Constant a -> [Constant a] #

ToJSON a => ToJSON (Constant a) Source # 
FromJSON a => FromJSON (Constant a) Source # 
HasInfo (Constant a) Source # 

Associated Types

type Info (Constant a) :: * Source #

Methods

getInfo :: Constant a -> Info (Constant a) Source #

type EvalResult e (Constant a) Source # 
type Rep (Constant a) Source # 
type Rep (Constant a) = D1 * (MetaData "Constant" "Database.Sql.Type.Query" "queryparser-0.1.0.1-L3r1ujeH5Ss7CLthXKM008" False) ((:+:) * ((:+:) * (C1 * (MetaCons "StringConstant" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * ByteString)))) ((:+:) * (C1 * (MetaCons "NumericConstant" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Text)))) (C1 * (MetaCons "NullConstant" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a))))) ((:+:) * (C1 * (MetaCons "BooleanConstant" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Bool)))) ((:+:) * (C1 * (MetaCons "TypedConstant" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a)) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Text)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (DataType a)))))) (C1 * (MetaCons "ParameterConstant" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a))))))
type Info (Constant a) Source # 
type Info (Constant a) = a

data DataTypeParam a Source #

Instances

Functor DataTypeParam Source # 

Methods

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

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

Foldable DataTypeParam Source # 

Methods

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

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

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

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

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

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

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

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

toList :: DataTypeParam a -> [a] #

null :: DataTypeParam a -> Bool #

length :: DataTypeParam a -> Int #

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

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

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

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

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

Traversable DataTypeParam Source # 

Methods

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

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

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

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

Eq a => Eq (DataTypeParam a) Source # 
Data a => Data (DataTypeParam a) Source # 

Methods

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

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

toConstr :: DataTypeParam a -> Constr #

dataTypeOf :: DataTypeParam a -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord a => Ord (DataTypeParam a) Source # 
Show a => Show (DataTypeParam a) Source # 
Generic (DataTypeParam a) Source # 

Associated Types

type Rep (DataTypeParam a) :: * -> * #

ToJSON a => ToJSON (DataTypeParam a) Source # 
FromJSON a => FromJSON (DataTypeParam a) Source # 
HasInfo (DataTypeParam a) Source # 

Associated Types

type Info (DataTypeParam a) :: * Source #

type Rep (DataTypeParam a) Source # 
type Rep (DataTypeParam a) = D1 * (MetaData "DataTypeParam" "Database.Sql.Type.Query" "queryparser-0.1.0.1-L3r1ujeH5Ss7CLthXKM008" False) ((:+:) * (C1 * (MetaCons "DataTypeParamConstant" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Constant a)))) (C1 * (MetaCons "DataTypeParamType" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (DataType a)))))
type Info (DataTypeParam a) Source # 
type Info (DataTypeParam a) = a

data DataType a Source #

Instances

Functor DataType Source # 

Methods

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

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

Foldable DataType Source # 

Methods

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

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

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

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

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

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

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

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

toList :: DataType a -> [a] #

null :: DataType a -> Bool #

length :: DataType a -> Int #

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

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

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

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

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

Traversable DataType Source # 

Methods

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

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

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

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

Eq a => Eq (DataType a) Source # 

Methods

(==) :: DataType a -> DataType a -> Bool #

(/=) :: DataType a -> DataType a -> Bool #

Data a => Data (DataType a) Source # 

Methods

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

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

toConstr :: DataType a -> Constr #

dataTypeOf :: DataType a -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord a => Ord (DataType a) Source # 

Methods

compare :: DataType a -> DataType a -> Ordering #

(<) :: DataType a -> DataType a -> Bool #

(<=) :: DataType a -> DataType a -> Bool #

(>) :: DataType a -> DataType a -> Bool #

(>=) :: DataType a -> DataType a -> Bool #

max :: DataType a -> DataType a -> DataType a #

min :: DataType a -> DataType a -> DataType a #

Show a => Show (DataType a) Source # 

Methods

showsPrec :: Int -> DataType a -> ShowS #

show :: DataType a -> String #

showList :: [DataType a] -> ShowS #

Generic (DataType a) Source #