{-# OPTIONS_GHC -Wno-missing-signatures -Wno-dodgy-imports #-}

module PostgresqlSyntax.Rendering where

import qualified Data.Text as Text
import qualified Data.Text.Encoding as Text
import PostgresqlSyntax.Ast
import qualified PostgresqlSyntax.Extras.NonEmpty as NonEmpty
import PostgresqlSyntax.Extras.TextBuilder
import PostgresqlSyntax.Prelude hiding (aExpr, bit, fromList, many, option, sortBy, try)
import Text.Builder hiding (char7, doubleDec, int64Dec, intDec)

-- * Execution

toByteString :: Builder -> ByteString
toByteString :: Builder -> ByteString
toByteString = Text -> ByteString
Text.encodeUtf8 forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. Builder -> Text
toText

toText :: Builder -> Text
toText :: Builder -> Text
toText = Builder -> Text
run

-- * Helpers

commaNonEmpty :: (a -> Builder) -> NonEmpty a -> Builder
commaNonEmpty :: forall a. (a -> Builder) -> NonEmpty a -> Builder
commaNonEmpty = forall m a. Monoid m => m -> (a -> m) -> NonEmpty a -> m
NonEmpty.intersperseFoldMap Builder
", "

spaceNonEmpty :: (a -> Builder) -> NonEmpty a -> Builder
spaceNonEmpty :: forall a. (a -> Builder) -> NonEmpty a -> Builder
spaceNonEmpty = forall m a. Monoid m => m -> (a -> m) -> NonEmpty a -> m
NonEmpty.intersperseFoldMap Builder
" "

lexemes :: [Builder] -> Builder
lexemes :: [Builder] -> Builder
lexemes = forall a. Monoid a => [a] -> a
mconcat forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall a. a -> [a] -> [a]
intersperse Builder
" "

optLexemes :: [Maybe Builder] -> Builder
optLexemes :: [Maybe Builder] -> Builder
optLexemes = [Builder] -> Builder
lexemes forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall a. [Maybe a] -> [a]
catMaybes

inParens :: Builder -> Builder
inParens :: Builder -> Builder
inParens Builder
a = Builder
"(" forall a. Semigroup a => a -> a -> a
<> Builder
a forall a. Semigroup a => a -> a -> a
<> Builder
")"

inBrackets :: Builder -> Builder
inBrackets :: Builder -> Builder
inBrackets Builder
a = Builder
"[" forall a. Semigroup a => a -> a -> a
<> Builder
a forall a. Semigroup a => a -> a -> a
<> Builder
"]"

prefixMaybe :: (a -> Builder) -> Maybe a -> Builder
prefixMaybe :: forall a. (a -> Builder) -> Maybe a -> Builder
prefixMaybe a -> Builder
a = forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap (forall a b c. (a -> b -> c) -> b -> a -> c
flip forall a. Monoid a => a -> a -> a
mappend Builder
" " forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. a -> Builder
a)

suffixMaybe :: (a -> Builder) -> Maybe a -> Builder
suffixMaybe :: forall a. (a -> Builder) -> Maybe a -> Builder
suffixMaybe a -> Builder
a = forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap (forall a. Monoid a => a -> a -> a
mappend Builder
" " forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. a -> Builder
a)

-- * Statements

preparableStmt :: PreparableStmt -> Builder
preparableStmt = \case
  SelectPreparableStmt SelectStmt
a -> SelectStmt -> Builder
selectStmt SelectStmt
a
  InsertPreparableStmt InsertStmt
a -> InsertStmt -> Builder
insertStmt InsertStmt
a
  UpdatePreparableStmt UpdateStmt
a -> UpdateStmt -> Builder
updateStmt UpdateStmt
a
  DeletePreparableStmt DeleteStmt
a -> DeleteStmt -> Builder
deleteStmt DeleteStmt
a
  CallPreparableStmt CallStmt
a -> CallStmt -> Builder
callStmt CallStmt
a

-- * Call

callStmt :: CallStmt -> Builder
callStmt (CallStmt FuncApplication
a) =
  Builder
"CALL " forall a. Semigroup a => a -> a -> a
<> FuncApplication -> Builder
funcApplication FuncApplication
a

-- * Insert

insertStmt :: InsertStmt -> Builder
insertStmt (InsertStmt Maybe WithClause
a InsertTarget
b InsertRest
c Maybe OnConflict
d Maybe ReturningClause
e) =
  forall a. (a -> Builder) -> Maybe a -> Builder
prefixMaybe WithClause -> Builder
withClause Maybe WithClause
a
    forall a. Semigroup a => a -> a -> a
<> Builder
"INSERT INTO "
    forall a. Semigroup a => a -> a -> a
<> InsertTarget -> Builder
insertTarget InsertTarget
b
    forall a. Semigroup a => a -> a -> a
<> Builder
" "
    forall a. Semigroup a => a -> a -> a
<> InsertRest -> Builder
insertRest InsertRest
c
    forall a. Semigroup a => a -> a -> a
<> forall a. (a -> Builder) -> Maybe a -> Builder
suffixMaybe OnConflict -> Builder
onConflict Maybe OnConflict
d
    forall a. Semigroup a => a -> a -> a
<> forall a. (a -> Builder) -> Maybe a -> Builder
suffixMaybe ReturningClause -> Builder
returningClause Maybe ReturningClause
e

insertTarget :: InsertTarget -> Builder
insertTarget (InsertTarget QualifiedName
a Maybe ColId
b) =
  QualifiedName -> Builder
qualifiedName QualifiedName
a forall a. Semigroup a => a -> a -> a
<> forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap (forall a. Monoid a => a -> a -> a
mappend Builder
" AS " forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. ColId -> Builder
colId) Maybe ColId
b

insertRest :: InsertRest -> Builder
insertRest = \case
  SelectInsertRest Maybe InsertColumnList
a Maybe OverrideKind
b SelectStmt
c ->
    [Maybe Builder] -> Builder
optLexemes
      [ forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Builder -> Builder
inParens forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. InsertColumnList -> Builder
insertColumnList) Maybe InsertColumnList
a,
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall {a}. (Semigroup a, IsString a) => OverrideKind -> a
insertRestOverriding Maybe OverrideKind
b,
        forall a. a -> Maybe a
Just (SelectStmt -> Builder
selectStmt SelectStmt
c)
      ]
  InsertRest
DefaultValuesInsertRest -> Builder
"DEFAULT VALUES"

insertRestOverriding :: OverrideKind -> a
insertRestOverriding OverrideKind
a = a
"OVERRIDING " forall a. Semigroup a => a -> a -> a
<> forall {a}. IsString a => OverrideKind -> a
overrideKind OverrideKind
a forall a. Semigroup a => a -> a -> a
<> a
" VALUE"

overrideKind :: OverrideKind -> a
overrideKind = \case
  OverrideKind
UserOverrideKind -> a
"USER"
  OverrideKind
SystemOverrideKind -> a
"SYSTEM"

insertColumnList :: InsertColumnList -> Builder
insertColumnList = forall a. (a -> Builder) -> NonEmpty a -> Builder
commaNonEmpty InsertColumnItem -> Builder
insertColumnItem

insertColumnItem :: InsertColumnItem -> Builder
insertColumnItem (InsertColumnItem ColId
a Maybe Indirection
b) = ColId -> Builder
colId ColId
a forall a. Semigroup a => a -> a -> a
<> forall a. (a -> Builder) -> Maybe a -> Builder
suffixMaybe Indirection -> Builder
indirection Maybe Indirection
b

onConflict :: OnConflict -> Builder
onConflict (OnConflict Maybe ConfExpr
a OnConflictDo
b) = Builder
"ON CONFLICT" forall a. Semigroup a => a -> a -> a
<> forall a. (a -> Builder) -> Maybe a -> Builder
suffixMaybe ConfExpr -> Builder
confExpr Maybe ConfExpr
a forall a. Semigroup a => a -> a -> a
<> Builder
" DO " forall a. Semigroup a => a -> a -> a
<> OnConflictDo -> Builder
onConflictDo OnConflictDo
b

onConflictDo :: OnConflictDo -> Builder
onConflictDo = \case
  UpdateOnConflictDo SetClauseList
a Maybe WhereClause
b -> Builder
"UPDATE SET " forall a. Semigroup a => a -> a -> a
<> SetClauseList -> Builder
setClauseList SetClauseList
a forall a. Semigroup a => a -> a -> a
<> forall a. (a -> Builder) -> Maybe a -> Builder
suffixMaybe WhereClause -> Builder
whereClause Maybe WhereClause
b
  OnConflictDo
NothingOnConflictDo -> Builder
"NOTHING"

confExpr :: ConfExpr -> Builder
confExpr = \case
  WhereConfExpr IndexParams
a Maybe WhereClause
b -> Builder -> Builder
inParens (IndexParams -> Builder
indexParams IndexParams
a) forall a. Semigroup a => a -> a -> a
<> forall a. (a -> Builder) -> Maybe a -> Builder
suffixMaybe WhereClause -> Builder
whereClause Maybe WhereClause
b
  ConstraintConfExpr ColId
a -> Builder
"ON CONSTRAINT " forall a. Semigroup a => a -> a -> a
<> ColId -> Builder
name ColId
a

returningClause :: ReturningClause -> Builder
returningClause = forall a. Monoid a => a -> a -> a
mappend Builder
"RETURNING " forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. ReturningClause -> Builder
targetList

-- * Update

updateStmt :: UpdateStmt -> Builder
updateStmt (UpdateStmt Maybe WithClause
a RelationExprOptAlias
b SetClauseList
c Maybe FromClause
d Maybe WhereOrCurrentClause
e Maybe ReturningClause
f) =
  forall a. (a -> Builder) -> Maybe a -> Builder
prefixMaybe WithClause -> Builder
withClause Maybe WithClause
a
    forall a. Semigroup a => a -> a -> a
<> Builder
"UPDATE "
    forall a. Semigroup a => a -> a -> a
<> RelationExprOptAlias -> Builder
relationExprOptAlias RelationExprOptAlias
b
    forall a. Semigroup a => a -> a -> a
<> Builder
" "
    forall a. Semigroup a => a -> a -> a
<> Builder
"SET "
    forall a. Semigroup a => a -> a -> a
<> SetClauseList -> Builder
setClauseList SetClauseList
c
    forall a. Semigroup a => a -> a -> a
<> forall a. (a -> Builder) -> Maybe a -> Builder
suffixMaybe FromClause -> Builder
fromClause Maybe FromClause
d
    forall a. Semigroup a => a -> a -> a
<> forall a. (a -> Builder) -> Maybe a -> Builder
suffixMaybe WhereOrCurrentClause -> Builder
whereOrCurrentClause Maybe WhereOrCurrentClause
e
    forall a. Semigroup a => a -> a -> a
<> forall a. (a -> Builder) -> Maybe a -> Builder
suffixMaybe ReturningClause -> Builder
returningClause Maybe ReturningClause
f

setClauseList :: SetClauseList -> Builder
setClauseList = forall a. (a -> Builder) -> NonEmpty a -> Builder
commaNonEmpty SetClause -> Builder
setClause

setClause :: SetClause -> Builder
setClause = \case
  TargetSetClause SetTarget
a WhereClause
b -> SetTarget -> Builder
setTarget SetTarget
a forall a. Semigroup a => a -> a -> a
<> Builder
" = " forall a. Semigroup a => a -> a -> a
<> WhereClause -> Builder
aExpr WhereClause
b
  TargetListSetClause SetTargetList
a WhereClause
b -> Builder -> Builder
inParens (SetTargetList -> Builder
setTargetList SetTargetList
a) forall a. Semigroup a => a -> a -> a
<> Builder
" = " forall a. Semigroup a => a -> a -> a
<> WhereClause -> Builder
aExpr WhereClause
b

setTarget :: SetTarget -> Builder
setTarget (SetTarget ColId
a Maybe Indirection
b) = ColId -> Builder
colId ColId
a forall a. Semigroup a => a -> a -> a
<> forall a. (a -> Builder) -> Maybe a -> Builder
suffixMaybe Indirection -> Builder
indirection Maybe Indirection
b

setTargetList :: SetTargetList -> Builder
setTargetList = forall a. (a -> Builder) -> NonEmpty a -> Builder
commaNonEmpty SetTarget -> Builder
setTarget

-- * Delete

deleteStmt :: DeleteStmt -> Builder
deleteStmt (DeleteStmt Maybe WithClause
a RelationExprOptAlias
b Maybe FromClause
c Maybe WhereOrCurrentClause
d Maybe ReturningClause
e) =
  forall a. (a -> Builder) -> Maybe a -> Builder
prefixMaybe WithClause -> Builder
withClause Maybe WithClause
a
    forall a. Semigroup a => a -> a -> a
<> Builder
"DELETE FROM "
    forall a. Semigroup a => a -> a -> a
<> RelationExprOptAlias -> Builder
relationExprOptAlias RelationExprOptAlias
b
    forall a. Semigroup a => a -> a -> a
<> forall a. (a -> Builder) -> Maybe a -> Builder
suffixMaybe FromClause -> Builder
usingClause Maybe FromClause
c
    forall a. Semigroup a => a -> a -> a
<> forall a. (a -> Builder) -> Maybe a -> Builder
suffixMaybe WhereOrCurrentClause -> Builder
whereOrCurrentClause Maybe WhereOrCurrentClause
d
    forall a. Semigroup a => a -> a -> a
<> forall a. (a -> Builder) -> Maybe a -> Builder
suffixMaybe ReturningClause -> Builder
returningClause Maybe ReturningClause
e

usingClause :: FromClause -> Builder
usingClause = forall a. Monoid a => a -> a -> a
mappend Builder
"USING " forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. FromClause -> Builder
fromList

-- * Select

selectStmt :: SelectStmt -> Builder
selectStmt = \case
  Left SelectNoParens
a -> SelectNoParens -> Builder
selectNoParens SelectNoParens
a
  Right SelectWithParens
a -> SelectWithParens -> Builder
selectWithParens SelectWithParens
a

