{-# LANGUAGE TemplateHaskell, TypeFamilies, DeriveTraversable, GeneralizedNewtypeDeriving, DerivingVia, DeriveAnyClass, DeriveGeneric, StandaloneDeriving, FlexibleInstances #-}
module ProjectM36.SQL.Select where
import qualified Data.List.NonEmpty as NE
import Data.Text (Text)
import Data.Functor.Foldable.TH
import Codec.Winery
import GHC.Generics
import Control.DeepSeq
import Data.Hashable

data Query = QuerySelect Select |
             QueryValues [[ScalarExpr]] |
             QueryTable TableName |
             QueryOp QueryOperator Query Query
             deriving (Int -> Query -> ShowS
[Query] -> ShowS
Query -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Query] -> ShowS
$cshowList :: [Query] -> ShowS
show :: Query -> String
$cshow :: Query -> String
showsPrec :: Int -> Query -> ShowS
$cshowsPrec :: Int -> Query -> ShowS
Show, Query -> Query -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Query -> Query -> Bool
$c/= :: Query -> Query -> Bool
== :: Query -> Query -> Bool
$c== :: Query -> Query -> Bool
Eq, forall x. Rep Query x -> Query
forall x. Query -> Rep Query x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Query x -> Query
$cfrom :: forall x. Query -> Rep Query x
Generic, Query -> ()
forall a. (a -> ()) -> NFData a
rnf :: Query -> ()
$crnf :: Query -> ()
NFData)
             deriving Typeable Query
BundleSerialise Query
Extractor Query
Decoder Query
Proxy Query -> SchemaGen Schema
Query -> Builder
forall a.
Typeable a
-> (Proxy a -> SchemaGen Schema)
-> (a -> Builder)
-> Extractor a
-> Decoder a
-> BundleSerialise a
-> Serialise a
bundleSerialise :: BundleSerialise Query
$cbundleSerialise :: BundleSerialise Query
decodeCurrent :: Decoder Query
$cdecodeCurrent :: Decoder Query
extractor :: Extractor Query
$cextractor :: Extractor Query
toBuilder :: Query -> Builder
$ctoBuilder :: Query -> Builder
schemaGen :: Proxy Query -> SchemaGen Schema
$cschemaGen :: Proxy Query -> SchemaGen Schema
Serialise via WineryVariant Query

data QueryOperator = UnionQueryOperator | IntersectQueryOperator | ExceptQueryOperator
  deriving (Int -> QueryOperator -> ShowS
[QueryOperator] -> ShowS
QueryOperator -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [QueryOperator] -> ShowS
$cshowList :: [QueryOperator] -> ShowS
show :: QueryOperator -> String
$cshow :: QueryOperator -> String
showsPrec :: Int -> QueryOperator -> ShowS
$cshowsPrec :: Int -> QueryOperator -> ShowS
Show, QueryOperator -> QueryOperator -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: QueryOperator -> QueryOperator -> Bool
$c/= :: QueryOperator -> QueryOperator -> Bool
== :: QueryOperator -> QueryOperator -> Bool
$c== :: QueryOperator -> QueryOperator -> Bool
Eq, forall x. Rep QueryOperator x -> QueryOperator
forall x. QueryOperator -> Rep QueryOperator x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep QueryOperator x -> QueryOperator
$cfrom :: forall x. QueryOperator -> Rep QueryOperator x
Generic, QueryOperator -> ()
forall a. (a -> ()) -> NFData a
rnf :: QueryOperator -> ()
$crnf :: QueryOperator -> ()
NFData)
  deriving Typeable QueryOperator
BundleSerialise QueryOperator
Extractor QueryOperator
Decoder QueryOperator
Proxy QueryOperator -> SchemaGen Schema
QueryOperator -> Builder
forall a.
Typeable a
-> (Proxy a -> SchemaGen Schema)
-> (a -> Builder)
-> Extractor a
-> Decoder a
-> BundleSerialise a
-> Serialise a
bundleSerialise :: BundleSerialise QueryOperator
$cbundleSerialise :: BundleSerialise QueryOperator
decodeCurrent :: Decoder QueryOperator
$cdecodeCurrent :: Decoder QueryOperator
extractor :: Extractor QueryOperator
$cextractor :: Extractor QueryOperator
toBuilder :: QueryOperator -> Builder
$ctoBuilder :: QueryOperator -> Builder
schemaGen :: Proxy QueryOperator -> SchemaGen Schema
$cschemaGen :: Proxy QueryOperator -> SchemaGen Schema
Serialise via WineryVariant QueryOperator

data Select = Select { Select -> Maybe Distinctness
distinctness :: Maybe Distinctness,
                       Select -> [SelectItem]
projectionClause :: [SelectItem],
                       Select -> Maybe TableExpr
tableExpr :: Maybe TableExpr,
                       Select -> Maybe WithClause
withClause :: Maybe WithClause
                     }
              deriving (Int -> Select -> ShowS
[Select] -> ShowS
Select -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Select] -> ShowS
$cshowList :: [Select] -> ShowS
show :: Select -> String
$cshow :: Select -> String
showsPrec :: Int -> Select -> ShowS
$cshowsPrec :: Int -> Select -> ShowS
Show, Select -> Select -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Select -> Select -> Bool
$c/= :: Select -> Select -> Bool
== :: Select -> Select -> Bool
$c== :: Select -> Select -> Bool
Eq, forall x. Rep Select x -> Select
forall x. Select -> Rep Select x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Select x -> Select
$cfrom :: forall x. Select -> Rep Select x
Generic, Select -> ()
forall a. (a -> ()) -> NFData a
rnf :: Select -> ()
$crnf :: Select -> ()
NFData)
              deriving Typeable Select
BundleSerialise Select
Extractor Select
Decoder Select
Proxy Select -> SchemaGen Schema
Select -> Builder
forall a.
Typeable a
-> (Proxy a -> SchemaGen Schema)
-> (a -> Builder)
-> Extractor a
-> Decoder a
-> BundleSerialise a
-> Serialise a
bundleSerialise :: BundleSerialise Select
$cbundleSerialise :: BundleSerialise Select
decodeCurrent :: Decoder Select
$cdecodeCurrent :: Decoder Select
extractor :: Extractor Select
$cextractor :: Extractor Select
toBuilder :: Select -> Builder
$ctoBuilder :: Select -> Builder
schemaGen :: Proxy Select -> SchemaGen Schema
$cschemaGen :: Proxy Select -> SchemaGen Schema
Serialise via WineryRecord Select

instance Hashable Select

emptySelect :: Select
emptySelect :: Select
emptySelect = Select { distinctness :: Maybe Distinctness
distinctness = forall a. Maybe a
Nothing,
                       projectionClause :: [SelectItem]
projectionClause = [],
                       tableExpr :: Maybe TableExpr
tableExpr = forall a. Maybe a
Nothing,
                       withClause :: Maybe WithClause
withClause = forall a. Maybe a
Nothing
                     }

type SelectItem = (ProjectionScalarExpr, Maybe ColumnAlias)

data WithClause = WithClause { WithClause -> Bool
isRecursive :: Bool,
                               WithClause -> NonEmpty WithExpr
withExprs :: NE.NonEmpty WithExpr }
                  deriving (Int -> WithClause -> ShowS
[WithClause] -> ShowS
WithClause -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [WithClause] -> ShowS
$cshowList :: [WithClause] -> ShowS
show :: WithClause -> String
$cshow :: WithClause -> String
showsPrec :: Int -> WithClause -> ShowS
$cshowsPrec :: Int -> WithClause -> ShowS
Show, WithClause -> WithClause -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: WithClause -> WithClause -> Bool
$c/= :: WithClause -> WithClause -> Bool
== :: WithClause -> WithClause -> Bool
$c== :: WithClause -> WithClause -> Bool
Eq, forall x. Rep WithClause x -> WithClause
forall x. WithClause -> Rep WithClause x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep WithClause x -> WithClause
$cfrom :: forall x. WithClause -> Rep WithClause x
Generic, WithClause -> ()
forall a. (a -> ()) -> NFData a
rnf :: WithClause -> ()
$crnf :: WithClause -> ()
NFData)
                  deriving Typeable WithClause
BundleSerialise WithClause
Extractor WithClause
Decoder WithClause
Proxy WithClause -> SchemaGen Schema
WithClause -> Builder
forall a.
Typeable a
-> (Proxy a -> SchemaGen Schema)
-> (a -> Builder)
-> Extractor a
-> Decoder a
-> BundleSerialise a
-> Serialise a
bundleSerialise :: BundleSerialise WithClause
$cbundleSerialise :: BundleSerialise WithClause
decodeCurrent :: Decoder WithClause
$cdecodeCurrent :: Decoder WithClause
extractor :: Extractor WithClause
$cextractor :: Extractor WithClause
toBuilder :: WithClause -> Builder
$ctoBuilder :: WithClause -> Builder
schemaGen :: Proxy WithClause -> SchemaGen Schema
$cschemaGen :: Proxy WithClause -> SchemaGen Schema
Serialise via WineryRecord WithClause
                  deriving Eq WithClause
