-- |
-- Names for nodes mostly resemble the according definitions in the @gram.y@
-- original Postgres parser file, except for the cases where we can optimize on that.
--
-- For reasoning see the docs of the parsing module of this project.
module PostgresqlSyntax.Ast where

import PostgresqlSyntax.Prelude

-- * Statement

-- |
-- ==== References
-- @
-- PreparableStmt:
--   |  SelectStmt
--   |  InsertStmt
--   |  UpdateStmt
--   |  DeleteStmt
--   |  CallStmt
-- @
data PreparableStmt
  = SelectPreparableStmt SelectStmt
  | InsertPreparableStmt InsertStmt
  | UpdatePreparableStmt UpdateStmt
  | DeletePreparableStmt DeleteStmt
  | CallPreparableStmt CallStmt
  deriving (Int -> PreparableStmt -> ShowS
[PreparableStmt] -> ShowS
PreparableStmt -> String
(Int -> PreparableStmt -> ShowS)
-> (PreparableStmt -> String)
-> ([PreparableStmt] -> ShowS)
-> Show PreparableStmt
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PreparableStmt -> ShowS
showsPrec :: Int -> PreparableStmt -> ShowS
$cshow :: PreparableStmt -> String
show :: PreparableStmt -> String
$cshowList :: [PreparableStmt] -> ShowS
showList :: [PreparableStmt] -> ShowS
Show, (forall x. PreparableStmt -> Rep PreparableStmt x)
-> (forall x. Rep PreparableStmt x -> PreparableStmt)
-> Generic PreparableStmt
forall x. Rep PreparableStmt x -> PreparableStmt
forall x. PreparableStmt -> Rep PreparableStmt x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. PreparableStmt -> Rep PreparableStmt x
from :: forall x. PreparableStmt -> Rep PreparableStmt x
$cto :: forall x. Rep PreparableStmt x -> PreparableStmt
to :: forall x. Rep PreparableStmt x -> PreparableStmt
Generic, PreparableStmt -> PreparableStmt -> Bool
(PreparableStmt -> PreparableStmt -> Bool)
-> (PreparableStmt -> PreparableStmt -> Bool) -> Eq PreparableStmt
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PreparableStmt -> PreparableStmt -> Bool
== :: PreparableStmt -> PreparableStmt -> Bool
$c/= :: PreparableStmt -> PreparableStmt -> Bool
/= :: PreparableStmt -> PreparableStmt -> Bool
Eq, Eq PreparableStmt
Eq PreparableStmt =>
(PreparableStmt -> PreparableStmt -> Ordering)
-> (PreparableStmt -> PreparableStmt -> Bool)
-> (PreparableStmt -> PreparableStmt -> Bool)
-> (PreparableStmt -> PreparableStmt -> Bool)
-> (PreparableStmt -> PreparableStmt -> Bool)
-> (PreparableStmt -> PreparableStmt -> PreparableStmt)
-> (PreparableStmt -> PreparableStmt -> PreparableStmt)
-> Ord PreparableStmt
PreparableStmt -> PreparableStmt -> Bool
PreparableStmt -> PreparableStmt -> Ordering
PreparableStmt -> PreparableStmt -> PreparableStmt
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
$ccompare :: PreparableStmt -> PreparableStmt -> Ordering
compare :: PreparableStmt -> PreparableStmt -> Ordering
$c< :: PreparableStmt -> PreparableStmt -> Bool
< :: PreparableStmt -> PreparableStmt -> Bool
$c<= :: PreparableStmt -> PreparableStmt -> Bool
<= :: PreparableStmt -> PreparableStmt -> Bool
$c> :: PreparableStmt -> PreparableStmt -> Bool
> :: PreparableStmt -> PreparableStmt -> Bool
$c>= :: PreparableStmt -> PreparableStmt -> Bool
>= :: PreparableStmt -> PreparableStmt -> Bool
$cmax :: PreparableStmt -> PreparableStmt -> PreparableStmt
max :: PreparableStmt -> PreparableStmt -> PreparableStmt
$cmin :: PreparableStmt -> PreparableStmt -> PreparableStmt
min :: PreparableStmt -> PreparableStmt -> PreparableStmt
Ord)

-- * Call

newtype CallStmt
  = CallStmt FuncApplication
  deriving (Int -> CallStmt -> ShowS
[CallStmt] -> ShowS
CallStmt -> String
(Int -> CallStmt -> ShowS)
-> (CallStmt -> String) -> ([CallStmt] -> ShowS) -> Show CallStmt
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CallStmt -> ShowS
showsPrec :: Int -> CallStmt -> ShowS
$cshow :: CallStmt -> String
show :: CallStmt -> String
$cshowList :: [CallStmt] -> ShowS
showList :: [CallStmt] -> ShowS
Show, (forall x. CallStmt -> Rep CallStmt x)
-> (forall x. Rep CallStmt x -> CallStmt) -> Generic CallStmt
forall x. Rep CallStmt x -> CallStmt
forall x. CallStmt -> Rep CallStmt x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. CallStmt -> Rep CallStmt x
from :: forall x. CallStmt -> Rep CallStmt x
$cto :: forall x. Rep CallStmt x -> CallStmt
to :: forall x. Rep CallStmt x -> CallStmt
Generic, CallStmt -> CallStmt -> Bool
(CallStmt -> CallStmt -> Bool)
-> (CallStmt -> CallStmt -> Bool) -> Eq CallStmt
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CallStmt -> CallStmt -> Bool
== :: CallStmt -> CallStmt -> Bool
$c/= :: CallStmt -> CallStmt -> Bool
/= :: CallStmt -> CallStmt -> Bool
Eq, Eq CallStmt
Eq CallStmt =>
(CallStmt -> CallStmt -> Ordering)
-> (CallStmt -> CallStmt -> Bool)
-> (CallStmt -> CallStmt -> Bool)
-> (CallStmt -> CallStmt -> Bool)
-> (CallStmt -> CallStmt -> Bool)
-> (CallStmt -> CallStmt -> CallStmt)
-> (CallStmt -> CallStmt -> CallStmt)
-> Ord CallStmt
CallStmt -> CallStmt -> Bool
CallStmt -> CallStmt -> Ordering
CallStmt -> CallStmt -> CallStmt
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
$ccompare :: CallStmt -> CallStmt -> Ordering
compare :: CallStmt -> CallStmt -> Ordering
$c< :: CallStmt -> CallStmt -> Bool
< :: CallStmt -> CallStmt -> Bool
$c<= :: CallStmt -> CallStmt -> Bool
<= :: CallStmt -> CallStmt -> Bool
$c> :: CallStmt -> CallStmt -> Bool
> :: CallStmt -> CallStmt -> Bool
$c>= :: CallStmt -> CallStmt -> Bool
>= :: CallStmt -> CallStmt -> Bool
$cmax :: CallStmt -> CallStmt -> CallStmt
max :: CallStmt -> CallStmt -> CallStmt
$cmin :: CallStmt -> CallStmt -> CallStmt
min :: CallStmt -> CallStmt -> CallStmt
Ord)

-- * Insert

-- |
-- ==== References
-- @
-- InsertStmt:
--   | opt_with_clause INSERT INTO insert_target insert_rest
--       opt_on_conflict returning_clause
-- @
data InsertStmt = InsertStmt (Maybe WithClause) InsertTarget InsertRest (Maybe OnConflict) (Maybe ReturningClause)
  deriving (Int -> InsertStmt -> ShowS
[InsertStmt] -> ShowS
InsertStmt -> String
(Int -> InsertStmt -> ShowS)
-> (InsertStmt -> String)
-> ([InsertStmt] -> ShowS)
-> Show InsertStmt
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> InsertStmt -> ShowS
showsPrec :: Int -> InsertStmt -> ShowS
$cshow :: InsertStmt -> String
show :: InsertStmt -> String
$cshowList :: [InsertStmt] -> ShowS
showList :: [InsertStmt] -> ShowS
Show, (forall x. InsertStmt -> Rep InsertStmt x)
-> (forall x. Rep InsertStmt x -> InsertStmt) -> Generic InsertStmt
forall x. Rep InsertStmt x -> InsertStmt
forall x. InsertStmt -> Rep InsertStmt x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. InsertStmt -> Rep InsertStmt x
from :: forall x. InsertStmt -> Rep InsertStmt x
$cto :: forall x. Rep InsertStmt x -> InsertStmt
to :: forall x. Rep InsertStmt x -> InsertStmt
Generic, InsertStmt -> InsertStmt -> Bool
(InsertStmt -> InsertStmt -> Bool)
-> (InsertStmt -> InsertStmt -> Bool) -> Eq InsertStmt
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: InsertStmt -> InsertStmt -> Bool
== :: InsertStmt -> InsertStmt -> Bool
$c/= :: InsertStmt -> InsertStmt -> Bool
/= :: InsertStmt -> InsertStmt -> Bool
Eq, Eq InsertStmt
Eq InsertStmt =>
(InsertStmt -> InsertStmt -> Ordering)
-> (InsertStmt -> InsertStmt -> Bool)
-> (InsertStmt -> InsertStmt -> Bool)
-> (InsertStmt -> InsertStmt -> Bool)
-> (InsertStmt -> InsertStmt -> Bool)
-> (InsertStmt -> InsertStmt -> InsertStmt)
-> (InsertStmt -> InsertStmt -> InsertStmt)
-> Ord InsertStmt
InsertStmt -> InsertStmt -> Bool
InsertStmt -> InsertStmt -> Ordering
InsertStmt -> InsertStmt -> InsertStmt
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
$ccompare :: InsertStmt -> InsertStmt -> Ordering
compare :: InsertStmt -> InsertStmt -> Ordering
$c< :: InsertStmt -> InsertStmt -> Bool
< :: InsertStmt -> InsertStmt -> Bool
$c<= :: InsertStmt -> InsertStmt -> Bool
<= :: InsertStmt -> InsertStmt -> Bool
$c> :: InsertStmt -> InsertStmt -> Bool
> :: InsertStmt -> InsertStmt -> Bool
$c>= :: InsertStmt -> InsertStmt -> Bool
>= :: InsertStmt -> InsertStmt -> Bool
$cmax :: InsertStmt -> InsertStmt -> InsertStmt
max :: InsertStmt -> InsertStmt -> InsertStmt
$cmin :: InsertStmt -> InsertStmt -> InsertStmt
min :: InsertStmt -> InsertStmt -> InsertStmt
Ord)

-- |
-- ==== References
-- @
-- insert_target:
--   | qualified_name
--   | qualified_name AS ColId
-- @
data InsertTarget = InsertTarget QualifiedName (Maybe ColId)
  deriving (Int -> InsertTarget -> ShowS
[InsertTarget] -> ShowS
InsertTarget -> String
(Int -> InsertTarget -> ShowS)
-> (InsertTarget -> String)
-> ([InsertTarget] -> ShowS)
-> Show InsertTarget
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> InsertTarget -> ShowS
showsPrec :: Int -> InsertTarget -> ShowS
$cshow :: InsertTarget -> String
show :: InsertTarget -> String
$cshowList :: [InsertTarget] -> ShowS
showList :: [InsertTarget] -> ShowS
Show, (forall x. InsertTarget -> Rep InsertTarget x)
-> (forall x. Rep InsertTarget x -> InsertTarget)
-> Generic InsertTarget
forall x. Rep InsertTarget x -> InsertTarget
forall x. InsertTarget -> Rep InsertTarget x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. InsertTarget -> Rep InsertTarget x
from :: forall x. InsertTarget -> Rep InsertTarget x
$cto :: forall x. Rep InsertTarget x -> InsertTarget
to :: forall x. Rep InsertTarget x -> InsertTarget
Generic, InsertTarget -> InsertTarget -> Bool
(InsertTarget -> InsertTarget -> Bool)
-> (InsertTarget -> InsertTarget -> Bool) -> Eq InsertTarget
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: InsertTarget -> InsertTarget -> Bool
== :: InsertTarget -> InsertTarget -> Bool
$c/= :: InsertTarget -> InsertTarget -> Bool
/= :: InsertTarget -> InsertTarget -> Bool
Eq, Eq InsertTarget
Eq InsertTarget =>
(InsertTarget -> InsertTarget -> Ordering)
-> (InsertTarget -> InsertTarget -> Bool)
-> (InsertTarget -> InsertTarget -> Bool)
-> (InsertTarget -> InsertTarget -> Bool)
-> (InsertTarget -> InsertTarget -> Bool)
-> (InsertTarget -> InsertTarget -> InsertTarget)
-> (InsertTarget -> InsertTarget -> InsertTarget)
-> Ord InsertTarget
InsertTarget -> InsertTarget -> Bool
InsertTarget -> InsertTarget -> Ordering
InsertTarget -> InsertTarget -> InsertTarget
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
$ccompare :: InsertTarget -> InsertTarget -> Ordering
compare :: InsertTarget -> InsertTarget -> Ordering
$c< :: InsertTarget -> InsertTarget -> Bool
< :: InsertTarget -> InsertTarget -> Bool
$c<= :: InsertTarget -> InsertTarget -> Bool
<= :: InsertTarget -> InsertTarget -> Bool
$c> :: InsertTarget -> InsertTarget -> Bool
> :: InsertTarget -> InsertTarget -> Bool
$c>= :: InsertTarget -> InsertTarget -> Bool
>= :: InsertTarget -> InsertTarget -> Bool
$cmax :: InsertTarget -> InsertTarget -> InsertTarget
max :: InsertTarget -> InsertTarget -> InsertTarget
$cmin :: InsertTarget -> InsertTarget -> InsertTarget
min :: InsertTarget -> InsertTarget -> InsertTarget
Ord)

-- |
-- ==== References
-- @
-- insert_rest:
--   | SelectStmt
--   | OVERRIDING override_kind VALUE_P SelectStmt
--   | '(' insert_column_list ')' SelectStmt
--   | '(' insert_column_list ')' OVERRIDING override_kind VALUE_P SelectStmt
--   | DEFAULT VALUES
-- @
data InsertRest
  = SelectInsertRest (Maybe InsertColumnList) (Maybe OverrideKind) SelectStmt
  | DefaultValuesInsertRest
  deriving (Int -> InsertRest -> ShowS
[InsertRest] -> ShowS
InsertRest -> String
(Int -> InsertRest -> ShowS)
-> (InsertRest -> String)
-> ([InsertRest] -> ShowS)
-> Show InsertRest
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> InsertRest -> ShowS
showsPrec :: Int -> InsertRest -> ShowS
$cshow :: InsertRest -> String
show :: InsertRest -> String
$cshowList :: [InsertRest] -> ShowS
showList :: [InsertRest] -> ShowS
Show, (forall x. InsertRest -> Rep InsertRest x)
-> (forall x. Rep InsertRest x -> InsertRest) -> Generic InsertRest
forall x. Rep InsertRest x -> InsertRest
forall x. InsertRest -> Rep InsertRest x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. InsertRest -> Rep InsertRest x
from :: forall x. InsertRest -> Rep InsertRest x
$cto :: forall x. Rep InsertRest x -> InsertRest
to :: forall x. Rep InsertRest x -> InsertRest
Generic, InsertRest -> InsertRest -> Bool
(InsertRest -> InsertRest -> Bool)
-> (InsertRest -> InsertRest -> Bool) -> Eq InsertRest
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: InsertRest -> InsertRest -> Bool
== :: InsertRest -> InsertRest -> Bool
$c/= :: InsertRest -> InsertRest -> Bool
/= :: InsertRest -> InsertRest -> Bool
Eq, Eq InsertRest
Eq InsertRest =>
(InsertRest -> InsertRest -> Ordering)
-> (InsertRest -> InsertRest -> Bool)
-> (InsertRest -> InsertRest -> Bool)
-> (InsertRest -> InsertRest -> Bool)
-> (InsertRest -> InsertRest -> Bool)
-> (InsertRest -> InsertRest -> InsertRest)
-> (InsertRest -> InsertRest -> InsertRest)
-> Ord InsertRest
InsertRest -> InsertRest -> Bool
InsertRest -> InsertRest -> Ordering
InsertRest -> InsertRest -> InsertRest
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
$ccompare :: InsertRest -> InsertRest -> Ordering
compare :: InsertRest -> InsertRest -> Ordering
$c< :: InsertRest -> InsertRest -> Bool
< :: InsertRest -> InsertRest -> Bool
$c<= :: InsertRest -> InsertRest -> Bool
<= :: InsertRest -> InsertRest -> Bool
$c> :: InsertRest -> InsertRest -> Bool
> :: InsertRest -> InsertRest -> Bool
$c>= :: InsertRest -> InsertRest -> Bool
>= :: InsertRest -> InsertRest -> Bool
$cmax :: InsertRest -> InsertRest -> InsertRest
max :: InsertRest -> InsertRest -> InsertRest
$cmin :: InsertRest -> InsertRest -> InsertRest
min :: InsertRest -> InsertRest -> InsertRest
Ord)

-- |
-- ==== References
-- @
-- override_kind:
--   | USER
--   | SYSTEM_P
-- @
data OverrideKind = UserOverrideKind | SystemOverrideKind
  deriving (Int -> OverrideKind -> ShowS
[OverrideKind] -> ShowS
OverrideKind -> String
(Int -> OverrideKind -> ShowS)
-> (OverrideKind -> String)
-> ([OverrideKind] -> ShowS)
-> Show OverrideKind
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> OverrideKind -> ShowS
showsPrec :: Int -> OverrideKind -> ShowS
$cshow :: OverrideKind -> String
show :: OverrideKind -> String
$cshowList :: [OverrideKind] -> ShowS
showList :: [OverrideKind] -> ShowS
Show, (forall x. OverrideKind -> Rep OverrideKind x)
-> (forall x. Rep OverrideKind x -> OverrideKind)
-> Generic OverrideKind
forall x. Rep OverrideKind x -> OverrideKind
forall x. OverrideKind -> Rep OverrideKind x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. OverrideKind -> Rep OverrideKind x
from :: forall x. OverrideKind -> Rep OverrideKind x
$cto :: forall x. Rep OverrideKind x -> OverrideKind
to :: forall x. Rep OverrideKind x -> OverrideKind
Generic, OverrideKind -> OverrideKind -> Bool
(OverrideKind -> OverrideKind -> Bool)
-> (OverrideKind -> OverrideKind -> Bool) -> Eq OverrideKind
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: OverrideKind -> OverrideKind -> Bool
== :: OverrideKind -> OverrideKind -> Bool
$c/= :: OverrideKind -> OverrideKind -> Bool
/= :: OverrideKind -> OverrideKind -> Bool
Eq, Eq OverrideKind
Eq OverrideKind =>
(OverrideKind -> OverrideKind -> Ordering)
-> (OverrideKind -> OverrideKind -> Bool)
-> (OverrideKind -> OverrideKind -> Bool)
-> (OverrideKind -> OverrideKind -> Bool)
-> (OverrideKind -> OverrideKind -> Bool)
-> (OverrideKind -> OverrideKind -> OverrideKind)
-> (OverrideKind -> OverrideKind -> OverrideKind)
-> Ord OverrideKind
OverrideKind -> OverrideKind -> Bool
OverrideKind -> OverrideKind -> Ordering
OverrideKind -> OverrideKind -> OverrideKind
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
$ccompare :: OverrideKind -> OverrideKind -> Ordering
compare :: OverrideKind -> OverrideKind -> Ordering
$c< :: OverrideKind -> OverrideKind -> Bool
< :: OverrideKind -> OverrideKind -> Bool
$c<= :: OverrideKind -> OverrideKind -> Bool
<= :: OverrideKind -> OverrideKind -> Bool
$c> :: OverrideKind -> OverrideKind -> Bool
> :: OverrideKind -> OverrideKind -> Bool
$c>= :: OverrideKind -> OverrideKind -> Bool
>= :: OverrideKind -> OverrideKind -> Bool
$cmax :: OverrideKind -> OverrideKind -> OverrideKind
max :: OverrideKind -> OverrideKind -> OverrideKind
$cmin :: OverrideKind -> OverrideKind -> OverrideKind
min :: OverrideKind -> OverrideKind -> OverrideKind
Ord, Int -> OverrideKind
OverrideKind -> Int
OverrideKind -> [OverrideKind]
OverrideKind -> OverrideKind
OverrideKind -> OverrideKind -> [OverrideKind]
OverrideKind -> OverrideKind -> OverrideKind -> [OverrideKind]
(OverrideKind -> OverrideKind)
-> (OverrideKind -> OverrideKind)
-> (Int -> OverrideKind)
-> (OverrideKind -> Int)
-> (OverrideKind -> [OverrideKind])
-> (OverrideKind -> OverrideKind -> [OverrideKind])
-> (OverrideKind -> OverrideKind -> [OverrideKind])
-> (OverrideKind -> OverrideKind -> OverrideKind -> [OverrideKind])
-> Enum OverrideKind
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: OverrideKind -> OverrideKind
succ :: OverrideKind -> OverrideKind
$cpred :: OverrideKind -> OverrideKind
pred :: OverrideKind -> OverrideKind
$ctoEnum :: Int -> OverrideKind
toEnum :: Int -> OverrideKind
$cfromEnum :: OverrideKind -> Int
fromEnum :: OverrideKind -> Int
$cenumFrom :: OverrideKind -> [OverrideKind]
enumFrom :: OverrideKind -> [OverrideKind]
$cenumFromThen :: OverrideKind -> OverrideKind -> [OverrideKind]
enumFromThen :: OverrideKind -> OverrideKind -> [OverrideKind]
$cenumFromTo :: OverrideKind -> OverrideKind -> [OverrideKind]
enumFromTo :: OverrideKind -> OverrideKind -> [OverrideKind]
$cenumFromThenTo :: OverrideKind -> OverrideKind -> OverrideKind -> [OverrideKind]
enumFromThenTo :: OverrideKind -> OverrideKind -> OverrideKind -> [OverrideKind]
Enum, OverrideKind
OverrideKind -> OverrideKind -> Bounded OverrideKind
forall a. a -> a -> Bounded a
$cminBound :: OverrideKind
minBound :: OverrideKind
$cmaxBound :: OverrideKind
maxBound :: OverrideKind
Bounded)

-- |
-- ==== References
-- @
-- insert_column_list:
--   | insert_column_item
--   | insert_column_list ',' insert_column_item
-- @
type InsertColumnList = NonEmpty InsertColumnItem

-- |
-- ==== References
-- @
-- insert_column_item:
--   | ColId opt_indirection
-- @
data InsertColumnItem = InsertColumnItem ColId (Maybe Indirection)
  deriving (Int -> InsertColumnItem -> ShowS
[InsertColumnItem] -> ShowS
InsertColumnItem -> String
(Int -> InsertColumnItem -> ShowS)
-> (InsertColumnItem -> String)
-> ([InsertColumnItem] -> ShowS)
-> Show InsertColumnItem
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> InsertColumnItem -> ShowS
showsPrec :: Int -> InsertColumnItem -> ShowS
$cshow :: InsertColumnItem -> String
show :: InsertColumnItem -> String
$cshowList :: [InsertColumnItem] -> ShowS
showList :: [InsertColumnItem] -> ShowS
Show, (forall x. InsertColumnItem -> Rep InsertColumnItem x)
-> (forall x. Rep InsertColumnItem x -> InsertColumnItem)
-> Generic InsertColumnItem
forall x. Rep InsertColumnItem x -> InsertColumnItem
forall x. InsertColumnItem -> Rep InsertColumnItem x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. InsertColumnItem -> Rep InsertColumnItem x
from :: forall x. InsertColumnItem -> Rep InsertColumnItem x
$cto :: forall x. Rep InsertColumnItem x -> InsertColumnItem
to :: forall x. Rep InsertColumnItem x -> InsertColumnItem
Generic, InsertColumnItem -> InsertColumnItem -> Bool
(InsertColumnItem -> InsertColumnItem -> Bool)
-> (InsertColumnItem -> InsertColumnItem -> Bool)
-> Eq InsertColumnItem
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: InsertColumnItem -> InsertColumnItem -> Bool
== :: InsertColumnItem -> InsertColumnItem -> Bool
$c/= :: InsertColumnItem -> InsertColumnItem -> Bool
/= :: InsertColumnItem -> InsertColumnItem -> Bool
Eq, Eq InsertColumnItem
Eq InsertColumnItem =>
(InsertColumnItem -> InsertColumnItem -> Ordering)
-> (InsertColumnItem -> InsertColumnItem -> Bool)
-> (InsertColumnItem -> InsertColumnItem -> Bool)
-> (InsertColumnItem -> InsertColumnItem -> Bool)
-> (InsertColumnItem -> InsertColumnItem -> Bool)
-> (InsertColumnItem -> InsertColumnItem -> InsertColumnItem)
-> (InsertColumnItem -> InsertColumnItem -> InsertColumnItem)
-> Ord InsertColumnItem
InsertColumnItem -> InsertColumnItem -> Bool
InsertColumnItem -> InsertColumnItem -> Ordering
InsertColumnItem -> InsertColumnItem -> InsertColumnItem
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
$ccompare :: InsertColumnItem -> InsertColumnItem -> Ordering
compare :: InsertColumnItem -> InsertColumnItem -> Ordering
$c< :: InsertColumnItem -> InsertColumnItem -> Bool
< :: InsertColumnItem -> InsertColumnItem -> Bool
$c<= :: InsertColumnItem -> InsertColumnItem -> Bool
<= :: InsertColumnItem -> InsertColumnItem -> Bool
$c> :: InsertColumnItem -> InsertColumnItem -> Bool
> :: InsertColumnItem -> InsertColumnItem -> Bool
$c>= :: InsertColumnItem -> InsertColumnItem -> Bool
>= :: InsertColumnItem -> InsertColumnItem -> Bool
$cmax :: InsertColumnItem -> InsertColumnItem -> InsertColumnItem
max :: InsertColumnItem -> InsertColumnItem -> InsertColumnItem
$cmin :: InsertColumnItem -> InsertColumnItem -> InsertColumnItem
min :: InsertColumnItem -> InsertColumnItem -> InsertColumnItem
Ord)

-- |
-- ==== References
-- @
-- opt_on_conflict:
--   | ON CONFLICT opt_conf_expr DO UPDATE SET set_clause_list where_clause
--   | ON CONFLICT opt_conf_expr DO NOTHING
--   | EMPTY
-- @
data OnConflict = OnConflict (Maybe ConfExpr) OnConflictDo
  deriving (Int -> OnConflict -> ShowS
[OnConflict] -> ShowS
OnConflict -> String
(Int -> OnConflict -> ShowS)
-> (OnConflict -> String)
-> ([OnConflict] -> ShowS)
-> Show OnConflict
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> OnConflict -> ShowS
showsPrec :: Int -> OnConflict -> ShowS
$cshow :: OnConflict -> String
show :: OnConflict -> String
$cshowList :: [OnConflict] -> ShowS
showList :: [OnConflict] -> ShowS
Show, (forall x. OnConflict -> Rep OnConflict x)
-> (forall x. Rep OnConflict x -> OnConflict) -> Generic OnConflict
forall x. Rep OnConflict x -> OnConflict
forall x. OnConflict -> Rep OnConflict x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. OnConflict -> Rep OnConflict x
from :: forall x. OnConflict -> Rep OnConflict x
$cto :: forall x. Rep OnConflict x -> OnConflict
to :: forall x. Rep OnConflict x -> OnConflict
Generic, OnConflict -> OnConflict -> Bool
(OnConflict -> OnConflict -> Bool)
-> (OnConflict -> OnConflict -> Bool) -> Eq OnConflict
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: OnConflict -> OnConflict -> Bool
== :: OnConflict -> OnConflict -> Bool
$c/= :: OnConflict -> OnConflict -> Bool
/= :: OnConflict -> OnConflict -> Bool
Eq, Eq OnConflict
Eq OnConflict =>
(OnConflict -> OnConflict -> Ordering)
-> (OnConflict -> OnConflict -> Bool)
-> (OnConflict -> OnConflict -> Bool)
-> (OnConflict -> OnConflict -> Bool)
-> (OnConflict -> OnConflict -> Bool)
-> (OnConflict -> OnConflict -> OnConflict)
-> (OnConflict -> OnConflict -> OnConflict)
-> Ord OnConflict
OnConflict -> OnConflict -> Bool
OnConflict -> OnConflict -> Ordering
OnConflict -> OnConflict -> OnConflict
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
$ccompare :: OnConflict -> OnConflict -> Ordering
compare :: OnConflict -> OnConflict -> Ordering
$c< :: OnConflict -> OnConflict -> Bool
< :: OnConflict -> OnConflict -> Bool
$c<= :: OnConflict -> OnConflict -> Bool
<= :: OnConflict -> OnConflict -> Bool
$c> :: OnConflict -> OnConflict -> Bool
> :: OnConflict -> OnConflict -> Bool
$c>= :: OnConflict -> OnConflict -> Bool
>= :: OnConflict -> OnConflict -> Bool
$cmax :: OnConflict -> OnConflict -> OnConflict
max :: OnConflict -> OnConflict -> OnConflict
$cmin :: OnConflict -> OnConflict -> OnConflict
min :: OnConflict -> OnConflict -> OnConflict
Ord)

-- |
-- ==== References
-- @
-- opt_on_conflict:
--   | ON CONFLICT opt_conf_expr DO UPDATE SET set_clause_list where_clause
--   | ON CONFLICT opt_conf_expr DO NOTHING
--   | EMPTY
-- @
data OnConflictDo
  = UpdateOnConflictDo SetClauseList (Maybe WhereClause)
  | NothingOnConflictDo
  deriving (Int -> OnConflictDo -> ShowS
[OnConflictDo] -> ShowS
OnConflictDo -> String
(Int -> OnConflictDo -> ShowS)
-> (OnConflictDo -> String)
-> ([OnConflictDo] -> ShowS)
-> Show OnConflictDo
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> OnConflictDo -> ShowS
showsPrec :: Int -> OnConflictDo -> ShowS
$cshow :: OnConflictDo -> String
show :: OnConflictDo -> String
$cshowList :: [OnConflictDo] -> ShowS
showList :: [OnConflictDo] -> ShowS
Show, (forall x. OnConflictDo -> Rep OnConflictDo x)
-> (forall x. Rep OnConflictDo x -> OnConflictDo)
-> Generic OnConflictDo
forall x. Rep OnConflictDo x -> OnConflictDo
forall x. OnConflictDo -> Rep OnConflictDo x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. OnConflictDo -> Rep OnConflictDo x
from :: forall x. OnConflictDo -> Rep OnConflictDo x
$cto :: forall x. Rep OnConflictDo x -> OnConflictDo
to :: forall x. Rep OnConflictDo x -> OnConflictDo
Generic, OnConflictDo -> OnConflictDo -> Bool
(OnConflictDo -> OnConflictDo -> Bool)
-> (OnConflictDo -> OnConflictDo -> Bool) -> Eq OnConflictDo
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: OnConflictDo -> OnConflictDo -> Bool
== :: OnConflictDo -> OnConflictDo -> Bool
$c/= :: OnConflictDo -> OnConflictDo -> Bool
/= :: OnConflictDo -> OnConflictDo -> Bool
Eq, Eq OnConflictDo
Eq OnConflictDo =>
(OnConflictDo -> OnConflictDo -> Ordering)
-> (OnConflictDo -> OnConflictDo -> Bool)
-> (OnConflictDo -> OnConflictDo -> Bool)
-> (OnConflictDo -> OnConflictDo -> Bool)
-> (OnConflictDo -> OnConflictDo -> Bool)
-> (OnConflictDo -> OnConflictDo -> OnConflictDo)
-> (OnConflictDo -> OnConflictDo -> OnConflictDo)
-> Ord OnConflictDo
OnConflictDo -> OnConflictDo -> Bool
OnConflictDo -> OnConflictDo -> Ordering
OnConflictDo -> OnConflictDo -> OnConflictDo
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
$ccompare :: OnConflictDo -> OnConflictDo -> Ordering
compare :: OnConflictDo -> OnConflictDo -> Ordering
$c< :: OnConflictDo -> OnConflictDo -> Bool
< :: OnConflictDo -> OnConflictDo -> Bool
$c<= :: OnConflictDo -> OnConflictDo -> Bool
<= :: OnConflictDo -> OnConflictDo -> Bool
$c> :: OnConflictDo -> OnConflictDo -> Bool
> :: OnConflictDo -> OnConflictDo -> Bool
$c>= :: OnConflictDo -> OnConflictDo -> Bool
>= :: OnConflictDo -> OnConflictDo -> Bool
$cmax :: OnConflictDo -> OnConflictDo -> OnConflictDo
max :: OnConflictDo -> OnConflictDo -> OnConflictDo
$cmin :: OnConflictDo -> OnConflictDo -> OnConflictDo
min :: OnConflictDo -> OnConflictDo -> OnConflictDo
Ord)

-- |
-- ==== References
-- @
-- opt_conf_expr:
--   | '(' index_params ')' where_clause
--   | ON CONSTRAINT name
--   | EMPTY
-- @
data ConfExpr
  = WhereConfExpr IndexParams (Maybe WhereClause)
  | ConstraintConfExpr Name
  deriving (Int -> ConfExpr -> ShowS
[ConfExpr] -> ShowS
ConfExpr -> String
(Int -> ConfExpr -> ShowS)
-> (ConfExpr -> String) -> ([ConfExpr] -> ShowS) -> Show ConfExpr
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ConfExpr -> ShowS
showsPrec :: Int -> ConfExpr -> ShowS
$cshow :: ConfExpr -> String
show :: ConfExpr -> String
$cshowList :: [ConfExpr] -> ShowS
showList :: [ConfExpr] -> ShowS
Show, (forall x. ConfExpr -> Rep ConfExpr x)
-> (forall x. Rep ConfExpr x -> ConfExpr) -> Generic ConfExpr
forall x. Rep ConfExpr x -> ConfExpr
forall x. ConfExpr -> Rep ConfExpr x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ConfExpr -> Rep ConfExpr x
from :: forall x. ConfExpr -> Rep ConfExpr x
$cto :: forall x. Rep ConfExpr x -> ConfExpr
to :: forall x. Rep ConfExpr x -> ConfExpr
Generic, ConfExpr -> ConfExpr -> Bool
(ConfExpr -> ConfExpr -> Bool)
-> (ConfExpr -> ConfExpr -> Bool) -> Eq ConfExpr
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ConfExpr -> ConfExpr -> Bool
== :: ConfExpr -> ConfExpr -> Bool
$c/= :: ConfExpr -> ConfExpr -> Bool
/= :: ConfExpr -> ConfExpr -> Bool
Eq, Eq ConfExpr
Eq ConfExpr =>
(ConfExpr -> ConfExpr -> Ordering)
-> (ConfExpr -> ConfExpr -> Bool)
-> (ConfExpr -> ConfExpr -> Bool)
-> (ConfExpr -> ConfExpr -> Bool)
-> (ConfExpr -> ConfExpr -> Bool)
-> (ConfExpr -> ConfExpr -> ConfExpr)
-> (ConfExpr -> ConfExpr -> ConfExpr)
-> Ord ConfExpr
ConfExpr -> ConfExpr -> Bool
ConfExpr -> ConfExpr -> Ordering
ConfExpr -> ConfExpr -> ConfExpr
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
$ccompare :: ConfExpr -> ConfExpr -> Ordering
compare :: ConfExpr -> ConfExpr -> Ordering
$c< :: ConfExpr -> ConfExpr -> Bool
< :: ConfExpr -> ConfExpr -> Bool
$c<= :: ConfExpr -> ConfExpr -> Bool
<= :: ConfExpr -> ConfExpr -> Bool
$c> :: ConfExpr -> ConfExpr -> Bool
> :: ConfExpr -> ConfExpr -> Bool
$c>= :: ConfExpr -> ConfExpr -> Bool
>= :: ConfExpr -> ConfExpr -> Bool
$cmax :: ConfExpr -> ConfExpr -> ConfExpr
max :: ConfExpr -> ConfExpr -> ConfExpr
$cmin :: ConfExpr -> ConfExpr -> ConfExpr
min :: ConfExpr -> ConfExpr -> ConfExpr
Ord)

-- |
-- ==== References
-- @
-- returning_clause:
--   | RETURNING target_list
--   | EMPTY
-- @
type ReturningClause = TargetList

-- * Update

-- |
-- ==== References
-- @
-- UpdateStmt:
--   | opt_with_clause UPDATE relation_expr_opt_alias
--       SET set_clause_list
--       from_clause
--       where_or_current_clause
--       returning_clause
-- @
data UpdateStmt = UpdateStmt (Maybe WithClause) RelationExprOptAlias SetClauseList (Maybe FromClause) (Maybe WhereOrCurrentClause) (Maybe ReturningClause)
  deriving (Int -> UpdateStmt -> ShowS
[UpdateStmt] -> ShowS
UpdateStmt -> String
(Int -> UpdateStmt -> ShowS)
-> (UpdateStmt -> String)
-> ([UpdateStmt] -> ShowS)
-> Show UpdateStmt
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> UpdateStmt -> ShowS
showsPrec :: Int -> UpdateStmt -> ShowS
$cshow :: UpdateStmt -> String
show :: UpdateStmt -> String
$cshowList :: [UpdateStmt] -> ShowS
showList :: [UpdateStmt] -> ShowS
Show, (forall x. UpdateStmt -> Rep UpdateStmt x)
-> (forall x. Rep UpdateStmt x -> UpdateStmt) -> Generic UpdateStmt
forall x. Rep UpdateStmt x -> UpdateStmt
forall x. UpdateStmt -> Rep UpdateStmt x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. UpdateStmt -> Rep UpdateStmt x
from :: forall x. UpdateStmt -> Rep UpdateStmt x
$cto :: forall x. Rep UpdateStmt x -> UpdateStmt
to :: forall x. Rep UpdateStmt x -> UpdateStmt
Generic, UpdateStmt -> UpdateStmt -> Bool
(UpdateStmt -> UpdateStmt -> Bool)
-> (UpdateStmt -> UpdateStmt -> Bool) -> Eq UpdateStmt
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: UpdateStmt -> UpdateStmt -> Bool
== :: UpdateStmt -> UpdateStmt -> Bool
$c/= :: UpdateStmt -> UpdateStmt -> Bool
/= :: UpdateStmt -> UpdateStmt -> Bool
Eq, Eq UpdateStmt
Eq UpdateStmt =>
(UpdateStmt -> UpdateStmt -> Ordering)
-> (UpdateStmt -> UpdateStmt -> Bool)
-> (UpdateStmt -> UpdateStmt -> Bool)
-> (UpdateStmt -> UpdateStmt -> Bool)
-> (UpdateStmt -> UpdateStmt -> Bool)
-> (UpdateStmt -> UpdateStmt -> UpdateStmt)
-> (UpdateStmt -> UpdateStmt -> UpdateStmt)
-> Ord UpdateStmt
UpdateStmt -> UpdateStmt -> Bool
UpdateStmt -> UpdateStmt -> Ordering
UpdateStmt -> UpdateStmt -> UpdateStmt
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
$ccompare :: UpdateStmt -> UpdateStmt -> Ordering
compare :: UpdateStmt -> UpdateStmt -> Ordering
$c< :: UpdateStmt -> UpdateStmt -> Bool
< :: UpdateStmt -> UpdateStmt -> Bool
$c<= :: UpdateStmt -> UpdateStmt -> Bool
<= :: UpdateStmt -> UpdateStmt -> Bool
$c> :: UpdateStmt -> UpdateStmt -> Bool
> :: UpdateStmt -> UpdateStmt -> Bool
$c>= :: UpdateStmt -> UpdateStmt -> Bool
>= :: UpdateStmt -> UpdateStmt -> Bool
$cmax :: UpdateStmt -> UpdateStmt -> UpdateStmt
max :: UpdateStmt -> UpdateStmt -> UpdateStmt
$cmin :: UpdateStmt -> UpdateStmt -> UpdateStmt
min :: UpdateStmt -> UpdateStmt -> UpdateStmt
Ord)

-- |
-- ==== References
-- @
-- set_clause_list:
--   | set_clause
--   | set_clause_list ',' set_clause
-- @
type SetClauseList = NonEmpty SetClause

-- |
-- ==== References
-- @
-- set_clause:
--   | set_target '=' a_expr
--   | '(' set_target_list ')' '=' a_expr
-- @
data SetClause
  = TargetSetClause SetTarget AExpr
  | TargetListSetClause SetTargetList AExpr
  deriving (Int -> SetClause -> ShowS
[SetClause] -> ShowS
SetClause -> String
(Int -> SetClause -> ShowS)
-> (SetClause -> String)
-> ([SetClause] -> ShowS)
-> Show SetClause
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SetClause -> ShowS
showsPrec :: Int -> SetClause -> ShowS
$cshow :: SetClause -> String
show :: SetClause -> String
$cshowList :: [SetClause] -> ShowS
showList :: [SetClause] -> ShowS
Show, (forall x. SetClause -> Rep SetClause x)
-> (forall x. Rep SetClause x -> SetClause) -> Generic SetClause
forall x. Rep SetClause x -> SetClause
forall x. SetClause -> Rep SetClause x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. SetClause -> Rep SetClause x
from :: forall x. SetClause -> Rep SetClause x
$cto :: forall x. Rep SetClause x -> SetClause
to :: forall x. Rep SetClause x -> SetClause
Generic, SetClause -> SetClause -> Bool
(SetClause -> SetClause -> Bool)
-> (SetClause -> SetClause -> Bool) -> Eq SetClause
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SetClause -> SetClause -> Bool
== :: SetClause -> SetClause -> Bool
$c/= :: SetClause -> SetClause -> Bool
/= :: SetClause -> SetClause -> Bool
Eq, Eq SetClause
Eq SetClause =>
(SetClause -> SetClause -> Ordering)
-> (SetClause -> SetClause -> Bool)
-> (SetClause -> SetClause -> Bool)
-> (SetClause -> SetClause -> Bool)
-> (SetClause -> SetClause -> Bool)
-> (SetClause -> SetClause -> SetClause)
-> (SetClause -> SetClause -> SetClause)
-> Ord SetClause
SetClause -> SetClause -> Bool
SetClause -> SetClause -> Ordering
SetClause -> SetClause -> SetClause
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
$ccompare :: SetClause -> SetClause -> Ordering
compare :: SetClause -> SetClause -> Ordering
$c< :: SetClause -> SetClause -> Bool
< :: SetClause -> SetClause -> Bool
$c<= :: SetClause -> SetClause -> Bool
<= :: SetClause -> SetClause -> Bool
$c> :: SetClause -> SetClause -> Bool
> :: SetClause -> SetClause -> Bool
$c>= :: SetClause -> SetClause -> Bool
>= :: SetClause -> SetClause -> Bool
$cmax :: SetClause -> SetClause -> SetClause
max :: SetClause -> SetClause -> SetClause
$cmin :: SetClause -> SetClause -> SetClause
min :: SetClause -> SetClause -> SetClause
Ord)

-- |
-- ==== References
-- @
-- set_target:
--   | ColId opt_indirection
-- @
data SetTarget = SetTarget ColId (Maybe Indirection)
  deriving (Int -> SetTarget -> ShowS
[SetTarget] -> ShowS
SetTarget -> String
(Int -> SetTarget -> ShowS)
-> (SetTarget -> String)
-> ([SetTarget] -> ShowS)
-> Show SetTarget
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SetTarget -> ShowS
showsPrec :: Int -> SetTarget -> ShowS
$cshow :: SetTarget -> String
show :: SetTarget -> String
$cshowList :: [SetTarget] -> ShowS
showList :: [SetTarget] -> ShowS
Show, (forall x. SetTarget -> Rep SetTarget x)
-> (forall x. Rep SetTarget x -> SetTarget) -> Generic SetTarget
forall x. Rep SetTarget x -> SetTarget
forall x. SetTarget -> Rep SetTarget x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. SetTarget -> Rep SetTarget x
from :: forall x. SetTarget -> Rep SetTarget x
$cto :: forall x. Rep SetTarget x -> SetTarget
to :: forall x. Rep SetTarget x -> SetTarget
Generic, SetTarget -> SetTarget -> Bool
(SetTarget -> SetTarget -> Bool)
-> (SetTarget -> SetTarget -> Bool) -> Eq SetTarget
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SetTarget -> SetTarget -> Bool
== :: SetTarget -> SetTarget -> Bool
$c/= :: SetTarget -> SetTarget -> Bool
/= :: SetTarget -> SetTarget -> Bool
Eq, Eq SetTarget
Eq SetTarget =>
(SetTarget -> SetTarget -> Ordering)
-> (SetTarget -> SetTarget -> Bool)
-> (SetTarget -> SetTarget -> Bool)
-> (SetTarget -> SetTarget -> Bool)
-> (SetTarget -> SetTarget -> Bool)
-> (SetTarget -> SetTarget -> SetTarget)
-> (SetTarget -> SetTarget -> SetTarget)
-> Ord SetTarget
SetTarget -> SetTarget -> Bool
SetTarget -> SetTarget -> Ordering
SetTarget -> SetTarget -> SetTarget
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
$ccompare :: SetTarget -> SetTarget -> Ordering
compare :: SetTarget -> SetTarget -> Ordering
$c< :: SetTarget -> SetTarget -> Bool
< :: SetTarget -> SetTarget -> Bool
$c<= :: SetTarget -> SetTarget -> Bool
<= :: SetTarget -> SetTarget -> Bool
$c> :: SetTarget -> SetTarget -> Bool
> :: SetTarget -> SetTarget -> Bool
$c>= :: SetTarget -> SetTarget -> Bool
>= :: SetTarget -> SetTarget -> Bool
$cmax :: SetTarget -> SetTarget -> SetTarget
max :: SetTarget -> SetTarget -> SetTarget
$cmin :: SetTarget -> SetTarget -> SetTarget
min :: SetTarget -> SetTarget -> SetTarget
Ord)

-- |
-- ==== References
-- @
-- set_target_list:
--   | set_target
--   | set_target_list ',' set_target
-- @
type SetTargetList = NonEmpty SetTarget

-- * Delete

-- |
-- ==== References
-- @
-- DeleteStmt:
--   | opt_with_clause DELETE_P FROM relation_expr_opt_alias
--       using_clause where_or_current_clause returning_clause
-- @
data DeleteStmt = DeleteStmt (Maybe WithClause) RelationExprOptAlias (Maybe UsingClause) (Maybe WhereOrCurrentClause) (Maybe ReturningClause)
  deriving (Int -> DeleteStmt -> ShowS
[DeleteStmt] -> ShowS
DeleteStmt -> String
(Int -> DeleteStmt -> ShowS)
-> (DeleteStmt -> String)
-> ([DeleteStmt] -> ShowS)
-> Show DeleteStmt
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DeleteStmt -> ShowS
showsPrec :: Int -> DeleteStmt -> ShowS
$cshow :: DeleteStmt -> String
show :: DeleteStmt -> String
$cshowList :: [DeleteStmt] -> ShowS
showList :: [DeleteStmt] -> ShowS
Show, (forall x. DeleteStmt -> Rep DeleteStmt x)
-> (forall x. Rep DeleteStmt x -> DeleteStmt) -> Generic DeleteStmt
forall x. Rep DeleteStmt x -> DeleteStmt
forall x. DeleteStmt -> Rep DeleteStmt x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. DeleteStmt -> Rep DeleteStmt x
from :: forall x. DeleteStmt -> Rep DeleteStmt x
$cto :: forall x. Rep DeleteStmt x -> DeleteStmt
to :: forall x. Rep DeleteStmt x -> DeleteStmt
Generic, DeleteStmt -> DeleteStmt -> Bool
(DeleteStmt -> DeleteStmt -> Bool)
-> (DeleteStmt -> DeleteStmt -> Bool) -> Eq DeleteStmt
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DeleteStmt -> DeleteStmt -> Bool
== :: DeleteStmt -> DeleteStmt -> Bool
$c/= :: DeleteStmt -> DeleteStmt -> Bool
/= :: DeleteStmt -> DeleteStmt -> Bool
Eq, Eq DeleteStmt
Eq DeleteStmt =>
(DeleteStmt -> DeleteStmt -> Ordering)
-> (DeleteStmt -> DeleteStmt -> Bool)
-> (DeleteStmt -> DeleteStmt -> Bool)
-> (DeleteStmt -> DeleteStmt -> Bool)
-> (DeleteStmt -> DeleteStmt -> Bool)
-> (DeleteStmt -> DeleteStmt -> DeleteStmt)
-> (DeleteStmt -> DeleteStmt -> DeleteStmt)
-> Ord DeleteStmt
DeleteStmt -> DeleteStmt -> Bool
DeleteStmt -> DeleteStmt -> Ordering
DeleteStmt -> DeleteStmt -> DeleteStmt
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
$ccompare :: DeleteStmt -> DeleteStmt -> Ordering
compare :: DeleteStmt -> DeleteStmt -> Ordering
$c< :: DeleteStmt -> DeleteStmt -> Bool
< :: DeleteStmt -> DeleteStmt -> Bool
$c<= :: DeleteStmt -> DeleteStmt -> Bool
<= :: DeleteStmt -> DeleteStmt -> Bool
$c> :: DeleteStmt -> DeleteStmt -> Bool
> :: DeleteStmt -> DeleteStmt -> Bool
$c>= :: DeleteStmt -> DeleteStmt -> Bool
>= :: DeleteStmt -> DeleteStmt -> Bool
$cmax :: DeleteStmt -> DeleteStmt -> DeleteStmt
max :: DeleteStmt -> DeleteStmt -> DeleteStmt
$cmin :: DeleteStmt -> DeleteStmt -> DeleteStmt
min :: DeleteStmt -> DeleteStmt -> DeleteStmt
Ord)

-- |
-- ==== References
-- @
-- using_clause:
--   | USING from_list
--   | EMPTY
-- @
type UsingClause = FromList

-- * Select

-- |
-- ==== References
-- @
-- SelectStmt:
--   |  select_no_parens
--   |  select_with_parens
-- @
type SelectStmt = Either SelectNoParens SelectWithParens

-- |
-- ==== References
-- @
-- select_with_parens:
--   |  '(' select_no_parens ')'
--   |  '(' select_with_parens ')'
-- @
data SelectWithParens
  = NoParensSelectWithParens SelectNoParens
  | WithParensSelectWithParens SelectWithParens
  deriving (Int -> SelectWithParens -> ShowS
[SelectWithParens] -> ShowS
SelectWithParens -> String
(Int -> SelectWithParens -> ShowS)
-> (SelectWithParens -> String)
-> ([SelectWithParens] -> ShowS)
-> Show SelectWithParens
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SelectWithParens -> ShowS
showsPrec :: Int -> SelectWithParens -> ShowS
$cshow :: SelectWithParens -> String
show :: SelectWithParens -> String
$cshowList :: [SelectWithParens] -> ShowS
showList :: [SelectWithParens] -> ShowS
Show, (forall x. SelectWithParens -> Rep SelectWithParens x)
-> (forall x. Rep SelectWithParens x -> SelectWithParens)
-> Generic SelectWithParens
forall x. Rep SelectWithParens x -> SelectWithParens
forall x. SelectWithParens -> Rep SelectWithParens x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. SelectWithParens -> Rep SelectWithParens x
from :: forall x. SelectWithParens -> Rep SelectWithParens x
$cto :: forall x. Rep SelectWithParens x -> SelectWithParens
to :: forall x. Rep SelectWithParens x -> SelectWithParens
Generic, SelectWithParens -> SelectWithParens -> Bool
(SelectWithParens -> SelectWithParens -> Bool)
-> (SelectWithParens -> SelectWithParens -> Bool)
-> Eq SelectWithParens
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SelectWithParens -> SelectWithParens -> Bool
== :: SelectWithParens -> SelectWithParens -> Bool
$c/= :: SelectWithParens -> SelectWithParens -> Bool
/= :: SelectWithParens -> SelectWithParens -> Bool
Eq, Eq SelectWithParens
Eq SelectWithParens =>
(SelectWithParens -> SelectWithParens -> Ordering)
-> (SelectWithParens -> SelectWithParens -> Bool)
-> (SelectWithParens -> SelectWithParens -> Bool)
-> (SelectWithParens -> SelectWithParens -> Bool)
-> (SelectWithParens -> SelectWithParens -> Bool)
-> (SelectWithParens -> SelectWithParens -> SelectWithParens)
-> (SelectWithParens -> SelectWithParens -> SelectWithParens)
-> Ord SelectWithParens
SelectWithParens -> SelectWithParens -> Bool
SelectWithParens -> SelectWithParens -> Ordering
SelectWithParens -> SelectWithParens -> SelectWithParens
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
$ccompare :: SelectWithParens -> SelectWithParens -> Ordering
compare :: SelectWithParens -> SelectWithParens -> Ordering
$c< :: SelectWithParens -> SelectWithParens -> Bool
< :: SelectWithParens -> SelectWithParens -> Bool
$c<= :: SelectWithParens -> SelectWithParens -> Bool
<= :: SelectWithParens -> SelectWithParens -> Bool
$c> :: SelectWithParens -> SelectWithParens -> Bool
> :: SelectWithParens -> SelectWithParens -> Bool
$c>= :: SelectWithParens -> SelectWithParens -> Bool
>= :: SelectWithParens -> SelectWithParens -> Bool
$cmax :: SelectWithParens -> SelectWithParens -> SelectWithParens
max :: SelectWithParens -> SelectWithParens -> SelectWithParens
$cmin :: SelectWithParens -> SelectWithParens -> SelectWithParens
min :: SelectWithParens -> SelectWithParens -> SelectWithParens
Ord)

-- |
-- Covers the following cases:
--
-- @
-- select_no_parens:
--   |  simple_select
--   |  select_clause sort_clause
--   |  select_clause opt_sort_clause for_locking_clause opt_select_limit
--   |  select_clause opt_sort_clause select_limit opt_for_locking_clause
--   |  with_clause select_clause
--   |  with_clause select_clause sort_clause
--   |  with_clause select_clause opt_sort_clause for_locking_clause opt_select_limit
--   |  with_clause select_clause opt_sort_clause select_limit opt_for_locking_clause
-- @
data SelectNoParens
  = SelectNoParens (Maybe WithClause) SelectClause (Maybe SortClause) (Maybe SelectLimit) (Maybe ForLockingClause)
  deriving (Int -> SelectNoParens -> ShowS
[SelectNoParens] -> ShowS
SelectNoParens -> String
(Int -> SelectNoParens -> ShowS)
-> (SelectNoParens -> String)
-> ([SelectNoParens] -> ShowS)
-> Show SelectNoParens
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SelectNoParens -> ShowS
showsPrec :: Int -> SelectNoParens -> ShowS
$cshow :: SelectNoParens -> String
show :: SelectNoParens -> String
$cshowList :: [SelectNoParens] -> ShowS
showList :: [SelectNoParens] -> ShowS
Show, (forall x. SelectNoParens -> Rep SelectNoParens x)
-> (forall x. Rep SelectNoParens x -> SelectNoParens)
-> Generic SelectNoParens
forall x. Rep SelectNoParens x -> SelectNoParens
forall x. SelectNoParens -> Rep SelectNoParens x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. SelectNoParens -> Rep SelectNoParens x
from :: forall x. SelectNoParens -> Rep SelectNoParens x
$cto :: forall x. Rep SelectNoParens x -> SelectNoParens
to :: forall x. Rep SelectNoParens x -> SelectNoParens
Generic, SelectNoParens -> SelectNoParens -> Bool
(SelectNoParens -> SelectNoParens -> Bool)
-> (SelectNoParens -> SelectNoParens -> Bool) -> Eq SelectNoParens
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SelectNoParens -> SelectNoParens -> Bool
== :: SelectNoParens -> SelectNoParens -> Bool
$c/= :: SelectNoParens -> SelectNoParens -> Bool
/= :: SelectNoParens -> SelectNoParens -> Bool
Eq, Eq SelectNoParens
Eq SelectNoParens =>
(SelectNoParens -> SelectNoParens -> Ordering)
-> (SelectNoParens -> SelectNoParens -> Bool)
-> (SelectNoParens -> SelectNoParens -> Bool)
-> (SelectNoParens -> SelectNoParens -> Bool)
-> (SelectNoParens -> SelectNoParens -> Bool)
-> (SelectNoParens -> SelectNoParens -> SelectNoParens)
-> (SelectNoParens -> SelectNoParens -> SelectNoParens)
-> Ord SelectNoParens
SelectNoParens -> SelectNoParens -> Bool
SelectNoParens -> SelectNoParens -> Ordering
SelectNoParens -> SelectNoParens -> SelectNoParens
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
$ccompare :: SelectNoParens -> SelectNoParens -> Ordering
compare :: SelectNoParens -> SelectNoParens -> Ordering
$c< :: SelectNoParens -> SelectNoParens -> Bool
< :: SelectNoParens -> SelectNoParens -> Bool
$c<= :: SelectNoParens -> SelectNoParens -> Bool
<= :: SelectNoParens -> SelectNoParens -> Bool
$c> :: SelectNoParens -> SelectNoParens -> Bool
> :: SelectNoParens -> SelectNoParens -> Bool
$c>= :: SelectNoParens -> SelectNoParens -> Bool
>= :: SelectNoParens -> SelectNoParens -> Bool
$cmax :: SelectNoParens -> SelectNoParens -> SelectNoParens
max :: SelectNoParens -> SelectNoParens -> SelectNoParens
$cmin :: SelectNoParens -> SelectNoParens -> SelectNoParens
min :: SelectNoParens -> SelectNoParens -> SelectNoParens
Ord)

-- |
-- @
-- select_clause:
--   |  simple_select
--   |  select_with_parens
-- @
type SelectClause = Either SimpleSelect SelectWithParens

-- |
-- ==== References
-- @
-- simple_select:
--   |  SELECT opt_all_clause opt_target_list
--       into_clause from_clause where_clause
--       group_clause having_clause window_clause
--   |  SELECT distinct_clause target_list
--       into_clause from_clause where_clause
--       group_clause having_clause window_clause
--   |  values_clause
--   |  TABLE relation_expr
--   |  select_clause UNION all_or_distinct select_clause
--   |  select_clause INTERSECT all_or_distinct select_clause
--   |  select_clause EXCEPT all_or_distinct select_clause
-- @
data SimpleSelect
  = NormalSimpleSelect (Maybe Targeting) (Maybe IntoClause) (Maybe FromClause) (Maybe WhereClause) (Maybe GroupClause) (Maybe HavingClause) (Maybe WindowClause)
  | ValuesSimpleSelect ValuesClause
  | TableSimpleSelect RelationExpr
  | BinSimpleSelect SelectBinOp SelectClause (Maybe Bool) SelectClause
  deriving (Int -> SimpleSelect -> ShowS
[SimpleSelect] -> ShowS
SimpleSelect -> String
(Int -> SimpleSelect -> ShowS)
-> (SimpleSelect -> String)
-> ([SimpleSelect] -> ShowS)
-> Show SimpleSelect
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SimpleSelect -> ShowS
showsPrec :: Int -> SimpleSelect -> ShowS
$cshow :: SimpleSelect -> String
show :: SimpleSelect -> String
$cshowList :: [SimpleSelect] -> ShowS
showList :: [SimpleSelect] -> ShowS
Show, (forall x. SimpleSelect -> Rep SimpleSelect x)
-> (forall x. Rep SimpleSelect x -> SimpleSelect)
-> Generic SimpleSelect
forall x. Rep SimpleSelect x -> SimpleSelect
forall x. SimpleSelect -> Rep SimpleSelect x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. SimpleSelect -> Rep SimpleSelect x
from :: forall x. SimpleSelect -> Rep SimpleSelect x
$cto :: forall x. Rep SimpleSelect x -> SimpleSelect
to :: forall x. Rep SimpleSelect x -> SimpleSelect
Generic, SimpleSelect -> SimpleSelect -> Bool
(SimpleSelect -> SimpleSelect -> Bool)
-> (SimpleSelect -> SimpleSelect -> Bool) -> Eq SimpleSelect
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SimpleSelect -> SimpleSelect -> Bool
== :: SimpleSelect -> SimpleSelect -> Bool
$c/= :: SimpleSelect -> SimpleSelect -> Bool
/= :: SimpleSelect -> SimpleSelect -> Bool
Eq, Eq SimpleSelect
Eq SimpleSelect =>
(SimpleSelect -> SimpleSelect -> Ordering)
-> (SimpleSelect -> SimpleSelect -> Bool)
-> (SimpleSelect -> SimpleSelect -> Bool)
-> (SimpleSelect -> SimpleSelect -> Bool)
-> (SimpleSelect -> SimpleSelect -> Bool)
-> (SimpleSelect -> SimpleSelect -> SimpleSelect)
-> (SimpleSelect -> SimpleSelect -> SimpleSelect)
-> Ord SimpleSelect
SimpleSelect -> SimpleSelect -> Bool
SimpleSelect -> SimpleSelect -> Ordering
SimpleSelect -> SimpleSelect -> SimpleSelect
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
$ccompare :: SimpleSelect -> SimpleSelect -> Ordering
compare :: SimpleSelect -> SimpleSelect -> Ordering
$c< :: SimpleSelect -> SimpleSelect -> Bool
< :: SimpleSelect -> SimpleSelect -> Bool
$c<= :: SimpleSelect -> SimpleSelect -> Bool
<= :: SimpleSelect -> SimpleSelect -> Bool
$c> :: SimpleSelect -> SimpleSelect -> Bool
> :: SimpleSelect -> SimpleSelect -> Bool
$c>= :: SimpleSelect -> SimpleSelect -> Bool
>= :: SimpleSelect -> SimpleSelect -> Bool
$cmax :: SimpleSelect -> SimpleSelect -> SimpleSelect
max :: SimpleSelect -> SimpleSelect -> SimpleSelect
$cmin :: SimpleSelect -> SimpleSelect -> SimpleSelect
min :: SimpleSelect -> SimpleSelect -> SimpleSelect
Ord)

-- |
-- Covers these parts of spec:
--
-- ==== References
-- @
-- simple_select:
--   |  SELECT opt_all_clause opt_target_list
--       into_clause from_clause where_clause
--       group_clause having_clause window_clause
--   |  SELECT distinct_clause target_list
--       into_clause from_clause where_clause
--       group_clause having_clause window_clause
--
-- distinct_clause:
--   |  DISTINCT
--   |  DISTINCT ON '(' expr_list ')'
-- @
data Targeting
  = NormalTargeting TargetList
  | AllTargeting (Maybe TargetList)
  | DistinctTargeting (Maybe ExprList) TargetList
  deriving (Int -> Targeting -> ShowS
[Targeting] -> ShowS
Targeting -> String
(Int -> Targeting -> ShowS)
-> (Targeting -> String)
-> ([Targeting] -> ShowS)
-> Show Targeting
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Targeting -> ShowS
showsPrec :: Int -> Targeting -> ShowS
$cshow :: Targeting -> String
show :: Targeting -> String
$cshowList :: [Targeting] -> ShowS
showList :: [Targeting] -> ShowS
Show, (forall x. Targeting -> Rep Targeting x)
-> (forall x. Rep Targeting x -> Targeting) -> Generic Targeting
forall x. Rep Targeting x -> Targeting
forall x. Targeting -> Rep Targeting x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Targeting -> Rep Targeting x
from :: forall x. Targeting -> Rep Targeting x
$cto :: forall x. Rep Targeting x -> Targeting
to :: forall x. Rep Targeting x -> Targeting
Generic, Targeting -> Targeting -> Bool
(Targeting -> Targeting -> Bool)
-> (Targeting -> Targeting -> Bool) -> Eq Targeting
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Targeting -> Targeting -> Bool
== :: Targeting -> Targeting -> Bool
$c/= :: Targeting -> Targeting -> Bool
/= :: Targeting -> Targeting -> Bool
Eq, Eq Targeting
Eq Targeting =>
(Targeting -> Targeting -> Ordering)
-> (Targeting -> Targeting -> Bool)
-> (Targeting -> Targeting -> Bool)
-> (Targeting -> Targeting -> Bool)
-> (Targeting -> Targeting -> Bool)
-> (Targeting -> Targeting -> Targeting)
-> (Targeting -> Targeting -> Targeting)
-> Ord Targeting
Targeting -> Targeting -> Bool
Targeting -> Targeting -> Ordering
Targeting -> Targeting -> Targeting
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
$ccompare :: Targeting -> Targeting -> Ordering
compare :: Targeting -> Targeting -> Ordering
$c< :: Targeting -> Targeting -> Bool
< :: Targeting -> Targeting -> Bool
$c<= :: Targeting -> Targeting -> Bool
<= :: Targeting -> Targeting -> Bool
$c> :: Targeting -> Targeting -> Bool
> :: Targeting -> Targeting -> Bool
$c>= :: Targeting -> Targeting -> Bool
>= :: Targeting -> Targeting -> Bool
$cmax :: Targeting -> Targeting -> Targeting
max :: Targeting -> Targeting -> Targeting
$cmin :: Targeting -> Targeting -> Targeting
min :: Targeting -> Targeting -> Targeting
Ord)

-- |
-- ==== References
-- @
-- target_list:
--   | target_el
--   | target_list ',' target_el
-- @
type TargetList = NonEmpty TargetEl

-- |
-- ==== References
-- @
-- target_el:
--   |  a_expr AS ColLabel
--   |  a_expr IDENT
--   |  a_expr
--   |  '*'
-- @
data TargetEl
  = AliasedExprTargetEl AExpr Ident
  | ImplicitlyAliasedExprTargetEl AExpr Ident
  | ExprTargetEl AExpr
  | AsteriskTargetEl
  deriving (Int -> TargetEl -> ShowS
[TargetEl] -> ShowS
TargetEl -> String
(Int -> TargetEl -> ShowS)
-> (TargetEl -> String) -> ([TargetEl] -> ShowS) -> Show TargetEl
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TargetEl -> ShowS
showsPrec :: Int -> TargetEl -> ShowS
$cshow :: TargetEl -> String
show :: TargetEl -> String
$cshowList :: [TargetEl] -> ShowS
showList :: [TargetEl] -> ShowS
Show, (forall x. TargetEl -> Rep TargetEl x)
-> (forall x. Rep TargetEl x -> TargetEl) -> Generic TargetEl
forall x. Rep TargetEl x -> TargetEl
forall x. TargetEl -> Rep TargetEl x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. TargetEl -> Rep TargetEl x
from :: forall x. TargetEl -> Rep TargetEl x
$cto :: forall x. Rep TargetEl x -> TargetEl
to :: forall x. Rep TargetEl x -> TargetEl
Generic, TargetEl -> TargetEl -> Bool
(TargetEl -> TargetEl -> Bool)
-> (TargetEl -> TargetEl -> Bool) -> Eq TargetEl
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TargetEl -> TargetEl -> Bool
== :: TargetEl -> TargetEl -> Bool
$c/= :: TargetEl -> TargetEl -> Bool
/= :: TargetEl -> TargetEl -> Bool
Eq, Eq TargetEl
Eq TargetEl =>
(TargetEl -> TargetEl -> Ordering)
-> (TargetEl -> TargetEl -> Bool)
-> (TargetEl -> TargetEl -> Bool)
-> (TargetEl -> TargetEl -> Bool)
-> (TargetEl -> TargetEl -> Bool)
-> (TargetEl -> TargetEl -> TargetEl)
-> (TargetEl -> TargetEl -> TargetEl)
-> Ord TargetEl
TargetEl -> TargetEl -> Bool
TargetEl -> TargetEl -> Ordering
TargetEl -> TargetEl -> TargetEl
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
$ccompare :: TargetEl -> TargetEl -> Ordering
compare :: TargetEl -> TargetEl -> Ordering
$c< :: TargetEl -> TargetEl -> Bool
< :: TargetEl -> TargetEl -> Bool
$c<= :: TargetEl -> TargetEl -> Bool
<= :: TargetEl -> TargetEl -> Bool
$c> :: TargetEl -> TargetEl -> Bool
> :: TargetEl -> TargetEl -> Bool
$c>= :: TargetEl -> TargetEl -> Bool
>= :: TargetEl -> TargetEl -> Bool
$cmax :: TargetEl -> TargetEl -> TargetEl
max :: TargetEl -> TargetEl -> TargetEl
$cmin :: TargetEl -> TargetEl -> TargetEl
min :: TargetEl -> TargetEl -> TargetEl
Ord)

-- |
-- ==== References
-- @
--   |  select_clause UNION all_or_distinct select_clause
--   |  select_clause INTERSECT all_or_distinct select_clause
--   |  select_clause EXCEPT all_or_distinct select_clause
-- @
data SelectBinOp = UnionSelectBinOp | IntersectSelectBinOp | ExceptSelectBinOp
  deriving (Int -> SelectBinOp -> ShowS
[SelectBinOp] -> ShowS
SelectBinOp -> String
(Int -> SelectBinOp -> ShowS)
-> (SelectBinOp -> String)
-> ([SelectBinOp] -> ShowS)
-> Show SelectBinOp
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SelectBinOp -> ShowS
showsPrec :: Int -> SelectBinOp -> ShowS
$cshow :: SelectBinOp -> String
show :: SelectBinOp -> String
$cshowList :: [SelectBinOp] -> ShowS
showList :: [SelectBinOp] -> ShowS
Show, (forall x. SelectBinOp -> Rep SelectBinOp x)
-> (forall x. Rep SelectBinOp x -> SelectBinOp)
-> Generic SelectBinOp
forall x. Rep SelectBinOp x -> SelectBinOp
forall x. SelectBinOp -> Rep SelectBinOp x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. SelectBinOp -> Rep SelectBinOp x
from :: forall x. SelectBinOp -> Rep SelectBinOp x
$cto :: forall x. Rep SelectBinOp x -> SelectBinOp
to :: forall x. Rep SelectBinOp x -> SelectBinOp
Generic, SelectBinOp -> SelectBinOp -> Bool
(SelectBinOp -> SelectBinOp -> Bool)
-> (SelectBinOp -> SelectBinOp -> Bool) -> Eq SelectBinOp
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SelectBinOp -> SelectBinOp -> Bool
== :: SelectBinOp -> SelectBinOp -> Bool
$c/= :: SelectBinOp -> SelectBinOp -> Bool
/= :: SelectBinOp -> SelectBinOp -> Bool
Eq, Eq SelectBinOp
Eq SelectBinOp =>
(SelectBinOp -> SelectBinOp -> Ordering)
-> (SelectBinOp -> SelectBinOp -> Bool)
-> (SelectBinOp -> SelectBinOp -> Bool)
-> (SelectBinOp -> SelectBinOp -> Bool)
-> (SelectBinOp -> SelectBinOp -> Bool)
-> (SelectBinOp -> SelectBinOp -> SelectBinOp)
-> (SelectBinOp -> SelectBinOp -> SelectBinOp)
-> Ord SelectBinOp
SelectBinOp -> SelectBinOp -> Bool
SelectBinOp -> SelectBinOp -> Ordering
SelectBinOp -> SelectBinOp -> SelectBinOp
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
$ccompare :: SelectBinOp -> SelectBinOp -> Ordering
compare :: SelectBinOp -> SelectBinOp -> Ordering
$c< :: SelectBinOp -> SelectBinOp -> Bool
< :: SelectBinOp -> SelectBinOp -> Bool
$c<= :: SelectBinOp -> SelectBinOp -> Bool
<= :: SelectBinOp -> SelectBinOp -> Bool
$c> :: SelectBinOp -> SelectBinOp -> Bool
> :: SelectBinOp -> SelectBinOp -> Bool
$c>= :: SelectBinOp -> SelectBinOp -> Bool
>= :: SelectBinOp -> SelectBinOp -> Bool
$cmax :: SelectBinOp -> SelectBinOp -> SelectBinOp
max :: SelectBinOp -> SelectBinOp -> SelectBinOp
$cmin :: SelectBinOp -> SelectBinOp -> SelectBinOp
min :: SelectBinOp -> SelectBinOp -> SelectBinOp
Ord)

-- |
-- ==== References
-- @
-- with_clause:
--   |  WITH cte_list
--   |  WITH_LA cte_list
--   |  WITH RECURSIVE cte_list
-- @
data WithClause = WithClause Bool (NonEmpty CommonTableExpr)
  deriving (Int -> WithClause -> ShowS
[WithClause] -> ShowS
WithClause -> String
(Int -> WithClause -> ShowS)
-> (WithClause -> String)
-> ([WithClause] -> ShowS)
-> Show WithClause
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> WithClause -> ShowS
showsPrec :: Int -> WithClause -> ShowS
$cshow :: WithClause -> String
show :: WithClause -> String
$cshowList :: [WithClause] -> ShowS
showList :: [WithClause] -> ShowS
Show, (forall x. WithClause -> Rep WithClause x)
-> (forall x. Rep WithClause x -> WithClause) -> Generic WithClause
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
$cfrom :: forall x. WithClause -> Rep WithClause x
from :: forall x. WithClause -> Rep WithClause x
$cto :: forall x. Rep WithClause x -> WithClause
to :: forall x. Rep WithClause x -> WithClause
Generic, WithClause -> WithClause -> Bool
(WithClause -> WithClause -> Bool)
-> (WithClause -> WithClause -> Bool) -> Eq WithClause
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: WithClause -> WithClause -> Bool
== :: WithClause -> WithClause -> Bool
$c/= :: WithClause -> WithClause -> Bool
/= :: WithClause -> WithClause -> Bool
Eq, Eq WithClause
Eq WithClause =>
(WithClause -> WithClause -> Ordering)
-> (WithClause -> WithClause -> Bool)
-> (WithClause -> WithClause -> Bool)
-> (WithClause -> WithClause -> Bool)
-> (WithClause -> WithClause -> Bool)
-> (WithClause -> WithClause -> WithClause)
-> (WithClause -> WithClause -> WithClause)
-> Ord WithClause
WithClause -> WithClause -> Bool
WithClause -> WithClause -> Ordering
WithClause -> WithClause -> WithClause
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
$ccompare :: WithClause -> WithClause -> Ordering
compare :: WithClause -> WithClause -> Ordering
$c< :: WithClause -> WithClause -> Bool
< :: WithClause -> WithClause -> Bool
$c<= :: WithClause -> WithClause -> Bool
<= :: WithClause -> WithClause -> Bool
$c> :: WithClause -> WithClause -> Bool
> :: WithClause -> WithClause -> Bool
$c>= :: WithClause -> WithClause -> Bool
>= :: WithClause -> WithClause -> Bool
$cmax :: WithClause -> WithClause -> WithClause
max :: WithClause -> WithClause -> WithClause
$cmin :: WithClause -> WithClause -> WithClause
min :: WithClause -> WithClause -> WithClause
Ord)

-- |
-- ==== References
-- @
-- common_table_expr:
--   |  name opt_name_list AS opt_materialized '(' PreparableStmt ')'
-- opt_materialized:
--   | MATERIALIZED
--   | NOT MATERIALIZED
--   | EMPTY
-- @
data CommonTableExpr = CommonTableExpr Ident (Maybe (NonEmpty Ident)) (Maybe Bool) PreparableStmt
  deriving (Int -> CommonTableExpr -> ShowS
[CommonTableExpr] -> ShowS
CommonTableExpr -> String
(Int -> CommonTableExpr -> ShowS)
-> (CommonTableExpr -> String)
-> ([CommonTableExpr] -> ShowS)
-> Show CommonTableExpr
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CommonTableExpr -> ShowS
showsPrec :: Int -> CommonTableExpr -> ShowS
$cshow :: CommonTableExpr -> String
show :: CommonTableExpr -> String
$cshowList :: [CommonTableExpr] -> ShowS
showList :: [CommonTableExpr] -> ShowS
Show, (forall x. CommonTableExpr -> Rep CommonTableExpr x)
-> (forall x. Rep CommonTableExpr x -> CommonTableExpr)
-> Generic CommonTableExpr
forall x. Rep CommonTableExpr x -> CommonTableExpr
forall x. CommonTableExpr -> Rep CommonTableExpr x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. CommonTableExpr -> Rep CommonTableExpr x
from :: forall x. CommonTableExpr -> Rep CommonTableExpr x
$cto :: forall x. Rep CommonTableExpr x -> CommonTableExpr
to :: forall x. Rep CommonTableExpr x -> CommonTableExpr
Generic, CommonTableExpr -> CommonTableExpr -> Bool
(CommonTableExpr -> CommonTableExpr -> Bool)
-> (CommonTableExpr -> CommonTableExpr -> Bool)
-> Eq CommonTableExpr
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CommonTableExpr -> CommonTableExpr -> Bool
== :: CommonTableExpr -> CommonTableExpr -> Bool
$c/= :: CommonTableExpr -> CommonTableExpr -> Bool
/= :: CommonTableExpr -> CommonTableExpr -> Bool
Eq, Eq CommonTableExpr
Eq CommonTableExpr =>
(CommonTableExpr -> CommonTableExpr -> Ordering)
-> (CommonTableExpr -> CommonTableExpr -> Bool)
-> (CommonTableExpr -> CommonTableExpr -> Bool)
-> (CommonTableExpr -> CommonTableExpr -> Bool)
-> (CommonTableExpr -> CommonTableExpr -> Bool)
-> (CommonTableExpr -> CommonTableExpr -> CommonTableExpr)
-> (CommonTableExpr -> CommonTableExpr -> CommonTableExpr)
-> Ord CommonTableExpr
CommonTableExpr -> CommonTableExpr -> Bool
CommonTableExpr -> CommonTableExpr -> Ordering
CommonTableExpr -> CommonTableExpr -> CommonTableExpr
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
$ccompare :: CommonTableExpr -> CommonTableExpr -> Ordering
compare :: CommonTableExpr -> CommonTableExpr -> Ordering
$c< :: CommonTableExpr -> CommonTableExpr -> Bool
< :: CommonTableExpr -> CommonTableExpr -> Bool
$c<= :: CommonTableExpr -> CommonTableExpr -> Bool
<= :: CommonTableExpr -> CommonTableExpr -> Bool
$c> :: CommonTableExpr -> CommonTableExpr -> Bool
> :: CommonTableExpr -> CommonTableExpr -> Bool
$c>= :: CommonTableExpr -> CommonTableExpr -> Bool
>= :: CommonTableExpr -> CommonTableExpr -> Bool
$cmax :: CommonTableExpr -> CommonTableExpr -> CommonTableExpr
max :: CommonTableExpr -> CommonTableExpr -> CommonTableExpr
$cmin :: CommonTableExpr -> CommonTableExpr -> CommonTableExpr
min :: CommonTableExpr -> CommonTableExpr -> CommonTableExpr
Ord)

type IntoClause = OptTempTableName

-- |
-- ==== References
-- @
-- OptTempTableName:
--   |  TEMPORARY opt_table qualified_name
--   |  TEMP opt_table qualified_name
--   |  LOCAL TEMPORARY opt_table qualified_name
--   |  LOCAL TEMP opt_table qualified_name
--   |  GLOBAL TEMPORARY opt_table qualified_name
--   |  GLOBAL TEMP opt_table qualified_name
--   |  UNLOGGED opt_table qualified_name
--   |  TABLE qualified_name
--   |  qualified_name
-- @
data OptTempTableName
  = TemporaryOptTempTableName Bool QualifiedName
  | TempOptTempTableName Bool QualifiedName
  | LocalTemporaryOptTempTableName Bool QualifiedName
  | LocalTempOptTempTableName Bool QualifiedName
  | GlobalTemporaryOptTempTableName Bool QualifiedName
  | GlobalTempOptTempTableName Bool QualifiedName
  | UnloggedOptTempTableName Bool QualifiedName
  | TableOptTempTableName QualifiedName
  | QualifedOptTempTableName QualifiedName
  deriving (Int -> IntoClause -> ShowS
[IntoClause] -> ShowS
IntoClause -> String
(Int -> IntoClause -> ShowS)
-> (IntoClause -> String)
-> ([IntoClause] -> ShowS)
-> Show IntoClause
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> IntoClause -> ShowS
showsPrec :: Int -> IntoClause -> ShowS
$cshow :: IntoClause -> String
show :: IntoClause -> String
$cshowList :: [IntoClause] -> ShowS
showList :: [IntoClause] -> ShowS
Show, (forall x. IntoClause -> Rep IntoClause x)
-> (forall x. Rep IntoClause x -> IntoClause) -> Generic IntoClause
forall x. Rep IntoClause x -> IntoClause
forall x. IntoClause -> Rep IntoClause x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. IntoClause -> Rep IntoClause x
from :: forall x. IntoClause -> Rep IntoClause x
$cto :: forall x. Rep IntoClause x -> IntoClause
to :: forall x. Rep IntoClause x -> IntoClause
Generic, IntoClause -> IntoClause -> Bool
(IntoClause -> IntoClause -> Bool)
-> (IntoClause -> IntoClause -> Bool) -> Eq IntoClause
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: IntoClause -> IntoClause -> Bool
== :: IntoClause -> IntoClause -> Bool
$c/= :: IntoClause -> IntoClause -> Bool
/= :: IntoClause -> IntoClause -> Bool
Eq, Eq IntoClause
Eq IntoClause =>
(IntoClause -> IntoClause -> Ordering)
-> (IntoClause -> IntoClause -> Bool)
-> (IntoClause -> IntoClause -> Bool)
-> (IntoClause -> IntoClause -> Bool)
-> (IntoClause -> IntoClause -> Bool)
-> (IntoClause -> IntoClause -> IntoClause)
-> (IntoClause -> IntoClause -> IntoClause)
-> Ord IntoClause
IntoClause -> IntoClause -> Bool
IntoClause -> IntoClause -> Ordering
IntoClause -> IntoClause -> IntoClause
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
$ccompare :: IntoClause -> IntoClause -> Ordering
compare :: IntoClause -> IntoClause -> Ordering
$c< :: IntoClause -> IntoClause -> Bool
< :: IntoClause -> IntoClause -> Bool
$c<= :: IntoClause -> IntoClause -> Bool
<= :: IntoClause -> IntoClause -> Bool
$c> :: IntoClause -> IntoClause -> Bool
> :: IntoClause -> IntoClause -> Bool
$c>= :: IntoClause -> IntoClause -> Bool
>= :: IntoClause -> IntoClause -> Bool
$cmax :: IntoClause -> IntoClause -> IntoClause
max :: IntoClause -> IntoClause -> IntoClause
$cmin :: IntoClause -> IntoClause -> IntoClause
min :: IntoClause -> IntoClause -> IntoClause
Ord)

type FromClause = NonEmpty TableRef

type GroupClause = NonEmpty GroupByItem

-- |
-- ==== References
-- @
-- group_by_item:
--   |  a_expr
--   |  empty_grouping_set
--   |  cube_clause
--   |  rollup_clause
--   |  grouping_sets_clause
-- empty_grouping_set:
--   |  '(' ')'
-- rollup_clause:
--   |  ROLLUP '(' expr_list ')'
-- cube_clause:
--   |  CUBE '(' expr_list ')'
-- grouping_sets_clause:
--   |  GROUPING SETS '(' group_by_list ')'
-- @
data GroupByItem
  = ExprGroupByItem AExpr
  | EmptyGroupingSetGroupByItem
  | RollupGroupByItem ExprList
  | CubeGroupByItem ExprList
  | GroupingSetsGroupByItem (NonEmpty GroupByItem)
  deriving (Int -> GroupByItem -> ShowS
[GroupByItem] -> ShowS
GroupByItem -> String
(Int -> GroupByItem -> ShowS)
-> (GroupByItem -> String)
-> ([GroupByItem] -> ShowS)
-> Show GroupByItem
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> GroupByItem -> ShowS
showsPrec :: Int -> GroupByItem -> ShowS
$cshow :: GroupByItem -> String
show :: GroupByItem -> String
$cshowList :: [GroupByItem] -> ShowS
showList :: [GroupByItem] -> ShowS
Show, (forall x. GroupByItem -> Rep GroupByItem x)
-> (forall x. Rep GroupByItem x -> GroupByItem)
-> Generic GroupByItem
forall x. Rep GroupByItem x -> GroupByItem
forall x. GroupByItem -> Rep GroupByItem x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. GroupByItem -> Rep GroupByItem x
from :: forall x. GroupByItem -> Rep GroupByItem x
$cto :: forall x. Rep GroupByItem x -> GroupByItem
to :: forall x. Rep GroupByItem x -> GroupByItem
Generic, GroupByItem -> GroupByItem -> Bool
(GroupByItem -> GroupByItem -> Bool)
-> (GroupByItem -> GroupByItem -> Bool) -> Eq GroupByItem
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: GroupByItem -> GroupByItem -> Bool
== :: GroupByItem -> GroupByItem -> Bool
$c/= :: GroupByItem -> GroupByItem -> Bool
/= :: GroupByItem -> GroupByItem -> Bool
Eq, Eq GroupByItem
Eq GroupByItem =>
(GroupByItem -> GroupByItem -> Ordering)
-> (GroupByItem -> GroupByItem -> Bool)
-> (GroupByItem -> GroupByItem -> Bool)
-> (GroupByItem -> GroupByItem -> Bool)
-> (GroupByItem -> GroupByItem -> Bool)
-> (GroupByItem -> GroupByItem -> GroupByItem)
-> (GroupByItem -> GroupByItem -> GroupByItem)
-> Ord GroupByItem
GroupByItem -> GroupByItem -> Bool
GroupByItem -> GroupByItem -> Ordering
GroupByItem -> GroupByItem -> GroupByItem
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
$ccompare :: GroupByItem -> GroupByItem -> Ordering
compare :: GroupByItem -> GroupByItem -> Ordering
$c< :: GroupByItem -> GroupByItem -> Bool
< :: GroupByItem -> GroupByItem -> Bool
$c<= :: GroupByItem -> GroupByItem -> Bool
<= :: GroupByItem -> GroupByItem -> Bool
$c> :: GroupByItem -> GroupByItem -> Bool
> :: GroupByItem -> GroupByItem -> Bool
$c>= :: GroupByItem -> GroupByItem -> Bool
>= :: GroupByItem -> GroupByItem -> Bool
$cmax :: GroupByItem -> GroupByItem -> GroupByItem
max :: GroupByItem -> GroupByItem -> GroupByItem
$cmin :: GroupByItem -> GroupByItem -> GroupByItem
min :: GroupByItem -> GroupByItem -> GroupByItem
Ord)

-- |
-- @
-- having_clause:
--   |  HAVING a_expr
--   |  EMPTY
-- @
type HavingClause = AExpr

-- |
-- @
-- window_clause:
--   |  WINDOW window_definition_list
--   |  EMPTY
--
-- window_definition_list:
--   |  window_definition
--   |  window_definition_list ',' window_definition
-- @
type WindowClause = NonEmpty WindowDefinition

-- |
-- @
-- window_definition:
--   |  ColId AS window_specification
-- @
data WindowDefinition = WindowDefinition Ident WindowSpecification
  deriving (Int -> WindowDefinition -> ShowS
[WindowDefinition] -> ShowS
WindowDefinition -> String
(Int -> WindowDefinition -> ShowS)
-> (WindowDefinition -> String)
-> ([WindowDefinition] -> ShowS)
-> Show WindowDefinition
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> WindowDefinition -> ShowS
showsPrec :: Int -> WindowDefinition -> ShowS
$cshow :: WindowDefinition -> String
show :: WindowDefinition -> String
$cshowList :: [WindowDefinition] -> ShowS
showList :: [WindowDefinition] -> ShowS
Show, (forall x. WindowDefinition -> Rep WindowDefinition x)
-> (forall x. Rep WindowDefinition x -> WindowDefinition)
-> Generic WindowDefinition
forall x. Rep WindowDefinition x -> WindowDefinition
forall x. WindowDefinition -> Rep WindowDefinition x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. WindowDefinition -> Rep WindowDefinition x
from :: forall x. WindowDefinition -> Rep WindowDefinition x
$cto :: forall x. Rep WindowDefinition x -> WindowDefinition
to :: forall x. Rep WindowDefinition x -> WindowDefinition
Generic, WindowDefinition -> WindowDefinition -> Bool
(WindowDefinition -> WindowDefinition -> Bool)
-> (WindowDefinition -> WindowDefinition -> Bool)
-> Eq WindowDefinition
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: WindowDefinition -> WindowDefinition -> Bool
== :: WindowDefinition -> WindowDefinition -> Bool
$c/= :: WindowDefinition -> WindowDefinition -> Bool
/= :: WindowDefinition -> WindowDefinition -> Bool
Eq, Eq WindowDefinition
Eq WindowDefinition =>
(WindowDefinition -> WindowDefinition -> Ordering)
-> (WindowDefinition -> WindowDefinition -> Bool)
-> (WindowDefinition -> WindowDefinition -> Bool)
-> (WindowDefinition -> WindowDefinition -> Bool)
-> (WindowDefinition -> WindowDefinition -> Bool)
-> (WindowDefinition -> WindowDefinition -> WindowDefinition)
-> (WindowDefinition -> WindowDefinition -> WindowDefinition)
-> Ord WindowDefinition
WindowDefinition -> WindowDefinition -> Bool
WindowDefinition -> WindowDefinition -> Ordering
WindowDefinition -> WindowDefinition -> WindowDefinition
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
$ccompare :: WindowDefinition -> WindowDefinition -> Ordering
compare :: WindowDefinition -> WindowDefinition -> Ordering
$c< :: WindowDefinition -> WindowDefinition -> Bool
< :: WindowDefinition -> WindowDefinition -> Bool
$c<= :: WindowDefinition -> WindowDefinition -> Bool
<= :: WindowDefinition -> WindowDefinition -> Bool
$c> :: WindowDefinition -> WindowDefinition -> Bool
> :: WindowDefinition -> WindowDefinition -> Bool
$c>= :: WindowDefinition -> WindowDefinition -> Bool
>= :: WindowDefinition -> WindowDefinition -> Bool
$cmax :: WindowDefinition -> WindowDefinition -> WindowDefinition
max :: WindowDefinition -> WindowDefinition -> WindowDefinition
$cmin :: WindowDefinition -> WindowDefinition -> WindowDefinition
min :: WindowDefinition -> WindowDefinition -> WindowDefinition
Ord)

-- |
-- @
-- window_specification:
--   |  '(' opt_existing_window_name opt_partition_clause
--             opt_sort_clause opt_frame_clause ')'
--
-- opt_existing_window_name:
--   |  ColId
--   |  EMPTY
--
-- opt_partition_clause:
--   |  PARTITION BY expr_list
--   |  EMPTY
-- @
data WindowSpecification = WindowSpecification (Maybe ExistingWindowName) (Maybe PartitionClause) (Maybe SortClause) (Maybe FrameClause)
  deriving (Int -> WindowSpecification -> ShowS
[WindowSpecification] -> ShowS
WindowSpecification -> String
(Int -> WindowSpecification -> ShowS)
-> (WindowSpecification -> String)
-> ([WindowSpecification] -> ShowS)
-> Show WindowSpecification
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> WindowSpecification -> ShowS
showsPrec :: Int -> WindowSpecification -> ShowS
$cshow :: WindowSpecification -> String
show :: WindowSpecification -> String
$cshowList :: [WindowSpecification] -> ShowS
showList :: [WindowSpecification] -> ShowS
Show, (forall x. WindowSpecification -> Rep WindowSpecification x)
-> (forall x. Rep WindowSpecification x -> WindowSpecification)
-> Generic WindowSpecification
forall x. Rep WindowSpecification x -> WindowSpecification
forall x. WindowSpecification -> Rep WindowSpecification x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. WindowSpecification -> Rep WindowSpecification x
from :: forall x. WindowSpecification -> Rep WindowSpecification x
$cto :: forall x. Rep WindowSpecification x -> WindowSpecification
to :: forall x. Rep WindowSpecification x -> WindowSpecification
Generic, WindowSpecification -> WindowSpecification -> Bool
(WindowSpecification -> WindowSpecification -> Bool)
-> (WindowSpecification -> WindowSpecification -> Bool)
-> Eq WindowSpecification
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: WindowSpecification -> WindowSpecification -> Bool
== :: WindowSpecification -> WindowSpecification -> Bool
$c/= :: WindowSpecification -> WindowSpecification -> Bool
/= :: WindowSpecification -> WindowSpecification -> Bool
Eq, Eq WindowSpecification
Eq WindowSpecification =>
(WindowSpecification -> WindowSpecification -> Ordering)
-> (WindowSpecification -> WindowSpecification -> Bool)
-> (WindowSpecification -> WindowSpecification -> Bool)
-> (WindowSpecification -> WindowSpecification -> Bool)
-> (WindowSpecification -> WindowSpecification -> Bool)
-> (WindowSpecification
    -> WindowSpecification -> WindowSpecification)
-> (WindowSpecification
    -> WindowSpecification -> WindowSpecification)
-> Ord WindowSpecification
WindowSpecification -> WindowSpecification -> Bool
WindowSpecification -> WindowSpecification -> Ordering
WindowSpecification -> WindowSpecification -> WindowSpecification
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
$ccompare :: WindowSpecification -> WindowSpecification -> Ordering
compare :: WindowSpecification -> WindowSpecification -> Ordering
$c< :: WindowSpecification -> WindowSpecification -> Bool
< :: WindowSpecification -> WindowSpecification -> Bool
$c<= :: WindowSpecification -> WindowSpecification -> Bool
<= :: WindowSpecification -> WindowSpecification -> Bool
$c> :: WindowSpecification -> WindowSpecification -> Bool
> :: WindowSpecification -> WindowSpecification -> Bool
$c>= :: WindowSpecification -> WindowSpecification -> Bool
>= :: WindowSpecification -> WindowSpecification -> Bool
$cmax :: WindowSpecification -> WindowSpecification -> WindowSpecification
max :: WindowSpecification -> WindowSpecification -> WindowSpecification
$cmin :: WindowSpecification -> WindowSpecification -> WindowSpecification
min :: WindowSpecification -> WindowSpecification -> WindowSpecification
Ord)

type ExistingWindowName = ColId

type PartitionClause = ExprList

-- |
-- ==== References
-- @
-- opt_frame_clause:
--   |  RANGE frame_extent opt_window_exclusion_clause
--   |  ROWS frame_extent opt_window_exclusion_clause
--   |  GROUPS frame_extent opt_window_exclusion_clause
--   |  EMPTY
-- @
data FrameClause = FrameClause FrameClauseMode FrameExtent (Maybe WindowExclusionClause)
  deriving (Int -> FrameClause -> ShowS
[FrameClause] -> ShowS
FrameClause -> String
(Int -> FrameClause -> ShowS)
-> (FrameClause -> String)
-> ([FrameClause] -> ShowS)
-> Show FrameClause
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FrameClause -> ShowS
showsPrec :: Int -> FrameClause -> ShowS
$cshow :: FrameClause -> String
show :: FrameClause -> String
$cshowList :: [FrameClause] -> ShowS
showList :: [FrameClause] -> ShowS
Show, (forall x. FrameClause -> Rep FrameClause x)
-> (forall x. Rep FrameClause x -> FrameClause)
-> Generic FrameClause
forall x. Rep FrameClause x -> FrameClause
forall x. FrameClause -> Rep FrameClause x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. FrameClause -> Rep FrameClause x
from :: forall x. FrameClause -> Rep FrameClause x
$cto :: forall x. Rep FrameClause x -> FrameClause
to :: forall x. Rep FrameClause x -> FrameClause
Generic, FrameClause -> FrameClause -> Bool
(FrameClause -> FrameClause -> Bool)
-> (FrameClause -> FrameClause -> Bool) -> Eq FrameClause
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FrameClause -> FrameClause -> Bool
== :: FrameClause -> FrameClause -> Bool
$c/= :: FrameClause -> FrameClause -> Bool
/= :: FrameClause -> FrameClause -> Bool
Eq, Eq FrameClause
Eq FrameClause =>
(FrameClause -> FrameClause -> Ordering)
-> (FrameClause -> FrameClause -> Bool)
-> (FrameClause -> FrameClause -> Bool)
-> (FrameClause -> FrameClause -> Bool)
-> (FrameClause -> FrameClause -> Bool)
-> (FrameClause -> FrameClause -> FrameClause)
-> (FrameClause -> FrameClause -> FrameClause)
-> Ord FrameClause
FrameClause -> FrameClause -> Bool
FrameClause -> FrameClause -> Ordering
FrameClause -> FrameClause -> FrameClause
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
$ccompare :: FrameClause -> FrameClause -> Ordering
compare :: FrameClause -> FrameClause -> Ordering
$c< :: FrameClause -> FrameClause -> Bool
< :: FrameClause -> FrameClause -> Bool
$c<= :: FrameClause -> FrameClause -> Bool
<= :: FrameClause -> FrameClause -> Bool
$c> :: FrameClause -> FrameClause -> Bool
> :: FrameClause -> FrameClause -> Bool
$c>= :: FrameClause -> FrameClause -> Bool
>= :: FrameClause -> FrameClause -> Bool
$cmax :: FrameClause -> FrameClause -> FrameClause
max :: FrameClause -> FrameClause -> FrameClause
$cmin :: FrameClause -> FrameClause -> FrameClause
min :: FrameClause -> FrameClause -> FrameClause
Ord)

-- |
-- ==== References
-- @
-- opt_frame_clause:
--   |  RANGE frame_extent opt_window_exclusion_clause
--   |  ROWS frame_extent opt_window_exclusion_clause
--   |  GROUPS frame_extent opt_window_exclusion_clause
--   |  EMPTY
-- @
data FrameClauseMode = RangeFrameClauseMode | RowsFrameClauseMode | GroupsFrameClauseMode
  deriving (Int -> FrameClauseMode -> ShowS
[FrameClauseMode] -> ShowS
FrameClauseMode -> String
(Int -> FrameClauseMode -> ShowS)
-> (FrameClauseMode -> String)
-> ([FrameClauseMode] -> ShowS)
-> Show FrameClauseMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FrameClauseMode -> ShowS
showsPrec :: Int -> FrameClauseMode -> ShowS
$cshow :: FrameClauseMode -> String
show :: FrameClauseMode -> String
$cshowList :: [FrameClauseMode] -> ShowS
showList :: [FrameClauseMode] -> ShowS
Show, (forall x. FrameClauseMode -> Rep FrameClauseMode x)
-> (forall x. Rep FrameClauseMode x -> FrameClauseMode)
-> Generic FrameClauseMode
forall x. Rep FrameClauseMode x -> FrameClauseMode
forall x. FrameClauseMode -> Rep FrameClauseMode x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. FrameClauseMode -> Rep FrameClauseMode x
from :: forall x. FrameClauseMode -> Rep FrameClauseMode x
$cto :: forall x. Rep FrameClauseMode x -> FrameClauseMode
to :: forall x. Rep FrameClauseMode x -> FrameClauseMode
Generic, FrameClauseMode -> FrameClauseMode -> Bool
(FrameClauseMode -> FrameClauseMode -> Bool)
-> (FrameClauseMode -> FrameClauseMode -> Bool)
-> Eq FrameClauseMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FrameClauseMode -> FrameClauseMode -> Bool
== :: FrameClauseMode -> FrameClauseMode -> Bool
$c/= :: FrameClauseMode -> FrameClauseMode -> Bool
/= :: FrameClauseMode -> FrameClauseMode -> Bool
Eq, Eq FrameClauseMode
Eq FrameClauseMode =>
(FrameClauseMode -> FrameClauseMode -> Ordering)
-> (FrameClauseMode -> FrameClauseMode -> Bool)
-> (FrameClauseMode -> FrameClauseMode -> Bool)
-> (FrameClauseMode -> FrameClauseMode -> Bool)
-> (FrameClauseMode -> FrameClauseMode -> Bool)
-> (FrameClauseMode -> FrameClauseMode -> FrameClauseMode)
-> (FrameClauseMode -> FrameClauseMode -> FrameClauseMode)
-> Ord FrameClauseMode
FrameClauseMode -> FrameClauseMode -> Bool
FrameClauseMode -> FrameClauseMode -> Ordering
FrameClauseMode -> FrameClauseMode -> FrameClauseMode
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
$ccompare :: FrameClauseMode -> FrameClauseMode -> Ordering
compare :: FrameClauseMode -> FrameClauseMode -> Ordering
$c< :: FrameClauseMode -> FrameClauseMode -> Bool
< :: FrameClauseMode -> FrameClauseMode -> Bool
$c<= :: FrameClauseMode -> FrameClauseMode -> Bool
<= :: FrameClauseMode -> FrameClauseMode -> Bool
$c> :: FrameClauseMode -> FrameClauseMode -> Bool
> :: FrameClauseMode -> FrameClauseMode -> Bool
$c>= :: FrameClauseMode -> FrameClauseMode -> Bool
>= :: FrameClauseMode -> FrameClauseMode -> Bool
$cmax :: FrameClauseMode -> FrameClauseMode -> FrameClauseMode
max :: FrameClauseMode -> FrameClauseMode -> FrameClauseMode
$cmin :: FrameClauseMode -> FrameClauseMode -> FrameClauseMode
min :: FrameClauseMode -> FrameClauseMode -> FrameClauseMode
Ord)

-- |
-- ==== References
-- @
-- frame_extent:
--   |  frame_bound
--   |  BETWEEN frame_bound AND frame_bound
-- @
data FrameExtent = SingularFrameExtent FrameBound | BetweenFrameExtent FrameBound FrameBound
  deriving (Int -> FrameExtent -> ShowS
[FrameExtent] -> ShowS
FrameExtent -> String
(Int -> FrameExtent -> ShowS)
-> (FrameExtent -> String)
-> ([FrameExtent] -> ShowS)
-> Show FrameExtent
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FrameExtent -> ShowS
showsPrec :: Int -> FrameExtent -> ShowS
$cshow :: FrameExtent -> String
show :: FrameExtent -> String
$cshowList :: [FrameExtent] -> ShowS
showList :: [FrameExtent] -> ShowS
Show, (forall x. FrameExtent -> Rep FrameExtent x)
-> (forall x. Rep FrameExtent x -> FrameExtent)
-> Generic FrameExtent
forall x. Rep FrameExtent x -> FrameExtent
forall x. FrameExtent -> Rep FrameExtent x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. FrameExtent -> Rep FrameExtent x
from :: forall x. FrameExtent -> Rep FrameExtent x
$cto :: forall x. Rep FrameExtent x -> FrameExtent
to :: forall x. Rep FrameExtent x -> FrameExtent
Generic, FrameExtent -> FrameExtent -> Bool
(FrameExtent -> FrameExtent -> Bool)
-> (FrameExtent -> FrameExtent -> Bool) -> Eq FrameExtent
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FrameExtent -> FrameExtent -> Bool
== :: FrameExtent -> FrameExtent -> Bool
$c/= :: FrameExtent -> FrameExtent -> Bool
/= :: FrameExtent -> FrameExtent -> Bool
Eq, Eq FrameExtent
Eq FrameExtent =>
(FrameExtent -> FrameExtent -> Ordering)
-> (FrameExtent -> FrameExtent -> Bool)
-> (FrameExtent -> FrameExtent -> Bool)
-> (FrameExtent -> FrameExtent -> Bool)
-> (FrameExtent -> FrameExtent -> Bool)
-> (FrameExtent -> FrameExtent -> FrameExtent)
-> (FrameExtent -> FrameExtent -> FrameExtent)
-> Ord FrameExtent
FrameExtent -> FrameExtent -> Bool
FrameExtent -> FrameExtent -> Ordering
FrameExtent -> FrameExtent -> FrameExtent
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
$ccompare :: FrameExtent -> FrameExtent -> Ordering
compare :: FrameExtent -> FrameExtent -> Ordering
$c< :: FrameExtent -> FrameExtent -> Bool
< :: FrameExtent -> FrameExtent -> Bool
$c<= :: FrameExtent -> FrameExtent -> Bool
<= :: FrameExtent -> FrameExtent -> Bool
$c> :: FrameExtent -> FrameExtent -> Bool
> :: FrameExtent -> FrameExtent -> Bool
$c>= :: FrameExtent -> FrameExtent -> Bool
>= :: FrameExtent -> FrameExtent -> Bool
$cmax :: FrameExtent -> FrameExtent -> FrameExtent
max :: FrameExtent -> FrameExtent -> FrameExtent
$cmin :: FrameExtent -> FrameExtent -> FrameExtent
min :: FrameExtent -> FrameExtent -> FrameExtent
Ord)

-- |
-- ==== References
-- @
-- frame_bound:
--   |  UNBOUNDED PRECEDING
--   |  UNBOUNDED FOLLOWING
--   |  CURRENT_P ROW
--   |  a_expr PRECEDING
--   |  a_expr FOLLOWING
-- @
data FrameBound
  = UnboundedPrecedingFrameBound
  | UnboundedFollowingFrameBound
  | CurrentRowFrameBound
  | PrecedingFrameBound AExpr
  | FollowingFrameBound AExpr
  deriving (Int -> FrameBound -> ShowS
[FrameBound] -> ShowS
FrameBound -> String
(Int -> FrameBound -> ShowS)
-> (FrameBound -> String)
-> ([FrameBound] -> ShowS)
-> Show FrameBound
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FrameBound -> ShowS
showsPrec :: Int -> FrameBound -> ShowS
$cshow :: FrameBound -> String
show :: FrameBound -> String
$cshowList :: [FrameBound] -> ShowS
showList :: [FrameBound] -> ShowS
Show, (forall x. FrameBound -> Rep FrameBound x)
-> (forall x. Rep FrameBound x -> FrameBound) -> Generic FrameBound
forall x. Rep FrameBound x -> FrameBound
forall x. FrameBound -> Rep FrameBound x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. FrameBound -> Rep FrameBound x
from :: forall x. FrameBound -> Rep FrameBound x
$cto :: forall x. Rep FrameBound x -> FrameBound
to :: forall x. Rep FrameBound x -> FrameBound
Generic, FrameBound -> FrameBound -> Bool
(FrameBound -> FrameBound -> Bool)
-> (FrameBound -> FrameBound -> Bool) -> Eq FrameBound
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FrameBound -> FrameBound -> Bool
== :: FrameBound -> FrameBound -> Bool
$c/= :: FrameBound -> FrameBound -> Bool
/= :: FrameBound -> FrameBound -> Bool
Eq, Eq FrameBound
Eq FrameBound =>
(FrameBound -> FrameBound -> Ordering)
-> (FrameBound -> FrameBound -> Bool)
-> (FrameBound -> FrameBound -> Bool)
-> (FrameBound -> FrameBound -> Bool)
-> (FrameBound -> FrameBound -> Bool)
-> (FrameBound -> FrameBound -> FrameBound)
-> (FrameBound -> FrameBound -> FrameBound)
-> Ord FrameBound
FrameBound -> FrameBound -> Bool
FrameBound -> FrameBound -> Ordering
FrameBound -> FrameBound -> FrameBound
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
$ccompare :: FrameBound -> FrameBound -> Ordering
compare :: FrameBound -> FrameBound -> Ordering
$c< :: FrameBound -> FrameBound -> Bool
< :: FrameBound -> FrameBound -> Bool
$c<= :: FrameBound -> FrameBound -> Bool
<= :: FrameBound -> FrameBound -> Bool
$c> :: FrameBound -> FrameBound -> Bool
> :: FrameBound -> FrameBound -> Bool
$c>= :: FrameBound -> FrameBound -> Bool
>= :: FrameBound -> FrameBound -> Bool
$cmax :: FrameBound -> FrameBound -> FrameBound
max :: FrameBound -> FrameBound -> FrameBound
$cmin :: FrameBound -> FrameBound -> FrameBound
min :: FrameBound -> FrameBound -> FrameBound
Ord)

-- |
-- ==== References
-- @
-- opt_window_exclusion_clause:
--   |  EXCLUDE CURRENT_P ROW
--   |  EXCLUDE GROUP_P
--   |  EXCLUDE TIES
--   |  EXCLUDE NO OTHERS
--   |  EMPTY
-- @
data WindowExclusionClause
  = CurrentRowWindowExclusionClause
  | GroupWindowExclusionClause
  | TiesWindowExclusionClause
  | NoOthersWindowExclusionClause
  deriving (Int -> WindowExclusionClause -> ShowS
[WindowExclusionClause] -> ShowS
WindowExclusionClause -> String
(Int -> WindowExclusionClause -> ShowS)
-> (WindowExclusionClause -> String)
-> ([WindowExclusionClause] -> ShowS)
-> Show WindowExclusionClause
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> WindowExclusionClause -> ShowS
showsPrec :: Int -> WindowExclusionClause -> ShowS
$cshow :: WindowExclusionClause -> String
show :: WindowExclusionClause -> String
$cshowList :: [WindowExclusionClause] -> ShowS
showList :: [WindowExclusionClause] -> ShowS
Show, (forall x. WindowExclusionClause -> Rep WindowExclusionClause x)
-> (forall x. Rep WindowExclusionClause x -> WindowExclusionClause)
-> Generic WindowExclusionClause
forall x. Rep WindowExclusionClause x -> WindowExclusionClause
forall x. WindowExclusionClause -> Rep WindowExclusionClause x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. WindowExclusionClause -> Rep WindowExclusionClause x
from :: forall x. WindowExclusionClause -> Rep WindowExclusionClause x
$cto :: forall x. Rep WindowExclusionClause x -> WindowExclusionClause
to :: forall x. Rep WindowExclusionClause x -> WindowExclusionClause
Generic, WindowExclusionClause -> WindowExclusionClause -> Bool
(WindowExclusionClause -> WindowExclusionClause -> Bool)
-> (WindowExclusionClause -> WindowExclusionClause -> Bool)
-> Eq WindowExclusionClause
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: WindowExclusionClause -> WindowExclusionClause -> Bool
== :: WindowExclusionClause -> WindowExclusionClause -> Bool
$c/= :: WindowExclusionClause -> WindowExclusionClause -> Bool
/= :: WindowExclusionClause -> WindowExclusionClause -> Bool
Eq, Eq WindowExclusionClause
Eq WindowExclusionClause =>
(WindowExclusionClause -> WindowExclusionClause -> Ordering)
-> (WindowExclusionClause -> WindowExclusionClause -> Bool)
-> (WindowExclusionClause -> WindowExclusionClause -> Bool)
-> (WindowExclusionClause -> WindowExclusionClause -> Bool)
-> (WindowExclusionClause -> WindowExclusionClause -> Bool)
-> (WindowExclusionClause
    -> WindowExclusionClause -> WindowExclusionClause)
-> (WindowExclusionClause
    -> WindowExclusionClause -> WindowExclusionClause)
-> Ord WindowExclusionClause
WindowExclusionClause -> WindowExclusionClause -> Bool
WindowExclusionClause -> WindowExclusionClause -> Ordering
WindowExclusionClause
-> WindowExclusionClause -> WindowExclusionClause
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
$ccompare :: WindowExclusionClause -> WindowExclusionClause -> Ordering
compare :: WindowExclusionClause -> WindowExclusionClause -> Ordering
$c< :: WindowExclusionClause -> WindowExclusionClause -> Bool
< :: WindowExclusionClause -> WindowExclusionClause -> Bool
$c<= :: WindowExclusionClause -> WindowExclusionClause -> Bool
<= :: WindowExclusionClause -> WindowExclusionClause -> Bool
$c> :: WindowExclusionClause -> WindowExclusionClause -> Bool
> :: WindowExclusionClause -> WindowExclusionClause -> Bool
$c>= :: WindowExclusionClause -> WindowExclusionClause -> Bool
>= :: WindowExclusionClause -> WindowExclusionClause -> Bool
$cmax :: WindowExclusionClause
-> WindowExclusionClause -> WindowExclusionClause
max :: WindowExclusionClause
-> WindowExclusionClause -> WindowExclusionClause
$cmin :: WindowExclusionClause
-> WindowExclusionClause -> WindowExclusionClause
min :: WindowExclusionClause
-> WindowExclusionClause -> WindowExclusionClause
Ord)

-- |
-- ==== References
-- @
-- values_clause:
--   |  VALUES '(' expr_list ')'
--   |  values_clause ',' '(' expr_list ')'
-- @
type ValuesClause = NonEmpty ExprList

-- |
--
-- sort_clause:
--   |  ORDER BY sortby_list
--
-- sortby_list:
--   |  sortby
--   |  sortby_list ',' sortby
type SortClause = NonEmpty SortBy

-- |
-- ==== References
-- @
-- sortby:
--   |  a_expr USING qual_all_Op opt_nulls_order
--   |  a_expr opt_asc_desc opt_nulls_order
-- @
data SortBy
  = UsingSortBy AExpr QualAllOp (Maybe NullsOrder)
  | AscDescSortBy AExpr (Maybe AscDesc) (Maybe NullsOrder)
  deriving (Int -> SortBy -> ShowS
[SortBy] -> ShowS
SortBy -> String
(Int -> SortBy -> ShowS)
-> (SortBy -> String) -> ([SortBy] -> ShowS) -> Show SortBy
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SortBy -> ShowS
showsPrec :: Int -> SortBy -> ShowS
$cshow :: SortBy -> String
show :: SortBy -> String
$cshowList :: [SortBy] -> ShowS
showList :: [SortBy] -> ShowS
Show, (forall x. SortBy -> Rep SortBy x)
-> (forall x. Rep SortBy x -> SortBy) -> Generic SortBy
forall x. Rep SortBy x -> SortBy
forall x. SortBy -> Rep SortBy x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. SortBy -> Rep SortBy x
from :: forall x. SortBy -> Rep SortBy x
$cto :: forall x. Rep SortBy x -> SortBy
to :: forall x. Rep SortBy x -> SortBy
Generic, SortBy -> SortBy -> Bool
(SortBy -> SortBy -> Bool)
-> (SortBy -> SortBy -> Bool) -> Eq SortBy
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SortBy -> SortBy -> Bool
== :: SortBy -> SortBy -> Bool
$c/= :: SortBy -> SortBy -> Bool
/= :: SortBy -> SortBy -> Bool
Eq, Eq SortBy
Eq SortBy =>
(SortBy -> SortBy -> Ordering)
-> (SortBy -> SortBy -> Bool)
-> (SortBy -> SortBy -> Bool)
-> (SortBy -> SortBy -> Bool)
-> (SortBy -> SortBy -> Bool)
-> (SortBy -> SortBy -> SortBy)
-> (SortBy -> SortBy -> SortBy)
-> Ord SortBy
SortBy -> SortBy -> Bool
SortBy -> SortBy -> Ordering
SortBy -> SortBy -> SortBy
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
$ccompare :: SortBy -> SortBy -> Ordering
compare :: SortBy -> SortBy -> Ordering
$c< :: SortBy -> SortBy -> Bool
< :: SortBy -> SortBy -> Bool
$c<= :: SortBy -> SortBy -> Bool
<= :: SortBy -> SortBy -> Bool
$c> :: SortBy -> SortBy -> Bool
> :: SortBy -> SortBy -> Bool
$c>= :: SortBy -> SortBy -> Bool
>= :: SortBy -> SortBy -> Bool
$cmax :: SortBy -> SortBy -> SortBy
max :: SortBy -> SortBy -> SortBy
$cmin :: SortBy -> SortBy -> SortBy
min :: SortBy -> SortBy -> SortBy
Ord)

-- |
-- ==== References
-- @
-- select_limit:
--   | limit_clause offset_clause
--   | offset_clause limit_clause
--   | limit_clause
--   | offset_clause
-- @
data SelectLimit
  = LimitOffsetSelectLimit LimitClause OffsetClause
  | OffsetLimitSelectLimit OffsetClause LimitClause
  | LimitSelectLimit LimitClause
  | OffsetSelectLimit OffsetClause
  deriving (Int -> SelectLimit -> ShowS
[SelectLimit] -> ShowS
SelectLimit -> String
(Int -> SelectLimit -> ShowS)
-> (SelectLimit -> String)
-> ([SelectLimit] -> ShowS)
-> Show SelectLimit
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SelectLimit -> ShowS
showsPrec :: Int -> SelectLimit -> ShowS
$cshow :: SelectLimit -> String
show :: SelectLimit -> String
$cshowList :: [SelectLimit] -> ShowS
showList :: [SelectLimit] -> ShowS
Show, (forall x. SelectLimit -> Rep SelectLimit x)
-> (forall x. Rep SelectLimit x -> SelectLimit)
-> Generic SelectLimit
forall x. Rep SelectLimit x -> SelectLimit
forall x. SelectLimit -> Rep SelectLimit x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. SelectLimit -> Rep SelectLimit x
from :: forall x. SelectLimit -> Rep SelectLimit x
$cto :: forall x. Rep SelectLimit x -> SelectLimit
to :: forall x. Rep SelectLimit x -> SelectLimit
Generic, SelectLimit -> SelectLimit -> Bool
(SelectLimit -> SelectLimit -> Bool)
-> (SelectLimit -> SelectLimit -> Bool) -> Eq SelectLimit
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SelectLimit -> SelectLimit -> Bool
== :: SelectLimit -> SelectLimit -> Bool
$c/= :: SelectLimit -> SelectLimit -> Bool
/= :: SelectLimit -> SelectLimit -> Bool
Eq, Eq SelectLimit
Eq SelectLimit =>
(SelectLimit -> SelectLimit -> Ordering)
-> (SelectLimit -> SelectLimit -> Bool)
-> (SelectLimit -> SelectLimit -> Bool)
-> (SelectLimit -> SelectLimit -> Bool)
-> (SelectLimit -> SelectLimit -> Bool)
-> (SelectLimit -> SelectLimit -> SelectLimit)
-> (SelectLimit -> SelectLimit -> SelectLimit)
-> Ord SelectLimit
SelectLimit -> SelectLimit -> Bool
SelectLimit -> SelectLimit -> Ordering
SelectLimit -> SelectLimit -> SelectLimit
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
$ccompare :: SelectLimit -> SelectLimit -> Ordering
compare :: SelectLimit -> SelectLimit -> Ordering
$c< :: SelectLimit -> SelectLimit -> Bool
< :: SelectLimit -> SelectLimit -> Bool
$c<= :: SelectLimit -> SelectLimit -> Bool
<= :: SelectLimit -> SelectLimit -> Bool
$c> :: SelectLimit -> SelectLimit -> Bool
> :: SelectLimit -> SelectLimit -> Bool
$c>= :: SelectLimit -> SelectLimit -> Bool
>= :: SelectLimit -> SelectLimit -> Bool
$cmax :: SelectLimit -> SelectLimit -> SelectLimit
max :: SelectLimit -> SelectLimit -> SelectLimit
$cmin :: SelectLimit -> SelectLimit -> SelectLimit
min :: SelectLimit -> SelectLimit -> SelectLimit
Ord)

-- |
-- ==== References
-- @
-- limit_clause:
--   | LIMIT select_limit_value
--   | LIMIT select_limit_value ',' select_offset_value
--   | FETCH first_or_next select_fetch_first_value row_or_rows ONLY
--   | FETCH first_or_next row_or_rows ONLY
-- select_offset_value:
--   | a_expr
-- first_or_next:
--   | FIRST_P
--   | NEXT
-- row_or_rows:
--   | ROW
--   | ROWS
-- @
data LimitClause
  = LimitLimitClause SelectLimitValue (Maybe AExpr)
  | FetchOnlyLimitClause Bool (Maybe SelectFetchFirstValue) Bool
  deriving (Int -> LimitClause -> ShowS
[LimitClause] -> ShowS
LimitClause -> String
(Int -> LimitClause -> ShowS)
-> (LimitClause -> String)
-> ([LimitClause] -> ShowS)
-> Show LimitClause
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> LimitClause -> ShowS
showsPrec :: Int -> LimitClause -> ShowS
$cshow :: LimitClause -> String
show :: LimitClause -> String
$cshowList :: [LimitClause] -> ShowS
showList :: [LimitClause] -> ShowS
Show, (forall x. LimitClause -> Rep LimitClause x)
-> (forall x. Rep LimitClause x -> LimitClause)
-> Generic LimitClause
forall x. Rep LimitClause x -> LimitClause
forall x. LimitClause -> Rep LimitClause x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. LimitClause -> Rep LimitClause x
from :: forall x. LimitClause -> Rep LimitClause x
$cto :: forall x. Rep LimitClause x -> LimitClause
to :: forall x. Rep LimitClause x -> LimitClause
Generic, LimitClause -> LimitClause -> Bool
(LimitClause -> LimitClause -> Bool)
-> (LimitClause -> LimitClause -> Bool) -> Eq LimitClause
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: LimitClause -> LimitClause -> Bool
== :: LimitClause -> LimitClause -> Bool
$c/= :: LimitClause -> LimitClause -> Bool
/= :: LimitClause -> LimitClause -> Bool
Eq, Eq LimitClause
Eq LimitClause =>
(LimitClause -> LimitClause -> Ordering)
-> (LimitClause -> LimitClause -> Bool)
-> (LimitClause -> LimitClause -> Bool)
-> (LimitClause -> LimitClause -> Bool)
-> (LimitClause -> LimitClause -> Bool)
-> (LimitClause -> LimitClause -> LimitClause)
-> (LimitClause -> LimitClause -> LimitClause)
-> Ord LimitClause
LimitClause -> LimitClause -> Bool
LimitClause -> LimitClause -> Ordering
LimitClause -> LimitClause -> LimitClause
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
$ccompare :: LimitClause -> LimitClause -> Ordering
compare :: LimitClause -> LimitClause -> Ordering
$c< :: LimitClause -> LimitClause -> Bool
< :: LimitClause -> LimitClause -> Bool
$c<= :: LimitClause -> LimitClause -> Bool
<= :: LimitClause -> LimitClause -> Bool
$c> :: LimitClause -> LimitClause -> Bool
> :: LimitClause -> LimitClause -> Bool
$c>= :: LimitClause -> LimitClause -> Bool
>= :: LimitClause -> LimitClause -> Bool
$cmax :: LimitClause -> LimitClause -> LimitClause
max :: LimitClause -> LimitClause -> LimitClause
$cmin :: LimitClause -> LimitClause -> LimitClause
min :: LimitClause -> LimitClause -> LimitClause
Ord)

-- |
-- ==== References
-- @
-- select_fetch_first_value:
--   | c_expr
--   | '+' I_or_F_const
--   | '-' I_or_F_const
-- @
data SelectFetchFirstValue
  = ExprSelectFetchFirstValue CExpr
  | NumSelectFetchFirstValue Bool (Either Int64 Double)
  deriving (Int -> SelectFetchFirstValue -> ShowS
[SelectFetchFirstValue] -> ShowS
SelectFetchFirstValue -> String
(Int -> SelectFetchFirstValue -> ShowS)
-> (SelectFetchFirstValue -> String)
-> ([SelectFetchFirstValue] -> ShowS)
-> Show SelectFetchFirstValue
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SelectFetchFirstValue -> ShowS
showsPrec :: Int -> SelectFetchFirstValue -> ShowS
$cshow :: SelectFetchFirstValue -> String
show :: SelectFetchFirstValue -> String
$cshowList :: [SelectFetchFirstValue] -> ShowS
showList :: [SelectFetchFirstValue] -> ShowS
Show, (forall x. SelectFetchFirstValue -> Rep SelectFetchFirstValue x)
-> (forall x. Rep SelectFetchFirstValue x -> SelectFetchFirstValue)
-> Generic SelectFetchFirstValue
forall x. Rep SelectFetchFirstValue x -> SelectFetchFirstValue
forall x. SelectFetchFirstValue -> Rep SelectFetchFirstValue x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. SelectFetchFirstValue -> Rep SelectFetchFirstValue x
from :: forall x. SelectFetchFirstValue -> Rep SelectFetchFirstValue x
$cto :: forall x. Rep SelectFetchFirstValue x -> SelectFetchFirstValue
to :: forall x. Rep SelectFetchFirstValue x -> SelectFetchFirstValue
Generic, SelectFetchFirstValue -> SelectFetchFirstValue -> Bool
(SelectFetchFirstValue -> SelectFetchFirstValue -> Bool)
-> (SelectFetchFirstValue -> SelectFetchFirstValue -> Bool)
-> Eq SelectFetchFirstValue
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SelectFetchFirstValue -> SelectFetchFirstValue -> Bool
== :: SelectFetchFirstValue -> SelectFetchFirstValue -> Bool
$c/= :: SelectFetchFirstValue -> SelectFetchFirstValue -> Bool
/= :: SelectFetchFirstValue -> SelectFetchFirstValue -> Bool
Eq, Eq SelectFetchFirstValue
Eq SelectFetchFirstValue =>
(SelectFetchFirstValue -> SelectFetchFirstValue -> Ordering)
-> (SelectFetchFirstValue -> SelectFetchFirstValue -> Bool)
-> (SelectFetchFirstValue -> SelectFetchFirstValue -> Bool)
-> (SelectFetchFirstValue -> SelectFetchFirstValue -> Bool)
-> (SelectFetchFirstValue -> SelectFetchFirstValue -> Bool)
-> (SelectFetchFirstValue
    -> SelectFetchFirstValue -> SelectFetchFirstValue)
-> (SelectFetchFirstValue
    -> SelectFetchFirstValue -> SelectFetchFirstValue)
-> Ord SelectFetchFirstValue
SelectFetchFirstValue -> SelectFetchFirstValue -> Bool
SelectFetchFirstValue -> SelectFetchFirstValue -> Ordering
SelectFetchFirstValue
-> SelectFetchFirstValue -> SelectFetchFirstValue
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
$ccompare :: SelectFetchFirstValue -> SelectFetchFirstValue -> Ordering
compare :: SelectFetchFirstValue -> SelectFetchFirstValue -> Ordering
$c< :: SelectFetchFirstValue -> SelectFetchFirstValue -> Bool
< :: SelectFetchFirstValue -> SelectFetchFirstValue -> Bool
$c<= :: SelectFetchFirstValue -> SelectFetchFirstValue -> Bool
<= :: SelectFetchFirstValue -> SelectFetchFirstValue -> Bool
$c> :: SelectFetchFirstValue -> SelectFetchFirstValue -> Bool
> :: SelectFetchFirstValue -> SelectFetchFirstValue -> Bool
$c>= :: SelectFetchFirstValue -> SelectFetchFirstValue -> Bool
>= :: SelectFetchFirstValue -> SelectFetchFirstValue -> Bool
$cmax :: SelectFetchFirstValue
-> SelectFetchFirstValue -> SelectFetchFirstValue
max :: SelectFetchFirstValue
-> SelectFetchFirstValue -> SelectFetchFirstValue
$cmin :: SelectFetchFirstValue
-> SelectFetchFirstValue -> SelectFetchFirstValue
min :: SelectFetchFirstValue
-> SelectFetchFirstValue -> SelectFetchFirstValue
Ord)

-- |
-- ==== References
-- @
-- select_limit_value:
--   | a_expr
--   | ALL
-- @
data SelectLimitValue
  = ExprSelectLimitValue AExpr
  | AllSelectLimitValue
  deriving (Int -> SelectLimitValue -> ShowS
[SelectLimitValue] -> ShowS
SelectLimitValue -> String
(Int -> SelectLimitValue -> ShowS)
-> (SelectLimitValue -> String)
-> ([SelectLimitValue] -> ShowS)
-> Show SelectLimitValue
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SelectLimitValue -> ShowS
showsPrec :: Int -> SelectLimitValue -> ShowS
$cshow :: SelectLimitValue -> String
show :: SelectLimitValue -> String
$cshowList :: [SelectLimitValue] -> ShowS
showList :: [SelectLimitValue] -> ShowS
Show, (forall x. SelectLimitValue -> Rep SelectLimitValue x)
-> (forall x. Rep SelectLimitValue x -> SelectLimitValue)
-> Generic SelectLimitValue
forall x. Rep SelectLimitValue x -> SelectLimitValue
forall x. SelectLimitValue -> Rep SelectLimitValue x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. SelectLimitValue -> Rep SelectLimitValue x
from :: forall x. SelectLimitValue -> Rep SelectLimitValue x
$cto :: forall x. Rep SelectLimitValue x -> SelectLimitValue
to :: forall x. Rep SelectLimitValue x -> SelectLimitValue
Generic, SelectLimitValue -> SelectLimitValue -> Bool
(SelectLimitValue -> SelectLimitValue -> Bool)
-> (SelectLimitValue -> SelectLimitValue -> Bool)
-> Eq SelectLimitValue
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SelectLimitValue -> SelectLimitValue -> Bool
== :: SelectLimitValue -> SelectLimitValue -> Bool
$c/= :: SelectLimitValue -> SelectLimitValue -> Bool
/= :: SelectLimitValue -> SelectLimitValue -> Bool
Eq, Eq SelectLimitValue
Eq SelectLimitValue =>
(SelectLimitValue -> SelectLimitValue -> Ordering)
-> (SelectLimitValue -> SelectLimitValue -> Bool)
-> (SelectLimitValue -> SelectLimitValue -> Bool)
-> (SelectLimitValue -> SelectLimitValue -> Bool)
-> (SelectLimitValue -> SelectLimitValue -> Bool)
-> (SelectLimitValue -> SelectLimitValue -> SelectLimitValue)
-> (SelectLimitValue -> SelectLimitValue -> SelectLimitValue)
-> Ord SelectLimitValue
SelectLimitValue -> SelectLimitValue -> Bool
SelectLimitValue -> SelectLimitValue -> Ordering
SelectLimitValue -> SelectLimitValue -> SelectLimitValue
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
$ccompare :: SelectLimitValue -> SelectLimitValue -> Ordering
compare :: SelectLimitValue -> SelectLimitValue -> Ordering
$c< :: SelectLimitValue -> SelectLimitValue -> Bool
< :: SelectLimitValue -> SelectLimitValue -> Bool
$c<= :: SelectLimitValue -> SelectLimitValue -> Bool
<= :: SelectLimitValue -> SelectLimitValue -> Bool
$c> :: SelectLimitValue -> SelectLimitValue -> Bool
> :: SelectLimitValue -> SelectLimitValue -> Bool
$c>= :: SelectLimitValue -> SelectLimitValue -> Bool
>= :: SelectLimitValue -> SelectLimitValue -> Bool
$cmax :: SelectLimitValue -> SelectLimitValue -> SelectLimitValue
max :: SelectLimitValue -> SelectLimitValue -> SelectLimitValue
$cmin :: SelectLimitValue -> SelectLimitValue -> SelectLimitValue
min :: SelectLimitValue -> SelectLimitValue -> SelectLimitValue
Ord)

-- |
-- ==== References
-- @
-- offset_clause:
--   | OFFSET select_offset_value
--   | OFFSET select_fetch_first_value row_or_rows
-- select_offset_value:
--   | a_expr
-- row_or_rows:
--   | ROW
--   | ROWS
-- @
data OffsetClause
  = ExprOffsetClause AExpr
  | FetchFirstOffsetClause SelectFetchFirstValue Bool
  deriving (Int -> OffsetClause -> ShowS
[OffsetClause] -> ShowS
OffsetClause -> String
(Int -> OffsetClause -> ShowS)
-> (OffsetClause -> String)
-> ([OffsetClause] -> ShowS)
-> Show OffsetClause
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> OffsetClause -> ShowS
showsPrec :: Int -> OffsetClause -> ShowS
$cshow :: OffsetClause -> String
show :: OffsetClause -> String
$cshowList :: [OffsetClause] -> ShowS
showList :: [OffsetClause] -> ShowS
Show, (forall x. OffsetClause -> Rep OffsetClause x)
-> (forall x. Rep OffsetClause x -> OffsetClause)
-> Generic OffsetClause
forall x. Rep OffsetClause x -> OffsetClause
forall x. OffsetClause -> Rep OffsetClause x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. OffsetClause -> Rep OffsetClause x
from :: forall x. OffsetClause -> Rep OffsetClause x
$cto :: forall x. Rep OffsetClause x -> OffsetClause
to :: forall x. Rep OffsetClause x -> OffsetClause
Generic, OffsetClause -> OffsetClause -> Bool
(OffsetClause -> OffsetClause -> Bool)
-> (OffsetClause -> OffsetClause -> Bool) -> Eq OffsetClause
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: OffsetClause -> OffsetClause -> Bool
== :: OffsetClause -> OffsetClause -> Bool
$c/= :: OffsetClause -> OffsetClause -> Bool
/= :: OffsetClause -> OffsetClause -> Bool
Eq, Eq OffsetClause
Eq OffsetClause =>
(OffsetClause -> OffsetClause -> Ordering)
-> (OffsetClause -> OffsetClause -> Bool)
-> (OffsetClause -> OffsetClause -> Bool)
-> (OffsetClause -> OffsetClause -> Bool)
-> (OffsetClause -> OffsetClause -> Bool)
-> (OffsetClause -> OffsetClause -> OffsetClause)
-> (OffsetClause -> OffsetClause -> OffsetClause)
-> Ord OffsetClause
OffsetClause -> OffsetClause -> Bool
OffsetClause -> OffsetClause -> Ordering
OffsetClause -> OffsetClause -> OffsetClause
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
$ccompare :: OffsetClause -> OffsetClause -> Ordering
compare :: OffsetClause -> OffsetClause -> Ordering
$c< :: OffsetClause -> OffsetClause -> Bool
< :: OffsetClause -> OffsetClause -> Bool
$c<= :: OffsetClause -> OffsetClause -> Bool
<= :: OffsetClause -> OffsetClause -> Bool
$c> :: OffsetClause -> OffsetClause -> Bool
> :: OffsetClause -> OffsetClause -> Bool
$c>= :: OffsetClause -> OffsetClause -> Bool
>= :: OffsetClause -> OffsetClause -> Bool
$cmax :: OffsetClause -> OffsetClause -> OffsetClause
max :: OffsetClause -> OffsetClause -> OffsetClause
$cmin :: OffsetClause -> OffsetClause -> OffsetClause
min :: OffsetClause -> OffsetClause -> OffsetClause
Ord)

-- * For Locking

-- |
-- ==== References
-- @
-- for_locking_clause:
--   | for_locking_items
--   | FOR READ ONLY
-- for_locking_items:
--   | for_locking_item
--   | for_locking_items for_locking_item
-- @
data ForLockingClause
  = ItemsForLockingClause (NonEmpty ForLockingItem)
  | ReadOnlyForLockingClause
  deriving (Int -> ForLockingClause -> ShowS
[ForLockingClause] -> ShowS
ForLockingClause -> String
(Int -> ForLockingClause -> ShowS)
-> (ForLockingClause -> String)
-> ([ForLockingClause] -> ShowS)
-> Show ForLockingClause
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ForLockingClause -> ShowS
showsPrec :: Int -> ForLockingClause -> ShowS
$cshow :: ForLockingClause -> String
show :: ForLockingClause -> String
$cshowList :: [ForLockingClause] -> ShowS
showList :: [ForLockingClause] -> ShowS
Show, (forall x. ForLockingClause -> Rep ForLockingClause x)
-> (forall x. Rep ForLockingClause x -> ForLockingClause)
-> Generic ForLockingClause
forall x. Rep ForLockingClause x -> ForLockingClause
forall x. ForLockingClause -> Rep ForLockingClause x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ForLockingClause -> Rep ForLockingClause x
from :: forall x. ForLockingClause -> Rep ForLockingClause x
$cto :: forall x. Rep ForLockingClause x -> ForLockingClause
to :: forall x. Rep ForLockingClause x -> ForLockingClause
Generic, ForLockingClause -> ForLockingClause -> Bool
(ForLockingClause -> ForLockingClause -> Bool)
-> (ForLockingClause -> ForLockingClause -> Bool)
-> Eq ForLockingClause
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ForLockingClause -> ForLockingClause -> Bool
== :: ForLockingClause -> ForLockingClause -> Bool
$c/= :: ForLockingClause -> ForLockingClause -> Bool
/= :: ForLockingClause -> ForLockingClause -> Bool
Eq, Eq ForLockingClause
Eq ForLockingClause =>
(ForLockingClause -> ForLockingClause -> Ordering)
-> (ForLockingClause -> ForLockingClause -> Bool)
-> (ForLockingClause -> ForLockingClause -> Bool)
-> (ForLockingClause -> ForLockingClause -> Bool)
-> (ForLockingClause -> ForLockingClause -> Bool)
-> (ForLockingClause -> ForLockingClause -> ForLockingClause)
-> (ForLockingClause -> ForLockingClause -> ForLockingClause)
-> Ord ForLockingClause
ForLockingClause -> ForLockingClause -> Bool
ForLockingClause -> ForLockingClause -> Ordering
ForLockingClause -> ForLockingClause -> ForLockingClause
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
$ccompare :: ForLockingClause -> ForLockingClause -> Ordering
compare :: ForLockingClause -> ForLockingClause -> Ordering
$c< :: ForLockingClause -> ForLockingClause -> Bool
< :: ForLockingClause -> ForLockingClause -> Bool
$c<= :: ForLockingClause -> ForLockingClause -> Bool
<= :: ForLockingClause -> ForLockingClause -> Bool
$c> :: ForLockingClause -> ForLockingClause -> Bool
> :: ForLockingClause -> ForLockingClause -> Bool
$c>= :: ForLockingClause -> ForLockingClause -> Bool
>= :: ForLockingClause -> ForLockingClause -> Bool
$cmax :: ForLockingClause -> ForLockingClause -> ForLockingClause
max :: ForLockingClause -> ForLockingClause -> ForLockingClause
$cmin :: ForLockingClause -> ForLockingClause -> ForLockingClause
min :: ForLockingClause -> ForLockingClause -> ForLockingClause
Ord)

-- |
-- ==== References
-- @
-- for_locking_item:
--   | for_locking_strength locked_rels_list opt_nowait_or_skip
-- locked_rels_list:
--   | OF qualified_name_list
--   | EMPTY
-- opt_nowait_or_skip:
--   | NOWAIT
--   | SKIP LOCKED
--   | EMPTY
-- @
data ForLockingItem = ForLockingItem ForLockingStrength (Maybe (NonEmpty QualifiedName)) (Maybe Bool)
  deriving (Int -> ForLockingItem -> ShowS
[ForLockingItem] -> ShowS
ForLockingItem -> String
(Int -> ForLockingItem -> ShowS)
-> (ForLockingItem -> String)
-> ([ForLockingItem] -> ShowS)
-> Show ForLockingItem
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ForLockingItem -> ShowS
showsPrec :: Int -> ForLockingItem -> ShowS
$cshow :: ForLockingItem -> String
show :: ForLockingItem -> String
$cshowList :: [ForLockingItem] -> ShowS
showList :: [ForLockingItem] -> ShowS
Show, (forall x. ForLockingItem -> Rep ForLockingItem x)
-> (forall x. Rep ForLockingItem x -> ForLockingItem)
-> Generic ForLockingItem
forall x. Rep ForLockingItem x -> ForLockingItem
forall x. ForLockingItem -> Rep ForLockingItem x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ForLockingItem -> Rep ForLockingItem x
from :: forall x. ForLockingItem -> Rep ForLockingItem x
$cto :: forall x. Rep ForLockingItem x -> ForLockingItem
to :: forall x. Rep ForLockingItem x -> ForLockingItem
Generic, ForLockingItem -> ForLockingItem -> Bool
(ForLockingItem -> ForLockingItem -> Bool)
-> (ForLockingItem -> ForLockingItem -> Bool) -> Eq ForLockingItem
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ForLockingItem -> ForLockingItem -> Bool
== :: ForLockingItem -> ForLockingItem -> Bool
$c/= :: ForLockingItem -> ForLockingItem -> Bool
/= :: ForLockingItem -> ForLockingItem -> Bool
Eq, Eq ForLockingItem
Eq ForLockingItem =>
(ForLockingItem -> ForLockingItem -> Ordering)
-> (ForLockingItem -> ForLockingItem -> Bool)
-> (ForLockingItem -> ForLockingItem -> Bool)
-> (ForLockingItem -> ForLockingItem -> Bool)
-> (ForLockingItem -> ForLockingItem -> Bool)
-> (ForLockingItem -> ForLockingItem -> ForLockingItem)
-> (ForLockingItem -> ForLockingItem -> ForLockingItem)
-> Ord ForLockingItem
ForLockingItem -> ForLockingItem -> Bool
ForLockingItem -> ForLockingItem -> Ordering
ForLockingItem -> ForLockingItem -> ForLockingItem
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
$ccompare :: ForLockingItem -> ForLockingItem -> Ordering
compare :: ForLockingItem -> ForLockingItem -> Ordering
$c< :: ForLockingItem -> ForLockingItem -> Bool
< :: ForLockingItem -> ForLockingItem -> Bool
$c<= :: ForLockingItem -> ForLockingItem -> Bool
<= :: ForLockingItem -> ForLockingItem -> Bool
$c> :: ForLockingItem -> ForLockingItem -> Bool
> :: ForLockingItem -> ForLockingItem -> Bool
$c>= :: ForLockingItem -> ForLockingItem -> Bool
>= :: ForLockingItem -> ForLockingItem -> Bool
$cmax :: ForLockingItem -> ForLockingItem -> ForLockingItem
max :: ForLockingItem -> ForLockingItem -> ForLockingItem
$cmin :: ForLockingItem -> ForLockingItem -> ForLockingItem
min :: ForLockingItem -> ForLockingItem -> ForLockingItem
Ord)

-- |
-- ==== References
-- @
-- for_locking_strength:
--   | FOR UPDATE
--   | FOR NO KEY UPDATE
--   | FOR SHARE
--   | FOR KEY SHARE
-- @
data ForLockingStrength
  = UpdateForLockingStrength
  | NoKeyUpdateForLockingStrength
  | ShareForLockingStrength
  | KeyForLockingStrength
  deriving (Int -> ForLockingStrength -> ShowS
[ForLockingStrength] -> ShowS
ForLockingStrength -> String
(Int -> ForLockingStrength -> ShowS)
-> (ForLockingStrength -> String)
-> ([ForLockingStrength] -> ShowS)
-> Show ForLockingStrength
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ForLockingStrength -> ShowS
showsPrec :: Int -> ForLockingStrength -> ShowS
$cshow :: ForLockingStrength -> String
show :: ForLockingStrength -> String
$cshowList :: [ForLockingStrength] -> ShowS
showList :: [ForLockingStrength] -> ShowS
Show, (forall x. ForLockingStrength -> Rep ForLockingStrength x)
-> (forall x. Rep ForLockingStrength x -> ForLockingStrength)
-> Generic ForLockingStrength
forall x. Rep ForLockingStrength x -> ForLockingStrength
forall x. ForLockingStrength -> Rep ForLockingStrength x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ForLockingStrength -> Rep ForLockingStrength x
from :: forall x. ForLockingStrength -> Rep ForLockingStrength x
$cto :: forall x. Rep ForLockingStrength x -> ForLockingStrength
to :: forall x. Rep ForLockingStrength x -> ForLockingStrength
Generic, ForLockingStrength -> ForLockingStrength -> Bool
(ForLockingStrength -> ForLockingStrength -> Bool)
-> (ForLockingStrength -> ForLockingStrength -> Bool)
-> Eq ForLockingStrength
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ForLockingStrength -> ForLockingStrength -> Bool
== :: ForLockingStrength -> ForLockingStrength -> Bool
$c/= :: ForLockingStrength -> ForLockingStrength -> Bool
/= :: ForLockingStrength -> ForLockingStrength -> Bool
Eq, Eq ForLockingStrength
Eq ForLockingStrength =>
(ForLockingStrength -> ForLockingStrength -> Ordering)
-> (ForLockingStrength -> ForLockingStrength -> Bool)
-> (ForLockingStrength -> ForLockingStrength -> Bool)
-> (ForLockingStrength -> ForLockingStrength -> Bool)
-> (ForLockingStrength -> ForLockingStrength -> Bool)
-> (ForLockingStrength -> ForLockingStrength -> ForLockingStrength)
-> (ForLockingStrength -> ForLockingStrength -> ForLockingStrength)
-> Ord ForLockingStrength
ForLockingStrength -> ForLockingStrength -> Bool
ForLockingStrength -> ForLockingStrength -> Ordering
ForLockingStrength -> ForLockingStrength -> ForLockingStrength
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
$ccompare :: ForLockingStrength -> ForLockingStrength -> Ordering
compare :: ForLockingStrength -> ForLockingStrength -> Ordering
$c< :: ForLockingStrength -> ForLockingStrength -> Bool
< :: ForLockingStrength -> ForLockingStrength -> Bool
$c<= :: ForLockingStrength -> ForLockingStrength -> Bool
<= :: ForLockingStrength -> ForLockingStrength -> Bool
$c> :: ForLockingStrength -> ForLockingStrength -> Bool
> :: ForLockingStrength -> ForLockingStrength -> Bool
$c>= :: ForLockingStrength -> ForLockingStrength -> Bool
>= :: ForLockingStrength -> ForLockingStrength -> Bool
$cmax :: ForLockingStrength -> ForLockingStrength -> ForLockingStrength
max :: ForLockingStrength -> ForLockingStrength -> ForLockingStrength
$cmin :: ForLockingStrength -> ForLockingStrength -> ForLockingStrength
min :: ForLockingStrength -> ForLockingStrength -> ForLockingStrength
Ord)

-- * Table references and joining

-- |
-- ==== References
-- @
-- from_list:
--   | table_ref
--   | from_list ',' table_ref
-- @
type FromList = NonEmpty TableRef

-- |
-- ==== References
-- @
-- | relation_expr opt_alias_clause
-- | relation_expr opt_alias_clause tablesample_clause
-- | func_table func_alias_clause
-- | LATERAL_P func_table func_alias_clause
-- | xmltable opt_alias_clause
-- | LATERAL_P xmltable opt_alias_clause
-- | select_with_parens opt_alias_clause
-- | LATERAL_P select_with_parens opt_alias_clause
-- | joined_table
-- | '(' joined_table ')' alias_clause
--
-- TODO: Add xmltable
-- @
data TableRef
  = -- |
    -- @
    --    | relation_expr opt_alias_clause
    --    | relation_expr opt_alias_clause tablesample_clause
    -- @
    RelationExprTableRef RelationExpr (Maybe AliasClause) (Maybe TablesampleClause)
  | -- |
    -- @
    --    | func_table func_alias_clause
    --    | LATERAL_P func_table func_alias_clause
    -- @
    FuncTableRef Bool FuncTable (Maybe FuncAliasClause)
  | -- |
    -- @
    --    | select_with_parens opt_alias_clause
    --    | LATERAL_P select_with_parens opt_alias_clause
    -- @
    SelectTableRef Bool SelectWithParens (Maybe AliasClause)
  | -- |
    -- @
    --    | joined_table
    --    | '(' joined_table ')' alias_clause
    -- @
    JoinTableRef JoinedTable (Maybe AliasClause)
  deriving (Int -> TableRef -> ShowS
[TableRef] -> ShowS
TableRef -> String
(Int -> TableRef -> ShowS)
-> (TableRef -> String) -> ([TableRef] -> ShowS) -> Show TableRef
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TableRef -> ShowS
showsPrec :: Int -> TableRef -> ShowS
$cshow :: TableRef -> String
show :: TableRef -> String
$cshowList :: [TableRef] -> ShowS
showList :: [TableRef] -> ShowS
Show, (forall x. TableRef -> Rep TableRef x)
-> (forall x. Rep TableRef x -> TableRef) -> Generic TableRef
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
$cfrom :: forall x. TableRef -> Rep TableRef x
from :: forall x. TableRef -> Rep TableRef x
$cto :: forall x. Rep TableRef x -> TableRef
to :: forall x. Rep TableRef x -> TableRef
Generic, TableRef -> TableRef -> Bool
(TableRef -> TableRef -> Bool)
-> (TableRef -> TableRef -> Bool) -> Eq TableRef
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TableRef -> TableRef -> Bool
== :: TableRef -> TableRef -> Bool
$c/= :: TableRef -> TableRef -> Bool
/= :: TableRef -> TableRef -> Bool
Eq, Eq TableRef
Eq TableRef =>
(TableRef -> TableRef -> Ordering)
-> (TableRef -> TableRef -> Bool)
-> (TableRef -> TableRef -> Bool)
-> (TableRef -> TableRef -> Bool)
-> (TableRef -> TableRef -> Bool)
-> (TableRef -> TableRef -> TableRef)
-> (TableRef -> TableRef -> TableRef)
-> Ord TableRef
TableRef -> TableRef -> Bool
TableRef -> TableRef -> Ordering
TableRef -> TableRef -> TableRef
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
$ccompare :: TableRef -> TableRef -> Ordering
compare :: TableRef -> TableRef -> Ordering
$c< :: TableRef -> TableRef -> Bool
< :: TableRef -> TableRef -> Bool
$c<= :: TableRef -> TableRef -> Bool
<= :: TableRef -> TableRef -> Bool
$c> :: TableRef -> TableRef -> Bool
> :: TableRef -> TableRef -> Bool
$c>= :: TableRef -> TableRef -> Bool
>= :: TableRef -> TableRef -> Bool
$cmax :: TableRef -> TableRef -> TableRef
max :: TableRef -> TableRef -> TableRef
$cmin :: TableRef -> TableRef -> TableRef
min :: TableRef -> TableRef -> TableRef
Ord)

-- |
-- ==== References
-- @
-- | qualified_name
-- | qualified_name '*'
-- | ONLY qualified_name
-- | ONLY '(' qualified_name ')'
-- @
data RelationExpr
  = SimpleRelationExpr
      -- | Name.
      QualifiedName
      -- | Is asterisk present?
      Bool
  | OnlyRelationExpr
      -- | Name.
      QualifiedName
      -- | Are parentheses present?
      Bool
  deriving (Int -> RelationExpr -> ShowS
[RelationExpr] -> ShowS
RelationExpr -> String
(Int -> RelationExpr -> ShowS)
-> (RelationExpr -> String)
-> ([RelationExpr] -> ShowS)
-> Show RelationExpr
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RelationExpr -> ShowS
showsPrec :: Int -> RelationExpr -> ShowS
$cshow :: RelationExpr -> String
show :: RelationExpr -> String
$cshowList :: [RelationExpr] -> ShowS
showList :: [RelationExpr] -> ShowS
Show, (forall x. RelationExpr -> Rep RelationExpr x)
-> (forall x. Rep RelationExpr x -> RelationExpr)
-> Generic RelationExpr
forall x. Rep RelationExpr x -> RelationExpr
forall x. RelationExpr -> Rep RelationExpr x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. RelationExpr -> Rep RelationExpr x
from :: forall x. RelationExpr -> Rep RelationExpr x
$cto :: forall x. Rep RelationExpr x -> RelationExpr
to :: forall x. Rep RelationExpr x -> RelationExpr
Generic, RelationExpr -> RelationExpr -> Bool
(RelationExpr -> RelationExpr -> Bool)
-> (RelationExpr -> RelationExpr -> Bool) -> Eq RelationExpr
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RelationExpr -> RelationExpr -> Bool
== :: RelationExpr -> RelationExpr -> Bool
$c/= :: RelationExpr -> RelationExpr -> Bool
/= :: RelationExpr -> RelationExpr -> Bool
Eq, Eq RelationExpr
Eq RelationExpr =>
(RelationExpr -> RelationExpr -> Ordering)
-> (RelationExpr -> RelationExpr -> Bool)
-> (RelationExpr -> RelationExpr -> Bool)
-> (RelationExpr -> RelationExpr -> Bool)
-> (RelationExpr -> RelationExpr -> Bool)
-> (RelationExpr -> RelationExpr -> RelationExpr)
-> (RelationExpr -> RelationExpr -> RelationExpr)
-> Ord RelationExpr
RelationExpr -> RelationExpr -> Bool
RelationExpr -> RelationExpr -> Ordering
RelationExpr -> RelationExpr -> RelationExpr
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
$ccompare :: RelationExpr -> RelationExpr -> Ordering
compare :: RelationExpr -> RelationExpr -> Ordering
$c< :: RelationExpr -> RelationExpr -> Bool
< :: RelationExpr -> RelationExpr -> Bool
$c<= :: RelationExpr -> RelationExpr -> Bool
<= :: RelationExpr -> RelationExpr -> Bool
$c> :: RelationExpr -> RelationExpr -> Bool
> :: RelationExpr -> RelationExpr -> Bool
$c>= :: RelationExpr -> RelationExpr -> Bool
>= :: RelationExpr -> RelationExpr -> Bool
$cmax :: RelationExpr -> RelationExpr -> RelationExpr
max :: RelationExpr -> RelationExpr -> RelationExpr
$cmin :: RelationExpr -> RelationExpr -> RelationExpr
min :: RelationExpr -> RelationExpr -> RelationExpr
Ord)

-- |
-- ==== References
-- @
-- relation_expr_opt_alias:
--   | relation_expr
--   | relation_expr ColId
--   | relation_expr AS ColId
-- @
data RelationExprOptAlias = RelationExprOptAlias RelationExpr (Maybe (Bool, ColId))
  deriving (Int -> RelationExprOptAlias -> ShowS
[RelationExprOptAlias] -> ShowS
RelationExprOptAlias -> String
(Int -> RelationExprOptAlias -> ShowS)
-> (RelationExprOptAlias -> String)
-> ([RelationExprOptAlias] -> ShowS)
-> Show RelationExprOptAlias
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RelationExprOptAlias -> ShowS
showsPrec :: Int -> RelationExprOptAlias -> ShowS
$cshow :: RelationExprOptAlias -> String
show :: RelationExprOptAlias -> String
$cshowList :: [RelationExprOptAlias] -> ShowS
showList :: [RelationExprOptAlias] -> ShowS
Show, (forall x. RelationExprOptAlias -> Rep RelationExprOptAlias x)
-> (forall x. Rep RelationExprOptAlias x -> RelationExprOptAlias)
-> Generic RelationExprOptAlias
forall x. Rep RelationExprOptAlias x -> RelationExprOptAlias
forall x. RelationExprOptAlias -> Rep RelationExprOptAlias x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. RelationExprOptAlias -> Rep RelationExprOptAlias x
from :: forall x. RelationExprOptAlias -> Rep RelationExprOptAlias x
$cto :: forall x. Rep RelationExprOptAlias x -> RelationExprOptAlias
to :: forall x. Rep RelationExprOptAlias x -> RelationExprOptAlias
Generic, RelationExprOptAlias -> RelationExprOptAlias -> Bool
(RelationExprOptAlias -> RelationExprOptAlias -> Bool)
-> (RelationExprOptAlias -> RelationExprOptAlias -> Bool)
-> Eq RelationExprOptAlias
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RelationExprOptAlias -> RelationExprOptAlias -> Bool
== :: RelationExprOptAlias -> RelationExprOptAlias -> Bool
$c/= :: RelationExprOptAlias -> RelationExprOptAlias -> Bool
/= :: RelationExprOptAlias -> RelationExprOptAlias -> Bool
Eq, Eq RelationExprOptAlias
Eq RelationExprOptAlias =>
(RelationExprOptAlias -> RelationExprOptAlias -> Ordering)
-> (RelationExprOptAlias -> RelationExprOptAlias -> Bool)
-> (RelationExprOptAlias -> RelationExprOptAlias -> Bool)
-> (RelationExprOptAlias -> RelationExprOptAlias -> Bool)
-> (RelationExprOptAlias -> RelationExprOptAlias -> Bool)
-> (RelationExprOptAlias
    -> RelationExprOptAlias -> RelationExprOptAlias)
-> (RelationExprOptAlias
    -> RelationExprOptAlias -> RelationExprOptAlias)
-> Ord RelationExprOptAlias
RelationExprOptAlias -> RelationExprOptAlias -> Bool
RelationExprOptAlias -> RelationExprOptAlias -> Ordering
RelationExprOptAlias
-> RelationExprOptAlias -> RelationExprOptAlias
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
$ccompare :: RelationExprOptAlias -> RelationExprOptAlias -> Ordering
compare :: RelationExprOptAlias -> RelationExprOptAlias -> Ordering
$c< :: RelationExprOptAlias -> RelationExprOptAlias -> Bool
< :: RelationExprOptAlias -> RelationExprOptAlias -> Bool
$c<= :: RelationExprOptAlias -> RelationExprOptAlias -> Bool
<= :: RelationExprOptAlias -> RelationExprOptAlias -> Bool
$c> :: RelationExprOptAlias -> RelationExprOptAlias -> Bool
> :: RelationExprOptAlias -> RelationExprOptAlias -> Bool
$c>= :: RelationExprOptAlias -> RelationExprOptAlias -> Bool
>= :: RelationExprOptAlias -> RelationExprOptAlias -> Bool
$cmax :: RelationExprOptAlias
-> RelationExprOptAlias -> RelationExprOptAlias
max :: RelationExprOptAlias
-> RelationExprOptAlias -> RelationExprOptAlias
$cmin :: RelationExprOptAlias
-> RelationExprOptAlias -> RelationExprOptAlias
min :: RelationExprOptAlias
-> RelationExprOptAlias -> RelationExprOptAlias
Ord)

-- |
-- ==== References
-- @
-- tablesample_clause:
--   | TABLESAMPLE func_name '(' expr_list ')' opt_repeatable_clause
-- @
data TablesampleClause = TablesampleClause FuncName ExprList (Maybe RepeatableClause)
  deriving (Int -> TablesampleClause -> ShowS
[TablesampleClause] -> ShowS
TablesampleClause -> String
(Int -> TablesampleClause -> ShowS)
-> (TablesampleClause -> String)
-> ([TablesampleClause] -> ShowS)
-> Show TablesampleClause
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TablesampleClause -> ShowS
showsPrec :: Int -> TablesampleClause -> ShowS
$cshow :: TablesampleClause -> String
show :: TablesampleClause -> String
$cshowList :: [TablesampleClause] -> ShowS
showList :: [TablesampleClause] -> ShowS
Show, (forall x. TablesampleClause -> Rep TablesampleClause x)
-> (forall x. Rep TablesampleClause x -> TablesampleClause)
-> Generic TablesampleClause
forall x. Rep TablesampleClause x -> TablesampleClause
forall x. TablesampleClause -> Rep TablesampleClause x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. TablesampleClause -> Rep TablesampleClause x
from :: forall x. TablesampleClause -> Rep TablesampleClause x
$cto :: forall x. Rep TablesampleClause x -> TablesampleClause
to :: forall x. Rep TablesampleClause x -> TablesampleClause
Generic, TablesampleClause -> TablesampleClause -> Bool
(TablesampleClause -> TablesampleClause -> Bool)
-> (TablesampleClause -> TablesampleClause -> Bool)
-> Eq TablesampleClause
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TablesampleClause -> TablesampleClause -> Bool
== :: TablesampleClause -> TablesampleClause -> Bool
$c/= :: TablesampleClause -> TablesampleClause -> Bool
/= :: TablesampleClause -> TablesampleClause -> Bool
Eq, Eq TablesampleClause
Eq TablesampleClause =>
(TablesampleClause -> TablesampleClause -> Ordering)
-> (TablesampleClause -> TablesampleClause -> Bool)
-> (TablesampleClause -> TablesampleClause -> Bool)
-> (TablesampleClause -> TablesampleClause -> Bool)
-> (TablesampleClause -> TablesampleClause -> Bool)
-> (TablesampleClause -> TablesampleClause -> TablesampleClause)
-> (TablesampleClause -> TablesampleClause -> TablesampleClause)
-> Ord TablesampleClause
TablesampleClause -> TablesampleClause -> Bool
TablesampleClause -> TablesampleClause -> Ordering
TablesampleClause -> TablesampleClause -> TablesampleClause
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
$ccompare :: TablesampleClause -> TablesampleClause -> Ordering
compare :: TablesampleClause -> TablesampleClause -> Ordering
$c< :: TablesampleClause -> TablesampleClause -> Bool
< :: TablesampleClause -> TablesampleClause -> Bool
$c<= :: TablesampleClause -> TablesampleClause -> Bool
<= :: TablesampleClause -> TablesampleClause -> Bool
$c> :: TablesampleClause -> TablesampleClause -> Bool
> :: TablesampleClause -> TablesampleClause -> Bool
$c>= :: TablesampleClause -> TablesampleClause -> Bool
>= :: TablesampleClause -> TablesampleClause -> Bool
$cmax :: TablesampleClause -> TablesampleClause -> TablesampleClause
max :: TablesampleClause -> TablesampleClause -> TablesampleClause
$cmin :: TablesampleClause -> TablesampleClause -> TablesampleClause
min :: TablesampleClause -> TablesampleClause -> TablesampleClause
Ord)

-- |
-- ==== References
-- @
-- opt_repeatable_clause:
--   | REPEATABLE '(' a_expr ')'
--   | EMPTY
-- @
type RepeatableClause = AExpr

-- |
-- ==== References
-- @
-- func_table:
--   | func_expr_windowless opt_ordinality
--   | ROWS FROM '(' rowsfrom_list ')' opt_ordinality
-- @
data FuncTable
  = FuncExprFuncTable FuncExprWindowless OptOrdinality
  | RowsFromFuncTable RowsfromList OptOrdinality
  deriving (Int -> FuncTable -> ShowS
[FuncTable] -> ShowS
FuncTable -> String
(Int -> FuncTable -> ShowS)
-> (FuncTable -> String)
-> ([FuncTable] -> ShowS)
-> Show FuncTable
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FuncTable -> ShowS
showsPrec :: Int -> FuncTable -> ShowS
$cshow :: FuncTable -> String
show :: FuncTable -> String
$cshowList :: [FuncTable] -> ShowS
showList :: [FuncTable] -> ShowS
Show, (forall x. FuncTable -> Rep FuncTable x)
-> (forall x. Rep FuncTable x -> FuncTable) -> Generic FuncTable
forall x. Rep FuncTable x -> FuncTable
forall x. FuncTable -> Rep FuncTable x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. FuncTable -> Rep FuncTable x
from :: forall x. FuncTable -> Rep FuncTable x
$cto :: forall x. Rep FuncTable x -> FuncTable
to :: forall x. Rep FuncTable x -> FuncTable
Generic, FuncTable -> FuncTable -> Bool
(FuncTable -> FuncTable -> Bool)
-> (FuncTable -> FuncTable -> Bool) -> Eq FuncTable
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FuncTable -> FuncTable -> Bool
== :: FuncTable -> FuncTable -> Bool
$c/= :: FuncTable -> FuncTable -> Bool
/= :: FuncTable -> FuncTable -> Bool
Eq, Eq FuncTable
Eq FuncTable =>
(FuncTable -> FuncTable -> Ordering)
-> (FuncTable -> FuncTable -> Bool)
-> (FuncTable -> FuncTable -> Bool)
-> (FuncTable -> FuncTable -> Bool)
-> (FuncTable -> FuncTable -> Bool)
-> (FuncTable -> FuncTable -> FuncTable)
-> (FuncTable -> FuncTable -> FuncTable)
-> Ord FuncTable
FuncTable -> FuncTable -> Bool
FuncTable -> FuncTable -> Ordering
FuncTable -> FuncTable -> FuncTable
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
$ccompare :: FuncTable -> FuncTable -> Ordering
compare :: FuncTable -> FuncTable -> Ordering
$c< :: FuncTable -> FuncTable -> Bool
< :: FuncTable -> FuncTable -> Bool
$c<= :: FuncTable -> FuncTable -> Bool
<= :: FuncTable -> FuncTable -> Bool
$c> :: FuncTable -> FuncTable -> Bool
> :: FuncTable -> FuncTable -> Bool
$c>= :: FuncTable -> FuncTable -> Bool
>= :: FuncTable -> FuncTable -> Bool
$cmax :: FuncTable -> FuncTable -> FuncTable
max :: FuncTable -> FuncTable -> FuncTable
$cmin :: FuncTable -> FuncTable -> FuncTable
min :: FuncTable -> FuncTable -> FuncTable
Ord)

-- |
-- ==== References
-- @
-- rowsfrom_item:
--   | func_expr_windowless opt_col_def_list
-- @
data RowsfromItem = RowsfromItem FuncExprWindowless (Maybe ColDefList)
  deriving (Int -> RowsfromItem -> ShowS
[RowsfromItem] -> ShowS
RowsfromItem -> String
(Int -> RowsfromItem -> ShowS)
-> (RowsfromItem -> String)
-> ([RowsfromItem] -> ShowS)
-> Show RowsfromItem
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RowsfromItem -> ShowS
showsPrec :: Int -> RowsfromItem -> ShowS
$cshow :: RowsfromItem -> String
show :: RowsfromItem -> String
$cshowList :: [RowsfromItem] -> ShowS
showList :: [RowsfromItem] -> ShowS
Show, (forall x. RowsfromItem -> Rep RowsfromItem x)
-> (forall x. Rep RowsfromItem x -> RowsfromItem)
-> Generic RowsfromItem
forall x. Rep RowsfromItem x -> RowsfromItem
forall x. RowsfromItem -> Rep RowsfromItem x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. RowsfromItem -> Rep RowsfromItem x
from :: forall x. RowsfromItem -> Rep RowsfromItem x
$cto :: forall x. Rep RowsfromItem x -> RowsfromItem
to :: forall x. Rep RowsfromItem x -> RowsfromItem
Generic, RowsfromItem -> RowsfromItem -> Bool
(RowsfromItem -> RowsfromItem -> Bool)
-> (RowsfromItem -> RowsfromItem -> Bool) -> Eq RowsfromItem
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RowsfromItem -> RowsfromItem -> Bool
== :: RowsfromItem -> RowsfromItem -> Bool
$c/= :: RowsfromItem -> RowsfromItem -> Bool
/= :: RowsfromItem -> RowsfromItem -> Bool
Eq, Eq RowsfromItem
Eq RowsfromItem =>
(RowsfromItem -> RowsfromItem -> Ordering)
-> (RowsfromItem -> RowsfromItem -> Bool)
-> (RowsfromItem -> RowsfromItem -> Bool)
-> (RowsfromItem -> RowsfromItem -> Bool)
-> (RowsfromItem -> RowsfromItem -> Bool)
-> (RowsfromItem -> RowsfromItem -> RowsfromItem)
-> (RowsfromItem -> RowsfromItem -> RowsfromItem)
-> Ord RowsfromItem
RowsfromItem -> RowsfromItem -> Bool
RowsfromItem -> RowsfromItem -> Ordering
RowsfromItem -> RowsfromItem -> RowsfromItem
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
$ccompare :: RowsfromItem -> RowsfromItem -> Ordering
compare :: RowsfromItem -> RowsfromItem -> Ordering
$c< :: RowsfromItem -> RowsfromItem -> Bool
< :: RowsfromItem -> RowsfromItem -> Bool
$c<= :: RowsfromItem -> RowsfromItem -> Bool
<= :: RowsfromItem -> RowsfromItem -> Bool
$c> :: RowsfromItem -> RowsfromItem -> Bool
> :: RowsfromItem -> RowsfromItem -> Bool
$c>= :: RowsfromItem -> RowsfromItem -> Bool
>= :: RowsfromItem -> RowsfromItem -> Bool
$cmax :: RowsfromItem -> RowsfromItem -> RowsfromItem
max :: RowsfromItem -> RowsfromItem -> RowsfromItem
$cmin :: RowsfromItem -> RowsfromItem -> RowsfromItem
min :: RowsfromItem -> RowsfromItem -> RowsfromItem
Ord)

-- |
-- ==== References
-- @
-- rowsfrom_list:
--   | rowsfrom_item
--   | rowsfrom_list ',' rowsfrom_item
-- @
type RowsfromList = NonEmpty RowsfromItem

-- |
-- ==== References
-- @
-- opt_col_def_list:
--   | AS '(' TableFuncElementList ')'
--   | EMPTY
-- @
type ColDefList = TableFuncElementList

-- |
-- ==== References
-- @
-- opt_ordinality:
--   | WITH_LA ORDINALITY
--   | EMPTY
-- @
type OptOrdinality = Bool

-- |
-- ==== References
-- @
-- TableFuncElementList:
--   | TableFuncElement
--   | TableFuncElementList ',' TableFuncElement
-- @
type TableFuncElementList = NonEmpty TableFuncElement

-- |
-- ==== References
-- @
-- TableFuncElement:
--   | ColId Typename opt_collate_clause
-- @
data TableFuncElement = TableFuncElement ColId Typename (Maybe CollateClause)
  deriving (Int -> TableFuncElement -> ShowS
[TableFuncElement] -> ShowS
TableFuncElement -> String
(Int -> TableFuncElement -> ShowS)
-> (TableFuncElement -> String)
-> ([TableFuncElement] -> ShowS)
-> Show TableFuncElement
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TableFuncElement -> ShowS
showsPrec :: Int -> TableFuncElement -> ShowS
$cshow :: TableFuncElement -> String
show :: TableFuncElement -> String
$cshowList :: [TableFuncElement] -> ShowS
showList :: [TableFuncElement] -> ShowS
Show, (forall x. TableFuncElement -> Rep TableFuncElement x)
-> (forall x. Rep TableFuncElement x -> TableFuncElement)
-> Generic TableFuncElement
forall x. Rep TableFuncElement x -> TableFuncElement
forall x. TableFuncElement -> Rep TableFuncElement x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. TableFuncElement -> Rep TableFuncElement x
from :: forall x. TableFuncElement -> Rep TableFuncElement x
$cto :: forall x. Rep TableFuncElement x -> TableFuncElement
to :: forall x. Rep TableFuncElement x -> TableFuncElement
Generic, TableFuncElement -> TableFuncElement -> Bool
(TableFuncElement -> TableFuncElement -> Bool)
-> (TableFuncElement -> TableFuncElement -> Bool)
-> Eq TableFuncElement
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TableFuncElement -> TableFuncElement -> Bool
== :: TableFuncElement -> TableFuncElement -> Bool
$c/= :: TableFuncElement -> TableFuncElement -> Bool
/= :: TableFuncElement -> TableFuncElement -> Bool
Eq, Eq TableFuncElement
Eq TableFuncElement =>
(TableFuncElement -> TableFuncElement -> Ordering)
-> (TableFuncElement -> TableFuncElement -> Bool)
-> (TableFuncElement -> TableFuncElement -> Bool)
-> (TableFuncElement -> TableFuncElement -> Bool)
-> (TableFuncElement -> TableFuncElement -> Bool)
-> (TableFuncElement -> TableFuncElement -> TableFuncElement)
-> (TableFuncElement -> TableFuncElement -> TableFuncElement)
-> Ord TableFuncElement
TableFuncElement -> TableFuncElement -> Bool
TableFuncElement -> TableFuncElement -> Ordering
TableFuncElement -> TableFuncElement -> TableFuncElement
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
$ccompare :: TableFuncElement -> TableFuncElement -> Ordering
compare :: TableFuncElement -> TableFuncElement -> Ordering
$c< :: TableFuncElement -> TableFuncElement -> Bool
< :: TableFuncElement -> TableFuncElement -> Bool
$c<= :: TableFuncElement -> TableFuncElement -> Bool
<= :: TableFuncElement -> TableFuncElement -> Bool
$c> :: TableFuncElement -> TableFuncElement -> Bool
> :: TableFuncElement -> TableFuncElement -> Bool
$c>= :: TableFuncElement -> TableFuncElement -> Bool
>= :: TableFuncElement -> TableFuncElement -> Bool
$cmax :: TableFuncElement -> TableFuncElement -> TableFuncElement
max :: TableFuncElement -> TableFuncElement -> TableFuncElement
$cmin :: TableFuncElement -> TableFuncElement -> TableFuncElement
min :: TableFuncElement -> TableFuncElement -> TableFuncElement
Ord)

-- |
-- ==== References
-- @
-- opt_collate_clause:
--   | COLLATE any_name
--   | EMPTY
-- @
type CollateClause = AnyName

-- |
-- ==== References
-- @
-- alias_clause:
--   |  AS ColId '(' name_list ')'
--   |  AS ColId
--   |  ColId '(' name_list ')'
--   |  ColId
-- @
data AliasClause = AliasClause Bool ColId (Maybe NameList)
  deriving (Int -> AliasClause -> ShowS
[AliasClause] -> ShowS
AliasClause -> String
(Int -> AliasClause -> ShowS)
-> (AliasClause -> String)
-> ([AliasClause] -> ShowS)
-> Show AliasClause
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> AliasClause -> ShowS
showsPrec :: Int -> AliasClause -> ShowS
$cshow :: AliasClause -> String
show :: AliasClause -> String
$cshowList :: [AliasClause] -> ShowS
showList :: [AliasClause] -> ShowS
Show, (forall x. AliasClause -> Rep AliasClause x)
-> (forall x. Rep AliasClause x -> AliasClause)
-> Generic AliasClause
forall x. Rep AliasClause x -> AliasClause
forall x. AliasClause -> Rep AliasClause x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. AliasClause -> Rep AliasClause x
from :: forall x. AliasClause -> Rep AliasClause x
$cto :: forall x. Rep AliasClause x -> AliasClause
to :: forall x. Rep AliasClause x -> AliasClause
Generic, AliasClause -> AliasClause -> Bool
(AliasClause -> AliasClause -> Bool)
-> (AliasClause -> AliasClause -> Bool) -> Eq AliasClause
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AliasClause -> AliasClause -> Bool
== :: AliasClause -> AliasClause -> Bool
$c/= :: AliasClause -> AliasClause -> Bool
/= :: AliasClause -> AliasClause -> Bool
Eq, Eq AliasClause
Eq AliasClause =>
(AliasClause -> AliasClause -> Ordering)
-> (AliasClause -> AliasClause -> Bool)
-> (AliasClause -> AliasClause -> Bool)
-> (AliasClause -> AliasClause -> Bool)
-> (AliasClause -> AliasClause -> Bool)
-> (AliasClause -> AliasClause -> AliasClause)
-> (AliasClause -> AliasClause -> AliasClause)
-> Ord AliasClause
AliasClause -> AliasClause -> Bool
AliasClause -> AliasClause -> Ordering
AliasClause -> AliasClause -> AliasClause
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
$ccompare :: AliasClause -> AliasClause -> Ordering
compare :: AliasClause -> AliasClause -> Ordering
$c< :: AliasClause -> AliasClause -> Bool
< :: AliasClause -> AliasClause -> Bool
$c<= :: AliasClause -> AliasClause -> Bool
<= :: AliasClause -> AliasClause -> Bool
$c> :: AliasClause -> AliasClause -> Bool
> :: AliasClause -> AliasClause -> Bool
$c>= :: AliasClause -> AliasClause -> Bool
>= :: AliasClause -> AliasClause -> Bool
$cmax :: AliasClause -> AliasClause -> AliasClause
max :: AliasClause -> AliasClause -> AliasClause
$cmin :: AliasClause -> AliasClause -> AliasClause
min :: AliasClause -> AliasClause -> AliasClause
Ord)

-- |
-- ==== References
-- @
-- func_alias_clause:
--   | alias_clause
--   | AS '(' TableFuncElementList ')'
--   | AS ColId '(' TableFuncElementList ')'
--   | ColId '(' TableFuncElementList ')'
--   | EMPTY
-- @
data FuncAliasClause
  = AliasFuncAliasClause AliasClause
  | AsFuncAliasClause TableFuncElementList
  | AsColIdFuncAliasClause ColId TableFuncElementList
  | ColIdFuncAliasClause ColId TableFuncElementList
  deriving (Int -> FuncAliasClause -> ShowS
[FuncAliasClause] -> ShowS
FuncAliasClause -> String
(Int -> FuncAliasClause -> ShowS)
-> (FuncAliasClause -> String)
-> ([FuncAliasClause] -> ShowS)
-> Show FuncAliasClause
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FuncAliasClause -> ShowS
showsPrec :: Int -> FuncAliasClause -> ShowS
$cshow :: FuncAliasClause -> String
show :: FuncAliasClause -> String
$cshowList :: [FuncAliasClause] -> ShowS
showList :: [FuncAliasClause] -> ShowS
Show, (forall x. FuncAliasClause -> Rep FuncAliasClause x)
-> (forall x. Rep FuncAliasClause x -> FuncAliasClause)
-> Generic FuncAliasClause
forall x. Rep FuncAliasClause x -> FuncAliasClause
forall x. FuncAliasClause -> Rep FuncAliasClause x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. FuncAliasClause -> Rep FuncAliasClause x
from :: forall x. FuncAliasClause -> Rep FuncAliasClause x
$cto :: forall x. Rep FuncAliasClause x -> FuncAliasClause
to :: forall x. Rep FuncAliasClause x -> FuncAliasClause
Generic, FuncAliasClause -> FuncAliasClause -> Bool
(FuncAliasClause -> FuncAliasClause -> Bool)
-> (FuncAliasClause -> FuncAliasClause -> Bool)
-> Eq FuncAliasClause
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FuncAliasClause -> FuncAliasClause -> Bool
== :: FuncAliasClause -> FuncAliasClause -> Bool
$c/= :: FuncAliasClause -> FuncAliasClause -> Bool
/= :: FuncAliasClause -> FuncAliasClause -> Bool
Eq, Eq FuncAliasClause
Eq FuncAliasClause =>
(FuncAliasClause -> FuncAliasClause -> Ordering)
-> (FuncAliasClause -> FuncAliasClause -> Bool)
-> (FuncAliasClause -> FuncAliasClause -> Bool)
-> (FuncAliasClause -> FuncAliasClause -> Bool)
-> (FuncAliasClause -> FuncAliasClause -> Bool)
-> (FuncAliasClause -> FuncAliasClause -> FuncAliasClause)
-> (FuncAliasClause -> FuncAliasClause -> FuncAliasClause)
-> Ord FuncAliasClause
FuncAliasClause -> FuncAliasClause -> Bool
FuncAliasClause -> FuncAliasClause -> Ordering
FuncAliasClause -> FuncAliasClause -> FuncAliasClause
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
$ccompare :: FuncAliasClause -> FuncAliasClause -> Ordering
compare :: FuncAliasClause -> FuncAliasClause -> Ordering
$c< :: FuncAliasClause -> FuncAliasClause -> Bool
< :: FuncAliasClause -> FuncAliasClause -> Bool
$c<= :: FuncAliasClause -> FuncAliasClause -> Bool
<= :: FuncAliasClause -> FuncAliasClause -> Bool
$c> :: FuncAliasClause -> FuncAliasClause -> Bool
> :: FuncAliasClause -> FuncAliasClause -> Bool
$c>= :: FuncAliasClause -> FuncAliasClause -> Bool
>= :: FuncAliasClause -> FuncAliasClause -> Bool
$cmax :: FuncAliasClause -> FuncAliasClause -> FuncAliasClause
max :: FuncAliasClause -> FuncAliasClause -> FuncAliasClause
$cmin :: FuncAliasClause -> FuncAliasClause -> FuncAliasClause
min :: FuncAliasClause -> FuncAliasClause -> FuncAliasClause
Ord)

-- |
-- ==== References
-- @
-- | '(' joined_table ')'
-- | table_ref CROSS JOIN table_ref
-- | table_ref join_type JOIN table_ref join_qual
-- | table_ref JOIN table_ref join_qual
-- | table_ref NATURAL join_type JOIN table_ref
-- | table_ref NATURAL JOIN table_ref
--
-- The options are covered by the `JoinMeth` type.
-- @
data JoinedTable
  = InParensJoinedTable JoinedTable
  | MethJoinedTable JoinMeth TableRef TableRef
  deriving (Int -> JoinedTable -> ShowS
[JoinedTable] -> ShowS
JoinedTable -> String
(Int -> JoinedTable -> ShowS)
-> (JoinedTable -> String)
-> ([JoinedTable] -> ShowS)
-> Show JoinedTable
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> JoinedTable -> ShowS
showsPrec :: Int -> JoinedTable -> ShowS
$cshow :: JoinedTable -> String
show :: JoinedTable -> String
$cshowList :: [JoinedTable] -> ShowS
showList :: [JoinedTable] -> ShowS
Show, (forall x. JoinedTable -> Rep JoinedTable x)
-> (forall x. Rep JoinedTable x -> JoinedTable)
-> Generic JoinedTable
forall x. Rep JoinedTable x -> JoinedTable
forall x. JoinedTable -> Rep JoinedTable x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. JoinedTable -> Rep JoinedTable x
from :: forall x. JoinedTable -> Rep JoinedTable x
$cto :: forall x. Rep JoinedTable x -> JoinedTable
to :: forall x. Rep JoinedTable x -> JoinedTable
Generic, JoinedTable -> JoinedTable -> Bool
(JoinedTable -> JoinedTable -> Bool)
-> (JoinedTable -> JoinedTable -> Bool) -> Eq JoinedTable
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: JoinedTable -> JoinedTable -> Bool
== :: JoinedTable -> JoinedTable -> Bool
$c/= :: JoinedTable -> JoinedTable -> Bool
/= :: JoinedTable -> JoinedTable -> Bool
Eq, Eq JoinedTable
Eq JoinedTable =>
(JoinedTable -> JoinedTable -> Ordering)
-> (JoinedTable -> JoinedTable -> Bool)
-> (JoinedTable -> JoinedTable -> Bool)
-> (JoinedTable -> JoinedTable -> Bool)
-> (JoinedTable -> JoinedTable -> Bool)
-> (JoinedTable -> JoinedTable -> JoinedTable)
-> (JoinedTable -> JoinedTable -> JoinedTable)
-> Ord JoinedTable
JoinedTable -> JoinedTable -> Bool
JoinedTable -> JoinedTable -> Ordering
JoinedTable -> JoinedTable -> JoinedTable
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
$ccompare :: JoinedTable -> JoinedTable -> Ordering
compare :: JoinedTable -> JoinedTable -> Ordering
$c< :: JoinedTable -> JoinedTable -> Bool
< :: JoinedTable -> JoinedTable -> Bool
$c<= :: JoinedTable -> JoinedTable -> Bool
<= :: JoinedTable -> JoinedTable -> Bool
$c> :: JoinedTable -> JoinedTable -> Bool
> :: JoinedTable -> JoinedTable -> Bool
$c>= :: JoinedTable -> JoinedTable -> Bool
>= :: JoinedTable -> JoinedTable -> Bool
$cmax :: JoinedTable -> JoinedTable -> JoinedTable
max :: JoinedTable -> JoinedTable -> JoinedTable
$cmin :: JoinedTable -> JoinedTable -> JoinedTable
min :: JoinedTable -> JoinedTable -> JoinedTable
Ord)

-- |
-- ==== References
-- @
-- | table_ref CROSS JOIN table_ref
-- | table_ref join_type JOIN table_ref join_qual
-- | table_ref JOIN table_ref join_qual
-- | table_ref NATURAL join_type JOIN table_ref
-- | table_ref NATURAL JOIN table_ref
-- @
data JoinMeth
  = CrossJoinMeth
  | QualJoinMeth (Maybe JoinType) JoinQual
  | NaturalJoinMeth (Maybe JoinType)
  deriving (Int -> JoinMeth -> ShowS
[JoinMeth] -> ShowS
JoinMeth -> String
(Int -> JoinMeth -> ShowS)
-> (JoinMeth -> String) -> ([JoinMeth] -> ShowS) -> Show JoinMeth
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> JoinMeth -> ShowS
showsPrec :: Int -> JoinMeth -> ShowS
$cshow :: JoinMeth -> String
show :: JoinMeth -> String
$cshowList :: [JoinMeth] -> ShowS
showList :: [JoinMeth] -> ShowS
Show, (forall x. JoinMeth -> Rep JoinMeth x)
-> (forall x. Rep JoinMeth x -> JoinMeth) -> Generic JoinMeth
forall x. Rep JoinMeth x -> JoinMeth
forall x. JoinMeth -> Rep JoinMeth x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. JoinMeth -> Rep JoinMeth x
from :: forall x. JoinMeth -> Rep JoinMeth x
$cto :: forall x. Rep JoinMeth x -> JoinMeth
to :: forall x. Rep JoinMeth x -> JoinMeth
Generic, JoinMeth -> JoinMeth -> Bool
(JoinMeth -> JoinMeth -> Bool)
-> (JoinMeth -> JoinMeth -> Bool) -> Eq JoinMeth
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: JoinMeth -> JoinMeth -> Bool
== :: JoinMeth -> JoinMeth -> Bool
$c/= :: JoinMeth -> JoinMeth -> Bool
/= :: JoinMeth -> JoinMeth -> Bool
Eq, Eq JoinMeth
Eq JoinMeth =>
(JoinMeth -> JoinMeth -> Ordering)
-> (JoinMeth -> JoinMeth -> Bool)
-> (JoinMeth -> JoinMeth -> Bool)
-> (JoinMeth -> JoinMeth -> Bool)
-> (JoinMeth -> JoinMeth -> Bool)
-> (JoinMeth -> JoinMeth -> JoinMeth)
-> (JoinMeth -> JoinMeth -> JoinMeth)
-> Ord JoinMeth
JoinMeth -> JoinMeth -> Bool
JoinMeth -> JoinMeth -> Ordering
JoinMeth -> JoinMeth -> JoinMeth
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
$ccompare :: JoinMeth -> JoinMeth -> Ordering
compare :: JoinMeth -> JoinMeth -> Ordering
$c< :: JoinMeth -> JoinMeth -> Bool
< :: JoinMeth -> JoinMeth -> Bool
$c<= :: JoinMeth -> JoinMeth -> Bool
<= :: JoinMeth -> JoinMeth -> Bool
$c> :: JoinMeth -> JoinMeth -> Bool
> :: JoinMeth -> JoinMeth -> Bool
$c>= :: JoinMeth -> JoinMeth -> Bool
>= :: JoinMeth -> JoinMeth -> Bool
$cmax :: JoinMeth -> JoinMeth -> JoinMeth
max :: JoinMeth -> JoinMeth -> JoinMeth
$cmin :: JoinMeth -> JoinMeth -> JoinMeth
min :: JoinMeth -> JoinMeth -> JoinMeth
Ord)

-- |
-- ==== References
-- @
-- | FULL join_outer
-- | LEFT join_outer
-- | RIGHT join_outer
-- | INNER_P
-- @
data JoinType
  = FullJoinType Bool
  | LeftJoinType Bool
  | RightJoinType Bool
  | InnerJoinType
  deriving (Int -> JoinType -> ShowS
[JoinType] -> ShowS
JoinType -> String
(Int -> JoinType -> ShowS)
-> (JoinType -> String) -> ([JoinType] -> ShowS) -> Show JoinType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> JoinType -> ShowS
showsPrec :: Int -> JoinType -> ShowS
$cshow :: JoinType -> String
show :: JoinType -> String
$cshowList :: [JoinType] -> ShowS
showList :: [JoinType] -> ShowS
Show, (forall x. JoinType -> Rep JoinType x)
-> (forall x. Rep JoinType x -> JoinType) -> Generic JoinType
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
$cfrom :: forall x. JoinType -> Rep JoinType x
from :: forall x. JoinType -> Rep JoinType x
$cto :: forall x. Rep JoinType x -> JoinType
to :: forall x. Rep JoinType x -> JoinType
Generic, JoinType -> JoinType -> Bool
(JoinType -> JoinType -> Bool)
-> (JoinType -> JoinType -> Bool) -> Eq JoinType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: JoinType -> JoinType -> Bool
== :: JoinType -> JoinType -> Bool
$c/= :: JoinType -> JoinType -> Bool
/= :: JoinType -> JoinType -> Bool
Eq, Eq JoinType
Eq JoinType =>
(JoinType -> JoinType -> Ordering)
-> (JoinType -> JoinType -> Bool)
-> (JoinType -> JoinType -> Bool)
-> (JoinType -> JoinType -> Bool)
-> (JoinType -> JoinType -> Bool)
-> (JoinType -> JoinType -> JoinType)
-> (JoinType -> JoinType -> JoinType)
-> Ord JoinType
JoinType -> JoinType -> Bool
JoinType -> JoinType -> Ordering
JoinType -> JoinType -> JoinType
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
$ccompare :: JoinType -> JoinType -> Ordering
compare :: JoinType -> JoinType -> Ordering
$c< :: JoinType -> JoinType -> Bool
< :: JoinType -> JoinType -> Bool
$c<= :: JoinType -> JoinType -> Bool
<= :: JoinType -> JoinType -> Bool
$c> :: JoinType -> JoinType -> Bool
> :: JoinType -> JoinType -> Bool
$c>= :: JoinType -> JoinType -> Bool
>= :: JoinType -> JoinType -> Bool
$cmax :: JoinType -> JoinType -> JoinType
max :: JoinType -> JoinType -> JoinType
$cmin :: JoinType -> JoinType -> JoinType
min :: JoinType -> JoinType -> JoinType
Ord)

-- |
-- ==== References
-- @
-- join_qual:
--   |  USING '(' name_list ')'
--   |  ON a_expr
-- @
data JoinQual
  = UsingJoinQual (NonEmpty Ident)
  | OnJoinQual AExpr
  deriving (Int -> JoinQual -> ShowS
[JoinQual] -> ShowS
JoinQual -> String
(Int -> JoinQual -> ShowS)
-> (JoinQual -> String) -> ([JoinQual] -> ShowS) -> Show JoinQual
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> JoinQual -> ShowS
showsPrec :: Int -> JoinQual -> ShowS
$cshow :: JoinQual -> String
show :: JoinQual -> String
$cshowList :: [JoinQual] -> ShowS
showList :: [JoinQual] -> ShowS
Show, (forall x. JoinQual -> Rep JoinQual x)
-> (forall x. Rep JoinQual x -> JoinQual) -> Generic JoinQual
forall x. Rep JoinQual x -> JoinQual
forall x. JoinQual -> Rep JoinQual x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. JoinQual -> Rep JoinQual x
from :: forall x. JoinQual -> Rep JoinQual x
$cto :: forall x. Rep JoinQual x -> JoinQual
to :: forall x. Rep JoinQual x -> JoinQual
Generic, JoinQual -> JoinQual -> Bool
(JoinQual -> JoinQual -> Bool)
-> (JoinQual -> JoinQual -> Bool) -> Eq JoinQual
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: JoinQual -> JoinQual -> Bool
== :: JoinQual -> JoinQual -> Bool
$c/= :: JoinQual -> JoinQual -> Bool
/= :: JoinQual -> JoinQual -> Bool
Eq, Eq JoinQual
Eq JoinQual =>
(JoinQual -> JoinQual -> Ordering)
-> (JoinQual -> JoinQual -> Bool)
-> (JoinQual -> JoinQual -> Bool)
-> (JoinQual -> JoinQual -> Bool)
-> (JoinQual -> JoinQual -> Bool)
-> (JoinQual -> JoinQual -> JoinQual)
-> (JoinQual -> JoinQual -> JoinQual)
-> Ord JoinQual
JoinQual -> JoinQual -> Bool
JoinQual -> JoinQual -> Ordering
JoinQual -> JoinQual -> JoinQual
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
$ccompare :: JoinQual -> JoinQual -> Ordering
compare :: JoinQual -> JoinQual -> Ordering
$c< :: JoinQual -> JoinQual -> Bool
< :: JoinQual -> JoinQual -> Bool
$c<= :: JoinQual -> JoinQual -> Bool
<= :: JoinQual -> JoinQual -> Bool
$c> :: JoinQual -> JoinQual -> Bool
> :: JoinQual -> JoinQual -> Bool
$c>= :: JoinQual -> JoinQual -> Bool
>= :: JoinQual -> JoinQual -> Bool
$cmax :: JoinQual -> JoinQual -> JoinQual
max :: JoinQual -> JoinQual -> JoinQual
$cmin :: JoinQual -> JoinQual -> JoinQual
min :: JoinQual -> JoinQual -> JoinQual
Ord)

-- * Where

type WhereClause = AExpr

-- |
-- ==== References
-- @
-- | WHERE a_expr
-- | WHERE CURRENT_P OF cursor_name
-- | /*EMPTY*/
-- @
data WhereOrCurrentClause
  = ExprWhereOrCurrentClause AExpr
  | CursorWhereOrCurrentClause CursorName
  deriving (Int -> WhereOrCurrentClause -> ShowS
[WhereOrCurrentClause] -> ShowS
WhereOrCurrentClause -> String
(Int -> WhereOrCurrentClause -> ShowS)
-> (WhereOrCurrentClause -> String)
-> ([WhereOrCurrentClause] -> ShowS)
-> Show WhereOrCurrentClause
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> WhereOrCurrentClause -> ShowS
showsPrec :: Int -> WhereOrCurrentClause -> ShowS
$cshow :: WhereOrCurrentClause -> String
show :: WhereOrCurrentClause -> String
$cshowList :: [WhereOrCurrentClause] -> ShowS
showList :: [WhereOrCurrentClause] -> ShowS
Show, (forall x. WhereOrCurrentClause -> Rep WhereOrCurrentClause x)
-> (forall x. Rep WhereOrCurrentClause x -> WhereOrCurrentClause)
-> Generic WhereOrCurrentClause
forall x. Rep WhereOrCurrentClause x -> WhereOrCurrentClause
forall x. WhereOrCurrentClause -> Rep WhereOrCurrentClause x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. WhereOrCurrentClause -> Rep WhereOrCurrentClause x
from :: forall x. WhereOrCurrentClause -> Rep WhereOrCurrentClause x
$cto :: forall x. Rep WhereOrCurrentClause x -> WhereOrCurrentClause
to :: forall x. Rep WhereOrCurrentClause x -> WhereOrCurrentClause
Generic, WhereOrCurrentClause -> WhereOrCurrentClause -> Bool
(WhereOrCurrentClause -> WhereOrCurrentClause -> Bool)
-> (WhereOrCurrentClause -> WhereOrCurrentClause -> Bool)
-> Eq WhereOrCurrentClause
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: WhereOrCurrentClause -> WhereOrCurrentClause -> Bool
== :: WhereOrCurrentClause -> WhereOrCurrentClause -> Bool
$c/= :: WhereOrCurrentClause -> WhereOrCurrentClause -> Bool
/= :: WhereOrCurrentClause -> WhereOrCurrentClause -> Bool
Eq, Eq WhereOrCurrentClause
Eq WhereOrCurrentClause =>
(WhereOrCurrentClause -> WhereOrCurrentClause -> Ordering)
-> (WhereOrCurrentClause -> WhereOrCurrentClause -> Bool)
-> (WhereOrCurrentClause -> WhereOrCurrentClause -> Bool)
-> (WhereOrCurrentClause -> WhereOrCurrentClause -> Bool)
-> (WhereOrCurrentClause -> WhereOrCurrentClause -> Bool)
-> (WhereOrCurrentClause
    -> WhereOrCurrentClause -> WhereOrCurrentClause)
-> (WhereOrCurrentClause
    -> WhereOrCurrentClause -> WhereOrCurrentClause)
-> Ord WhereOrCurrentClause
WhereOrCurrentClause -> WhereOrCurrentClause -> Bool
WhereOrCurrentClause -> WhereOrCurrentClause -> Ordering
WhereOrCurrentClause
-> WhereOrCurrentClause -> WhereOrCurrentClause
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
$ccompare :: WhereOrCurrentClause -> WhereOrCurrentClause -> Ordering
compare :: WhereOrCurrentClause -> WhereOrCurrentClause -> Ordering
$c< :: WhereOrCurrentClause -> WhereOrCurrentClause -> Bool
< :: WhereOrCurrentClause -> WhereOrCurrentClause -> Bool
$c<= :: WhereOrCurrentClause -> WhereOrCurrentClause -> Bool
<= :: WhereOrCurrentClause -> WhereOrCurrentClause -> Bool
$c> :: WhereOrCurrentClause -> WhereOrCurrentClause -> Bool
> :: WhereOrCurrentClause -> WhereOrCurrentClause -> Bool
$c>= :: WhereOrCurrentClause -> WhereOrCurrentClause -> Bool
>= :: WhereOrCurrentClause -> WhereOrCurrentClause -> Bool
$cmax :: WhereOrCurrentClause
-> WhereOrCurrentClause -> WhereOrCurrentClause
max :: WhereOrCurrentClause
-> WhereOrCurrentClause -> WhereOrCurrentClause
$cmin :: WhereOrCurrentClause
-> WhereOrCurrentClause -> WhereOrCurrentClause
min :: WhereOrCurrentClause
-> WhereOrCurrentClause -> WhereOrCurrentClause
Ord)

-- * Expression

type ExprList = NonEmpty AExpr

-- |
-- ==== References
-- @
-- a_expr:
--   | c_expr
--   | a_expr TYPECAST Typename
--   | a_expr COLLATE any_name
--   | a_expr AT TIME ZONE a_expr
--   | '+' a_expr
--   | '-' a_expr
--   | a_expr '+' a_expr
--   | a_expr '-' a_expr
--   | a_expr '*' a_expr
--   | a_expr '/' a_expr
--   | a_expr '%' a_expr
--   | a_expr '^' a_expr
--   | a_expr '<' a_expr
--   | a_expr '>' a_expr
--   | a_expr '=' a_expr
--   | a_expr LESS_EQUALS a_expr
--   | a_expr GREATER_EQUALS a_expr
--   | a_expr NOT_EQUALS a_expr
--   | a_expr qual_Op a_expr
--   | qual_Op a_expr
--   | a_expr qual_Op
--   | a_expr AND a_expr
--   | a_expr OR a_expr
--   | NOT a_expr
--   | NOT_LA a_expr
--   | a_expr LIKE a_expr
--   | a_expr LIKE a_expr ESCAPE a_expr
--   | a_expr NOT_LA LIKE a_expr
--   | a_expr NOT_LA LIKE a_expr ESCAPE a_expr
--   | a_expr ILIKE a_expr
--   | a_expr ILIKE a_expr ESCAPE a_expr
--   | a_expr NOT_LA ILIKE a_expr
--   | a_expr NOT_LA ILIKE a_expr ESCAPE a_expr
--   | a_expr SIMILAR TO a_expr
--   | a_expr SIMILAR TO a_expr ESCAPE a_expr
--   | a_expr NOT_LA SIMILAR TO a_expr
--   | a_expr NOT_LA SIMILAR TO a_expr ESCAPE a_expr
--   | a_expr IS NULL_P
--   | a_expr ISNULL
--   | a_expr IS NOT NULL_P
--   | a_expr NOTNULL
--   | row OVERLAPS row
--   | a_expr IS TRUE_P
--   | a_expr IS NOT TRUE_P
--   | a_expr IS FALSE_P
--   | a_expr IS NOT FALSE_P
--   | a_expr IS UNKNOWN
--   | a_expr IS NOT UNKNOWN
--   | a_expr IS DISTINCT FROM a_expr
--   | a_expr IS NOT DISTINCT FROM a_expr
--   | a_expr IS OF '(' type_list ')'
--   | a_expr IS NOT OF '(' type_list ')'
--   | a_expr BETWEEN opt_asymmetric b_expr AND a_expr
--   | a_expr NOT_LA BETWEEN opt_asymmetric b_expr AND a_expr
--   | a_expr BETWEEN SYMMETRIC b_expr AND a_expr
--   | a_expr NOT_LA BETWEEN SYMMETRIC b_expr AND a_expr
--   | a_expr IN_P in_expr
--   | a_expr NOT_LA IN_P in_expr
--   | a_expr subquery_Op sub_type select_with_parens
--   | a_expr subquery_Op sub_type '(' a_expr ')'
--   | UNIQUE select_with_parens
--   | a_expr IS DOCUMENT_P
--   | a_expr IS NOT DOCUMENT_P
--   | DEFAULT
-- @
data AExpr
  = CExprAExpr CExpr
  | TypecastAExpr AExpr Typename
  | CollateAExpr AExpr AnyName
  | AtTimeZoneAExpr AExpr AExpr
  | PlusAExpr AExpr
  | MinusAExpr AExpr
  | SymbolicBinOpAExpr AExpr SymbolicExprBinOp AExpr
  | PrefixQualOpAExpr QualOp AExpr
  | SuffixQualOpAExpr AExpr QualOp
  | AndAExpr AExpr AExpr
  | OrAExpr AExpr AExpr
  | NotAExpr AExpr
  | VerbalExprBinOpAExpr AExpr Bool VerbalExprBinOp AExpr (Maybe AExpr)
  | ReversableOpAExpr AExpr Bool AExprReversableOp
  | IsnullAExpr AExpr
  | NotnullAExpr AExpr
  | OverlapsAExpr Row Row
  | SubqueryAExpr AExpr SubqueryOp SubType (Either SelectWithParens AExpr)
  | UniqueAExpr SelectWithParens
  | DefaultAExpr
  deriving (Int -> WhereClause -> ShowS
[WhereClause] -> ShowS
WhereClause -> String
(Int -> WhereClause -> ShowS)
-> (WhereClause -> String)
-> ([WhereClause] -> ShowS)
-> Show WhereClause
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> WhereClause -> ShowS
showsPrec :: Int -> WhereClause -> ShowS
$cshow :: WhereClause -> String
show :: WhereClause -> String
$cshowList :: [WhereClause] -> ShowS
showList :: [WhereClause] -> ShowS
Show, (forall x. WhereClause -> Rep WhereClause x)
-> (forall x. Rep WhereClause x -> WhereClause)
-> Generic WhereClause
forall x. Rep WhereClause x -> WhereClause
forall x. WhereClause -> Rep WhereClause x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. WhereClause -> Rep WhereClause x
from :: forall x. WhereClause -> Rep WhereClause x
$cto :: forall x. Rep WhereClause x -> WhereClause
to :: forall x. Rep WhereClause x -> WhereClause
Generic, WhereClause -> WhereClause -> Bool
(WhereClause -> WhereClause -> Bool)
-> (WhereClause -> WhereClause -> Bool) -> Eq WhereClause
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: WhereClause -> WhereClause -> Bool
== :: WhereClause -> WhereClause -> Bool
$c/= :: WhereClause -> WhereClause -> Bool
/= :: WhereClause -> WhereClause -> Bool
Eq, Eq WhereClause
Eq WhereClause =>
(WhereClause -> WhereClause -> Ordering)
-> (WhereClause -> WhereClause -> Bool)
-> (WhereClause -> WhereClause -> Bool)
-> (WhereClause -> WhereClause -> Bool)
-> (WhereClause -> WhereClause -> Bool)
-> (WhereClause -> WhereClause -> WhereClause)
-> (WhereClause -> WhereClause -> WhereClause)
-> Ord WhereClause
WhereClause -> WhereClause -> Bool
WhereClause -> WhereClause -> Ordering
WhereClause -> WhereClause -> WhereClause
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
$ccompare :: WhereClause -> WhereClause -> Ordering
compare :: WhereClause -> WhereClause -> Ordering
$c< :: WhereClause -> WhereClause -> Bool
< :: WhereClause -> WhereClause -> Bool
$c<= :: WhereClause -> WhereClause -> Bool
<= :: WhereClause -> WhereClause -> Bool
$c> :: WhereClause -> WhereClause -> Bool
> :: WhereClause -> WhereClause -> Bool
$c>= :: WhereClause -> WhereClause -> Bool
>= :: WhereClause -> WhereClause -> Bool
$cmax :: WhereClause -> WhereClause -> WhereClause
max :: WhereClause -> WhereClause -> WhereClause
$cmin :: WhereClause -> WhereClause -> WhereClause
min :: WhereClause -> WhereClause -> WhereClause
Ord)

-- |
-- ==== References
-- @
-- b_expr:
--   | c_expr
--   | b_expr TYPECAST Typename
--   | '+' b_expr
--   | '-' b_expr
--   | b_expr '+' b_expr
--   | b_expr '-' b_expr
--   | b_expr '*' b_expr
--   | b_expr '/' b_expr
--   | b_expr '%' b_expr
--   | b_expr '^' b_expr
--   | b_expr '<' b_expr
--   | b_expr '>' b_expr
--   | b_expr '=' b_expr
--   | b_expr LESS_EQUALS b_expr
--   | b_expr GREATER_EQUALS b_expr
--   | b_expr NOT_EQUALS b_expr
--   | b_expr qual_Op b_expr
--   | qual_Op b_expr
--   | b_expr qual_Op
--   | b_expr IS DISTINCT FROM b_expr
--   | b_expr IS NOT DISTINCT FROM b_expr
--   | b_expr IS OF '(' type_list ')'
--   | b_expr IS NOT OF '(' type_list ')'
--   | b_expr IS DOCUMENT_P
--   | b_expr IS NOT DOCUMENT_P
-- @
data BExpr
  = CExprBExpr CExpr
  | TypecastBExpr BExpr Typename
  | PlusBExpr BExpr
  | MinusBExpr BExpr
  | SymbolicBinOpBExpr BExpr SymbolicExprBinOp BExpr
  | QualOpBExpr QualOp BExpr
  | IsOpBExpr BExpr Bool BExprIsOp
  deriving (Int -> BExpr -> ShowS
[BExpr] -> ShowS
BExpr -> String
(Int -> BExpr -> ShowS)
-> (BExpr -> String) -> ([BExpr] -> ShowS) -> Show BExpr
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BExpr -> ShowS
showsPrec :: Int -> BExpr -> ShowS
$cshow :: BExpr -> String
show :: BExpr -> String
$cshowList :: [BExpr] -> ShowS
showList :: [BExpr] -> ShowS
Show, (forall x. BExpr -> Rep BExpr x)
-> (forall x. Rep BExpr x -> BExpr) -> Generic BExpr
forall x. Rep BExpr x -> BExpr
forall x. BExpr -> Rep BExpr x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. BExpr -> Rep BExpr x
from :: forall x. BExpr -> Rep BExpr x
$cto :: forall x. Rep BExpr x -> BExpr
to :: forall x. Rep BExpr x -> BExpr
Generic, BExpr -> BExpr -> Bool
(BExpr -> BExpr -> Bool) -> (BExpr -> BExpr -> Bool) -> Eq BExpr
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BExpr -> BExpr -> Bool
== :: BExpr -> BExpr -> Bool
$c/= :: BExpr -> BExpr -> Bool
/= :: BExpr -> BExpr -> Bool
Eq, Eq BExpr
Eq BExpr =>
(BExpr -> BExpr -> Ordering)
-> (BExpr -> BExpr -> Bool)
-> (BExpr -> BExpr -> Bool)
-> (BExpr -> BExpr -> Bool)
-> (BExpr -> BExpr -> Bool)
-> (BExpr -> BExpr -> BExpr)
-> (BExpr -> BExpr -> BExpr)
-> Ord BExpr
BExpr -> BExpr -> Bool
BExpr -> BExpr -> Ordering
BExpr -> BExpr -> BExpr
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
$ccompare :: BExpr -> BExpr -> Ordering
compare :: BExpr -> BExpr -> Ordering
$c< :: BExpr -> BExpr -> Bool
< :: BExpr -> BExpr -> Bool
$c<= :: BExpr -> BExpr -> Bool
<= :: BExpr -> BExpr -> Bool
$c> :: BExpr -> BExpr -> Bool
> :: BExpr -> BExpr -> Bool
$c>= :: BExpr -> BExpr -> Bool
>= :: BExpr -> BExpr -> Bool
$cmax :: BExpr -> BExpr -> BExpr
max :: BExpr -> BExpr -> BExpr
$cmin :: BExpr -> BExpr -> BExpr
min :: BExpr -> BExpr -> BExpr
Ord)

-- |
-- ==== References
-- @
-- c_expr:
--   | columnref
--   | AexprConst
--   | PARAM opt_indirection
--   | '(' a_expr ')' opt_indirection
--   | case_expr
--   | func_expr
--   | select_with_parens
--   | select_with_parens indirection
--   | EXISTS select_with_parens
--   | ARRAY select_with_parens
--   | ARRAY array_expr
--   | explicit_row
--   | implicit_row
--   | GROUPING '(' expr_list ')'
-- @
data CExpr
  = ColumnrefCExpr Columnref
  | AexprConstCExpr AexprConst
  | ParamCExpr Int (Maybe Indirection)
  | InParensCExpr AExpr (Maybe Indirection)
  | CaseCExpr CaseExpr
  | FuncCExpr FuncExpr
  | SelectWithParensCExpr SelectWithParens (Maybe Indirection)
  | ExistsCExpr SelectWithParens
  | ArrayCExpr (Either SelectWithParens ArrayExpr)
  | ExplicitRowCExpr ExplicitRow
  | ImplicitRowCExpr ImplicitRow
  | GroupingCExpr ExprList
  deriving (Int -> CExpr -> ShowS
[CExpr] -> ShowS
CExpr -> String
(Int -> CExpr -> ShowS)
-> (CExpr -> String) -> ([CExpr] -> ShowS) -> Show CExpr
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CExpr -> ShowS
showsPrec :: Int -> CExpr -> ShowS
$cshow :: CExpr -> String
show :: CExpr -> String
$cshowList :: [CExpr] -> ShowS
showList :: [CExpr] -> ShowS
Show, (forall x. CExpr -> Rep CExpr x)
-> (forall x. Rep CExpr x -> CExpr) -> Generic CExpr
forall x. Rep CExpr x -> CExpr
forall x. CExpr -> Rep CExpr x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. CExpr -> Rep CExpr x
from :: forall x. CExpr -> Rep CExpr x
$cto :: forall x. Rep CExpr x -> CExpr
to :: forall x. Rep CExpr x -> CExpr
Generic, CExpr -> CExpr -> Bool
(CExpr -> CExpr -> Bool) -> (CExpr -> CExpr -> Bool) -> Eq CExpr
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CExpr -> CExpr -> Bool
== :: CExpr -> CExpr -> Bool
$c/= :: CExpr -> CExpr -> Bool
/= :: CExpr -> CExpr -> Bool
Eq, Eq CExpr
Eq CExpr =>
(CExpr -> CExpr -> Ordering)
-> (CExpr -> CExpr -> Bool)
-> (CExpr -> CExpr -> Bool)
-> (CExpr -> CExpr -> Bool)
-> (CExpr -> CExpr -> Bool)
-> (CExpr -> CExpr -> CExpr)
-> (CExpr -> CExpr -> CExpr)
-> Ord CExpr
CExpr -> CExpr -> Bool
CExpr -> CExpr -> Ordering
CExpr -> CExpr -> CExpr
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
$ccompare :: CExpr -> CExpr -> Ordering
compare :: CExpr -> CExpr -> Ordering
$c< :: CExpr -> CExpr -> Bool
< :: CExpr -> CExpr -> Bool
$c<= :: CExpr -> CExpr -> Bool
<= :: CExpr -> CExpr -> Bool
$c> :: CExpr -> CExpr -> Bool
> :: CExpr -> CExpr -> Bool
$c>= :: CExpr -> CExpr -> Bool
>= :: CExpr -> CExpr -> Bool
$cmax :: CExpr -> CExpr -> CExpr
max :: CExpr -> CExpr -> CExpr
$cmin :: CExpr -> CExpr -> CExpr
min :: CExpr -> CExpr -> CExpr
Ord)

-- |
-- ==== References
-- @
-- in_expr:
--   | select_with_parens
--   | '(' expr_list ')'
-- @
data InExpr
  = SelectInExpr SelectWithParens
  | ExprListInExpr ExprList
  deriving (Int -> InExpr -> ShowS
[InExpr] -> ShowS
InExpr -> String
(Int -> InExpr -> ShowS)
-> (InExpr -> String) -> ([InExpr] -> ShowS) -> Show InExpr
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> InExpr -> ShowS
showsPrec :: Int -> InExpr -> ShowS
$cshow :: InExpr -> String
show :: InExpr -> String
$cshowList :: [InExpr] -> ShowS
showList :: [InExpr] -> ShowS
Show, (forall x. InExpr -> Rep InExpr x)
-> (forall x. Rep InExpr x -> InExpr) -> Generic InExpr
forall x. Rep InExpr x -> InExpr
forall x. InExpr -> Rep InExpr x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. InExpr -> Rep InExpr x
from :: forall x. InExpr -> Rep InExpr x
$cto :: forall x. Rep InExpr x -> InExpr
to :: forall x. Rep InExpr x -> InExpr
Generic, InExpr -> InExpr -> Bool
(InExpr -> InExpr -> Bool)
-> (InExpr -> InExpr -> Bool) -> Eq InExpr
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: InExpr -> InExpr -> Bool
== :: InExpr -> InExpr -> Bool
$c/= :: InExpr -> InExpr -> Bool
/= :: InExpr -> InExpr -> Bool
Eq, Eq InExpr
Eq InExpr =>
(InExpr -> InExpr -> Ordering)
-> (InExpr -> InExpr -> Bool)
-> (InExpr -> InExpr -> Bool)
-> (InExpr -> InExpr -> Bool)
-> (InExpr -> InExpr -> Bool)
-> (InExpr -> InExpr -> InExpr)
-> (InExpr -> InExpr -> InExpr)
-> Ord InExpr
InExpr -> InExpr -> Bool
InExpr -> InExpr -> Ordering
InExpr -> InExpr -> InExpr
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
$ccompare :: InExpr -> InExpr -> Ordering
compare :: InExpr -> InExpr -> Ordering
$c< :: InExpr -> InExpr -> Bool
< :: InExpr -> InExpr -> Bool
$c<= :: InExpr -> InExpr -> Bool
<= :: InExpr -> InExpr -> Bool
$c> :: InExpr -> InExpr -> Bool
> :: InExpr -> InExpr -> Bool
$c>= :: InExpr -> InExpr -> Bool
>= :: InExpr -> InExpr -> Bool
$cmax :: InExpr -> InExpr -> InExpr
max :: InExpr -> InExpr -> InExpr
$cmin :: InExpr -> InExpr -> InExpr
min :: InExpr -> InExpr -> InExpr
Ord)

-- |
-- ==== References
-- @
-- sub_type:
--   | ANY
--   | SOME
--   | ALL
-- @
data SubType = AnySubType | SomeSubType | AllSubType
  deriving (Int -> SubType -> ShowS
[SubType] -> ShowS
SubType -> String
(Int -> SubType -> ShowS)
-> (SubType -> String) -> ([SubType] -> ShowS) -> Show SubType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SubType -> ShowS
showsPrec :: Int -> SubType -> ShowS
$cshow :: SubType -> String
show :: SubType -> String
$cshowList :: [SubType] -> ShowS
showList :: [SubType] -> ShowS
Show, (forall x. SubType -> Rep SubType x)
-> (forall x. Rep SubType x -> SubType) -> Generic SubType
forall x. Rep SubType x -> SubType
forall x. SubType -> Rep SubType x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. SubType -> Rep SubType x
from :: forall x. SubType -> Rep SubType x
$cto :: forall x. Rep SubType x -> SubType
to :: forall x. Rep SubType x -> SubType
Generic, SubType -> SubType -> Bool
(SubType -> SubType -> Bool)
-> (SubType -> SubType -> Bool) -> Eq SubType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SubType -> SubType -> Bool
== :: SubType -> SubType -> Bool
$c/= :: SubType -> SubType -> Bool
/= :: SubType -> SubType -> Bool
Eq, Eq SubType
Eq SubType =>
(SubType -> SubType -> Ordering)
-> (SubType -> SubType -> Bool)
-> (SubType -> SubType -> Bool)
-> (SubType -> SubType -> Bool)
-> (SubType -> SubType -> Bool)
-> (SubType -> SubType -> SubType)
-> (SubType -> SubType -> SubType)
-> Ord SubType
SubType -> SubType -> Bool
SubType -> SubType -> Ordering
SubType -> SubType -> SubType
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
$ccompare :: SubType -> SubType -> Ordering
compare :: SubType -> SubType -> Ordering
$c< :: SubType -> SubType -> Bool
< :: SubType -> SubType -> Bool
$c<= :: SubType -> SubType -> Bool
<= :: SubType -> SubType -> Bool
$c> :: SubType -> SubType -> Bool
> :: SubType -> SubType -> Bool
$c>= :: SubType -> SubType -> Bool
>= :: SubType -> SubType -> Bool
$cmax :: SubType -> SubType -> SubType
max :: SubType -> SubType -> SubType
$cmin :: SubType -> SubType -> SubType
min :: SubType -> SubType -> SubType
Ord, Int -> SubType
SubType -> Int
SubType -> [SubType]
SubType -> SubType
SubType -> SubType -> [SubType]
SubType -> SubType -> SubType -> [SubType]
(SubType -> SubType)
-> (SubType -> SubType)
-> (Int -> SubType)
-> (SubType -> Int)
-> (SubType -> [SubType])
-> (SubType -> SubType -> [SubType])
-> (SubType -> SubType -> [SubType])
-> (SubType -> SubType -> SubType -> [SubType])
-> Enum SubType
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: SubType -> SubType
succ :: SubType -> SubType
$cpred :: SubType -> SubType
pred :: SubType -> SubType
$ctoEnum :: Int -> SubType
toEnum :: Int -> SubType
$cfromEnum :: SubType -> Int
fromEnum :: SubType -> Int
$cenumFrom :: SubType -> [SubType]
enumFrom :: SubType -> [SubType]
$cenumFromThen :: SubType -> SubType -> [SubType]
enumFromThen :: SubType -> SubType -> [SubType]
$cenumFromTo :: SubType -> SubType -> [SubType]
enumFromTo :: SubType -> SubType -> [SubType]
$cenumFromThenTo :: SubType -> SubType -> SubType -> [SubType]
enumFromThenTo :: SubType -> SubType -> SubType -> [SubType]
Enum, SubType
SubType -> SubType -> Bounded SubType
forall a. a -> a -> Bounded a
$cminBound :: SubType
minBound :: SubType
$cmaxBound :: SubType
maxBound :: SubType
Bounded)

-- |
-- ==== References
-- @
-- array_expr:
--   | '[' expr_list ']'
--   | '[' array_expr_list ']'
--   | '[' ']'
-- @
data ArrayExpr
  = ExprListArrayExpr ExprList
  | ArrayExprListArrayExpr ArrayExprList
  | EmptyArrayExpr
  deriving (Int -> ArrayExpr -> ShowS
[ArrayExpr] -> ShowS
ArrayExpr -> String
(Int -> ArrayExpr -> ShowS)
-> (ArrayExpr -> String)
-> ([ArrayExpr] -> ShowS)
-> Show ArrayExpr
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ArrayExpr -> ShowS
showsPrec :: Int -> ArrayExpr -> ShowS
$cshow :: ArrayExpr -> String
show :: ArrayExpr -> String
$cshowList :: [ArrayExpr] -> ShowS
showList :: [ArrayExpr] -> ShowS
Show, (forall x. ArrayExpr -> Rep ArrayExpr x)
-> (forall x. Rep ArrayExpr x -> ArrayExpr) -> Generic ArrayExpr
forall x. Rep ArrayExpr x -> ArrayExpr
forall x. ArrayExpr -> Rep ArrayExpr x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ArrayExpr -> Rep ArrayExpr x
from :: forall x. ArrayExpr -> Rep ArrayExpr x
$cto :: forall x. Rep ArrayExpr x -> ArrayExpr
to :: forall x. Rep ArrayExpr x -> ArrayExpr
Generic, ArrayExpr -> ArrayExpr -> Bool
(ArrayExpr -> ArrayExpr -> Bool)
-> (ArrayExpr -> ArrayExpr -> Bool) -> Eq ArrayExpr
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ArrayExpr -> ArrayExpr -> Bool
== :: ArrayExpr -> ArrayExpr -> Bool
$c/= :: ArrayExpr -> ArrayExpr -> Bool
/= :: ArrayExpr -> ArrayExpr -> Bool
Eq, Eq ArrayExpr
Eq ArrayExpr =>
(ArrayExpr -> ArrayExpr -> Ordering)
-> (ArrayExpr -> ArrayExpr -> Bool)
-> (ArrayExpr -> ArrayExpr -> Bool)
-> (ArrayExpr -> ArrayExpr -> Bool)
-> (ArrayExpr -> ArrayExpr -> Bool)
-> (ArrayExpr -> ArrayExpr -> ArrayExpr)
-> (ArrayExpr -> ArrayExpr -> ArrayExpr)
-> Ord ArrayExpr
ArrayExpr -> ArrayExpr -> Bool
ArrayExpr -> ArrayExpr -> Ordering
ArrayExpr -> ArrayExpr -> ArrayExpr
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
$ccompare :: ArrayExpr -> ArrayExpr -> Ordering
compare :: ArrayExpr -> ArrayExpr -> Ordering
$c< :: ArrayExpr -> ArrayExpr -> Bool
< :: ArrayExpr -> ArrayExpr -> Bool
$c<= :: ArrayExpr -> ArrayExpr -> Bool
<= :: ArrayExpr -> ArrayExpr -> Bool
$c> :: ArrayExpr -> ArrayExpr -> Bool
> :: ArrayExpr -> ArrayExpr -> Bool
$c>= :: ArrayExpr -> ArrayExpr -> Bool
>= :: ArrayExpr -> ArrayExpr -> Bool
$cmax :: ArrayExpr -> ArrayExpr -> ArrayExpr
max :: ArrayExpr -> ArrayExpr -> ArrayExpr
$cmin :: ArrayExpr -> ArrayExpr -> ArrayExpr
min :: ArrayExpr -> ArrayExpr -> ArrayExpr
Ord)

-- |
-- ==== References
-- @
-- array_expr_list:
--   | array_expr
--   | array_expr_list ',' array_expr
-- @
type ArrayExprList = NonEmpty ArrayExpr

-- |
-- ==== References
-- @
-- row:
--   | ROW '(' expr_list ')'
--   | ROW '(' ')'
--   | '(' expr_list ',' a_expr ')'
-- @
data Row
  = ExplicitRowRow ExplicitRow
  | ImplicitRowRow ImplicitRow
  deriving (Int -> Row -> ShowS
[Row] -> ShowS
Row -> String
(Int -> Row -> ShowS)
-> (Row -> String) -> ([Row] -> ShowS) -> Show Row
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Row -> ShowS
showsPrec :: Int -> Row -> ShowS
$cshow :: Row -> String
show :: Row -> String
$cshowList :: [Row] -> ShowS
showList :: [Row] -> ShowS
Show, (forall x. Row -> Rep Row x)
-> (forall x. Rep Row x -> Row) -> Generic Row
forall x. Rep Row x -> Row
forall x. Row -> Rep Row x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Row -> Rep Row x
from :: forall x. Row -> Rep Row x
$cto :: forall x. Rep Row x -> Row
to :: forall x. Rep Row x -> Row
Generic, Row -> Row -> Bool
(Row -> Row -> Bool) -> (Row -> Row -> Bool) -> Eq Row
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Row -> Row -> Bool
== :: Row -> Row -> Bool
$c/= :: Row -> Row -> Bool
/= :: Row -> Row -> Bool
Eq, Eq Row
Eq Row =>
(Row -> Row -> Ordering)
-> (Row -> Row -> Bool)
-> (Row -> Row -> Bool)
-> (Row -> Row -> Bool)
-> (Row -> Row -> Bool)
-> (Row -> Row -> Row)
-> (Row -> Row -> Row)
-> Ord Row
Row -> Row -> Bool
Row -> Row -> Ordering
Row -> Row -> Row
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
$ccompare :: Row -> Row -> Ordering
compare :: Row -> Row -> Ordering
$c< :: Row -> Row -> Bool
< :: Row -> Row -> Bool
$c<= :: Row -> Row -> Bool
<= :: Row -> Row -> Bool
$c> :: Row -> Row -> Bool
> :: Row -> Row -> Bool
$c>= :: Row -> Row -> Bool
>= :: Row -> Row -> Bool
$cmax :: Row -> Row -> Row
max :: Row -> Row -> Row
$cmin :: Row -> Row -> Row
min :: Row -> Row -> Row
Ord)

-- |
-- ==== References
-- @
-- explicit_row:
--   | ROW '(' expr_list ')'
--   | ROW '(' ')'
-- @
type ExplicitRow = Maybe ExprList

-- |
-- ==== References
-- @
-- implicit_row:
--   | '(' expr_list ',' a_expr ')'
-- @
data ImplicitRow = ImplicitRow ExprList AExpr
  deriving (Int -> ImplicitRow -> ShowS
[ImplicitRow] -> ShowS
ImplicitRow -> String
(Int -> ImplicitRow -> ShowS)
-> (ImplicitRow -> String)
-> ([ImplicitRow] -> ShowS)
-> Show ImplicitRow
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ImplicitRow -> ShowS
showsPrec :: Int -> ImplicitRow -> ShowS
$cshow :: ImplicitRow -> String
show :: ImplicitRow -> String
$cshowList :: [ImplicitRow] -> ShowS
showList :: [ImplicitRow] -> ShowS
Show, (forall x. ImplicitRow -> Rep ImplicitRow x)
-> (forall x. Rep ImplicitRow x -> ImplicitRow)
-> Generic ImplicitRow
forall x. Rep ImplicitRow x -> ImplicitRow
forall x. ImplicitRow -> Rep ImplicitRow x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ImplicitRow -> Rep ImplicitRow x
from :: forall x. ImplicitRow -> Rep ImplicitRow x
$cto :: forall x. Rep ImplicitRow x -> ImplicitRow
to :: forall x. Rep ImplicitRow x -> ImplicitRow
Generic, ImplicitRow -> ImplicitRow -> Bool
(ImplicitRow -> ImplicitRow -> Bool)
-> (ImplicitRow -> ImplicitRow -> Bool) -> Eq ImplicitRow
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ImplicitRow -> ImplicitRow -> Bool
== :: ImplicitRow -> ImplicitRow -> Bool
$c/= :: ImplicitRow -> ImplicitRow -> Bool
/= :: ImplicitRow -> ImplicitRow -> Bool
Eq, Eq ImplicitRow
Eq ImplicitRow =>
(ImplicitRow -> ImplicitRow -> Ordering)
-> (ImplicitRow -> ImplicitRow -> Bool)
-> (ImplicitRow -> ImplicitRow -> Bool)
-> (ImplicitRow -> ImplicitRow -> Bool)
-> (ImplicitRow -> ImplicitRow -> Bool)
-> (ImplicitRow -> ImplicitRow -> ImplicitRow)
-> (ImplicitRow -> ImplicitRow -> ImplicitRow)
-> Ord ImplicitRow
ImplicitRow -> ImplicitRow -> Bool
ImplicitRow -> ImplicitRow -> Ordering
ImplicitRow -> ImplicitRow -> ImplicitRow
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
$ccompare :: ImplicitRow -> ImplicitRow -> Ordering
compare :: ImplicitRow -> ImplicitRow -> Ordering
$c< :: ImplicitRow -> ImplicitRow -> Bool
< :: ImplicitRow -> ImplicitRow -> Bool
$c<= :: ImplicitRow -> ImplicitRow -> Bool
<= :: ImplicitRow -> ImplicitRow -> Bool
$c> :: ImplicitRow -> ImplicitRow -> Bool
> :: ImplicitRow -> ImplicitRow -> Bool
$c>= :: ImplicitRow -> ImplicitRow -> Bool
>= :: ImplicitRow -> ImplicitRow -> Bool
$cmax :: ImplicitRow -> ImplicitRow -> ImplicitRow
max :: ImplicitRow -> ImplicitRow -> ImplicitRow
$cmin :: ImplicitRow -> ImplicitRow -> ImplicitRow
min :: ImplicitRow -> ImplicitRow -> ImplicitRow
Ord)

-- |
-- ==== References
-- @
-- func_expr:
--   | func_application within_group_clause filter_clause over_clause
--   | func_expr_common_subexpr
-- @
data FuncExpr
  = ApplicationFuncExpr FuncApplication (Maybe WithinGroupClause) (Maybe FilterClause) (Maybe OverClause)
  | SubexprFuncExpr FuncExprCommonSubexpr
  deriving (Int -> FuncExpr -> ShowS
[FuncExpr] -> ShowS
FuncExpr -> String
(Int -> FuncExpr -> ShowS)
-> (FuncExpr -> String) -> ([FuncExpr] -> ShowS) -> Show FuncExpr
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FuncExpr -> ShowS
showsPrec :: Int -> FuncExpr -> ShowS
$cshow :: FuncExpr -> String
show :: FuncExpr -> String
$cshowList :: [FuncExpr] -> ShowS
showList :: [FuncExpr] -> ShowS
Show, (forall x. FuncExpr -> Rep FuncExpr x)
-> (forall x. Rep FuncExpr x -> FuncExpr) -> Generic FuncExpr
forall x. Rep FuncExpr x -> FuncExpr
forall x. FuncExpr -> Rep FuncExpr x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. FuncExpr -> Rep FuncExpr x
from :: forall x. FuncExpr -> Rep FuncExpr x
$cto :: forall x. Rep FuncExpr x -> FuncExpr
to :: forall x. Rep FuncExpr x -> FuncExpr
Generic, FuncExpr -> FuncExpr -> Bool
(FuncExpr -> FuncExpr -> Bool)
-> (FuncExpr -> FuncExpr -> Bool) -> Eq FuncExpr
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FuncExpr -> FuncExpr -> Bool
== :: FuncExpr -> FuncExpr -> Bool
$c/= :: FuncExpr -> FuncExpr -> Bool
/= :: FuncExpr -> FuncExpr -> Bool
Eq, Eq FuncExpr
Eq FuncExpr =>
(FuncExpr -> FuncExpr -> Ordering)
-> (FuncExpr -> FuncExpr -> Bool)
-> (FuncExpr -> FuncExpr -> Bool)
-> (FuncExpr -> FuncExpr -> Bool)
-> (FuncExpr -> FuncExpr -> Bool)
-> (FuncExpr -> FuncExpr -> FuncExpr)
-> (FuncExpr -> FuncExpr -> FuncExpr)
-> Ord FuncExpr
FuncExpr -> FuncExpr -> Bool
FuncExpr -> FuncExpr -> Ordering
FuncExpr -> FuncExpr -> FuncExpr
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
$ccompare :: FuncExpr -> FuncExpr -> Ordering
compare :: FuncExpr -> FuncExpr -> Ordering
$c< :: FuncExpr -> FuncExpr -> Bool
< :: FuncExpr -> FuncExpr -> Bool
$c<= :: FuncExpr -> FuncExpr -> Bool
<= :: FuncExpr -> FuncExpr -> Bool
$c> :: FuncExpr -> FuncExpr -> Bool
> :: FuncExpr -> FuncExpr -> Bool
$c>= :: FuncExpr -> FuncExpr -> Bool
>= :: FuncExpr -> FuncExpr -> Bool
$cmax :: FuncExpr -> FuncExpr -> FuncExpr
max :: FuncExpr -> FuncExpr -> FuncExpr
$cmin :: FuncExpr -> FuncExpr -> FuncExpr
min :: FuncExpr -> FuncExpr -> FuncExpr
Ord)

-- |
-- ==== References
-- @
-- func_expr_windowless:
--   | func_application
--   | func_expr_common_subexpr
-- @
data FuncExprWindowless
  = ApplicationFuncExprWindowless FuncApplication
  | CommonSubexprFuncExprWindowless FuncExprCommonSubexpr
  deriving (Int -> FuncExprWindowless -> ShowS
[FuncExprWindowless] -> ShowS
FuncExprWindowless -> String
(Int -> FuncExprWindowless -> ShowS)
-> (FuncExprWindowless -> String)
-> ([FuncExprWindowless] -> ShowS)
-> Show FuncExprWindowless
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FuncExprWindowless -> ShowS
showsPrec :: Int -> FuncExprWindowless -> ShowS
$cshow :: FuncExprWindowless -> String
show :: FuncExprWindowless -> String
$cshowList :: [FuncExprWindowless] -> ShowS
showList :: [FuncExprWindowless] -> ShowS
Show, (forall x. FuncExprWindowless -> Rep FuncExprWindowless x)
-> (forall x. Rep FuncExprWindowless x -> FuncExprWindowless)
-> Generic FuncExprWindowless
forall x. Rep FuncExprWindowless x -> FuncExprWindowless
forall x. FuncExprWindowless -> Rep FuncExprWindowless x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. FuncExprWindowless -> Rep FuncExprWindowless x
from :: forall x. FuncExprWindowless -> Rep FuncExprWindowless x
$cto :: forall x. Rep FuncExprWindowless x -> FuncExprWindowless
to :: forall x. Rep FuncExprWindowless x -> FuncExprWindowless
Generic, FuncExprWindowless -> FuncExprWindowless -> Bool
(FuncExprWindowless -> FuncExprWindowless -> Bool)
-> (FuncExprWindowless -> FuncExprWindowless -> Bool)
-> Eq FuncExprWindowless
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FuncExprWindowless -> FuncExprWindowless -> Bool
== :: FuncExprWindowless -> FuncExprWindowless -> Bool
$c/= :: FuncExprWindowless -> FuncExprWindowless -> Bool
/= :: FuncExprWindowless -> FuncExprWindowless -> Bool
Eq, Eq FuncExprWindowless
Eq FuncExprWindowless =>
(FuncExprWindowless -> FuncExprWindowless -> Ordering)
-> (FuncExprWindowless -> FuncExprWindowless -> Bool)
-> (FuncExprWindowless -> FuncExprWindowless -> Bool)
-> (FuncExprWindowless -> FuncExprWindowless -> Bool)
-> (FuncExprWindowless -> FuncExprWindowless -> Bool)
-> (FuncExprWindowless -> FuncExprWindowless -> FuncExprWindowless)
-> (FuncExprWindowless -> FuncExprWindowless -> FuncExprWindowless)
-> Ord FuncExprWindowless
FuncExprWindowless -> FuncExprWindowless -> Bool
FuncExprWindowless -> FuncExprWindowless -> Ordering
FuncExprWindowless -> FuncExprWindowless -> FuncExprWindowless
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
$ccompare :: FuncExprWindowless -> FuncExprWindowless -> Ordering
compare :: FuncExprWindowless -> FuncExprWindowless -> Ordering
$c< :: FuncExprWindowless -> FuncExprWindowless -> Bool
< :: FuncExprWindowless -> FuncExprWindowless -> Bool
$c<= :: FuncExprWindowless -> FuncExprWindowless -> Bool
<= :: FuncExprWindowless -> FuncExprWindowless -> Bool
$c> :: FuncExprWindowless -> FuncExprWindowless -> Bool
> :: FuncExprWindowless -> FuncExprWindowless -> Bool
$c>= :: FuncExprWindowless -> FuncExprWindowless -> Bool
>= :: FuncExprWindowless -> FuncExprWindowless -> Bool
$cmax :: FuncExprWindowless -> FuncExprWindowless -> FuncExprWindowless
max :: FuncExprWindowless -> FuncExprWindowless -> FuncExprWindowless
$cmin :: FuncExprWindowless -> FuncExprWindowless -> FuncExprWindowless
min :: FuncExprWindowless -> FuncExprWindowless -> FuncExprWindowless
Ord)

-- |
-- ==== References
-- @
-- within_group_clause:
--   | WITHIN GROUP_P '(' sort_clause ')'
--   | EMPTY
-- @
type WithinGroupClause = SortClause

-- |
-- ==== References
-- @
-- filter_clause:
--   | FILTER '(' WHERE a_expr ')'
--   | EMPTY
-- @
type FilterClause = AExpr

-- |
-- ==== References
-- @
-- over_clause:
--   | OVER window_specification
--   | OVER ColId
--   | EMPTY
-- @
data OverClause
  = WindowOverClause WindowSpecification
  | ColIdOverClause ColId
  deriving (Int -> OverClause -> ShowS
[OverClause] -> ShowS
OverClause -> String
(Int -> OverClause -> ShowS)
-> (OverClause -> String)
-> ([OverClause] -> ShowS)
-> Show OverClause
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> OverClause -> ShowS
showsPrec :: Int -> OverClause -> ShowS
$cshow :: OverClause -> String
show :: OverClause -> String
$cshowList :: [OverClause] -> ShowS
showList :: [OverClause] -> ShowS
Show, (forall x. OverClause -> Rep OverClause x)
-> (forall x. Rep OverClause x -> OverClause) -> Generic OverClause
forall x. Rep OverClause x -> OverClause
forall x. OverClause -> Rep OverClause x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. OverClause -> Rep OverClause x
from :: forall x. OverClause -> Rep OverClause x
$cto :: forall x. Rep OverClause x -> OverClause
to :: forall x. Rep OverClause x -> OverClause
Generic, OverClause -> OverClause -> Bool
(OverClause -> OverClause -> Bool)
-> (OverClause -> OverClause -> Bool) -> Eq OverClause
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: OverClause -> OverClause -> Bool
== :: OverClause -> OverClause -> Bool
$c/= :: OverClause -> OverClause -> Bool
/= :: OverClause -> OverClause -> Bool
Eq, Eq OverClause
Eq OverClause =>
(OverClause -> OverClause -> Ordering)
-> (OverClause -> OverClause -> Bool)
-> (OverClause -> OverClause -> Bool)
-> (OverClause -> OverClause -> Bool)
-> (OverClause -> OverClause -> Bool)
-> (OverClause -> OverClause -> OverClause)
-> (OverClause -> OverClause -> OverClause)
-> Ord OverClause
OverClause -> OverClause -> Bool
OverClause -> OverClause -> Ordering
OverClause -> OverClause -> OverClause
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
$ccompare :: OverClause -> OverClause -> Ordering
compare :: OverClause -> OverClause -> Ordering
$c< :: OverClause -> OverClause -> Bool
< :: OverClause -> OverClause -> Bool
$c<= :: OverClause -> OverClause -> Bool
<= :: OverClause -> OverClause -> Bool
$c> :: OverClause -> OverClause -> Bool
> :: OverClause -> OverClause -> Bool
$c>= :: OverClause -> OverClause -> Bool
>= :: OverClause -> OverClause -> Bool
$cmax :: OverClause -> OverClause -> OverClause
max :: OverClause -> OverClause -> OverClause
$cmin :: OverClause -> OverClause -> OverClause
min :: OverClause -> OverClause -> OverClause
Ord)

-- |
-- ==== References
-- @
-- func_expr_common_subexpr:
--   | COLLATION FOR '(' a_expr ')'
--   | CURRENT_DATE
--   | CURRENT_TIME
--   | CURRENT_TIME '(' Iconst ')'
--   | CURRENT_TIMESTAMP
--   | CURRENT_TIMESTAMP '(' Iconst ')'
--   | LOCALTIME
--   | LOCALTIME '(' Iconst ')'
--   | LOCALTIMESTAMP
--   | LOCALTIMESTAMP '(' Iconst ')'
--   | CURRENT_ROLE
--   | CURRENT_USER
--   | SESSION_USER
--   | USER
--   | CURRENT_CATALOG
--   | CURRENT_SCHEMA
--   | CAST '(' a_expr AS Typename ')'
--   | EXTRACT '(' extract_list ')'
--   | OVERLAY '(' overlay_list ')'
--   | POSITION '(' position_list ')'
--   | SUBSTRING '(' substr_list ')'
--   | TREAT '(' a_expr AS Typename ')'
--   | TRIM '(' BOTH trim_list ')'
--   | TRIM '(' LEADING trim_list ')'
--   | TRIM '(' TRAILING trim_list ')'
--   | TRIM '(' trim_list ')'
--   | NULLIF '(' a_expr ',' a_expr ')'
--   | COALESCE '(' expr_list ')'
--   | GREATEST '(' expr_list ')'
--   | LEAST '(' expr_list ')'
--   | XMLCONCAT '(' expr_list ')'
--   | XMLELEMENT '(' NAME_P ColLabel ')'
--   | XMLELEMENT '(' NAME_P ColLabel ',' xml_attributes ')'
--   | XMLELEMENT '(' NAME_P ColLabel ',' expr_list ')'
--   | XMLELEMENT '(' NAME_P ColLabel ',' xml_attributes ',' expr_list ')'
--   | XMLEXISTS '(' c_expr xmlexists_argument ')'
--   | XMLFOREST '(' xml_attribute_list ')'
--   | XMLPARSE '(' document_or_content a_expr xml_whitespace_option ')'
--   | XMLPI '(' NAME_P ColLabel ')'
--   | XMLPI '(' NAME_P ColLabel ',' a_expr ')'
--   | XMLROOT '(' a_expr ',' xml_root_version opt_xml_root_standalone ')'
--   | XMLSERIALIZE '(' document_or_content a_expr AS SimpleTypename ')'
--
-- TODO: Implement the XML cases
-- @
data FuncExprCommonSubexpr
  = CollationForFuncExprCommonSubexpr AExpr
  | CurrentDateFuncExprCommonSubexpr
  | CurrentTimeFuncExprCommonSubexpr (Maybe Int64)
  | CurrentTimestampFuncExprCommonSubexpr (Maybe Int64)
  | LocalTimeFuncExprCommonSubexpr (Maybe Int64)
  | LocalTimestampFuncExprCommonSubexpr (Maybe Int64)
  | CurrentRoleFuncExprCommonSubexpr
  | CurrentUserFuncExprCommonSubexpr
  | SessionUserFuncExprCommonSubexpr
  | UserFuncExprCommonSubexpr
  | CurrentCatalogFuncExprCommonSubexpr
  | CurrentSchemaFuncExprCommonSubexpr
  | CastFuncExprCommonSubexpr AExpr Typename
  | ExtractFuncExprCommonSubexpr (Maybe ExtractList)
  | OverlayFuncExprCommonSubexpr OverlayList
  | PositionFuncExprCommonSubexpr (Maybe PositionList)
  | SubstringFuncExprCommonSubexpr (Maybe SubstrList)
  | TreatFuncExprCommonSubexpr AExpr Typename
  | TrimFuncExprCommonSubexpr (Maybe TrimModifier) TrimList
  | NullIfFuncExprCommonSubexpr AExpr AExpr
  | CoalesceFuncExprCommonSubexpr ExprList
  | GreatestFuncExprCommonSubexpr ExprList
  | LeastFuncExprCommonSubexpr ExprList
  deriving (Int -> FuncExprCommonSubexpr -> ShowS
[FuncExprCommonSubexpr] -> ShowS
FuncExprCommonSubexpr -> String
(Int -> FuncExprCommonSubexpr -> ShowS)
-> (FuncExprCommonSubexpr -> String)
-> ([FuncExprCommonSubexpr] -> ShowS)
-> Show FuncExprCommonSubexpr
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FuncExprCommonSubexpr -> ShowS
showsPrec :: Int -> FuncExprCommonSubexpr -> ShowS
$cshow :: FuncExprCommonSubexpr -> String
show :: FuncExprCommonSubexpr -> String
$cshowList :: [FuncExprCommonSubexpr] -> ShowS
showList :: [FuncExprCommonSubexpr] -> ShowS
Show, (forall x. FuncExprCommonSubexpr -> Rep FuncExprCommonSubexpr x)
-> (forall x. Rep FuncExprCommonSubexpr x -> FuncExprCommonSubexpr)
-> Generic FuncExprCommonSubexpr
forall x. Rep FuncExprCommonSubexpr x -> FuncExprCommonSubexpr
forall x. FuncExprCommonSubexpr -> Rep FuncExprCommonSubexpr x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. FuncExprCommonSubexpr -> Rep FuncExprCommonSubexpr x
from :: forall x. FuncExprCommonSubexpr -> Rep FuncExprCommonSubexpr x
$cto :: forall x. Rep FuncExprCommonSubexpr x -> FuncExprCommonSubexpr
to :: forall x. Rep FuncExprCommonSubexpr x -> FuncExprCommonSubexpr
Generic, FuncExprCommonSubexpr -> FuncExprCommonSubexpr -> Bool
(FuncExprCommonSubexpr -> FuncExprCommonSubexpr -> Bool)
-> (FuncExprCommonSubexpr -> FuncExprCommonSubexpr -> Bool)
-> Eq FuncExprCommonSubexpr
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FuncExprCommonSubexpr -> FuncExprCommonSubexpr -> Bool
== :: FuncExprCommonSubexpr -> FuncExprCommonSubexpr -> Bool
$c/= :: FuncExprCommonSubexpr -> FuncExprCommonSubexpr -> Bool
/= :: FuncExprCommonSubexpr -> FuncExprCommonSubexpr -> Bool
Eq, Eq FuncExprCommonSubexpr
Eq FuncExprCommonSubexpr =>
(FuncExprCommonSubexpr -> FuncExprCommonSubexpr -> Ordering)
-> (FuncExprCommonSubexpr -> FuncExprCommonSubexpr -> Bool)
-> (FuncExprCommonSubexpr -> FuncExprCommonSubexpr -> Bool)
-> (FuncExprCommonSubexpr -> FuncExprCommonSubexpr -> Bool)
-> (FuncExprCommonSubexpr -> FuncExprCommonSubexpr -> Bool)
-> (FuncExprCommonSubexpr
    -> FuncExprCommonSubexpr -> FuncExprCommonSubexpr)
-> (FuncExprCommonSubexpr
    -> FuncExprCommonSubexpr -> FuncExprCommonSubexpr)
-> Ord FuncExprCommonSubexpr
FuncExprCommonSubexpr -> FuncExprCommonSubexpr -> Bool
FuncExprCommonSubexpr -> FuncExprCommonSubexpr -> Ordering
FuncExprCommonSubexpr
-> FuncExprCommonSubexpr -> FuncExprCommonSubexpr
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
$ccompare :: FuncExprCommonSubexpr -> FuncExprCommonSubexpr -> Ordering
compare :: FuncExprCommonSubexpr -> FuncExprCommonSubexpr -> Ordering
$c< :: FuncExprCommonSubexpr -> FuncExprCommonSubexpr -> Bool
< :: FuncExprCommonSubexpr -> FuncExprCommonSubexpr -> Bool
$c<= :: FuncExprCommonSubexpr -> FuncExprCommonSubexpr -> Bool
<= :: FuncExprCommonSubexpr -> FuncExprCommonSubexpr -> Bool
$c> :: FuncExprCommonSubexpr -> FuncExprCommonSubexpr -> Bool
> :: FuncExprCommonSubexpr -> FuncExprCommonSubexpr -> Bool
$c>= :: FuncExprCommonSubexpr -> FuncExprCommonSubexpr -> Bool
>= :: FuncExprCommonSubexpr -> FuncExprCommonSubexpr -> Bool
$cmax :: FuncExprCommonSubexpr
-> FuncExprCommonSubexpr -> FuncExprCommonSubexpr
max :: FuncExprCommonSubexpr
-> FuncExprCommonSubexpr -> FuncExprCommonSubexpr
$cmin :: FuncExprCommonSubexpr
-> FuncExprCommonSubexpr -> FuncExprCommonSubexpr
min :: FuncExprCommonSubexpr
-> FuncExprCommonSubexpr -> FuncExprCommonSubexpr
Ord)

-- |
-- ==== References
-- @
-- extract_list:
--   | extract_arg FROM a_expr
--   | EMPTY
-- @
data ExtractList = ExtractList ExtractArg AExpr
  deriving (Int -> ExtractList -> ShowS
[ExtractList] -> ShowS
ExtractList -> String
(Int -> ExtractList -> ShowS)
-> (ExtractList -> String)
-> ([ExtractList] -> ShowS)
-> Show ExtractList
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ExtractList -> ShowS
showsPrec :: Int -> ExtractList -> ShowS
$cshow :: ExtractList -> String
show :: ExtractList -> String
$cshowList :: [ExtractList] -> ShowS
showList :: [ExtractList] -> ShowS
Show, (forall x. ExtractList -> Rep ExtractList x)
-> (forall x. Rep ExtractList x -> ExtractList)
-> Generic ExtractList
forall x. Rep ExtractList x -> ExtractList
forall x. ExtractList -> Rep ExtractList x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ExtractList -> Rep ExtractList x
from :: forall x. ExtractList -> Rep ExtractList x
$cto :: forall x. Rep ExtractList x -> ExtractList
to :: forall x. Rep ExtractList x -> ExtractList
Generic, ExtractList -> ExtractList -> Bool
(ExtractList -> ExtractList -> Bool)
-> (ExtractList -> ExtractList -> Bool) -> Eq ExtractList
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ExtractList -> ExtractList -> Bool
== :: ExtractList -> ExtractList -> Bool
$c/= :: ExtractList -> ExtractList -> Bool
/= :: ExtractList -> ExtractList -> Bool
Eq, Eq ExtractList
Eq ExtractList =>
(ExtractList -> ExtractList -> Ordering)
-> (ExtractList -> ExtractList -> Bool)
-> (ExtractList -> ExtractList -> Bool)
-> (ExtractList -> ExtractList -> Bool)
-> (ExtractList -> ExtractList -> Bool)
-> (ExtractList -> ExtractList -> ExtractList)
-> (ExtractList -> ExtractList -> ExtractList)
-> Ord ExtractList
ExtractList -> ExtractList -> Bool
ExtractList -> ExtractList -> Ordering
ExtractList -> ExtractList -> ExtractList
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
$ccompare :: ExtractList -> ExtractList -> Ordering
compare :: ExtractList -> ExtractList -> Ordering
$c< :: ExtractList -> ExtractList -> Bool
< :: ExtractList -> ExtractList -> Bool
$c<= :: ExtractList -> ExtractList -> Bool
<= :: ExtractList -> ExtractList -> Bool
$c> :: ExtractList -> ExtractList -> Bool
> :: ExtractList -> ExtractList -> Bool
$c>= :: ExtractList -> ExtractList -> Bool
>= :: ExtractList -> ExtractList -> Bool
$cmax :: ExtractList -> ExtractList -> ExtractList
max :: ExtractList -> ExtractList -> ExtractList
$cmin :: ExtractList -> ExtractList -> ExtractList
min :: ExtractList -> ExtractList -> ExtractList
Ord)

-- |
-- ==== References
-- @
-- extract_arg:
--   | IDENT
--   | YEAR_P
--   | MONTH_P
--   | DAY_P
--   | HOUR_P
--   | MINUTE_P
--   | SECOND_P
--   | Sconst
-- @
data ExtractArg
  = IdentExtractArg Ident
  | YearExtractArg
  | MonthExtractArg
  | DayExtractArg
  | HourExtractArg
  | MinuteExtractArg
  | SecondExtractArg
  | SconstExtractArg Sconst
  deriving (Int -> ExtractArg -> ShowS
[ExtractArg] -> ShowS
ExtractArg -> String
(Int -> ExtractArg -> ShowS)
-> (ExtractArg -> String)
-> ([ExtractArg] -> ShowS)
-> Show ExtractArg
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ExtractArg -> ShowS
showsPrec :: Int -> ExtractArg -> ShowS
$cshow :: ExtractArg -> String
show :: ExtractArg -> String
$cshowList :: [ExtractArg] -> ShowS
showList :: [ExtractArg] -> ShowS
Show, (forall x. ExtractArg -> Rep ExtractArg x)
-> (forall x. Rep ExtractArg x -> ExtractArg) -> Generic ExtractArg
forall x. Rep ExtractArg x -> ExtractArg
forall x. ExtractArg -> Rep ExtractArg x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ExtractArg -> Rep ExtractArg x
from :: forall x. ExtractArg -> Rep ExtractArg x
$cto :: forall x. Rep ExtractArg x -> ExtractArg
to :: forall x. Rep ExtractArg x -> ExtractArg
Generic, ExtractArg -> ExtractArg -> Bool
(ExtractArg -> ExtractArg -> Bool)
-> (ExtractArg -> ExtractArg -> Bool) -> Eq ExtractArg
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ExtractArg -> ExtractArg -> Bool
== :: ExtractArg -> ExtractArg -> Bool
$c/= :: ExtractArg -> ExtractArg -> Bool
/= :: ExtractArg -> ExtractArg -> Bool
Eq, Eq ExtractArg
Eq ExtractArg =>
(ExtractArg -> ExtractArg -> Ordering)
-> (ExtractArg -> ExtractArg -> Bool)
-> (ExtractArg -> ExtractArg -> Bool)
-> (ExtractArg -> ExtractArg -> Bool)
-> (ExtractArg -> ExtractArg -> Bool)
-> (ExtractArg -> ExtractArg -> ExtractArg)
-> (ExtractArg -> ExtractArg -> ExtractArg)
-> Ord ExtractArg
ExtractArg -> ExtractArg -> Bool
ExtractArg -> ExtractArg -> Ordering
ExtractArg -> ExtractArg -> ExtractArg
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
$ccompare :: ExtractArg -> ExtractArg -> Ordering
compare :: ExtractArg -> ExtractArg -> Ordering
$c< :: ExtractArg -> ExtractArg -> Bool
< :: ExtractArg -> ExtractArg -> Bool
$c<= :: ExtractArg -> ExtractArg -> Bool
<= :: ExtractArg -> ExtractArg -> Bool
$c> :: ExtractArg -> ExtractArg -> Bool
> :: ExtractArg -> ExtractArg -> Bool
$c>= :: ExtractArg -> ExtractArg -> Bool
>= :: ExtractArg -> ExtractArg -> Bool
$cmax :: ExtractArg -> ExtractArg -> ExtractArg
max :: ExtractArg -> ExtractArg -> ExtractArg
$cmin :: ExtractArg -> ExtractArg -> ExtractArg
min :: ExtractArg -> ExtractArg -> ExtractArg
Ord)

-- |
-- ==== References
-- @
-- overlay_list:
--   | a_expr overlay_placing substr_from substr_for
--   | a_expr overlay_placing substr_from
-- @
data OverlayList = OverlayList AExpr OverlayPlacing SubstrFrom (Maybe SubstrFor)
  deriving (Int -> OverlayList -> ShowS
[OverlayList] -> ShowS
OverlayList -> String
(Int -> OverlayList -> ShowS)
-> (OverlayList -> String)
-> ([OverlayList] -> ShowS)
-> Show OverlayList
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> OverlayList -> ShowS
showsPrec :: Int -> OverlayList -> ShowS
$cshow :: OverlayList -> String
show :: OverlayList -> String
$cshowList :: [OverlayList] -> ShowS
showList :: [OverlayList] -> ShowS
Show, (forall x. OverlayList -> Rep OverlayList x)
-> (forall x. Rep OverlayList x -> OverlayList)
-> Generic OverlayList
forall x. Rep OverlayList x -> OverlayList
forall x. OverlayList -> Rep OverlayList x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. OverlayList -> Rep OverlayList x
from :: forall x. OverlayList -> Rep OverlayList x
$cto :: forall x. Rep OverlayList x -> OverlayList
to :: forall x. Rep OverlayList x -> OverlayList
Generic, OverlayList -> OverlayList -> Bool
(OverlayList -> OverlayList -> Bool)
-> (OverlayList -> OverlayList -> Bool) -> Eq OverlayList
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: OverlayList -> OverlayList -> Bool
== :: OverlayList -> OverlayList -> Bool
$c/= :: OverlayList -> OverlayList -> Bool
/= :: OverlayList -> OverlayList -> Bool
Eq, Eq OverlayList
Eq OverlayList =>
(OverlayList -> OverlayList -> Ordering)
-> (OverlayList -> OverlayList -> Bool)
-> (OverlayList -> OverlayList -> Bool)
-> (OverlayList -> OverlayList -> Bool)
-> (OverlayList -> OverlayList -> Bool)
-> (OverlayList -> OverlayList -> OverlayList)
-> (OverlayList -> OverlayList -> OverlayList)
-> Ord OverlayList
OverlayList -> OverlayList -> Bool
OverlayList -> OverlayList -> Ordering
OverlayList -> OverlayList -> OverlayList
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
$ccompare :: OverlayList -> OverlayList -> Ordering
compare :: OverlayList -> OverlayList -> Ordering
$c< :: OverlayList -> OverlayList -> Bool
< :: OverlayList -> OverlayList -> Bool
$c<= :: OverlayList -> OverlayList -> Bool
<= :: OverlayList -> OverlayList -> Bool
$c> :: OverlayList -> OverlayList -> Bool
> :: OverlayList -> OverlayList -> Bool
$c>= :: OverlayList -> OverlayList -> Bool
>= :: OverlayList -> OverlayList -> Bool
$cmax :: OverlayList -> OverlayList -> OverlayList
max :: OverlayList -> OverlayList -> OverlayList
$cmin :: OverlayList -> OverlayList -> OverlayList
min :: OverlayList -> OverlayList -> OverlayList
Ord)

-- |
-- ==== References
-- @
-- overlay_placing:
--   | PLACING a_expr
-- @
type OverlayPlacing = AExpr

-- |
-- ==== References
-- @
-- position_list:
--   | b_expr IN_P b_expr
--   | EMPTY
-- @
data PositionList = PositionList BExpr BExpr
  deriving (Int -> PositionList -> ShowS
[PositionList] -> ShowS
PositionList -> String
(Int -> PositionList -> ShowS)
-> (PositionList -> String)
-> ([PositionList] -> ShowS)
-> Show PositionList
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PositionList -> ShowS
showsPrec :: Int -> PositionList -> ShowS
$cshow :: PositionList -> String
show :: PositionList -> String
$cshowList :: [PositionList] -> ShowS
showList :: [PositionList] -> ShowS
Show, (forall x. PositionList -> Rep PositionList x)
-> (forall x. Rep PositionList x -> PositionList)
-> Generic PositionList
forall x. Rep PositionList x -> PositionList
forall x. PositionList -> Rep PositionList x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. PositionList -> Rep PositionList x
from :: forall x. PositionList -> Rep PositionList x
$cto :: forall x. Rep PositionList x -> PositionList
to :: forall x. Rep PositionList x -> PositionList
Generic, PositionList -> PositionList -> Bool
(PositionList -> PositionList -> Bool)
-> (PositionList -> PositionList -> Bool) -> Eq PositionList
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PositionList -> PositionList -> Bool
== :: PositionList -> PositionList -> Bool
$c/= :: PositionList -> PositionList -> Bool
/= :: PositionList -> PositionList -> Bool
Eq, Eq PositionList
Eq PositionList =>
(PositionList -> PositionList -> Ordering)
-> (PositionList -> PositionList -> Bool)
-> (PositionList -> PositionList -> Bool)
-> (PositionList -> PositionList -> Bool)
-> (PositionList -> PositionList -> Bool)
-> (PositionList -> PositionList -> PositionList)
-> (PositionList -> PositionList -> PositionList)
-> Ord PositionList
PositionList -> PositionList -> Bool
PositionList -> PositionList -> Ordering
PositionList -> PositionList -> PositionList
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
$ccompare :: PositionList -> PositionList -> Ordering
compare :: PositionList -> PositionList -> Ordering
$c< :: PositionList -> PositionList -> Bool
< :: PositionList -> PositionList -> Bool
$c<= :: PositionList -> PositionList -> Bool
<= :: PositionList -> PositionList -> Bool
$c> :: PositionList -> PositionList -> Bool
> :: PositionList -> PositionList -> Bool
$c>= :: PositionList -> PositionList -> Bool
>= :: PositionList -> PositionList -> Bool
$cmax :: PositionList -> PositionList -> PositionList
max :: PositionList -> PositionList -> PositionList
$cmin :: PositionList -> PositionList -> PositionList
min :: PositionList -> PositionList -> PositionList
Ord)

-- |
-- ==== References
-- @
-- substr_list:
--   | a_expr substr_from substr_for
--   | a_expr substr_for substr_from
--   | a_expr substr_from
--   | a_expr substr_for
--   | expr_list
--   | EMPTY
-- @
data SubstrList
  = ExprSubstrList AExpr SubstrListFromFor
  | ExprListSubstrList ExprList
  deriving (Int -> SubstrList -> ShowS
[SubstrList] -> ShowS
SubstrList -> String
(Int -> SubstrList -> ShowS)
-> (SubstrList -> String)
-> ([SubstrList] -> ShowS)
-> Show SubstrList
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SubstrList -> ShowS
showsPrec :: Int -> SubstrList -> ShowS
$cshow :: SubstrList -> String
show :: SubstrList -> String
$cshowList :: [SubstrList] -> ShowS
showList :: [SubstrList] -> ShowS
Show, (forall x. SubstrList -> Rep SubstrList x)
-> (forall x. Rep SubstrList x -> SubstrList) -> Generic SubstrList
forall x. Rep SubstrList x -> SubstrList
forall x. SubstrList -> Rep SubstrList x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. SubstrList -> Rep SubstrList x
from :: forall x. SubstrList -> Rep SubstrList x
$cto :: forall x. Rep SubstrList x -> SubstrList
to :: forall x. Rep SubstrList x -> SubstrList
Generic, SubstrList -> SubstrList -> Bool
(SubstrList -> SubstrList -> Bool)
-> (SubstrList -> SubstrList -> Bool) -> Eq SubstrList
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SubstrList -> SubstrList -> Bool
== :: SubstrList -> SubstrList -> Bool
$c/= :: SubstrList -> SubstrList -> Bool
/= :: SubstrList -> SubstrList -> Bool
Eq, Eq SubstrList
Eq SubstrList =>
(SubstrList -> SubstrList -> Ordering)
-> (SubstrList -> SubstrList -> Bool)
-> (SubstrList -> SubstrList -> Bool)
-> (SubstrList -> SubstrList -> Bool)
-> (SubstrList -> SubstrList -> Bool)
-> (SubstrList -> SubstrList -> SubstrList)
-> (SubstrList -> SubstrList -> SubstrList)
-> Ord SubstrList
SubstrList -> SubstrList -> Bool
SubstrList -> SubstrList -> Ordering
SubstrList -> SubstrList -> SubstrList
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
$ccompare :: SubstrList -> SubstrList -> Ordering
compare :: SubstrList -> SubstrList -> Ordering
$c< :: SubstrList -> SubstrList -> Bool
< :: SubstrList -> SubstrList -> Bool
$c<= :: SubstrList -> SubstrList -> Bool
<= :: SubstrList -> SubstrList -> Bool
$c> :: SubstrList -> SubstrList -> Bool
> :: SubstrList -> SubstrList -> Bool
$c>= :: SubstrList -> SubstrList -> Bool
>= :: SubstrList -> SubstrList -> Bool
$cmax :: SubstrList -> SubstrList -> SubstrList
max :: SubstrList -> SubstrList -> SubstrList
$cmin :: SubstrList -> SubstrList -> SubstrList
min :: SubstrList -> SubstrList -> SubstrList
Ord)

-- |
-- ==== References
-- @
--   | a_expr substr_from substr_for
--   | a_expr substr_for substr_from
--   | a_expr substr_from
--   | a_expr substr_for
-- @
data SubstrListFromFor
  = FromForSubstrListFromFor SubstrFrom SubstrFor
  | ForFromSubstrListFromFor SubstrFor SubstrFrom
  | FromSubstrListFromFor SubstrFrom
  | ForSubstrListFromFor SubstrFor
  deriving (Int -> SubstrListFromFor -> ShowS
[SubstrListFromFor] -> ShowS
SubstrListFromFor -> String
(Int -> SubstrListFromFor -> ShowS)
-> (SubstrListFromFor -> String)
-> ([SubstrListFromFor] -> ShowS)
-> Show SubstrListFromFor
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SubstrListFromFor -> ShowS
showsPrec :: Int -> SubstrListFromFor -> ShowS
$cshow :: SubstrListFromFor -> String
show :: SubstrListFromFor -> String
$cshowList :: [SubstrListFromFor] -> ShowS
showList :: [SubstrListFromFor] -> ShowS
Show, (forall x. SubstrListFromFor -> Rep SubstrListFromFor x)
-> (forall x. Rep SubstrListFromFor x -> SubstrListFromFor)
-> Generic SubstrListFromFor
forall x. Rep SubstrListFromFor x -> SubstrListFromFor
forall x. SubstrListFromFor -> Rep SubstrListFromFor x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. SubstrListFromFor -> Rep SubstrListFromFor x
from :: forall x. SubstrListFromFor -> Rep SubstrListFromFor x
$cto :: forall x. Rep SubstrListFromFor x -> SubstrListFromFor
to :: forall x. Rep SubstrListFromFor x -> SubstrListFromFor
Generic, SubstrListFromFor -> SubstrListFromFor -> Bool
(SubstrListFromFor -> SubstrListFromFor -> Bool)
-> (SubstrListFromFor -> SubstrListFromFor -> Bool)
-> Eq SubstrListFromFor
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SubstrListFromFor -> SubstrListFromFor -> Bool
== :: SubstrListFromFor -> SubstrListFromFor -> Bool
$c/= :: SubstrListFromFor -> SubstrListFromFor -> Bool
/= :: SubstrListFromFor -> SubstrListFromFor -> Bool
Eq, Eq SubstrListFromFor
Eq SubstrListFromFor =>
(SubstrListFromFor -> SubstrListFromFor -> Ordering)
-> (SubstrListFromFor -> SubstrListFromFor -> Bool)
-> (SubstrListFromFor -> SubstrListFromFor -> Bool)
-> (SubstrListFromFor -> SubstrListFromFor -> Bool)
-> (SubstrListFromFor -> SubstrListFromFor -> Bool)
-> (SubstrListFromFor -> SubstrListFromFor -> SubstrListFromFor)
-> (SubstrListFromFor -> SubstrListFromFor -> SubstrListFromFor)
-> Ord SubstrListFromFor
SubstrListFromFor -> SubstrListFromFor -> Bool
SubstrListFromFor -> SubstrListFromFor -> Ordering
SubstrListFromFor -> SubstrListFromFor -> SubstrListFromFor
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
$ccompare :: SubstrListFromFor -> SubstrListFromFor -> Ordering
compare :: SubstrListFromFor -> SubstrListFromFor -> Ordering
$c< :: SubstrListFromFor -> SubstrListFromFor -> Bool
< :: SubstrListFromFor -> SubstrListFromFor -> Bool
$c<= :: SubstrListFromFor -> SubstrListFromFor -> Bool
<= :: SubstrListFromFor -> SubstrListFromFor -> Bool
$c> :: SubstrListFromFor -> SubstrListFromFor -> Bool
> :: SubstrListFromFor -> SubstrListFromFor -> Bool
$c>= :: SubstrListFromFor -> SubstrListFromFor -> Bool
>= :: SubstrListFromFor -> SubstrListFromFor -> Bool
$cmax :: SubstrListFromFor -> SubstrListFromFor -> SubstrListFromFor
max :: SubstrListFromFor -> SubstrListFromFor -> SubstrListFromFor
$cmin :: SubstrListFromFor -> SubstrListFromFor -> SubstrListFromFor
min :: SubstrListFromFor -> SubstrListFromFor -> SubstrListFromFor
Ord)

-- |
-- ==== References
-- @
-- substr_from:
--   | FROM a_expr
-- @
type SubstrFrom = AExpr

-- |
-- ==== References
-- @
-- substr_for:
--   | FOR a_expr
-- @
type SubstrFor = AExpr

-- |
-- ==== References
-- @
--   | TRIM '(' BOTH trim_list ')'
--   | TRIM '(' LEADING trim_list ')'
--   | TRIM '(' TRAILING trim_list ')'
-- @
data TrimModifier = BothTrimModifier | LeadingTrimModifier | TrailingTrimModifier
  deriving (Int -> TrimModifier -> ShowS
[TrimModifier] -> ShowS
TrimModifier -> String
(Int -> TrimModifier -> ShowS)
-> (TrimModifier -> String)
-> ([TrimModifier] -> ShowS)
-> Show TrimModifier
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TrimModifier -> ShowS
showsPrec :: Int -> TrimModifier -> ShowS
$cshow :: TrimModifier -> String
show :: TrimModifier -> String
$cshowList :: [TrimModifier] -> ShowS
showList :: [TrimModifier] -> ShowS
Show, (forall x. TrimModifier -> Rep TrimModifier x)
-> (forall x. Rep TrimModifier x -> TrimModifier)
-> Generic TrimModifier
forall x. Rep TrimModifier x -> TrimModifier
forall x. TrimModifier -> Rep TrimModifier x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. TrimModifier -> Rep TrimModifier x
from :: forall x. TrimModifier -> Rep TrimModifier x
$cto :: forall x. Rep TrimModifier x -> TrimModifier
to :: forall x. Rep TrimModifier x -> TrimModifier
Generic, TrimModifier -> TrimModifier -> Bool
(TrimModifier -> TrimModifier -> Bool)
-> (TrimModifier -> TrimModifier -> Bool) -> Eq TrimModifier
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TrimModifier -> TrimModifier -> Bool
== :: TrimModifier -> TrimModifier -> Bool
$c/= :: TrimModifier -> TrimModifier -> Bool
/= :: TrimModifier -> TrimModifier -> Bool
Eq, Eq TrimModifier
Eq TrimModifier =>
(TrimModifier -> TrimModifier -> Ordering)
-> (TrimModifier -> TrimModifier -> Bool)
-> (TrimModifier -> TrimModifier -> Bool)
-> (TrimModifier -> TrimModifier -> Bool)
-> (TrimModifier -> TrimModifier -> Bool)
-> (TrimModifier -> TrimModifier -> TrimModifier)
-> (TrimModifier -> TrimModifier -> TrimModifier)
-> Ord TrimModifier
TrimModifier -> TrimModifier -> Bool
TrimModifier -> TrimModifier -> Ordering
TrimModifier -> TrimModifier -> TrimModifier
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
$ccompare :: TrimModifier -> TrimModifier -> Ordering
compare :: TrimModifier -> TrimModifier -> Ordering
$c< :: TrimModifier -> TrimModifier -> Bool
< :: TrimModifier -> TrimModifier -> Bool
$c<= :: TrimModifier -> TrimModifier -> Bool
<= :: TrimModifier -> TrimModifier -> Bool
$c> :: TrimModifier -> TrimModifier -> Bool
> :: TrimModifier -> TrimModifier -> Bool
$c>= :: TrimModifier -> TrimModifier -> Bool
>= :: TrimModifier -> TrimModifier -> Bool
$cmax :: TrimModifier -> TrimModifier -> TrimModifier
max :: TrimModifier -> TrimModifier -> TrimModifier
$cmin :: TrimModifier -> TrimModifier -> TrimModifier
min :: TrimModifier -> TrimModifier -> TrimModifier
Ord, Int -> TrimModifier
TrimModifier -> Int
TrimModifier -> [TrimModifier]
TrimModifier -> TrimModifier
TrimModifier -> TrimModifier -> [TrimModifier]
TrimModifier -> TrimModifier -> TrimModifier -> [TrimModifier]
(TrimModifier -> TrimModifier)
-> (TrimModifier -> TrimModifier)
-> (Int -> TrimModifier)
-> (TrimModifier -> Int)
-> (TrimModifier -> [TrimModifier])
-> (TrimModifier -> TrimModifier -> [TrimModifier])
-> (TrimModifier -> TrimModifier -> [TrimModifier])
-> (TrimModifier -> TrimModifier -> TrimModifier -> [TrimModifier])
-> Enum TrimModifier
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: TrimModifier -> TrimModifier
succ :: TrimModifier -> TrimModifier
$cpred :: TrimModifier -> TrimModifier
pred :: TrimModifier -> TrimModifier
$ctoEnum :: Int -> TrimModifier
toEnum :: Int -> TrimModifier
$cfromEnum :: TrimModifier -> Int
fromEnum :: TrimModifier -> Int
$cenumFrom :: TrimModifier -> [TrimModifier]
enumFrom :: TrimModifier -> [TrimModifier]
$cenumFromThen :: TrimModifier -> TrimModifier -> [TrimModifier]
enumFromThen :: TrimModifier -> TrimModifier -> [TrimModifier]
$cenumFromTo :: TrimModifier -> TrimModifier -> [TrimModifier]
enumFromTo :: TrimModifier -> TrimModifier -> [TrimModifier]
$cenumFromThenTo :: TrimModifier -> TrimModifier -> TrimModifier -> [TrimModifier]
enumFromThenTo :: TrimModifier -> TrimModifier -> TrimModifier -> [TrimModifier]
Enum, TrimModifier
TrimModifier -> TrimModifier -> Bounded TrimModifier
forall a. a -> a -> Bounded a
$cminBound :: TrimModifier
minBound :: TrimModifier
$cmaxBound :: TrimModifier
maxBound :: TrimModifier
Bounded)

-- |
-- ==== References
-- @
-- trim_list:
--   | a_expr FROM expr_list
--   | FROM expr_list
--   | expr_list
-- @
data TrimList
  = ExprFromExprListTrimList AExpr ExprList
  | FromExprListTrimList ExprList
  | ExprListTrimList ExprList
  deriving (Int -> TrimList -> ShowS
[TrimList] -> ShowS
TrimList -> String
(Int -> TrimList -> ShowS)
-> (TrimList -> String) -> ([TrimList] -> ShowS) -> Show TrimList
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TrimList -> ShowS
showsPrec :: Int -> TrimList -> ShowS
$cshow :: TrimList -> String
show :: TrimList -> String
$cshowList :: [TrimList] -> ShowS
showList :: [TrimList] -> ShowS
Show, (forall x. TrimList -> Rep TrimList x)
-> (forall x. Rep TrimList x -> TrimList) -> Generic TrimList
forall x. Rep TrimList x -> TrimList
forall x. TrimList -> Rep TrimList x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. TrimList -> Rep TrimList x
from :: forall x. TrimList -> Rep TrimList x
$cto :: forall x. Rep TrimList x -> TrimList
to :: forall x. Rep TrimList x -> TrimList
Generic, TrimList -> TrimList -> Bool
(TrimList -> TrimList -> Bool)
-> (TrimList -> TrimList -> Bool) -> Eq TrimList
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TrimList -> TrimList -> Bool
== :: TrimList -> TrimList -> Bool
$c/= :: TrimList -> TrimList -> Bool
/= :: TrimList -> TrimList -> Bool
Eq, Eq TrimList
Eq TrimList =>
(TrimList -> TrimList -> Ordering)
-> (TrimList -> TrimList -> Bool)
-> (TrimList -> TrimList -> Bool)
-> (TrimList -> TrimList -> Bool)
-> (TrimList -> TrimList -> Bool)
-> (TrimList -> TrimList -> TrimList)
-> (TrimList -> TrimList -> TrimList)
-> Ord TrimList
TrimList -> TrimList -> Bool
TrimList -> TrimList -> Ordering
TrimList -> TrimList -> TrimList
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
$ccompare :: TrimList -> TrimList -> Ordering
compare :: TrimList -> TrimList -> Ordering
$c< :: TrimList -> TrimList -> Bool
< :: TrimList -> TrimList -> Bool
$c<= :: TrimList -> TrimList -> Bool
<= :: TrimList -> TrimList -> Bool
$c> :: TrimList -> TrimList -> Bool
> :: TrimList -> TrimList -> Bool
$c>= :: TrimList -> TrimList -> Bool
>= :: TrimList -> TrimList -> Bool
$cmax :: TrimList -> TrimList -> TrimList
max :: TrimList -> TrimList -> TrimList
$cmin :: TrimList -> TrimList -> TrimList
min :: TrimList -> TrimList -> TrimList
Ord)

-- |
-- ==== References
-- @
-- case_expr:
--   | CASE case_arg when_clause_list case_default END_P
-- @
data CaseExpr = CaseExpr (Maybe CaseArg) WhenClauseList (Maybe CaseDefault)
  deriving (Int -> CaseExpr -> ShowS
[CaseExpr] -> ShowS
CaseExpr -> String
(Int -> CaseExpr -> ShowS)
-> (CaseExpr -> String) -> ([CaseExpr] -> ShowS) -> Show CaseExpr
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CaseExpr -> ShowS
showsPrec :: Int -> CaseExpr -> ShowS
$cshow :: CaseExpr -> String
show :: CaseExpr -> String
$cshowList :: [CaseExpr] -> ShowS
showList :: [CaseExpr] -> ShowS
Show, (forall x. CaseExpr -> Rep CaseExpr x)
-> (forall x. Rep CaseExpr x -> CaseExpr) -> Generic CaseExpr
forall x. Rep CaseExpr x -> CaseExpr
forall x. CaseExpr -> Rep CaseExpr x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. CaseExpr -> Rep CaseExpr x
from :: forall x. CaseExpr -> Rep CaseExpr x
$cto :: forall x. Rep CaseExpr x -> CaseExpr
to :: forall x. Rep CaseExpr x -> CaseExpr
Generic, CaseExpr -> CaseExpr -> Bool
(CaseExpr -> CaseExpr -> Bool)
-> (CaseExpr -> CaseExpr -> Bool) -> Eq CaseExpr
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CaseExpr -> CaseExpr -> Bool
== :: CaseExpr -> CaseExpr -> Bool
$c/= :: CaseExpr -> CaseExpr -> Bool
/= :: CaseExpr -> CaseExpr -> Bool
Eq, Eq CaseExpr
Eq CaseExpr =>
(CaseExpr -> CaseExpr -> Ordering)
-> (CaseExpr -> CaseExpr -> Bool)
-> (CaseExpr -> CaseExpr -> Bool)
-> (CaseExpr -> CaseExpr -> Bool)
-> (CaseExpr -> CaseExpr -> Bool)
-> (CaseExpr -> CaseExpr -> CaseExpr)
-> (CaseExpr -> CaseExpr -> CaseExpr)
-> Ord CaseExpr
CaseExpr -> CaseExpr -> Bool
CaseExpr -> CaseExpr -> Ordering
CaseExpr -> CaseExpr -> CaseExpr
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
$ccompare :: CaseExpr -> CaseExpr -> Ordering
compare :: CaseExpr -> CaseExpr -> Ordering
$c< :: CaseExpr -> CaseExpr -> Bool
< :: CaseExpr -> CaseExpr -> Bool
$c<= :: CaseExpr -> CaseExpr -> Bool
<= :: CaseExpr -> CaseExpr -> Bool
$c> :: CaseExpr -> CaseExpr -> Bool
> :: CaseExpr -> CaseExpr -> Bool
$c>= :: CaseExpr -> CaseExpr -> Bool
>= :: CaseExpr -> CaseExpr -> Bool
$cmax :: CaseExpr -> CaseExpr -> CaseExpr
max :: CaseExpr -> CaseExpr -> CaseExpr
$cmin :: CaseExpr -> CaseExpr -> CaseExpr
min :: CaseExpr -> CaseExpr -> CaseExpr
Ord)

-- |
-- ==== References
-- @
-- case_arg:
--   | a_expr
--   | EMPTY
-- @
type CaseArg = AExpr

-- |
-- ==== References
-- @
-- when_clause_list:
--   | when_clause
--   | when_clause_list when_clause
-- @
type WhenClauseList = NonEmpty WhenClause

-- |
-- ==== References
-- @
-- case_default:
--   | ELSE a_expr
--   | EMPTY
-- @
type CaseDefault = AExpr

-- |
-- ==== References
-- @
-- when_clause:
--   |  WHEN a_expr THEN a_expr
-- @
data WhenClause = WhenClause AExpr AExpr
  deriving (Int -> WhenClause -> ShowS
[WhenClause] -> ShowS
WhenClause -> String
(Int -> WhenClause -> ShowS)
-> (WhenClause -> String)
-> ([WhenClause] -> ShowS)
-> Show WhenClause
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> WhenClause -> ShowS
showsPrec :: Int -> WhenClause -> ShowS
$cshow :: WhenClause -> String
show :: WhenClause -> String
$cshowList :: [WhenClause] -> ShowS
showList :: [WhenClause] -> ShowS
Show, (forall x. WhenClause -> Rep WhenClause x)
-> (forall x. Rep WhenClause x -> WhenClause) -> Generic WhenClause
forall x. Rep WhenClause x -> WhenClause
forall x. WhenClause -> Rep WhenClause x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. WhenClause -> Rep WhenClause x
from :: forall x. WhenClause -> Rep WhenClause x
$cto :: forall x. Rep WhenClause x -> WhenClause
to :: forall x. Rep WhenClause x -> WhenClause
Generic, WhenClause -> WhenClause -> Bool
(WhenClause -> WhenClause -> Bool)
-> (WhenClause -> WhenClause -> Bool) -> Eq WhenClause
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: WhenClause -> WhenClause -> Bool
== :: WhenClause -> WhenClause -> Bool
$c/= :: WhenClause -> WhenClause -> Bool
/= :: WhenClause -> WhenClause -> Bool
Eq, Eq WhenClause
Eq WhenClause =>
(WhenClause -> WhenClause -> Ordering)
-> (WhenClause -> WhenClause -> Bool)
-> (WhenClause -> WhenClause -> Bool)
-> (WhenClause -> WhenClause -> Bool)
-> (WhenClause -> WhenClause -> Bool)
-> (WhenClause -> WhenClause -> WhenClause)
-> (WhenClause -> WhenClause -> WhenClause)
-> Ord WhenClause
WhenClause -> WhenClause -> Bool
WhenClause -> WhenClause -> Ordering
WhenClause -> WhenClause -> WhenClause
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
$ccompare :: WhenClause -> WhenClause -> Ordering
compare :: WhenClause -> WhenClause -> Ordering
$c< :: WhenClause -> WhenClause -> Bool
< :: WhenClause -> WhenClause -> Bool
$c<= :: WhenClause -> WhenClause -> Bool
<= :: WhenClause -> WhenClause -> Bool
$c> :: WhenClause -> WhenClause -> Bool
> :: WhenClause -> WhenClause -> Bool
$c>= :: WhenClause -> WhenClause -> Bool
>= :: WhenClause -> WhenClause -> Bool
$cmax :: WhenClause -> WhenClause -> WhenClause
max :: WhenClause -> WhenClause -> WhenClause
$cmin :: WhenClause -> WhenClause -> WhenClause
min :: WhenClause -> WhenClause -> WhenClause
Ord)

-- |
-- ==== References
-- @
-- func_application:
--   |  func_name '(' ')'
--   |  func_name '(' func_arg_list opt_sort_clause ')'
--   |  func_name '(' VARIADIC func_arg_expr opt_sort_clause ')'
--   |  func_name '(' func_arg_list ',' VARIADIC func_arg_expr opt_sort_clause ')'
--   |  func_name '(' ALL func_arg_list opt_sort_clause ')'
--   |  func_name '(' DISTINCT func_arg_list opt_sort_clause ')'
--   |  func_name '(' '*' ')'
-- @
data FuncApplication = FuncApplication FuncName (Maybe FuncApplicationParams)
  deriving (Int -> FuncApplication -> ShowS
[FuncApplication] -> ShowS
FuncApplication -> String
(Int -> FuncApplication -> ShowS)
-> (FuncApplication -> String)
-> ([FuncApplication] -> ShowS)
-> Show FuncApplication
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FuncApplication -> ShowS
showsPrec :: Int -> FuncApplication -> ShowS
$cshow :: FuncApplication -> String
show :: FuncApplication -> String
$cshowList :: [FuncApplication] -> ShowS
showList :: [FuncApplication] -> ShowS
Show, (forall x. FuncApplication -> Rep FuncApplication x)
-> (forall x. Rep FuncApplication x -> FuncApplication)
-> Generic FuncApplication
forall x. Rep FuncApplication x -> FuncApplication
forall x. FuncApplication -> Rep FuncApplication x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. FuncApplication -> Rep FuncApplication x
from :: forall x. FuncApplication -> Rep FuncApplication x
$cto :: forall x. Rep FuncApplication x -> FuncApplication
to :: forall x. Rep FuncApplication x -> FuncApplication
Generic, FuncApplication -> FuncApplication -> Bool
(FuncApplication -> FuncApplication -> Bool)
-> (FuncApplication -> FuncApplication -> Bool)
-> Eq FuncApplication
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FuncApplication -> FuncApplication -> Bool
== :: FuncApplication -> FuncApplication -> Bool
$c/= :: FuncApplication -> FuncApplication -> Bool
/= :: FuncApplication -> FuncApplication -> Bool
Eq, Eq FuncApplication
Eq FuncApplication =>
(FuncApplication -> FuncApplication -> Ordering)
-> (FuncApplication -> FuncApplication -> Bool)
-> (FuncApplication -> FuncApplication -> Bool)
-> (FuncApplication -> FuncApplication -> Bool)
-> (FuncApplication -> FuncApplication -> Bool)
-> (FuncApplication -> FuncApplication -> FuncApplication)
-> (FuncApplication -> FuncApplication -> FuncApplication)
-> Ord FuncApplication
FuncApplication -> FuncApplication -> Bool
FuncApplication -> FuncApplication -> Ordering
FuncApplication -> FuncApplication -> FuncApplication
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
$ccompare :: FuncApplication -> FuncApplication -> Ordering
compare :: FuncApplication -> FuncApplication -> Ordering
$c< :: FuncApplication -> FuncApplication -> Bool
< :: FuncApplication -> FuncApplication -> Bool
$c<= :: FuncApplication -> FuncApplication -> Bool
<= :: FuncApplication -> FuncApplication -> Bool
$c> :: FuncApplication -> FuncApplication -> Bool
> :: FuncApplication -> FuncApplication -> Bool
$c>= :: FuncApplication -> FuncApplication -> Bool
>= :: FuncApplication -> FuncApplication -> Bool
$cmax :: FuncApplication -> FuncApplication -> FuncApplication
max :: FuncApplication -> FuncApplication -> FuncApplication
$cmin :: FuncApplication -> FuncApplication -> FuncApplication
min :: FuncApplication -> FuncApplication -> FuncApplication
Ord)

-- |
-- ==== References
-- @
-- func_application:
--   |  func_name '(' ')'
--   |  func_name '(' func_arg_list opt_sort_clause ')'
--   |  func_name '(' VARIADIC func_arg_expr opt_sort_clause ')'
--   |  func_name '(' func_arg_list ',' VARIADIC func_arg_expr opt_sort_clause ')'
--   |  func_name '(' ALL func_arg_list opt_sort_clause ')'
--   |  func_name '(' DISTINCT func_arg_list opt_sort_clause ')'
--   |  func_name '(' '*' ')'
-- @
data FuncApplicationParams
  = NormalFuncApplicationParams (Maybe Bool) (NonEmpty FuncArgExpr) (Maybe SortClause)
  | VariadicFuncApplicationParams (Maybe (NonEmpty FuncArgExpr)) FuncArgExpr (Maybe SortClause)
  | StarFuncApplicationParams
  deriving (Int -> FuncApplicationParams -> ShowS
[FuncApplicationParams] -> ShowS
FuncApplicationParams -> String
(Int -> FuncApplicationParams -> ShowS)
-> (FuncApplicationParams -> String)
-> ([FuncApplicationParams] -> ShowS)
-> Show FuncApplicationParams
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FuncApplicationParams -> ShowS
showsPrec :: Int -> FuncApplicationParams -> ShowS
$cshow :: FuncApplicationParams -> String
show :: FuncApplicationParams -> String
$cshowList :: [FuncApplicationParams] -> ShowS
showList :: [FuncApplicationParams] -> ShowS
Show, (forall x. FuncApplicationParams -> Rep FuncApplicationParams x)
-> (forall x. Rep FuncApplicationParams x -> FuncApplicationParams)
-> Generic FuncApplicationParams
forall x. Rep FuncApplicationParams x -> FuncApplicationParams
forall x. FuncApplicationParams -> Rep FuncApplicationParams x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. FuncApplicationParams -> Rep FuncApplicationParams x
from :: forall x. FuncApplicationParams -> Rep FuncApplicationParams x
$cto :: forall x. Rep FuncApplicationParams x -> FuncApplicationParams
to :: forall x. Rep FuncApplicationParams x -> FuncApplicationParams
Generic, FuncApplicationParams -> FuncApplicationParams -> Bool
(FuncApplicationParams -> FuncApplicationParams -> Bool)
-> (FuncApplicationParams -> FuncApplicationParams -> Bool)
-> Eq FuncApplicationParams
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FuncApplicationParams -> FuncApplicationParams -> Bool
== :: FuncApplicationParams -> FuncApplicationParams -> Bool
$c/= :: FuncApplicationParams -> FuncApplicationParams -> Bool
/= :: FuncApplicationParams -> FuncApplicationParams -> Bool
Eq, Eq FuncApplicationParams
Eq FuncApplicationParams =>
(FuncApplicationParams -> FuncApplicationParams -> Ordering)
-> (FuncApplicationParams -> FuncApplicationParams -> Bool)
-> (FuncApplicationParams -> FuncApplicationParams -> Bool)
-> (FuncApplicationParams -> FuncApplicationParams -> Bool)
-> (FuncApplicationParams -> FuncApplicationParams -> Bool)
-> (FuncApplicationParams
    -> FuncApplicationParams -> FuncApplicationParams)
-> (FuncApplicationParams
    -> FuncApplicationParams -> FuncApplicationParams)
-> Ord FuncApplicationParams
FuncApplicationParams -> FuncApplicationParams -> Bool
FuncApplicationParams -> FuncApplicationParams -> Ordering
FuncApplicationParams
-> FuncApplicationParams -> FuncApplicationParams
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
$ccompare :: FuncApplicationParams -> FuncApplicationParams -> Ordering
compare :: FuncApplicationParams -> FuncApplicationParams -> Ordering
$c< :: FuncApplicationParams -> FuncApplicationParams -> Bool
< :: FuncApplicationParams -> FuncApplicationParams -> Bool
$c<= :: FuncApplicationParams -> FuncApplicationParams -> Bool
<= :: FuncApplicationParams -> FuncApplicationParams -> Bool
$c> :: FuncApplicationParams -> FuncApplicationParams -> Bool
> :: FuncApplicationParams -> FuncApplicationParams -> Bool
$c>= :: FuncApplicationParams -> FuncApplicationParams -> Bool
>= :: FuncApplicationParams -> FuncApplicationParams -> Bool
$cmax :: FuncApplicationParams
-> FuncApplicationParams -> FuncApplicationParams
max :: FuncApplicationParams
-> FuncApplicationParams -> FuncApplicationParams
$cmin :: FuncApplicationParams
-> FuncApplicationParams -> FuncApplicationParams
min :: FuncApplicationParams
-> FuncApplicationParams -> FuncApplicationParams
Ord)

data FuncArgExpr
  = ExprFuncArgExpr AExpr
  | ColonEqualsFuncArgExpr Ident AExpr
  | EqualsGreaterFuncArgExpr Ident AExpr
  deriving (Int -> FuncArgExpr -> ShowS
[FuncArgExpr] -> ShowS
FuncArgExpr -> String
(Int -> FuncArgExpr -> ShowS)
-> (FuncArgExpr -> String)
-> ([FuncArgExpr] -> ShowS)
-> Show FuncArgExpr
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FuncArgExpr -> ShowS
showsPrec :: Int -> FuncArgExpr -> ShowS
$cshow :: FuncArgExpr -> String
show :: FuncArgExpr -> String
$cshowList :: [FuncArgExpr] -> ShowS
showList :: [FuncArgExpr] -> ShowS
Show, (forall x. FuncArgExpr -> Rep FuncArgExpr x)
-> (forall x. Rep FuncArgExpr x -> FuncArgExpr)
-> Generic FuncArgExpr
forall x. Rep FuncArgExpr x -> FuncArgExpr
forall x. FuncArgExpr -> Rep FuncArgExpr x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. FuncArgExpr -> Rep FuncArgExpr x
from :: forall x. FuncArgExpr -> Rep FuncArgExpr x
$cto :: forall x. Rep FuncArgExpr x -> FuncArgExpr
to :: forall x. Rep FuncArgExpr x -> FuncArgExpr
Generic, FuncArgExpr -> FuncArgExpr -> Bool
(FuncArgExpr -> FuncArgExpr -> Bool)
-> (FuncArgExpr -> FuncArgExpr -> Bool) -> Eq FuncArgExpr
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FuncArgExpr -> FuncArgExpr -> Bool
== :: FuncArgExpr -> FuncArgExpr -> Bool
$c/= :: FuncArgExpr -> FuncArgExpr -> Bool
/= :: FuncArgExpr -> FuncArgExpr -> Bool
Eq, Eq FuncArgExpr
Eq FuncArgExpr =>
(FuncArgExpr -> FuncArgExpr -> Ordering)
-> (FuncArgExpr -> FuncArgExpr -> Bool)
-> (FuncArgExpr -> FuncArgExpr -> Bool)
-> (FuncArgExpr -> FuncArgExpr -> Bool)
-> (FuncArgExpr -> FuncArgExpr -> Bool)
-> (FuncArgExpr -> FuncArgExpr -> FuncArgExpr)
-> (FuncArgExpr -> FuncArgExpr -> FuncArgExpr)
-> Ord FuncArgExpr
FuncArgExpr -> FuncArgExpr -> Bool
FuncArgExpr -> FuncArgExpr -> Ordering
FuncArgExpr -> FuncArgExpr -> FuncArgExpr
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
$ccompare :: FuncArgExpr -> FuncArgExpr -> Ordering
compare :: FuncArgExpr -> FuncArgExpr -> Ordering
$c< :: FuncArgExpr -> FuncArgExpr -> Bool
< :: FuncArgExpr -> FuncArgExpr -> Bool
$c<= :: FuncArgExpr -> FuncArgExpr -> Bool
<= :: FuncArgExpr -> FuncArgExpr -> Bool
$c> :: FuncArgExpr -> FuncArgExpr -> Bool
> :: FuncArgExpr -> FuncArgExpr -> Bool
$c>= :: FuncArgExpr -> FuncArgExpr -> Bool
>= :: FuncArgExpr -> FuncArgExpr -> Bool
$cmax :: FuncArgExpr -> FuncArgExpr -> FuncArgExpr
max :: FuncArgExpr -> FuncArgExpr -> FuncArgExpr
$cmin :: FuncArgExpr -> FuncArgExpr -> FuncArgExpr
min :: FuncArgExpr -> FuncArgExpr -> FuncArgExpr
Ord)

-- * Constants

type Sconst = Text

type Iconst = Int64

type Fconst = Double

type Bconst = Text

type Xconst = Text

-- |
-- AexprConst:
--   |  Iconst
--   |  FCONST
--   |  Sconst
--   |  BCONST
--   |  XCONST
--   |  func_name Sconst
--   |  func_name '(' func_arg_list opt_sort_clause ')' Sconst
--   |  ConstTypename Sconst
--   |  ConstInterval Sconst opt_interval
--   |  ConstInterval '(' Iconst ')' Sconst
--   |  TRUE_P
--   |  FALSE_P
--   |  NULL_P
data AexprConst
  = IAexprConst Iconst
  | FAexprConst Fconst
  | SAexprConst Sconst
  | BAexprConst Bconst
  | XAexprConst Xconst
  | FuncAexprConst FuncName (Maybe FuncConstArgs) Sconst
  | ConstTypenameAexprConst ConstTypename Sconst
  | StringIntervalAexprConst Sconst (Maybe Interval)
  | IntIntervalAexprConst Iconst Sconst
  | BoolAexprConst Bool
  | NullAexprConst
  deriving (Int -> AexprConst -> ShowS
[AexprConst] -> ShowS
AexprConst -> String
(Int -> AexprConst -> ShowS)
-> (AexprConst -> String)
-> ([AexprConst] -> ShowS)
-> Show AexprConst
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> AexprConst -> ShowS
showsPrec :: Int -> AexprConst -> ShowS
$cshow :: AexprConst -> String
show :: AexprConst -> String
$cshowList :: [AexprConst] -> ShowS
showList :: [AexprConst] -> ShowS
Show, (forall x. AexprConst -> Rep AexprConst x)
-> (forall x. Rep AexprConst x -> AexprConst) -> Generic AexprConst
forall x. Rep AexprConst x -> AexprConst
forall x. AexprConst -> Rep AexprConst x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. AexprConst -> Rep AexprConst x
from :: forall x. AexprConst -> Rep AexprConst x
$cto :: forall x. Rep AexprConst x -> AexprConst
to :: forall x. Rep AexprConst x -> AexprConst
Generic, AexprConst -> AexprConst -> Bool
(AexprConst -> AexprConst -> Bool)
-> (AexprConst -> AexprConst -> Bool) -> Eq AexprConst
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AexprConst -> AexprConst -> Bool
== :: AexprConst -> AexprConst -> Bool
$c/= :: AexprConst -> AexprConst -> Bool
/= :: AexprConst -> AexprConst -> Bool
Eq, Eq AexprConst
Eq AexprConst =>
(AexprConst -> AexprConst -> Ordering)
-> (AexprConst -> AexprConst -> Bool)
-> (AexprConst -> AexprConst -> Bool)
-> (AexprConst -> AexprConst -> Bool)
-> (AexprConst -> AexprConst -> Bool)
-> (AexprConst -> AexprConst -> AexprConst)
-> (AexprConst -> AexprConst -> AexprConst)
-> Ord AexprConst
AexprConst -> AexprConst -> Bool
AexprConst -> AexprConst -> Ordering
AexprConst -> AexprConst -> AexprConst
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
$ccompare :: AexprConst -> AexprConst -> Ordering
compare :: AexprConst -> AexprConst -> Ordering
$c< :: AexprConst -> AexprConst -> Bool
< :: AexprConst -> AexprConst -> Bool
$c<= :: AexprConst -> AexprConst -> Bool
<= :: AexprConst -> AexprConst -> Bool
$c> :: AexprConst -> AexprConst -> Bool
> :: AexprConst -> AexprConst -> Bool
$c>= :: AexprConst -> AexprConst -> Bool
>= :: AexprConst -> AexprConst -> Bool
$cmax :: AexprConst -> AexprConst -> AexprConst
max :: AexprConst -> AexprConst -> AexprConst
$cmin :: AexprConst -> AexprConst -> AexprConst
min :: AexprConst -> AexprConst -> AexprConst
Ord)

-- |
-- ==== References
-- @
--   |  func_name '(' func_arg_list opt_sort_clause ')' Sconst
-- @
data FuncConstArgs = FuncConstArgs (NonEmpty FuncArgExpr) (Maybe SortClause)
  deriving (Int -> FuncConstArgs -> ShowS
[FuncConstArgs] -> ShowS
FuncConstArgs -> String
(Int -> FuncConstArgs -> ShowS)
-> (FuncConstArgs -> String)
-> ([FuncConstArgs] -> ShowS)
-> Show FuncConstArgs
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FuncConstArgs -> ShowS
showsPrec :: Int -> FuncConstArgs -> ShowS
$cshow :: FuncConstArgs -> String
show :: FuncConstArgs -> String
$cshowList :: [FuncConstArgs] -> ShowS
showList :: [FuncConstArgs] -> ShowS
Show, (forall x. FuncConstArgs -> Rep FuncConstArgs x)
-> (forall x. Rep FuncConstArgs x -> FuncConstArgs)
-> Generic FuncConstArgs
forall x. Rep FuncConstArgs x -> FuncConstArgs
forall x. FuncConstArgs -> Rep FuncConstArgs x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. FuncConstArgs -> Rep FuncConstArgs x
from :: forall x. FuncConstArgs -> Rep FuncConstArgs x
$cto :: forall x. Rep FuncConstArgs x -> FuncConstArgs
to :: forall x. Rep FuncConstArgs x -> FuncConstArgs
Generic, FuncConstArgs -> FuncConstArgs -> Bool
(FuncConstArgs -> FuncConstArgs -> Bool)
-> (FuncConstArgs -> FuncConstArgs -> Bool) -> Eq FuncConstArgs
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FuncConstArgs -> FuncConstArgs -> Bool
== :: FuncConstArgs -> FuncConstArgs -> Bool
$c/= :: FuncConstArgs -> FuncConstArgs -> Bool
/= :: FuncConstArgs -> FuncConstArgs -> Bool
Eq, Eq FuncConstArgs
Eq FuncConstArgs =>
(FuncConstArgs -> FuncConstArgs -> Ordering)
-> (FuncConstArgs -> FuncConstArgs -> Bool)
-> (FuncConstArgs -> FuncConstArgs -> Bool)
-> (FuncConstArgs -> FuncConstArgs -> Bool)
-> (FuncConstArgs -> FuncConstArgs -> Bool)
-> (FuncConstArgs -> FuncConstArgs -> FuncConstArgs)
-> (FuncConstArgs -> FuncConstArgs -> FuncConstArgs)
-> Ord FuncConstArgs
FuncConstArgs -> FuncConstArgs -> Bool
FuncConstArgs -> FuncConstArgs -> Ordering
FuncConstArgs -> FuncConstArgs -> FuncConstArgs
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
$ccompare :: FuncConstArgs -> FuncConstArgs -> Ordering
compare :: FuncConstArgs -> FuncConstArgs -> Ordering
$c< :: FuncConstArgs -> FuncConstArgs -> Bool
< :: FuncConstArgs -> FuncConstArgs -> Bool
$c<= :: FuncConstArgs -> FuncConstArgs -> Bool
<= :: FuncConstArgs -> FuncConstArgs -> Bool
$c> :: FuncConstArgs -> FuncConstArgs -> Bool
> :: FuncConstArgs -> FuncConstArgs -> Bool
$c>= :: FuncConstArgs -> FuncConstArgs -> Bool
>= :: FuncConstArgs -> FuncConstArgs -> Bool
$cmax :: FuncConstArgs -> FuncConstArgs -> FuncConstArgs
max :: FuncConstArgs -> FuncConstArgs -> FuncConstArgs
$cmin :: FuncConstArgs -> FuncConstArgs -> FuncConstArgs
min :: FuncConstArgs -> FuncConstArgs -> FuncConstArgs
Ord)

-- |
-- ==== References
-- @
-- ConstTypename:
--   | Numeric
--   | ConstBit
--   | ConstCharacter
--   | ConstDatetime
-- @
data ConstTypename
  = NumericConstTypename Numeric
  | ConstBitConstTypename ConstBit
  | ConstCharacterConstTypename ConstCharacter
  | ConstDatetimeConstTypename ConstDatetime
  deriving (Int -> ConstTypename -> ShowS
[ConstTypename] -> ShowS
ConstTypename -> String
(Int -> ConstTypename -> ShowS)
-> (ConstTypename -> String)
-> ([ConstTypename] -> ShowS)
-> Show ConstTypename
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ConstTypename -> ShowS
showsPrec :: Int -> ConstTypename -> ShowS
$cshow :: ConstTypename -> String
show :: ConstTypename -> String
$cshowList :: [ConstTypename] -> ShowS
showList :: [ConstTypename] -> ShowS
Show, (forall x. ConstTypename -> Rep ConstTypename x)
-> (forall x. Rep ConstTypename x -> ConstTypename)
-> Generic ConstTypename
forall x. Rep ConstTypename x -> ConstTypename
forall x. ConstTypename -> Rep ConstTypename x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ConstTypename -> Rep ConstTypename x
from :: forall x. ConstTypename -> Rep ConstTypename x
$cto :: forall x. Rep ConstTypename x -> ConstTypename
to :: forall x. Rep ConstTypename x -> ConstTypename
Generic, ConstTypename -> ConstTypename -> Bool
(ConstTypename -> ConstTypename -> Bool)
-> (ConstTypename -> ConstTypename -> Bool) -> Eq ConstTypename
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ConstTypename -> ConstTypename -> Bool
== :: ConstTypename -> ConstTypename -> Bool
$c/= :: ConstTypename -> ConstTypename -> Bool
/= :: ConstTypename -> ConstTypename -> Bool
Eq, Eq ConstTypename
Eq ConstTypename =>
(ConstTypename -> ConstTypename -> Ordering)
-> (ConstTypename -> ConstTypename -> Bool)
-> (ConstTypename -> ConstTypename -> Bool)
-> (ConstTypename -> ConstTypename -> Bool)
-> (ConstTypename -> ConstTypename -> Bool)
-> (ConstTypename -> ConstTypename -> ConstTypename)
-> (ConstTypename -> ConstTypename -> ConstTypename)
-> Ord ConstTypename
ConstTypename -> ConstTypename -> Bool
ConstTypename -> ConstTypename -> Ordering
ConstTypename -> ConstTypename -> ConstTypename
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
$ccompare :: ConstTypename -> ConstTypename -> Ordering
compare :: ConstTypename -> ConstTypename -> Ordering
$c< :: ConstTypename -> ConstTypename -> Bool
< :: ConstTypename -> ConstTypename -> Bool
$c<= :: ConstTypename -> ConstTypename -> Bool
<= :: ConstTypename -> ConstTypename -> Bool
$c> :: ConstTypename -> ConstTypename -> Bool
> :: ConstTypename -> ConstTypename -> Bool
$c>= :: ConstTypename -> ConstTypename -> Bool
>= :: ConstTypename -> ConstTypename -> Bool
$cmax :: ConstTypename -> ConstTypename -> ConstTypename
max :: ConstTypename -> ConstTypename -> ConstTypename
$cmin :: ConstTypename -> ConstTypename -> ConstTypename
min :: ConstTypename -> ConstTypename -> ConstTypename
Ord)

-- |
-- ==== References
-- @
-- Numeric:
--   | INT_P
--   | INTEGER
--   | SMALLINT
--   | BIGINT
--   | REAL
--   | FLOAT_P opt_float
--   | DOUBLE_P PRECISION
--   | DECIMAL_P opt_type_modifiers
--   | DEC opt_type_modifiers
--   | NUMERIC opt_type_modifiers
--   | BOOLEAN_P
-- opt_float:
--   | '(' Iconst ')'
--   | EMPTY
-- opt_type_modifiers:
--   | '(' expr_list ')'
--   | EMPTY
-- @
data Numeric
  = IntNumeric
  | IntegerNumeric
  | SmallintNumeric
  | BigintNumeric
  | RealNumeric
  | FloatNumeric (Maybe Int64)
  | DoublePrecisionNumeric
  | DecimalNumeric (Maybe TypeModifiers)
  | DecNumeric (Maybe TypeModifiers)
  | NumericNumeric (Maybe TypeModifiers)
  | BooleanNumeric
  deriving (Int -> Numeric -> ShowS
[Numeric] -> ShowS
Numeric -> String
(Int -> Numeric -> ShowS)
-> (Numeric -> String) -> ([Numeric] -> ShowS) -> Show Numeric
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Numeric -> ShowS
showsPrec :: Int -> Numeric -> ShowS
$cshow :: Numeric -> String
show :: Numeric -> String
$cshowList :: [Numeric] -> ShowS
showList :: [Numeric] -> ShowS
Show, (forall x. Numeric -> Rep Numeric x)
-> (forall x. Rep Numeric x -> Numeric) -> Generic Numeric
forall x. Rep Numeric x -> Numeric
forall x. Numeric -> Rep Numeric x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Numeric -> Rep Numeric x
from :: forall x. Numeric -> Rep Numeric x
$cto :: forall x. Rep Numeric x -> Numeric
to :: forall x. Rep Numeric x -> Numeric
Generic, Numeric -> Numeric -> Bool
(Numeric -> Numeric -> Bool)
-> (Numeric -> Numeric -> Bool) -> Eq Numeric
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Numeric -> Numeric -> Bool
== :: Numeric -> Numeric -> Bool
$c/= :: Numeric -> Numeric -> Bool
/= :: Numeric -> Numeric -> Bool
Eq, Eq Numeric
Eq Numeric =>
(Numeric -> Numeric -> Ordering)
-> (Numeric -> Numeric -> Bool)
-> (Numeric -> Numeric -> Bool)
-> (Numeric -> Numeric -> Bool)
-> (Numeric -> Numeric -> Bool)
-> (Numeric -> Numeric -> Numeric)
-> (Numeric -> Numeric -> Numeric)
-> Ord Numeric
Numeric -> Numeric -> Bool
Numeric -> Numeric -> Ordering
Numeric -> Numeric -> Numeric
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
$ccompare :: Numeric -> Numeric -> Ordering
compare :: Numeric -> Numeric -> Ordering
$c< :: Numeric -> Numeric -> Bool
< :: Numeric -> Numeric -> Bool
$c<= :: Numeric -> Numeric -> Bool
<= :: Numeric -> Numeric -> Bool
$c> :: Numeric -> Numeric -> Bool
> :: Numeric -> Numeric -> Bool
$c>= :: Numeric -> Numeric -> Bool
>= :: Numeric -> Numeric -> Bool
$cmax :: Numeric -> Numeric -> Numeric
max :: Numeric -> Numeric -> Numeric
$cmin :: Numeric -> Numeric -> Numeric
min :: Numeric -> Numeric -> Numeric
Ord)

-- |
-- ==== References
-- @
-- Bit:
--   | BitWithLength
--   | BitWithoutLength
-- ConstBit:
--   | BitWithLength
--   | BitWithoutLength
-- BitWithLength:
--   | BIT opt_varying '(' expr_list ')'
-- BitWithoutLength:
--   | BIT opt_varying
-- @
data Bit = Bit OptVarying (Maybe ExprList)
  deriving (Int -> ConstBit -> ShowS
[ConstBit] -> ShowS
ConstBit -> String
(Int -> ConstBit -> ShowS)
-> (ConstBit -> String) -> ([ConstBit] -> ShowS) -> Show ConstBit
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ConstBit -> ShowS
showsPrec :: Int -> ConstBit -> ShowS
$cshow :: ConstBit -> String
show :: ConstBit -> String
$cshowList :: [ConstBit] -> ShowS
showList :: [ConstBit] -> ShowS
Show, (forall x. ConstBit -> Rep ConstBit x)
-> (forall x. Rep ConstBit x -> ConstBit) -> Generic ConstBit
forall x. Rep ConstBit x -> ConstBit
forall x. ConstBit -> Rep ConstBit x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ConstBit -> Rep ConstBit x
from :: forall x. ConstBit -> Rep ConstBit x
$cto :: forall x. Rep ConstBit x -> ConstBit
to :: forall x. Rep ConstBit x -> ConstBit
Generic, ConstBit -> ConstBit -> Bool
(ConstBit -> ConstBit -> Bool)
-> (ConstBit -> ConstBit -> Bool) -> Eq ConstBit
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ConstBit -> ConstBit -> Bool
== :: ConstBit -> ConstBit -> Bool
$c/= :: ConstBit -> ConstBit -> Bool
/= :: ConstBit -> ConstBit -> Bool
Eq, Eq ConstBit
Eq ConstBit =>
(ConstBit -> ConstBit -> Ordering)
-> (ConstBit -> ConstBit -> Bool)
-> (ConstBit -> ConstBit -> Bool)
-> (ConstBit -> ConstBit -> Bool)
-> (ConstBit -> ConstBit -> Bool)
-> (ConstBit -> ConstBit -> ConstBit)
-> (ConstBit -> ConstBit -> ConstBit)
-> Ord ConstBit
ConstBit -> ConstBit -> Bool
ConstBit -> ConstBit -> Ordering
ConstBit -> ConstBit -> ConstBit
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
$ccompare :: ConstBit -> ConstBit -> Ordering
compare :: ConstBit -> ConstBit -> Ordering
$c< :: ConstBit -> ConstBit -> Bool
< :: ConstBit -> ConstBit -> Bool
$c<= :: ConstBit -> ConstBit -> Bool
<= :: ConstBit -> ConstBit -> Bool
$c> :: ConstBit -> ConstBit -> Bool
> :: ConstBit -> ConstBit -> Bool
$c>= :: ConstBit -> ConstBit -> Bool
>= :: ConstBit -> ConstBit -> Bool
$cmax :: ConstBit -> ConstBit -> ConstBit
max :: ConstBit -> ConstBit -> ConstBit
$cmin :: ConstBit -> ConstBit -> ConstBit
min :: ConstBit -> ConstBit -> ConstBit
Ord)

type ConstBit = Bit

-- |
-- ==== References
-- @
-- opt_varying:
--   | VARYING
--   | EMPTY
-- @
type OptVarying = Bool

-- |
-- ==== References
-- @
-- Character:
--   | CharacterWithLength
--   | CharacterWithoutLength
-- ConstCharacter:
--   | CharacterWithLength
--   | CharacterWithoutLength
-- CharacterWithLength:
--   | character '(' Iconst ')'
-- CharacterWithoutLength:
--   | character
-- @
data ConstCharacter = ConstCharacter Character (Maybe Int64)
  deriving (Int -> ConstCharacter -> ShowS
[ConstCharacter] -> ShowS
ConstCharacter -> String
(Int -> ConstCharacter -> ShowS)
-> (ConstCharacter -> String)
-> ([ConstCharacter] -> ShowS)
-> Show ConstCharacter
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ConstCharacter -> ShowS
showsPrec :: Int -> ConstCharacter -> ShowS
$cshow :: ConstCharacter -> String
show :: ConstCharacter -> String
$cshowList :: [ConstCharacter] -> ShowS
showList :: [ConstCharacter] -> ShowS
Show, (forall x. ConstCharacter -> Rep ConstCharacter x)
-> (forall x. Rep ConstCharacter x -> ConstCharacter)
-> Generic ConstCharacter
forall x. Rep ConstCharacter x -> ConstCharacter
forall x. ConstCharacter -> Rep ConstCharacter x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ConstCharacter -> Rep ConstCharacter x
from :: forall x. ConstCharacter -> Rep ConstCharacter x
$cto :: forall x. Rep ConstCharacter x -> ConstCharacter
to :: forall x. Rep ConstCharacter x -> ConstCharacter
Generic, ConstCharacter -> ConstCharacter -> Bool
(ConstCharacter -> ConstCharacter -> Bool)
-> (ConstCharacter -> ConstCharacter -> Bool) -> Eq ConstCharacter
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ConstCharacter -> ConstCharacter -> Bool
== :: ConstCharacter -> ConstCharacter -> Bool
$c/= :: ConstCharacter -> ConstCharacter -> Bool
/= :: ConstCharacter -> ConstCharacter -> Bool
Eq, Eq ConstCharacter
Eq ConstCharacter =>
(ConstCharacter -> ConstCharacter -> Ordering)
-> (ConstCharacter -> ConstCharacter -> Bool)
-> (ConstCharacter -> ConstCharacter -> Bool)
-> (ConstCharacter -> ConstCharacter -> Bool)
-> (ConstCharacter -> ConstCharacter -> Bool)
-> (ConstCharacter -> ConstCharacter -> ConstCharacter)
-> (ConstCharacter -> ConstCharacter -> ConstCharacter)
-> Ord ConstCharacter
ConstCharacter -> ConstCharacter -> Bool
ConstCharacter -> ConstCharacter -> Ordering
ConstCharacter -> ConstCharacter -> ConstCharacter
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
$ccompare :: ConstCharacter -> ConstCharacter -> Ordering
compare :: ConstCharacter -> ConstCharacter -> Ordering
$c< :: ConstCharacter -> ConstCharacter -> Bool
< :: ConstCharacter -> ConstCharacter -> Bool
$c<= :: ConstCharacter -> ConstCharacter -> Bool
<= :: ConstCharacter -> ConstCharacter -> Bool
$c> :: ConstCharacter -> ConstCharacter -> Bool
> :: ConstCharacter -> ConstCharacter -> Bool
$c>= :: ConstCharacter -> ConstCharacter -> Bool
>= :: ConstCharacter -> ConstCharacter -> Bool
$cmax :: ConstCharacter -> ConstCharacter -> ConstCharacter
max :: ConstCharacter -> ConstCharacter -> ConstCharacter
$cmin :: ConstCharacter -> ConstCharacter -> ConstCharacter
min :: ConstCharacter -> ConstCharacter -> ConstCharacter
Ord)

-- |
-- ==== References
-- @
-- character:
--   | CHARACTER opt_varying
--   | CHAR_P opt_varying
--   | VARCHAR
--   | NATIONAL CHARACTER opt_varying
--   | NATIONAL CHAR_P opt_varying
--   | NCHAR opt_varying
-- @
data Character
  = CharacterCharacter OptVarying
  | CharCharacter OptVarying
  | VarcharCharacter
  | NationalCharacterCharacter OptVarying
  | NationalCharCharacter OptVarying
  | NcharCharacter OptVarying
  deriving (Int -> Character -> ShowS
[Character] -> ShowS
Character -> String
(Int -> Character -> ShowS)
-> (Character -> String)
-> ([Character] -> ShowS)
-> Show Character
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Character -> ShowS
showsPrec :: Int -> Character -> ShowS
$cshow :: Character -> String
show :: Character -> String
$cshowList :: [Character] -> ShowS
showList :: [Character] -> ShowS
Show, (forall x. Character -> Rep Character x)
-> (forall x. Rep Character x -> Character) -> Generic Character
forall x. Rep Character x -> Character
forall x. Character -> Rep Character x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Character -> Rep Character x
from :: forall x. Character -> Rep Character x
$cto :: forall x. Rep Character x -> Character
to :: forall x. Rep Character x -> Character
Generic, Character -> Character -> Bool
(Character -> Character -> Bool)
-> (Character -> Character -> Bool) -> Eq Character
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Character -> Character -> Bool
== :: Character -> Character -> Bool
$c/= :: Character -> Character -> Bool
/= :: Character -> Character -> Bool
Eq, Eq Character
Eq Character =>
(Character -> Character -> Ordering)
-> (Character -> Character -> Bool)
-> (Character -> Character -> Bool)
-> (Character -> Character -> Bool)
-> (Character -> Character -> Bool)
-> (Character -> Character -> Character)
-> (Character -> Character -> Character)
-> Ord Character
Character -> Character -> Bool
Character -> Character -> Ordering
Character -> Character -> Character
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
$ccompare :: Character -> Character -> Ordering
compare :: Character -> Character -> Ordering
$c< :: Character -> Character -> Bool
< :: Character -> Character -> Bool
$c<= :: Character -> Character -> Bool
<= :: Character -> Character -> Bool
$c> :: Character -> Character -> Bool
> :: Character -> Character -> Bool
$c>= :: Character -> Character -> Bool
>= :: Character -> Character -> Bool
$cmax :: Character -> Character -> Character
max :: Character -> Character -> Character
$cmin :: Character -> Character -> Character
min :: Character -> Character -> Character
Ord)

-- |
-- ==== References
-- @
-- ConstDatetime:
--   | TIMESTAMP '(' Iconst ')' opt_timezone
--   | TIMESTAMP opt_timezone
--   | TIME '(' Iconst ')' opt_timezone
--   | TIME opt_timezone
-- @
data ConstDatetime
  = TimestampConstDatetime (Maybe Int64) (Maybe Timezone)
  | TimeConstDatetime (Maybe Int64) (Maybe Timezone)
  deriving (Int -> ConstDatetime -> ShowS
[ConstDatetime] -> ShowS
ConstDatetime -> String
(Int -> ConstDatetime -> ShowS)
-> (ConstDatetime -> String)
-> ([ConstDatetime] -> ShowS)
-> Show ConstDatetime
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ConstDatetime -> ShowS
showsPrec :: Int -> ConstDatetime -> ShowS
$cshow :: ConstDatetime -> String
show :: ConstDatetime -> String
$cshowList :: [ConstDatetime] -> ShowS
showList :: [ConstDatetime] -> ShowS
Show, (forall x. ConstDatetime -> Rep ConstDatetime x)
-> (forall x. Rep ConstDatetime x -> ConstDatetime)
-> Generic ConstDatetime
forall x. Rep ConstDatetime x -> ConstDatetime
forall x. ConstDatetime -> Rep ConstDatetime x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ConstDatetime -> Rep ConstDatetime x
from :: forall x. ConstDatetime -> Rep ConstDatetime x
$cto :: forall x. Rep ConstDatetime x -> ConstDatetime
to :: forall x. Rep ConstDatetime x -> ConstDatetime
Generic, ConstDatetime -> ConstDatetime -> Bool
(ConstDatetime -> ConstDatetime -> Bool)
-> (ConstDatetime -> ConstDatetime -> Bool) -> Eq ConstDatetime
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ConstDatetime -> ConstDatetime -> Bool
== :: ConstDatetime -> ConstDatetime -> Bool
$c/= :: ConstDatetime -> ConstDatetime -> Bool
/= :: ConstDatetime -> ConstDatetime -> Bool
Eq, Eq ConstDatetime
Eq ConstDatetime =>
(ConstDatetime -> ConstDatetime -> Ordering)
-> (ConstDatetime -> ConstDatetime -> Bool)
-> (ConstDatetime -> ConstDatetime -> Bool)
-> (ConstDatetime -> ConstDatetime -> Bool)
-> (ConstDatetime -> ConstDatetime -> Bool)
-> (ConstDatetime -> ConstDatetime -> ConstDatetime)
-> (ConstDatetime -> ConstDatetime -> ConstDatetime)
-> Ord ConstDatetime
ConstDatetime -> ConstDatetime -> Bool
ConstDatetime -> ConstDatetime -> Ordering
ConstDatetime -> ConstDatetime -> ConstDatetime
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
$ccompare :: ConstDatetime -> ConstDatetime -> Ordering
compare :: ConstDatetime -> ConstDatetime -> Ordering
$c< :: ConstDatetime -> ConstDatetime -> Bool
< :: ConstDatetime -> ConstDatetime -> Bool
$c<= :: ConstDatetime -> ConstDatetime -> Bool
<= :: ConstDatetime -> ConstDatetime -> Bool
$c> :: ConstDatetime -> ConstDatetime -> Bool
> :: ConstDatetime -> ConstDatetime -> Bool
$c>= :: ConstDatetime -> ConstDatetime -> Bool
>= :: ConstDatetime -> ConstDatetime -> Bool
$cmax :: ConstDatetime -> ConstDatetime -> ConstDatetime
max :: ConstDatetime -> ConstDatetime -> ConstDatetime
$cmin :: ConstDatetime -> ConstDatetime -> ConstDatetime
min :: ConstDatetime -> ConstDatetime -> ConstDatetime
Ord)

-- |
-- ==== References
-- @
-- opt_timezone:
--   | WITH_LA TIME ZONE
--   | WITHOUT TIME ZONE
--   | EMPTY
-- @
type Timezone = Bool

-- |
-- ==== References
-- @
-- opt_interval:
--   | YEAR_P
--   | MONTH_P
--   | DAY_P
--   | HOUR_P
--   | MINUTE_P
--   | interval_second
--   | YEAR_P TO MONTH_P
--   | DAY_P TO HOUR_P
--   | DAY_P TO MINUTE_P
--   | DAY_P TO interval_second
--   | HOUR_P TO MINUTE_P
--   | HOUR_P TO interval_second
--   | MINUTE_P TO interval_second
--   | EMPTY
-- @
data Interval
  = YearInterval
  | MonthInterval
  | DayInterval
  | HourInterval
  | MinuteInterval
  | SecondInterval IntervalSecond
  | YearToMonthInterval
  | DayToHourInterval
  | DayToMinuteInterval
  | DayToSecondInterval IntervalSecond
  | HourToMinuteInterval
  | HourToSecondInterval IntervalSecond
  | MinuteToSecondInterval IntervalSecond
  deriving (Int -> Interval -> ShowS
[Interval] -> ShowS
Interval -> String
(Int -> Interval -> ShowS)
-> (Interval -> String) -> ([Interval] -> ShowS) -> Show Interval
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Interval -> ShowS
showsPrec :: Int -> Interval -> ShowS
$cshow :: Interval -> String
show :: Interval -> String
$cshowList :: [Interval] -> ShowS
showList :: [Interval] -> ShowS
Show, (forall x. Interval -> Rep Interval x)
-> (forall x. Rep Interval x -> Interval) -> Generic Interval
forall x. Rep Interval x -> Interval
forall x. Interval -> Rep Interval x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Interval -> Rep Interval x
from :: forall x. Interval -> Rep Interval x
$cto :: forall x. Rep Interval x -> Interval
to :: forall x. Rep Interval x -> Interval
Generic, Interval -> Interval -> Bool
(Interval -> Interval -> Bool)
-> (Interval -> Interval -> Bool) -> Eq Interval
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Interval -> Interval -> Bool
== :: Interval -> Interval -> Bool
$c/= :: Interval -> Interval -> Bool
/= :: Interval -> Interval -> Bool
Eq, Eq Interval
Eq Interval =>
(Interval -> Interval -> Ordering)
-> (Interval -> Interval -> Bool)
-> (Interval -> Interval -> Bool)
-> (Interval -> Interval -> Bool)
-> (Interval -> Interval -> Bool)
-> (Interval -> Interval -> Interval)
-> (Interval -> Interval -> Interval)
-> Ord Interval
Interval -> Interval -> Bool
Interval -> Interval -> Ordering
Interval -> Interval -> Interval
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
$ccompare :: Interval -> Interval -> Ordering
compare :: Interval -> Interval -> Ordering
$c< :: Interval -> Interval -> Bool
< :: Interval -> Interval -> Bool
$c<= :: Interval -> Interval -> Bool
<= :: Interval -> Interval -> Bool
$c> :: Interval -> Interval -> Bool
> :: Interval -> Interval -> Bool
$c>= :: Interval -> Interval -> Bool
>= :: Interval -> Interval -> Bool
$cmax :: Interval -> Interval -> Interval
max :: Interval -> Interval -> Interval
$cmin :: Interval -> Interval -> Interval
min :: Interval -> Interval -> Interval
Ord)

-- |
-- ==== References
-- @
-- interval_second:
--   | SECOND_P
--   | SECOND_P '(' Iconst ')'
-- @
type IntervalSecond = Maybe Int64

-- * Names & References

-- |
-- ==== References
-- @
-- IDENT
-- @
data Ident = QuotedIdent Text | UnquotedIdent Text
  deriving (Int -> ColId -> ShowS
[ColId] -> ShowS
ColId -> String
(Int -> ColId -> ShowS)
-> (ColId -> String) -> ([ColId] -> ShowS) -> Show ColId
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ColId -> ShowS
showsPrec :: Int -> ColId -> ShowS
$cshow :: ColId -> String
show :: ColId -> String
$cshowList :: [ColId] -> ShowS
showList :: [ColId] -> ShowS
Show, (forall x. ColId -> Rep ColId x)
-> (forall x. Rep ColId x -> ColId) -> Generic ColId
forall x. Rep ColId x -> ColId
forall x. ColId -> Rep ColId x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ColId -> Rep ColId x
from :: forall x. ColId -> Rep ColId x
$cto :: forall x. Rep ColId x -> ColId
to :: forall x. Rep ColId x -> ColId
Generic, ColId -> ColId -> Bool
(ColId -> ColId -> Bool) -> (ColId -> ColId -> Bool) -> Eq ColId
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ColId -> ColId -> Bool
== :: ColId -> ColId -> Bool
$c/= :: ColId -> ColId -> Bool
/= :: ColId -> ColId -> Bool
Eq, Eq ColId
Eq ColId =>
(ColId -> ColId -> Ordering)
-> (ColId -> ColId -> Bool)
-> (ColId -> ColId -> Bool)
-> (ColId -> ColId -> Bool)
-> (ColId -> ColId -> Bool)
-> (ColId -> ColId -> ColId)
-> (ColId -> ColId -> ColId)
-> Ord ColId
ColId -> ColId -> Bool
ColId -> ColId -> Ordering
ColId -> ColId -> ColId
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
$ccompare :: ColId -> ColId -> Ordering
compare :: ColId -> ColId -> Ordering
$c< :: ColId -> ColId -> Bool
< :: ColId -> ColId -> Bool
$c<= :: ColId -> ColId -> Bool
<= :: ColId -> ColId -> Bool
$c> :: ColId -> ColId -> Bool
> :: ColId -> ColId -> Bool
$c>= :: ColId -> ColId -> Bool
>= :: ColId -> ColId -> Bool
$cmax :: ColId -> ColId -> ColId
max :: ColId -> ColId -> ColId
$cmin :: ColId -> ColId -> ColId
min :: ColId -> ColId -> ColId
Ord)

-- |
-- ==== References
-- @
-- ColId:
--   | IDENT
--   | unreserved_keyword
--   | col_name_keyword
-- @
type ColId = Ident

-- |
-- ==== References
-- @
-- ColLabel:
--   | IDENT
--   | unreserved_keyword
--   | col_name_keyword
--   | type_func_name_keyword
--   | reserved_keyword
-- @
type ColLabel = Ident

-- |
-- ==== References
-- @
-- name:
--   | ColId
-- @
type Name = ColId

-- |
-- ==== References
-- @
-- name_list:
--   | name
--   | name_list ',' name
-- @
type NameList = NonEmpty Name

-- |
-- ==== References
-- @
-- cursor_name:
--   | name
-- @
type CursorName = Name

-- |
-- ==== References
-- @
-- columnref:
--   | ColId
--   | ColId indirection
-- @
data Columnref = Columnref ColId (Maybe Indirection)
  deriving (Int -> Columnref -> ShowS
[Columnref] -> ShowS
Columnref -> String
(Int -> Columnref -> ShowS)
-> (Columnref -> String)
-> ([Columnref] -> ShowS)
-> Show Columnref
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Columnref -> ShowS
showsPrec :: Int -> Columnref -> ShowS
$cshow :: Columnref -> String
show :: Columnref -> String
$cshowList :: [Columnref] -> ShowS
showList :: [Columnref] -> ShowS
Show, (forall x. Columnref -> Rep Columnref x)
-> (forall x. Rep Columnref x -> Columnref) -> Generic Columnref
forall x. Rep Columnref x -> Columnref
forall x. Columnref -> Rep Columnref x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Columnref -> Rep Columnref x
from :: forall x. Columnref -> Rep Columnref x
$cto :: forall x. Rep Columnref x -> Columnref
to :: forall x. Rep Columnref x -> Columnref
Generic, Columnref -> Columnref -> Bool
(Columnref -> Columnref -> Bool)
-> (Columnref -> Columnref -> Bool) -> Eq Columnref
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Columnref -> Columnref -> Bool
== :: Columnref -> Columnref -> Bool
$c/= :: Columnref -> Columnref -> Bool
/= :: Columnref -> Columnref -> Bool
Eq, Eq Columnref
Eq Columnref =>
(Columnref -> Columnref -> Ordering)
-> (Columnref -> Columnref -> Bool)
-> (Columnref -> Columnref -> Bool)
-> (Columnref -> Columnref -> Bool)
-> (Columnref -> Columnref -> Bool)
-> (Columnref -> Columnref -> Columnref)
-> (Columnref -> Columnref -> Columnref)
-> Ord Columnref
Columnref -> Columnref -> Bool
Columnref -> Columnref -> Ordering
Columnref -> Columnref -> Columnref
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
$ccompare :: Columnref -> Columnref -> Ordering
compare :: Columnref -> Columnref -> Ordering
$c< :: Columnref -> Columnref -> Bool
< :: Columnref -> Columnref -> Bool
$c<= :: Columnref -> Columnref -> Bool
<= :: Columnref -> Columnref -> Bool
$c> :: Columnref -> Columnref -> Bool
> :: Columnref -> Columnref -> Bool
$c>= :: Columnref -> Columnref -> Bool
>= :: Columnref -> Columnref -> Bool
$cmax :: Columnref -> Columnref -> Columnref
max :: Columnref -> Columnref -> Columnref
$cmin :: Columnref -> Columnref -> Columnref
min :: Columnref -> Columnref -> Columnref
Ord)

-- |
-- ==== References
-- @
-- any_name:
--   | ColId
--   | ColId attrs
-- @
data AnyName = AnyName ColId (Maybe Attrs)
  deriving (Int -> CollateClause -> ShowS
[CollateClause] -> ShowS
CollateClause -> String
(Int -> CollateClause -> ShowS)
-> (CollateClause -> String)
-> ([CollateClause] -> ShowS)
-> Show CollateClause
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CollateClause -> ShowS
showsPrec :: Int -> CollateClause -> ShowS
$cshow :: CollateClause -> String
show :: CollateClause -> String
$cshowList :: [CollateClause] -> ShowS
showList :: [CollateClause] -> ShowS
Show, (forall x. CollateClause -> Rep CollateClause x)
-> (forall x. Rep CollateClause x -> CollateClause)
-> Generic CollateClause
forall x. Rep CollateClause x -> CollateClause
forall x. CollateClause -> Rep CollateClause x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. CollateClause -> Rep CollateClause x
from :: forall x. CollateClause -> Rep CollateClause x
$cto :: forall x. Rep CollateClause x -> CollateClause
to :: forall x. Rep CollateClause x -> CollateClause
Generic, CollateClause -> CollateClause -> Bool
(CollateClause -> CollateClause -> Bool)
-> (CollateClause -> CollateClause -> Bool) -> Eq CollateClause
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CollateClause -> CollateClause -> Bool
== :: CollateClause -> CollateClause -> Bool
$c/= :: CollateClause -> CollateClause -> Bool
/= :: CollateClause -> CollateClause -> Bool
Eq, Eq CollateClause
Eq CollateClause =>
(CollateClause -> CollateClause -> Ordering)
-> (CollateClause -> CollateClause -> Bool)
-> (CollateClause -> CollateClause -> Bool)
-> (CollateClause -> CollateClause -> Bool)
-> (CollateClause -> CollateClause -> Bool)
-> (CollateClause -> CollateClause -> CollateClause)
-> (CollateClause -> CollateClause -> CollateClause)
-> Ord CollateClause
CollateClause -> CollateClause -> Bool
CollateClause -> CollateClause -> Ordering
CollateClause -> CollateClause -> CollateClause
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
$ccompare :: CollateClause -> CollateClause -> Ordering
compare :: CollateClause -> CollateClause -> Ordering
$c< :: CollateClause -> CollateClause -> Bool
< :: CollateClause -> CollateClause -> Bool
$c<= :: CollateClause -> CollateClause -> Bool
<= :: CollateClause -> CollateClause -> Bool
$c> :: CollateClause -> CollateClause -> Bool
> :: CollateClause -> CollateClause -> Bool
$c>= :: CollateClause -> CollateClause -> Bool
>= :: CollateClause -> CollateClause -> Bool
$cmax :: CollateClause -> CollateClause -> CollateClause
max :: CollateClause -> CollateClause -> CollateClause
$cmin :: CollateClause -> CollateClause -> CollateClause
min :: CollateClause -> CollateClause -> CollateClause
Ord)

-- |
-- ==== References
-- @
-- func_name:
--   | type_function_name
--   | ColId indirection
-- @
data FuncName
  = TypeFuncName TypeFunctionName
  | IndirectedFuncName ColId Indirection
  deriving (Int -> FuncName -> ShowS
[FuncName] -> ShowS
FuncName -> String
(Int -> FuncName -> ShowS)
-> (FuncName -> String) -> ([FuncName] -> ShowS) -> Show FuncName
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FuncName -> ShowS
showsPrec :: Int -> FuncName -> ShowS
$cshow :: FuncName -> String
show :: FuncName -> String
$cshowList :: [FuncName] -> ShowS
showList :: [FuncName] -> ShowS
Show, (forall x. FuncName -> Rep FuncName x)
-> (forall x. Rep FuncName x -> FuncName) -> Generic FuncName
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
$cfrom :: forall x. FuncName -> Rep FuncName x
from :: forall x. FuncName -> Rep FuncName x
$cto :: forall x. Rep FuncName x -> FuncName
to :: forall x. Rep FuncName x -> FuncName
Generic, FuncName -> FuncName -> Bool
(FuncName -> FuncName -> Bool)
-> (FuncName -> FuncName -> Bool) -> Eq FuncName
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FuncName -> FuncName -> Bool
== :: FuncName -> FuncName -> Bool
$c/= :: FuncName -> FuncName -> Bool
/= :: FuncName -> FuncName -> Bool
Eq, Eq FuncName
Eq FuncName =>
(FuncName -> FuncName -> Ordering)
-> (FuncName -> FuncName -> Bool)
-> (FuncName -> FuncName -> Bool)
-> (FuncName -> FuncName -> Bool)
-> (FuncName -> FuncName -> Bool)
-> (FuncName -> FuncName -> FuncName)
-> (FuncName -> FuncName -> FuncName)
-> Ord 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
$ccompare :: FuncName -> FuncName -> Ordering
compare :: FuncName -> FuncName -> Ordering
$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
>= :: FuncName -> FuncName -> Bool
$cmax :: FuncName -> FuncName -> FuncName
max :: FuncName -> FuncName -> FuncName
$cmin :: FuncName -> FuncName -> FuncName
min :: FuncName -> FuncName -> FuncName
Ord)

-- |
-- ==== References
-- @
-- type_function_name:
--   | IDENT
--   | unreserved_keyword
--   | type_func_name_keyword
-- @
type TypeFunctionName = Ident

-- |
-- ==== References
-- @
-- columnref:
--   | ColId
--   | ColId indirection
-- qualified_name:
--   | ColId
--   | ColId indirection
-- @
data QualifiedName
  = SimpleQualifiedName Ident
  | IndirectedQualifiedName Ident Indirection
  deriving (Int -> QualifiedName -> ShowS
[QualifiedName] -> ShowS
QualifiedName -> String
(Int -> QualifiedName -> ShowS)
-> (QualifiedName -> String)
-> ([QualifiedName] -> ShowS)
-> Show QualifiedName
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> QualifiedName -> ShowS
showsPrec :: Int -> QualifiedName -> ShowS
$cshow :: QualifiedName -> String
show :: QualifiedName -> String
$cshowList :: [QualifiedName] -> ShowS
showList :: [QualifiedName] -> ShowS
Show, (forall x. QualifiedName -> Rep QualifiedName x)
-> (forall x. Rep QualifiedName x -> QualifiedName)
-> Generic QualifiedName
forall x. Rep QualifiedName x -> QualifiedName
forall x. QualifiedName -> Rep QualifiedName x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. QualifiedName -> Rep QualifiedName x
from :: forall x. QualifiedName -> Rep QualifiedName x
$cto :: forall x. Rep QualifiedName x -> QualifiedName
to :: forall x. Rep QualifiedName x -> QualifiedName
Generic, QualifiedName -> QualifiedName -> Bool
(QualifiedName -> QualifiedName -> Bool)
-> (QualifiedName -> QualifiedName -> Bool) -> Eq QualifiedName
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: QualifiedName -> QualifiedName -> Bool
== :: QualifiedName -> QualifiedName -> Bool
$c/= :: QualifiedName -> QualifiedName -> Bool
/= :: QualifiedName -> QualifiedName -> Bool
Eq, Eq QualifiedName
Eq QualifiedName =>
(QualifiedName -> QualifiedName -> Ordering)
-> (QualifiedName -> QualifiedName -> Bool)
-> (QualifiedName -> QualifiedName -> Bool)
-> (QualifiedName -> QualifiedName -> Bool)
-> (QualifiedName -> QualifiedName -> Bool)
-> (QualifiedName -> QualifiedName -> QualifiedName)
-> (QualifiedName -> QualifiedName -> QualifiedName)
-> Ord QualifiedName
QualifiedName -> QualifiedName -> Bool
QualifiedName -> QualifiedName -> Ordering
QualifiedName -> QualifiedName -> QualifiedName
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
$ccompare :: QualifiedName -> QualifiedName -> Ordering
compare :: QualifiedName -> QualifiedName -> Ordering
$c< :: QualifiedName -> QualifiedName -> Bool
< :: QualifiedName -> QualifiedName -> Bool
$c<= :: QualifiedName -> QualifiedName -> Bool
<= :: QualifiedName -> QualifiedName -> Bool
$c> :: QualifiedName -> QualifiedName -> Bool
> :: QualifiedName -> QualifiedName -> Bool
$c>= :: QualifiedName -> QualifiedName -> Bool
>= :: QualifiedName -> QualifiedName -> Bool
$cmax :: QualifiedName -> QualifiedName -> QualifiedName
max :: QualifiedName -> QualifiedName -> QualifiedName
$cmin :: QualifiedName -> QualifiedName -> QualifiedName
min :: QualifiedName -> QualifiedName -> QualifiedName
Ord)

-- |
-- ==== References
-- @
-- indirection:
--   |  indirection_el
--   |  indirection indirection_el
-- @
type Indirection = NonEmpty IndirectionEl

-- |
-- ==== References
-- @
-- indirection_el:
--   |  '.' attr_name
--   |  '.' '*'
--   |  '[' a_expr ']'
--   |  '[' opt_slice_bound ':' opt_slice_bound ']'
-- opt_slice_bound:
--   |  a_expr
--   |  EMPTY
-- @
data IndirectionEl
  = AttrNameIndirectionEl Ident
  | AllIndirectionEl
  | ExprIndirectionEl AExpr
  | SliceIndirectionEl (Maybe AExpr) (Maybe AExpr)
  deriving (Int -> IndirectionEl -> ShowS
[IndirectionEl] -> ShowS
IndirectionEl -> String
(Int -> IndirectionEl -> ShowS)
-> (IndirectionEl -> String)
-> ([IndirectionEl] -> ShowS)
-> Show IndirectionEl
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> IndirectionEl -> ShowS
showsPrec :: Int -> IndirectionEl -> ShowS
$cshow :: IndirectionEl -> String
show :: IndirectionEl -> String
$cshowList :: [IndirectionEl] -> ShowS
showList :: [IndirectionEl] -> ShowS
Show, (forall x. IndirectionEl -> Rep IndirectionEl x)
-> (forall x. Rep IndirectionEl x -> IndirectionEl)
-> Generic IndirectionEl
forall x. Rep IndirectionEl x -> IndirectionEl
forall x. IndirectionEl -> Rep IndirectionEl x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. IndirectionEl -> Rep IndirectionEl x
from :: forall x. IndirectionEl -> Rep IndirectionEl x
$cto :: forall x. Rep IndirectionEl x -> IndirectionEl
to :: forall x. Rep IndirectionEl x -> IndirectionEl
Generic, IndirectionEl -> IndirectionEl -> Bool
(IndirectionEl -> IndirectionEl -> Bool)
-> (IndirectionEl -> IndirectionEl -> Bool) -> Eq IndirectionEl
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: IndirectionEl -> IndirectionEl -> Bool
== :: IndirectionEl -> IndirectionEl -> Bool
$c/= :: IndirectionEl -> IndirectionEl -> Bool
/= :: IndirectionEl -> IndirectionEl -> Bool
Eq, Eq IndirectionEl
Eq IndirectionEl =>
(IndirectionEl -> IndirectionEl -> Ordering)
-> (IndirectionEl -> IndirectionEl -> Bool)
-> (IndirectionEl -> IndirectionEl -> Bool)
-> (IndirectionEl -> IndirectionEl -> Bool)
-> (IndirectionEl -> IndirectionEl -> Bool)
-> (IndirectionEl -> IndirectionEl -> IndirectionEl)
-> (IndirectionEl -> IndirectionEl -> IndirectionEl)
-> Ord IndirectionEl
IndirectionEl -> IndirectionEl -> Bool
IndirectionEl -> IndirectionEl -> Ordering
IndirectionEl -> IndirectionEl -> IndirectionEl
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
$ccompare :: IndirectionEl -> IndirectionEl -> Ordering
compare :: IndirectionEl -> IndirectionEl -> Ordering
$c< :: IndirectionEl -> IndirectionEl -> Bool
< :: IndirectionEl -> IndirectionEl -> Bool
$c<= :: IndirectionEl -> IndirectionEl -> Bool
<= :: IndirectionEl -> IndirectionEl -> Bool
$c> :: IndirectionEl -> IndirectionEl -> Bool
> :: IndirectionEl -> IndirectionEl -> Bool
$c>= :: IndirectionEl -> IndirectionEl -> Bool
>= :: IndirectionEl -> IndirectionEl -> Bool
$cmax :: IndirectionEl -> IndirectionEl -> IndirectionEl
max :: IndirectionEl -> IndirectionEl -> IndirectionEl
$cmin :: IndirectionEl -> IndirectionEl -> IndirectionEl
min :: IndirectionEl -> IndirectionEl -> IndirectionEl
Ord)

-- * Types

-- |
-- Typename definition extended with custom question-marks for nullability specification.
--
-- To match the standard Postgres syntax simply interpret their presence as a parsing error.
--
-- ==== References
-- @
-- Typename:
--   | SimpleTypename opt_array_bounds
--   | SETOF SimpleTypename opt_array_bounds
--   | SimpleTypename ARRAY '[' Iconst ']'
--   | SETOF SimpleTypename ARRAY '[' Iconst ']'
--   | SimpleTypename ARRAY
--   | SETOF SimpleTypename ARRAY
-- @
data Typename
  = Typename
      -- | SETOF
      Bool
      SimpleTypename
      -- | Question mark
      Bool
      -- | Array dimensions possibly followed by a question mark
      (Maybe (TypenameArrayDimensions, Bool))
  deriving (Int -> Typename -> ShowS
[Typename] -> ShowS
Typename -> String
(Int -> Typename -> ShowS)
-> (Typename -> String) -> ([Typename] -> ShowS) -> Show Typename
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Typename -> ShowS
showsPrec :: Int -> Typename -> ShowS
$cshow :: Typename -> String
show :: Typename -> String
$cshowList :: [Typename] -> ShowS
showList :: [Typename] -> ShowS
Show, (forall x. Typename -> Rep Typename x)
-> (forall x. Rep Typename x -> Typename) -> Generic Typename
forall x. Rep Typename x -> Typename
forall x. Typename -> Rep Typename x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Typename -> Rep Typename x
from :: forall x. Typename -> Rep Typename x
$cto :: forall x. Rep Typename x -> Typename
to :: forall x. Rep Typename x -> Typename
Generic, Typename -> Typename -> Bool
(Typename -> Typename -> Bool)
-> (Typename -> Typename -> Bool) -> Eq Typename
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Typename -> Typename -> Bool
== :: Typename -> Typename -> Bool
$c/= :: Typename -> Typename -> Bool
/= :: Typename -> Typename -> Bool
Eq, Eq Typename
Eq Typename =>
(Typename -> Typename -> Ordering)
-> (Typename -> Typename -> Bool)
-> (Typename -> Typename -> Bool)
-> (Typename -> Typename -> Bool)
-> (Typename -> Typename -> Bool)
-> (Typename -> Typename -> Typename)
-> (Typename -> Typename -> Typename)
-> Ord Typename
Typename -> Typename -> Bool
Typename -> Typename -> Ordering
Typename -> Typename -> Typename
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
$ccompare :: Typename -> Typename -> Ordering
compare :: Typename -> Typename -> Ordering
$c< :: Typename -> Typename -> Bool
< :: Typename -> Typename -> Bool
$c<= :: Typename -> Typename -> Bool
<= :: Typename -> Typename -> Bool
$c> :: Typename -> Typename -> Bool
> :: Typename -> Typename -> Bool
$c>= :: Typename -> Typename -> Bool
>= :: Typename -> Typename -> Bool
$cmax :: Typename -> Typename -> Typename
max :: Typename -> Typename -> Typename
$cmin :: Typename -> Typename -> Typename
min :: Typename -> Typename -> Typename
Ord)

-- |
-- ==== References
-- @
-- Part of the Typename specification responsible for the choice between the following:
--   | opt_array_bounds
--   | ARRAY '[' Iconst ']'
--   | ARRAY
-- @
data TypenameArrayDimensions
  = BoundsTypenameArrayDimensions ArrayBounds
  | ExplicitTypenameArrayDimensions (Maybe Iconst)
  deriving (Int -> TypenameArrayDimensions -> ShowS
[TypenameArrayDimensions] -> ShowS
TypenameArrayDimensions -> String
(Int -> TypenameArrayDimensions -> ShowS)
-> (TypenameArrayDimensions -> String)
-> ([TypenameArrayDimensions] -> ShowS)
-> Show TypenameArrayDimensions
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TypenameArrayDimensions -> ShowS
showsPrec :: Int -> TypenameArrayDimensions -> ShowS
$cshow :: TypenameArrayDimensions -> String
show :: TypenameArrayDimensions -> String
$cshowList :: [TypenameArrayDimensions] -> ShowS
showList :: [TypenameArrayDimensions] -> ShowS
Show, (forall x.
 TypenameArrayDimensions -> Rep TypenameArrayDimensions x)
-> (forall x.
    Rep TypenameArrayDimensions x -> TypenameArrayDimensions)
-> Generic TypenameArrayDimensions
forall x. Rep TypenameArrayDimensions x -> TypenameArrayDimensions
forall x. TypenameArrayDimensions -> Rep TypenameArrayDimensions x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. TypenameArrayDimensions -> Rep TypenameArrayDimensions x
from :: forall x. TypenameArrayDimensions -> Rep TypenameArrayDimensions x
$cto :: forall x. Rep TypenameArrayDimensions x -> TypenameArrayDimensions
to :: forall x. Rep TypenameArrayDimensions x -> TypenameArrayDimensions
Generic, TypenameArrayDimensions -> TypenameArrayDimensions -> Bool
(TypenameArrayDimensions -> TypenameArrayDimensions -> Bool)
-> (TypenameArrayDimensions -> TypenameArrayDimensions -> Bool)
-> Eq TypenameArrayDimensions
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TypenameArrayDimensions -> TypenameArrayDimensions -> Bool
== :: TypenameArrayDimensions -> TypenameArrayDimensions -> Bool
$c/= :: TypenameArrayDimensions -> TypenameArrayDimensions -> Bool
/= :: TypenameArrayDimensions -> TypenameArrayDimensions -> Bool
Eq, Eq TypenameArrayDimensions
Eq TypenameArrayDimensions =>
(TypenameArrayDimensions -> TypenameArrayDimensions -> Ordering)
-> (TypenameArrayDimensions -> TypenameArrayDimensions -> Bool)
-> (TypenameArrayDimensions -> TypenameArrayDimensions -> Bool)
-> (TypenameArrayDimensions -> TypenameArrayDimensions -> Bool)
-> (TypenameArrayDimensions -> TypenameArrayDimensions -> Bool)
-> (TypenameArrayDimensions
    -> TypenameArrayDimensions -> TypenameArrayDimensions)
-> (TypenameArrayDimensions
    -> TypenameArrayDimensions -> TypenameArrayDimensions)
-> Ord TypenameArrayDimensions
TypenameArrayDimensions -> TypenameArrayDimensions -> Bool
TypenameArrayDimensions -> TypenameArrayDimensions -> Ordering
TypenameArrayDimensions
-> TypenameArrayDimensions -> TypenameArrayDimensions
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
$ccompare :: TypenameArrayDimensions -> TypenameArrayDimensions -> Ordering
compare :: TypenameArrayDimensions -> TypenameArrayDimensions -> Ordering
$c< :: TypenameArrayDimensions -> TypenameArrayDimensions -> Bool
< :: TypenameArrayDimensions -> TypenameArrayDimensions -> Bool
$c<= :: TypenameArrayDimensions -> TypenameArrayDimensions -> Bool
<= :: TypenameArrayDimensions -> TypenameArrayDimensions -> Bool
$c> :: TypenameArrayDimensions -> TypenameArrayDimensions -> Bool
> :: TypenameArrayDimensions -> TypenameArrayDimensions -> Bool
$c>= :: TypenameArrayDimensions -> TypenameArrayDimensions -> Bool
>= :: TypenameArrayDimensions -> TypenameArrayDimensions -> Bool
$cmax :: TypenameArrayDimensions
-> TypenameArrayDimensions -> TypenameArrayDimensions
max :: TypenameArrayDimensions
-> TypenameArrayDimensions -> TypenameArrayDimensions
$cmin :: TypenameArrayDimensions
-> TypenameArrayDimensions -> TypenameArrayDimensions
min :: TypenameArrayDimensions
-> TypenameArrayDimensions -> TypenameArrayDimensions
Ord)

-- |
-- ==== References
-- @
-- opt_array_bounds:
--   | opt_array_bounds '[' ']'
--   | opt_array_bounds '[' Iconst ']'
--   | EMPTY
-- @
type ArrayBounds = NonEmpty (Maybe Iconst)

-- |
-- ==== References
-- @
-- SimpleTypename:
--   | GenericType
--   | Numeric
--   | Bit
--   | Character
--   | ConstDatetime
--   | ConstInterval opt_interval
--   | ConstInterval '(' Iconst ')'
-- ConstInterval:
--   | INTERVAL
-- @
data SimpleTypename
  = GenericTypeSimpleTypename GenericType
  | NumericSimpleTypename Numeric
  | BitSimpleTypename Bit
  | CharacterSimpleTypename Character
  | ConstDatetimeSimpleTypename ConstDatetime
  | ConstIntervalSimpleTypename (Either (Maybe Interval) Iconst)
  deriving (Int -> SimpleTypename -> ShowS
[SimpleTypename] -> ShowS
SimpleTypename -> String
(Int -> SimpleTypename -> ShowS)
-> (SimpleTypename -> String)
-> ([SimpleTypename] -> ShowS)
-> Show SimpleTypename
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SimpleTypename -> ShowS
showsPrec :: Int -> SimpleTypename -> ShowS
$cshow :: SimpleTypename -> String
show :: SimpleTypename -> String
$cshowList :: [SimpleTypename] -> ShowS
showList :: [SimpleTypename] -> ShowS
Show, (forall x. SimpleTypename -> Rep SimpleTypename x)
-> (forall x. Rep SimpleTypename x -> SimpleTypename)
-> Generic SimpleTypename
forall x. Rep SimpleTypename x -> SimpleTypename
forall x. SimpleTypename -> Rep SimpleTypename x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. SimpleTypename -> Rep SimpleTypename x
from :: forall x. SimpleTypename -> Rep SimpleTypename x
$cto :: forall x. Rep SimpleTypename x -> SimpleTypename
to :: forall x. Rep SimpleTypename x -> SimpleTypename
Generic, SimpleTypename -> SimpleTypename -> Bool
(SimpleTypename -> SimpleTypename -> Bool)
-> (SimpleTypename -> SimpleTypename -> Bool) -> Eq SimpleTypename
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SimpleTypename -> SimpleTypename -> Bool
== :: SimpleTypename -> SimpleTypename -> Bool
$c/= :: SimpleTypename -> SimpleTypename -> Bool
/= :: SimpleTypename -> SimpleTypename -> Bool
Eq, Eq SimpleTypename
Eq SimpleTypename =>
(SimpleTypename -> SimpleTypename -> Ordering)
-> (SimpleTypename -> SimpleTypename -> Bool)
-> (SimpleTypename -> SimpleTypename -> Bool)
-> (SimpleTypename -> SimpleTypename -> Bool)
-> (SimpleTypename -> SimpleTypename -> Bool)
-> (SimpleTypename -> SimpleTypename -> SimpleTypename)
-> (SimpleTypename -> SimpleTypename -> SimpleTypename)
-> Ord SimpleTypename
SimpleTypename -> SimpleTypename -> Bool
SimpleTypename -> SimpleTypename -> Ordering
SimpleTypename -> SimpleTypename -> SimpleTypename
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
$ccompare :: SimpleTypename -> SimpleTypename -> Ordering
compare :: SimpleTypename -> SimpleTypename -> Ordering
$c< :: SimpleTypename -> SimpleTypename -> Bool
< :: SimpleTypename -> SimpleTypename -> Bool
$c<= :: SimpleTypename -> SimpleTypename -> Bool
<= :: SimpleTypename -> SimpleTypename -> Bool
$c> :: SimpleTypename -> SimpleTypename -> Bool
> :: SimpleTypename -> SimpleTypename -> Bool
$c>= :: SimpleTypename -> SimpleTypename -> Bool
>= :: SimpleTypename -> SimpleTypename -> Bool
$cmax :: SimpleTypename -> SimpleTypename -> SimpleTypename
max :: SimpleTypename -> SimpleTypename -> SimpleTypename
$cmin :: SimpleTypename -> SimpleTypename -> SimpleTypename
min :: SimpleTypename -> SimpleTypename -> SimpleTypename
Ord)

-- |
-- ==== References
-- @
-- GenericType:
--   | type_function_name opt_type_modifiers
--   | type_function_name attrs opt_type_modifiers
-- @
data GenericType = GenericType TypeFunctionName (Maybe Attrs) (Maybe TypeModifiers)
  deriving (Int -> GenericType -> ShowS
[GenericType] -> ShowS
GenericType -> String
(Int -> GenericType -> ShowS)
-> (GenericType -> String)
-> ([GenericType] -> ShowS)
-> Show GenericType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> GenericType -> ShowS
showsPrec :: Int -> GenericType -> ShowS
$cshow :: GenericType -> String
show :: GenericType -> String
$cshowList :: [GenericType] -> ShowS
showList :: [GenericType] -> ShowS
Show, (forall x. GenericType -> Rep GenericType x)
-> (forall x. Rep GenericType x -> GenericType)
-> Generic GenericType
forall x. Rep GenericType x -> GenericType
forall x. GenericType -> Rep GenericType x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. GenericType -> Rep GenericType x
from :: forall x. GenericType -> Rep GenericType x
$cto :: forall x. Rep GenericType x -> GenericType
to :: forall x. Rep GenericType x -> GenericType
Generic, GenericType -> GenericType -> Bool
(GenericType -> GenericType -> Bool)
-> (GenericType -> GenericType -> Bool) -> Eq GenericType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: GenericType -> GenericType -> Bool
== :: GenericType -> GenericType -> Bool
$c/= :: GenericType -> GenericType -> Bool
/= :: GenericType -> GenericType -> Bool
Eq, Eq GenericType
Eq GenericType =>
(GenericType -> GenericType -> Ordering)
-> (GenericType -> GenericType -> Bool)
-> (GenericType -> GenericType -> Bool)
-> (GenericType -> GenericType -> Bool)
-> (GenericType -> GenericType -> Bool)
-> (GenericType -> GenericType -> GenericType)
-> (GenericType -> GenericType -> GenericType)
-> Ord GenericType
GenericType -> GenericType -> Bool
GenericType -> GenericType -> Ordering
GenericType -> GenericType -> GenericType
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
$ccompare :: GenericType -> GenericType -> Ordering
compare :: GenericType -> GenericType -> Ordering
$c< :: GenericType -> GenericType -> Bool
< :: GenericType -> GenericType -> Bool
$c<= :: GenericType -> GenericType -> Bool
<= :: GenericType -> GenericType -> Bool
$c> :: GenericType -> GenericType -> Bool
> :: GenericType -> GenericType -> Bool
$c>= :: GenericType -> GenericType -> Bool
>= :: GenericType -> GenericType -> Bool
$cmax :: GenericType -> GenericType -> GenericType
max :: GenericType -> GenericType -> GenericType
$cmin :: GenericType -> GenericType -> GenericType
min :: GenericType -> GenericType -> GenericType
Ord)

-- |
-- ==== References
-- @
-- attrs:
--   | '.' attr_name
--   | attrs '.' attr_name
-- @
type Attrs = NonEmpty AttrName

-- |
-- ==== References
-- @
-- attr_name:
--   | ColLabel
-- @
type AttrName = ColLabel

-- |
-- ==== References
-- @
-- opt_type_modifiers:
--   | '(' expr_list ')'
--   | EMPTY
-- @
type TypeModifiers = ExprList

-- |
-- ==== References
-- @
-- type_list:
--   | Typename
--   | type_list ',' Typename
-- @
type TypeList = NonEmpty Typename

-- * Operators

-- |
-- ==== References
-- @
-- qual_Op:
--   | Op
--   | OPERATOR '(' any_operator ')'
-- @
data QualOp
  = OpQualOp Op
  | OperatorQualOp AnyOperator
  deriving (Int -> QualOp -> ShowS
[QualOp] -> ShowS
QualOp -> String
(Int -> QualOp -> ShowS)
-> (QualOp -> String) -> ([QualOp] -> ShowS) -> Show QualOp
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> QualOp -> ShowS
showsPrec :: Int -> QualOp -> ShowS
$cshow :: QualOp -> String
show :: QualOp -> String
$cshowList :: [QualOp] -> ShowS
showList :: [QualOp] -> ShowS
Show, (forall x. QualOp -> Rep QualOp x)
-> (forall x. Rep QualOp x -> QualOp) -> Generic QualOp
forall x. Rep QualOp x -> QualOp
forall x. QualOp -> Rep QualOp x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. QualOp -> Rep QualOp x
from :: forall x. QualOp -> Rep QualOp x
$cto :: forall x. Rep QualOp x -> QualOp
to :: forall x. Rep QualOp x -> QualOp
Generic, QualOp -> QualOp -> Bool
(QualOp -> QualOp -> Bool)
-> (QualOp -> QualOp -> Bool) -> Eq QualOp
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: QualOp -> QualOp -> Bool
== :: QualOp -> QualOp -> Bool
$c/= :: QualOp -> QualOp -> Bool
/= :: QualOp -> QualOp -> Bool
Eq, Eq QualOp
Eq QualOp =>
(QualOp -> QualOp -> Ordering)
-> (QualOp -> QualOp -> Bool)
-> (QualOp -> QualOp -> Bool)
-> (QualOp -> QualOp -> Bool)
-> (QualOp -> QualOp -> Bool)
-> (QualOp -> QualOp -> QualOp)
-> (QualOp -> QualOp -> QualOp)
-> Ord QualOp
QualOp -> QualOp -> Bool
QualOp -> QualOp -> Ordering
QualOp -> QualOp -> QualOp
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
$ccompare :: QualOp -> QualOp -> Ordering
compare :: QualOp -> QualOp -> Ordering
$c< :: QualOp -> QualOp -> Bool
< :: QualOp -> QualOp -> Bool
$c<= :: QualOp -> QualOp -> Bool
<= :: QualOp -> QualOp -> Bool
$c> :: QualOp -> QualOp -> Bool
> :: QualOp -> QualOp -> Bool
$c>= :: QualOp -> QualOp -> Bool
>= :: QualOp -> QualOp -> Bool
$cmax :: QualOp -> QualOp -> QualOp
max :: QualOp -> QualOp -> QualOp
$cmin :: QualOp -> QualOp -> QualOp
min :: QualOp -> QualOp -> QualOp
Ord)

-- |
-- ==== References
-- @
-- qual_all_Op:
--   | all_Op
--   | OPERATOR '(' any_operator ')'
-- @
data QualAllOp
  = AllQualAllOp AllOp
  | AnyQualAllOp AnyOperator
  deriving (Int -> QualAllOp -> ShowS
[QualAllOp] -> ShowS
QualAllOp -> String
(Int -> QualAllOp -> ShowS)
-> (QualAllOp -> String)
-> ([QualAllOp] -> ShowS)
-> Show QualAllOp
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> QualAllOp -> ShowS
showsPrec :: Int -> QualAllOp -> ShowS
$cshow :: QualAllOp -> String
show :: QualAllOp -> String
$cshowList :: [QualAllOp] -> ShowS
showList :: [QualAllOp] -> ShowS
Show, (forall x. QualAllOp -> Rep QualAllOp x)
-> (forall x. Rep QualAllOp x -> QualAllOp) -> Generic QualAllOp
forall x. Rep QualAllOp x -> QualAllOp
forall x. QualAllOp -> Rep QualAllOp x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. QualAllOp -> Rep QualAllOp x
from :: forall x. QualAllOp -> Rep QualAllOp x
$cto :: forall x. Rep QualAllOp x -> QualAllOp
to :: forall x. Rep QualAllOp x -> QualAllOp
Generic, QualAllOp -> QualAllOp -> Bool
(QualAllOp -> QualAllOp -> Bool)
-> (QualAllOp -> QualAllOp -> Bool) -> Eq QualAllOp
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: QualAllOp -> QualAllOp -> Bool
== :: QualAllOp -> QualAllOp -> Bool
$c/= :: QualAllOp -> QualAllOp -> Bool
/= :: QualAllOp -> QualAllOp -> Bool
Eq, Eq QualAllOp
Eq QualAllOp =>
(QualAllOp -> QualAllOp -> Ordering)
-> (QualAllOp -> QualAllOp -> Bool)
-> (QualAllOp -> QualAllOp -> Bool)
-> (QualAllOp -> QualAllOp -> Bool)
-> (QualAllOp -> QualAllOp -> Bool)
-> (QualAllOp -> QualAllOp -> QualAllOp)
-> (QualAllOp -> QualAllOp -> QualAllOp)
-> Ord QualAllOp
QualAllOp -> QualAllOp -> Bool
QualAllOp -> QualAllOp -> Ordering
QualAllOp -> QualAllOp -> QualAllOp
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
$ccompare :: QualAllOp -> QualAllOp -> Ordering
compare :: QualAllOp -> QualAllOp -> Ordering
$c< :: QualAllOp -> QualAllOp -> Bool
< :: QualAllOp -> QualAllOp -> Bool
$c<= :: QualAllOp -> QualAllOp -> Bool
<= :: QualAllOp -> QualAllOp -> Bool
$c> :: QualAllOp -> QualAllOp -> Bool
> :: QualAllOp -> QualAllOp -> Bool
$c>= :: QualAllOp -> QualAllOp -> Bool
>= :: QualAllOp -> QualAllOp -> Bool
$cmax :: QualAllOp -> QualAllOp -> QualAllOp
max :: QualAllOp -> QualAllOp -> QualAllOp
$cmin :: QualAllOp -> QualAllOp -> QualAllOp
min :: QualAllOp -> QualAllOp -> QualAllOp
Ord)

-- |
-- ==== References
-- @
-- The operator name is a sequence of up to NAMEDATALEN-1 (63 by default)
-- characters from the following list:
--
-- + - * / < > = ~ ! @ # % ^ & | ` ?
--
-- There are a few restrictions on your choice of name:
-- -- and /* cannot appear anywhere in an operator name,
-- since they will be taken as the start of a comment.
--
-- A multicharacter operator name cannot end in + or -,
-- unless the name also contains at least one of these characters:
--
-- ~ ! @ # % ^ & | ` ?
--
-- For example, @- is an allowed operator name, but *- is not.
-- This restriction allows PostgreSQL to parse SQL-compliant
-- commands without requiring spaces between tokens.
-- The use of => as an operator name is deprecated.
-- It may be disallowed altogether in a future release.
--
-- The operator != is mapped to <> on input,
-- so these two names are always equivalent.
-- @
type Op = Text

-- |
-- ==== References
-- @
-- any_operator:
--   | all_Op
--   | ColId '.' any_operator
-- @
data AnyOperator
  = AllOpAnyOperator AllOp
  | QualifiedAnyOperator ColId AnyOperator
  deriving (Int -> AnyOperator -> ShowS
[AnyOperator] -> ShowS
AnyOperator -> String
(Int -> AnyOperator -> ShowS)
-> (AnyOperator -> String)
-> ([AnyOperator] -> ShowS)
-> Show AnyOperator
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> AnyOperator -> ShowS
showsPrec :: Int -> AnyOperator -> ShowS
$cshow :: AnyOperator -> String
show :: AnyOperator -> String
$cshowList :: [AnyOperator] -> ShowS
showList :: [AnyOperator] -> ShowS
Show, (forall x. AnyOperator -> Rep AnyOperator x)
-> (forall x. Rep AnyOperator x -> AnyOperator)
-> Generic AnyOperator
forall x. Rep AnyOperator x -> AnyOperator
forall x. AnyOperator -> Rep AnyOperator x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. AnyOperator -> Rep AnyOperator x
from :: forall x. AnyOperator -> Rep AnyOperator x
$cto :: forall x. Rep AnyOperator x -> AnyOperator
to :: forall x. Rep AnyOperator x -> AnyOperator
Generic, AnyOperator -> AnyOperator -> Bool
(AnyOperator -> AnyOperator -> Bool)
-> (AnyOperator -> AnyOperator -> Bool) -> Eq AnyOperator
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AnyOperator -> AnyOperator -> Bool
== :: AnyOperator -> AnyOperator -> Bool
$c/= :: AnyOperator -> AnyOperator -> Bool
/= :: AnyOperator -> AnyOperator -> Bool
Eq, Eq AnyOperator
Eq AnyOperator =>
(AnyOperator -> AnyOperator -> Ordering)
-> (AnyOperator -> AnyOperator -> Bool)
-> (AnyOperator -> AnyOperator -> Bool)
-> (AnyOperator -> AnyOperator -> Bool)
-> (AnyOperator -> AnyOperator -> Bool)
-> (AnyOperator -> AnyOperator -> AnyOperator)
-> (AnyOperator -> AnyOperator -> AnyOperator)
-> Ord AnyOperator
AnyOperator -> AnyOperator -> Bool
AnyOperator -> AnyOperator -> Ordering
AnyOperator -> AnyOperator -> AnyOperator
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
$ccompare :: AnyOperator -> AnyOperator -> Ordering
compare :: AnyOperator -> AnyOperator -> Ordering
$c< :: AnyOperator -> AnyOperator -> Bool
< :: AnyOperator -> AnyOperator -> Bool
$c<= :: AnyOperator -> AnyOperator -> Bool
<= :: AnyOperator -> AnyOperator -> Bool
$c> :: AnyOperator -> AnyOperator -> Bool
> :: AnyOperator -> AnyOperator -> Bool
$c>= :: AnyOperator -> AnyOperator -> Bool
>= :: AnyOperator -> AnyOperator -> Bool
$cmax :: AnyOperator -> AnyOperator -> AnyOperator
max :: AnyOperator -> AnyOperator -> AnyOperator
$cmin :: AnyOperator -> AnyOperator -> AnyOperator
min :: AnyOperator -> AnyOperator -> AnyOperator
Ord)

-- |
-- ==== References
-- @
-- all_Op:
--   | Op
--   | MathOp
-- @
data AllOp
  = OpAllOp Op
  | MathAllOp MathOp
  deriving (Int -> AllOp -> ShowS
[AllOp] -> ShowS
AllOp -> String
(Int -> AllOp -> ShowS)
-> (AllOp -> String) -> ([AllOp] -> ShowS) -> Show AllOp
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> AllOp -> ShowS
showsPrec :: Int -> AllOp -> ShowS
$cshow :: AllOp -> String
show :: AllOp -> String
$cshowList :: [AllOp] -> ShowS
showList :: [AllOp] -> ShowS
Show, (forall x. AllOp -> Rep AllOp x)
-> (forall x. Rep AllOp x -> AllOp) -> Generic AllOp
forall x. Rep AllOp x -> AllOp
forall x. AllOp -> Rep AllOp x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. AllOp -> Rep AllOp x
from :: forall x. AllOp -> Rep AllOp x
$cto :: forall x. Rep AllOp x -> AllOp
to :: forall x. Rep AllOp x -> AllOp
Generic, AllOp -> AllOp -> Bool
(AllOp -> AllOp -> Bool) -> (AllOp -> AllOp -> Bool) -> Eq AllOp
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AllOp -> AllOp -> Bool
== :: AllOp -> AllOp -> Bool
$c/= :: AllOp -> AllOp -> Bool
/= :: AllOp -> AllOp -> Bool
Eq, Eq AllOp
Eq AllOp =>
(AllOp -> AllOp -> Ordering)
-> (AllOp -> AllOp -> Bool)
-> (AllOp -> AllOp -> Bool)
-> (AllOp -> AllOp -> Bool)
-> (AllOp -> AllOp -> Bool)
-> (AllOp -> AllOp -> AllOp)
-> (AllOp -> AllOp -> AllOp)
-> Ord AllOp
AllOp -> AllOp -> Bool
AllOp -> AllOp -> Ordering
AllOp -> AllOp -> AllOp
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
$ccompare :: AllOp -> AllOp -> Ordering
compare :: AllOp -> AllOp -> Ordering
$c< :: AllOp -> AllOp -> Bool
< :: AllOp -> AllOp -> Bool
$c<= :: AllOp -> AllOp -> Bool
<= :: AllOp -> AllOp -> Bool
$c> :: AllOp -> AllOp -> Bool
> :: AllOp -> AllOp -> Bool
$c>= :: AllOp -> AllOp -> Bool
>= :: AllOp -> AllOp -> Bool
$cmax :: AllOp -> AllOp -> AllOp
max :: AllOp -> AllOp -> AllOp
$cmin :: AllOp -> AllOp -> AllOp
min :: AllOp -> AllOp -> AllOp
Ord)

-- |
-- ==== References
-- @
-- MathOp:
--   | '+'
--   | '-'
--   | '*'
--   | '/'
--   | '%'
--   | '^'
--   | '<'
--   | '>'
--   | '='
--   | LESS_EQUALS
--   | GREATER_EQUALS
--   | NOT_EQUALS
-- @
data MathOp
  = PlusMathOp
  | MinusMathOp
  | AsteriskMathOp
  | SlashMathOp
  | PercentMathOp
  | ArrowUpMathOp
  | ArrowLeftMathOp
  | ArrowRightMathOp
  | EqualsMathOp
  | LessEqualsMathOp
  | GreaterEqualsMathOp
  | ArrowLeftArrowRightMathOp
  | ExclamationEqualsMathOp
  deriving (Int -> MathOp -> ShowS
[MathOp] -> ShowS
MathOp -> String
(Int -> MathOp -> ShowS)
-> (MathOp -> String) -> ([MathOp] -> ShowS) -> Show MathOp
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MathOp -> ShowS
showsPrec :: Int -> MathOp -> ShowS
$cshow :: MathOp -> String
show :: MathOp -> String
$cshowList :: [MathOp] -> ShowS
showList :: [MathOp] -> ShowS
Show, (forall x. MathOp -> Rep MathOp x)
-> (forall x. Rep MathOp x -> MathOp) -> Generic MathOp
forall x. Rep MathOp x -> MathOp
forall x. MathOp -> Rep MathOp x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. MathOp -> Rep MathOp x
from :: forall x. MathOp -> Rep MathOp x
$cto :: forall x. Rep MathOp x -> MathOp
to :: forall x. Rep MathOp x -> MathOp
Generic, MathOp -> MathOp -> Bool
(MathOp -> MathOp -> Bool)
-> (MathOp -> MathOp -> Bool) -> Eq MathOp
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MathOp -> MathOp -> Bool
== :: MathOp -> MathOp -> Bool
$c/= :: MathOp -> MathOp -> Bool
/= :: MathOp -> MathOp -> Bool
Eq, Eq MathOp
Eq MathOp =>
(MathOp -> MathOp -> Ordering)
-> (MathOp -> MathOp -> Bool)
-> (MathOp -> MathOp -> Bool)
-> (MathOp -> MathOp -> Bool)
-> (MathOp -> MathOp -> Bool)
-> (MathOp -> MathOp -> MathOp)
-> (MathOp -> MathOp -> MathOp)
-> Ord MathOp
MathOp -> MathOp -> Bool
MathOp -> MathOp -> Ordering
MathOp -> MathOp -> MathOp
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
$ccompare :: MathOp -> MathOp -> Ordering
compare :: MathOp -> MathOp -> Ordering
$c< :: MathOp -> MathOp -> Bool
< :: MathOp -> MathOp -> Bool
$c<= :: MathOp -> MathOp -> Bool
<= :: MathOp -> MathOp -> Bool
$c> :: MathOp -> MathOp -> Bool
> :: MathOp -> MathOp -> Bool
$c>= :: MathOp -> MathOp -> Bool
>= :: MathOp -> MathOp -> Bool
$cmax :: MathOp -> MathOp -> MathOp
max :: MathOp -> MathOp -> MathOp
$cmin :: MathOp -> MathOp -> MathOp
min :: MathOp -> MathOp -> MathOp
Ord, Int -> MathOp
MathOp -> Int
MathOp -> [MathOp]
MathOp -> MathOp
MathOp -> MathOp -> [MathOp]
MathOp -> MathOp -> MathOp -> [MathOp]
(MathOp -> MathOp)
-> (MathOp -> MathOp)
-> (Int -> MathOp)
-> (MathOp -> Int)
-> (MathOp -> [MathOp])
-> (MathOp -> MathOp -> [MathOp])
-> (MathOp -> MathOp -> [MathOp])
-> (MathOp -> MathOp -> MathOp -> [MathOp])
-> Enum MathOp
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: MathOp -> MathOp
succ :: MathOp -> MathOp
$cpred :: MathOp -> MathOp
pred :: MathOp -> MathOp
$ctoEnum :: Int -> MathOp
toEnum :: Int -> MathOp
$cfromEnum :: MathOp -> Int
fromEnum :: MathOp -> Int
$cenumFrom :: MathOp -> [MathOp]
enumFrom :: MathOp -> [MathOp]
$cenumFromThen :: MathOp -> MathOp -> [MathOp]
enumFromThen :: MathOp -> MathOp -> [MathOp]
$cenumFromTo :: MathOp -> MathOp -> [MathOp]
enumFromTo :: MathOp -> MathOp -> [MathOp]
$cenumFromThenTo :: MathOp -> MathOp -> MathOp -> [MathOp]
enumFromThenTo :: MathOp -> MathOp -> MathOp -> [MathOp]
Enum, MathOp
MathOp -> MathOp -> Bounded MathOp
forall a. a -> a -> Bounded a
$cminBound :: MathOp
minBound :: MathOp
$cmaxBound :: MathOp
maxBound :: MathOp
Bounded)

data SymbolicExprBinOp
  = MathSymbolicExprBinOp MathOp
  | QualSymbolicExprBinOp QualOp
  deriving (Int -> SymbolicExprBinOp -> ShowS
[SymbolicExprBinOp] -> ShowS
SymbolicExprBinOp -> String
(Int -> SymbolicExprBinOp -> ShowS)
-> (SymbolicExprBinOp -> String)
-> ([SymbolicExprBinOp] -> ShowS)
-> Show SymbolicExprBinOp
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SymbolicExprBinOp -> ShowS
showsPrec :: Int -> SymbolicExprBinOp -> ShowS
$cshow :: SymbolicExprBinOp -> String
show :: SymbolicExprBinOp -> String
$cshowList :: [SymbolicExprBinOp] -> ShowS
showList :: [SymbolicExprBinOp] -> ShowS
Show, (forall x. SymbolicExprBinOp -> Rep SymbolicExprBinOp x)
-> (forall x. Rep SymbolicExprBinOp x -> SymbolicExprBinOp)
-> Generic SymbolicExprBinOp
forall x. Rep SymbolicExprBinOp x -> SymbolicExprBinOp
forall x. SymbolicExprBinOp -> Rep SymbolicExprBinOp x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. SymbolicExprBinOp -> Rep SymbolicExprBinOp x
from :: forall x. SymbolicExprBinOp -> Rep SymbolicExprBinOp x
$cto :: forall x. Rep SymbolicExprBinOp x -> SymbolicExprBinOp
to :: forall x. Rep SymbolicExprBinOp x -> SymbolicExprBinOp
Generic, SymbolicExprBinOp -> SymbolicExprBinOp -> Bool
(SymbolicExprBinOp -> SymbolicExprBinOp -> Bool)
-> (SymbolicExprBinOp -> SymbolicExprBinOp -> Bool)
-> Eq SymbolicExprBinOp
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SymbolicExprBinOp -> SymbolicExprBinOp -> Bool
== :: SymbolicExprBinOp -> SymbolicExprBinOp -> Bool
$c/= :: SymbolicExprBinOp -> SymbolicExprBinOp -> Bool
/= :: SymbolicExprBinOp -> SymbolicExprBinOp -> Bool
Eq, Eq SymbolicExprBinOp
Eq SymbolicExprBinOp =>
(SymbolicExprBinOp -> SymbolicExprBinOp -> Ordering)
-> (SymbolicExprBinOp -> SymbolicExprBinOp -> Bool)
-> (SymbolicExprBinOp -> SymbolicExprBinOp -> Bool)
-> (SymbolicExprBinOp -> SymbolicExprBinOp -> Bool)
-> (SymbolicExprBinOp -> SymbolicExprBinOp -> Bool)
-> (SymbolicExprBinOp -> SymbolicExprBinOp -> SymbolicExprBinOp)
-> (SymbolicExprBinOp -> SymbolicExprBinOp -> SymbolicExprBinOp)
-> Ord SymbolicExprBinOp
SymbolicExprBinOp -> SymbolicExprBinOp -> Bool
SymbolicExprBinOp -> SymbolicExprBinOp -> Ordering
SymbolicExprBinOp -> SymbolicExprBinOp -> SymbolicExprBinOp
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
$ccompare :: SymbolicExprBinOp -> SymbolicExprBinOp -> Ordering
compare :: SymbolicExprBinOp -> SymbolicExprBinOp -> Ordering
$c< :: SymbolicExprBinOp -> SymbolicExprBinOp -> Bool
< :: SymbolicExprBinOp -> SymbolicExprBinOp -> Bool
$c<= :: SymbolicExprBinOp -> SymbolicExprBinOp -> Bool
<= :: SymbolicExprBinOp -> SymbolicExprBinOp -> Bool
$c> :: SymbolicExprBinOp -> SymbolicExprBinOp -> Bool
> :: SymbolicExprBinOp -> SymbolicExprBinOp -> Bool
$c>= :: SymbolicExprBinOp -> SymbolicExprBinOp -> Bool
>= :: SymbolicExprBinOp -> SymbolicExprBinOp -> Bool
$cmax :: SymbolicExprBinOp -> SymbolicExprBinOp -> SymbolicExprBinOp
max :: SymbolicExprBinOp -> SymbolicExprBinOp -> SymbolicExprBinOp
$cmin :: SymbolicExprBinOp -> SymbolicExprBinOp -> SymbolicExprBinOp
min :: SymbolicExprBinOp -> SymbolicExprBinOp -> SymbolicExprBinOp
Ord)

data VerbalExprBinOp
  = LikeVerbalExprBinOp
  | IlikeVerbalExprBinOp
  | SimilarToVerbalExprBinOp
  deriving (Int -> VerbalExprBinOp -> ShowS
[VerbalExprBinOp] -> ShowS
VerbalExprBinOp -> String
(Int -> VerbalExprBinOp -> ShowS)
-> (VerbalExprBinOp -> String)
-> ([VerbalExprBinOp] -> ShowS)
-> Show VerbalExprBinOp
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> VerbalExprBinOp -> ShowS
showsPrec :: Int -> VerbalExprBinOp -> ShowS
$cshow :: VerbalExprBinOp -> String
show :: VerbalExprBinOp -> String
$cshowList :: [VerbalExprBinOp] -> ShowS
showList :: [VerbalExprBinOp] -> ShowS
Show, (forall x. VerbalExprBinOp -> Rep VerbalExprBinOp x)
-> (forall x. Rep VerbalExprBinOp x -> VerbalExprBinOp)
-> Generic VerbalExprBinOp
forall x. Rep VerbalExprBinOp x -> VerbalExprBinOp
forall x. VerbalExprBinOp -> Rep VerbalExprBinOp x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. VerbalExprBinOp -> Rep VerbalExprBinOp x
from :: forall x. VerbalExprBinOp -> Rep VerbalExprBinOp x
$cto :: forall x. Rep VerbalExprBinOp x -> VerbalExprBinOp
to :: forall x. Rep VerbalExprBinOp x -> VerbalExprBinOp
Generic, VerbalExprBinOp -> VerbalExprBinOp -> Bool
(VerbalExprBinOp -> VerbalExprBinOp -> Bool)
-> (VerbalExprBinOp -> VerbalExprBinOp -> Bool)
-> Eq VerbalExprBinOp
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: VerbalExprBinOp -> VerbalExprBinOp -> Bool
== :: VerbalExprBinOp -> VerbalExprBinOp -> Bool
$c/= :: VerbalExprBinOp -> VerbalExprBinOp -> Bool
/= :: VerbalExprBinOp -> VerbalExprBinOp -> Bool
Eq, Eq VerbalExprBinOp
Eq VerbalExprBinOp =>
(VerbalExprBinOp -> VerbalExprBinOp -> Ordering)
-> (VerbalExprBinOp -> VerbalExprBinOp -> Bool)
-> (VerbalExprBinOp -> VerbalExprBinOp -> Bool)
-> (VerbalExprBinOp -> VerbalExprBinOp -> Bool)
-> (VerbalExprBinOp -> VerbalExprBinOp -> Bool)
-> (VerbalExprBinOp -> VerbalExprBinOp -> VerbalExprBinOp)
-> (VerbalExprBinOp -> VerbalExprBinOp -> VerbalExprBinOp)
-> Ord VerbalExprBinOp
VerbalExprBinOp -> VerbalExprBinOp -> Bool
VerbalExprBinOp -> VerbalExprBinOp -> Ordering
VerbalExprBinOp -> VerbalExprBinOp -> VerbalExprBinOp
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
$ccompare :: VerbalExprBinOp -> VerbalExprBinOp -> Ordering
compare :: VerbalExprBinOp -> VerbalExprBinOp -> Ordering
$c< :: VerbalExprBinOp -> VerbalExprBinOp -> Bool
< :: VerbalExprBinOp -> VerbalExprBinOp -> Bool
$c<= :: VerbalExprBinOp -> VerbalExprBinOp -> Bool
<= :: VerbalExprBinOp -> VerbalExprBinOp -> Bool
$c> :: VerbalExprBinOp -> VerbalExprBinOp -> Bool
> :: VerbalExprBinOp -> VerbalExprBinOp -> Bool
$c>= :: VerbalExprBinOp -> VerbalExprBinOp -> Bool
>= :: VerbalExprBinOp -> VerbalExprBinOp -> Bool
$cmax :: VerbalExprBinOp -> VerbalExprBinOp -> VerbalExprBinOp
max :: VerbalExprBinOp -> VerbalExprBinOp -> VerbalExprBinOp
$cmin :: VerbalExprBinOp -> VerbalExprBinOp -> VerbalExprBinOp
min :: VerbalExprBinOp -> VerbalExprBinOp -> VerbalExprBinOp
Ord, Int -> VerbalExprBinOp
VerbalExprBinOp -> Int
VerbalExprBinOp -> [VerbalExprBinOp]
VerbalExprBinOp -> VerbalExprBinOp
VerbalExprBinOp -> VerbalExprBinOp -> [VerbalExprBinOp]
VerbalExprBinOp
-> VerbalExprBinOp -> VerbalExprBinOp -> [VerbalExprBinOp]
(VerbalExprBinOp -> VerbalExprBinOp)
-> (VerbalExprBinOp -> VerbalExprBinOp)
-> (Int -> VerbalExprBinOp)
-> (VerbalExprBinOp -> Int)
-> (VerbalExprBinOp -> [VerbalExprBinOp])
-> (VerbalExprBinOp -> VerbalExprBinOp -> [VerbalExprBinOp])
-> (VerbalExprBinOp -> VerbalExprBinOp -> [VerbalExprBinOp])
-> (VerbalExprBinOp
    -> VerbalExprBinOp -> VerbalExprBinOp -> [VerbalExprBinOp])
-> Enum VerbalExprBinOp
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: VerbalExprBinOp -> VerbalExprBinOp
succ :: VerbalExprBinOp -> VerbalExprBinOp
$cpred :: VerbalExprBinOp -> VerbalExprBinOp
pred :: VerbalExprBinOp -> VerbalExprBinOp
$ctoEnum :: Int -> VerbalExprBinOp
toEnum :: Int -> VerbalExprBinOp
$cfromEnum :: VerbalExprBinOp -> Int
fromEnum :: VerbalExprBinOp -> Int
$cenumFrom :: VerbalExprBinOp -> [VerbalExprBinOp]
enumFrom :: VerbalExprBinOp -> [VerbalExprBinOp]
$cenumFromThen :: VerbalExprBinOp -> VerbalExprBinOp -> [VerbalExprBinOp]
enumFromThen :: VerbalExprBinOp -> VerbalExprBinOp -> [VerbalExprBinOp]
$cenumFromTo :: VerbalExprBinOp -> VerbalExprBinOp -> [VerbalExprBinOp]
enumFromTo :: VerbalExprBinOp -> VerbalExprBinOp -> [VerbalExprBinOp]
$cenumFromThenTo :: VerbalExprBinOp
-> VerbalExprBinOp -> VerbalExprBinOp -> [VerbalExprBinOp]
enumFromThenTo :: VerbalExprBinOp
-> VerbalExprBinOp -> VerbalExprBinOp -> [VerbalExprBinOp]
Enum, VerbalExprBinOp
VerbalExprBinOp -> VerbalExprBinOp -> Bounded VerbalExprBinOp
forall a. a -> a -> Bounded a
$cminBound :: VerbalExprBinOp
minBound :: VerbalExprBinOp
$cmaxBound :: VerbalExprBinOp
maxBound :: VerbalExprBinOp
Bounded)

-- |
-- ==== References
-- @
--   | a_expr IS NULL_P
--   | a_expr IS TRUE_P
--   | a_expr IS FALSE_P
--   | a_expr IS UNKNOWN
--   | a_expr IS DISTINCT FROM a_expr
--   | a_expr IS OF '(' type_list ')'
--   | a_expr BETWEEN opt_asymmetric b_expr AND a_expr
--   | a_expr BETWEEN SYMMETRIC b_expr AND a_expr
--   | a_expr IN_P in_expr
--   | a_expr IS DOCUMENT_P
-- @
data AExprReversableOp
  = NullAExprReversableOp
  | TrueAExprReversableOp
  | FalseAExprReversableOp
  | UnknownAExprReversableOp
  | DistinctFromAExprReversableOp AExpr
  | OfAExprReversableOp TypeList
  | BetweenAExprReversableOp Bool BExpr AExpr
  | BetweenSymmetricAExprReversableOp BExpr AExpr
  | InAExprReversableOp InExpr
  | DocumentAExprReversableOp
  deriving (Int -> AExprReversableOp -> ShowS
[AExprReversableOp] -> ShowS
AExprReversableOp -> String
(Int -> AExprReversableOp -> ShowS)
-> (AExprReversableOp -> String)
-> ([AExprReversableOp] -> ShowS)
-> Show AExprReversableOp
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> AExprReversableOp -> ShowS
showsPrec :: Int -> AExprReversableOp -> ShowS
$cshow :: AExprReversableOp -> String
show :: AExprReversableOp -> String
$cshowList :: [AExprReversableOp] -> ShowS
showList :: [AExprReversableOp] -> ShowS
Show, (forall x. AExprReversableOp -> Rep AExprReversableOp x)
-> (forall x. Rep AExprReversableOp x -> AExprReversableOp)
-> Generic AExprReversableOp
forall x. Rep AExprReversableOp x -> AExprReversableOp
forall x. AExprReversableOp -> Rep AExprReversableOp x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. AExprReversableOp -> Rep AExprReversableOp x
from :: forall x. AExprReversableOp -> Rep AExprReversableOp x
$cto :: forall x. Rep AExprReversableOp x -> AExprReversableOp
to :: forall x. Rep AExprReversableOp x -> AExprReversableOp
Generic, AExprReversableOp -> AExprReversableOp -> Bool
(AExprReversableOp -> AExprReversableOp -> Bool)
-> (AExprReversableOp -> AExprReversableOp -> Bool)
-> Eq AExprReversableOp
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AExprReversableOp -> AExprReversableOp -> Bool
== :: AExprReversableOp -> AExprReversableOp -> Bool
$c/= :: AExprReversableOp -> AExprReversableOp -> Bool
/= :: AExprReversableOp -> AExprReversableOp -> Bool
Eq, Eq AExprReversableOp
Eq AExprReversableOp =>
(AExprReversableOp -> AExprReversableOp -> Ordering)
-> (AExprReversableOp -> AExprReversableOp -> Bool)
-> (AExprReversableOp -> AExprReversableOp -> Bool)
-> (AExprReversableOp -> AExprReversableOp -> Bool)
-> (AExprReversableOp -> AExprReversableOp -> Bool)
-> (AExprReversableOp -> AExprReversableOp -> AExprReversableOp)
-> (AExprReversableOp -> AExprReversableOp -> AExprReversableOp)
-> Ord AExprReversableOp
AExprReversableOp -> AExprReversableOp -> Bool
AExprReversableOp -> AExprReversableOp -> Ordering
AExprReversableOp -> AExprReversableOp -> AExprReversableOp
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
$ccompare :: AExprReversableOp -> AExprReversableOp -> Ordering
compare :: AExprReversableOp -> AExprReversableOp -> Ordering
$c< :: AExprReversableOp -> AExprReversableOp -> Bool
< :: AExprReversableOp -> AExprReversableOp -> Bool
$c<= :: AExprReversableOp -> AExprReversableOp -> Bool
<= :: AExprReversableOp -> AExprReversableOp -> Bool
$c> :: AExprReversableOp -> AExprReversableOp -> Bool
> :: AExprReversableOp -> AExprReversableOp -> Bool
$c>= :: AExprReversableOp -> AExprReversableOp -> Bool
>= :: AExprReversableOp -> AExprReversableOp -> Bool
$cmax :: AExprReversableOp -> AExprReversableOp -> AExprReversableOp
max :: AExprReversableOp -> AExprReversableOp -> AExprReversableOp
$cmin :: AExprReversableOp -> AExprReversableOp -> AExprReversableOp
min :: AExprReversableOp -> AExprReversableOp -> AExprReversableOp
Ord)

-- |
-- ==== References
-- @
--   | b_expr IS DISTINCT FROM b_expr
--   | b_expr IS NOT DISTINCT FROM b_expr
--   | b_expr IS OF '(' type_list ')'
--   | b_expr IS NOT OF '(' type_list ')'
--   | b_expr IS DOCUMENT_P
--   | b_expr IS NOT DOCUMENT_P
-- @
data BExprIsOp
  = DistinctFromBExprIsOp BExpr
  | OfBExprIsOp TypeList
  | DocumentBExprIsOp
  deriving (Int -> BExprIsOp -> ShowS
[BExprIsOp] -> ShowS
BExprIsOp -> String
(Int -> BExprIsOp -> ShowS)
-> (BExprIsOp -> String)
-> ([BExprIsOp] -> ShowS)
-> Show BExprIsOp
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BExprIsOp -> ShowS
showsPrec :: Int -> BExprIsOp -> ShowS
$cshow :: BExprIsOp -> String
show :: BExprIsOp -> String
$cshowList :: [BExprIsOp] -> ShowS
showList :: [BExprIsOp] -> ShowS
Show, (forall x. BExprIsOp -> Rep BExprIsOp x)
-> (forall x. Rep BExprIsOp x -> BExprIsOp) -> Generic BExprIsOp
forall x. Rep BExprIsOp x -> BExprIsOp
forall x. BExprIsOp -> Rep BExprIsOp x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. BExprIsOp -> Rep BExprIsOp x
from :: forall x. BExprIsOp -> Rep BExprIsOp x
$cto :: forall x. Rep BExprIsOp x -> BExprIsOp
to :: forall x. Rep BExprIsOp x -> BExprIsOp
Generic, BExprIsOp -> BExprIsOp -> Bool
(BExprIsOp -> BExprIsOp -> Bool)
-> (BExprIsOp -> BExprIsOp -> Bool) -> Eq BExprIsOp
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BExprIsOp -> BExprIsOp -> Bool
== :: BExprIsOp -> BExprIsOp -> Bool
$c/= :: BExprIsOp -> BExprIsOp -> Bool
/= :: BExprIsOp -> BExprIsOp -> Bool
Eq, Eq BExprIsOp
Eq BExprIsOp =>
(BExprIsOp -> BExprIsOp -> Ordering)
-> (BExprIsOp -> BExprIsOp -> Bool)
-> (BExprIsOp -> BExprIsOp -> Bool)
-> (BExprIsOp -> BExprIsOp -> Bool)
-> (BExprIsOp -> BExprIsOp -> Bool)
-> (BExprIsOp -> BExprIsOp -> BExprIsOp)
-> (BExprIsOp -> BExprIsOp -> BExprIsOp)
-> Ord BExprIsOp
BExprIsOp -> BExprIsOp -> Bool
BExprIsOp -> BExprIsOp -> Ordering
BExprIsOp -> BExprIsOp -> BExprIsOp
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
$ccompare :: BExprIsOp -> BExprIsOp -> Ordering
compare :: BExprIsOp -> BExprIsOp -> Ordering
$c< :: BExprIsOp -> BExprIsOp -> Bool
< :: BExprIsOp -> BExprIsOp -> Bool
$c<= :: BExprIsOp -> BExprIsOp -> Bool
<= :: BExprIsOp -> BExprIsOp -> Bool
$c> :: BExprIsOp -> BExprIsOp -> Bool
> :: BExprIsOp -> BExprIsOp -> Bool
$c>= :: BExprIsOp -> BExprIsOp -> Bool
>= :: BExprIsOp -> BExprIsOp -> Bool
$cmax :: BExprIsOp -> BExprIsOp -> BExprIsOp
max :: BExprIsOp -> BExprIsOp -> BExprIsOp
$cmin :: BExprIsOp -> BExprIsOp -> BExprIsOp
min :: BExprIsOp -> BExprIsOp -> BExprIsOp
Ord)

-- |
-- ==== References
-- @
-- subquery_Op:
--   | all_Op
--   | OPERATOR '(' any_operator ')'
--   | LIKE
--   | NOT_LA LIKE
--   | ILIKE
--   | NOT_LA ILIKE
-- @
data SubqueryOp
  = AllSubqueryOp AllOp
  | AnySubqueryOp AnyOperator
  | LikeSubqueryOp Bool
  | IlikeSubqueryOp Bool
  deriving (Int -> SubqueryOp -> ShowS
[SubqueryOp] -> ShowS
SubqueryOp -> String
(Int -> SubqueryOp -> ShowS)
-> (SubqueryOp -> String)
-> ([SubqueryOp] -> ShowS)
-> Show SubqueryOp
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SubqueryOp -> ShowS
showsPrec :: Int -> SubqueryOp -> ShowS
$cshow :: SubqueryOp -> String
show :: SubqueryOp -> String
$cshowList :: [SubqueryOp] -> ShowS
showList :: [SubqueryOp] -> ShowS
Show, (forall x. SubqueryOp -> Rep SubqueryOp x)
-> (forall x. Rep SubqueryOp x -> SubqueryOp) -> Generic SubqueryOp
forall x. Rep SubqueryOp x -> SubqueryOp
forall x. SubqueryOp -> Rep SubqueryOp x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. SubqueryOp -> Rep SubqueryOp x
from :: forall x. SubqueryOp -> Rep SubqueryOp x
$cto :: forall x. Rep SubqueryOp x -> SubqueryOp
to :: forall x. Rep SubqueryOp x -> SubqueryOp
Generic, SubqueryOp -> SubqueryOp -> Bool
(SubqueryOp -> SubqueryOp -> Bool)
-> (SubqueryOp -> SubqueryOp -> Bool) -> Eq SubqueryOp
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SubqueryOp -> SubqueryOp -> Bool
== :: SubqueryOp -> SubqueryOp -> Bool
$c/= :: SubqueryOp -> SubqueryOp -> Bool
/= :: SubqueryOp -> SubqueryOp -> Bool
Eq, Eq SubqueryOp
Eq SubqueryOp =>
(SubqueryOp -> SubqueryOp -> Ordering)
-> (SubqueryOp -> SubqueryOp -> Bool)
-> (SubqueryOp -> SubqueryOp -> Bool)
-> (SubqueryOp -> SubqueryOp -> Bool)
-> (SubqueryOp -> SubqueryOp -> Bool)
-> (SubqueryOp -> SubqueryOp -> SubqueryOp)
-> (SubqueryOp -> SubqueryOp -> SubqueryOp)
-> Ord SubqueryOp
SubqueryOp -> SubqueryOp -> Bool
SubqueryOp -> SubqueryOp -> Ordering
SubqueryOp -> SubqueryOp -> SubqueryOp
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
$ccompare :: SubqueryOp -> SubqueryOp -> Ordering
compare :: SubqueryOp -> SubqueryOp -> Ordering
$c< :: SubqueryOp -> SubqueryOp -> Bool
< :: SubqueryOp -> SubqueryOp -> Bool
$c<= :: SubqueryOp -> SubqueryOp -> Bool
<= :: SubqueryOp -> SubqueryOp -> Bool
$c> :: SubqueryOp -> SubqueryOp -> Bool
> :: SubqueryOp -> SubqueryOp -> Bool
$c>= :: SubqueryOp -> SubqueryOp -> Bool
>= :: SubqueryOp -> SubqueryOp -> Bool
$cmax :: SubqueryOp -> SubqueryOp -> SubqueryOp
max :: SubqueryOp -> SubqueryOp -> SubqueryOp
$cmin :: SubqueryOp -> SubqueryOp -> SubqueryOp
min :: SubqueryOp -> SubqueryOp -> SubqueryOp
Ord)

-- * Indexes

-- |
-- ==== References
-- @
-- index_params:
--   | index_elem
--   | index_params ',' index_elem
-- @
type IndexParams = NonEmpty IndexElem

-- |
-- ==== References
-- @
-- index_elem:
--   | ColId opt_collate opt_class opt_asc_desc opt_nulls_order
--   | func_expr_windowless opt_collate opt_class opt_asc_desc opt_nulls_order
--   | '(' a_expr ')' opt_collate opt_class opt_asc_desc opt_nulls_order
-- @
data IndexElem = IndexElem IndexElemDef (Maybe Collate) (Maybe Class) (Maybe AscDesc) (Maybe NullsOrder)
  deriving (Int -> IndexElem -> ShowS
[IndexElem] -> ShowS
IndexElem -> String
(Int -> IndexElem -> ShowS)
-> (IndexElem -> String)
-> ([IndexElem] -> ShowS)
-> Show IndexElem
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> IndexElem -> ShowS
showsPrec :: Int -> IndexElem -> ShowS
$cshow :: IndexElem -> String
show :: IndexElem -> String
$cshowList :: [IndexElem] -> ShowS
showList :: [IndexElem] -> ShowS
Show, (forall x. IndexElem -> Rep IndexElem x)
-> (forall x. Rep IndexElem x -> IndexElem) -> Generic IndexElem
forall x. Rep IndexElem x -> IndexElem
forall x. IndexElem -> Rep IndexElem x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. IndexElem -> Rep IndexElem x
from :: forall x. IndexElem -> Rep IndexElem x
$cto :: forall x. Rep IndexElem x -> IndexElem
to :: forall x. Rep IndexElem x -> IndexElem
Generic, IndexElem -> IndexElem -> Bool
(IndexElem -> IndexElem -> Bool)
-> (IndexElem -> IndexElem -> Bool) -> Eq IndexElem
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: IndexElem -> IndexElem -> Bool
== :: IndexElem -> IndexElem -> Bool
$c/= :: IndexElem -> IndexElem -> Bool
/= :: IndexElem -> IndexElem -> Bool
Eq, Eq IndexElem
Eq IndexElem =>
(IndexElem -> IndexElem -> Ordering)
-> (IndexElem -> IndexElem -> Bool)
-> (IndexElem -> IndexElem -> Bool)
-> (IndexElem -> IndexElem -> Bool)
-> (IndexElem -> IndexElem -> Bool)
-> (IndexElem -> IndexElem -> IndexElem)
-> (IndexElem -> IndexElem -> IndexElem)
-> Ord IndexElem
IndexElem -> IndexElem -> Bool
IndexElem -> IndexElem -> Ordering
IndexElem -> IndexElem -> IndexElem
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
$ccompare :: IndexElem -> IndexElem -> Ordering
compare :: IndexElem -> IndexElem -> Ordering
$c< :: IndexElem -> IndexElem -> Bool
< :: IndexElem -> IndexElem -> Bool
$c<= :: IndexElem -> IndexElem -> Bool
<= :: IndexElem -> IndexElem -> Bool
$c> :: IndexElem -> IndexElem -> Bool
> :: IndexElem -> IndexElem -> Bool
$c>= :: IndexElem -> IndexElem -> Bool
>= :: IndexElem -> IndexElem -> Bool
$cmax :: IndexElem -> IndexElem -> IndexElem
max :: IndexElem -> IndexElem -> IndexElem
$cmin :: IndexElem -> IndexElem -> IndexElem
min :: IndexElem -> IndexElem -> IndexElem
Ord)

-- |
-- ==== References
-- @
--   | ColId opt_collate opt_class opt_asc_desc opt_nulls_order
--   | func_expr_windowless opt_collate opt_class opt_asc_desc opt_nulls_order
--   | '(' a_expr ')' opt_collate opt_class opt_asc_desc opt_nulls_order
-- @
data IndexElemDef
  = IdIndexElemDef ColId
  | FuncIndexElemDef FuncExprWindowless
  | ExprIndexElemDef AExpr
  deriving (Int -> IndexElemDef -> ShowS
[IndexElemDef] -> ShowS
IndexElemDef -> String
(Int -> IndexElemDef -> ShowS)
-> (IndexElemDef -> String)
-> ([IndexElemDef] -> ShowS)
-> Show IndexElemDef
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> IndexElemDef -> ShowS
showsPrec :: Int -> IndexElemDef -> ShowS
$cshow :: IndexElemDef -> String
show :: IndexElemDef -> String
$cshowList :: [IndexElemDef] -> ShowS
showList :: [IndexElemDef] -> ShowS
Show, (forall x. IndexElemDef -> Rep IndexElemDef x)
-> (forall x. Rep IndexElemDef x -> IndexElemDef)
-> Generic IndexElemDef
forall x. Rep IndexElemDef x -> IndexElemDef
forall x. IndexElemDef -> Rep IndexElemDef x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. IndexElemDef -> Rep IndexElemDef x
from :: forall x. IndexElemDef -> Rep IndexElemDef x
$cto :: forall x. Rep IndexElemDef x -> IndexElemDef
to :: forall x. Rep IndexElemDef x -> IndexElemDef
Generic, IndexElemDef -> IndexElemDef -> Bool
(IndexElemDef -> IndexElemDef -> Bool)
-> (IndexElemDef -> IndexElemDef -> Bool) -> Eq IndexElemDef
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: IndexElemDef -> IndexElemDef -> Bool
== :: IndexElemDef -> IndexElemDef -> Bool
$c/= :: IndexElemDef -> IndexElemDef -> Bool
/= :: IndexElemDef -> IndexElemDef -> Bool
Eq, Eq IndexElemDef
Eq IndexElemDef =>
(IndexElemDef -> IndexElemDef -> Ordering)
-> (IndexElemDef -> IndexElemDef -> Bool)
-> (IndexElemDef -> IndexElemDef -> Bool)
-> (IndexElemDef -> IndexElemDef -> Bool)
-> (IndexElemDef -> IndexElemDef -> Bool)
-> (IndexElemDef -> IndexElemDef -> IndexElemDef)
-> (IndexElemDef -> IndexElemDef -> IndexElemDef)
-> Ord IndexElemDef
IndexElemDef -> IndexElemDef -> Bool
IndexElemDef -> IndexElemDef -> Ordering
IndexElemDef -> IndexElemDef -> IndexElemDef
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
$ccompare :: IndexElemDef -> IndexElemDef -> Ordering
compare :: IndexElemDef -> IndexElemDef -> Ordering
$c< :: IndexElemDef -> IndexElemDef -> Bool
< :: IndexElemDef -> IndexElemDef -> Bool
$c<= :: IndexElemDef -> IndexElemDef -> Bool
<= :: IndexElemDef -> IndexElemDef -> Bool
$c> :: IndexElemDef -> IndexElemDef -> Bool
> :: IndexElemDef -> IndexElemDef -> Bool
$c>= :: IndexElemDef -> IndexElemDef -> Bool
>= :: IndexElemDef -> IndexElemDef -> Bool
$cmax :: IndexElemDef -> IndexElemDef -> IndexElemDef
max :: IndexElemDef -> IndexElemDef -> IndexElemDef
$cmin :: IndexElemDef -> IndexElemDef -> IndexElemDef
min :: IndexElemDef -> IndexElemDef -> IndexElemDef
Ord)

-- |
-- ==== References
-- @
-- opt_collate:
--   | COLLATE any_name
--   | EMPTY
-- @
type Collate = AnyName

-- |
-- ==== References
-- @
-- opt_class:
--   | any_name
--   | EMPTY
-- @
type Class = AnyName

-- |
-- ==== References
-- @
-- opt_asc_desc:
--   | ASC
--   | DESC
--   | EMPTY
-- @
data AscDesc = AscAscDesc | DescAscDesc
  deriving (Int -> AscDesc -> ShowS
[AscDesc] -> ShowS
AscDesc -> String
(Int -> AscDesc -> ShowS)
-> (AscDesc -> String) -> ([AscDesc] -> ShowS) -> Show AscDesc
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> AscDesc -> ShowS
showsPrec :: Int -> AscDesc -> ShowS
$cshow :: AscDesc -> String
show :: AscDesc -> String
$cshowList :: [AscDesc] -> ShowS
showList :: [AscDesc] -> ShowS
Show, (forall x. AscDesc -> Rep AscDesc x)
-> (forall x. Rep AscDesc x -> AscDesc) -> Generic AscDesc
forall x. Rep AscDesc x -> AscDesc
forall x. AscDesc -> Rep AscDesc x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. AscDesc -> Rep AscDesc x
from :: forall x. AscDesc -> Rep AscDesc x
$cto :: forall x. Rep AscDesc x -> AscDesc
to :: forall x. Rep AscDesc x -> AscDesc
Generic, AscDesc -> AscDesc -> Bool
(AscDesc -> AscDesc -> Bool)
-> (AscDesc -> AscDesc -> Bool) -> Eq AscDesc
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AscDesc -> AscDesc -> Bool
== :: AscDesc -> AscDesc -> Bool
$c/= :: AscDesc -> AscDesc -> Bool
/= :: AscDesc -> AscDesc -> Bool
Eq, Eq AscDesc
Eq AscDesc =>
(AscDesc -> AscDesc -> Ordering)
-> (AscDesc -> AscDesc -> Bool)
-> (AscDesc -> AscDesc -> Bool)
-> (AscDesc -> AscDesc -> Bool)
-> (AscDesc -> AscDesc -> Bool)
-> (AscDesc -> AscDesc -> AscDesc)
-> (AscDesc -> AscDesc -> AscDesc)
-> Ord AscDesc
AscDesc -> AscDesc -> Bool
AscDesc -> AscDesc -> Ordering
AscDesc -> AscDesc -> AscDesc
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
$ccompare :: AscDesc -> AscDesc -> Ordering
compare :: AscDesc -> AscDesc -> Ordering
$c< :: AscDesc -> AscDesc -> Bool
< :: AscDesc -> AscDesc -> Bool
$c<= :: AscDesc -> AscDesc -> Bool
<= :: AscDesc -> AscDesc -> Bool
$c> :: AscDesc -> AscDesc -> Bool
> :: AscDesc -> AscDesc -> Bool
$c>= :: AscDesc -> AscDesc -> Bool
>= :: AscDesc -> AscDesc -> Bool
$cmax :: AscDesc -> AscDesc -> AscDesc
max :: AscDesc -> AscDesc -> AscDesc
$cmin :: AscDesc -> AscDesc -> AscDesc
min :: AscDesc -> AscDesc -> AscDesc
Ord, Int -> AscDesc
AscDesc -> Int
AscDesc -> [AscDesc]
AscDesc -> AscDesc
AscDesc -> AscDesc -> [AscDesc]
AscDesc -> AscDesc -> AscDesc -> [AscDesc]
(AscDesc -> AscDesc)
-> (AscDesc -> AscDesc)
-> (Int -> AscDesc)
-> (AscDesc -> Int)
-> (AscDesc -> [AscDesc])
-> (AscDesc -> AscDesc -> [AscDesc])
-> (AscDesc -> AscDesc -> [AscDesc])
-> (AscDesc -> AscDesc -> AscDesc -> [AscDesc])
-> Enum AscDesc
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: AscDesc -> AscDesc
succ :: AscDesc -> AscDesc
$cpred :: AscDesc -> AscDesc
pred :: AscDesc -> AscDesc
$ctoEnum :: Int -> AscDesc
toEnum :: Int -> AscDesc
$cfromEnum :: AscDesc -> Int
fromEnum :: AscDesc -> Int
$cenumFrom :: AscDesc -> [AscDesc]
enumFrom :: AscDesc -> [AscDesc]
$cenumFromThen :: AscDesc -> AscDesc -> [AscDesc]
enumFromThen :: AscDesc -> AscDesc -> [AscDesc]
$cenumFromTo :: AscDesc -> AscDesc -> [AscDesc]
enumFromTo :: AscDesc -> AscDesc -> [AscDesc]
$cenumFromThenTo :: AscDesc -> AscDesc -> AscDesc -> [AscDesc]
enumFromThenTo :: AscDesc -> AscDesc -> AscDesc -> [AscDesc]
Enum, AscDesc
AscDesc -> AscDesc -> Bounded AscDesc
forall a. a -> a -> Bounded a
$cminBound :: AscDesc
minBound :: AscDesc
$cmaxBound :: AscDesc
maxBound :: AscDesc
Bounded)

-- |
-- ==== References
-- @
-- opt_nulls_order:
--   | NULLS_LA FIRST_P
--   | NULLS_LA LAST_P
--   | EMPTY
-- @
data NullsOrder = FirstNullsOrder | LastNullsOrder
  deriving (Int -> NullsOrder -> ShowS
[NullsOrder] -> ShowS
NullsOrder -> String
(Int -> NullsOrder -> ShowS)
-> (NullsOrder -> String)
-> ([NullsOrder] -> ShowS)
-> Show NullsOrder
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> NullsOrder -> ShowS
showsPrec :: Int -> NullsOrder -> ShowS
$cshow :: NullsOrder -> String
show :: NullsOrder -> String
$cshowList :: [NullsOrder] -> ShowS
showList :: [NullsOrder] -> ShowS
Show, (forall x. NullsOrder -> Rep NullsOrder x)
-> (forall x. Rep NullsOrder x -> NullsOrder) -> Generic NullsOrder
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
$cfrom :: forall x. NullsOrder -> Rep NullsOrder x
from :: forall x. NullsOrder -> Rep NullsOrder x
$cto :: forall x. Rep NullsOrder x -> NullsOrder
to :: forall x. Rep NullsOrder x -> NullsOrder
Generic, NullsOrder -> NullsOrder -> Bool
(NullsOrder -> NullsOrder -> Bool)
-> (NullsOrder -> NullsOrder -> Bool) -> Eq NullsOrder
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NullsOrder -> NullsOrder -> Bool
== :: NullsOrder -> NullsOrder -> Bool
$c/= :: NullsOrder -> NullsOrder -> Bool
/= :: NullsOrder -> NullsOrder -> Bool
Eq, Eq NullsOrder
Eq NullsOrder =>
(NullsOrder -> NullsOrder -> Ordering)
-> (NullsOrder -> NullsOrder -> Bool)
-> (NullsOrder -> NullsOrder -> Bool)
-> (NullsOrder -> NullsOrder -> Bool)
-> (NullsOrder -> NullsOrder -> Bool)
-> (NullsOrder -> NullsOrder -> NullsOrder)
-> (NullsOrder -> NullsOrder -> NullsOrder)
-> Ord NullsOrder
NullsOrder -> NullsOrder -> Bool
NullsOrder -> NullsOrder -> Ordering
NullsOrder -> NullsOrder -> NullsOrder
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
$ccompare :: NullsOrder -> NullsOrder -> Ordering
compare :: NullsOrder -> NullsOrder -> Ordering
$c< :: NullsOrder -> NullsOrder -> Bool
< :: NullsOrder -> NullsOrder -> Bool
$c<= :: NullsOrder -> NullsOrder -> Bool
<= :: NullsOrder -> NullsOrder -> Bool
$c> :: NullsOrder -> NullsOrder -> Bool
> :: NullsOrder -> NullsOrder -> Bool
$c>= :: NullsOrder -> NullsOrder -> Bool
>= :: NullsOrder -> NullsOrder -> Bool
$cmax :: NullsOrder -> NullsOrder -> NullsOrder
max :: NullsOrder -> NullsOrder -> NullsOrder
$cmin :: NullsOrder -> NullsOrder -> NullsOrder
min :: NullsOrder -> NullsOrder -> NullsOrder
Ord, Int -> NullsOrder
NullsOrder -> Int
NullsOrder -> [NullsOrder]
NullsOrder -> NullsOrder
NullsOrder -> NullsOrder -> [NullsOrder]
NullsOrder -> NullsOrder -> NullsOrder -> [NullsOrder]
(NullsOrder -> NullsOrder)
-> (NullsOrder -> NullsOrder)
-> (Int -> NullsOrder)
-> (NullsOrder -> Int)
-> (NullsOrder -> [NullsOrder])
-> (NullsOrder -> NullsOrder -> [NullsOrder])
-> (NullsOrder -> NullsOrder -> [NullsOrder])
-> (NullsOrder -> NullsOrder -> NullsOrder -> [NullsOrder])
-> Enum NullsOrder
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: NullsOrder -> NullsOrder
succ :: NullsOrder -> NullsOrder
$cpred :: NullsOrder -> NullsOrder
pred :: NullsOrder -> NullsOrder
$ctoEnum :: Int -> NullsOrder
toEnum :: Int -> NullsOrder
$cfromEnum :: NullsOrder -> Int
fromEnum :: NullsOrder -> Int
$cenumFrom :: NullsOrder -> [NullsOrder]
enumFrom :: NullsOrder -> [NullsOrder]
$cenumFromThen :: NullsOrder -> NullsOrder -> [NullsOrder]
enumFromThen :: NullsOrder -> NullsOrder -> [NullsOrder]
$cenumFromTo :: NullsOrder -> NullsOrder -> [NullsOrder]
enumFromTo :: NullsOrder -> NullsOrder -> [NullsOrder]
$cenumFromThenTo :: NullsOrder -> NullsOrder -> NullsOrder -> [NullsOrder]
enumFromThenTo :: NullsOrder -> NullsOrder -> NullsOrder -> [NullsOrder]
Enum, NullsOrder
NullsOrder -> NullsOrder -> Bounded NullsOrder
forall a. a -> a -> Bounded a
$cminBound :: NullsOrder
minBound :: NullsOrder
$cmaxBound :: NullsOrder
maxBound :: NullsOrder
Bounded)