selectNoParens :: SelectNoParens -> Builder
selectNoParens (SelectNoParens Maybe WithClause
a SelectClause
b Maybe SortClause
c Maybe SelectLimit
d Maybe ForLockingClause
e) =
  [Maybe Builder] -> Builder
optLexemes
    [ forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap WithClause -> Builder
withClause Maybe WithClause
a,
      forall a. a -> Maybe a
Just (SelectClause -> Builder
selectClause SelectClause
b),
      forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap SortClause -> Builder
sortClause Maybe SortClause
c,
      forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap SelectLimit -> Builder
selectLimit Maybe SelectLimit
d,
      forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ForLockingClause -> Builder
forLockingClause Maybe ForLockingClause
e
    ]

selectWithParens :: SelectWithParens -> Builder
selectWithParens =
  Builder -> Builder
inParens forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. \case
    NoParensSelectWithParens SelectNoParens
a -> SelectNoParens -> Builder
selectNoParens SelectNoParens
a
    WithParensSelectWithParens SelectWithParens
a -> SelectWithParens -> Builder
selectWithParens SelectWithParens
a

withClause :: WithClause -> Builder
withClause (WithClause Bool
a NonEmpty CommonTableExpr
b) =
  Builder
"WITH " forall a. Semigroup a => a -> a -> a
<> forall a. a -> a -> Bool -> a
bool Builder
"" Builder
"RECURSIVE " Bool
a forall a. Semigroup a => a -> a -> a
<> forall a. (a -> Builder) -> NonEmpty a -> Builder
commaNonEmpty CommonTableExpr -> Builder
commonTableExpr NonEmpty CommonTableExpr
b

commonTableExpr :: CommonTableExpr -> Builder
commonTableExpr (CommonTableExpr ColId
a Maybe (NonEmpty ColId)
b Maybe Bool
c PreparableStmt
d) =
  [Maybe Builder] -> Builder
optLexemes
    [ forall a. a -> Maybe a
Just (ColId -> Builder
ident ColId
a),
      forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Builder -> Builder
inParens forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall a. (a -> Builder) -> NonEmpty a -> Builder
commaNonEmpty ColId -> Builder
ident) Maybe (NonEmpty ColId)
b,
      forall a. a -> Maybe a
Just Builder
"AS",
      forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall {a}. IsString a => Bool -> a
materialization Maybe Bool
c,
      forall a. a -> Maybe a
Just (Builder -> Builder
inParens (PreparableStmt -> Builder
preparableStmt PreparableStmt
d))
    ]

materialization :: Bool -> a
materialization = forall a. a -> a -> Bool -> a
bool a
"NOT MATERIALIZED" a
"MATERIALIZED"

selectLimit :: SelectLimit -> Builder
selectLimit = \case
  LimitOffsetSelectLimit LimitClause
a OffsetClause
b -> [Builder] -> Builder
lexemes [LimitClause -> Builder
limitClause LimitClause
a, OffsetClause -> Builder
offsetClause OffsetClause
b]
  OffsetLimitSelectLimit OffsetClause
a LimitClause
b -> [Builder] -> Builder
lexemes [OffsetClause -> Builder
offsetClause OffsetClause
a, LimitClause -> Builder
limitClause LimitClause
b]
  LimitSelectLimit LimitClause
a -> LimitClause -> Builder
limitClause LimitClause
a
  OffsetSelectLimit OffsetClause
a -> OffsetClause -> Builder
offsetClause OffsetClause
a

limitClause :: LimitClause -> Builder
limitClause = \case
  LimitLimitClause SelectLimitValue
a Maybe WhereClause
b -> Builder
"LIMIT " forall a. Semigroup a => a -> a -> a
<> SelectLimitValue -> Builder
selectLimitValue SelectLimitValue
a forall a. Semigroup a => a -> a -> a
<> forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap (forall a. Monoid a => a -> a -> a
mappend Builder
", " forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. WhereClause -> Builder
aExpr) Maybe WhereClause
b
  FetchOnlyLimitClause Bool
a Maybe SelectFetchFirstValue
b Bool
c ->
    [Maybe Builder] -> Builder
optLexemes
      [ forall a. a -> Maybe a
Just Builder
"FETCH",
        forall a. a -> Maybe a
Just (forall {a}. IsString a => Bool -> a
firstOrNext Bool
a),
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap SelectFetchFirstValue -> Builder
selectFetchFirstValue Maybe SelectFetchFirstValue
b,
        forall a. a -> Maybe a
Just (forall {a}. IsString a => Bool -> a
rowOrRows Bool
c),
        forall a. a -> Maybe a
Just Builder
"ONLY"
      ]

firstOrNext :: Bool -> a
firstOrNext = forall a. a -> a -> Bool -> a
bool a
"FIRST" a
"NEXT"

rowOrRows :: Bool -> a
rowOrRows = forall a. a -> a -> Bool -> a
bool a
"ROW" a
"ROWS"

selectFetchFirstValue :: SelectFetchFirstValue -> Builder
selectFetchFirstValue = \case
  ExprSelectFetchFirstValue CExpr
a -> CExpr -> Builder
cExpr CExpr
a
  NumSelectFetchFirstValue Bool
a Either Int64 Double
b -> forall a. a -> a -> Bool -> a
bool Builder
"+" Builder
"-" Bool
a forall a. Semigroup a => a -> a -> a
<> Either Int64 Double -> Builder
intOrFloat Either Int64 Double
b

intOrFloat :: Either Int64 Double -> Builder
intOrFloat = forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either Int64 -> Builder
int64Dec Double -> Builder
doubleDec

selectLimitValue :: SelectLimitValue -> Builder
selectLimitValue = \case
  ExprSelectLimitValue WhereClause
a -> WhereClause -> Builder
aExpr WhereClause
a
  SelectLimitValue
AllSelectLimitValue -> Builder
"ALL"

offsetClause :: OffsetClause -> Builder
offsetClause = \case
  ExprOffsetClause WhereClause
a -> Builder
"OFFSET " forall a. Semigroup a => a -> a -> a
<> WhereClause -> Builder
aExpr WhereClause
a
  FetchFirstOffsetClause SelectFetchFirstValue
a Bool
b -> Builder
"OFFSET " forall a. Semigroup a => a -> a -> a
<> SelectFetchFirstValue -> Builder
selectFetchFirstValue SelectFetchFirstValue
a forall a. Semigroup a => a -> a -> a
<> Builder
" " forall a. Semigroup a => a -> a -> a
<> forall {a}. IsString a => Bool -> a
rowOrRows Bool
b

forLockingClause :: ForLockingClause -> Builder
forLockingClause = \case
  ItemsForLockingClause NonEmpty ForLockingItem
a -> forall a. (a -> Builder) -> NonEmpty a -> Builder
spaceNonEmpty ForLockingItem -> Builder
forLockingItem NonEmpty ForLockingItem
a
  ForLockingClause
ReadOnlyForLockingClause -> Builder
"FOR READ ONLY"

forLockingItem :: ForLockingItem -> Builder
forLockingItem (ForLockingItem ForLockingStrength
a Maybe (NonEmpty QualifiedName)
b Maybe Bool
c) =
  [Maybe Builder] -> Builder
optLexemes
    [ forall a. a -> Maybe a
Just (forall {a}. IsString a => ForLockingStrength -> a
forLockingStrength ForLockingStrength
a),
      forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap NonEmpty QualifiedName -> Builder
lockedRelsList Maybe (NonEmpty QualifiedName)
b,
      forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall {a}. IsString a => Bool -> a
nowaitOrSkip Maybe Bool
c
    ]

forLockingStrength :: ForLockingStrength -> a
forLockingStrength = \case
  ForLockingStrength
UpdateForLockingStrength -> a
"FOR UPDATE"
  ForLockingStrength
NoKeyUpdateForLockingStrength -> a
"FOR NO KEY UPDATE"
  ForLockingStrength
ShareForLockingStrength -> a
"FOR SHARE"
  ForLockingStrength
KeyForLockingStrength -> a
"FOR KEY SHARE"

lockedRelsList :: NonEmpty QualifiedName -> Builder
lockedRelsList NonEmpty QualifiedName
a = Builder
"OF " forall a. Semigroup a => a -> a -> a
<> forall a. (a -> Builder) -> NonEmpty a -> Builder
commaNonEmpty QualifiedName -> Builder
qualifiedName NonEmpty QualifiedName
a

nowaitOrSkip :: Bool -> a
nowaitOrSkip = forall a. a -> a -> Bool -> a
bool a
"NOWAIT" a
"SKIP LOCKED"

selectClause :: SelectClause -> Builder
selectClause = forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either SimpleSelect -> Builder
simpleSelect SelectWithParens -> Builder
selectWithParens

simpleSelect :: SimpleSelect -> Builder
simpleSelect = \case
  NormalSimpleSelect Maybe Targeting
a Maybe IntoClause
b Maybe FromClause
c Maybe WhereClause
d Maybe GroupClause
e Maybe WhereClause
f Maybe WindowClause
g ->
    [Maybe Builder] -> Builder
optLexemes
      [ forall a. a -> Maybe a
Just Builder
"SELECT",
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Targeting -> Builder
targeting Maybe Targeting
a,
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap IntoClause -> Builder
intoClause Maybe IntoClause
b,
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap FromClause -> Builder
fromClause Maybe FromClause
c,
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap WhereClause -> Builder
whereClause Maybe WhereClause
d,
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap GroupClause -> Builder
groupClause Maybe GroupClause
e,
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap WhereClause -> Builder
havingClause Maybe WhereClause
f,
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap WindowClause -> Builder
windowClause Maybe WindowClause
g
      ]
  ValuesSimpleSelect ValuesClause
a -> ValuesClause -> Builder
valuesClause ValuesClause
a
  TableSimpleSelect RelationExpr
a -> Builder
"TABLE " forall a. Semigroup a => a -> a -> a
<> RelationExpr -> Builder
relationExpr RelationExpr
a
  BinSimpleSelect SelectBinOp
a SelectClause
b Maybe Bool
c SelectClause
d -> SelectClause -> Builder
selectClause SelectClause
b forall a. Semigroup a => a -> a -> a
<> Builder
" " forall a. Semigroup a => a -> a -> a
<> forall {a}. IsString a => SelectBinOp -> a
selectBinOp SelectBinOp
a forall a. Semigroup a => a -> a -> a
<> forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap (forall a. Monoid a => a -> a -> a
mappend Builder
" " forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall {a}. IsString a => Bool -> a
allOrDistinct) Maybe Bool
c forall a. Semigroup a => a -> a -> a
<> Builder
" " forall a. Semigroup a => a -> a -> a
<> SelectClause -> Builder
selectClause SelectClause
d

selectBinOp :: SelectBinOp -> a
selectBinOp = \case
  SelectBinOp
UnionSelectBinOp -> a
"UNION"
  SelectBinOp
IntersectSelectBinOp -> a
"INTERSECT"
  SelectBinOp
ExceptSelectBinOp -> a
"EXCEPT"

targeting :: Targeting -> Builder
targeting = \case
  NormalTargeting ReturningClause
a -> ReturningClause -> Builder
targetList ReturningClause
a
  AllTargeting Maybe ReturningClause
a -> Builder
"ALL" forall a. Semigroup a => a -> a -> a
<> forall a. (a -> Builder) -> Maybe a -> Builder
suffixMaybe ReturningClause -> Builder
targetList Maybe ReturningClause
a
  DistinctTargeting Maybe ExprList
a ReturningClause
b -> Builder
"DISTINCT" forall a. Semigroup a => a -> a -> a
<> forall a. (a -> Builder) -> Maybe a -> Builder
suffixMaybe ExprList -> Builder
onExpressionsClause Maybe ExprList
a forall a. Semigroup a => a -> a -> a
<> Builder
" " forall a. Semigroup a => a -> a -> a
<> forall a. (a -> Builder) -> NonEmpty a -> Builder
commaNonEmpty TargetEl -> Builder
targetEl ReturningClause
b

targetList :: ReturningClause -> Builder
targetList = forall a. (a -> Builder) -> NonEmpty a -> Builder
commaNonEmpty TargetEl -> Builder
targetEl

onExpressionsClause :: ExprList -> Builder
onExpressionsClause ExprList
a = Builder
"ON (" forall a. Semigroup a => a -> a -> a
<> forall a. (a -> Builder) -> NonEmpty a -> Builder
commaNonEmpty WhereClause -> Builder
aExpr ExprList
a forall a. Semigroup a => a -> a -> a
<> Builder
")"

targetEl :: TargetEl -> Builder
targetEl = \case
  AliasedExprTargetEl WhereClause
a ColId
b -> WhereClause -> Builder
aExpr WhereClause
a forall a. Semigroup a => a -> a -> a
<> Builder
" AS " forall a. Semigroup a => a -> a -> a
<> ColId -> Builder
ident ColId
b
  ImplicitlyAliasedExprTargetEl WhereClause
a ColId
b -> WhereClause -> Builder
aExpr WhereClause
a forall a. Semigroup a => a -> a -> a
<> Builder
" " forall a. Semigroup a => a -> a -> a
<> ColId -> Builder
ident ColId
b
  ExprTargetEl WhereClause
a -> WhereClause -> Builder
aExpr WhereClause
a
  TargetEl
AsteriskTargetEl -> Builder
"*"

-- * Select Into

intoClause :: IntoClause -> Builder
intoClause IntoClause
a = Builder
"INTO " forall a. Semigroup a => a -> a -> a
<> IntoClause -> Builder
optTempTableName IntoClause
a

optTempTableName :: IntoClause -> Builder
optTempTableName = \case
  TemporaryOptTempTableName Bool
a QualifiedName
b -> [Maybe Builder] -> Builder
optLexemes [forall a. a -> Maybe a
Just Builder
"TEMPORARY", forall a. a -> a -> Bool -> a
bool forall a. Maybe a
Nothing (forall a. a -> Maybe a
Just Builder
"TABLE") Bool
a, forall a. a -> Maybe a
Just (QualifiedName -> Builder
qualifiedName QualifiedName
b)]
  TempOptTempTableName Bool