Int -> WithClause -> Int
WithClause -> Int
forall a. Eq a -> (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: WithClause -> Int
$chash :: WithClause -> Int
hashWithSalt :: Int -> WithClause -> Int
$chashWithSalt :: Int -> WithClause -> Int
Hashable

data WithExpr = WithExpr WithExprAlias Select
  deriving (Int -> WithExpr -> ShowS
[WithExpr] -> ShowS
WithExpr -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [WithExpr] -> ShowS
$cshowList :: [WithExpr] -> ShowS
show :: WithExpr -> String
$cshow :: WithExpr -> String
showsPrec :: Int -> WithExpr -> ShowS
$cshowsPrec :: Int -> WithExpr -> ShowS
Show, WithExpr -> WithExpr -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: WithExpr -> WithExpr -> Bool
$c/= :: WithExpr -> WithExpr -> Bool
== :: WithExpr -> WithExpr -> Bool
$c== :: WithExpr -> WithExpr -> Bool
Eq, forall x. Rep WithExpr x -> WithExpr
forall x. WithExpr -> Rep WithExpr x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep WithExpr x -> WithExpr
$cfrom :: forall x. WithExpr -> Rep WithExpr x
Generic, WithExpr -> ()
forall a. (a -> ()) -> NFData a
rnf :: WithExpr -> ()
$crnf :: WithExpr -> ()
NFData)
  deriving Typeable WithExpr
BundleSerialise WithExpr
Extractor WithExpr
Decoder WithExpr
Proxy WithExpr -> SchemaGen Schema
WithExpr -> Builder
forall a.
Typeable a
-> (Proxy a -> SchemaGen Schema)
-> (a -> Builder)
-> Extractor a
-> Decoder a
-> BundleSerialise a
-> Serialise a
bundleSerialise :: BundleSerialise WithExpr
$cbundleSerialise :: BundleSerialise WithExpr
decodeCurrent :: Decoder WithExpr
$cdecodeCurrent :: Decoder WithExpr
extractor :: Extractor WithExpr
$cextractor :: Extractor WithExpr
toBuilder :: WithExpr -> Builder
$ctoBuilder :: WithExpr -> Builder
schemaGen :: Proxy WithExpr -> SchemaGen Schema
$cschemaGen :: Proxy WithExpr -> SchemaGen Schema
Serialise via WineryVariant WithExpr
  deriving Eq WithExpr
Int -> WithExpr -> Int
WithExpr -> Int
forall a. Eq a -> (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: WithExpr -> Int
$chash :: WithExpr -> Int
hashWithSalt :: Int -> WithExpr -> Int
$chashWithSalt :: Int -> WithExpr -> Int
Hashable

newtype WithExprAlias = WithExprAlias Text
  deriving (Int -> WithExprAlias -> ShowS
[WithExprAlias] -> ShowS
WithExprAlias -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [WithExprAlias] -> ShowS
$cshowList :: [WithExprAlias] -> ShowS
show :: WithExprAlias -> String
$cshow :: WithExprAlias -> String
showsPrec :: Int -> WithExprAlias -> ShowS
$cshowsPrec :: Int -> WithExprAlias -> ShowS
Show, WithExprAlias -> WithExprAlias -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: WithExprAlias -> WithExprAlias -> Bool
$c/= :: WithExprAlias -> WithExprAlias -> Bool
== :: WithExprAlias -> WithExprAlias -> Bool
$c== :: WithExprAlias -> WithExprAlias -> Bool
Eq, forall x. Rep WithExprAlias x -> WithExprAlias
forall x. WithExprAlias -> Rep WithExprAlias x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep WithExprAlias x -> WithExprAlias
$cfrom :: forall x. WithExprAlias -> Rep WithExprAlias x
Generic)
  deriving Typeable WithExprAlias
BundleSerialise WithExprAlias
Extractor WithExprAlias
Decoder WithExprAlias
Proxy WithExprAlias -> SchemaGen Schema
WithExprAlias -> Builder
forall a.
Typeable a
-> (Proxy a -> SchemaGen Schema)
-> (a -> Builder)
-> Extractor a
-> Decoder a
-> BundleSerialise a
-> Serialise a
bundleSerialise :: BundleSerialise WithExprAlias
$cbundleSerialise :: BundleSerialise WithExprAlias
decodeCurrent :: Decoder WithExprAlias
$cdecodeCurrent :: Decoder WithExprAlias
extractor :: Extractor WithExprAlias
$cextractor :: Extractor WithExprAlias
toBuilder :: WithExprAlias -> Builder
$ctoBuilder :: WithExprAlias -> Builder
schemaGen :: Proxy WithExprAlias -> SchemaGen Schema
$cschemaGen :: Proxy WithExprAlias -> SchemaGen Schema
Serialise via WineryVariant WithExprAlias
  deriving newtype WithExprAlias -> ()
forall a. (a -> ()) -> NFData a
rnf :: WithExprAlias -> ()
$crnf :: WithExprAlias -> ()
NFData
  deriving anyclass Eq WithExprAlias
Int -> WithExprAlias -> Int
WithExprAlias -> Int
forall a. Eq a -> (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: WithExprAlias -> Int
$chash :: WithExprAlias -> Int
hashWithSalt :: Int -> WithExprAlias -> Int
$chashWithSalt :: Int -> WithExprAlias -> Int
Hashable

data InFlag = In | NotIn
  deriving (Int -> InFlag -> ShowS
[InFlag] -> ShowS
InFlag -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [InFlag] -> ShowS
$cshowList :: [InFlag] -> ShowS
show :: InFlag -> String
$cshow :: InFlag -> String
showsPrec :: Int -> InFlag -> ShowS
$cshowsPrec :: Int -> InFlag -> ShowS
Show, InFlag -> InFlag -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: InFlag -> InFlag -> Bool
$c/= :: InFlag -> InFlag -> Bool
== :: InFlag -> InFlag -> Bool
$c== :: InFlag -> InFlag -> Bool
Eq, forall x. Rep InFlag x -> InFlag
forall x. InFlag -> Rep InFlag x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep InFlag x -> InFlag
$cfrom :: forall x. InFlag -> Rep InFlag x
Generic, InFlag -> ()
forall a. (a -> ()) -> NFData a
rnf :: InFlag -> ()
$crnf :: InFlag -> ()
NFData)
  deriving Typeable InFlag
BundleSerialise InFlag
Extractor InFlag
Decoder InFlag
Proxy InFlag -> SchemaGen Schema
InFlag -> Builder
forall a.
Typeable a
-> (Proxy a -> SchemaGen Schema)
-> (a -> Builder)
-> Extractor a
-> Decoder a
-> BundleSerialise a
-> Serialise a
bundleSerialise :: BundleSerialise InFlag
$cbundleSerialise :: BundleSerialise InFlag
decodeCurrent :: Decoder InFlag
$cdecodeCurrent :: Decoder InFlag
extractor :: Extractor InFlag
$cextractor :: Extractor InFlag
toBuilder :: InFlag -> Builder
$ctoBuilder :: InFlag -> Builder
schemaGen :: Proxy InFlag -> SchemaGen Schema
$cschemaGen :: Proxy InFlag -> SchemaGen Schema
Serialise via WineryVariant InFlag
  deriving Eq InFlag
Int -> InFlag -> Int
InFlag -> Int
forall a. Eq a -> (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: InFlag -> Int
$chash :: InFlag -> Int
hashWithSalt :: Int -> InFlag -> Int
$chashWithSalt :: Int -> InFlag -> Int
Hashable

data ComparisonOperator = OpLT | OpGT | OpGTE | OpEQ | OpNE | OpLTE
  deriving (Int -> ComparisonOperator -> ShowS
[ComparisonOperator] -> ShowS
ComparisonOperator -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ComparisonOperator] -> ShowS
$cshowList :: [ComparisonOperator] -> ShowS
show :: ComparisonOperator -> String
$cshow :: ComparisonOperator -> String
showsPrec :: Int -> ComparisonOperator -> ShowS
$cshowsPrec :: Int -> ComparisonOperator -> ShowS
Show, ComparisonOperator -> ComparisonOperator -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ComparisonOperator -> ComparisonOperator -> Bool
$c/= :: ComparisonOperator -> ComparisonOperator -> Bool
== :: ComparisonOperator -> ComparisonOperator -> Bool
$c== :: ComparisonOperator -> ComparisonOperator -> Bool
Eq, forall x. Rep ComparisonOperator x -> ComparisonOperator
forall x. ComparisonOperator -> Rep ComparisonOperator x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ComparisonOperator x -> ComparisonOperator
$cfrom :: forall x. ComparisonOperator -> Rep ComparisonOperator x
Generic, ComparisonOperator -> ()
forall a. (a -> ()) -> NFData a
rnf :: ComparisonOperator -> ()
$crnf :: ComparisonOperator -> ()
NFData)
  deriving Typeable ComparisonOperator
BundleSerialise ComparisonOperator
Extractor ComparisonOperator
Decoder ComparisonOperator
Proxy ComparisonOperator -> SchemaGen Schema
ComparisonOperator -> Builder
forall a.
Typeable a
-> (Proxy a -> SchemaGen Schema)
-> (a -> Builder)
-> Extractor a
-> Decoder a
-> BundleSerialise a
-> Serialise a
bundleSerialise :: BundleSerialise ComparisonOperator
$cbundleSerialise :: BundleSerialise ComparisonOperator
decodeCurrent :: Decoder ComparisonOperator
$cdecodeCurrent :: Decoder ComparisonOperator
extractor :: Extractor ComparisonOperator
$cextractor :: Extractor ComparisonOperator
toBuilder :: ComparisonOperator -> Builder
$ctoBuilder :: ComparisonOperator -> Builder
schemaGen :: Proxy ComparisonOperator -> SchemaGen Schema
$cschemaGen :: Proxy ComparisonOperator -> SchemaGen Schema
Serialise via WineryVariant ComparisonOperator

instance Hashable ComparisonOperator

data QuantifiedComparisonPredicate = QCAny | QCSome | QCAll
  deriving (Int -> QuantifiedComparisonPredicate -> ShowS
[QuantifiedComparisonPredicate] -> ShowS
QuantifiedComparisonPredicate -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [QuantifiedComparisonPredicate] -> ShowS
$cshowList :: [QuantifiedComparisonPredicate] -> ShowS
show :: QuantifiedComparisonPredicate -> String
$cshow :: QuantifiedComparisonPredicate -> String
showsPrec :: Int -> QuantifiedComparisonPredicate -> ShowS
$cshowsPrec :: Int -> QuantifiedComparisonPredicate -> ShowS
Show, QuantifiedComparisonPredicate
-> QuantifiedComparisonPredicate -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: QuantifiedComparisonPredicate
-> QuantifiedComparisonPredicate -> Bool
$c/= :: QuantifiedComparisonPredicate
-> QuantifiedComparisonPredicate -> Bool
== :: QuantifiedComparisonPredicate
-> QuantifiedComparisonPredicate -> Bool
$c== :: QuantifiedComparisonPredicate
-> QuantifiedComparisonPredicate -> Bool
Eq, forall x.
Rep QuantifiedComparisonPredicate x
-> QuantifiedComparisonPredicate
forall x.
QuantifiedComparisonPredicate
-> Rep QuantifiedComparisonPredicate x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep QuantifiedComparisonPredicate x
-> QuantifiedComparisonPredicate
$cfrom :: forall x.
QuantifiedComparisonPredicate
-> Rep QuantifiedComparisonPredicate x
Generic, QuantifiedComparisonPredicate -> ()
forall a. (a -> ()) -> NFData a
rnf :: QuantifiedComparisonPredicate -> ()
$crnf :: QuantifiedComparisonPredicate -> ()
NFData)
  deriving Typeable QuantifiedComparisonPredicate
BundleSerialise QuantifiedComparisonPredicate
Extractor QuantifiedComparisonPredicate
Decoder QuantifiedComparisonPredicate
Proxy QuantifiedComparisonPredicate -> SchemaGen Schema
QuantifiedComparisonPredicate -> Builder
forall a.
Typeable a
-> (Proxy a -> SchemaGen Schema)
-> (a -> Builder)
-> Extractor a
-> Decoder a
-> BundleSerialise a
-> Serialise a
bundleSerialise :: BundleSerialise QuantifiedComparisonPredicate
$cbundleSerialise :: BundleSerialise QuantifiedComparisonPredicate
decodeCurrent :: Decoder QuantifiedComparisonPredicate
$cdecodeCurrent :: Decoder QuantifiedComparisonPredicate
extractor :: Extractor QuantifiedComparisonPredicate
$cextractor :: Extractor QuantifiedComparisonPredicate
toBuilder :: QuantifiedComparisonPredicate -> Builder
$ctoBuilder :: QuantifiedComparisonPredicate -> Builder
schemaGen :: Proxy QuantifiedComparisonPredicate -> SchemaGen Schema
$cschemaGen :: Proxy QuantifiedComparisonPredicate -> SchemaGen Schema
Serialise via WineryVariant QuantifiedComparisonPredicate

instance Hashable QuantifiedComparisonPredicate

data TableRef = SimpleTableRef TableName
              | InnerJoinTableRef TableRef JoinCondition
              | RightOuterJoinTableRef TableRef JoinCondition
              | LeftOuterJoinTableRef TableRef JoinCondition
              | FullOuterJoinTableRef TableRef JoinCondition
              | CrossJoinTableRef TableRef
              | NaturalJoinTableRef TableRef
              | AliasedTableRef TableRef TableAlias
              | QueryTableRef Select
              deriving (Int -> TableRef -> ShowS
[TableRef] -> ShowS
TableRef -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TableRef] -> ShowS
$cshowList :: [TableRef] -> ShowS
show :: TableRef -> String
$cshow :: TableRef -> String
showsPrec :: Int -> TableRef -> ShowS
$cshowsPrec :: Int -> TableRef -> ShowS
Show, TableRef -> TableRef -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TableRef -> TableRef -> Bool
$c/= :: TableRef -> TableRef -> Bool
== :: TableRef -> TableRef -> Bool
$c== :: TableRef -> TableRef -> Bool
Eq, forall x. Rep TableRef x -> TableRef
forall x. TableRef -> Rep TableRef x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep TableRef x -> TableRef
$cfrom :: forall x. TableRef -> Rep TableRef x
Generic, TableRef -> ()
forall a. (a -> ()) -> NFData a
rnf :: TableRef -> ()
$crnf :: TableRef -> ()
NFData)
              deriving Typeable TableRef
BundleSerialise TableRef
Extractor TableRef
Decoder TableRef
Proxy TableRef -> SchemaGen Schema
TableRef -> Builder
forall a.
Typeable a
-> (Proxy a -> SchemaGen Schema)
-> (a -> Builder)
-> Extractor a
-> Decoder a
-> BundleSerialise a
-> Serialise a
bundleSerialise :: BundleSerialise TableRef
$cbundleSerialise :: BundleSerialise TableRef
decodeCurrent :: Decoder TableRef
$cdecodeCurrent :: Decoder TableRef
extractor :: Extractor TableRef
$cextractor :: Extractor TableRef
toBuilder :: TableRef -> Builder
$ctoBuilder :: TableRef -> Builder
schemaGen :: Proxy TableRef -> SchemaGen Schema
$cschemaGen :: Proxy TableRef -> SchemaGen Schema
Serialise via WineryVariant TableRef
              deriving Eq TableRef
Int -> TableRef -> Int
TableRef -> Int
forall a. Eq a -> (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: TableRef -> Int
$chash :: TableRef -> Int
hashWithSalt :: Int -> TableRef -> Int
$chashWithSalt :: Int -> TableRef -> Int
Hashable

-- distinguish between projection attributes which may include an asterisk and scalar expressions (such as in a where clause) where an asterisk is invalid
type ProjectionScalarExpr = ScalarExprBase ColumnProjectionName

deriving via WineryVariant ProjectionScalarExpr instance Serialise ProjectionScalarExpr

type ScalarExpr = ScalarExprBase ColumnName

deriving via WineryVariant ScalarExpr instance Serialise ScalarExpr

data ScalarExprBase n =
  IntegerLiteral Integer
  | DoubleLiteral Double
  | StringLiteral Text
  | BooleanLiteral Bool
  | NullLiteral
    -- | Interval
  | Identifier n
  | BinaryOperator (ScalarExprBase n) OperatorName (ScalarExprBase n)
  | PrefixOperator OperatorName (ScalarExprBase n)
  | PostfixOperator (ScalarExprBase n) OperatorName
  | BetweenOperator (ScalarExprBase n) (ScalarExprBase n) (ScalarExprBase n)
  | FunctionApplication FuncName [ScalarExprBase n]
  | CaseExpr { forall n.
ScalarExprBase n -> [(ScalarExprBase n, ScalarExprBase n)]
caseWhens :: [(ScalarExprBase n,ScalarExprBase n)],
               forall n. ScalarExprBase n -> Maybe (ScalarExprBase n)
caseElse :: Maybe (ScalarExprBase n) }
  | QuantifiedComparison { forall n. ScalarExprBase n -> ScalarExprBase n
qcExpr :: ScalarExprBase n,
                           forall n. ScalarExprBase n -> ComparisonOperator
qcOperator :: ComparisonOperator,
                           forall n. ScalarExprBase n -> QuantifiedComparisonPredicate
qcPredicate :: QuantifiedComparisonPredicate,
                           forall n. ScalarExprBase n -> Select
qcQuery :: Select }
    
  | InExpr InFlag (ScalarExprBase n) InPredicateValue
    -- | ExistsSubQuery Select
    -- | UniqueSubQuery Select
    -- | ScalarSubQuery Select
  | BooleanOperatorExpr (ScalarExprBase n) BoolOp (ScalarExprBase n)
  | ExistsExpr Select
  deriving (Int -> ScalarExprBase n -> ShowS
forall n. Show n => Int -> ScalarExprBase n -> ShowS
forall n. Show n => [ScalarExprBase n] -> ShowS
forall n. Show n => ScalarExprBase n -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ScalarExprBase n] -> ShowS
$cshowList :: forall n. Show n => [ScalarExprBase n] -> ShowS
show :: ScalarExprBase n -> String
$cshow :: forall n. Show n => ScalarExprBase n -> String
showsPrec :: Int -> ScalarExprBase n -> ShowS
$cshowsPrec :: forall n. Show n => Int -> ScalarExprBase n -> ShowS
Show, ScalarExprBase n -> ScalarExprBase n -> Bool
forall n. Eq n => ScalarExprBase n -> ScalarExprBase n -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ScalarExprBase n -> ScalarExprBase n -> Bool
$c/= :: forall n. Eq n => ScalarExprBase n -> ScalarExprBase n -> Bool
== :: ScalarExprBase n -> ScalarExprBase n -> Bool
$c== :: forall n. Eq n => ScalarExprBase n -> ScalarExprBase n -> Bool
Eq, forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall n x. Rep (ScalarExprBase n) x -> ScalarExprBase n
forall n x. ScalarExprBase n -> Rep (ScalarExprBase n) x
$cto :: forall n x. Rep (ScalarExprBase n) x -> ScalarExprBase n
$cfrom :: forall n x. ScalarExprBase n -> Rep (ScalarExprBase n) x
Generic, forall n. NFData n => ScalarExprBase n -> ()
forall a. (a -> ()) -> NFData a
rnf :: ScalarExprBase n -> ()
$crnf :: forall n. NFData n => ScalarExprBase n -> ()
NFData)

instance (Hashable n, Eq n) => Hashable (ScalarExprBase n)

data BoolOp = AndOp | OrOp
  deriving (BoolOp -> BoolOp -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BoolOp -> BoolOp -> Bool
$c/= :: BoolOp -> BoolOp -> Bool
== :: BoolOp -> BoolOp -> Bool
$c== :: BoolOp -> BoolOp -> Bool
Eq, Int -> BoolOp -> ShowS
[BoolOp] -> ShowS
BoolOp -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BoolOp] -> ShowS
$cshowList :: [BoolOp] -> ShowS
show :: BoolOp -> String
$cshow :: BoolOp -> String
showsPrec :: Int -> BoolOp -> ShowS
$cshowsPrec :: Int -> BoolOp -> ShowS
Show, forall x. Rep BoolOp x -> BoolOp
forall x. BoolOp -> Rep BoolOp x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep BoolOp x -> BoolOp
$cfrom :: forall x. BoolOp -> Rep BoolOp x
Generic, BoolOp -> ()
forall a. (a -> ()) -> NFData a
rnf :: BoolOp -> ()
$crnf :: BoolOp -> ()
NFData)
  deriving Typeable BoolOp
BundleSerialise BoolOp
Extractor BoolOp
Decoder BoolOp
Proxy BoolOp -> SchemaGen Schema
BoolOp -> Builder
forall a.
Typeable a
-> (Proxy a -> SchemaGen Schema)
-> (a -> Builder)
-> Extractor a
-> Decoder a
-> BundleSerialise a
-> Serialise a
bundleSerialise :: BundleSerialise BoolOp
$cbundleSerialise :: BundleSerialise BoolOp
decodeCurrent :: Decoder BoolOp
$cdecodeCurrent :: Decoder BoolOp
extractor :: Extractor BoolOp
$cextractor :: Extractor BoolOp
toBuilder :: BoolOp -> Builder
$ctoBuilder :: BoolOp -> Builder
schemaGen :: Proxy BoolOp -> SchemaGen Schema
$cschemaGen :: Proxy BoolOp -> SchemaGen Schema
Serialise via WineryVariant BoolOp
  deriving Eq BoolOp
Int -> BoolOp -> Int
BoolOp -> Int
forall a. Eq a -> (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: BoolOp -> Int
$chash :: BoolOp -> Int
hashWithSalt :: Int -> BoolOp -> Int
$chashWithSalt :: Int -> BoolOp -> Int
Hashable

data InPredicateValue = InList [ScalarExpr] | InQueryExpr Select | InScalarExpr ScalarExpr
  deriving (InPredicateValue -> InPredicateValue -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: InPredicateValue -> InPredicateValue -> Bool
$c/= :: InPredicateValue -> InPredicateValue -> Bool
== :: InPredicateValue -> InPredicateValue -> Bool
$c== :: InPredicateValue -> InPredicateValue -> Bool
Eq, Int -> InPredicateValue -> ShowS
[InPredicateValue] -> ShowS
InPredicateValue -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [InPredicateValue] -> ShowS
$cshowList :: [InPredicateValue] -> ShowS
show :: InPredicateValue -> String
$cshow :: InPredicateValue -> String
showsPrec :: Int -> InPredicateValue -> ShowS
$cshowsPrec :: Int -> InPredicateValue -> ShowS
Show, forall x. Rep InPredicateValue x -> InPredicateValue
forall x. InPredicateValue -> Rep InPredicateValue x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep InPredicateValue x -> InPredicateValue
$cfrom :: forall x. InPredicateValue -> Rep InPredicateValue x
Generic, InPredicateValue -> ()
forall a. (a -> ()) -> NFData a
rnf :: InPredicateValue -> ()
$crnf :: InPredicateValue -> ()
NFData)
  deriving Typeable InPredicateValue
BundleSerialise InPredicateValue
Extractor InPredicateValue
Decoder InPredicateValue
Proxy InPredicateValue -> SchemaGen Schema
InPredicateValue -> Builder
forall a.
Typeable a
-> (Proxy a -> SchemaGen Schema)
-> (a -> Builder)
-> Extractor a
-> Decoder a
-> BundleSerialise a
-> Serialise a
bundleSerialise :: BundleSerialise InPredicateValue
$cbundleSerialise :: BundleSerialise InPredicateValue
decodeCurrent :: Decoder InPredicateValue
$cdecodeCurrent :: Decoder InPredicateValue
extractor :: Extractor InPredicateValue
$cextractor :: Extractor InPredicateValue
toBuilder :: InPredicateValue -> Builder
$ctoBuilder :: InPredicateValue -> Builder
schemaGen :: Proxy InPredicateValue -> SchemaGen Schema
$cschemaGen :: Proxy InPredicateValue -> SchemaGen Schema
Serialise via WineryVariant InPredicateValue
  deriving Eq InPredicateValue
Int -> InPredicateValue -> Int
InPredicateValue -> Int
forall a. Eq a -> (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: InPredicateValue -> Int
$chash :: InPredicateValue -> Int
hashWithSalt :: Int -> InPredicateValue -> Int
$chashWithSalt :: Int -> InPredicateValue -> Int
Hashable

newtype GroupByExpr = GroupByExpr ProjectionScalarExpr
  deriving (Int -> GroupByExpr -> ShowS
[GroupByExpr] -> ShowS
GroupByExpr -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GroupByExpr] -> ShowS
$cshowList :: [GroupByExpr] -> ShowS
show :: GroupByExpr -> String
$cshow :: GroupByExpr -> String
showsPrec :: Int -> GroupByExpr -> ShowS
$cshowsPrec :: Int -> GroupByExpr -> ShowS
Show, GroupByExpr -> GroupByExpr -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GroupByExpr -> GroupByExpr -> Bool
$c/= :: GroupByExpr -> GroupByExpr -> Bool
== :: GroupByExpr -> GroupByExpr -> Bool
$c== :: GroupByExpr -> GroupByExpr -> Bool
Eq, forall x. Rep GroupByExpr x -> GroupByExpr
forall x. GroupByExpr -> Rep GroupByExpr x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep GroupByExpr x -> GroupByExpr
$cfrom :: forall x. GroupByExpr -> Rep GroupByExpr x
Generic)
  deriving Typeable GroupByExpr
BundleSerialise GroupByExpr
Extractor GroupByExpr
Decoder GroupByExpr
Proxy GroupByExpr -> SchemaGen Schema
GroupByExpr -> Builder
forall a.
Typeable a
-> (Proxy a -> SchemaGen Schema)
-> (a -> Builder)
-> Extractor a
-> Decoder a
-> BundleSerialise a
-> Serialise a
bundleSerialise :: BundleSerialise GroupByExpr
$cbundleSerialise :: BundleSerialise GroupByExpr
decodeCurrent :: Decoder GroupByExpr
$cdecodeCurrent :: Decoder GroupByExpr
extractor :: Extractor GroupByExpr
$cextractor :: Extractor GroupByExpr
toBuilder :: GroupByExpr -> Builder
$ctoBuilder :: GroupByExpr -> Builder
schemaGen :: Proxy GroupByExpr -> SchemaGen Schema
$cschemaGen :: Proxy GroupByExpr -> SchemaGen Schema
Serialise via WineryVariant GroupByExpr
  deriving newtype Eq GroupByExpr
Int -> GroupByExpr -> Int
GroupByExpr -> Int
forall a. Eq a -> (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: GroupByExpr -> Int
$chash :: GroupByExpr -> Int
hashWithSalt :: Int -> GroupByExpr -> Int
$chashWithSalt :: Int -> GroupByExpr -> Int
Hashable
  deriving newtype GroupByExpr -> ()
forall a. (a -> ()) -> NFData a
rnf :: GroupByExpr -> ()
$crnf :: GroupByExpr -> ()
NFData

newtype HavingExpr = HavingExpr ProjectionScalarExpr
  deriving (Int -> HavingExpr -> ShowS
[HavingExpr] -> ShowS
HavingExpr -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [HavingExpr] -> ShowS
$cshowList :: [HavingExpr] -> ShowS
show :: HavingExpr -> String
$cshow :: HavingExpr -> String
showsPrec :: Int -> HavingExpr -> ShowS
$cshowsPrec :: Int -> HavingExpr -> ShowS
Show, HavingExpr -> HavingExpr -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: HavingExpr -> HavingExpr -> Bool
$c/= :: HavingExpr -> HavingExpr -> Bool
== :: HavingExpr -> HavingExpr -> Bool
$c== :: HavingExpr -> HavingExpr -> Bool
Eq, forall x. Rep HavingExpr x -> HavingExpr
forall x. HavingExpr -> Rep HavingExpr x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep HavingExpr x -> HavingExpr
$cfrom :: forall x. HavingExpr -> Rep HavingExpr x
Generic)
  deriving Typeable HavingExpr
BundleSerialise HavingExpr
Extractor HavingExpr
Decoder HavingExpr
Proxy HavingExpr -> SchemaGen Schema
HavingExpr -> Builder
forall a.
Typeable a
-> (Proxy a -> SchemaGen Schema)
-> (a -> Builder)
-> Extractor a
-> Decoder a
-> BundleSerialise a
-> Serialise a
bundleSerialise :: BundleSerialise HavingExpr
$cbundleSerialise :: BundleSerialise HavingExpr
decodeCurrent :: Decoder HavingExpr
$cdecodeCurrent :: Decoder HavingExpr
extractor :: Extractor HavingExpr
$cextractor :: Extractor HavingExpr
toBuilder :: HavingExpr -> Builder
$ctoBuilder :: HavingExpr -> Builder
schemaGen :: Proxy HavingExpr -> SchemaGen Schema
$cschemaGen :: Proxy HavingExpr -> SchemaGen Schema
Serialise via WineryVariant HavingExpr
  deriving newtype Eq HavingExpr
Int -> HavingExpr -> Int
HavingExpr -> Int
forall a. Eq a -> (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: HavingExpr -> Int
$chash :: HavingExpr -> Int
hashWithSalt :: Int -> HavingExpr -> Int
$chashWithSalt :: Int -> HavingExpr -> Int
Hashable
  deriving newtype HavingExpr -> ()
forall a. (a -> ()) -> NFData a
rnf :: HavingExpr -> ()
$crnf :: HavingExpr -> ()
NFData

data SortExpr = SortExpr ScalarExpr (Maybe Direction) (Maybe NullsOrder)
  deriving (Int -> SortExpr -> ShowS
[SortExpr] -> ShowS
SortExpr -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SortExpr] -> ShowS
$cshowList :: [SortExpr] -> ShowS
show :: SortExpr -> String
$cshow :: SortExpr -> String
showsPrec :: Int -> SortExpr -> ShowS
$cshowsPrec :: Int -> SortExpr -> ShowS
Show, SortExpr -> SortExpr -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SortExpr -> SortExpr -> Bool
$c/= :: SortExpr -> SortExpr -> Bool
== :: SortExpr -> SortExpr -> Bool
$c== :: SortExpr -> SortExpr -> Bool
Eq, forall x. Rep SortExpr x -> SortExpr
forall x. SortExpr -> Rep SortExpr x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep SortExpr x -> SortExpr
$cfrom :: forall x. SortExpr -> Rep SortExpr x
Generic, SortExpr -> ()
forall a. (a -> ()) -> NFData a
rnf :: SortExpr -> ()
$crnf :: SortExpr -> ()
NFData)
  deriving Typeable SortExpr
BundleSerialise SortExpr
Extractor SortExpr
Decoder SortExpr
Proxy SortExpr -> SchemaGen Schema
SortExpr -> Builder
forall a.
Typeable a
-> (Proxy a -> SchemaGen Schema)
-> (a -> Builder)
-> Extractor a
-> Decoder a
-> BundleSerialise a
-> Serialise a
bundleSerialise :: BundleSerialise SortExpr
$cbundleSerialise :: BundleSerialise SortExpr
decodeCurrent :: Decoder SortExpr
$cdecodeCurrent :: Decoder SortExpr
extractor :: Extractor SortExpr
$cextractor :: Extractor SortExpr
toBuilder :: SortExpr -> Builder
$ctoBuilder :: SortExpr -> Builder
schemaGen :: Proxy SortExpr -> SchemaGen Schema
$cschemaGen :: Proxy SortExpr -> SchemaGen Schema
Serialise via WineryVariant SortExpr  
  deriving Eq SortExpr
Int -> SortExpr -> Int
SortExpr -> Int
forall a. Eq a -> (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: SortExpr -> Int
$chash :: SortExpr -> Int
hashWithSalt :: Int -> SortExpr -> Int
$chashWithSalt :: Int -> SortExpr -> Int
Hashable

data Direction = Ascending | Descending
  deriving (Int -> Direction -> ShowS
[Direction] -> ShowS
Direction -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Direction] -> ShowS
$cshowList :: [Direction] -> ShowS
show :: Direction -> String
$cshow :: Direction -> String
showsPrec :: Int -> Direction -> ShowS
$cshowsPrec :: Int -> Direction -> ShowS
Show, Direction -> Direction -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Direction -> Direction -> Bool
$c/= :: Direction -> Direction -> Bool
== :: Direction -> Direction -> Bool
$c== :: Direction -> Direction -> Bool
Eq, forall x. Rep Direction x -> Direction
forall x. Direction -> Rep Direction x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Direction x -> Direction
$cfrom :: forall x. Direction -> Rep Direction x
Generic, Direction -> ()
forall a. (a -> ()) -> NFData a
rnf :: Direction -> ()
$crnf :: Direction -> ()
NFData)
  deriving Typeable Direction
BundleSerialise Direction
Extractor Direction
Decoder Direction
Proxy Direction -> SchemaGen Schema
Direction -> Builder
forall a.
Typeable a
-> (Proxy a -> SchemaGen Schema)
-> (a -> Builder)
-> Extractor a
-> Decoder a
-> BundleSerialise a
-> Serialise a
bundleSerialise :: BundleSerialise Direction
$cbundleSerialise :: BundleSerialise Direction
decodeCurrent :: Decoder Direction
$cdecodeCurrent :: Decoder Direction
extractor :: Extractor Direction
$cextractor :: Extractor Direction
toBuilder :: Direction -> Builder
$ctoBuilder :: Direction -> Builder
schemaGen :: Proxy Direction -> SchemaGen Schema
$cschemaGen :: Proxy Direction -> SchemaGen Schema
Serialise via WineryVariant Direction  
  deriving Eq Direction
Int -> Direction -> Int
Direction -> Int
forall a. Eq a -> (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: Direction -> Int
$chash :: Direction -> Int
hashWithSalt :: Int -> Direction -> Int
$chashWithSalt :: Int -> Direction -> Int
Hashable

data NullsOrder = NullsFirst | NullsLast
  deriving (Int -> NullsOrder -> ShowS
[NullsOrder] -> ShowS
NullsOrder -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [NullsOrder] -> ShowS
$cshowList :: [NullsOrder] -> ShowS
show :: NullsOrder -> String
$cshow :: NullsOrder -> String
showsPrec :: Int -> NullsOrder -> ShowS
$cshowsPrec :: Int -> NullsOrder -> ShowS
Show, NullsOrder -> NullsOrder -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NullsOrder -> NullsOrder -> Bool
$c/= :: NullsOrder -> NullsOrder -> Bool
== :: NullsOrder -> NullsOrder -> Bool
$c== :: NullsOrder -> NullsOrder -> Bool
Eq, forall x. Rep NullsOrder x -> NullsOrder
forall x. NullsOrder -> Rep NullsOrder x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep NullsOrder x -> NullsOrder
$cfrom :: forall x. NullsOrder -> Rep NullsOrder x
Generic, NullsOrder -> ()
forall a. (a -> ()) -> NFData a
rnf :: NullsOrder -> ()
$crnf :: NullsOrder -> ()
NFData)
  deriving Typeable NullsOrder
BundleSerialise NullsOrder
Extractor NullsOrder
Decoder NullsOrder
Proxy NullsOrder -> SchemaGen Schema
NullsOrder -> Builder
forall a.
Typeable a
-> (Proxy a -> SchemaGen Schema)
-> (a -> Builder)
-> Extractor a
-> Decoder a
-> BundleSerialise a
-> Serialise a
bundleSerialise :: BundleSerialise NullsOrder
$cbundleSerialise :: BundleSerialise NullsOrder
decodeCurrent :: Decoder NullsOrder
$cdecodeCurrent :: Decoder NullsOrder
extractor :: Extractor NullsOrder
$cextractor :: Extractor NullsOrder
toBuilder :: NullsOrder -> Builder
$ctoBuilder :: NullsOrder -> Builder
schemaGen :: Proxy NullsOrder -> SchemaGen Schema
$cschemaGen :: Proxy NullsOrder -> SchemaGen Schema
Serialise via WineryVariant NullsOrder  
  deriving Eq NullsOrder
Int -> NullsOrder -> Int
NullsOrder -> Int
forall a. Eq a -> (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: NullsOrder -> Int
$chash :: NullsOrder -> Int
hashWithSalt :: Int -> NullsOrder -> Int
$chashWithSalt :: Int -> NullsOrder -> Int
Hashable

data JoinType = InnerJoin | RightOuterJoin | LeftOuterJoin | FullOuterJoin | CrossJoin | NaturalJoin
  deriving (Int -> JoinType -> ShowS
[JoinType] -> ShowS
JoinType -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [JoinType] -> ShowS
$cshowList :: [JoinType] -> ShowS
show :: JoinType -> String
$cshow :: JoinType -> String
showsPrec :: Int -> JoinType -> ShowS
$cshowsPrec :: Int -> JoinType -> ShowS
Show, JoinType -> JoinType -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: JoinType -> JoinType -> Bool
$c/= :: JoinType -> JoinType -> Bool
== :: JoinType -> JoinType -> Bool
$c== :: JoinType -> JoinType -> Bool
Eq, forall x. Rep JoinType x -> JoinType
forall x. JoinType -> Rep JoinType x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep JoinType x -> JoinType
$cfrom :: forall x. JoinType -> Rep JoinType x
Generic, JoinType -> ()
forall a. (a -> ()) -> NFData a
rnf :: JoinType -> ()
$crnf :: JoinType -> ()
NFData)
  deriving Typeable JoinType
BundleSerialise JoinType
Extractor JoinType
Decoder JoinType
Proxy JoinType -> SchemaGen Schema
JoinType -> Builder
forall a.
Typeable a
-> (Proxy a -> SchemaGen Schema)
-> (a -> Builder)
-> Extractor a
-> Decoder a
-> BundleSerialise a
-> Serialise a
bundleSerialise :: BundleSerialise JoinType
$cbundleSerialise :: BundleSerialise JoinType
decodeCurrent :: Decoder JoinType
$cdecodeCurrent :: Decoder JoinType
extractor :: Extractor JoinType
$cextractor :: Extractor JoinType
toBuilder :: JoinType -> Builder
$ctoBuilder :: JoinType -> Builder
schemaGen :: Proxy JoinType -> SchemaGen Schema
$cschemaGen :: Proxy JoinType -> SchemaGen Schema
Serialise via WineryVariant JoinType  

data JoinCondition = JoinOn JoinOnCondition | JoinUsing [UnqualifiedColumnName]
  deriving (Int -> JoinCondition -> ShowS
[JoinCondition] -> ShowS
JoinCondition -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [JoinCondition] -> ShowS
$cshowList :: [JoinCondition] -> ShowS
show :: JoinCondition -> String
$cshow :: JoinCondition -> String
showsPrec :: Int -> JoinCondition -> ShowS
$cshowsPrec :: Int -> JoinCondition -> ShowS
Show, JoinCondition -> JoinCondition -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: JoinCondition -> JoinCondition -> Bool
$c/= :: JoinCondition -> JoinCondition -> Bool
== :: JoinCondition -> JoinCondition -> Bool
$c== :: JoinCondition -> JoinCondition -> Bool
Eq, forall x. Rep JoinCondition x -> JoinCondition
forall x. JoinCondition -> Rep JoinCondition x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep JoinCondition x -> JoinCondition
$cfrom :: forall x. JoinCondition -> Rep JoinCondition x
Generic, JoinCondition -> ()
forall a. (a -> ()) -> NFData a
rnf :: JoinCondition -> ()
$crnf :: JoinCondition -> ()
NFData)
  deriving Typeable JoinCondition
BundleSerialise JoinCondition
Extractor JoinCondition
Decoder JoinCondition
Proxy JoinCondition -> SchemaGen Schema
JoinCondition -> Builder
forall a.
Typeable a
-> (Proxy a -> SchemaGen Schema)
-> (a -> Builder)
-> Extractor a
-> Decoder a
-> BundleSerialise a
-> Serialise a
bundleSerialise :: BundleSerialise JoinCondition
$cbundleSerialise :: BundleSerialise JoinCondition
decodeCurrent :: Decoder JoinCondition
$cdecodeCurrent :: Decoder JoinCondition
extractor :: Extractor JoinCondition
$cextractor :: Extractor JoinCondition
toBuilder :: JoinCondition -> Builder
$ctoBuilder :: JoinCondition -> Builder
schemaGen :: Proxy JoinCondition -> SchemaGen Schema
$cschemaGen :: Proxy JoinCondition -> SchemaGen Schema
Serialise via WineryVariant JoinCondition
  deriving Eq JoinCondition
Int -> JoinCondition -> Int
JoinCondition -> Int
forall a. Eq a -> (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: JoinCondition -> Int
$chash :: JoinCondition -> Int
hashWithSalt :: Int -> JoinCondition -> Int
$chashWithSalt :: Int -> JoinCondition -> Int
Hashable

newtype JoinOnCondition = JoinOnCondition ScalarExpr
  deriving (Int -> JoinOnCondition -> ShowS
[JoinOnCondition] -> ShowS
JoinOnCondition -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [JoinOnCondition] -> ShowS
$cshowList :: [JoinOnCondition] -> ShowS
show :: JoinOnCondition -> String
$cshow :: JoinOnCondition -> String
showsPrec :: Int -> JoinOnCondition -> ShowS
$cshowsPrec :: Int -> JoinOnCondition -> ShowS
Show, JoinOnCondition -> JoinOnCondition -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: JoinOnCondition -> JoinOnCondition -> Bool
$c/= :: JoinOnCondition -> JoinOnCondition -> Bool
== :: JoinOnCondition -> JoinOnCondition -> Bool
$c== :: JoinOnCondition -> JoinOnCondition -> Bool
Eq, forall x. Rep JoinOnCondition x -> JoinOnCondition
forall x. JoinOnCondition -> Rep JoinOnCondition x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep JoinOnCondition x -> JoinOnCondition
$cfrom :: forall x. JoinOnCondition -> Rep JoinOnCondition x
Generic)
  deriving Typeable JoinOnCondition
BundleSerialise JoinOnCondition
Extractor JoinOnCondition
Decoder JoinOnCondition
Proxy JoinOnCondition -> SchemaGen Schema
JoinOnCondition -> Builder
forall a.
Typeable a
-> (Proxy a -> SchemaGen Schema)
-> (a -> Builder)
-> Extractor a
-> Decoder a
-> BundleSerialise a
-> Serialise a
bundleSerialise :: BundleSerialise JoinOnCondition
$cbundleSerialise :: BundleSerialise JoinOnCondition
decodeCurrent :: Decoder JoinOnCondition
$cdecodeCurrent :: Decoder JoinOnCondition
extractor :: Extractor JoinOnCondition
$cextractor :: Extractor JoinOnCondition
toBuilder :: JoinOnCondition -> Builder
$ctoBuilder :: JoinOnCondition -> Builder
schemaGen :: Proxy JoinOnCondition -> SchemaGen Schema
$cschemaGen :: Proxy JoinOnCondition -> SchemaGen Schema
Serialise via WineryVariant JoinOnCondition
  deriving newtype JoinOnCondition -> ()
forall a. (a -> ()) -> NFData a
rnf :: JoinOnCondition -> ()
$crnf :: JoinOnCondition -> ()
NFData
  deriving newtype Eq JoinOnCondition
Int -> JoinOnCondition -> Int
JoinOnCondition -> Int
forall a. Eq a -> (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: JoinOnCondition -> Int
$chash :: JoinOnCondition -> Int
hashWithSalt :: Int -> JoinOnCondition -> Int
$chashWithSalt :: Int -> JoinOnCondition -> Int
Hashable

newtype ColumnProjectionName = ColumnProjectionName [ProjectionName] --dot-delimited reference
  deriving (Int -> ColumnProjectionName -> ShowS
[ColumnProjectionName] -> ShowS
ColumnProjectionName -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ColumnProjectionName] -> ShowS
$cshowList :: [ColumnProjectionName] -> ShowS
show :: ColumnProjectionName -> String
$cshow :: ColumnProjectionName -> String
showsPrec :: Int -> ColumnProjectionName -> ShowS
$cshowsPrec :: Int -> ColumnProjectionName -> ShowS
Show, ColumnProjectionName -> ColumnProjectionName -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ColumnProjectionName -> ColumnProjectionName -> Bool
$c/= :: ColumnProjectionName -> ColumnProjectionName -> Bool
== :: ColumnProjectionName -> ColumnProjectionName -> Bool
$c== :: ColumnProjectionName -> ColumnProjectionName -> Bool
Eq, Eq ColumnProjectionName
ColumnProjectionName -> ColumnProjectionName -> Bool
ColumnProjectionName -> ColumnProjectionName -> Ordering
ColumnProjectionName
-> ColumnProjectionName -> ColumnProjectionName
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: ColumnProjectionName
-> ColumnProjectionName -> ColumnProjectionName
$cmin :: ColumnProjectionName
-> ColumnProjectionName -> ColumnProjectionName
max :: ColumnProjectionName
-> ColumnProjectionName -> ColumnProjectionName
$cmax :: ColumnProjectionName
-> ColumnProjectionName -> ColumnProjectionName
>= :: ColumnProjectionName -> ColumnProjectionName -> Bool
$c>= :: ColumnProjectionName -> ColumnProjectionName -> Bool
> :: ColumnProjectionName -> ColumnProjectionName -> Bool
$c> :: ColumnProjectionName -> ColumnProjectionName -> Bool
<= :: ColumnProjectionName -> ColumnProjectionName -> Bool
$c<= :: ColumnProjectionName -> ColumnProjectionName -> Bool
< :: ColumnProjectionName -> ColumnProjectionName -> Bool
$c< :: ColumnProjectionName -> ColumnProjectionName -> Bool
compare :: ColumnProjectionName -> ColumnProjectionName -> Ordering
$ccompare :: ColumnProjectionName -> ColumnProjectionName -> Ordering
Ord, forall x. Rep ColumnProjectionName x -> ColumnProjectionName
forall x. ColumnProjectionName -> Rep ColumnProjectionName x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ColumnProjectionName x -> ColumnProjectionName
$cfrom :: forall x. ColumnProjectionName -> Rep ColumnProjectionName x
Generic)
  deriving Typeable ColumnProjectionName
BundleSerialise ColumnProjectionName
Extractor ColumnProjectionName
Decoder ColumnProjectionName
Proxy ColumnProjectionName -> SchemaGen Schema
ColumnProjectionName -> Builder
forall a.
Typeable a
-> (Proxy a -> SchemaGen Schema)
-> (a -> Builder)
-> Extractor a
-> Decoder a
-> BundleSerialise a
-> Serialise a
bundleSerialise :: BundleSerialise ColumnProjectionName
$cbundleSerialise :: BundleSerialise ColumnProjectionName
decodeCurrent :: Decoder ColumnProjectionName
$cdecodeCurrent :: Decoder ColumnProjectionName
extractor :: Extractor ColumnProjectionName
$cextractor :: Extractor ColumnProjectionName
toBuilder :: ColumnProjectionName -> Builder
$ctoBuilder :: ColumnProjectionName -> Builder
schemaGen :: Proxy ColumnProjectionName -> SchemaGen Schema
$cschemaGen :: Proxy ColumnProjectionName -> SchemaGen Schema
Serialise via WineryVariant ColumnProjectionName
  deriving newtype ColumnProjectionName -> ()
forall a. (a -> ()) -> NFData a
rnf :: ColumnProjectionName -> ()
$crnf :: ColumnProjectionName -> ()
NFData
  deriving newtype Eq ColumnProjectionName
Int -> ColumnProjectionName -> Int
ColumnProjectionName -> Int
forall a. Eq a -> (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: ColumnProjectionName -> Int
$chash :: ColumnProjectionName -> Int
hashWithSalt :: Int -> ColumnProjectionName -> Int
$chashWithSalt :: Int -> ColumnProjectionName -> Int
Hashable

data ProjectionName = ProjectionName Text | Asterisk
  deriving (Int -> ProjectionName -> ShowS
[ProjectionName] -> ShowS
ProjectionName -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ProjectionName] -> ShowS
$cshowList :: [ProjectionName] -> ShowS
show :: ProjectionName -> String
$cshow :: ProjectionName -> String
showsPrec :: Int -> ProjectionName -> ShowS
$cshowsPrec :: Int -> ProjectionName -> ShowS
Show, ProjectionName -> ProjectionName -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ProjectionName -> ProjectionName -> Bool
$c/= :: ProjectionName -> ProjectionName -> Bool
== :: ProjectionName -> ProjectionName -> Bool
$c== :: ProjectionName -> ProjectionName -> Bool
Eq, Eq ProjectionName
ProjectionName -> ProjectionName -> Bool
ProjectionName -> ProjectionName -> Ordering
ProjectionName -> ProjectionName -> ProjectionName
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: ProjectionName -> ProjectionName -> ProjectionName
$cmin :: ProjectionName -> ProjectionName -> ProjectionName
max :: ProjectionName -> ProjectionName -> ProjectionName
$cmax :: ProjectionName -> ProjectionName -> ProjectionName
>= :: ProjectionName -> ProjectionName -> Bool
$c>= :: ProjectionName -> ProjectionName -> Bool
> :: ProjectionName -> ProjectionName -> Bool
$c> :: ProjectionName -> ProjectionName -> Bool
<= :: ProjectionName -> ProjectionName -> Bool
$c<= :: ProjectionName -> ProjectionName -> Bool
< :: ProjectionName -> ProjectionName -> Bool
$c< :: ProjectionName -> ProjectionName -> Bool
compare :: ProjectionName -> ProjectionName -> Ordering
$ccompare :: ProjectionName -> ProjectionName -> Ordering
Ord, forall x. Rep ProjectionName x -> ProjectionName
forall x. ProjectionName -> Rep ProjectionName x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ProjectionName x -> ProjectionName
$cfrom :: forall x. ProjectionName -> Rep ProjectionName x
Generic, ProjectionName -> ()
forall a. (a -> ()) -> NFData a
rnf :: ProjectionName -> ()
$crnf :: ProjectionName -> ()
NFData)
  deriving Typeable ProjectionName
BundleSerialise ProjectionName
Extractor ProjectionName
Decoder ProjectionName
Proxy ProjectionName -> SchemaGen Schema
ProjectionName -> Builder
forall a.
Typeable a
-> (Proxy a -> SchemaGen Schema)
-> (a -> Builder)
-> Extractor a
-> Decoder a
-> BundleSerialise a
-> Serialise a
bundleSerialise :: BundleSerialise ProjectionName
$cbundleSerialise :: BundleSerialise ProjectionName
decodeCurrent :: Decoder ProjectionName
$cdecodeCurrent :: Decoder ProjectionName
extractor :: Extractor ProjectionName
$cextractor :: Extractor ProjectionName
toBuilder :: ProjectionName -> Builder
$ctoBuilder :: ProjectionName -> Builder
schemaGen :: Proxy ProjectionName -> SchemaGen Schema
$cschemaGen :: Proxy ProjectionName -> SchemaGen Schema
Serialise via WineryVariant ProjectionName
  deriving Eq ProjectionName
Int -> ProjectionName -> Int
ProjectionName -> Int
forall a. Eq a -> (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: ProjectionName -> Int
$chash :: ProjectionName -> Int
hashWithSalt :: Int -> ProjectionName -> Int
$chashWithSalt :: Int -> ProjectionName -> Int
Hashable

newtype ColumnName = ColumnName [Text]
  deriving (Int -> ColumnName -> ShowS
[ColumnName] -> ShowS
ColumnName -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ColumnName] -> ShowS
$cshowList :: [ColumnName] -> ShowS
show :: ColumnName -> String
$cshow :: ColumnName -> String
showsPrec :: Int -> ColumnName -> ShowS
$cshowsPrec :: Int -> ColumnName -> ShowS
Show, ColumnName -> ColumnName -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ColumnName -> ColumnName -> Bool
$c/= :: ColumnName -> ColumnName -> Bool
== :: ColumnName -> ColumnName -> Bool
$c== :: ColumnName -> ColumnName -> Bool
Eq, Eq ColumnName
ColumnName -> ColumnName -> Bool
ColumnName -> ColumnName -> Ordering
ColumnName -> ColumnName -> ColumnName
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: ColumnName -> ColumnName -> ColumnName
$cmin :: ColumnName -> ColumnName -> ColumnName
max :: ColumnName -> ColumnName -> ColumnName
$cmax :: ColumnName -> ColumnName -> ColumnName
>= :: ColumnName -> ColumnName -> Bool
$c>= :: ColumnName -> ColumnName -> Bool
> :: ColumnName -> ColumnName -> Bool
$c> :: ColumnName -> ColumnName -> Bool
<= :: ColumnName -> ColumnName -> Bool
$c<= :: ColumnName -> ColumnName -> Bool
< :: ColumnName -> ColumnName -> Bool
$c< :: ColumnName -> ColumnName -> Bool
compare :: ColumnName -> ColumnName -> Ordering
$ccompare :: ColumnName -> ColumnName -> Ordering
Ord, forall x. Rep ColumnName x -> ColumnName
forall x. ColumnName -> Rep ColumnName x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ColumnName x -> ColumnName
$cfrom :: forall x. ColumnName -> Rep ColumnName x
Generic)
  deriving Typeable ColumnName
BundleSerialise ColumnName
Extractor ColumnName
Decoder ColumnName
Proxy ColumnName -> SchemaGen Schema
ColumnName -> Builder
forall a.
Typeable a
-> (Proxy a -> SchemaGen Schema)
-> (a -> Builder)
-> Extractor a
-> Decoder a
-> BundleSerialise a
-> Serialise a
bundleSerialise :: BundleSerialise ColumnName
$cbundleSerialise :: BundleSerialise ColumnName
decodeCurrent :: Decoder ColumnName
$cdecodeCurrent :: Decoder ColumnName
extractor :: Extractor ColumnName
$cextractor :: Extractor ColumnName
toBuilder :: ColumnName -> Builder
$ctoBuilder :: ColumnName -> Builder
schemaGen :: Proxy ColumnName -> SchemaGen Schema
$cschemaGen :: Proxy ColumnName -> SchemaGen Schema
Serialise via WineryVariant ColumnName
  deriving newtype Eq ColumnName
Int -> ColumnName -> Int
ColumnName -> Int
forall a. Eq a -> (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: ColumnName -> Int
$chash :: ColumnName -> Int
hashWithSalt :: Int -> ColumnName -> Int
$chashWithSalt :: Int -> ColumnName -> Int
Hashable
  deriving newtype ColumnName -> ()
forall a. (a -> ()) -> NFData a
rnf :: ColumnName -> ()
$crnf :: ColumnName -> ()
NFData

newtype UnqualifiedColumnName = UnqualifiedColumnName Text
  deriving (Int -> UnqualifiedColumnName -> ShowS
[UnqualifiedColumnName] -> ShowS
UnqualifiedColumnName -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [UnqualifiedColumnName] -> ShowS
$cshowList :: [UnqualifiedColumnName] -> ShowS
show :: UnqualifiedColumnName -> String
$cshow :: UnqualifiedColumnName -> String
showsPrec :: Int -> UnqualifiedColumnName -> ShowS
$cshowsPrec :: Int -> UnqualifiedColumnName -> ShowS
Show, UnqualifiedColumnName -> UnqualifiedColumnName -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: UnqualifiedColumnName -> UnqualifiedColumnName -> Bool
$c/= :: UnqualifiedColumnName -> UnqualifiedColumnName -> Bool
== :: UnqualifiedColumnName -> UnqualifiedColumnName -> Bool
$c== :: UnqualifiedColumnName -> UnqualifiedColumnName -> Bool
Eq, Eq UnqualifiedColumnName
UnqualifiedColumnName -> UnqualifiedColumnName -> Bool
UnqualifiedColumnName -> UnqualifiedColumnName -> Ordering
UnqualifiedColumnName
-> UnqualifiedColumnName -> UnqualifiedColumnName
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: UnqualifiedColumnName
-> UnqualifiedColumnName -> UnqualifiedColumnName
$cmin :: UnqualifiedColumnName
-> UnqualifiedColumnName -> UnqualifiedColumnName
max :: UnqualifiedColumnName
-> UnqualifiedColumnName -> UnqualifiedColumnName
$cmax :: UnqualifiedColumnName
-> UnqualifiedColumnName -> UnqualifiedColumnName
>= :: UnqualifiedColumnName -> UnqualifiedColumnName -> Bool
$c>= :: UnqualifiedColumnName -> UnqualifiedColumnName -> Bool
> :: UnqualifiedColumnName -> UnqualifiedColumnName -> Bool
$c> :: UnqualifiedColumnName -> UnqualifiedColumnName -> Bool
<= :: UnqualifiedColumnName -> UnqualifiedColumnName -> Bool
$c<= :: UnqualifiedColumnName -> UnqualifiedColumnName -> Bool
< :: UnqualifiedColumnName -> UnqualifiedColumnName -> Bool
$c< :: UnqualifiedColumnName -> UnqualifiedColumnName -> Bool
compare :: UnqualifiedColumnName -> UnqualifiedColumnName -> Ordering
$ccompare :: UnqualifiedColumnName -> UnqualifiedColumnName -> Ordering
Ord, forall x. Rep UnqualifiedColumnName x -> UnqualifiedColumnName
forall x. UnqualifiedColumnName -> Rep UnqualifiedColumnName x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep UnqualifiedColumnName x -> UnqualifiedColumnName
$cfrom :: forall x. UnqualifiedColumnName -> Rep UnqualifiedColumnName x
Generic)
  deriving Typeable UnqualifiedColumnName
BundleSerialise UnqualifiedColumnName
Extractor UnqualifiedColumnName
Decoder UnqualifiedColumnName
Proxy UnqualifiedColumnName -> SchemaGen Schema
UnqualifiedColumnName -> Builder
forall a.
Typeable a
-> (Proxy a -> SchemaGen Schema)
-> (a -> Builder)
-> Extractor a
-> Decoder a
-> BundleSerialise a
-> Serialise a
bundleSerialise :: BundleSerialise UnqualifiedColumnName
$cbundleSerialise :: BundleSerialise UnqualifiedColumnName
decodeCurrent :: Decoder UnqualifiedColumnName
$cdecodeCurrent :: Decoder UnqualifiedColumnName
extractor :: Extractor UnqualifiedColumnName
$cextractor :: Extractor UnqualifiedColumnName
toBuilder :: UnqualifiedColumnName -> Builder
$ctoBuilder :: UnqualifiedColumnName -> Builder
schemaGen :: Proxy UnqualifiedColumnName -> SchemaGen Schema
$cschemaGen :: Proxy UnqualifiedColumnName -> SchemaGen Schema
Serialise via WineryVariant UnqualifiedColumnName
  deriving newtype (Eq UnqualifiedColumnName
Int -> UnqualifiedColumnName -> Int
UnqualifiedColumnName -> Int
forall a. Eq a -> (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: UnqualifiedColumnName -> Int
$chash :: UnqualifiedColumnName -> Int
hashWithSalt :: Int -> UnqualifiedColumnName -> Int
$chashWithSalt :: Int -> UnqualifiedColumnName -> Int
Hashable, UnqualifiedColumnName -> ()
forall a. (a -> ()) -> NFData a
rnf :: UnqualifiedColumnName -> ()
$crnf :: UnqualifiedColumnName -> ()
NFData)

newtype TableName = TableName [Text]
  deriving (Int -> TableName -> ShowS
[TableName] -> ShowS
TableName -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TableName] -> ShowS
$cshowList :: [TableName] -> ShowS
show :: TableName -> String
$cshow :: TableName -> String
showsPrec :: Int -> TableName -> ShowS
$cshowsPrec :: Int -> TableName -> ShowS
Show, TableName -> TableName -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TableName -> TableName -> Bool
$c/= :: TableName -> TableName -> Bool
== :: TableName -> TableName -> Bool
$c== :: TableName -> TableName -> Bool
Eq, Eq TableName
TableName -> TableName -> Bool
TableName -> TableName -> Ordering
TableName -> TableName -> TableName
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: TableName -> TableName -> TableName
$cmin :: TableName -> TableName -> TableName
max :: TableName -> TableName -> TableName
$cmax :: TableName -> TableName -> TableName
>= :: TableName -> TableName -> Bool
$c>= :: TableName -> TableName -> Bool
> :: TableName -> TableName -> Bool
$c> :: TableName -> TableName -> Bool
<= :: TableName -> TableName -> Bool
$c<= :: TableName -> TableName -> Bool
< :: TableName -> TableName -> Bool
$c< :: TableName -> TableName -> Bool
compare :: TableName -> TableName -> Ordering
$ccompare :: TableName -> TableName -> Ordering
Ord, forall x. Rep TableName x -> TableName
forall x. TableName -> Rep TableName x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep TableName x -> TableName
$cfrom :: forall x. TableName -> Rep TableName x
Generic)
  deriving Typeable TableName
BundleSerialise TableName
Extractor TableName
Decoder TableName
Proxy TableName -> SchemaGen Schema
TableName -> Builder
forall a.
Typeable a
-> (Proxy a -> SchemaGen Schema)
-> (a -> Builder)
-> Extractor a
-> Decoder a
-> BundleSerialise a
-> Serialise a
bundleSerialise :: BundleSerialise TableName
$cbundleSerialise :: BundleSerialise TableName
decodeCurrent :: Decoder TableName
$cdecodeCurrent :: Decoder TableName
extractor :: Extractor TableName
$cextractor :: Extractor TableName
toBuilder :: TableName -> Builder
$ctoBuilder :: TableName -> Builder
schemaGen :: Proxy TableName -> SchemaGen Schema
$cschemaGen :: Proxy TableName -> SchemaGen Schema
Serialise via WineryVariant TableName
  deriving newtype (Eq TableName
Int -> TableName -> Int
TableName -> Int
forall a. Eq a -> (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: TableName -> Int
$chash :: TableName -> Int
hashWithSalt :: Int -> TableName -> Int
$chashWithSalt :: Int -> TableName -> Int
Hashable, TableName -> ()
forall a. (a -> ()) -> NFData a
rnf :: TableName -> ()
$crnf :: TableName -> ()
NFData)

newtype OperatorName = OperatorName [Text]
  deriving (Int -> OperatorName -> ShowS
[OperatorName] -> ShowS
OperatorName -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [OperatorName] -> ShowS
$cshowList :: [OperatorName] -> ShowS
show :: OperatorName -> String
$cshow :: OperatorName -> String
showsPrec :: Int -> OperatorName -> ShowS
$cshowsPrec :: Int -> OperatorName -> ShowS
Show, OperatorName -> OperatorName -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: OperatorName -> OperatorName -> Bool
$c/= :: OperatorName -> OperatorName -> Bool
== :: OperatorName -> OperatorName -> Bool
$c== :: OperatorName -> OperatorName -> Bool
Eq, Eq OperatorName
OperatorName -> OperatorName -> Bool
OperatorName -> OperatorName -> Ordering
OperatorName -> OperatorName -> OperatorName
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: OperatorName -> OperatorName -> OperatorName
$cmin :: OperatorName -> OperatorName -> OperatorName
max :: OperatorName -> OperatorName -> OperatorName
$cmax :: OperatorName -> OperatorName -> OperatorName
>= :: OperatorName -> OperatorName -> Bool
$c>= :: OperatorName -> OperatorName -> Bool
> :: OperatorName -> OperatorName -> Bool
$c> :: OperatorName -> OperatorName -> Bool
<= :: OperatorName -> OperatorName -> Bool
$c<= :: OperatorName -> OperatorName -> Bool
< :: OperatorName -> OperatorName -> Bool
$c< :: OperatorName -> OperatorName -> Bool
compare :: OperatorName -> OperatorName -> Ordering
$ccompare :: OperatorName -> OperatorName -> Ordering
Ord, forall x. Rep OperatorName x -> OperatorName
forall x. OperatorName -> Rep OperatorName x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep OperatorName x -> OperatorName
$cfrom :: forall x. OperatorName -> Rep OperatorName x
Generic)
  deriving Typeable OperatorName
BundleSerialise OperatorName
Extractor OperatorName
Decoder OperatorName
Proxy OperatorName -> SchemaGen Schema
OperatorName -> Builder
forall a.
Typeable a
-> (Proxy a -> SchemaGen Schema)
-> (a -> Builder)
-> Extractor a
-> Decoder a
-> BundleSerialise a
-> Serialise a
bundleSerialise :: BundleSerialise OperatorName
$cbundleSerialise :: BundleSerialise OperatorName
decodeCurrent :: Decoder OperatorName
$cdecodeCurrent :: Decoder OperatorName
extractor :: Extractor OperatorName
$cextractor :: Extractor OperatorName
toBuilder :: OperatorName -> Builder
$ctoBuilder :: OperatorName -> Builder
schemaGen :: Proxy OperatorName -> SchemaGen Schema
$cschemaGen :: Proxy OperatorName -> SchemaGen Schema
Serialise via WineryVariant OperatorName
  deriving newtype OperatorName -> ()
forall a. (a -> ()) -> NFData a
rnf :: OperatorName -> ()
$crnf :: OperatorName -> ()
NFData

instance Hashable OperatorName

newtype ColumnAlias = ColumnAlias { ColumnAlias -> Text
unColumnAlias :: Text }
  deriving (Int -> ColumnAlias -> ShowS
[ColumnAlias] -> ShowS
ColumnAlias -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ColumnAlias] -> ShowS
$cshowList :: [ColumnAlias] -> ShowS
show :: ColumnAlias -> String
$cshow :: ColumnAlias -> String
showsPrec :: Int -> ColumnAlias -> ShowS
$cshowsPrec :: Int -> ColumnAlias -> ShowS
Show, ColumnAlias -> ColumnAlias -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ColumnAlias -> ColumnAlias -> Bool
$c/= :: ColumnAlias -> ColumnAlias -> Bool
== :: ColumnAlias -> ColumnAlias -> Bool
$c== :: ColumnAlias -> ColumnAlias -> Bool
Eq, Eq ColumnAlias
ColumnAlias -> ColumnAlias -> Bool
ColumnAlias -> ColumnAlias -> Ordering
ColumnAlias -> ColumnAlias -> ColumnAlias
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: ColumnAlias -> ColumnAlias -> ColumnAlias
$cmin :: ColumnAlias -> ColumnAlias -> ColumnAlias
max :: ColumnAlias -> ColumnAlias -> ColumnAlias
$cmax :: ColumnAlias -> ColumnAlias -> ColumnAlias
>= :: ColumnAlias -> ColumnAlias -> Bool
$c>= :: ColumnAlias -> ColumnAlias -> Bool
> :: ColumnAlias -> ColumnAlias -> Bool
$c> :: ColumnAlias -> ColumnAlias -> Bool
<= :: ColumnAlias -> ColumnAlias -> Bool
$c<= :: ColumnAlias -> ColumnAlias -> Bool
< :: ColumnAlias -> ColumnAlias -> Bool
$c< :: ColumnAlias -> ColumnAlias -> Bool
compare :: ColumnAlias -> ColumnAlias -> Ordering
$ccompare :: ColumnAlias -> ColumnAlias -> Ordering
Ord, forall x. Rep ColumnAlias x -> ColumnAlias
forall x. ColumnAlias -> Rep ColumnAlias x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ColumnAlias x -> ColumnAlias
$cfrom :: forall x. ColumnAlias -> Rep ColumnAlias x
Generic)
  deriving Typeable ColumnAlias
BundleSerialise ColumnAlias
Extractor ColumnAlias
Decoder ColumnAlias
Proxy ColumnAlias -> SchemaGen Schema
ColumnAlias -> Builder
forall a.
Typeable a
-> (Proxy a -> SchemaGen Schema)
-> (a -> Builder)
-> Extractor a
-> Decoder a
-> BundleSerialise a
-> Serialise a
bundleSerialise :: BundleSerialise ColumnAlias
$cbundleSerialise :: BundleSerialise ColumnAlias
decodeCurrent :: Decoder ColumnAlias
$cdecodeCurrent :: Decoder ColumnAlias
extractor :: Extractor ColumnAlias
$cextractor :: Extractor ColumnAlias
toBuilder :: ColumnAlias -> Builder
$ctoBuilder :: ColumnAlias -> Builder
schemaGen :: Proxy ColumnAlias -> SchemaGen Schema
$cschemaGen :: Proxy ColumnAlias -> SchemaGen Schema
Serialise via WineryVariant ColumnAlias
  deriving newtype ColumnAlias -> ()
forall a. (a -> ()) -> NFData a
rnf :: ColumnAlias -> ()
$crnf :: ColumnAlias -> ()
NFData
  deriving newtype Eq ColumnAlias
Int -> ColumnAlias -> Int
ColumnAlias -> Int
forall a. Eq a -> (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: ColumnAlias -> Int
$chash :: ColumnAlias -> Int
hashWithSalt :: Int -> ColumnAlias -> Int
$chashWithSalt :: Int -> ColumnAlias -> Int
Hashable

newtype TableAlias = TableAlias { TableAlias -> Text
unTableAlias :: Text }
  deriving (Int -> TableAlias -> ShowS
[TableAlias] -> ShowS
TableAlias -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TableAlias] -> ShowS
$cshowList :: [TableAlias] -> ShowS
show :: TableAlias -> String
$cshow :: TableAlias -> String
showsPrec :: Int -> TableAlias -> ShowS
$cshowsPrec :: Int -> TableAlias -> ShowS
Show, TableAlias -> TableAlias -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TableAlias -> TableAlias -> Bool
$c/= :: TableAlias -> TableAlias -> Bool
== :: TableAlias -> TableAlias -> Bool
$c== :: TableAlias -> TableAlias -> Bool
Eq, Eq TableAlias
TableAlias -> TableAlias -> Bool
TableAlias -> TableAlias -> Ordering
TableAlias -> TableAlias -> TableAlias
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: TableAlias -> TableAlias -> TableAlias
$cmin :: TableAlias -> TableAlias -> TableAlias
max :: TableAlias -> TableAlias -> TableAlias
$cmax :: TableAlias -> TableAlias -> TableAlias
>= :: TableAlias -> TableAlias -> Bool
$c>= :: TableAlias -> TableAlias -> Bool
> :: TableAlias -> TableAlias -> Bool
$c> :: TableAlias -> TableAlias -> Bool
<= :: TableAlias -> TableAlias -> Bool
$c<= :: TableAlias -> TableAlias -> Bool
< :: TableAlias -> TableAlias -> Bool
$c< :: TableAlias -> TableAlias -> Bool
compare :: TableAlias -> TableAlias -> Ordering
$ccompare :: TableAlias -> TableAlias -> Ordering
Ord, forall x. Rep TableAlias x -> TableAlias
forall x. TableAlias -> Rep TableAlias x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep TableAlias x -> TableAlias
$cfrom :: forall x. TableAlias -> Rep TableAlias x
Generic)
  deriving Typeable TableAlias
BundleSerialise TableAlias
Extractor TableAlias
Decoder TableAlias
Proxy TableAlias -> SchemaGen Schema
TableAlias -> Builder
forall a.
Typeable a
-> (Proxy a -> SchemaGen Schema)
-> (a -> Builder)
-> Extractor a
-> Decoder a
-> BundleSerialise a
-> Serialise a
bundleSerialise :: BundleSerialise TableAlias
$cbundleSerialise :: BundleSerialise TableAlias
decodeCurrent :: Decoder TableAlias
$cdecodeCurrent :: Decoder TableAlias
extractor :: Extractor TableAlias
$cextractor :: Extractor TableAlias
toBuilder :: TableAlias -> Builder
$ctoBuilder :: TableAlias -> Builder
schemaGen :: Proxy TableAlias -> SchemaGen Schema
$cschemaGen :: Proxy TableAlias -> SchemaGen Schema
Serialise via WineryVariant TableAlias
  deriving newtype (Semigroup TableAlias
TableAlias
[TableAlias] -> TableAlias
TableAlias -> TableAlias -> TableAlias
forall a.
Semigroup a -> a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
mconcat :: [TableAlias] -> TableAlias
$cmconcat :: [TableAlias] -> TableAlias
mappend :: TableAlias -> TableAlias -> TableAlias
$cmappend :: TableAlias -> TableAlias -> TableAlias
mempty :: TableAlias
$cmempty :: TableAlias
Monoid, NonEmpty TableAlias -> TableAlias
TableAlias -> TableAlias -> TableAlias
forall b. Integral b => b -> TableAlias -> TableAlias
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
stimes :: forall b. Integral b => b -> TableAlias -> TableAlias
$cstimes :: forall b. Integral b => b -> TableAlias -> TableAlias
sconcat :: NonEmpty TableAlias -> TableAlias
$csconcat :: NonEmpty TableAlias -> TableAlias
<> :: TableAlias -> TableAlias -> TableAlias
$c<> :: TableAlias -> TableAlias -> TableAlias
Semigroup, TableAlias -> ()
forall a. (a -> ()) -> NFData a
rnf :: TableAlias -> ()
$crnf :: TableAlias -> ()
NFData)
  deriving newtype Eq TableAlias
Int -> TableAlias -> Int
TableAlias -> Int
forall a. Eq a -> (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: TableAlias -> Int
$chash :: TableAlias -> Int
hashWithSalt :: Int -> TableAlias -> Int
$chashWithSalt :: Int -> TableAlias -> Int
Hashable

newtype FuncName = FuncName [Text]
  deriving (Int -> FuncName -> ShowS
[FuncName] -> ShowS
FuncName -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FuncName] -> ShowS
$cshowList :: [FuncName] -> ShowS
show :: FuncName -> String
$cshow :: FuncName -> String
showsPrec :: Int -> FuncName -> ShowS
$cshowsPrec :: Int -> FuncName -> ShowS
Show, FuncName -> FuncName -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FuncName -> FuncName -> Bool
$c/= :: FuncName -> FuncName -> Bool
== :: FuncName -> FuncName -> Bool
$c== :: FuncName -> FuncName -> Bool
Eq, forall x. Rep FuncName x -> FuncName
forall x. FuncName -> Rep FuncName x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep FuncName x -> FuncName
$cfrom :: forall x. FuncName -> Rep FuncName x
Generic, Eq FuncName
FuncName -> FuncName -> Bool
FuncName -> FuncName -> Ordering
FuncName -> FuncName -> FuncName
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: FuncName -> FuncName -> FuncName
$cmin :: FuncName -> FuncName -> FuncName
max :: FuncName -> FuncName -> FuncName
$cmax :: FuncName -> FuncName -> FuncName
>= :: FuncName -> FuncName -> Bool
$c>= :: FuncName -> FuncName -> Bool
> :: FuncName -> FuncName -> Bool
$c> :: FuncName -> FuncName -> Bool
<= :: FuncName -> FuncName -> Bool
$c<= :: FuncName -> FuncName -> Bool
< :: FuncName -> FuncName -> Bool
$c< :: FuncName -> FuncName -> Bool
compare :: FuncName -> FuncName -> Ordering
$ccompare :: FuncName -> FuncName -> Ordering
Ord)
  deriving Typeable FuncName
BundleSerialise FuncName
Extractor FuncName
Decoder FuncName
Proxy FuncName -> SchemaGen Schema
FuncName -> Builder
forall a.
Typeable a
-> (Proxy a -> SchemaGen Schema)
-> (a -> Builder)
-> Extractor a
-> Decoder a
-> BundleSerialise a
-> Serialise a
bundleSerialise :: BundleSerialise FuncName
$cbundleSerialise :: BundleSerialise FuncName
decodeCurrent :: Decoder FuncName
$cdecodeCurrent :: Decoder FuncName
extractor :: Extractor FuncName
$cextractor :: Extractor FuncName
toBuilder :: FuncName -> Builder
$ctoBuilder :: FuncName -> Builder
schemaGen :: Proxy FuncName -> SchemaGen Schema
$cschemaGen :: Proxy FuncName -> SchemaGen Schema
Serialise via WineryVariant FuncName
  deriving newtype FuncName -> ()
forall a. (a -> ()) -> NFData a
rnf :: FuncName -> ()
$crnf :: FuncName -> ()
NFData

instance Hashable FuncName

data Distinctness = Distinct | All
  deriving (Int -> Distinctness -> ShowS
[Distinctness] -> ShowS
Distinctness -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Distinctness] -> ShowS
$cshowList :: [Distinctness] -> ShowS
show :: Distinctness -> String
$cshow :: Distinctness -> String
showsPrec :: Int -> Distinctness -> ShowS
$cshowsPrec :: Int -> Distinctness -> ShowS
Show, Distinctness -> Distinctness -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Distinctness -> Distinctness -> Bool
$c/= :: Distinctness -> Distinctness -> Bool
== :: Distinctness -> Distinctness -> Bool
$c== :: Distinctness -> Distinctness -> Bool
Eq, forall x. Rep Distinctness x -> Distinctness
forall x. Distinctness -> Rep Distinctness x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Distinctness x -> Distinctness
$cfrom :: forall x. Distinctness -> Rep Distinctness x
Generic, Distinctness -> ()
forall a. (a -> ()) -> NFData a
rnf :: Distinctness -> ()
$crnf :: Distinctness -> ()
NFData)
  deriving Typeable Distinctness
BundleSerialise Distinctness
Extractor Distinctness
Decoder Distinctness
Proxy Distinctness -> SchemaGen Schema
Distinctness -> Builder
forall a.
Typeable a
-> (Proxy a -> SchemaGen Schema)
-> (a -> Builder)
-> Extractor a
-> Decoder a
-> BundleSerialise a
-> Serialise a
bundleSerialise :: BundleSerialise Distinctness
$cbundleSerialise :: BundleSerialise Distinctness
decodeCurrent :: Decoder Distinctness
$cdecodeCurrent :: Decoder Distinctness
extractor :: Extractor Distinctness
$cextractor :: Extractor Distinctness
toBuilder :: Distinctness -> Builder
$ctoBuilder :: Distinctness -> Builder
schemaGen :: Proxy Distinctness -> SchemaGen Schema
$cschemaGen :: Proxy Distinctness -> SchemaGen Schema
Serialise via WineryVariant Distinctness

instance Hashable Distinctness

newtype RestrictionExpr = RestrictionExpr ScalarExpr
  deriving (Int -> RestrictionExpr -> ShowS
[RestrictionExpr] -> ShowS
RestrictionExpr -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RestrictionExpr] -> ShowS
$cshowList :: [RestrictionExpr] -> ShowS
show :: RestrictionExpr -> String
$cshow :: RestrictionExpr -> String
showsPrec :: Int -> RestrictionExpr -> ShowS
$cshowsPrec :: Int -> RestrictionExpr -> ShowS
Show, RestrictionExpr -> RestrictionExpr -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RestrictionExpr -> RestrictionExpr -> Bool
$c/= :: RestrictionExpr -> RestrictionExpr -> Bool
== :: RestrictionExpr -> RestrictionExpr -> Bool
$c== :: RestrictionExpr -> RestrictionExpr -> Bool
Eq, forall x. Rep RestrictionExpr x -> RestrictionExpr
forall x. RestrictionExpr -> Rep RestrictionExpr x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep RestrictionExpr x -> RestrictionExpr
$cfrom :: forall x. RestrictionExpr -> Rep RestrictionExpr x
Generic)
  deriving Typeable RestrictionExpr
BundleSerialise RestrictionExpr
Extractor RestrictionExpr
Decoder RestrictionExpr
Proxy RestrictionExpr -> SchemaGen Schema
RestrictionExpr -> Builder
forall a.
Typeable a
-> (Proxy a -> SchemaGen Schema)
-> (a -> Builder)
-> Extractor a
-> Decoder a
-> BundleSerialise a
-> Serialise a
bundleSerialise :: BundleSerialise RestrictionExpr
$cbundleSerialise :: BundleSerialise RestrictionExpr
decodeCurrent :: Decoder RestrictionExpr
$cdecodeCurrent :: Decoder RestrictionExpr
extractor :: Extractor RestrictionExpr
$cextractor :: Extractor RestrictionExpr
toBuilder :: RestrictionExpr -> Builder
$ctoBuilder :: RestrictionExpr -> Builder
schemaGen :: Proxy RestrictionExpr -> SchemaGen Schema
$cschemaGen :: Proxy RestrictionExpr -> SchemaGen Schema
Serialise via WineryVariant RestrictionExpr
  deriving newtype RestrictionExpr -> ()
forall a. (a -> ()) -> NFData a
rnf :: RestrictionExpr -> ()
$crnf :: RestrictionExpr -> ()
NFData
  deriving newtype Eq RestrictionExpr
Int -> RestrictionExpr -> Int
RestrictionExpr -> Int
forall a. Eq a -> (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: RestrictionExpr -> Int
$chash :: RestrictionExpr -> Int
hashWithSalt :: Int -> RestrictionExpr -> Int
$chashWithSalt :: Int -> RestrictionExpr -> Int
Hashable

data TableExpr =
  TableExpr { TableExpr -> [TableRef]
fromClause :: [TableRef],
              TableExpr -> Maybe RestrictionExpr
whereClause :: Maybe RestrictionExpr,
              TableExpr -> [GroupByExpr]
groupByClause :: [GroupByExpr],
              TableExpr -> Maybe HavingExpr
havingClause :: Maybe HavingExpr,
              TableExpr -> [SortExpr]
orderByClause :: [SortExpr],
              TableExpr -> Maybe Integer
limitClause :: Maybe Integer,
              TableExpr -> Maybe Integer
offsetClause :: Maybe Integer
                           }
  deriving (Int -> TableExpr -> ShowS
[TableExpr] -> ShowS
TableExpr -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TableExpr] -> ShowS
$cshowList :: [TableExpr] -> ShowS
show :: TableExpr -> String
$cshow :: TableExpr -> String
showsPrec :: Int -> TableExpr -> ShowS
$cshowsPrec :: Int -> TableExpr -> ShowS
Show, TableExpr -> TableExpr -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TableExpr -> TableExpr -> Bool
$c/= :: TableExpr -> TableExpr -> Bool
== :: TableExpr -> TableExpr -> Bool
$c== :: TableExpr -> TableExpr -> Bool
Eq, forall x. Rep TableExpr x -> TableExpr
forall x. TableExpr -> Rep TableExpr x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep TableExpr x -> TableExpr
$cfrom :: forall x. TableExpr -> Rep TableExpr x
Generic, TableExpr -> ()
forall a. (a -> ()) -> NFData a
rnf :: TableExpr -> ()
$crnf :: TableExpr -> ()
NFData)
  deriving Typeable TableExpr
BundleSerialise TableExpr
Extractor TableExpr
Decoder TableExpr
Proxy TableExpr -> SchemaGen Schema
TableExpr -> Builder
forall a.
Typeable a
-> (Proxy a -> SchemaGen Schema)
-> (a -> Builder)
-> Extractor a
-> Decoder a
-> BundleSerialise a
-> Serialise a
bundleSerialise :: BundleSerialise TableExpr
$cbundleSerialise :: BundleSerialise TableExpr
decodeCurrent :: Decoder TableExpr
$cdecodeCurrent :: Decoder TableExpr
extractor :: Extractor TableExpr
$cextractor :: Extractor TableExpr
toBuilder :: TableExpr -> Builder
$ctoBuilder :: TableExpr -> Builder
schemaGen :: Proxy TableExpr -> SchemaGen Schema
$cschemaGen :: Proxy TableExpr -> SchemaGen Schema
Serialise via WineryRecord TableExpr
  deriving Eq TableExpr
Int -> TableExpr -> Int
TableExpr -> Int
forall a. Eq a -> (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: TableExpr -> Int
$chash :: TableExpr -> Int
hashWithSalt :: Int -> TableExpr -> Int
$chashWithSalt :: Int -> TableExpr -> Int
Hashable

emptyTableExpr :: TableExpr
emptyTableExpr :: TableExpr
emptyTableExpr = TableExpr { fromClause :: [TableRef]
fromClause = [],
                             whereClause :: Maybe RestrictionExpr
whereClause = forall a. Maybe a
Nothing,
                             groupByClause :: [GroupByExpr]
groupByClause = [],
                             havingClause :: Maybe HavingExpr
havingClause = forall a. Maybe a
Nothing,
                             orderByClause :: [SortExpr]
orderByClause = [],
                             limitClause :: Maybe Integer
limitClause = forall a. Maybe a
Nothing,
                             offsetClause :: Maybe Integer
offsetClause = forall a. Maybe a
Nothing }

makeBaseFunctor ''ScalarExprBase