a QualifiedName
b -> [Maybe Builder] -> Builder
optLexemes [forall a. a -> Maybe a
Just Builder
"TEMP", forall a. a -> a -> Bool -> a
bool forall a. Maybe a
Nothing (forall a. a -> Maybe a
Just Builder
"TABLE") Bool
a, forall a. a -> Maybe a
Just (QualifiedName -> Builder
qualifiedName QualifiedName
b)]
  LocalTemporaryOptTempTableName Bool
a QualifiedName
b -> [Maybe Builder] -> Builder
optLexemes [forall a. a -> Maybe a
Just Builder
"LOCAL TEMPORARY", forall a. a -> a -> Bool -> a
bool forall a. Maybe a
Nothing (forall a. a -> Maybe a
Just Builder
"TABLE") Bool
a, forall a. a -> Maybe a
Just (QualifiedName -> Builder
qualifiedName QualifiedName
b)]
  LocalTempOptTempTableName Bool
a QualifiedName
b -> [Maybe Builder] -> Builder
optLexemes [forall a. a -> Maybe a
Just Builder
"LOCAL TEMP", forall a. a -> a -> Bool -> a
bool forall a. Maybe a
Nothing (forall a. a -> Maybe a
Just Builder
"TABLE") Bool
a, forall a. a -> Maybe a
Just (QualifiedName -> Builder
qualifiedName QualifiedName
b)]
  GlobalTemporaryOptTempTableName Bool
a QualifiedName
b -> [Maybe Builder] -> Builder
optLexemes [forall a. a -> Maybe a
Just Builder
"GLOBAL TEMPORARY", forall a. a -> a -> Bool -> a
bool forall a. Maybe a
Nothing (forall a. a -> Maybe a
Just Builder
"TABLE") Bool
a, forall a. a -> Maybe a
Just (QualifiedName -> Builder
qualifiedName QualifiedName
b)]
  GlobalTempOptTempTableName Bool
a QualifiedName
b -> [Maybe Builder] -> Builder
optLexemes [forall a. a -> Maybe a
Just Builder
"GLOBAL TEMP", forall a. a -> a -> Bool -> a
bool forall a. Maybe a
Nothing (forall a. a -> Maybe a
Just Builder
"TABLE") Bool
a, forall a. a -> Maybe a
Just (QualifiedName -> Builder
qualifiedName QualifiedName
b)]
  UnloggedOptTempTableName Bool
a QualifiedName
b -> [Maybe Builder] -> Builder
optLexemes [forall a. a -> Maybe a
Just Builder
"UNLOGGED", forall a. a -> a -> Bool -> a
bool forall a. Maybe a
Nothing (forall a. a -> Maybe a
Just Builder
"TABLE") Bool
a, forall a. a -> Maybe a
Just (QualifiedName -> Builder
qualifiedName QualifiedName
b)]
  TableOptTempTableName QualifiedName
a -> Builder
"TABLE " forall a. Semigroup a => a -> a -> a
<> QualifiedName -> Builder
qualifiedName QualifiedName
a
  QualifedOptTempTableName QualifiedName
a -> QualifiedName -> Builder
qualifiedName QualifiedName
a

-- * From

fromClause :: FromClause -> Builder
fromClause FromClause
a = Builder
"FROM " forall a. Semigroup a => a -> a -> a
<> FromClause -> Builder
fromList FromClause
a

fromList :: FromClause -> Builder
fromList = forall a. (a -> Builder) -> NonEmpty a -> Builder
commaNonEmpty TableRef -> Builder
tableRef

tableRef :: TableRef -> Builder
tableRef = \case
  RelationExprTableRef RelationExpr
a Maybe AliasClause
b Maybe TablesampleClause
c ->
    [Maybe Builder] -> Builder
optLexemes
      [ forall a. a -> Maybe a
Just (RelationExpr -> Builder
relationExpr RelationExpr
a),
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap AliasClause -> Builder
aliasClause Maybe AliasClause
b,
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap TablesampleClause -> Builder
tablesampleClause Maybe TablesampleClause
c
      ]
  FuncTableRef Bool
a FuncTable
b Maybe FuncAliasClause
c ->
    [Maybe Builder] -> Builder
optLexemes
      [ if Bool
a then forall a. a -> Maybe a
Just Builder
"LATERAL" else forall a. Maybe a
Nothing,
        forall a. a -> Maybe a
Just (FuncTable -> Builder
funcTable FuncTable
b),
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap FuncAliasClause -> Builder
funcAliasClause Maybe FuncAliasClause
c
      ]
  SelectTableRef Bool
a SelectWithParens
b Maybe AliasClause
c ->
    [Maybe Builder] -> Builder
optLexemes
      [ if Bool
a then forall a. a -> Maybe a
Just Builder
"LATERAL" else forall a. Maybe a
Nothing,
        forall a. a -> Maybe a
Just (SelectWithParens -> Builder
selectWithParens SelectWithParens
b),
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap AliasClause -> Builder
aliasClause Maybe AliasClause
c
      ]
  JoinTableRef JoinedTable
a Maybe AliasClause
b -> case Maybe AliasClause
b of
    Just AliasClause
c -> Builder -> Builder
inParens (JoinedTable -> Builder
joinedTable JoinedTable
a) forall a. Semigroup a => a -> a -> a
<> Builder
" " forall a. Semigroup a => a -> a -> a
<> AliasClause -> Builder
aliasClause AliasClause
c
    Maybe AliasClause
Nothing -> JoinedTable -> Builder
joinedTable JoinedTable
a

relationExpr :: RelationExpr -> Builder
relationExpr = \case
  SimpleRelationExpr QualifiedName
a Bool
b -> QualifiedName -> Builder
qualifiedName QualifiedName
a forall a. Semigroup a => a -> a -> a
<> forall a. a -> a -> Bool -> a
bool Builder
"" Builder
" *" Bool
b
  OnlyRelationExpr QualifiedName
a Bool
b -> Builder
"ONLY " forall a. Semigroup a => a -> a -> a
<> forall a. a -> a -> Bool -> a
bool QualifiedName -> Builder
qualifiedName (Builder -> Builder
inParens forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. QualifiedName -> Builder
qualifiedName) Bool
b QualifiedName
a

relationExprOptAlias :: RelationExprOptAlias -> Builder
relationExprOptAlias (RelationExprOptAlias RelationExpr
a Maybe (Bool, ColId)
b) = RelationExpr -> Builder
relationExpr RelationExpr
a forall a. Semigroup a => a -> a -> a
<> forall a. (a -> Builder) -> Maybe a -> Builder
suffixMaybe (Bool, ColId) -> Builder
optAlias Maybe (Bool, ColId)
b

optAlias :: (Bool, ColId) -> Builder
optAlias (Bool
a, ColId
b) = forall a. a -> a -> Bool -> a
bool Builder
"" Builder
"AS " Bool
a forall a. Semigroup a => a -> a -> a
<> ColId -> Builder
colId ColId
b

tablesampleClause :: TablesampleClause -> Builder
tablesampleClause (TablesampleClause FuncName
a ExprList
b Maybe WhereClause
c) =
  Builder
"TABLESAMPLE " forall a. Semigroup a => a -> a -> a
<> FuncName -> Builder
funcName FuncName
a forall a. Semigroup a => a -> a -> a
<> Builder
" (" forall a. Semigroup a => a -> a -> a
<> ExprList -> Builder
exprList ExprList
b forall a. Semigroup a => a -> a -> a
<> Builder
")" forall a. Semigroup a => a -> a -> a
<> forall a. (a -> Builder) -> Maybe a -> Builder
suffixMaybe WhereClause -> Builder
repeatableClause Maybe WhereClause
c

repeatableClause :: WhereClause -> Builder
repeatableClause WhereClause
a = Builder
"REPEATABLE (" forall a. Semigroup a => a -> a -> a
<> WhereClause -> Builder
aExpr WhereClause
a forall a. Semigroup a => a -> a -> a
<> Builder
")"

funcTable :: FuncTable -> Builder
funcTable = \case
  FuncExprFuncTable FuncExprWindowless
a Bool
b -> FuncExprWindowless -> Builder
funcExprWindownless FuncExprWindowless
a forall a. Semigroup a => a -> a -> a
<> forall a. a -> a -> Bool -> a
bool Builder
"" Builder
" WITH ORDINALITY" Bool
b
  RowsFromFuncTable RowsfromList
a Bool
b -> Builder
"ROWS FROM (" forall a. Semigroup a => a -> a -> a
<> RowsfromList -> Builder
rowsfromList RowsfromList
a forall a. Semigroup a => a -> a -> a
<> Builder
")" forall a. Semigroup a => a -> a -> a
<> forall a. a -> a -> Bool -> a
bool Builder
"" Builder
" WITH ORDINALITY" Bool
b

rowsfromItem :: RowsfromItem -> Builder
rowsfromItem (RowsfromItem FuncExprWindowless
a Maybe ColDefList
b) = FuncExprWindowless -> Builder
funcExprWindownless FuncExprWindowless
a forall a. Semigroup a => a -> a -> a
<> forall a. (a -> Builder) -> Maybe a -> Builder
suffixMaybe ColDefList -> Builder
colDefList Maybe ColDefList
b

rowsfromList :: RowsfromList -> Builder
rowsfromList = forall a. (a -> Builder) -> NonEmpty a -> Builder
commaNonEmpty RowsfromItem -> Builder
rowsfromItem

colDefList :: ColDefList -> Builder
colDefList ColDefList
a = Builder
"AS (" forall a. Semigroup a => a -> a -> a
<> ColDefList -> Builder
tableFuncElementList ColDefList
a forall a. Semigroup a => a -> a -> a
<> Builder
")"

tableFuncElementList :: ColDefList -> Builder
tableFuncElementList = forall a. (a -> Builder) -> NonEmpty a -> Builder
commaNonEmpty TableFuncElement -> Builder
tableFuncElement

tableFuncElement :: TableFuncElement -> Builder
tableFuncElement (TableFuncElement ColId
a Typename
b Maybe CollateClause
c) = ColId -> Builder
colId ColId
a forall a. Semigroup a => a -> a -> a
<> Builder
" " forall a. Semigroup a => a -> a -> a
<> Typename -> Builder
typename Typename
b forall a. Semigroup a => a -> a -> a
<> forall a. (a -> Builder) -> Maybe a -> Builder
suffixMaybe CollateClause -> Builder
collateClause Maybe CollateClause
c

collateClause :: CollateClause -> Builder
collateClause CollateClause
a = Builder
"COLLATE " forall a. Semigroup a => a -> a -> a
<> CollateClause -> Builder
anyName CollateClause
a

aliasClause :: AliasClause -> Builder
aliasClause (AliasClause Bool
a ColId
b Maybe (NonEmpty ColId)
c) =
  [Maybe Builder] -> Builder
optLexemes
    [ if Bool
a then forall a. a -> Maybe a
Just Builder
"AS" else forall a. Maybe a
Nothing,
      forall a. a -> Maybe a
Just (ColId -> Builder
ident ColId
b),
      forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Builder -> Builder
inParens forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall a. (a -> Builder) -> NonEmpty a -> Builder
commaNonEmpty ColId -> Builder
ident) Maybe (NonEmpty ColId)
c
    ]

funcAliasClause :: FuncAliasClause -> Builder
funcAliasClause = \case
  AliasFuncAliasClause AliasClause
a -> AliasClause -> Builder
aliasClause AliasClause
a
  AsFuncAliasClause ColDefList
a -> Builder
"AS (" forall a. Semigroup a => a -> a -> a
<> ColDefList -> Builder
tableFuncElementList ColDefList
a forall a. Semigroup a => a -> a -> a
<> Builder
")"
  AsColIdFuncAliasClause ColId
a ColDefList
b -> Builder
"AS " forall a. Semigroup a => a -> a -> a
<> ColId -> Builder
colId ColId
a forall a. Semigroup a => a -> a -> a
<> Builder
" (" forall a. Semigroup a => a -> a -> a
<> ColDefList -> Builder
tableFuncElementList ColDefList
b forall a. Semigroup a => a -> a -> a
<> Builder
")"
  ColIdFuncAliasClause ColId
a ColDefList
b -> ColId -> Builder
colId ColId
a forall a. Semigroup a => a -> a -> a
<> Builder
" (" forall a. Semigroup a => a -> a -> a
<> ColDefList -> Builder
tableFuncElementList ColDefList
b forall a. Semigroup a => a -> a -> a
<> Builder
")"

joinedTable :: JoinedTable -> Builder
joinedTable = \case
  InParensJoinedTable JoinedTable
a -> Builder -> Builder
inParens (JoinedTable -> Builder
joinedTable JoinedTable
a)
  MethJoinedTable JoinMeth
a TableRef
b TableRef
c -> case JoinMeth
a of
    JoinMeth
CrossJoinMeth -> TableRef -> Builder
tableRef TableRef
b forall a. Semigroup a => a -> a -> a
<> Builder
" CROSS JOIN " forall a. Semigroup a => a -> a -> a
<> TableRef -> Builder
tableRef TableRef
c
    QualJoinMeth Maybe JoinType
d JoinQual
e -> TableRef -> Builder
tableRef TableRef
b forall a. Semigroup a => a -> a -> a
<> forall a. (a -> Builder) -> Maybe a -> Builder
suffixMaybe forall {a}. (Semigroup a, IsString a) => JoinType -> a
joinType Maybe JoinType
d forall a. Semigroup a => a -> a -> a
<> Builder
" JOIN " forall a. Semigroup a => a -> a -> a
<> TableRef -> Builder
tableRef TableRef
c forall a. Semigroup a => a -> a -> a
<> Builder
" " forall a. Semigroup a => a -> a -> a
<> JoinQual -> Builder
joinQual JoinQual
e
    NaturalJoinMeth Maybe JoinType
d -> TableRef -> Builder
tableRef TableRef
b forall a. Semigroup a => a -> a -> a
<> Builder
" NATURAL" forall a. Semigroup a => a -> a -> a
<> forall a. (a -> Builder) -> Maybe a -> Builder
suffixMaybe forall {a}. (Semigroup a, IsString a) => JoinType -> a
joinType Maybe JoinType
d forall a. Semigroup a => a -> a -> a
<> Builder
" JOIN " forall a. Semigroup a => a -> a -> a
<> TableRef -> Builder
tableRef TableRef
c

joinType :: JoinType -> a
joinType = \case
  FullJoinType Bool
a -> a
"FULL" forall a. Semigroup a => a -> a -> a
<> if Bool
a then a
" OUTER" else a
""
  LeftJoinType Bool
a -> a
"LEFT" forall a. Semigroup a => a -> a -> a
<> if Bool
a then a
" OUTER" else a
""
  RightJoinType Bool
a -> a
"RIGHT" forall a. Semigroup a => a -> a -> a
<> if Bool
a then a
" OUTER" else a
""
  JoinType
InnerJoinType -> a
"INNER"

joinQual :: JoinQual -> Builder
joinQual = \case
  UsingJoinQual NonEmpty ColId
a -> Builder
"USING (" forall a. Semigroup a => a -> a -> a
<> forall a. (a -> Builder) -> NonEmpty a -> Builder
commaNonEmpty ColId -> Builder
ident NonEmpty ColId
a forall a. Semigroup a => a -> a -> a
<> Builder
")"
  OnJoinQual WhereClause
a -> Builder
"ON " forall a. Semigroup a => a -> a -> a
<> WhereClause -> Builder
aExpr WhereClause
a

-- * Where

whereClause :: WhereClause -> Builder
whereClause WhereClause
a = Builder
"WHERE " forall a. Semigroup a => a -> a -> a
<> WhereClause -> Builder
aExpr WhereClause
a

whereOrCurrentClause :: WhereOrCurrentClause -> Builder
whereOrCurrentClause = \case
  ExprWhereOrCurrentClause WhereClause
a -> Builder
"WHERE " forall a. Semigroup a => a -> a -> a
<> WhereClause -> Builder
aExpr WhereClause
a
  CursorWhereOrCurrentClause ColId
a -> Builder
"WHERE CURRENT OF " forall a. Semigroup a => a -> a -> a
<> ColId -> Builder
cursorName ColId
a

-- * Group By

groupClause :: GroupClause -> Builder
groupClause GroupClause
a = Builder
"GROUP BY " forall a. Semigroup a => a -> a -> a
<> forall a. (a -> Builder) -> NonEmpty a -> Builder
commaNonEmpty GroupByItem -> Builder
groupByItem GroupClause
a

groupByItem :: GroupByItem -> Builder
groupByItem = \case
  ExprGroupByItem WhereClause
a -> WhereClause -> Builder
aExpr WhereClause
a
  GroupByItem
EmptyGroupingSetGroupByItem -> Builder
"()"
  RollupGroupByItem ExprList
a -> Builder
"ROLLUP (" forall a. Semigroup a => a -> a -> a
<> forall a. (a -> Builder) -> NonEmpty a -> Builder
commaNonEmpty WhereClause -> Builder
aExpr ExprList
a forall a. Semigroup a => a -> a -> a
<> Builder
")"
  CubeGroupByItem ExprList
a -> Builder
"CUBE (" forall a. Semigroup a => a -> a -> a
<> forall a. (a -> Builder) -> NonEmpty a -> Builder
commaNonEmpty WhereClause -> Builder
aExpr ExprList
a forall a. Semigroup a => a -> a -> a
<> Builder
")"
  GroupingSetsGroupByItem GroupClause
a -> Builder
"GROUPING SETS (" forall a. Semigroup a => a -> a -> a
<> forall a. (a -> Builder) -> NonEmpty a -> Builder
commaNonEmpty GroupByItem -> Builder
groupByItem GroupClause
a forall a. Semigroup a => a -> a -> a
<> Builder
")"

-- * Having

havingClause :: WhereClause -> Builder
havingClause WhereClause
a = Builder
"HAVING " forall a. Semigroup a => a -> a -> a
<> WhereClause -> Builder
aExpr WhereClause
a

-- * Window

windowClause :: WindowClause -> Builder
windowClause WindowClause
a = Builder
"WINDOW " forall a. Semigroup a => a -> a -> a
<> forall a. (a -> Builder) -> NonEmpty a -> Builder
commaNonEmpty WindowDefinition -> Builder
windowDefinition WindowClause
a

windowDefinition :: WindowDefinition -> Builder
windowDefinition (WindowDefinition ColId
a WindowSpecification
b) = ColId -> Builder
ident ColId
a forall a. Semigroup a => a -> a -> a
<> Builder
" AS " forall a. Semigroup a => a -> a -> a
<> WindowSpecification -> Builder
windowSpecification WindowSpecification
b

windowSpecification :: WindowSpecification -> Builder
windowSpecification (WindowSpecification Maybe ColId
a Maybe ExprList
b Maybe SortClause
c Maybe FrameClause
d) =
  Builder -> Builder
inParens
    forall a b. (a -> b) -> a -> b
$ [Maybe Builder] -> Builder
optLexemes
      [ forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ColId -> Builder
ident Maybe ColId
a,
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ExprList -> Builder
partitionClause Maybe ExprList
b,
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap SortClause -> Builder
sortClause Maybe SortClause
c,
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap FrameClause -> Builder
frameClause Maybe FrameClause
d
      ]

partitionClause :: ExprList -> Builder
partitionClause ExprList
a = Builder
"PARTITION BY " forall a. Semigroup a => a -> a -> a
<> forall a. (a -> Builder) -> NonEmpty a -> Builder
commaNonEmpty WhereClause -> Builder
aExpr ExprList
a

frameClause :: FrameClause -> Builder
frameClause (FrameClause FrameClauseMode
a FrameExtent
b Maybe WindowExclusionClause
c) =
  [Maybe Builder] -> Builder
optLexemes
    [ forall a. a -> Maybe a
Just (forall {a}. IsString a => FrameClauseMode -> a
frameClauseMode FrameClauseMode
a),
      forall a. a -> Maybe a
Just (FrameExtent -> Builder
frameExtent FrameExtent
b),
      forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall {a}. IsString a => WindowExclusionClause -> a
windowExclusionCause Maybe WindowExclusionClause
c
    ]

frameClauseMode :: FrameClauseMode -> a
frameClauseMode = \case
  FrameClauseMode
RangeFrameClauseMode -> a
"RANGE"
  FrameClauseMode
RowsFrameClauseMode -> a
"ROWS"
  FrameClauseMode
GroupsFrameClauseMode -> a
"GROUPS"

frameExtent :: FrameExtent -> Builder
frameExtent = \case
  SingularFrameExtent FrameBound
a -> FrameBound -> Builder
frameBound FrameBound
a
  BetweenFrameExtent FrameBound
a FrameBound
b -> Builder
"BETWEEN " forall a. Semigroup a => a -> a -> a
<> FrameBound -> Builder
frameBound FrameBound
a forall a. Semigroup a => a -> a -> a
<> Builder
" AND " forall a. Semigroup a => a -> a -> a
<> FrameBound -> Builder
frameBound FrameBound
b

frameBound :: FrameBound -> Builder
frameBound = \case
  FrameBound
UnboundedPrecedingFrameBound -> Builder
"UNBOUNDED PRECEDING"
  FrameBound
UnboundedFollowingFrameBound -> Builder
"UNBOUNDED FOLLOWING"
  FrameBound
CurrentRowFrameBound -> Builder
"CURRENT ROW"
  PrecedingFrameBound WhereClause
a -> WhereClause -> Builder
aExpr WhereClause
a forall a. Semigroup a => a -> a -> a
<> Builder
" PRECEDING"
  FollowingFrameBound WhereClause
a -> WhereClause -> Builder
aExpr WhereClause
a forall a. Semigroup a => a -> a -> a
<> Builder
" FOLLOWING"

windowExclusionCause :: WindowExclusionClause -> a
windowExclusionCause = \case
  WindowExclusionClause
CurrentRowWindowExclusionClause -> a
"EXCLUDE CURRENT ROW"
  WindowExclusionClause
GroupWindowExclusionClause -> a
"EXCLUDE GROUP"
  WindowExclusionClause
TiesWindowExclusionClause -> a
"EXCLUDE TIES"
  WindowExclusionClause
NoOthersWindowExclusionClause -> a
"EXCLUDE NO OTHERS"

-- * Order By

sortClause :: SortClause -> Builder
sortClause SortClause
a = Builder
"ORDER BY " forall a. Semigroup a => a -> a -> a
<> forall a. (a -> Builder) -> NonEmpty a -> Builder
commaNonEmpty SortBy -> Builder
sortBy SortClause
a

sortBy :: SortBy -> Builder
sortBy = \case
  UsingSortBy WhereClause
a QualAllOp
b Maybe NullsOrder
c -> WhereClause -> Builder
aExpr WhereClause
a forall a. Semigroup a => a -> a -> a
<> Builder
" USING " forall a. Semigroup a => a -> a -> a
<> QualAllOp -> Builder
qualAllOp QualAllOp
b forall a. Semigroup a => a -> a -> a
<> forall a. (a -> Builder) -> Maybe a -> Builder
suffixMaybe forall {a}. IsString a => NullsOrder -> a
nullsOrder Maybe NullsOrder
c
  AscDescSortBy WhereClause
a Maybe AscDesc
b Maybe NullsOrder
c -> WhereClause -> Builder
aExpr WhereClause
a forall a. Semigroup a => a -> a -> a
<> forall a. (a -> Builder) -> Maybe a -> Builder
suffixMaybe forall {a}. IsString a => AscDesc -> a
ascDesc Maybe AscDesc
b forall a. Semigroup a => a -> a -> a
<> forall a. (a -> Builder) -> Maybe a -> Builder
suffixMaybe forall {a}. IsString a => NullsOrder -> a
nullsOrder Maybe NullsOrder
c

-- * Values

valuesClause :: ValuesClause -> Builder
valuesClause ValuesClause
a = Builder
"VALUES " forall a. Semigroup a => a -> a -> a
<> forall a. (a -> Builder) -> NonEmpty a -> Builder
commaNonEmpty (Builder -> Builder
inParens forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall a. (a -> Builder) -> NonEmpty a -> Builder
commaNonEmpty WhereClause -> Builder
aExpr) ValuesClause
a

-- * Exprs

exprList :: ExprList -> Builder
exprList = forall a. (a -> Builder) -> NonEmpty a -> Builder
commaNonEmpty WhereClause -> Builder
aExpr

aExpr :: WhereClause -> Builder
aExpr = \case
  CExprAExpr CExpr
a -> CExpr -> Builder
cExpr CExpr
a
  TypecastAExpr WhereClause
a Typename
b -> WhereClause -> Builder
aExpr WhereClause
a forall a. Semigroup a => a -> a -> a
<> Builder
" :: " forall a. Semigroup a => a -> a -> a
<> Typename -> Builder
typename Typename
b
  CollateAExpr WhereClause
a CollateClause
b -> WhereClause -> Builder
aExpr WhereClause
a forall a. Semigroup a => a -> a -> a
<> Builder
" COLLATE " forall a. Semigroup a => a -> a -> a
<> CollateClause -> Builder
anyName CollateClause
b
  AtTimeZoneAExpr WhereClause
a WhereClause
b -> WhereClause -> Builder
aExpr WhereClause
a forall a. Semigroup a => a -> a -> a
<> Builder
" AT TIME ZONE " forall a. Semigroup a => a -> a -> a
<> WhereClause -> Builder
aExpr WhereClause
b
  PlusAExpr WhereClause
a -> Builder
"+ " forall a. Semigroup a => a -> a -> a
<> WhereClause -> Builder
aExpr WhereClause
a
  MinusAExpr WhereClause
a -> Builder
"- " forall a. Semigroup a => a -> a -> a
<> WhereClause -> Builder
aExpr WhereClause
a
  SymbolicBinOpAExpr WhereClause
a SymbolicExprBinOp
b WhereClause
c -> WhereClause -> Builder
aExpr WhereClause
a forall a. Semigroup a => a -> a -> a
<> Builder
" " forall a. Semigroup a => a -> a -> a
<> SymbolicExprBinOp -> Builder
symbolicExprBinOp SymbolicExprBinOp
b forall a. Semigroup a => a -> a -> a
<> Builder
" " forall a. Semigroup a => a -> a -> a
<> WhereClause -> Builder
aExpr WhereClause
c
  PrefixQualOpAExpr QualOp
a WhereClause
b -> QualOp -> Builder
qualOp QualOp
a forall a. Semigroup a => a -> a -> a
<> Builder
" " forall a. Semigroup a => a -> a -> a
<> WhereClause -> Builder
aExpr WhereClause
b
  SuffixQualOpAExpr WhereClause
a QualOp
b -> WhereClause -> Builder
aExpr WhereClause
a forall a. Semigroup a => a -> a -> a
<> Builder
" " forall a. Semigroup a => a -> a -> a
<> QualOp -> Builder
qualOp QualOp
b
  AndAExpr WhereClause
a WhereClause
b -> WhereClause -> Builder
aExpr WhereClause
a forall a. Semigroup a => a -> a -> a
<> Builder
" AND " forall a. Semigroup a => a -> a -> a
<> WhereClause -> Builder
aExpr WhereClause
b
  OrAExpr WhereClause
a WhereClause
b -> WhereClause -> Builder
aExpr WhereClause
a forall a. Semigroup a => a -> a -> a
<> Builder
" OR " forall a. Semigroup a => a -> a -> a
<> WhereClause -> Builder
aExpr WhereClause
b
  NotAExpr WhereClause
a -> Builder
"NOT " forall a. Semigroup a => a -> a -> a
<> WhereClause -> Builder
aExpr WhereClause
a
  VerbalExprBinOpAExpr WhereClause
a Bool
b VerbalExprBinOp
c WhereClause
d Maybe WhereClause
e -> WhereClause -> Builder
aExpr WhereClause
a forall a. Semigroup a => a -> a -> a
<> Builder
" " forall a. Semigroup a => a -> a -> a
<> forall {b}. (Monoid b, IsString b) => Bool -> VerbalExprBinOp -> b
verbalExprBinOp Bool
b VerbalExprBinOp
c forall a. Semigroup a => a -> a -> a
<> Builder
" " forall a. Semigroup a => a -> a -> a
<> WhereClause -> Builder
aExpr WhereClause
d forall a. Semigroup a => a -> a -> a
<> forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap (forall a. Monoid a => a -> a -> a
mappend Builder
" ESCAPE " forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. WhereClause -> Builder
aExpr) Maybe WhereClause
e
  ReversableOpAExpr WhereClause
a Bool
b AExprReversableOp
c -> WhereClause -> Builder
aExpr WhereClause
a forall a. Semigroup a => a -> a -> a
<> Builder
" " forall a. Semigroup a => a -> a -> a
<> Bool -> AExprReversableOp -> Builder
aExprReversableOp Bool
b AExprReversableOp
c
  IsnullAExpr WhereClause
a -> WhereClause -> Builder
aExpr WhereClause
a forall a. Semigroup a => a -> a -> a
<> Builder
" ISNULL"
  NotnullAExpr WhereClause
a -> WhereClause -> Builder
aExpr WhereClause
a forall a. Semigroup a => a -> a -> a
<> Builder
" NOTNULL"
  OverlapsAExpr Row
a Row
b -> Row -> Builder
row Row
a forall a. Semigroup a => a -> a -> a
<> Builder
" OVERLAPS " forall a. Semigroup a => a -> a -> a
<> Row -> Builder
row Row
b
  SubqueryAExpr WhereClause
a SubqueryOp
b SubType
c Either SelectWithParens WhereClause
d -> WhereClause -> Builder
aExpr WhereClause
a forall a. Semigroup a => a -> a -> a
<> Builder
" " forall a. Semigroup a => a -> a -> a
<> SubqueryOp -> Builder
subqueryOp SubqueryOp
b forall a. Semigroup a => a -> a -> a
<> Builder
" " forall a. Semigroup a => a -> a -> a
<> forall {a}. IsString a => SubType -> a
subType SubType
c forall a. Semigroup a => a -> a -> a
<> Builder
" " forall a. Semigroup a => a -> a -> a
<> forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either SelectWithParens -> Builder
selectWithParens (Builder -> Builder
inParens forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. WhereClause -> Builder
aExpr) Either SelectWithParens WhereClause
d
  UniqueAExpr SelectWithParens
a -> Builder
"UNIQUE " forall a. Semigroup a => a -> a -> a
<> SelectWithParens -> Builder
selectWithParens SelectWithParens
a
  WhereClause
DefaultAExpr -> Builder
"DEFAULT"

bExpr :: BExpr -> Builder
bExpr = \case
  CExprBExpr CExpr
a -> CExpr -> Builder
cExpr CExpr
a
  TypecastBExpr BExpr
a Typename
b -> BExpr -> Builder
bExpr BExpr
a forall a. Semigroup a => a -> a -> a
<> Builder
" :: " forall a. Semigroup a => a -> a -> a
<> Typename -> Builder
typename Typename
b
  PlusBExpr BExpr
a -> Builder
"+ " forall a. Semigroup a => a -> a -> a
<> BExpr -> Builder
bExpr BExpr
a
  MinusBExpr BExpr
a -> Builder
"- " forall a. Semigroup a => a -> a -> a
<> BExpr -> Builder
bExpr BExpr
a
  SymbolicBinOpBExpr BExpr
a SymbolicExprBinOp
b BExpr
c -> BExpr -> Builder
bExpr BExpr
a forall a. Semigroup a => a -> a -> a
<> Builder
" " forall a. Semigroup a => a -> a -> a
<> SymbolicExprBinOp -> Builder
symbolicExprBinOp SymbolicExprBinOp
b forall a. Semigroup a => a -> a -> a
<> Builder
" " forall a. Semigroup a => a -> a -> a
<> BExpr -> Builder
bExpr BExpr
c
  QualOpBExpr QualOp
a BExpr
b -> QualOp -> Builder
qualOp QualOp
a forall a. Semigroup a => a -> a -> a
<> Builder
" " forall a. Semigroup a => a -> a -> a
<> BExpr -> Builder
bExpr BExpr
b
  IsOpBExpr BExpr
a Bool
b BExprIsOp
c -> BExpr -> Builder
bExpr BExpr
a forall a. Semigroup a => a -> a -> a
<> Builder
" " forall a. Semigroup a => a -> a -> a
<> Bool -> BExprIsOp -> Builder
bExprIsOp Bool
b BExprIsOp
c

cExpr :: CExpr -> Builder
cExpr = \case
  ColumnrefCExpr Columnref
a -> Columnref -> Builder
columnref Columnref
a
  AexprConstCExpr AexprConst
a -> AexprConst -> Builder
aexprConst AexprConst
a
  ParamCExpr Int
a Maybe Indirection
b -> Builder
"$" forall a. Semigroup a => a -> a -> a
<> Int -> Builder
intDec Int
a forall a. Semigroup a => a -> a -> a
<> forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap Indirection -> Builder
indirection Maybe Indirection
b
  InParensCExpr WhereClause
a Maybe Indirection
b -> Builder -> Builder
inParens (WhereClause -> Builder
aExpr WhereClause
a) forall a. Semigroup a => a -> a -> a
<> forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap Indirection -> Builder
indirection Maybe Indirection
b
  CaseCExpr CaseExpr
a -> CaseExpr -> Builder
caseExpr CaseExpr
a
  FuncCExpr FuncExpr
a -> FuncExpr -> Builder
funcExpr FuncExpr
a
  SelectWithParensCExpr SelectWithParens
a Maybe Indirection
b -> SelectWithParens -> Builder
selectWithParens SelectWithParens
a forall a. Semigroup a => a -> a -> a
<> forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap Indirection -> Builder
indirection Maybe Indirection
b
  ExistsCExpr SelectWithParens
a -> Builder
"EXISTS " forall a. Semigroup a => a -> a -> a
<> SelectWithParens -> Builder
selectWithParens SelectWithParens
a
  ArrayCExpr Either SelectWithParens ArrayExpr
a -> Builder
"ARRAY " forall a. Semigroup a => a -> a -> a
<> forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either SelectWithParens -> Builder
selectWithParens ArrayExpr -> Builder
arrayExpr Either SelectWithParens ArrayExpr
a
  ExplicitRowCExpr Maybe ExprList
a -> Maybe ExprList -> Builder
explicitRow Maybe ExprList
a
  ImplicitRowCExpr ImplicitRow
a -> ImplicitRow -> Builder
implicitRow ImplicitRow
a
  GroupingCExpr ExprList
a -> Builder
"GROUPING " forall a. Semigroup a => a -> a -> a
<> Builder -> Builder
inParens (ExprList -> Builder
exprList ExprList
a)

-- * Ops

aExprReversableOp :: Bool -> AExprReversableOp -> Builder
aExprReversableOp Bool
a = \case
  AExprReversableOp
NullAExprReversableOp -> forall a. a -> a -> Bool -> a
bool Builder
"IS " Builder
"IS NOT " Bool
a forall a. Semigroup a => a -> a -> a
<> Builder
"NULL"
  AExprReversableOp
TrueAExprReversableOp -> forall a. a -> a -> Bool -> a
bool Builder
"IS " Builder
"IS NOT " Bool
a forall a. Semigroup a => a -> a -> a
<> Builder
"TRUE"
  AExprReversableOp
FalseAExprReversableOp -> forall a. a -> a -> Bool -> a
bool Builder
"IS " Builder
"IS NOT " Bool
a forall a. Semigroup a => a -> a -> a
<> Builder
"FALSE"
  AExprReversableOp
UnknownAExprReversableOp -> forall a. a -> a -> Bool -> a
bool Builder
"IS " Builder
"IS NOT " Bool
a forall a. Semigroup a => a -> a -> a
<> Builder
"UNKNOWN"
  DistinctFromAExprReversableOp WhereClause
b -> forall a. a -> a -> Bool -> a
bool Builder
"IS " Builder
"IS NOT " Bool
a forall a. Semigroup a => a -> a -> a
<> Builder
"DISTINCT FROM " forall a. Semigroup a => a -> a -> a
<> WhereClause -> Builder
aExpr WhereClause
b
  OfAExprReversableOp TypeList
b -> forall a. a -> a -> Bool -> a
bool Builder
"IS " Builder
"IS NOT " Bool
a forall a. Semigroup a => a -> a -> a
<> Builder
"OF " forall a. Semigroup a => a -> a -> a
<> Builder -> Builder
inParens (TypeList -> Builder
typeList TypeList
b)
  BetweenAExprReversableOp Bool
b BExpr
c WhereClause
d -> forall a. a -> a -> Bool -> a
bool Builder
"" Builder
"NOT " Bool
a forall a. Semigroup a => a -> a -> a
<> forall a. a -> a -> Bool -> a
bool Builder
"BETWEEN " Builder
"BETWEEN ASYMMETRIC " Bool
b forall a. Semigroup a => a -> a -> a
<> BExpr -> Builder
bExpr BExpr
c forall a. Semigroup a => a -> a -> a
<> Builder
" AND " forall a. Semigroup a => a -> a -> a
<> WhereClause -> Builder
aExpr WhereClause
d
  BetweenSymmetricAExprReversableOp BExpr
b WhereClause
c -> forall a. a -> a -> Bool -> a
bool Builder
"" Builder
"NOT " Bool
a forall a. Semigroup a => a -> a -> a
<> Builder
"BETWEEN SYMMETRIC " forall a. Semigroup a => a -> a -> a
<> BExpr -> Builder
bExpr BExpr
b forall a. Semigroup a => a -> a -> a
<> Builder
" AND " forall a. Semigroup a => a -> a -> a
<> WhereClause -> Builder
aExpr WhereClause
c
  InAExprReversableOp InExpr
b -> forall a. a -> a -> Bool -> a
bool Builder
"" Builder
"NOT " Bool
a forall a. Semigroup a => a -> a -> a
<> Builder
"IN " forall a. Semigroup a => a -> a -> a
<> InExpr -> Builder
inExpr InExpr
b
  AExprReversableOp
DocumentAExprReversableOp -> forall a. a -> a -> Bool -> a
bool Builder
"IS " Builder
"IS NOT " Bool
a forall a. Semigroup a => a -> a -> a
<> Builder
"DOCUMENT"

verbalExprBinOp :: Bool -> VerbalExprBinOp -> b
verbalExprBinOp Bool
a =
  forall a. Monoid a => a -> a -> a
mappend (forall a. a -> a -> Bool -> a
bool b
"" b
"NOT " Bool
a) forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. \case
    VerbalExprBinOp
LikeVerbalExprBinOp -> b
"LIKE"
    VerbalExprBinOp
IlikeVerbalExprBinOp -> b
"ILIKE"
    VerbalExprBinOp
SimilarToVerbalExprBinOp -> b
"SIMILAR TO"

subqueryOp :: SubqueryOp -> Builder
subqueryOp = \case
  AllSubqueryOp AllOp
a -> AllOp -> Builder
allOp AllOp
a
  AnySubqueryOp AnyOperator
a -> Builder
"OPERATOR " forall a. Semigroup a => a -> a -> a
<> Builder -> Builder
inParens (AnyOperator -> Builder
anyOperator AnyOperator
a)
  LikeSubqueryOp Bool
a -> forall a. a -> a -> Bool -> a
bool Builder
"" Builder
"NOT " Bool
a forall a. Semigroup a => a -> a -> a
<> Builder
"LIKE"
  IlikeSubqueryOp Bool
a -> forall a. a -> a -> Bool -> a
bool Builder
"" Builder
"NOT " Bool
a forall a. Semigroup a => a -> a -> a
<> Builder
"ILIKE"

bExprIsOp :: Bool -> BExprIsOp -> Builder
bExprIsOp Bool
a =
  forall a. Monoid a => a -> a -> a
mappend (forall a. a -> a -> Bool -> a
bool Builder
"IS " Builder
"IS NOT " Bool
a) forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. \case
    DistinctFromBExprIsOp BExpr
b -> Builder
"DISTINCT FROM " forall a. Semigroup a => a -> a -> a
<> BExpr -> Builder
bExpr BExpr
b
    OfBExprIsOp TypeList
a -> Builder
"OF " forall a. Semigroup a => a -> a -> a
<> Builder -> Builder
inParens (TypeList -> Builder
typeList TypeList
a)
    BExprIsOp
DocumentBExprIsOp -> Builder
"DOCUMENT"

symbolicExprBinOp :: SymbolicExprBinOp -> Builder
symbolicExprBinOp = \case
  MathSymbolicExprBinOp MathOp
a -> MathOp -> Builder
mathOp MathOp
a
  QualSymbolicExprBinOp QualOp
a -> QualOp -> Builder
qualOp QualOp
a

qualOp :: QualOp -> Builder
qualOp = \case
  OpQualOp Text
a -> Text -> Builder
op Text
a
  OperatorQualOp AnyOperator
a -> Builder
"OPERATOR (" forall a. Semigroup a => a -> a -> a
<> AnyOperator -> Builder
anyOperator AnyOperator
a forall a. Semigroup a => a -> a -> a
<> Builder
")"

qualAllOp :: QualAllOp -> Builder
qualAllOp = \case
  AllQualAllOp AllOp
a -> AllOp -> Builder
allOp AllOp
a
  AnyQualAllOp AnyOperator
a -> Builder
"OPERATOR (" forall a. Semigroup a => a -> a -> a
<> AnyOperator -> Builder
anyOperator AnyOperator
a forall a. Semigroup a => a -> a -> a
<> Builder
")"

op :: Text -> Builder
op = Text -> Builder
text

anyOperator :: AnyOperator -> Builder
anyOperator = \case
  AllOpAnyOperator AllOp
a -> AllOp -> Builder
allOp AllOp
a
  QualifiedAnyOperator ColId
a AnyOperator
b -> ColId -> Builder
colId ColId
a forall a. Semigroup a => a -> a -> a
<> Builder
"." forall a. Semigroup a => a -> a -> a
<> AnyOperator -> Builder
anyOperator AnyOperator
b

allOp :: AllOp -> Builder
allOp = \case
  OpAllOp Text
a -> Text -> Builder
op Text
a
  MathAllOp MathOp
a -> MathOp -> Builder
mathOp MathOp
a

mathOp :: MathOp -> Builder
mathOp = \case
  MathOp
PlusMathOp -> Char -> Builder
char7 Char
'+'
  MathOp
MinusMathOp -> Char -> Builder
char7 Char
'-'
  MathOp
AsteriskMathOp -> Char -> Builder
char7 Char
'*'
  MathOp
SlashMathOp -> Char -> Builder
char7 Char
'/'
  MathOp
PercentMathOp -> Char -> Builder
char7 Char
'%'
  MathOp
ArrowUpMathOp -> Char -> Builder
char7 Char
'^'
  MathOp
ArrowLeftMathOp -> Char -> Builder
char7 Char
'<'
  MathOp
ArrowRightMathOp -> Char -> Builder
char7 Char
'>'
  MathOp
EqualsMathOp -> Char -> Builder
char7 Char
'='
  MathOp
LessEqualsMathOp -> Builder
"<="
  MathOp
GreaterEqualsMathOp -> Builder
">="
  MathOp
ArrowLeftArrowRightMathOp -> Builder
"<>"
  MathOp
ExclamationEqualsMathOp -> Builder
"!="

inExpr :: InExpr -> Builder
inExpr = \case
  SelectInExpr SelectWithParens
a -> SelectWithParens -> Builder
selectWithParens SelectWithParens
a
  ExprListInExpr ExprList
a -> Builder -> Builder
inParens (ExprList -> Builder
exprList ExprList
a)

caseExpr :: CaseExpr -> Builder
caseExpr (CaseExpr Maybe WhereClause
a WhenClauseList
b Maybe WhereClause
c) =
  [Maybe Builder] -> Builder
optLexemes
    [ forall a. a -> Maybe a
Just Builder
"CASE",
      forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap WhereClause -> Builder
aExpr Maybe WhereClause
a,
      forall a. a -> Maybe a
Just (forall a. (a -> Builder) -> NonEmpty a -> Builder
spaceNonEmpty WhenClause -> Builder
whenClause WhenClauseList
b),
      forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap WhereClause -> Builder
caseDefault Maybe WhereClause
c,
      forall a. a -> Maybe a
Just Builder
"END"
    ]

whenClause :: WhenClause -> Builder
whenClause (WhenClause WhereClause
a WhereClause
b) = Builder
"WHEN " forall a. Semigroup a => a -> a -> a
<> WhereClause -> Builder
aExpr WhereClause
a forall a. Semigroup a => a -> a -> a
<> Builder
" THEN " forall a. Semigroup a => a -> a -> a
<> WhereClause -> Builder
aExpr WhereClause
b

caseDefault :: WhereClause -> Builder
caseDefault WhereClause
a = Builder
"ELSE " forall a. Semigroup a => a -> a -> a
<> WhereClause -> Builder
aExpr WhereClause
a

arrayExpr :: ArrayExpr -> Builder
arrayExpr =
  Builder -> Builder
inBrackets forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. \case
    ExprListArrayExpr ExprList
a -> ExprList -> Builder
exprList ExprList
a
    ArrayExprListArrayExpr ArrayExprList
a -> ArrayExprList -> Builder
arrayExprList ArrayExprList
a
    ArrayExpr
EmptyArrayExpr -> forall a. Monoid a => a
mempty

arrayExprList :: ArrayExprList -> Builder
arrayExprList = forall a. (a -> Builder) -> NonEmpty a -> Builder
commaNonEmpty ArrayExpr -> Builder
arrayExpr

row :: Row -> Builder
row = \case
  ExplicitRowRow Maybe ExprList
a -> Maybe ExprList -> Builder
explicitRow Maybe ExprList
a
  ImplicitRowRow ImplicitRow
a -> ImplicitRow -> Builder
implicitRow ImplicitRow
a

explicitRow :: Maybe ExprList -> Builder
explicitRow Maybe ExprList
a = Builder
"ROW " forall a. Semigroup a => a -> a -> a
<> Builder -> Builder
inParens (forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap ExprList -> Builder
exprList Maybe ExprList
a)

implicitRow :: ImplicitRow -> Builder
implicitRow (ImplicitRow ExprList
a WhereClause
b) = Builder -> Builder
inParens (ExprList -> Builder
exprList ExprList
a forall a. Semigroup a => a -> a -> a
<> Builder
", " forall a. Semigroup a => a -> a -> a
<> WhereClause -> Builder
aExpr WhereClause
b)

funcApplication :: FuncApplication -> Builder
funcApplication (FuncApplication FuncName
a Maybe FuncApplicationParams
b) =
  FuncName -> Builder
funcName FuncName
a forall a. Semigroup a => a -> a -> a
<> Builder
"(" forall a. Semigroup a => a -> a -> a
<> forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap FuncApplicationParams -> Builder
funcApplicationParams Maybe FuncApplicationParams
b forall a. Semigroup a => a -> a -> a
<> Builder
")"

funcApplicationParams :: FuncApplicationParams -> Builder
funcApplicationParams = \case
  NormalFuncApplicationParams Maybe Bool
a NonEmpty FuncArgExpr
b Maybe SortClause
c ->
    [Maybe Builder] -> Builder
optLexemes
      [ forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall {a}. IsString a => Bool -> a
allOrDistinct Maybe Bool
a,
        forall a. a -> Maybe a
Just (forall a. (a -> Builder) -> NonEmpty a -> Builder
commaNonEmpty FuncArgExpr -> Builder
funcArgExpr NonEmpty FuncArgExpr
b),
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap SortClause -> Builder
sortClause Maybe SortClause
c
      ]
  VariadicFuncApplicationParams Maybe (NonEmpty FuncArgExpr)
a FuncArgExpr
b Maybe SortClause
c ->
    [Maybe Builder] -> Builder
optLexemes
      [ forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall a b c. (a -> b -> c) -> b -> a -> c
flip forall a. Monoid a => a -> a -> a
mappend Builder
"," forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall a. (a -> Builder) -> NonEmpty a -> Builder
commaNonEmpty FuncArgExpr -> Builder
funcArgExpr) Maybe (NonEmpty FuncArgExpr)
a,
        forall a. a -> Maybe a
Just Builder
"VARIADIC",
        forall a. a -> Maybe a
Just (FuncArgExpr -> Builder
funcArgExpr FuncArgExpr
b),
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap SortClause -> Builder
sortClause Maybe SortClause
c
      ]
  FuncApplicationParams
StarFuncApplicationParams -> Builder
"*"

allOrDistinct :: Bool -> a
allOrDistinct = \case
  Bool
False -> a
"ALL"
  Bool
True -> a
"DISTINCT"

funcArgExpr :: FuncArgExpr -> Builder
funcArgExpr = \case
  ExprFuncArgExpr WhereClause
a -> WhereClause -> Builder
aExpr WhereClause
a
  ColonEqualsFuncArgExpr ColId
a WhereClause
b -> ColId -> Builder
ident ColId
a forall a. Semigroup a => a -> a -> a
<> Builder
" := " forall a. Semigroup a => a -> a -> a
<> WhereClause -> Builder
aExpr WhereClause
b
  EqualsGreaterFuncArgExpr ColId
a WhereClause
b -> ColId -> Builder
ident ColId
a forall a. Semigroup a => a -> a -> a
<> Builder
" => " forall a. Semigroup a => a -> a -> a
<> WhereClause -> Builder
aExpr WhereClause
b

-- ** Func Expr

funcExpr :: FuncExpr -> Builder
funcExpr = \case
  ApplicationFuncExpr FuncApplication
a Maybe SortClause
b Maybe WhereClause
c Maybe OverClause
d ->
    [Maybe Builder] -> Builder
optLexemes
      [ forall a. a -> Maybe a
Just (FuncApplication -> Builder
funcApplication FuncApplication
a),
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap SortClause -> Builder
withinGroupClause Maybe SortClause
b,
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap WhereClause -> Builder
filterClause Maybe WhereClause
c,
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap OverClause -> Builder
overClause Maybe OverClause
d
      ]
  SubexprFuncExpr FuncExprCommonSubexpr
a -> FuncExprCommonSubexpr -> Builder
funcExprCommonSubexpr FuncExprCommonSubexpr
a

funcExprWindownless :: FuncExprWindowless -> Builder
funcExprWindownless = \case
  ApplicationFuncExprWindowless FuncApplication
a -> FuncApplication -> Builder
funcApplication FuncApplication
a
  CommonSubexprFuncExprWindowless FuncExprCommonSubexpr
a -> FuncExprCommonSubexpr -> Builder
funcExprCommonSubexpr FuncExprCommonSubexpr
a

withinGroupClause :: SortClause -> Builder
withinGroupClause SortClause
a = Builder
"WITHIN GROUP (" forall a. Semigroup a => a -> a -> a
<> SortClause -> Builder
sortClause SortClause
a forall a. Semigroup a => a -> a -> a
<> Builder
")"

filterClause :: WhereClause -> Builder
filterClause WhereClause
a = Builder
"FILTER (WHERE " forall a. Semigroup a => a -> a -> a
<> WhereClause -> Builder
aExpr WhereClause
a forall a. Semigroup a => a -> a -> a
<> Builder
")"

overClause :: OverClause -> Builder
overClause = \case
  WindowOverClause WindowSpecification
a -> Builder
"OVER " forall a. Semigroup a => a -> a -> a
<> WindowSpecification -> Builder
windowSpecification WindowSpecification
a
  ColIdOverClause ColId
a -> Builder
"OVER " forall a. Semigroup a => a -> a -> a
<> ColId -> Builder
colId ColId
a

funcExprCommonSubexpr :: FuncExprCommonSubexpr -> Builder
funcExprCommonSubexpr = \case
  CollationForFuncExprCommonSubexpr WhereClause
a -> Builder
"COLLATION FOR (" forall a. Semigroup a => a -> a -> a
<> WhereClause -> Builder
aExpr WhereClause
a forall a. Semigroup a => a -> a -> a
<> Builder
")"
  FuncExprCommonSubexpr
CurrentDateFuncExprCommonSubexpr -> Builder
"CURRENT_DATE"
  CurrentTimeFuncExprCommonSubexpr Maybe Int64
a -> Builder
"CURRENT_TIME" forall a. Semigroup a => a -> a -> a
<> forall a. (a -> Builder) -> Maybe a -> Builder
suffixMaybe (Builder -> Builder
inParens forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. Int64 -> Builder
iconst) Maybe Int64
a
  CurrentTimestampFuncExprCommonSubexpr Maybe Int64
a -> Builder
"CURRENT_TIMESTAMP" forall a. Semigroup a => a -> a -> a
<> forall a. (a -> Builder) -> Maybe a -> Builder
suffixMaybe (Builder -> Builder
inParens forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. Int64 -> Builder
iconst) Maybe Int64
a
  LocalTimeFuncExprCommonSubexpr Maybe Int64
a -> Builder
"LOCALTIME" forall a. Semigroup a => a -> a -> a
<> forall a. (a -> Builder) -> Maybe a -> Builder
suffixMaybe (Builder -> Builder
inParens forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. Int64 -> Builder
iconst) Maybe Int64
a
  LocalTimestampFuncExprCommonSubexpr Maybe Int64
a -> Builder
"LOCALTIMESTAMP" forall a. Semigroup a => a -> a -> a
<> forall a. (a -> Builder) -> Maybe a -> Builder
suffixMaybe (Builder -> Builder
inParens forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. Int64 -> Builder
iconst) Maybe Int64
a
  FuncExprCommonSubexpr
CurrentRoleFuncExprCommonSubexpr -> Builder
"CURRENT_ROLE"
  FuncExprCommonSubexpr
CurrentUserFuncExprCommonSubexpr -> Builder
"CURRENT_USER"
  FuncExprCommonSubexpr
SessionUserFuncExprCommonSubexpr -> Builder
"SESSION_USER"
  FuncExprCommonSubexpr
UserFuncExprCommonSubexpr -> Builder
"USER"
  FuncExprCommonSubexpr
CurrentCatalogFuncExprCommonSubexpr -> Builder
"CURRENT_CATALOG"
  FuncExprCommonSubexpr
CurrentSchemaFuncExprCommonSubexpr -> Builder
"CURRENT_SCHEMA"
  CastFuncExprCommonSubexpr WhereClause
a Typename
b -> Builder
"CAST (" forall a. Semigroup a => a -> a -> a
<> WhereClause -> Builder
aExpr WhereClause
a forall a. Semigroup a => a -> a -> a
<> Builder
" AS " forall a. Semigroup a => a -> a -> a
<> Typename -> Builder
typename Typename
b forall a. Semigroup a => a -> a -> a
<> Builder
")"
  ExtractFuncExprCommonSubexpr Maybe ExtractList
a -> Builder
"EXTRACT (" forall a. Semigroup a => a -> a -> a
<> forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap ExtractList -> Builder
extractList Maybe ExtractList
a forall a. Semigroup a => a -> a -> a
<> Builder
")"
  OverlayFuncExprCommonSubexpr OverlayList
a -> Builder
"OVERLAY (" forall a. Semigroup a => a -> a -> a
<> OverlayList -> Builder
overlayList OverlayList
a forall a. Semigroup a => a -> a -> a
<> Builder
")"
  PositionFuncExprCommonSubexpr Maybe PositionList
a -> Builder
"POSITION (" forall a. Semigroup a => a -> a -> a
<> forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap PositionList -> Builder
positionList Maybe PositionList
a forall a. Semigroup a => a -> a -> a
<> Builder
")"
  SubstringFuncExprCommonSubexpr Maybe SubstrList
a -> Builder
"SUBSTRING (" forall a. Semigroup a => a -> a -> a
<> forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap SubstrList -> Builder
substrList Maybe SubstrList
a forall a. Semigroup a => a -> a -> a
<> Builder
")"
  TreatFuncExprCommonSubexpr WhereClause
a Typename
b -> Builder
"TREAT (" forall a. Semigroup a => a -> a -> a
<> WhereClause -> Builder
aExpr WhereClause
a forall a. Semigroup a => a -> a -> a
<> Builder
" AS " forall a. Semigroup a => a -> a -> a
<> Typename -> Builder
typename Typename
b forall a. Semigroup a => a -> a -> a
<> Builder
")"
  TrimFuncExprCommonSubexpr Maybe TrimModifier
a TrimList
b -> Builder
"TRIM (" forall a. Semigroup a => a -> a -> a
<> forall a. (a -> Builder) -> Maybe a -> Builder
prefixMaybe forall {a}. IsString a => TrimModifier -> a
trimModifier Maybe TrimModifier
a forall a. Semigroup a => a -> a -> a
<> TrimList -> Builder
trimList TrimList
b forall a. Semigroup a => a -> a -> a
<> Builder
")"
  NullIfFuncExprCommonSubexpr WhereClause
a WhereClause
b -> Builder
"NULLIF (" forall a. Semigroup a => a -> a -> a
<> WhereClause -> Builder
aExpr WhereClause
a forall a. Semigroup a => a -> a -> a
<> Builder
", " forall a. Semigroup a => a -> a -> a
<> WhereClause -> Builder
aExpr WhereClause
b forall a. Semigroup a => a -> a -> a
<> Builder
")"
  CoalesceFuncExprCommonSubexpr ExprList
a -> Builder
"COALESCE (" forall a. Semigroup a => a -> a -> a
<> ExprList -> Builder
exprList ExprList
a forall a. Semigroup a => a -> a -> a
<> Builder
")"
  GreatestFuncExprCommonSubexpr ExprList
a -> Builder
"GREATEST (" forall a. Semigroup a => a -> a -> a
<> ExprList -> Builder
exprList ExprList
a forall a. Semigroup a => a -> a -> a
<> Builder
")"
  LeastFuncExprCommonSubexpr ExprList
a -> Builder
"LEAST (" forall a. Semigroup a => a -> a -> a
<> ExprList -> Builder
exprList ExprList
a forall a. Semigroup a => a -> a -> a
<> Builder
")"

extractList :: ExtractList -> Builder
extractList (ExtractList ExtractArg
a WhereClause
b) = ExtractArg -> Builder
extractArg ExtractArg
a forall a. Semigroup a => a -> a -> a
<> Builder
" FROM " forall a. Semigroup a => a -> a -> a
<> WhereClause -> Builder
aExpr WhereClause
b

extractArg :: ExtractArg -> Builder
extractArg = \case
  IdentExtractArg ColId
a -> ColId -> Builder
ident ColId
a
  ExtractArg
YearExtractArg -> Builder
"YEAR"
  ExtractArg
MonthExtractArg -> Builder
"MONTH"
  ExtractArg
DayExtractArg -> Builder
"DAY"
  ExtractArg
HourExtractArg -> Builder
"HOUR"
  ExtractArg
MinuteExtractArg -> Builder
"MINUTE"
  ExtractArg
SecondExtractArg -> Builder
"SECOND"
  SconstExtractArg Text
a -> Text -> Builder
sconst Text
a

overlayList :: OverlayList -> Builder
overlayList (OverlayList WhereClause
a WhereClause
b WhereClause
c Maybe WhereClause
d) = WhereClause -> Builder
aExpr WhereClause
a forall a. Semigroup a => a -> a -> a
<> Builder
" " forall a. Semigroup a => a -> a -> a
<> WhereClause -> Builder
overlayPlacing WhereClause
b forall a. Semigroup a => a -> a -> a
<> Builder
" " forall a. Semigroup a => a -> a -> a
<> WhereClause -> Builder
substrFrom WhereClause
c forall a. Semigroup a => a -> a -> a
<> forall a. (a -> Builder) -> Maybe a -> Builder
suffixMaybe WhereClause -> Builder
substrFor Maybe WhereClause
d

overlayPlacing :: WhereClause -> Builder
overlayPlacing WhereClause
a = Builder
"PLACING " forall a. Semigroup a => a -> a -> a
<> WhereClause -> Builder
aExpr WhereClause
a

positionList :: PositionList -> Builder
positionList (PositionList BExpr
a BExpr
b) = BExpr -> Builder
bExpr BExpr
a forall a. Semigroup a => a -> a -> a
<> Builder
" IN " forall a. Semigroup a => a -> a -> a
<> BExpr -> Builder
bExpr BExpr
b

substrList :: SubstrList -> Builder
substrList = \case
  ExprSubstrList WhereClause
a SubstrListFromFor
b -> WhereClause -> Builder
aExpr WhereClause
a forall a. Semigroup a => a -> a -> a
<> Builder
" " forall a. Semigroup a => a -> a -> a
<> SubstrListFromFor -> Builder
substrListFromFor SubstrListFromFor
b
  ExprListSubstrList ExprList
a -> ExprList -> Builder
exprList ExprList
a

substrListFromFor :: SubstrListFromFor -> Builder
substrListFromFor = \case
  FromForSubstrListFromFor WhereClause
a WhereClause
b -> WhereClause -> Builder
substrFrom WhereClause
a forall a. Semigroup a => a -> a -> a
<> Builder
" " forall a. Semigroup a => a -> a -> a
<> WhereClause -> Builder
substrFor WhereClause
b
  ForFromSubstrListFromFor WhereClause
a WhereClause
b -> WhereClause -> Builder
substrFor WhereClause
a forall a. Semigroup a => a -> a -> a
<> Builder
" " forall a. Semigroup a => a -> a -> a
<> WhereClause -> Builder
substrFrom WhereClause
b
  FromSubstrListFromFor WhereClause
a -> WhereClause -> Builder
substrFrom WhereClause
a
  ForSubstrListFromFor WhereClause
a -> WhereClause -> Builder
substrFor WhereClause
a

substrFrom :: WhereClause -> Builder
substrFrom WhereClause
a = Builder
"FROM " forall a. Semigroup a => a -> a -> a
<> WhereClause -> Builder
aExpr WhereClause
a

substrFor :: WhereClause -> Builder
substrFor WhereClause
a = Builder
"FOR " forall a. Semigroup a => a -> a -> a
<> WhereClause -> Builder
aExpr WhereClause
a

trimModifier :: TrimModifier -> a
trimModifier = \case
  TrimModifier
BothTrimModifier -> a
"BOTH"
  TrimModifier
LeadingTrimModifier -> a
"LEADING"
  TrimModifier
TrailingTrimModifier -> a
"TRAILING"

trimList :: TrimList -> Builder
trimList = \case
  ExprFromExprListTrimList WhereClause
a ExprList
b -> WhereClause -> Builder
aExpr WhereClause
a forall a. Semigroup a => a -> a -> a
<> Builder
" FROM " forall a. Semigroup a => a -> a -> a
<> ExprList -> Builder
exprList ExprList
b
  FromExprListTrimList ExprList
a -> Builder
"FROM " forall a. Semigroup a => a -> a -> a
<> ExprList -> Builder
exprList ExprList
a
  ExprListTrimList ExprList
a -> ExprList -> Builder
exprList ExprList
a

-- * AexprConsts

aexprConst :: AexprConst -> Builder
aexprConst = \case
  IAexprConst Int64
a -> Int64 -> Builder
iconst Int64
a
  FAexprConst Double
a -> Double -> Builder
fconst Double
a
  SAexprConst Text
a -> Text -> Builder
sconst Text
a
  BAexprConst Text
a -> Builder
"B'" forall a. Semigroup a => a -> a -> a
<> Text -> Builder
text Text
a forall a. Semigroup a => a -> a -> a
<> Builder
"'"
  XAexprConst Text
a -> Builder
"X'" forall a. Semigroup a => a -> a -> a
<> Text -> Builder
text Text
a forall a. Semigroup a => a -> a -> a
<> Builder
"'"
  FuncAexprConst FuncName
a Maybe FuncConstArgs
b Text
c -> FuncName -> Builder
funcName FuncName
a forall a. Semigroup a => a -> a -> a
<> forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap (Builder -> Builder
inParens forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. FuncConstArgs -> Builder
funcAexprConstArgList) Maybe FuncConstArgs
b forall a. Semigroup a => a -> a -> a
<> Builder
" " forall a. Semigroup a => a -> a -> a
<> Text -> Builder
sconst Text
c
  ConstTypenameAexprConst ConstTypename
a Text
b -> ConstTypename -> Builder
constTypename ConstTypename
a forall a. Semigroup a => a -> a -> a
<> Builder
" " forall a. Semigroup a => a -> a -> a
<> Text -> Builder
sconst Text
b
  StringIntervalAexprConst Text
a Maybe Interval
b -> Builder
"INTERVAL " forall a. Semigroup a => a -> a -> a
<> Text -> Builder
sconst Text
a forall a. Semigroup a => a -> a -> a
<> forall a. (a -> Builder) -> Maybe a -> Builder
suffixMaybe Interval -> Builder
interval Maybe Interval
b
  IntIntervalAexprConst Int64
a Text
b -> Builder
"INTERVAL " forall a. Semigroup a => a -> a -> a
<> Builder -> Builder
inParens (Int64 -> Builder
int64Dec Int64
a) forall a. Semigroup a => a -> a -> a
<> Builder
" " forall a. Semigroup a => a -> a -> a
<> Text -> Builder
sconst Text
b
  BoolAexprConst Bool
a -> if Bool
a then Builder
"TRUE" else Builder
"FALSE"
  AexprConst
NullAexprConst -> Builder
"NULL"

iconst :: Int64 -> Builder
iconst = Int64 -> Builder
int64Dec

fconst :: Double -> Builder
fconst = Double -> Builder
doubleDec

sconst :: Text -> Builder
sconst Text
a = Builder
"'" forall a. Semigroup a => a -> a -> a
<> Text -> Builder
text (Text -> Text -> Text -> Text
Text.replace Text
"'" Text
"''" Text
a) forall a. Semigroup a => a -> a -> a
<> Builder
"'"

funcAexprConstArgList :: FuncConstArgs -> Builder
funcAexprConstArgList (FuncConstArgs NonEmpty FuncArgExpr
a Maybe SortClause
b) = forall a. (a -> Builder) -> NonEmpty a -> Builder
commaNonEmpty FuncArgExpr -> Builder
funcArgExpr NonEmpty FuncArgExpr
a forall a. Semigroup a => a -> a -> a
<> forall a. (a -> Builder) -> Maybe a -> Builder
suffixMaybe SortClause -> Builder
sortClause Maybe SortClause
b

constTypename :: ConstTypename -> Builder
constTypename = \case
  NumericConstTypename Numeric
a -> Numeric -> Builder
numeric Numeric
a
  ConstBitConstTypename ConstBit
a -> ConstBit -> Builder
constBit ConstBit
a
  ConstCharacterConstTypename ConstCharacter
a -> ConstCharacter -> Builder
constCharacter ConstCharacter
a
  ConstDatetimeConstTypename ConstDatetime
a -> ConstDatetime -> Builder
constDatetime ConstDatetime
a

numeric :: Numeric -> Builder
numeric = \case
  Numeric
IntNumeric -> Builder
"INT"
  Numeric
IntegerNumeric -> Builder
"INTEGER"
  Numeric
SmallintNumeric -> Builder
"SMALLINT"
  Numeric
BigintNumeric -> Builder
"BIGINT"
  Numeric
RealNumeric -> Builder
"REAL"
  FloatNumeric Maybe Int64
a -> Builder
"FLOAT" forall a. Semigroup a => a -> a -> a
<> forall a. (a -> Builder) -> Maybe a -> Builder
suffixMaybe (Builder -> Builder
inParens forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. Int64 -> Builder
int64Dec) Maybe Int64
a
  Numeric
DoublePrecisionNumeric -> Builder
"DOUBLE PRECISION"
  DecimalNumeric Maybe ExprList
a -> Builder
"DECIMAL" forall a. Semigroup a => a -> a -> a
<> forall a. (a -> Builder) -> Maybe a -> Builder
suffixMaybe (Builder -> Builder
inParens forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall a. (a -> Builder) -> NonEmpty a -> Builder
commaNonEmpty WhereClause -> Builder
aExpr) Maybe ExprList
a
  DecNumeric Maybe ExprList
a -> Builder
"DEC" forall a. Semigroup a => a -> a -> a
<> forall a. (a -> Builder) -> Maybe a -> Builder
suffixMaybe (Builder -> Builder
inParens forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall a. (a -> Builder) -> NonEmpty a -> Builder
commaNonEmpty WhereClause -> Builder
aExpr) Maybe ExprList
a
  NumericNumeric Maybe ExprList
a -> Builder
"NUMERIC" forall a. Semigroup a => a -> a -> a
<> forall a. (a -> Builder) -> Maybe a -> Builder
suffixMaybe (Builder -> Builder
inParens forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall a. (a -> Builder) -> NonEmpty a -> Builder
commaNonEmpty WhereClause -> Builder
aExpr) Maybe ExprList
a
  Numeric
BooleanNumeric -> Builder
"BOOLEAN"

bit :: ConstBit -> Builder
bit (Bit Bool
a Maybe ExprList
b) =
  [Maybe Builder] -> Builder
optLexemes
    [ forall a. a -> Maybe a
Just Builder
"BIT",
      forall a. a -> a -> Bool -> a
bool forall a. Maybe a
Nothing (forall a. a -> Maybe a
Just Builder
"VARYING") Bool
a,
      forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Builder -> Builder
inParens forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall a. (a -> Builder) -> NonEmpty a -> Builder
commaNonEmpty WhereClause -> Builder
aExpr) Maybe ExprList
b
    ]

constBit :: ConstBit -> Builder
constBit = ConstBit -> Builder
bit

constCharacter :: ConstCharacter -> Builder
constCharacter (ConstCharacter Character
a Maybe Int64
b) = forall {a}. (Semigroup a, IsString a) => Character -> a
character Character
a forall a. Semigroup a => a -> a -> a
<> forall a. (a -> Builder) -> Maybe a -> Builder
suffixMaybe (Builder -> Builder
inParens forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. Int64 -> Builder
int64Dec) Maybe Int64
b

character :: Character -> a
character = \case
  CharacterCharacter Bool
a -> a
"CHARACTER" forall a. Semigroup a => a -> a -> a
<> forall a. a -> a -> Bool -> a
bool a
"" a
" VARYING" Bool
a
  CharCharacter Bool
a -> a
"CHAR" forall a. Semigroup a => a -> a -> a
<> forall a. a -> a -> Bool -> a
bool a
"" a
" VARYING" Bool
a
  Character
VarcharCharacter -> a
"VARCHAR"
  NationalCharacterCharacter Bool
a -> a
"NATIONAL CHARACTER" forall a. Semigroup a => a -> a -> a
<> forall a. a -> a -> Bool -> a
bool a
"" a
" VARYING" Bool
a
  NationalCharCharacter Bool
a -> a
"NATIONAL CHAR" forall a. Semigroup a => a -> a -> a
<> forall a. a -> a -> Bool -> a
bool a
"" a
" VARYING" Bool
a
  NcharCharacter Bool
a -> a
"NCHAR" forall a. Semigroup a => a -> a -> a
<> forall a. a -> a -> Bool -> a
bool a
"" a
" VARYING" Bool
a

constDatetime :: ConstDatetime -> Builder
constDatetime = \case
  TimestampConstDatetime Maybe Int64
a Maybe Bool
b ->
    [Maybe Builder] -> Builder
optLexemes
      [ forall a. a -> Maybe a
Just Builder
"TIMESTAMP",
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Builder -> Builder
inParens forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. Int64 -> Builder
int64Dec) Maybe Int64
a,
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall {a}. IsString a => Bool -> a
timezone Maybe Bool
b
      ]
  TimeConstDatetime Maybe Int64
a Maybe Bool
b ->
    [Maybe Builder] -> Builder
optLexemes
      [ forall a. a -> Maybe a
Just Builder
"TIME",
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Builder -> Builder
inParens forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. Int64 -> Builder
int64Dec) Maybe Int64
a,
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall {a}. IsString a => Bool -> a
timezone Maybe Bool
b
      ]

timezone :: Bool -> a
timezone = \case
  Bool
False -> a
"WITH TIME ZONE"
  Bool
True -> a
"WITHOUT TIME ZONE"

interval :: Interval -> Builder
interval = \case
  Interval
YearInterval -> Builder
"YEAR"
  Interval
MonthInterval -> Builder
"MONTH"
  Interval
DayInterval -> Builder
"DAY"
  Interval
HourInterval -> Builder
"HOUR"
  Interval
MinuteInterval -> Builder
"MINUTE"
  SecondInterval Maybe Int64
a -> Maybe Int64 -> Builder
intervalSecond Maybe Int64
a
  Interval
YearToMonthInterval -> Builder
"YEAR TO MONTH"
  Interval
DayToHourInterval -> Builder
"DAY TO HOUR"
  Interval
DayToMinuteInterval -> Builder
"DAY TO MINUTE"
  DayToSecondInterval Maybe Int64
a -> Builder
"DAY TO " forall a. Semigroup a => a -> a -> a
<> Maybe Int64 -> Builder
intervalSecond Maybe Int64
a
  Interval
HourToMinuteInterval -> Builder
"HOUR TO MINUTE"
  HourToSecondInterval Maybe Int64
a -> Builder
"HOUR TO " forall a. Semigroup a => a -> a -> a
<> Maybe Int64 -> Builder
intervalSecond Maybe Int64
a
  MinuteToSecondInterval Maybe Int64
a -> Builder
"MINUTE TO " forall a. Semigroup a => a -> a -> a
<> Maybe Int64 -> Builder
intervalSecond Maybe Int64
a

intervalSecond :: Maybe Int64 -> Builder
intervalSecond = \case
  Maybe Int64
Nothing -> Builder
"SECOND"
  Just Int64
a -> Builder
"SECOND " forall a. Semigroup a => a -> a -> a
<> Builder -> Builder
inParens (Int64 -> Builder
int64Dec Int64
a)

-- * Names and refs

columnref :: Columnref -> Builder
columnref (Columnref ColId
a Maybe Indirection
b) = ColId -> Builder
colId ColId
a forall a. Semigroup a => a -> a -> a
<> forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap Indirection -> Builder
indirection Maybe Indirection
b

ident :: ColId -> Builder
ident = \case
  QuotedIdent Text
a -> Char -> Builder
char7 Char
'"' forall a. Semigroup a => a -> a -> a
<> Text -> Builder
text (Text -> Text -> Text -> Text
Text.replace Text
"\"" Text
"\"\"" Text
a) forall a. Semigroup a => a -> a -> a
<> Char -> Builder
char7 Char
'"'
  UnquotedIdent Text
a -> Text -> Builder
text Text
a

qualifiedName :: QualifiedName -> Builder
qualifiedName = \case
  SimpleQualifiedName ColId
a -> ColId -> Builder
ident ColId
a
  IndirectedQualifiedName ColId
a Indirection
b -> ColId -> Builder
ident ColId
a forall a. Semigroup a => a -> a -> a
<> Indirection -> Builder
indirection Indirection
b

indirection :: Indirection -> Builder
indirection = forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap IndirectionEl -> Builder
indirectionEl

indirectionEl :: IndirectionEl -> Builder
indirectionEl = \case
  AttrNameIndirectionEl ColId
a -> Builder
"." forall a. Semigroup a => a -> a -> a
<> ColId -> Builder
ident ColId
a
  IndirectionEl
AllIndirectionEl -> Builder
".*"
  ExprIndirectionEl WhereClause
a -> Builder
"[" forall a. Semigroup a => a -> a -> a
<> WhereClause -> Builder
aExpr WhereClause
a forall a. Semigroup a => a -> a -> a
<> Builder
"]"
  SliceIndirectionEl Maybe WhereClause
a Maybe WhereClause
b -> Builder
"[" forall a. Semigroup a => a -> a -> a
<> forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap WhereClause -> Builder
aExpr Maybe WhereClause
a forall a. Semigroup a => a -> a -> a
<> Builder
":" forall a. Semigroup a => a -> a -> a
<> forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap WhereClause -> Builder
aExpr Maybe WhereClause
b forall a. Semigroup a => a -> a -> a
<> Builder
"]"

colId :: ColId -> Builder
colId = ColId -> Builder
ident

name :: ColId -> Builder
name = ColId -> Builder
colId

cursorName :: ColId -> Builder
cursorName = ColId -> Builder
name

colLabel :: ColId -> Builder
colLabel = ColId -> Builder
ident

attrName :: ColId -> Builder
attrName = ColId -> Builder
colLabel

typeFunctionName :: ColId -> Builder
typeFunctionName = ColId -> Builder
ident

funcName :: FuncName -> Builder
funcName = \case
  TypeFuncName ColId
a -> ColId -> Builder
typeFunctionName ColId
a
  IndirectedFuncName ColId
a Indirection
b -> ColId -> Builder
colId ColId
a forall a. Semigroup a => a -> a -> a
<> Indirection -> Builder
indirection Indirection
b

anyName :: CollateClause -> Builder
anyName (AnyName ColId
a Maybe (NonEmpty ColId)
b) = ColId -> Builder
colId ColId
a forall a. Semigroup a => a -> a -> a
<> forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap forall {t :: * -> *}. Foldable t => t ColId -> Builder
attrs Maybe (NonEmpty ColId)
b

-- * Types

typename :: Typename -> Builder
typename (Typename Bool
a SimpleTypename
b Bool
c Maybe (TypenameArrayDimensions, Bool)
d) =
  forall a. a -> a -> Bool -> a
bool Builder
"" Builder
"SETOF " Bool
a forall a. Semigroup a => a -> a -> a
<> SimpleTypename -> Builder
simpleTypename SimpleTypename
b forall a. Semigroup a => a -> a -> a
<> forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap forall {b}. (TypenameArrayDimensions, b) -> Builder
typenameArrayDimensionsWithQuestionMark Maybe (TypenameArrayDimensions, Bool)
d

typenameArrayDimensionsWithQuestionMark :: (TypenameArrayDimensions, b) -> Builder
typenameArrayDimensionsWithQuestionMark (TypenameArrayDimensions
a, b
b) =
  TypenameArrayDimensions -> Builder
typenameArrayDimensions TypenameArrayDimensions
a

typenameArrayDimensions :: TypenameArrayDimensions -> Builder
typenameArrayDimensions = \case
  BoundsTypenameArrayDimensions ArrayBounds
a -> forall {t :: * -> *}. Foldable t => NonEmpty (t Int64) -> Builder
arrayBounds ArrayBounds
a
  ExplicitTypenameArrayDimensions Maybe Int64
a -> Builder
" ARRAY" forall a. Semigroup a => a -> a -> a
<> forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap (Builder -> Builder
inBrackets forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. Int64 -> Builder
iconst) Maybe Int64
a

arrayBounds :: NonEmpty (t Int64) -> Builder
arrayBounds = forall a. (a -> Builder) -> NonEmpty a -> Builder
spaceNonEmpty (Builder -> Builder
inBrackets forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap Int64 -> Builder
iconst)

simpleTypename :: SimpleTypename -> Builder
simpleTypename = \case
  GenericTypeSimpleTypename GenericType
a -> GenericType -> Builder
genericType GenericType
a
  NumericSimpleTypename Numeric
a -> Numeric -> Builder
numeric Numeric
a
  BitSimpleTypename ConstBit
a -> ConstBit -> Builder
bit ConstBit
a
  CharacterSimpleTypename Character
a -> forall {a}. (Semigroup a, IsString a) => Character -> a
character Character
a
  ConstDatetimeSimpleTypename ConstDatetime
a -> ConstDatetime -> Builder
constDatetime ConstDatetime
a
  ConstIntervalSimpleTypename Either (Maybe Interval) Int64
a -> Builder
"INTERVAL" forall a. Semigroup a => a -> a -> a
<> forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (forall a. (a -> Builder) -> Maybe a -> Builder
suffixMaybe Interval -> Builder
interval) (forall a. Monoid a => a -> a -> a
mappend Builder
" " forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. Builder -> Builder
inParens forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. Int64 -> Builder
iconst) Either (Maybe Interval) Int64
a

genericType :: GenericType -> Builder
genericType (GenericType ColId
a Maybe (NonEmpty ColId)
b Maybe ExprList
c) = ColId -> Builder
typeFunctionName ColId
a forall a. Semigroup a => a -> a -> a
<> forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap forall {t :: * -> *}. Foldable t => t ColId -> Builder
attrs Maybe (NonEmpty ColId)
b forall a. Semigroup a => a -> a -> a
<> forall a. (a -> Builder) -> Maybe a -> Builder
suffixMaybe ExprList -> Builder
typeModifiers Maybe ExprList
c

attrs :: t ColId -> Builder
attrs = forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap (forall a. Monoid a => a -> a -> a
mappend Builder
"." forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. ColId -> Builder
attrName)

typeModifiers :: ExprList -> Builder
typeModifiers = Builder -> Builder
inParens forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. ExprList -> Builder
exprList

typeList :: TypeList -> Builder
typeList = forall a. (a -> Builder) -> NonEmpty a -> Builder
commaNonEmpty Typename -> Builder
typename

subType :: SubType -> a
subType = \case
  SubType
AnySubType -> a
"ANY"
  SubType
SomeSubType -> a
"SOME"
  SubType
AllSubType -> a
"ALL"

-- * Indexes

indexParams :: IndexParams -> Builder
indexParams = forall a. (a -> Builder) -> NonEmpty a -> Builder
commaNonEmpty IndexElem -> Builder
indexElem

indexElem :: IndexElem -> Builder
indexElem (IndexElem IndexElemDef
a Maybe CollateClause
b Maybe CollateClause
c Maybe AscDesc
d Maybe NullsOrder
e) =
  IndexElemDef -> Builder
indexElemDef IndexElemDef
a
    forall a. Semigroup a => a -> a -> a
<> forall a. (a -> Builder) -> Maybe a -> Builder
suffixMaybe CollateClause -> Builder
collate Maybe CollateClause
b
    forall a. Semigroup a => a -> a -> a
<> forall a. (a -> Builder) -> Maybe a -> Builder
suffixMaybe CollateClause -> Builder
class_ Maybe CollateClause
c
    forall a. Semigroup a => a -> a -> a
<> forall a. (a -> Builder) -> Maybe a -> Builder
suffixMaybe forall {a}. IsString a => AscDesc -> a
ascDesc Maybe AscDesc
d
    forall a. Semigroup a => a -> a -> a
<> forall a. (a -> Builder) -> Maybe a -> Builder
suffixMaybe forall {a}. IsString a => NullsOrder -> a
nullsOrder Maybe NullsOrder
e

indexElemDef :: IndexElemDef -> Builder
indexElemDef = \case
  IdIndexElemDef ColId
a -> ColId -> Builder
colId ColId
a
  FuncIndexElemDef FuncExprWindowless
a -> FuncExprWindowless -> Builder
funcExprWindownless FuncExprWindowless
a
  ExprIndexElemDef WhereClause
a -> Builder -> Builder
inParens (WhereClause -> Builder
aExpr WhereClause
a)

collate :: CollateClause -> Builder
collate = forall a. Monoid a => a -> a -> a
mappend Builder
"COLLATE " forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. CollateClause -> Builder
anyName

class_ :: CollateClause -> Builder
class_ = CollateClause -> Builder
anyName

ascDesc :: AscDesc -> a
ascDesc = \case
  AscDesc
AscAscDesc -> a
"ASC"
  AscDesc
DescAscDesc -> a
"DESC"

nullsOrder :: NullsOrder -> a
nullsOrder = \case
  NullsOrder
FirstNullsOrder -> a
"NULLS FIRST"
  NullsOrder
LastNullsOrder -> a
"NULLS LAST"