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

-- |
--
-- Our parsing strategy is to port the original Postgres parser as closely as possible.
--
-- We're using the @gram.y@ Postgres source file, which is the closest thing we have
-- to a Postgres syntax spec. Here's a link to it:
-- https://github.com/postgres/postgres/blob/master/src/backend/parser/gram.y.
--
-- Here's the essence of how the original parser is implemented, citing from
-- [PostgreSQL Wiki](https://wiki.postgresql.org/wiki/Developer_FAQ):
--
--     scan.l defines the lexer, i.e. the algorithm that splits a string
--     (containing an SQL statement) into a stream of tokens.
--     A token is usually a single word
--     (i.e., doesn't contain spaces but is delimited by spaces),
--     but can also be a whole single or double-quoted string for example.
--     The lexer is basically defined in terms of regular expressions
--     which describe the different token types.
--
--     gram.y defines the grammar (the syntactical structure) of SQL statements,
--     using the tokens generated by the lexer as basic building blocks.
--     The grammar is defined in BNF notation.
--     BNF resembles regular expressions but works on the level of tokens, not characters.
--     Also, patterns (called rules or productions in BNF) are named, and may be recursive,
--     i.e. use themselves as sub-patterns.
module PostgresqlSyntax.Parsing where

import Control.Applicative.Combinators hiding (some)
import Control.Applicative.Combinators.NonEmpty
import qualified Data.HashSet as HashSet
import qualified Data.Text as Text
import HeadedMegaparsec hiding (string)
import PostgresqlSyntax.Ast
import PostgresqlSyntax.Extras.HeadedMegaparsec hiding (run)
import qualified PostgresqlSyntax.Extras.HeadedMegaparsec as Extras
import qualified PostgresqlSyntax.Extras.NonEmpty as NonEmpty
import qualified PostgresqlSyntax.KeywordSet as KeywordSet
import qualified PostgresqlSyntax.Predicate as Predicate
import PostgresqlSyntax.Prelude hiding (bit, expr, filter, fromList, head, many, option, some, sortBy, tail, try)
import qualified PostgresqlSyntax.Validation as Validation
import qualified Text.Builder as TextBuilder
import qualified Text.Megaparsec as Megaparsec
import qualified Text.Megaparsec.Char as MegaparsecChar

-- $setup
-- >>> testParser parser = either putStr print . run parser

type Parser = HeadedParsec Void Text

-- * Executors

run :: Parser a -> Text -> Either String a
run :: forall a. Parser a -> Text -> Either String a
run = forall err strm a.
(Ord err, VisualStream strm, TraversableStream strm,
 ShowErrorComponent err) =>
HeadedParsec err strm a -> strm -> Either String a
Extras.run

-- * Helpers

commaSeparator :: Parser ()
commaSeparator :: Parser ()
commaSeparator = forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
Char -> HeadedParsec err strm Char
char Char
',' forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall strm err. Stream strm => HeadedParsec err strm ()
endHead forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space

dotSeparator :: Parser ()
dotSeparator :: Parser ()
dotSeparator = forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
Char -> HeadedParsec err strm Char
char Char
'.' forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall strm err. Stream strm => HeadedParsec err strm ()
endHead forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space

inBrackets :: Parser a -> Parser a
inBrackets :: forall a. Parser a -> Parser a
inBrackets Parser a
p = forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
Char -> HeadedParsec err strm Char
char Char
'[' forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser a
p forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall strm err. Stream strm => HeadedParsec err strm ()
endHead forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
Char -> HeadedParsec err strm Char
char Char
']'

inBracketsCont :: Parser a -> Parser (Parser a)
inBracketsCont :: forall a. Parser a -> Parser (Parser a)
inBracketsCont Parser a
p = forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
Char -> HeadedParsec err strm Char
char Char
'[' forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall strm err. Stream strm => HeadedParsec err strm ()
endHead forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall (f :: * -> *) a. Applicative f => a -> f a
pure (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser a
p forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall strm err. Stream strm => HeadedParsec err strm ()
endHead forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
Char -> HeadedParsec err strm Char
char Char
']')

inParens :: Parser a -> Parser a
inParens :: forall a. Parser a -> Parser a
inParens Parser a
p = forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
Char -> HeadedParsec err strm Char
char Char
'(' forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser a
p forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall strm err. Stream strm => HeadedParsec err strm ()
endHead forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
Char -> HeadedParsec err strm Char
char Char
')'

inParensCont :: Parser a -> Parser (Parser a)
inParensCont :: forall a. Parser a -> Parser (Parser a)
inParensCont Parser a
p = forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
Char -> HeadedParsec err strm Char
char Char
'(' forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall strm err. Stream strm => HeadedParsec err strm ()
endHead forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall (f :: * -> *) a. Applicative f => a -> f a
pure (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser a
p forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall strm err. Stream strm => HeadedParsec err strm ()
endHead forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
Char -> HeadedParsec err strm Char
char Char
')')

inParensWithLabel :: (label -> content -> result) -> Parser label -> Parser content -> Parser result
inParensWithLabel :: forall label content result.
(label -> content -> result)
-> Parser label -> Parser content -> Parser result
inParensWithLabel label -> content -> result
result Parser label
labelParser Parser content
contentParser = do
  label
label <- forall err strm a.
(Ord err, Stream strm) =>
HeadedParsec err strm a -> HeadedParsec err strm a
wrapToHead Parser label
labelParser
  forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space
  forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
Char -> HeadedParsec err strm Char
char Char
'('
  forall strm err. Stream strm => HeadedParsec err strm ()
endHead
  forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space
  content
content <- Parser content
contentParser
  forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space
  forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
Char -> HeadedParsec err strm Char
char Char
')'
  pure (label -> content -> result
result label
label content
content)

inParensWithClause :: Parser clause -> Parser content -> Parser content
inParensWithClause :: forall clause content.
Parser clause -> Parser content -> Parser content
inParensWithClause = forall label content result.
(label -> content -> result)
-> Parser label -> Parser content -> Parser result
inParensWithLabel (forall a b. a -> b -> a
const forall {k} (cat :: k -> k -> *) (a :: k). Category cat => cat a a
id)

trueIfPresent :: Parser a -> Parser Bool
trueIfPresent :: forall a. Parser a -> Parser Bool
trueIfPresent Parser a
p = forall (m :: * -> *) a. Alternative m => a -> m a -> m a
option Bool
False (Bool
True forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Parser a
p)

-- |
-- >>> testParser (quotedString '\'') "'abc''d'"
-- "abc'd"
quotedString :: Char -> Parser Text
quotedString :: Char -> Parser Text
quotedString Char
q = do
  forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
Char -> HeadedParsec err strm Char
char Char
q
  forall strm err. Stream strm => HeadedParsec err strm ()
endHead
  Text
tail <-
    forall err strm a. Parsec err strm a -> HeadedParsec err strm a
parse
      forall a b. (a -> b) -> a -> b
$ let collectChunks :: Builder -> ParsecT Void Text Identity Text
collectChunks !Builder
bdr = do
              Text
chunk <- forall e s (m :: * -> *).
MonadParsec e s m =>
Maybe String -> (Token s -> Bool) -> m (Tokens s)
Megaparsec.takeWhileP forall a. Maybe a
Nothing (forall a. Eq a => a -> a -> Bool
/= Char
q)
              let bdr' :: Builder
bdr' = Builder
bdr forall a. Semigroup a => a -> a -> a
<> Text -> Builder
TextBuilder.text Text
chunk
              forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
Megaparsec.try (Builder -> ParsecT Void Text Identity Text
consumeEscapedQuote Builder
bdr') forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Builder -> ParsecT Void Text Identity Text
finish Builder
bdr'
            consumeEscapedQuote :: Builder -> ParsecT Void Text Identity Text
consumeEscapedQuote Builder
bdr = do
              forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
MegaparsecChar.char Char
q
              forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
MegaparsecChar.char Char
q
              Builder -> ParsecT Void Text Identity Text
collectChunks (Builder
bdr forall a. Semigroup a => a -> a -> a
<> Char -> Builder
TextBuilder.char Char
q)
            finish :: Builder -> ParsecT Void Text Identity Text
finish Builder
bdr = do
              forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
MegaparsecChar.char Char
q
              return (Builder -> Text
TextBuilder.run Builder
bdr)
         in Builder -> ParsecT Void Text Identity Text
collectChunks forall a. Monoid a => a
mempty
  return Text
tail

atEnd :: Parser a -> Parser a
atEnd :: forall a. Parser a -> Parser a
atEnd Parser a
p = forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser a
p forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall strm err. Stream strm => HeadedParsec err strm ()
endHead forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall err strm. (Ord err, Stream strm) => HeadedParsec err strm ()
eof

-- * PreparableStmt

preparableStmt :: Parser PreparableStmt
preparableStmt =
  forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
    [ SelectStmt -> PreparableStmt
SelectPreparableStmt forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HeadedParsec Void Text SelectStmt
selectStmt,
      InsertStmt -> PreparableStmt
InsertPreparableStmt forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HeadedParsec Void Text InsertStmt
insertStmt,
      UpdateStmt -> PreparableStmt
UpdatePreparableStmt forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HeadedParsec Void Text UpdateStmt
updateStmt,
      DeleteStmt -> PreparableStmt
DeletePreparableStmt forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HeadedParsec Void Text DeleteStmt
deleteStmt,
      CallStmt -> PreparableStmt
CallPreparableStmt forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HeadedParsec Void Text CallStmt
callStmt
    ]

-- * Call

callStmt :: HeadedParsec Void Text CallStmt
callStmt = do
  forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"call"
  forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
  FuncApplication -> CallStmt
CallStmt forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HeadedParsec Void Text FuncApplication
funcApplication

-- * Insert

insertStmt :: HeadedParsec Void Text InsertStmt
insertStmt = do
  Maybe WithClause
a <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall err strm a.
(Ord err, Stream strm) =>
HeadedParsec err strm a -> HeadedParsec err strm a
wrapToHead HeadedParsec Void Text WithClause
withClause forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1)
  forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"insert"
  forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
  forall strm err. Stream strm => HeadedParsec err strm ()
endHead
  forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"into"
  forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
  InsertTarget
b <- HeadedParsec Void Text InsertTarget
insertTarget
  forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
  InsertRest
c <- HeadedParsec Void Text InsertRest
insertRest
  Maybe OnConflict
d <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text OnConflict
onConflict)
  Maybe (NonEmpty TargetEl)
e <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text (NonEmpty TargetEl)
returningClause)
  return (Maybe WithClause
-> InsertTarget
-> InsertRest
-> Maybe OnConflict
-> Maybe (NonEmpty TargetEl)
-> InsertStmt
InsertStmt Maybe WithClause
a InsertTarget
b InsertRest
c Maybe OnConflict
d Maybe (NonEmpty TargetEl)
e)

insertTarget :: HeadedParsec Void Text InsertTarget
insertTarget = do
  QualifiedName
a <- HeadedParsec Void Text QualifiedName
qualifiedName
  forall strm err. Stream strm => HeadedParsec err strm ()
endHead
  Maybe Ident
b <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"as" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall strm err. Stream strm => HeadedParsec err strm ()
endHead forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text Ident
colId)
  return (QualifiedName -> Maybe Ident -> InsertTarget
InsertTarget QualifiedName
a Maybe Ident
b)

insertRest :: HeadedParsec Void Text InsertRest
insertRest =
  forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
    [ InsertRest
DefaultValuesInsertRest forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ (forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"default" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall strm err. Stream strm => HeadedParsec err strm ()
endHead forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"values"),
      do
        Maybe InsertColumnList
a <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall a. Parser a -> Parser a
inParens HeadedParsec Void Text InsertColumnList
insertColumnList forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1)
        Maybe OverrideKind
b <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional forall a b. (a -> b) -> a -> b
$ do
          forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"overriding"
          forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
          forall strm err. Stream strm => HeadedParsec err strm ()
endHead
          OverrideKind
b <- forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
HeadedParsec e s OverrideKind
overrideKind
          forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
          forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"value"
          forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
          return OverrideKind
b
        SelectStmt
c <- HeadedParsec Void Text SelectStmt
selectStmt
        return (Maybe InsertColumnList
-> Maybe OverrideKind -> SelectStmt -> InsertRest
SelectInsertRest Maybe InsertColumnList
a Maybe OverrideKind
b SelectStmt
c)
    ]

overrideKind :: HeadedParsec e s OverrideKind
overrideKind =
  forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
    [ OverrideKind
UserOverrideKind forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"user",
      OverrideKind
SystemOverrideKind forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"system"
    ]

insertColumnList :: HeadedParsec Void Text InsertColumnList
insertColumnList = forall err strm separtor a.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm separtor
-> HeadedParsec err strm a -> HeadedParsec err strm (NonEmpty a)
sep1 Parser ()
commaSeparator HeadedParsec Void Text InsertColumnItem
insertColumnItem

insertColumnItem :: HeadedParsec Void Text InsertColumnItem
insertColumnItem = do
  Ident
a <- HeadedParsec Void Text Ident
colId
  forall strm err. Stream strm => HeadedParsec err strm ()
endHead
  Maybe Indirection
b <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text Indirection
indirection)
  return (Ident -> Maybe Indirection -> InsertColumnItem
InsertColumnItem Ident
a Maybe Indirection
b)

onConflict :: HeadedParsec Void Text OnConflict
onConflict = do
  forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"on"
  forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
  forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"conflict"
  forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
  forall strm err. Stream strm => HeadedParsec err strm ()
endHead
  Maybe ConfExpr
a <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (HeadedParsec Void Text ConfExpr
confExpr forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1)
  forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"do"
  forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
  OnConflictDo
b <- HeadedParsec Void Text OnConflictDo
onConflictDo
  return (Maybe ConfExpr -> OnConflictDo -> OnConflict
OnConflict Maybe ConfExpr
a OnConflictDo
b)

confExpr :: HeadedParsec Void Text ConfExpr
confExpr =
  forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
    [ IndexParams -> Maybe WhereClause -> ConfExpr
WhereConfExpr forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. Parser a -> Parser a
inParens HeadedParsec Void Text IndexParams
indexParams forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text WhereClause
whereClause),
      Ident -> ConfExpr
ConstraintConfExpr forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"on" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"constraint" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall strm err. Stream strm => HeadedParsec err strm ()
endHead forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text Ident
name)
    ]

onConflictDo :: HeadedParsec Void Text OnConflictDo
onConflictDo =
  forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
    [ OnConflictDo
NothingOnConflictDo forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"nothing",
      do
        forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"update"
        forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
        forall strm err. Stream strm => HeadedParsec err strm ()
endHead
        forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"set"
        forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
        NonEmpty SetClause
a <- HeadedParsec Void Text (NonEmpty SetClause)
setClauseList
        Maybe WhereClause
b <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text WhereClause
whereClause)
        return (NonEmpty SetClause -> Maybe WhereClause -> OnConflictDo
UpdateOnConflictDo NonEmpty SetClause
a Maybe WhereClause
b)
    ]

returningClause :: HeadedParsec Void Text (NonEmpty TargetEl)
returningClause = do
  forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"returning"
  forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
  forall strm err. Stream strm => HeadedParsec err strm ()
endHead
  HeadedParsec Void Text (NonEmpty TargetEl)
targetList

-- * Update

updateStmt :: HeadedParsec Void Text UpdateStmt
updateStmt = do
  Maybe WithClause
a <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall err strm a.
(Ord err, Stream strm) =>
HeadedParsec err strm a -> HeadedParsec err strm a
wrapToHead HeadedParsec Void Text WithClause
withClause forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1)
  forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"update"
  forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
  forall strm err. Stream strm => HeadedParsec err strm ()
endHead
  RelationExprOptAlias
b <- [Text] -> HeadedParsec Void Text RelationExprOptAlias
relationExprOptAlias [Text
"set"]
  forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
  forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"set"
  forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
  NonEmpty SetClause
c <- HeadedParsec Void Text (NonEmpty SetClause)
setClauseList
  Maybe FromClause
d <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text FromClause
fromClause)
  Maybe WhereOrCurrentClause
e <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text WhereOrCurrentClause
whereOrCurrentClause)
  Maybe (NonEmpty TargetEl)
f <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text (NonEmpty TargetEl)
returningClause)
  return (Maybe WithClause
-> RelationExprOptAlias
-> NonEmpty SetClause
-> Maybe FromClause
-> Maybe WhereOrCurrentClause
-> Maybe (NonEmpty TargetEl)
-> UpdateStmt
UpdateStmt Maybe WithClause
a RelationExprOptAlias
b NonEmpty SetClause
c Maybe FromClause
d Maybe WhereOrCurrentClause
e Maybe (NonEmpty TargetEl)
f)

setClauseList :: HeadedParsec Void Text (NonEmpty SetClause)
setClauseList = forall err strm separtor a.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm separtor
-> HeadedParsec err strm a -> HeadedParsec err strm (NonEmpty a)
sep1 Parser ()
commaSeparator HeadedParsec Void Text SetClause
setClause

setClause :: HeadedParsec Void Text SetClause
setClause =
  forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
    [ do
        NonEmpty SetTarget
a <- forall a. Parser a -> Parser a
inParens Parser (NonEmpty SetTarget)
setTargetList
        forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space
        forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
Char -> HeadedParsec err strm Char
char Char
'='
        forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space
        WhereClause
b <- HeadedParsec Void Text WhereClause
aExpr
        return (NonEmpty SetTarget -> WhereClause -> SetClause
TargetListSetClause NonEmpty SetTarget
a WhereClause
b),
      do
        SetTarget
a <- HeadedParsec Void Text SetTarget
setTarget
        forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space
        forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
Char -> HeadedParsec err strm Char
char Char
'='
        forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space
        WhereClause
b <- HeadedParsec Void Text WhereClause
aExpr
        return (SetTarget -> WhereClause -> SetClause
TargetSetClause SetTarget
a WhereClause
b)
    ]

setTarget :: HeadedParsec Void Text SetTarget
setTarget = do
  Ident
a <- HeadedParsec Void Text Ident
colId
  forall strm err. Stream strm => HeadedParsec err strm ()
endHead
  Maybe Indirection
b <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text Indirection
indirection)
  return (Ident -> Maybe Indirection -> SetTarget
SetTarget Ident
a Maybe Indirection
b)

setTargetList :: Parser (NonEmpty SetTarget)
setTargetList = forall err strm separtor a.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm separtor
-> HeadedParsec err strm a -> HeadedParsec err strm (NonEmpty a)
sep1 Parser ()
commaSeparator HeadedParsec Void Text SetTarget
setTarget

-- * Delete

deleteStmt :: HeadedParsec Void Text DeleteStmt
deleteStmt = do
  Maybe WithClause
a <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall err strm a.
(Ord err, Stream strm) =>
HeadedParsec err strm a -> HeadedParsec err strm a
wrapToHead HeadedParsec Void Text WithClause
withClause forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1)
  forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"delete"
  forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
  forall strm err. Stream strm => HeadedParsec err strm ()
endHead
  forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"from"
  forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
  RelationExprOptAlias
b <- [Text] -> HeadedParsec Void Text RelationExprOptAlias
relationExprOptAlias [Text
"using", Text
"where", Text
"returning"]
  Maybe FromClause
c <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text FromClause
usingClause)
  Maybe WhereOrCurrentClause
d <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text WhereOrCurrentClause
whereOrCurrentClause)
  Maybe (NonEmpty TargetEl)
e <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text (NonEmpty TargetEl)
returningClause)
  return (Maybe WithClause
-> RelationExprOptAlias
-> Maybe FromClause
-> Maybe WhereOrCurrentClause
-> Maybe (NonEmpty TargetEl)
-> DeleteStmt
DeleteStmt Maybe WithClause
a RelationExprOptAlias
b Maybe FromClause
c Maybe WhereOrCurrentClause
d Maybe (NonEmpty TargetEl)
e)

usingClause :: HeadedParsec Void Text FromClause
usingClause = do
  forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"using"
  forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
  HeadedParsec Void Text FromClause
fromList

-- * Select

-- |
-- >>> test = testParser selectStmt
--
-- >>> test "select id from as"
-- ...
--   |
-- 1 | select id from as
--   |                  ^
-- Reserved keyword "as" used as an identifier. If that's what you intend, you have to wrap it in double quotes.
selectStmt :: HeadedParsec Void Text SelectStmt
selectStmt = forall a b. a -> Either a b
Left forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HeadedParsec Void Text SelectNoParens
selectNoParens forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall a b. b -> Either a b
Right forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HeadedParsec Void Text SelectWithParens
selectWithParens

selectWithParens :: HeadedParsec Void Text SelectWithParens
selectWithParens = forall a. Parser a -> Parser a
inParens (SelectWithParens -> SelectWithParens
WithParensSelectWithParens forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HeadedParsec Void Text SelectWithParens
selectWithParens forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> SelectNoParens -> SelectWithParens
NoParensSelectWithParens forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HeadedParsec Void Text SelectNoParens
selectNoParens)

selectNoParens :: HeadedParsec Void Text SelectNoParens
selectNoParens = HeadedParsec Void Text SelectNoParens
withSelectNoParens forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> HeadedParsec Void Text SelectNoParens
simpleSelectNoParens

sharedSelectNoParens :: Maybe WithClause -> HeadedParsec Void Text SelectNoParens
sharedSelectNoParens Maybe WithClause
with = do
  Either SimpleSelect SelectWithParens
select <- HeadedParsec Void Text (Either SimpleSelect SelectWithParens)
selectClause
  Maybe SortClause
sort <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text SortClause
sortClause)
  Maybe SelectLimit
limit <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text SelectLimit
selectLimit)
  Maybe ForLockingClause
forLocking <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text ForLockingClause
forLockingClause)
  return (Maybe WithClause
-> Either SimpleSelect SelectWithParens
-> Maybe SortClause
-> Maybe SelectLimit
-> Maybe ForLockingClause
-> SelectNoParens
SelectNoParens Maybe WithClause
with Either SimpleSelect SelectWithParens
select Maybe SortClause
sort Maybe SelectLimit
limit Maybe ForLockingClause
forLocking)

-- |
-- The one that doesn't start with \"WITH\".
--
-- ==== References
-- @
--   | simple_select
--   | select_clause sort_clause
--   | select_clause opt_sort_clause for_locking_clause opt_select_limit
--   | select_clause opt_sort_clause select_limit opt_for_locking_clause
-- @
simpleSelectNoParens :: HeadedParsec Void Text SelectNoParens
simpleSelectNoParens = Maybe WithClause -> HeadedParsec Void Text SelectNoParens
sharedSelectNoParens forall a. Maybe a
Nothing

withSelectNoParens :: HeadedParsec Void Text SelectNoParens
withSelectNoParens = do
  WithClause
with <- forall err strm a.
(Ord err, Stream strm) =>
HeadedParsec err strm a -> HeadedParsec err strm a
wrapToHead HeadedParsec Void Text WithClause
withClause
  forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
  Maybe WithClause -> HeadedParsec Void Text SelectNoParens
sharedSelectNoParens (forall a. a -> Maybe a
Just WithClause
with)

selectClause :: HeadedParsec Void Text (Either SimpleSelect SelectWithParens)
selectClause = forall (m :: * -> *) a. MonadPlus m => m a -> (a -> m a) -> m a
suffixRec HeadedParsec Void Text (Either SimpleSelect SelectWithParens)
base Either SimpleSelect SelectWithParens
-> HeadedParsec Void Text (Either SimpleSelect SelectWithParens)
suffix
  where
    base :: HeadedParsec Void Text (Either SimpleSelect SelectWithParens)
base =
      forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
        [ forall a b. b -> Either a b
Right forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HeadedParsec Void Text SelectWithParens
selectWithParens,
          forall a b. a -> Either a b
Left forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HeadedParsec Void Text SimpleSelect
baseSimpleSelect
        ]
    suffix :: Either SimpleSelect SelectWithParens
-> HeadedParsec Void Text (Either SimpleSelect SelectWithParens)
suffix Either SimpleSelect SelectWithParens
a = forall a b. a -> Either a b
Left forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Either SimpleSelect SelectWithParens
-> HeadedParsec Void Text SimpleSelect
extensionSimpleSelect Either SimpleSelect SelectWithParens
a

baseSimpleSelect :: HeadedParsec Void Text SimpleSelect
baseSimpleSelect =
  forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
    [ do
        forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"select"
        forall err strm a.
(Ord err, Stream strm) =>
HeadedParsec err strm a -> HeadedParsec err strm ()
notFollowedBy forall a b. (a -> b) -> a -> b
$ forall err strm.
(Ord err, Stream strm) =>
(Token strm -> Bool) -> HeadedParsec err strm (Token strm)
satisfy forall a b. (a -> b) -> a -> b
$ Char -> Bool
isAlphaNum
        forall strm err. Stream strm => HeadedParsec err strm ()
endHead
        Maybe Targeting
targeting <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text Targeting
targeting)
        Maybe IntoClause
intoClause <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"into" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall strm err. Stream strm => HeadedParsec err strm ()
endHead forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text IntoClause
optTempTableName)
        Maybe FromClause
fromClause <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text FromClause
fromClause)
        Maybe WhereClause
whereClause <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text WhereClause
whereClause)
        Maybe (NonEmpty GroupByItem)
groupClause <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall {s} {e}.
(Token s ~ Char, Tokens s ~ Text, Ord e, Stream s,
 FoldCase (Tokens s)) =>
Text -> HeadedParsec e s Text
keyphrase Text
"group by" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall strm err. Stream strm => HeadedParsec err strm ()
endHead forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm separtor a.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm separtor
-> HeadedParsec err strm a -> HeadedParsec err strm (NonEmpty a)
sep1 Parser ()
commaSeparator HeadedParsec Void Text GroupByItem
groupByItem)
        Maybe WhereClause
havingClause <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"having" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall strm err. Stream strm => HeadedParsec err strm ()
endHead forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text WhereClause
aExpr)
        Maybe (NonEmpty WindowDefinition)
windowClause <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"window" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall strm err. Stream strm => HeadedParsec err strm ()
endHead forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm separtor a.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm separtor
-> HeadedParsec err strm a -> HeadedParsec err strm (NonEmpty a)
sep1 Parser ()
commaSeparator HeadedParsec Void Text WindowDefinition
windowDefinition)
        return (Maybe Targeting
-> Maybe IntoClause
-> Maybe FromClause
-> Maybe WhereClause
-> Maybe (NonEmpty GroupByItem)
-> Maybe WhereClause
-> Maybe (NonEmpty WindowDefinition)
-> SimpleSelect
NormalSimpleSelect Maybe Targeting
targeting Maybe IntoClause
intoClause Maybe FromClause
fromClause Maybe WhereClause
whereClause Maybe (NonEmpty GroupByItem)
groupClause Maybe WhereClause
havingClause Maybe (NonEmpty WindowDefinition)
windowClause),
      do
        forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"table"
        forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
        forall strm err. Stream strm => HeadedParsec err strm ()
endHead
        RelationExpr -> SimpleSelect
TableSimpleSelect forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HeadedParsec Void Text RelationExpr
relationExpr,
      ValuesClause -> SimpleSelect
ValuesSimpleSelect forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HeadedParsec Void Text ValuesClause
valuesClause
    ]

extensionSimpleSelect :: Either SimpleSelect SelectWithParens
-> HeadedParsec Void Text SimpleSelect
extensionSimpleSelect Either SimpleSelect SelectWithParens
headSelectClause = do
  SelectBinOp
op <- forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
HeadedParsec e s SelectBinOp
selectBinOp forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
  forall strm err. Stream strm => HeadedParsec err strm ()
endHead
  Maybe Bool
allOrDistinct <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
HeadedParsec e s Bool
allOrDistinct forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1)
  Either SimpleSelect SelectWithParens
selectClause <- HeadedParsec Void Text (Either SimpleSelect SelectWithParens)
selectClause
  return (SelectBinOp
-> Either SimpleSelect SelectWithParens
-> Maybe Bool
-> Either SimpleSelect SelectWithParens
-> SimpleSelect
BinSimpleSelect SelectBinOp
op Either SimpleSelect SelectWithParens
headSelectClause Maybe Bool
allOrDistinct Either SimpleSelect SelectWithParens
selectClause)

allOrDistinct :: HeadedParsec e s Bool
allOrDistinct = forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"all" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Bool
False forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"distinct" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Bool
True

selectBinOp :: HeadedParsec e s SelectBinOp
selectBinOp =
  forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
    [ forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"union" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> SelectBinOp
UnionSelectBinOp,
      forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"intersect" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> SelectBinOp
IntersectSelectBinOp,
      forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"except" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> SelectBinOp
ExceptSelectBinOp
    ]

valuesClause :: HeadedParsec Void Text ValuesClause
valuesClause = do
  forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"values"
  forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space
  forall err strm separtor a.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm separtor
-> HeadedParsec err strm a -> HeadedParsec err strm (NonEmpty a)
sep1 Parser ()
commaSeparator forall a b. (a -> b) -> a -> b
$ do
    forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
Char -> HeadedParsec err strm Char
char Char
'('
    forall strm err. Stream strm => HeadedParsec err strm ()
endHead
    forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space
    ExprList
a <- forall err strm separtor a.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm separtor
-> HeadedParsec err strm a -> HeadedParsec err strm (NonEmpty a)
sep1 Parser ()
commaSeparator HeadedParsec Void Text WhereClause
aExpr
    forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space
    forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
Char -> HeadedParsec err strm Char
char Char
')'
    return ExprList
a

withClause :: HeadedParsec Void Text WithClause
withClause = forall err strm a.
(Ord err, Stream strm) =>
String -> HeadedParsec err strm a -> HeadedParsec err strm a
label String
"with clause" forall a b. (a -> b) -> a -> b
$ do
  forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"with"
  forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
  forall strm err. Stream strm => HeadedParsec err strm ()
endHead
  Bool
recursive <- forall (m :: * -> *) a. Alternative m => a -> m a -> m a
option Bool
False (Bool
True forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"recursive" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1)
  NonEmpty CommonTableExpr
cteList <- forall err strm separtor a.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm separtor
-> HeadedParsec err strm a -> HeadedParsec err strm (NonEmpty a)
sep1 Parser ()
commaSeparator HeadedParsec Void Text CommonTableExpr
commonTableExpr
  return (Bool -> NonEmpty CommonTableExpr -> WithClause
WithClause Bool
recursive NonEmpty CommonTableExpr
cteList)

commonTableExpr :: HeadedParsec Void Text CommonTableExpr
commonTableExpr = forall err strm a.
(Ord err, Stream strm) =>
String -> HeadedParsec err strm a -> HeadedParsec err strm a
label String
"common table expression" forall a b. (a -> b) -> a -> b
$ do
  Ident
name <- HeadedParsec Void Text Ident
colId forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall strm err. Stream strm => HeadedParsec err strm ()
endHead
  Maybe (NonEmpty Ident)
nameList <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall a. Parser a -> Parser a
inParens (forall err strm separtor a.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm separtor
-> HeadedParsec err strm a -> HeadedParsec err strm (NonEmpty a)
sep1 Parser ()
commaSeparator HeadedParsec Void Text Ident
colId) forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1)
  forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"as"
  forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
  Maybe Bool
materialized <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s,
 FoldCase (Tokens s)) =>
HeadedParsec e s Bool
materialized forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1)
  PreparableStmt
stmt <- forall a. Parser a -> Parser a
inParens Parser PreparableStmt
preparableStmt
  return (Ident
-> Maybe (NonEmpty Ident)
-> Maybe Bool
-> PreparableStmt
-> CommonTableExpr
CommonTableExpr Ident
name Maybe (NonEmpty Ident)
nameList Maybe Bool
materialized PreparableStmt
stmt)

materialized :: HeadedParsec e s Bool
materialized =
  Bool
True forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"materialized"
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Bool
False forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Token s ~ Char, Tokens s ~ Text, Ord e, Stream s,
 FoldCase (Tokens s)) =>
Text -> HeadedParsec e s Text
keyphrase Text
"not materialized"

targeting :: HeadedParsec Void Text Targeting
targeting = HeadedParsec Void Text Targeting
distinct forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> HeadedParsec Void Text Targeting
allWithTargetList forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
HeadedParsec e s Targeting
all forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> HeadedParsec Void Text Targeting
normal
  where
    normal :: HeadedParsec Void Text Targeting
normal = NonEmpty TargetEl -> Targeting
NormalTargeting forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HeadedParsec Void Text (NonEmpty TargetEl)
targetList
    allWithTargetList :: HeadedParsec Void Text Targeting
allWithTargetList = do
      forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"all"
      forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
      Maybe (NonEmpty TargetEl) -> Targeting
AllTargeting forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. a -> Maybe a
Just forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HeadedParsec Void Text (NonEmpty TargetEl)
targetList
    all :: HeadedParsec e s Targeting
all = forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"all" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Maybe (NonEmpty TargetEl) -> Targeting
AllTargeting forall a. Maybe a
Nothing
    distinct :: HeadedParsec Void Text Targeting
distinct = do
      forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"distinct"
      forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
      forall strm err. Stream strm => HeadedParsec err strm ()
endHead
      Maybe ExprList
optOn <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (HeadedParsec Void Text ExprList
onExpressionsClause forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1)
      NonEmpty TargetEl
targetList <- HeadedParsec Void Text (NonEmpty TargetEl)
targetList
      return (Maybe ExprList -> NonEmpty TargetEl -> Targeting
DistinctTargeting Maybe ExprList
optOn NonEmpty TargetEl
targetList)

targetList :: HeadedParsec Void Text (NonEmpty TargetEl)
targetList = forall err strm separtor a.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm separtor
-> HeadedParsec err strm a -> HeadedParsec err strm (NonEmpty a)
sep1 Parser ()
commaSeparator HeadedParsec Void Text TargetEl
targetEl

-- |
-- >>> testParser targetEl "a.b as c"
-- AliasedExprTargetEl (CExprAExpr (ColumnrefCExpr (Columnref (UnquotedIdent "a") (Just (AttrNameIndirectionEl (UnquotedIdent "b") :| []))))) (UnquotedIdent "c")
targetEl :: HeadedParsec Void Text TargetEl
targetEl =
  forall err strm a.
(Ord err, Stream strm) =>
String -> HeadedParsec err strm a -> HeadedParsec err strm a
label String
"target"
    forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
      [ do
          WhereClause
expr <- HeadedParsec Void Text WhereClause
aExpr
          forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
            [ do
                forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
                forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
                  [ WhereClause -> Ident -> TargetEl
AliasedExprTargetEl WhereClause
expr forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"as" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall strm err. Stream strm => HeadedParsec err strm ()
endHead forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text Ident
colLabel),
                    WhereClause -> Ident -> TargetEl
ImplicitlyAliasedExprTargetEl WhereClause
expr forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HeadedParsec Void Text Ident
ident
                  ],
              forall (f :: * -> *) a. Applicative f => a -> f a
pure (WhereClause -> TargetEl
ExprTargetEl WhereClause
expr)
            ],
        TargetEl
AsteriskTargetEl forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
Char -> HeadedParsec err strm Char
char Char
'*'
      ]

onExpressionsClause :: HeadedParsec Void Text ExprList
onExpressionsClause = do
  forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"on"
  forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
  forall strm err. Stream strm => HeadedParsec err strm ()
endHead
  forall a. Parser a -> Parser a
inParens (forall err strm separtor a.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm separtor
-> HeadedParsec err strm a -> HeadedParsec err strm (NonEmpty a)
sep1 Parser ()
commaSeparator HeadedParsec Void Text WhereClause
aExpr)

-- * Into clause details

-- |
-- ==== References
-- @
-- OptTempTableName:
--   | TEMPORARY opt_table qualified_name
--   | TEMP opt_table qualified_name
--   | LOCAL TEMPORARY opt_table qualified_name
--   | LOCAL TEMP opt_table qualified_name
--   | GLOBAL TEMPORARY opt_table qualified_name
--   | GLOBAL TEMP opt_table qualified_name
--   | UNLOGGED opt_table qualified_name
--   | TABLE qualified_name
--   | qualified_name
-- @
optTempTableName :: HeadedParsec Void Text IntoClause
optTempTableName =
  forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
    [ do
        Bool -> QualifiedName -> IntoClause
a <-
          forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
            [ Bool -> QualifiedName -> IntoClause
TemporaryOptTempTableName forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"temporary" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1,
              Bool -> QualifiedName -> IntoClause
TempOptTempTableName forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"temp" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1,
              Bool -> QualifiedName -> IntoClause
LocalTemporaryOptTempTableName forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Token s ~ Char, Tokens s ~ Text, Ord e, Stream s,
 FoldCase (Tokens s)) =>
Text -> HeadedParsec e s Text
keyphrase Text
"local temporary" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1,
              Bool -> QualifiedName -> IntoClause
LocalTempOptTempTableName forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Token s ~ Char, Tokens s ~ Text, Ord e, Stream s,
 FoldCase (Tokens s)) =>
Text -> HeadedParsec e s Text
keyphrase Text
"local temp" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1,
              Bool -> QualifiedName -> IntoClause
GlobalTemporaryOptTempTableName forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Token s ~ Char, Tokens s ~ Text, Ord e, Stream s,
 FoldCase (Tokens s)) =>
Text -> HeadedParsec e s Text
keyphrase Text
"global temporary" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1,
              Bool -> QualifiedName -> IntoClause
GlobalTempOptTempTableName forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Token s ~ Char, Tokens s ~ Text, Ord e, Stream s,
 FoldCase (Tokens s)) =>
Text -> HeadedParsec e s Text
keyphrase Text
"global temp" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1,
              Bool -> QualifiedName -> IntoClause
UnloggedOptTempTableName forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"unlogged" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
            ]
        Bool
b <- forall (m :: * -> *) a. Alternative m => a -> m a -> m a
option Bool
False (Bool
True forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"table" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1)
        QualifiedName
c <- HeadedParsec Void Text QualifiedName
qualifiedName
        return (Bool -> QualifiedName -> IntoClause
a Bool
b QualifiedName
c),
      do
        forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"table"
        forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
        forall strm err. Stream strm => HeadedParsec err strm ()
endHead
        QualifiedName -> IntoClause
TableOptTempTableName forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HeadedParsec Void Text QualifiedName
qualifiedName,
      QualifiedName -> IntoClause
QualifedOptTempTableName forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HeadedParsec Void Text QualifiedName
qualifiedName
    ]

-- * Group by details

groupByItem :: HeadedParsec Void Text GroupByItem
groupByItem =
  forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
    [ GroupByItem
EmptyGroupingSetGroupByItem forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
Char -> HeadedParsec err strm Char
char Char
'(' forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
Char -> HeadedParsec err strm Char
char Char
')'),
      ExprList -> GroupByItem
RollupGroupByItem forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"rollup" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall strm err. Stream strm => HeadedParsec err strm ()
endHead forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall a. Parser a -> Parser a
inParens (forall err strm separtor a.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm separtor
-> HeadedParsec err strm a -> HeadedParsec err strm (NonEmpty a)
sep1 Parser ()
commaSeparator HeadedParsec Void Text WhereClause
aExpr)),
      ExprList -> GroupByItem
CubeGroupByItem forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"cube" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall strm err. Stream strm => HeadedParsec err strm ()
endHead forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall a. Parser a -> Parser a
inParens (forall err strm separtor a.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm separtor
-> HeadedParsec err strm a -> HeadedParsec err strm (NonEmpty a)
sep1 Parser ()
commaSeparator HeadedParsec Void Text WhereClause
aExpr)),
      NonEmpty GroupByItem -> GroupByItem
GroupingSetsGroupByItem forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall {s} {e}.
(Token s ~ Char, Tokens s ~ Text, Ord e, Stream s,
 FoldCase (Tokens s)) =>
Text -> HeadedParsec e s Text
keyphrase Text
"grouping sets" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall strm err. Stream strm => HeadedParsec err strm ()
endHead forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall a. Parser a -> Parser a
inParens (forall err strm separtor a.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm separtor
-> HeadedParsec err strm a -> HeadedParsec err strm (NonEmpty a)
sep1 Parser ()
commaSeparator HeadedParsec Void Text GroupByItem
groupByItem)),
      WhereClause -> GroupByItem
ExprGroupByItem forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HeadedParsec Void Text WhereClause
aExpr
    ]

-- * Window clause details

windowDefinition :: HeadedParsec Void Text WindowDefinition
windowDefinition = Ident -> WindowSpecification -> WindowDefinition
WindowDefinition forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (HeadedParsec Void Text Ident
colId forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"as" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall strm err. Stream strm => HeadedParsec err strm ()
endHead) forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> HeadedParsec Void Text WindowSpecification
windowSpecification

-- |
-- ==== References
-- @
-- window_specification:
--   |  '(' opt_existing_window_name opt_partition_clause
--             opt_sort_clause opt_frame_clause ')'
-- @
windowSpecification :: HeadedParsec Void Text WindowSpecification
windowSpecification =
  forall a. Parser a -> Parser a
inParens
    forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
      [ do
          FrameClause
a <- HeadedParsec Void Text FrameClause
frameClause
          return (Maybe Ident
-> Maybe ExprList
-> Maybe SortClause
-> Maybe FrameClause
-> WindowSpecification
WindowSpecification forall a. Maybe a
Nothing forall a. Maybe a
Nothing forall a. Maybe a
Nothing (forall a. a -> Maybe a
Just FrameClause
a)),
        do
          SortClause
a <- HeadedParsec Void Text SortClause
sortClause
          Maybe FrameClause
b <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text FrameClause
frameClause)
          return (Maybe Ident
-> Maybe ExprList
-> Maybe SortClause
-> Maybe FrameClause
-> WindowSpecification
WindowSpecification forall a. Maybe a
Nothing forall a. Maybe a
Nothing (forall a. a -> Maybe a
Just SortClause
a) Maybe FrameClause
b),
        do
          ExprList
a <- HeadedParsec Void Text ExprList
partitionByClause
          Maybe SortClause
b <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text SortClause
sortClause)
          Maybe FrameClause
c <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text FrameClause
frameClause)
          return (Maybe Ident
-> Maybe ExprList
-> Maybe SortClause
-> Maybe FrameClause
-> WindowSpecification
WindowSpecification forall a. Maybe a
Nothing (forall a. a -> Maybe a
Just ExprList
a) Maybe SortClause
b Maybe FrameClause
c),
        do
          Ident
a <- HeadedParsec Void Text Ident
colId
          Maybe ExprList
b <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text ExprList
partitionByClause)
          Maybe SortClause
c <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text SortClause
sortClause)
          Maybe FrameClause
d <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text FrameClause
frameClause)
          return (Maybe Ident
-> Maybe ExprList
-> Maybe SortClause
-> Maybe FrameClause
-> WindowSpecification
WindowSpecification (forall a. a -> Maybe a
Just Ident
a) Maybe ExprList
b Maybe SortClause
c Maybe FrameClause
d),
        forall (f :: * -> *) a. Applicative f => a -> f a
pure (Maybe Ident
-> Maybe ExprList
-> Maybe SortClause
-> Maybe FrameClause
-> WindowSpecification
WindowSpecification forall a. Maybe a
Nothing forall a. Maybe a
Nothing forall a. Maybe a
Nothing forall a. Maybe a
Nothing)
      ]

partitionByClause :: HeadedParsec Void Text ExprList
partitionByClause = forall {s} {e}.
(Token s ~ Char, Tokens s ~ Text, Ord e, Stream s,
 FoldCase (Tokens s)) =>
Text -> HeadedParsec e s Text
keyphrase Text
"partition by" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall strm err. Stream strm => HeadedParsec err strm ()
endHead forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm separtor a.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm separtor
-> HeadedParsec err strm a -> HeadedParsec err strm (NonEmpty a)
sep1 Parser ()
commaSeparator HeadedParsec Void Text WhereClause
aExpr

-- |
-- ==== References
-- @
-- opt_frame_clause:
--   |  RANGE frame_extent opt_window_exclusion_clause
--   |  ROWS frame_extent opt_window_exclusion_clause
--   |  GROUPS frame_extent opt_window_exclusion_clause
--   |  EMPTY
-- @
frameClause :: HeadedParsec Void Text FrameClause
frameClause = do
  FrameClauseMode
a <- forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
HeadedParsec e s FrameClauseMode
frameClauseMode forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall strm err. Stream strm => HeadedParsec err strm ()
endHead
  FrameExtent
b <- HeadedParsec Void Text FrameExtent
frameExtent
  Maybe WindowExclusionClause
c <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall {s} {e}.
(Token s ~ Char, Tokens s ~ Text, Ord e, Stream s,
 FoldCase (Tokens s)) =>
HeadedParsec e s WindowExclusionClause
windowExclusionClause)
  return (FrameClauseMode
-> FrameExtent -> Maybe WindowExclusionClause -> FrameClause
FrameClause FrameClauseMode
a FrameExtent
b Maybe WindowExclusionClause
c)

frameClauseMode :: HeadedParsec e s FrameClauseMode
frameClauseMode =
  forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
    [ FrameClauseMode
RangeFrameClauseMode forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"range",
      FrameClauseMode
RowsFrameClauseMode forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"rows",
      FrameClauseMode
GroupsFrameClauseMode forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"groups"
    ]

frameExtent :: HeadedParsec Void Text FrameExtent
frameExtent =
  FrameBound -> FrameBound -> FrameExtent
BetweenFrameExtent forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"between" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall strm err. Stream strm => HeadedParsec err strm ()
endHead forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text FrameBound
frameBound forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"and" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1) forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> HeadedParsec Void Text FrameBound
frameBound
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> FrameBound -> FrameExtent
SingularFrameExtent forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HeadedParsec Void Text FrameBound
frameBound

-- |
-- ==== References
-- @
--   |  UNBOUNDED PRECEDING
--   |  UNBOUNDED FOLLOWING
--   |  CURRENT_P ROW
--   |  a_expr PRECEDING
--   |  a_expr FOLLOWING
-- @
frameBound :: HeadedParsec Void Text FrameBound
frameBound =
  FrameBound
UnboundedPrecedingFrameBound forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Token s ~ Char, Tokens s ~ Text, Ord e, Stream s,
 FoldCase (Tokens s)) =>
Text -> HeadedParsec e s Text
keyphrase Text
"unbounded preceding"
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> FrameBound
UnboundedFollowingFrameBound forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Token s ~ Char, Tokens s ~ Text, Ord e, Stream s,
 FoldCase (Tokens s)) =>
Text -> HeadedParsec e s Text
keyphrase Text
"unbounded following"
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> FrameBound
CurrentRowFrameBound forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Token s ~ Char, Tokens s ~ Text, Ord e, Stream s,
 FoldCase (Tokens s)) =>
Text -> HeadedParsec e s Text
keyphrase Text
"current row"
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> do
      WhereClause
a <- HeadedParsec Void Text WhereClause
aExpr
      forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
      WhereClause -> FrameBound
PrecedingFrameBound WhereClause
a forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"preceding" forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> WhereClause -> FrameBound
FollowingFrameBound WhereClause
a forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"following"

windowExclusionClause :: HeadedParsec e s WindowExclusionClause
windowExclusionClause =
  WindowExclusionClause
CurrentRowWindowExclusionClause forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Token s ~ Char, Tokens s ~ Text, Ord e, Stream s,
 FoldCase (Tokens s)) =>
Text -> HeadedParsec e s Text
keyphrase Text
"exclude current row"
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> WindowExclusionClause
GroupWindowExclusionClause forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Token s ~ Char, Tokens s ~ Text, Ord e, Stream s,
 FoldCase (Tokens s)) =>
Text -> HeadedParsec e s Text
keyphrase Text
"exclude group"
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> WindowExclusionClause
TiesWindowExclusionClause forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Token s ~ Char, Tokens s ~ Text, Ord e, Stream s,
 FoldCase (Tokens s)) =>
Text -> HeadedParsec e s Text
keyphrase Text
"exclude ties"
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> WindowExclusionClause
NoOthersWindowExclusionClause forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Token s ~ Char, Tokens s ~ Text, Ord e, Stream s,
 FoldCase (Tokens s)) =>
Text -> HeadedParsec e s Text
keyphrase Text
"exclude no others"

-- * Table refs

fromList :: HeadedParsec Void Text FromClause
fromList = forall err strm separtor a.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm separtor
-> HeadedParsec err strm a -> HeadedParsec err strm (NonEmpty a)
sep1 Parser ()
commaSeparator HeadedParsec Void Text TableRef
tableRef

fromClause :: HeadedParsec Void Text FromClause
fromClause = forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"from" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall strm err. Stream strm => HeadedParsec err strm ()
endHead forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text FromClause
fromList

-- |
-- >>> testParser tableRef "a left join b on (a.i = b.i)"
-- JoinTableRef (MethJoinedTable (QualJoinMeth...
tableRef :: HeadedParsec Void Text TableRef
tableRef =
  forall err strm a.
(Ord err, Stream strm) =>
String -> HeadedParsec err strm a -> HeadedParsec err strm a
label String
"table reference"
    forall a b. (a -> b) -> a -> b
$ do
      TableRef
tr <- HeadedParsec Void Text TableRef
nonTrailingTableRef
      TableRef -> HeadedParsec Void Text TableRef
recur TableRef
tr
  where
    recur :: TableRef -> HeadedParsec Void Text TableRef
recur TableRef
tr =
      forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
        [ do
            TableRef
tr2 <- forall err strm a.
(Ord err, Stream strm) =>
HeadedParsec err strm a -> HeadedParsec err strm a
wrapToHead (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> TableRef -> HeadedParsec Void Text TableRef
trailingTableRef TableRef
tr)
            forall strm err. Stream strm => HeadedParsec err strm ()
endHead
            TableRef -> HeadedParsec Void Text TableRef
recur TableRef
tr2,
          forall (f :: * -> *) a. Applicative f => a -> f a
pure TableRef
tr
        ]

nonTrailingTableRef :: HeadedParsec Void Text TableRef
nonTrailingTableRef =
  forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
    [ HeadedParsec Void Text TableRef
lateralTableRef
        forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall err strm a.
(Ord err, Stream strm) =>
HeadedParsec err strm a -> HeadedParsec err strm a
wrapToHead HeadedParsec Void Text TableRef
nonLateralTableRef
        forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> HeadedParsec Void Text TableRef
relationExprTableRef
        forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> HeadedParsec Void Text TableRef
joinedTableWithAliasTableRef
        forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> HeadedParsec Void Text TableRef
inParensJoinedTableTableRef
    ]
  where
    relationExprTableRef :: HeadedParsec Void Text TableRef
relationExprTableRef = do
      RelationExpr
relationExpr <- HeadedParsec Void Text RelationExpr
relationExpr
      forall strm err. Stream strm => HeadedParsec err strm ()
endHead
      Maybe AliasClause
optAliasClause <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text AliasClause
aliasClause)
      Maybe TablesampleClause
optTablesampleClause <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text TablesampleClause
tablesampleClause)
      return (RelationExpr
-> Maybe AliasClause -> Maybe TablesampleClause -> TableRef
RelationExprTableRef RelationExpr
relationExpr Maybe AliasClause
optAliasClause Maybe TablesampleClause
optTablesampleClause)

    lateralTableRef :: HeadedParsec Void Text TableRef
lateralTableRef = do
      forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"lateral"
      forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
      forall strm err. Stream strm => HeadedParsec err strm ()
endHead
      Bool -> HeadedParsec Void Text TableRef
lateralableTableRef Bool
True

    nonLateralTableRef :: HeadedParsec Void Text TableRef
nonLateralTableRef = Bool -> HeadedParsec Void Text TableRef
lateralableTableRef Bool
False

    lateralableTableRef :: Bool -> HeadedParsec Void Text TableRef
lateralableTableRef Bool
lateral =
      forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
        [ do
            FuncTable
a <- HeadedParsec Void Text FuncTable
funcTable
            Maybe FuncAliasClause
b <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text FuncAliasClause
funcAliasClause)
            return (Bool -> FuncTable -> Maybe FuncAliasClause -> TableRef
FuncTableRef Bool
lateral FuncTable
a Maybe FuncAliasClause
b),
          do
            SelectWithParens
select <- HeadedParsec Void Text SelectWithParens
selectWithParens
            Maybe AliasClause
optAliasClause <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional forall a b. (a -> b) -> a -> b
$ forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text AliasClause
aliasClause
            return (Bool -> SelectWithParens -> Maybe AliasClause -> TableRef
SelectTableRef Bool
lateral SelectWithParens
select Maybe AliasClause
optAliasClause)
        ]

    inParensJoinedTableTableRef :: HeadedParsec Void Text TableRef
inParensJoinedTableTableRef = JoinedTable -> Maybe AliasClause -> TableRef
JoinTableRef forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HeadedParsec Void Text JoinedTable
inParensJoinedTable forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a. Maybe a
Nothing

    joinedTableWithAliasTableRef :: HeadedParsec Void Text TableRef
joinedTableWithAliasTableRef = do
      JoinedTable
joinedTable <- forall err strm a.
(Ord err, Stream strm) =>
HeadedParsec err strm a -> HeadedParsec err strm a
wrapToHead (forall a. Parser a -> Parser a
inParens HeadedParsec Void Text JoinedTable
joinedTable)
      forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
      AliasClause
alias <- HeadedParsec Void Text AliasClause
aliasClause
      return (JoinedTable -> Maybe AliasClause -> TableRef
JoinTableRef JoinedTable
joinedTable (forall a. a -> Maybe a
Just AliasClause
alias))

trailingTableRef :: TableRef -> HeadedParsec Void Text TableRef
trailingTableRef TableRef
tableRef =
  JoinedTable -> Maybe AliasClause -> TableRef
JoinTableRef forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TableRef -> HeadedParsec Void Text JoinedTable
trailingJoinedTable TableRef
tableRef forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a. Maybe a
Nothing

relationExpr :: HeadedParsec Void Text RelationExpr
relationExpr =
  forall err strm a.
(Ord err, Stream strm) =>
String -> HeadedParsec err strm a -> HeadedParsec err strm a
label String
"relation expression"
    forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
      [ do
          forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"only"
          forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
          QualifiedName
name <- HeadedParsec Void Text QualifiedName
qualifiedName
          return (QualifiedName -> Bool -> RelationExpr
OnlyRelationExpr QualifiedName
name Bool
False),
        forall clause content.
Parser clause -> Parser content -> Parser content
inParensWithClause (forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"only") HeadedParsec Void Text QualifiedName
qualifiedName forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \QualifiedName
a -> QualifiedName -> Bool -> RelationExpr
OnlyRelationExpr QualifiedName
a Bool
True,
        do
          QualifiedName
name <- HeadedParsec Void Text QualifiedName
qualifiedName
          Bool
asterisk <-
            forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
              [ Bool
True forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
Char -> HeadedParsec err strm Char
char Char
'*'),
                forall (f :: * -> *) a. Applicative f => a -> f a
pure Bool
False
              ]
          return (QualifiedName -> Bool -> RelationExpr
SimpleRelationExpr QualifiedName
name Bool
asterisk)
      ]

relationExprOptAlias :: [Text] -> HeadedParsec Void Text RelationExprOptAlias
relationExprOptAlias [Text]
reservedKeywords = do
  RelationExpr
a <- HeadedParsec Void Text RelationExpr
relationExpr
  Maybe (Bool, Ident)
b <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional forall a b. (a -> b) -> a -> b
$ do
    forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
    Bool
b <- forall a. Parser a -> Parser Bool
trueIfPresent (forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"as" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1)
    Ident
c <- forall {t :: * -> *}.
Foldable t =>
t Text -> HeadedParsec Void Text Ident
filteredColId [Text]
reservedKeywords
    return (Bool
b, Ident
c)
  return (RelationExpr -> Maybe (Bool, Ident) -> RelationExprOptAlias
RelationExprOptAlias RelationExpr
a Maybe (Bool, Ident)
b)

tablesampleClause :: HeadedParsec Void Text TablesampleClause
tablesampleClause = do
  forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"tablesample"
  forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
  forall strm err. Stream strm => HeadedParsec err strm ()
endHead
  FuncName
a <- Parser FuncName
funcName
  forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space
  ExprList
b <- forall a. Parser a -> Parser a
inParens HeadedParsec Void Text ExprList
exprList
  Maybe WhereClause
c <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text WhereClause
repeatableClause)
  return (FuncName -> ExprList -> Maybe WhereClause -> TablesampleClause
TablesampleClause FuncName
a ExprList
b Maybe WhereClause
c)

repeatableClause :: HeadedParsec Void Text WhereClause
repeatableClause = do
  forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"repeatable"
  forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space
  forall a. Parser a -> Parser a
inParens (forall strm err. Stream strm => HeadedParsec err strm ()
endHead forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text WhereClause
aExpr)

funcTable :: HeadedParsec Void Text FuncTable
funcTable =
  forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
    [ do
        forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"rows"
        forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
        forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"from"
        forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space
        NonEmpty RowsfromItem
a <- forall a. Parser a -> Parser a
inParens (forall strm err. Stream strm => HeadedParsec err strm ()
endHead forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text (NonEmpty RowsfromItem)
rowsfromList)
        Bool
b <- forall a. Parser a -> Parser Bool
trueIfPresent (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
HeadedParsec e s Text
optOrdinality)
        return (NonEmpty RowsfromItem -> Bool -> FuncTable
RowsFromFuncTable NonEmpty RowsfromItem
a Bool
b),
      do
        FuncExprWindowless
a <- HeadedParsec Void Text FuncExprWindowless
funcExprWindowless
        Bool
b <- forall a. Parser a -> Parser Bool
trueIfPresent (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
HeadedParsec e s Text
optOrdinality)
        return (FuncExprWindowless -> Bool -> FuncTable
FuncExprFuncTable FuncExprWindowless
a Bool
b)
    ]

rowsfromItem :: HeadedParsec Void Text RowsfromItem
rowsfromItem = do
  FuncExprWindowless
a <- HeadedParsec Void Text FuncExprWindowless
funcExprWindowless
  forall strm err. Stream strm => HeadedParsec err strm ()
endHead
  Maybe ColDefList
b <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text ColDefList
colDefList)
  return (FuncExprWindowless -> Maybe ColDefList -> RowsfromItem
RowsfromItem FuncExprWindowless
a Maybe ColDefList
b)

rowsfromList :: HeadedParsec Void Text (NonEmpty RowsfromItem)
rowsfromList = forall err strm separtor a.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm separtor
-> HeadedParsec err strm a -> HeadedParsec err strm (NonEmpty a)
sep1 Parser ()
commaSeparator HeadedParsec Void Text RowsfromItem
rowsfromItem

colDefList :: HeadedParsec Void Text ColDefList
colDefList = forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"as" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall a. Parser a -> Parser a
inParens (forall strm err. Stream strm => HeadedParsec err strm ()
endHead forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text ColDefList
tableFuncElementList)

optOrdinality :: HeadedParsec e s Text
optOrdinality = forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"with" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"ordinality"

tableFuncElementList :: HeadedParsec Void Text ColDefList
tableFuncElementList = forall err strm separtor a.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm separtor
-> HeadedParsec err strm a -> HeadedParsec err strm (NonEmpty a)
sep1 Parser ()
commaSeparator HeadedParsec Void Text TableFuncElement
tableFuncElement

tableFuncElement :: HeadedParsec Void Text TableFuncElement
tableFuncElement = do
  Ident
a <- forall err strm a.
(Ord err, Stream strm) =>
HeadedParsec err strm a -> HeadedParsec err strm a
wrapToHead HeadedParsec Void Text Ident
colId
  forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
  Typename
b <- HeadedParsec Void Text Typename
typename
  Maybe AnyName
c <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text AnyName
collateClause)
  return (Ident -> Typename -> Maybe AnyName -> TableFuncElement
TableFuncElement Ident
a Typename
b Maybe AnyName
c)

collateClause :: HeadedParsec Void Text AnyName
collateClause = forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"collate" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall strm err. Stream strm => HeadedParsec err strm ()
endHead forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text AnyName
anyName

funcAliasClause :: HeadedParsec Void Text FuncAliasClause
funcAliasClause =
  forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
    [ do
        forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"as"
        forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
          [ do
              forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space
              forall a. Parser a -> Parser a
inParens forall a b. (a -> b) -> a -> b
$ do
                forall strm err. Stream strm => HeadedParsec err strm ()
endHead
                ColDefList -> FuncAliasClause
AsFuncAliasClause forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HeadedParsec Void Text ColDefList
tableFuncElementList,
            do
              forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
              Ident
a <- HeadedParsec Void Text Ident
colId
              forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
                [ do
                    forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space
                    forall a. Parser a -> Parser a
inParens forall a b. (a -> b) -> a -> b
$ do
                      forall strm err. Stream strm => HeadedParsec err strm ()
endHead
                      forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
                        [ Ident -> ColDefList -> FuncAliasClause
AsColIdFuncAliasClause Ident
a forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall err strm a.
(Ord err, Stream strm) =>
HeadedParsec err strm a -> HeadedParsec err strm a
wrapToHead HeadedParsec Void Text ColDefList
tableFuncElementList,
                          AliasClause -> FuncAliasClause
AliasFuncAliasClause forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Bool -> Ident -> Maybe (NonEmpty Ident) -> AliasClause
AliasClause Bool
True Ident
a forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. a -> Maybe a
Just forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HeadedParsec Void Text (NonEmpty Ident)
nameList
                        ],
                  forall (f :: * -> *) a. Applicative f => a -> f a
pure (AliasClause -> FuncAliasClause
AliasFuncAliasClause (Bool -> Ident -> Maybe (NonEmpty Ident) -> AliasClause
AliasClause Bool
True Ident
a forall a. Maybe a
Nothing))
                ]
          ],
      do
        Ident
a <- HeadedParsec Void Text Ident
colId
        forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
          [ do
              forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space
              forall a. Parser a -> Parser a
inParens forall a b. (a -> b) -> a -> b
$ do
                forall strm err. Stream strm => HeadedParsec err strm ()
endHead
                forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
                  [ Ident -> ColDefList -> FuncAliasClause
ColIdFuncAliasClause Ident
a forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall err strm a.
(Ord err, Stream strm) =>
HeadedParsec err strm a -> HeadedParsec err strm a
wrapToHead HeadedParsec Void Text ColDefList
tableFuncElementList,
                    AliasClause -> FuncAliasClause
AliasFuncAliasClause forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Bool -> Ident -> Maybe (NonEmpty Ident) -> AliasClause
AliasClause Bool
False Ident
a forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. a -> Maybe a
Just forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HeadedParsec Void Text (NonEmpty Ident)
nameList
                  ],
            forall (f :: * -> *) a. Applicative f => a -> f a
pure (AliasClause -> FuncAliasClause
AliasFuncAliasClause (Bool -> Ident -> Maybe (NonEmpty Ident) -> AliasClause
AliasClause Bool
False Ident
a forall a. Maybe a
Nothing))
          ]
    ]

joinedTable :: HeadedParsec Void Text JoinedTable
joinedTable =
  HeadedParsec Void Text JoinedTable
head forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= JoinedTable -> HeadedParsec Void Text JoinedTable
tail
  where
    head :: HeadedParsec Void Text JoinedTable
head =
      forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
        [ do
            TableRef
tr <- forall err strm a.
(Ord err, Stream strm) =>
HeadedParsec err strm a -> HeadedParsec err strm a
wrapToHead HeadedParsec Void Text TableRef
nonTrailingTableRef
            forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
            TableRef -> HeadedParsec Void Text JoinedTable
trailingJoinedTable TableRef
tr,
          HeadedParsec Void Text JoinedTable
inParensJoinedTable
        ]
    tail :: JoinedTable -> HeadedParsec Void Text JoinedTable
tail JoinedTable
jt =
      forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
        [ do
            JoinedTable
jt2 <- forall err strm a.
(Ord err, Stream strm) =>
HeadedParsec err strm a -> HeadedParsec err strm a
wrapToHead (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> TableRef -> HeadedParsec Void Text JoinedTable
trailingJoinedTable (JoinedTable -> Maybe AliasClause -> TableRef
JoinTableRef JoinedTable
jt forall a. Maybe a
Nothing))
            forall strm err. Stream strm => HeadedParsec err strm ()
endHead
            JoinedTable -> HeadedParsec Void Text JoinedTable
tail JoinedTable
jt2,
          forall (f :: * -> *) a. Applicative f => a -> f a
pure JoinedTable
jt
        ]

-- |
-- ==== References
-- @
--   | '(' joined_table ')'
-- @
inParensJoinedTable :: HeadedParsec Void Text JoinedTable
inParensJoinedTable = JoinedTable -> JoinedTable
InParensJoinedTable forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. Parser a -> Parser a
inParens HeadedParsec Void Text JoinedTable
joinedTable

-- |
-- ==== References
-- @
--   | table_ref CROSS JOIN table_ref
--   | table_ref join_type JOIN table_ref join_qual
--   | table_ref JOIN table_ref join_qual
--   | table_ref NATURAL join_type JOIN table_ref
--   | table_ref NATURAL JOIN table_ref
-- @
trailingJoinedTable :: TableRef -> HeadedParsec Void Text JoinedTable
trailingJoinedTable TableRef
tr1 =
  forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
    [ do
        forall {s} {e}.
(Token s ~ Char, Tokens s ~ Text, Ord e, Stream s,
 FoldCase (Tokens s)) =>
Text -> HeadedParsec e s Text
keyphrase Text
"cross join"
        forall strm err. Stream strm => HeadedParsec err strm ()
endHead
        forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
        TableRef
tr2 <- HeadedParsec Void Text TableRef
nonTrailingTableRef
        return (JoinMeth -> TableRef -> TableRef -> JoinedTable
MethJoinedTable JoinMeth
CrossJoinMeth TableRef
tr1 TableRef
tr2),
      do
        Maybe JoinType
jt <- forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
HeadedParsec e s (Maybe JoinType)
joinTypedJoin
        forall strm err. Stream strm => HeadedParsec err strm ()
endHead
        forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
        TableRef
tr2 <- HeadedParsec Void Text TableRef
tableRef
        forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
        JoinQual
jq <- HeadedParsec Void Text JoinQual
joinQual
        return (JoinMeth -> TableRef -> TableRef -> JoinedTable
MethJoinedTable (Maybe JoinType -> JoinQual -> JoinMeth
QualJoinMeth Maybe JoinType
jt JoinQual
jq) TableRef
tr1 TableRef
tr2),
      do
        forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"natural"
        forall strm err. Stream strm => HeadedParsec err strm ()
endHead
        forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
        Maybe JoinType
jt <- forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
HeadedParsec e s (Maybe JoinType)
joinTypedJoin
        forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
        TableRef
tr2 <- HeadedParsec Void Text TableRef
nonTrailingTableRef
        return (JoinMeth -> TableRef -> TableRef -> JoinedTable
MethJoinedTable (Maybe JoinType -> JoinMeth
NaturalJoinMeth Maybe JoinType
jt) TableRef
tr1 TableRef
tr2)
    ]
  where
    joinTypedJoin :: HeadedParsec e s (Maybe JoinType)
joinTypedJoin =
      forall a. a -> Maybe a
Just forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
HeadedParsec e s JoinType
joinType forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall strm err. Stream strm => HeadedParsec err strm ()
endHead forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"join")
        forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall a. Maybe a
Nothing forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"join"

joinType :: HeadedParsec e s JoinType
joinType =
  forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
    [ do
        forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"full"
        forall strm err. Stream strm => HeadedParsec err strm ()
endHead
        Bool
outer <- forall {strm} {err}.
(Token strm ~ Char, Tokens strm ~ Text, Ord err, Stream strm) =>
HeadedParsec err strm Bool
outerAfterSpace
        return (Bool -> JoinType
FullJoinType Bool
outer),
      do
        forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"left"
        forall strm err. Stream strm => HeadedParsec err strm ()
endHead
        Bool
outer <- forall {strm} {err}.
(Token strm ~ Char, Tokens strm ~ Text, Ord err, Stream strm) =>
HeadedParsec err strm Bool
outerAfterSpace
        return (Bool -> JoinType
LeftJoinType Bool
outer),
      do
        forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"right"
        forall strm err. Stream strm => HeadedParsec err strm ()
endHead
        Bool
outer <- forall {strm} {err}.
(Token strm ~ Char, Tokens strm ~ Text, Ord err, Stream strm) =>
HeadedParsec err strm Bool
outerAfterSpace
        return (Bool -> JoinType
RightJoinType Bool
outer),
      forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"inner" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> JoinType
InnerJoinType
    ]
  where
    outerAfterSpace :: HeadedParsec err strm Bool
outerAfterSpace = (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"outer") forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Bool
True forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (f :: * -> *) a. Applicative f => a -> f a
pure Bool
False

joinQual :: HeadedParsec Void Text JoinQual
joinQual =
  forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
    [ forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"using" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall a. Parser a -> Parser a
inParens (forall err strm separtor a.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm separtor
-> HeadedParsec err strm a -> HeadedParsec err strm (NonEmpty a)
sep1 Parser ()
commaSeparator HeadedParsec Void Text Ident
colId) forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> NonEmpty Ident -> JoinQual
UsingJoinQual,
      forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"on" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text WhereClause
aExpr forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> WhereClause -> JoinQual
OnJoinQual
    ]

aliasClause :: HeadedParsec Void Text AliasClause
aliasClause = do
  (Bool
as, Ident
alias) <- (Bool
True,) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"as" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall strm err. Stream strm => HeadedParsec err strm ()
endHead forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text Ident
colId) forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (Bool
False,) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HeadedParsec Void Text Ident
colId
  Maybe (NonEmpty Ident)
columnAliases <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall a. Parser a -> Parser a
inParens (forall err strm separtor a.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm separtor
-> HeadedParsec err strm a -> HeadedParsec err strm (NonEmpty a)
sep1 Parser ()
commaSeparator HeadedParsec Void Text Ident
colId))
  return (Bool -> Ident -> Maybe (NonEmpty Ident) -> AliasClause
AliasClause Bool
as Ident
alias Maybe (NonEmpty Ident)
columnAliases)

-- * Where

whereClause :: HeadedParsec Void Text WhereClause
whereClause = forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"where" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall strm err. Stream strm => HeadedParsec err strm ()
endHead forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text WhereClause
aExpr

whereOrCurrentClause :: HeadedParsec Void Text WhereOrCurrentClause
whereOrCurrentClause = do
  forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"where"
  forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
  forall strm err. Stream strm => HeadedParsec err strm ()
endHead
  forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
    [ do
        forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"current"
        forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
        forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"of"
        forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
        forall strm err. Stream strm => HeadedParsec err strm ()
endHead
        Ident
a <- HeadedParsec Void Text Ident
cursorName
        return (Ident -> WhereOrCurrentClause
CursorWhereOrCurrentClause Ident
a),
      WhereClause -> WhereOrCurrentClause
ExprWhereOrCurrentClause forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HeadedParsec Void Text WhereClause
aExpr
    ]

-- * Sorting

sortClause :: HeadedParsec Void Text SortClause
sortClause = do
  forall {s} {e}.
(Token s ~ Char, Tokens s ~ Text, Ord e, Stream s,
 FoldCase (Tokens s)) =>
Text -> HeadedParsec e s Text
keyphrase Text
"order by"
  forall strm err. Stream strm => HeadedParsec err strm ()
endHead
  forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
  SortClause
a <- forall err strm separtor a.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm separtor
-> HeadedParsec err strm a -> HeadedParsec err strm (NonEmpty a)
sep1 Parser ()
commaSeparator HeadedParsec Void Text SortBy
sortBy
  return SortClause
a

sortBy :: HeadedParsec Void Text SortBy
sortBy = do
  WhereClause
a <- [Text] -> HeadedParsec Void Text WhereClause
filteredAExpr [Text
"using", Text
"asc", Text
"desc", Text
"nulls"]
  forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
    [ do
        forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
        forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"using"
        forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
        forall strm err. Stream strm => HeadedParsec err strm ()
endHead
        QualAllOp
b <- HeadedParsec Void Text QualAllOp
qualAllOp
        Maybe NullsOrder
c <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
HeadedParsec e s NullsOrder
nullsOrder)
        return (WhereClause -> QualAllOp -> Maybe NullsOrder -> SortBy
UsingSortBy WhereClause
a QualAllOp
b Maybe NullsOrder
c),
      do
        Maybe AscDesc
b <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
HeadedParsec e s AscDesc
ascDesc)
        Maybe NullsOrder
c <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
HeadedParsec e s NullsOrder
nullsOrder)
        return (WhereClause -> Maybe AscDesc -> Maybe NullsOrder -> SortBy
AscDescSortBy WhereClause
a Maybe AscDesc
b Maybe NullsOrder
c)
    ]

-- * Expressions

exprList :: HeadedParsec Void Text ExprList
exprList = forall err strm separtor a.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm separtor
-> HeadedParsec err strm a -> HeadedParsec err strm (NonEmpty a)
sep1 Parser ()
commaSeparator HeadedParsec Void Text WhereClause
aExpr

exprListInParens :: HeadedParsec Void Text ExprList
exprListInParens = forall a. Parser a -> Parser a
inParens HeadedParsec Void Text ExprList
exprList

-- |
-- Notice that the tree constructed by this parser does not reflect
-- the precedence order of Postgres.
-- For the purposes of this library it simply doesn't matter,
-- so we're not bothering with that.
--
-- ==== Composite on the right:
--
-- >>> testParser aExpr "a = b :: int4"
-- SymbolicBinOpAExpr (CExprAExpr (ColumnrefCExpr (Columnref (UnquotedIdent "a") Nothing))) (MathSymbolicExprBinOp EqualsMathOp) (TypecastAExpr (CExprAExpr (ColumnrefCExpr (Columnref (UnquotedIdent "b") Nothing))) (Typename False (GenericTypeSimpleTypename (GenericType (UnquotedIdent "int4") Nothing Nothing)) False Nothing))
--
-- ==== Composite on the left:
--
-- >>> testParser aExpr "a = b :: int4 and c"
-- SymbolicBinOpAExpr (CExprAExpr (ColumnrefCExpr (Columnref (UnquotedIdent "a") Nothing))) (MathSymbolicExprBinOp EqualsMathOp) (AndAExpr (TypecastAExpr (CExprAExpr (ColumnrefCExpr (Columnref (UnquotedIdent "b") Nothing))) (Typename False (GenericTypeSimpleTypename (GenericType (UnquotedIdent "int4") Nothing Nothing)) False Nothing)) (CExprAExpr (ColumnrefCExpr (Columnref (UnquotedIdent "c") Nothing))))
aExpr :: HeadedParsec Void Text WhereClause
aExpr = HeadedParsec Void Text CExpr -> HeadedParsec Void Text WhereClause
customizedAExpr HeadedParsec Void Text CExpr
cExpr

filteredAExpr :: [Text] -> HeadedParsec Void Text WhereClause
filteredAExpr = HeadedParsec Void Text CExpr -> HeadedParsec Void Text WhereClause
customizedAExpr forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. HeadedParsec Void Text Columnref -> HeadedParsec Void Text CExpr
customizedCExpr forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. [Text] -> HeadedParsec Void Text Columnref
filteredColumnref

customizedAExpr :: HeadedParsec Void Text CExpr -> HeadedParsec Void Text WhereClause
customizedAExpr HeadedParsec Void Text CExpr
cExpr = forall (m :: * -> *) a. MonadPlus m => m a -> (a -> m a) -> m a
suffixRec HeadedParsec Void Text WhereClause
base WhereClause -> HeadedParsec Void Text WhereClause
suffix
  where
    aExpr :: HeadedParsec Void Text WhereClause
aExpr = HeadedParsec Void Text CExpr -> HeadedParsec Void Text WhereClause
customizedAExpr HeadedParsec Void Text CExpr
cExpr
    base :: HeadedParsec Void Text WhereClause
base =
      forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
        [ WhereClause
DefaultAExpr forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"default",
          SelectWithParens -> WhereClause
UniqueAExpr forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"unique" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text SelectWithParens
selectWithParens),
          Row -> Row -> WhereClause
OverlapsAExpr forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall err strm a.
(Ord err, Stream strm) =>
HeadedParsec err strm a -> HeadedParsec err strm a
wrapToHead HeadedParsec Void Text Row
row forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"overlaps" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall strm err. Stream strm => HeadedParsec err strm ()
endHead forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text Row
row),
          forall {a} {b}.
HeadedParsec Void Text a
-> (QualOp -> a -> b) -> HeadedParsec Void Text b
qualOpExpr HeadedParsec Void Text WhereClause
aExpr QualOp -> WhereClause -> WhereClause
PrefixQualOpAExpr,
          WhereClause -> WhereClause
PlusAExpr forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall {strm} {err} {b}.
(Token strm ~ Char, Stream strm, Ord err) =>
HeadedParsec err strm b -> HeadedParsec err strm b
plusedExpr HeadedParsec Void Text WhereClause
aExpr,
          WhereClause -> WhereClause
MinusAExpr forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall {strm} {err} {b}.
(Token strm ~ Char, Stream strm, Ord err) =>
HeadedParsec err strm b -> HeadedParsec err strm b
minusedExpr HeadedParsec Void Text WhereClause
aExpr,
          WhereClause -> WhereClause
NotAExpr forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"not" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text WhereClause
aExpr),
          CExpr -> WhereClause
CExprAExpr forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HeadedParsec Void Text CExpr
cExpr
        ]
    suffix :: WhereClause -> HeadedParsec Void Text WhereClause
suffix WhereClause
a =
      forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
        [ do
            forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
            SubqueryOp
b <- forall err strm a.
(Ord err, Stream strm) =>
HeadedParsec err strm a -> HeadedParsec err strm a
wrapToHead HeadedParsec Void Text SubqueryOp
subqueryOp
            forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
            SubType
c <- forall err strm a.
(Ord err, Stream strm) =>
HeadedParsec err strm a -> HeadedParsec err strm a
wrapToHead forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
HeadedParsec e s SubType
subType
            forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space
            Either SelectWithParens WhereClause
d <- forall a b. a -> Either a b
Left forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall err strm a.
(Ord err, Stream strm) =>
HeadedParsec err strm a -> HeadedParsec err strm a
wrapToHead HeadedParsec Void Text SelectWithParens
selectWithParens forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall a b. b -> Either a b
Right forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. Parser a -> Parser a
inParens HeadedParsec Void Text WhereClause
aExpr
            return (WhereClause
-> SubqueryOp
-> SubType
-> Either SelectWithParens WhereClause
-> WhereClause
SubqueryAExpr WhereClause
a SubqueryOp
b SubType
c Either SelectWithParens WhereClause
d),
          forall a. a -> (a -> Typename -> a) -> HeadedParsec Void Text a
typecastExpr WhereClause
a WhereClause -> Typename -> WhereClause
TypecastAExpr,
          WhereClause -> AnyName -> WhereClause
CollateAExpr WhereClause
a forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"collate" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall strm err. Stream strm => HeadedParsec err strm ()
endHead forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text AnyName
anyName),
          WhereClause -> WhereClause -> WhereClause
AtTimeZoneAExpr WhereClause
a forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall {s} {e}.
(Token s ~ Char, Tokens s ~ Text, Ord e, Stream s,
 FoldCase (Tokens s)) =>
Text -> HeadedParsec e s Text
keyphrase Text
"at time zone" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall strm err. Stream strm => HeadedParsec err strm ()
endHead forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text WhereClause
aExpr),
          forall {t} {t} {b}.
t
-> HeadedParsec Void Text t
-> (t -> SymbolicExprBinOp -> t -> b)
-> HeadedParsec Void Text b
symbolicBinOpExpr WhereClause
a HeadedParsec Void Text WhereClause
aExpr WhereClause -> SymbolicExprBinOp -> WhereClause -> WhereClause
SymbolicBinOpAExpr,
          WhereClause -> QualOp -> WhereClause
SuffixQualOpAExpr WhereClause
a forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text QualOp
qualOp),
          WhereClause -> WhereClause -> WhereClause
AndAExpr WhereClause
a forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"and" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall strm err. Stream strm => HeadedParsec err strm ()
endHead forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text WhereClause
aExpr),
          WhereClause -> WhereClause -> WhereClause
OrAExpr WhereClause
a forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"or" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall strm err. Stream strm => HeadedParsec err strm ()
endHead forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text WhereClause
aExpr),
          do
            forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
            Bool
b <- forall a. Parser a -> Parser Bool
trueIfPresent (forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"not" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1)
            VerbalExprBinOp
c <-
              forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
                [ VerbalExprBinOp
LikeVerbalExprBinOp forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"like",
                  VerbalExprBinOp
IlikeVerbalExprBinOp forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"ilike",
                  VerbalExprBinOp
SimilarToVerbalExprBinOp forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Token s ~ Char, Tokens s ~ Text, Ord e, Stream s,
 FoldCase (Tokens s)) =>
Text -> HeadedParsec e s Text
keyphrase Text
"similar to"
                ]
            forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
            forall strm err. Stream strm => HeadedParsec err strm ()
endHead
            WhereClause
d <- HeadedParsec Void Text WhereClause
aExpr
            Maybe WhereClause
e <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"escape" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall strm err. Stream strm => HeadedParsec err strm ()
endHead forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text WhereClause
aExpr)
            return (WhereClause
-> Bool
-> VerbalExprBinOp
-> WhereClause
-> Maybe WhereClause
-> WhereClause
VerbalExprBinOpAExpr WhereClause
a Bool
b VerbalExprBinOp
c WhereClause
d Maybe WhereClause
e),
          do
            forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
            forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"is"
            forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
            forall strm err. Stream strm => HeadedParsec err strm ()
endHead
            Bool
b <- forall a. Parser a -> Parser Bool
trueIfPresent (forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"not" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1)
            AExprReversableOp
c <-
              forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
                [ AExprReversableOp
NullAExprReversableOp forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"null",
                  AExprReversableOp
TrueAExprReversableOp forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"true",
                  AExprReversableOp
FalseAExprReversableOp forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"false",
                  AExprReversableOp
UnknownAExprReversableOp forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"unknown",
                  WhereClause -> AExprReversableOp
DistinctFromAExprReversableOp forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"distinct" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"from" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall strm err. Stream strm => HeadedParsec err strm ()
endHead forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text WhereClause
aExpr),
                  TypeList -> AExprReversableOp
OfAExprReversableOp forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"of" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall strm err. Stream strm => HeadedParsec err strm ()
endHead forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall a. Parser a -> Parser a
inParens HeadedParsec Void Text TypeList
typeList),
                  AExprReversableOp
DocumentAExprReversableOp forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"document"
                ]
            return (WhereClause -> Bool -> AExprReversableOp -> WhereClause
ReversableOpAExpr WhereClause
a Bool
b AExprReversableOp
c),
          do
            forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
            Bool
b <- forall a. Parser a -> Parser Bool
trueIfPresent (forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"not" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1)
            forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"between"
            forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
            forall strm err. Stream strm => HeadedParsec err strm ()
endHead
            BExpr -> WhereClause -> AExprReversableOp
c <-
              forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
                [ BExpr -> WhereClause -> AExprReversableOp
BetweenSymmetricAExprReversableOp forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ (forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"symmetric" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1),
                  Bool -> BExpr -> WhereClause -> AExprReversableOp
BetweenAExprReversableOp Bool
True forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ (forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"asymmetric" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1),
                  forall (f :: * -> *) a. Applicative f => a -> f a
pure (Bool -> BExpr -> WhereClause -> AExprReversableOp
BetweenAExprReversableOp Bool
False)
                ]
            BExpr
d <- HeadedParsec Void Text BExpr
bExpr
            forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
            forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"and"
            forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
            WhereClause
e <- HeadedParsec Void Text WhereClause
aExpr
            return (WhereClause -> Bool -> AExprReversableOp -> WhereClause
ReversableOpAExpr WhereClause
a Bool
b (BExpr -> WhereClause -> AExprReversableOp
c BExpr
d WhereClause
e)),
          do
            forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
            Bool
b <- forall a. Parser a -> Parser Bool
trueIfPresent (forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"not" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1)
            forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"in"
            forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space
            AExprReversableOp
c <- InExpr -> AExprReversableOp
InAExprReversableOp forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HeadedParsec Void Text InExpr
inExpr
            return (WhereClause -> Bool -> AExprReversableOp -> WhereClause
ReversableOpAExpr WhereClause
a Bool
b AExprReversableOp
c),
          WhereClause -> WhereClause
IsnullAExpr WhereClause
a forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"isnull"),
          WhereClause -> WhereClause
NotnullAExpr WhereClause
a forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"notnull")
        ]

bExpr :: HeadedParsec Void Text BExpr
bExpr = HeadedParsec Void Text CExpr -> HeadedParsec Void Text BExpr
customizedBExpr HeadedParsec Void Text CExpr
cExpr

customizedBExpr :: HeadedParsec Void Text CExpr -> HeadedParsec Void Text BExpr
customizedBExpr HeadedParsec Void Text CExpr
cExpr = forall (m :: * -> *) a. MonadPlus m => m a -> (a -> m a) -> m a
suffixRec HeadedParsec Void Text BExpr
base BExpr -> HeadedParsec Void Text BExpr
suffix
  where
    bExpr :: HeadedParsec Void Text BExpr
bExpr = HeadedParsec Void Text CExpr -> HeadedParsec Void Text BExpr
customizedBExpr HeadedParsec Void Text CExpr
cExpr
    base :: HeadedParsec Void Text BExpr
base =
      forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
        [ forall {a} {b}.
HeadedParsec Void Text a
-> (QualOp -> a -> b) -> HeadedParsec Void Text b
qualOpExpr HeadedParsec Void Text BExpr
bExpr QualOp -> BExpr -> BExpr
QualOpBExpr,
          BExpr -> BExpr
PlusBExpr forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall {strm} {err} {b}.
(Token strm ~ Char, Stream strm, Ord err) =>
HeadedParsec err strm b -> HeadedParsec err strm b
plusedExpr HeadedParsec Void Text BExpr
bExpr,
          BExpr -> BExpr
MinusBExpr forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall {strm} {err} {b}.
(Token strm ~ Char, Stream strm, Ord err) =>
HeadedParsec err strm b -> HeadedParsec err strm b
minusedExpr HeadedParsec Void Text BExpr
bExpr,
          CExpr -> BExpr
CExprBExpr forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HeadedParsec Void Text CExpr
cExpr
        ]
    suffix :: BExpr -> HeadedParsec Void Text BExpr
suffix BExpr
a =
      forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
        [ forall a. a -> (a -> Typename -> a) -> HeadedParsec Void Text a
typecastExpr BExpr
a BExpr -> Typename -> BExpr
TypecastBExpr,
          forall {t} {t} {b}.
t
-> HeadedParsec Void Text t
-> (t -> SymbolicExprBinOp -> t -> b)
-> HeadedParsec Void Text b
symbolicBinOpExpr BExpr
a HeadedParsec Void Text BExpr
bExpr BExpr -> SymbolicExprBinOp -> BExpr -> BExpr
SymbolicBinOpBExpr,
          do
            forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
            forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"is"
            forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
            forall strm err. Stream strm => HeadedParsec err strm ()
endHead
            Bool
b <- forall a. Parser a -> Parser Bool
trueIfPresent (forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"not" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1)
            BExprIsOp
c <-
              forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
                [ BExpr -> BExprIsOp
DistinctFromBExprIsOp forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall {s} {e}.
(Token s ~ Char, Tokens s ~ Text, Ord e, Stream s,
 FoldCase (Tokens s)) =>
Text -> HeadedParsec e s Text
keyphrase Text
"distinct from" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall strm err. Stream strm => HeadedParsec err strm ()
endHead forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text BExpr
bExpr),
                  TypeList -> BExprIsOp
OfBExprIsOp forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"of" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall strm err. Stream strm => HeadedParsec err strm ()
endHead forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall a. Parser a -> Parser a
inParens HeadedParsec Void Text TypeList
typeList),
                  BExprIsOp
DocumentBExprIsOp forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"document"
                ]
            return (BExpr -> Bool -> BExprIsOp -> BExpr
IsOpBExpr BExpr
a Bool
b BExprIsOp
c)
        ]

cExpr :: HeadedParsec Void Text CExpr
cExpr = HeadedParsec Void Text Columnref -> HeadedParsec Void Text CExpr
customizedCExpr HeadedParsec Void Text Columnref
columnref

customizedCExpr :: HeadedParsec Void Text Columnref -> HeadedParsec Void Text CExpr
customizedCExpr HeadedParsec Void Text Columnref
columnref =
  forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
    [ Int -> Maybe Indirection -> CExpr
ParamCExpr forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
Char -> HeadedParsec err strm Char
char Char
'$' forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm decimal.
(Ord err, Stream strm, Token strm ~ Char, Integral decimal) =>
HeadedParsec err strm decimal
decimal forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall strm err. Stream strm => HeadedParsec err strm ()
endHead) forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text Indirection
indirection),
      CaseExpr -> CExpr
CaseCExpr forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HeadedParsec Void Text CaseExpr
caseExpr,
      ImplicitRow -> CExpr
ImplicitRowCExpr forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HeadedParsec Void Text ImplicitRow
implicitRow,
      Maybe ExprList -> CExpr
ExplicitRowCExpr forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HeadedParsec Void Text (Maybe ExprList)
explicitRow,
      forall clause content.
Parser clause -> Parser content -> Parser content
inParensWithClause (forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"grouping") (ExprList -> CExpr
GroupingCExpr forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall err strm separtor a.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm separtor
-> HeadedParsec err strm a -> HeadedParsec err strm (NonEmpty a)
sep1 Parser ()
commaSeparator HeadedParsec Void Text WhereClause
aExpr),
      forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"exists" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> (SelectWithParens -> CExpr
ExistsCExpr forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HeadedParsec Void Text SelectWithParens
selectWithParens),
      do
        forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"array"
        forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space
        forall (m :: * -> *) a. Monad m => m (m a) -> m a
join
          forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
            [ forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Either SelectWithParens ArrayExpr -> CExpr
ArrayCExpr forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall a b. b -> Either a b
Right)) HeadedParsec Void Text (HeadedParsec Void Text ArrayExpr)
arrayExprCont,
              forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Either SelectWithParens ArrayExpr -> CExpr
ArrayCExpr forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall a b. a -> Either a b
Left) forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall (f :: * -> *) a. Applicative f => a -> f a
pure) HeadedParsec Void Text SelectWithParens
selectWithParens
            ],
      do
        SelectWithParens
a <- forall err strm a.
(Ord err, Stream strm) =>
HeadedParsec err strm a -> HeadedParsec err strm a
wrapToHead HeadedParsec Void Text SelectWithParens
selectWithParens
        forall strm err. Stream strm => HeadedParsec err strm ()
endHead
        Maybe Indirection
b <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text Indirection
indirection)
        return (SelectWithParens -> Maybe Indirection -> CExpr
SelectWithParensCExpr SelectWithParens
a Maybe Indirection
b),
      WhereClause -> Maybe Indirection -> CExpr
InParensCExpr forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall a. Parser a -> Parser a
inParens HeadedParsec Void Text WhereClause
aExpr forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall strm err. Stream strm => HeadedParsec err strm ()
endHead) forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text Indirection
indirection),
      AexprConst -> CExpr
AexprConstCExpr forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall err strm a.
(Ord err, Stream strm) =>
HeadedParsec err strm a -> HeadedParsec err strm a
wrapToHead HeadedParsec Void Text AexprConst
aexprConst,
      FuncExpr -> CExpr
FuncCExpr forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HeadedParsec Void Text FuncExpr
funcExpr,
      Columnref -> CExpr
ColumnrefCExpr forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HeadedParsec Void Text Columnref
columnref
    ]

subqueryOp :: HeadedParsec Void Text SubqueryOp
subqueryOp =
  forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
    [ AnyOperator -> SubqueryOp
AnySubqueryOp forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"operator" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall strm err. Stream strm => HeadedParsec err strm ()
endHead forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall a. Parser a -> Parser a
inParens HeadedParsec Void Text AnyOperator
anyOperator),
      do
        Bool
a <- forall a. Parser a -> Parser Bool
trueIfPresent (forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"not" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1)
        Bool -> SubqueryOp
LikeSubqueryOp Bool
a forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"like" forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Bool -> SubqueryOp
IlikeSubqueryOp Bool
a forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"ilike",
      AllOp -> SubqueryOp
AllSubqueryOp forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall {strm} {err}.
(Tokens strm ~ Text, Token strm ~ Char, Ord err, Stream strm,
 FoldCase (Tokens strm), IsString (Tokens strm)) =>
HeadedParsec err strm AllOp
allOp
    ]

subType :: HeadedParsec e s SubType
subType =
  forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
    [ SubType
AnySubType forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"any",
      SubType
SomeSubType forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"some",
      SubType
AllSubType forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"all"
    ]

inExpr :: HeadedParsec Void Text InExpr
inExpr = SelectWithParens -> InExpr
SelectInExpr forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall err strm a.
(Ord err, Stream strm) =>
HeadedParsec err strm a -> HeadedParsec err strm a
wrapToHead HeadedParsec Void Text SelectWithParens
selectWithParens forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ExprList -> InExpr
ExprListInExpr forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. Parser a -> Parser a
inParens HeadedParsec Void Text ExprList
exprList

symbolicBinOpExpr :: t
-> HeadedParsec Void Text t
-> (t -> SymbolicExprBinOp -> t -> b)
-> HeadedParsec Void Text b
symbolicBinOpExpr t
a HeadedParsec Void Text t
bParser t -> SymbolicExprBinOp -> t -> b
constr = do
  SymbolicExprBinOp
binOp <- forall err strm a.
(Ord err, Stream strm) =>
String -> HeadedParsec err strm a -> HeadedParsec err strm a
label String
"binary operator" (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm a.
(Ord err, Stream strm) =>
HeadedParsec err strm a -> HeadedParsec err strm a
wrapToHead HeadedParsec Void Text SymbolicExprBinOp
symbolicExprBinOp forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space)
  t
b <- HeadedParsec Void Text t
bParser
  return (t -> SymbolicExprBinOp -> t -> b
constr t
a SymbolicExprBinOp
binOp t
b)

typecastExpr :: a -> (a -> Typename -> a) -> HeadedParsec Void Text a
typecastExpr :: forall a. a -> (a -> Typename -> a) -> HeadedParsec Void Text a
typecastExpr a
prefix a -> Typename -> a
constr = do
  forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space
  forall err strm.
(Ord err, Stream strm) =>
Tokens strm -> HeadedParsec err strm (Tokens strm)
string Text
"::"
  forall strm err. Stream strm => HeadedParsec err strm ()
endHead
  forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space
  Typename
type' <- HeadedParsec Void Text Typename
typename
  return (a -> Typename -> a
constr a
prefix Typename
type')

plusedExpr :: HeadedParsec err strm b -> HeadedParsec err strm b
plusedExpr HeadedParsec err strm b
expr = forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
Char -> HeadedParsec err strm Char
char Char
'+' forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec err strm b
expr

minusedExpr :: HeadedParsec err strm b -> HeadedParsec err strm b
minusedExpr HeadedParsec err strm b
expr = forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
Char -> HeadedParsec err strm Char
char Char
'-' forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec err strm b
expr

qualOpExpr :: HeadedParsec Void Text a
-> (QualOp -> a -> b) -> HeadedParsec Void Text b
qualOpExpr HeadedParsec Void Text a
expr QualOp -> a -> b
constr = QualOp -> a -> b
constr forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall err strm a.
(Ord err, Stream strm) =>
HeadedParsec err strm a -> HeadedParsec err strm a
wrapToHead HeadedParsec Void Text QualOp
qualOp forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text a
expr)

row :: HeadedParsec Void Text Row
row = Maybe ExprList -> Row
ExplicitRowRow forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HeadedParsec Void Text (Maybe ExprList)
explicitRow forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ImplicitRow -> Row
ImplicitRowRow forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HeadedParsec Void Text ImplicitRow
implicitRow

explicitRow :: HeadedParsec Void Text (Maybe ExprList)
explicitRow = forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"row" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall a. Parser a -> Parser a
inParens (forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional HeadedParsec Void Text ExprList
exprList)

implicitRow :: HeadedParsec Void Text ImplicitRow
implicitRow = forall a. Parser a -> Parser a
inParens forall a b. (a -> b) -> a -> b
$ do
  WhereClause
a <- forall err strm a.
(Ord err, Stream strm) =>
HeadedParsec err strm a -> HeadedParsec err strm a
wrapToHead HeadedParsec Void Text WhereClause
aExpr
  Parser ()
commaSeparator
  ExprList
b <- HeadedParsec Void Text ExprList
exprList
  return $ case forall a. a -> NonEmpty a -> (NonEmpty a, a)
NonEmpty.consAndUnsnoc WhereClause
a ExprList
b of
    (ExprList
c, WhereClause
d) -> ExprList -> WhereClause -> ImplicitRow
ImplicitRow ExprList
c WhereClause
d

arrayExprCont :: HeadedParsec Void Text (HeadedParsec Void Text ArrayExpr)
arrayExprCont =
  forall a. Parser a -> Parser (Parser a)
inBracketsCont
    forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
      [ ArrayExprList -> ArrayExpr
ArrayExprListArrayExpr forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall err strm separtor a.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm separtor
-> HeadedParsec err strm a -> HeadedParsec err strm (NonEmpty a)
sep1 Parser ()
commaSeparator (forall (m :: * -> *) a. Monad m => m (m a) -> m a
join HeadedParsec Void Text (HeadedParsec Void Text ArrayExpr)
arrayExprCont),
        ExprList -> ArrayExpr
ExprListArrayExpr forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HeadedParsec Void Text ExprList
exprList,
        forall (f :: * -> *) a. Applicative f => a -> f a
pure ArrayExpr
EmptyArrayExpr
      ]

caseExpr :: HeadedParsec Void Text CaseExpr
caseExpr = forall err strm a.
(Ord err, Stream strm) =>
String -> HeadedParsec err strm a -> HeadedParsec err strm a
label String
"case expression" forall a b. (a -> b) -> a -> b
$ do
  forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"case"
  forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
  forall strm err. Stream strm => HeadedParsec err strm ()
endHead
  Maybe WhereClause
arg <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (HeadedParsec Void Text WhereClause
aExpr forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1)
  NonEmpty WhenClause
whenClauses <- forall err strm separtor a.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm separtor
-> HeadedParsec err strm a -> HeadedParsec err strm (NonEmpty a)
sep1 forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 HeadedParsec Void Text WhenClause
whenClause
  forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
  Maybe WhereClause
default' <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional HeadedParsec Void Text WhereClause
elseClause
  forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"end"
  pure $ Maybe WhereClause
-> NonEmpty WhenClause -> Maybe WhereClause -> CaseExpr
CaseExpr Maybe WhereClause
arg NonEmpty WhenClause
whenClauses Maybe WhereClause
default'

whenClause :: HeadedParsec Void Text WhenClause
whenClause = do
  forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"when"
  forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
  forall strm err. Stream strm => HeadedParsec err strm ()
endHead
  WhereClause
a <- HeadedParsec Void Text WhereClause
aExpr
  forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
  forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"then"
  forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
  WhereClause
b <- HeadedParsec Void Text WhereClause
aExpr
  return (WhereClause -> WhereClause -> WhenClause
WhenClause WhereClause
a WhereClause
b)

elseClause :: HeadedParsec Void Text WhereClause
elseClause = do
  forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"else"
  forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
  forall strm err. Stream strm => HeadedParsec err strm ()
endHead
  WhereClause
a <- HeadedParsec Void Text WhereClause
aExpr
  forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
  return WhereClause
a

funcExpr :: HeadedParsec Void Text FuncExpr
funcExpr =
  forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
    [ FuncExprCommonSubexpr -> FuncExpr
SubexprFuncExpr forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HeadedParsec Void Text FuncExprCommonSubexpr
funcExprCommonSubexpr,
      do
        FuncApplication
a <- HeadedParsec Void Text FuncApplication
funcApplication
        forall strm err. Stream strm => HeadedParsec err strm ()
endHead
        Maybe SortClause
b <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text SortClause
withinGroupClause)
        Maybe WhereClause
c <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text WhereClause
filterClause)
        Maybe OverClause
d <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text OverClause
overClause)
        return (FuncApplication
-> Maybe SortClause
-> Maybe WhereClause
-> Maybe OverClause
-> FuncExpr
ApplicationFuncExpr FuncApplication
a Maybe SortClause
b Maybe WhereClause
c Maybe OverClause
d)
    ]

funcExprWindowless :: HeadedParsec Void Text FuncExprWindowless
funcExprWindowless =
  forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
    [ FuncExprCommonSubexpr -> FuncExprWindowless
CommonSubexprFuncExprWindowless forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HeadedParsec Void Text FuncExprCommonSubexpr
funcExprCommonSubexpr,
      FuncApplication -> FuncExprWindowless
ApplicationFuncExprWindowless forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HeadedParsec Void Text FuncApplication
funcApplication
    ]

withinGroupClause :: HeadedParsec Void Text SortClause
withinGroupClause = do
  forall {s} {e}.
(Token s ~ Char, Tokens s ~ Text, Ord e, Stream s,
 FoldCase (Tokens s)) =>
Text -> HeadedParsec e s Text
keyphrase Text
"within group"
  forall strm err. Stream strm => HeadedParsec err strm ()
endHead
  forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space
  forall a. Parser a -> Parser a
inParens HeadedParsec Void Text SortClause
sortClause

filterClause :: HeadedParsec Void Text WhereClause
filterClause = do
  forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"filter"
  forall strm err. Stream strm => HeadedParsec err strm ()
endHead
  forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space
  forall a. Parser a -> Parser a
inParens (forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"where" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text WhereClause
aExpr)

overClause :: HeadedParsec Void Text OverClause
overClause = do
  forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"over"
  forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
  forall strm err. Stream strm => HeadedParsec err strm ()
endHead
  forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
    [ WindowSpecification -> OverClause
WindowOverClause forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HeadedParsec Void Text WindowSpecification
windowSpecification,
      Ident -> OverClause
ColIdOverClause forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HeadedParsec Void Text Ident
colId
    ]

funcExprCommonSubexpr :: HeadedParsec Void Text FuncExprCommonSubexpr
funcExprCommonSubexpr =
  forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
    [ WhereClause -> FuncExprCommonSubexpr
CollationForFuncExprCommonSubexpr forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall clause content.
Parser clause -> Parser content -> Parser content
inParensWithClause (forall {s} {e}.
(Token s ~ Char, Tokens s ~ Text, Ord e, Stream s,
 FoldCase (Tokens s)) =>
Text -> HeadedParsec e s Text
keyphrase Text
"collation for") HeadedParsec Void Text WhereClause
aExpr),
      FuncExprCommonSubexpr
CurrentDateFuncExprCommonSubexpr forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"current_date",
      Maybe Int64 -> FuncExprCommonSubexpr
CurrentTimestampFuncExprCommonSubexpr forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall {a}. Integral a => Text -> HeadedParsec Void Text (Maybe a)
labeledIconst Text
"current_timestamp",
      Maybe Int64 -> FuncExprCommonSubexpr
CurrentTimeFuncExprCommonSubexpr forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall {a}. Integral a => Text -> HeadedParsec Void Text (Maybe a)
labeledIconst Text
"current_time",
      Maybe Int64 -> FuncExprCommonSubexpr
LocalTimestampFuncExprCommonSubexpr forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall {a}. Integral a => Text -> HeadedParsec Void Text (Maybe a)
labeledIconst Text
"localtimestamp",
      Maybe Int64 -> FuncExprCommonSubexpr
LocalTimeFuncExprCommonSubexpr forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall {a}. Integral a => Text -> HeadedParsec Void Text (Maybe a)
labeledIconst Text
"localtime",
      FuncExprCommonSubexpr
CurrentRoleFuncExprCommonSubexpr forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"current_role",
      FuncExprCommonSubexpr
CurrentUserFuncExprCommonSubexpr forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"current_user",
      FuncExprCommonSubexpr
SessionUserFuncExprCommonSubexpr forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"session_user",
      FuncExprCommonSubexpr
UserFuncExprCommonSubexpr forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"user",
      FuncExprCommonSubexpr
CurrentCatalogFuncExprCommonSubexpr forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"current_catalog",
      FuncExprCommonSubexpr
CurrentSchemaFuncExprCommonSubexpr forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"current_schema",
      forall clause content.
Parser clause -> Parser content -> Parser content
inParensWithClause (forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"cast") (WhereClause -> Typename -> FuncExprCommonSubexpr
CastFuncExprCommonSubexpr forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HeadedParsec Void Text WhereClause
aExpr forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"as" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text Typename
typename)),
      forall clause content.
Parser clause -> Parser content -> Parser content
inParensWithClause (forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"extract") (Maybe ExtractList -> FuncExprCommonSubexpr
ExtractFuncExprCommonSubexpr forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional HeadedParsec Void Text ExtractList
extractList),
      forall clause content.
Parser clause -> Parser content -> Parser content
inParensWithClause (forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"overlay") (OverlayList -> FuncExprCommonSubexpr
OverlayFuncExprCommonSubexpr forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HeadedParsec Void Text OverlayList
overlayList),
      forall clause content.
Parser clause -> Parser content -> Parser content
inParensWithClause (forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"position") (Maybe PositionList -> FuncExprCommonSubexpr
PositionFuncExprCommonSubexpr forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional HeadedParsec Void Text PositionList
positionList),
      forall clause content.
Parser clause -> Parser content -> Parser content
inParensWithClause (forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"substring") (Maybe SubstrList -> FuncExprCommonSubexpr
SubstringFuncExprCommonSubexpr forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional HeadedParsec Void Text SubstrList
substrList),
      forall clause content.
Parser clause -> Parser content -> Parser content
inParensWithClause (forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"treat") (WhereClause -> Typename -> FuncExprCommonSubexpr
TreatFuncExprCommonSubexpr forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HeadedParsec Void Text WhereClause
aExpr forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"as" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text Typename
typename)),
      forall clause content.
Parser clause -> Parser content -> Parser content
inParensWithClause (forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"trim") (Maybe TrimModifier -> TrimList -> FuncExprCommonSubexpr
TrimFuncExprCommonSubexpr forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
HeadedParsec e s TrimModifier
trimModifier forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1) forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> HeadedParsec Void Text TrimList
trimList),
      forall clause content.
Parser clause -> Parser content -> Parser content
inParensWithClause (forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"nullif") (WhereClause -> WhereClause -> FuncExprCommonSubexpr
NullIfFuncExprCommonSubexpr forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HeadedParsec Void Text WhereClause
aExpr forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Parser ()
commaSeparator forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text WhereClause
aExpr)),
      forall clause content.
Parser clause -> Parser content -> Parser content
inParensWithClause (forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"coalesce") (ExprList -> FuncExprCommonSubexpr
CoalesceFuncExprCommonSubexpr forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HeadedParsec Void Text ExprList
exprList),
      forall clause content.
Parser clause -> Parser content -> Parser content
inParensWithClause (forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"greatest") (ExprList -> FuncExprCommonSubexpr
GreatestFuncExprCommonSubexpr forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HeadedParsec Void Text ExprList
exprList),
      forall clause content.
Parser clause -> Parser content -> Parser content
inParensWithClause (forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"least") (ExprList -> FuncExprCommonSubexpr
LeastFuncExprCommonSubexpr forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HeadedParsec Void Text ExprList
exprList)
    ]
  where
    labeledIconst :: Text -> HeadedParsec Void Text (Maybe a)
labeledIconst Text
label = forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
label forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall strm err. Stream strm => HeadedParsec err strm ()
endHead forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall a. Parser a -> Parser a
inParens forall {strm} {decimal} {err}.
(Token strm ~ Char, Stream strm, Integral decimal, Ord err) =>
HeadedParsec err strm decimal
iconst)

extractList :: HeadedParsec Void Text ExtractList
extractList = ExtractArg -> WhereClause -> ExtractList
ExtractList forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HeadedParsec Void Text ExtractArg
extractArg forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"from" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text WhereClause
aExpr)

extractArg :: HeadedParsec Void Text ExtractArg
extractArg =
  forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
    [ ExtractArg
YearExtractArg forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"year",
      ExtractArg
MonthExtractArg forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"month",
      ExtractArg
DayExtractArg forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"day",
      ExtractArg
HourExtractArg forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"hour",
      ExtractArg
MinuteExtractArg forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"minute",
      ExtractArg
SecondExtractArg forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"second",
      Text -> ExtractArg
SconstExtractArg forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Text
sconst,
      Ident -> ExtractArg
IdentExtractArg forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HeadedParsec Void Text Ident
ident
    ]

overlayList :: HeadedParsec Void Text OverlayList
overlayList = do
  WhereClause
a <- HeadedParsec Void Text WhereClause
aExpr
  forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
  WhereClause
b <- HeadedParsec Void Text WhereClause
overlayPlacing
  forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
  WhereClause
c <- HeadedParsec Void Text WhereClause
substrFrom
  Maybe WhereClause
d <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text WhereClause
substrFor)
  return (WhereClause
-> WhereClause -> WhereClause -> Maybe WhereClause -> OverlayList
OverlayList WhereClause
a WhereClause
b WhereClause
c Maybe WhereClause
d)

overlayPlacing :: HeadedParsec Void Text WhereClause
overlayPlacing = forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"placing" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall strm err. Stream strm => HeadedParsec err strm ()
endHead forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text WhereClause
aExpr

positionList :: HeadedParsec Void Text PositionList
positionList = BExpr -> BExpr -> PositionList
PositionList forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HeadedParsec Void Text BExpr
bExpr forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"in" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text BExpr
bExpr)

substrList :: HeadedParsec Void Text SubstrList
substrList =
  forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
    [ WhereClause -> SubstrListFromFor -> SubstrList
ExprSubstrList forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall err strm a.
(Ord err, Stream strm) =>
HeadedParsec err strm a -> HeadedParsec err strm a
wrapToHead HeadedParsec Void Text WhereClause
aExpr forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text SubstrListFromFor
substrListFromFor),
      ExprList -> SubstrList
ExprListSubstrList forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HeadedParsec Void Text ExprList
exprList
    ]

substrListFromFor :: HeadedParsec Void Text SubstrListFromFor
substrListFromFor =
  forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
    [ do
        WhereClause
a <- HeadedParsec Void Text WhereClause
substrFrom
        forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
          [ do
              WhereClause
b <- forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text WhereClause
substrFor
              return (WhereClause -> WhereClause -> SubstrListFromFor
FromForSubstrListFromFor WhereClause
a WhereClause
b),
            forall (m :: * -> *) a. Monad m => a -> m a
return (WhereClause -> SubstrListFromFor
FromSubstrListFromFor WhereClause
a)
          ],
      do
        WhereClause
a <- HeadedParsec Void Text WhereClause
substrFor
        forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
          [ do
              WhereClause
b <- forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text WhereClause
substrFrom
              return (WhereClause -> WhereClause -> SubstrListFromFor
ForFromSubstrListFromFor WhereClause
a WhereClause
b),
            forall (m :: * -> *) a. Monad m => a -> m a
return (WhereClause -> SubstrListFromFor
ForSubstrListFromFor WhereClause
a)
          ]
    ]

substrFrom :: HeadedParsec Void Text WhereClause
substrFrom = forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"from" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall strm err. Stream strm => HeadedParsec err strm ()
endHead forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text WhereClause
aExpr

substrFor :: HeadedParsec Void Text WhereClause
substrFor = forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"for" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall strm err. Stream strm => HeadedParsec err strm ()
endHead forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text WhereClause
aExpr

trimModifier :: HeadedParsec e s TrimModifier
trimModifier =
  TrimModifier
BothTrimModifier forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"both"
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> TrimModifier
LeadingTrimModifier forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"leading"
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> TrimModifier
TrailingTrimModifier forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"trailing"

trimList :: HeadedParsec Void Text TrimList
trimList =
  forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
    [ WhereClause -> ExprList -> TrimList
ExprFromExprListTrimList forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall err strm a.
(Ord err, Stream strm) =>
HeadedParsec err strm a -> HeadedParsec err strm a
wrapToHead HeadedParsec Void Text WhereClause
aExpr forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"from" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall strm err. Stream strm => HeadedParsec err strm ()
endHead forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text ExprList
exprList),
      ExprList -> TrimList
FromExprListTrimList forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"from" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall strm err. Stream strm => HeadedParsec err strm ()
endHead forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text ExprList
exprList),
      ExprList -> TrimList
ExprListTrimList forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HeadedParsec Void Text ExprList
exprList
    ]

funcApplication :: HeadedParsec Void Text FuncApplication
funcApplication = forall label content result.
(label -> content -> result)
-> Parser label -> Parser content -> Parser result
inParensWithLabel FuncName -> Maybe FuncApplicationParams -> FuncApplication
FuncApplication Parser FuncName
funcName (forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional HeadedParsec Void Text FuncApplicationParams
funcApplicationParams)

funcApplicationParams :: HeadedParsec Void Text FuncApplicationParams
funcApplicationParams =
  forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
    [ forall {strm} {err}.
(Token strm ~ Char, Stream strm, Ord err) =>
HeadedParsec err strm FuncApplicationParams
starFuncApplicationParams,
      HeadedParsec Void Text FuncApplicationParams
listVariadicFuncApplicationParams,
      HeadedParsec Void Text FuncApplicationParams
singleVariadicFuncApplicationParams,
      HeadedParsec Void Text FuncApplicationParams
normalFuncApplicationParams
    ]

normalFuncApplicationParams :: HeadedParsec Void Text FuncApplicationParams
normalFuncApplicationParams = do
  Maybe Bool
optAllOrDistinct <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
HeadedParsec e s Bool
allOrDistinct forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1)
  NonEmpty FuncArgExpr
argList <- forall err strm separtor a.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm separtor
-> HeadedParsec err strm a -> HeadedParsec err strm (NonEmpty a)
sep1 Parser ()
commaSeparator HeadedParsec Void Text FuncArgExpr
funcArgExpr
  forall strm err. Stream strm => HeadedParsec err strm ()
endHead
  Maybe SortClause
optSortClause <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text SortClause
sortClause)
  return (Maybe Bool
-> NonEmpty FuncArgExpr
-> Maybe SortClause
-> FuncApplicationParams
NormalFuncApplicationParams Maybe Bool
optAllOrDistinct NonEmpty FuncArgExpr
argList Maybe SortClause
optSortClause)

singleVariadicFuncApplicationParams :: HeadedParsec Void Text FuncApplicationParams
singleVariadicFuncApplicationParams = do
  forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"variadic"
  forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
  forall strm err. Stream strm => HeadedParsec err strm ()
endHead
  FuncArgExpr
arg <- HeadedParsec Void Text FuncArgExpr
funcArgExpr
  Maybe SortClause
optSortClause <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text SortClause
sortClause)
  return (Maybe (NonEmpty FuncArgExpr)
-> FuncArgExpr -> Maybe SortClause -> FuncApplicationParams
VariadicFuncApplicationParams forall a. Maybe a
Nothing FuncArgExpr
arg Maybe SortClause
optSortClause)

listVariadicFuncApplicationParams :: HeadedParsec Void Text FuncApplicationParams
listVariadicFuncApplicationParams = do
  (NonEmpty FuncArgExpr
argList, Text
_) <- forall err strm a.
(Ord err, Stream strm) =>
HeadedParsec err strm a -> HeadedParsec err strm a
wrapToHead forall a b. (a -> b) -> a -> b
$ forall err strm separator end el.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm separator
-> HeadedParsec err strm end
-> HeadedParsec err strm el
-> HeadedParsec err strm (NonEmpty el, end)
sepEnd1 Parser ()
commaSeparator (forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"variadic" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1) HeadedParsec Void Text FuncArgExpr
funcArgExpr
  forall strm err. Stream strm => HeadedParsec err strm ()
endHead
  FuncArgExpr
arg <- HeadedParsec Void Text FuncArgExpr
funcArgExpr
  Maybe SortClause
optSortClause <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text SortClause
sortClause)
  return (Maybe (NonEmpty FuncArgExpr)
-> FuncArgExpr -> Maybe SortClause -> FuncApplicationParams
VariadicFuncApplicationParams (forall a. a -> Maybe a
Just NonEmpty FuncArgExpr
argList) FuncArgExpr
arg Maybe SortClause
optSortClause)

starFuncApplicationParams :: HeadedParsec err strm FuncApplicationParams
starFuncApplicationParams = forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
Char -> HeadedParsec err strm Char
char Char
'*' forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall strm err. Stream strm => HeadedParsec err strm ()
endHead forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> FuncApplicationParams
StarFuncApplicationParams

-- |
-- ==== References
-- @
-- func_arg_expr:
--   | a_expr
--   | param_name COLON_EQUALS a_expr
--   | param_name EQUALS_GREATER a_expr
-- param_name:
--   | type_function_name
-- @
funcArgExpr :: HeadedParsec Void Text FuncArgExpr
funcArgExpr =
  forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
    [ do
        Ident
a <- forall err strm a.
(Ord err, Stream strm) =>
HeadedParsec err strm a -> HeadedParsec err strm a
wrapToHead HeadedParsec Void Text Ident
typeFunctionName
        forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space
        forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
          [ do
              forall err strm.
(Ord err, Stream strm) =>
Tokens strm -> HeadedParsec err strm (Tokens strm)
string Text
":="
              forall strm err. Stream strm => HeadedParsec err strm ()
endHead
              WhereClause
b <- forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text WhereClause
aExpr
              return (Ident -> WhereClause -> FuncArgExpr
ColonEqualsFuncArgExpr Ident
a WhereClause
b),
            do
              forall err strm.
(Ord err, Stream strm) =>
Tokens strm -> HeadedParsec err strm (Tokens strm)
string Text
"=>"
              forall strm err. Stream strm => HeadedParsec err strm ()
endHead
              WhereClause
b <- forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text WhereClause
aExpr
              return (Ident -> WhereClause -> FuncArgExpr
EqualsGreaterFuncArgExpr Ident
a WhereClause
b)
          ],
      WhereClause -> FuncArgExpr
ExprFuncArgExpr forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HeadedParsec Void Text WhereClause
aExpr
    ]

-- * Ops

symbolicExprBinOp :: HeadedParsec Void Text SymbolicExprBinOp
symbolicExprBinOp =
  QualOp -> SymbolicExprBinOp
QualSymbolicExprBinOp forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HeadedParsec Void Text QualOp
qualOp
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> MathOp -> SymbolicExprBinOp
MathSymbolicExprBinOp forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall {strm} {err}.
(Token strm ~ Char, Stream strm, FoldCase (Tokens strm),
 IsString (Tokens strm), Ord err) =>
HeadedParsec err strm MathOp
mathOp

lexicalExprBinOp :: HeadedParsec e s Text
lexicalExprBinOp = forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum forall a b. (a -> b) -> a -> b
$ forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall {s} {e}.
(Token s ~ Char, Tokens s ~ Text, Ord e, Stream s,
 FoldCase (Tokens s)) =>
Text -> HeadedParsec e s Text
keyphrase forall a b. (a -> b) -> a -> b
$ [Text
"and", Text
"or", Text
"is distinct from", Text
"is not distinct from"]

qualOp :: HeadedParsec Void Text QualOp
qualOp =
  forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
    [ Text -> QualOp
OpQualOp forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
HeadedParsec e s Text
op,
      AnyOperator -> QualOp
OperatorQualOp forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall clause content.
Parser clause -> Parser content -> Parser content
inParensWithClause (forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"operator") HeadedParsec Void Text AnyOperator
anyOperator
    ]

qualAllOp :: HeadedParsec Void Text QualAllOp
qualAllOp =
  forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
    [ AnyOperator -> QualAllOp
AnyQualAllOp forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"operator" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall a. Parser a -> Parser a
inParens (forall strm err. Stream strm => HeadedParsec err strm ()
endHead forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text AnyOperator
anyOperator)),
      AllOp -> QualAllOp
AllQualAllOp forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall {strm} {err}.
(Tokens strm ~ Text, Token strm ~ Char, Ord err, Stream strm,
 FoldCase (Tokens strm), IsString (Tokens strm)) =>
HeadedParsec err strm AllOp
allOp
    ]

op :: HeadedParsec err strm Text
op = do
  Text
a <- forall err strm.
(Ord err, Stream strm) =>
Maybe String
-> (Token strm -> Bool) -> HeadedParsec err strm (Tokens strm)
takeWhile1P forall a. Maybe a
Nothing Char -> Bool
Predicate.opChar
  case Text -> Maybe Text
Validation.op Text
a of
    Maybe Text
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return Text
a
    Just Text
err -> forall (m :: * -> *) a. MonadFail m => String -> m a
fail (Text -> String
Text.unpack Text
err)

anyOperator :: HeadedParsec Void Text AnyOperator
anyOperator =
  forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
    [ AllOp -> AnyOperator
AllOpAnyOperator forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall {strm} {err}.
(Tokens strm ~ Text, Token strm ~ Char, Ord err, Stream strm,
 FoldCase (Tokens strm), IsString (Tokens strm)) =>
HeadedParsec err strm AllOp
allOp,
      Ident -> AnyOperator -> AnyOperator
QualifiedAnyOperator forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HeadedParsec Void Text Ident
colId forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
Char -> HeadedParsec err strm Char
char Char
'.' forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text AnyOperator
anyOperator)
    ]

allOp :: HeadedParsec err strm AllOp
allOp =
  forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
    [ Text -> AllOp
OpAllOp forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
HeadedParsec e s Text
op,
      MathOp -> AllOp
MathAllOp forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall {strm} {err}.
(Token strm ~ Char, Stream strm, FoldCase (Tokens strm),
 IsString (Tokens strm), Ord err) =>
HeadedParsec err strm MathOp
mathOp
    ]

mathOp :: HeadedParsec err strm MathOp
mathOp =
  forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
    [ MathOp
ArrowLeftArrowRightMathOp forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall err strm.
(Ord err, Stream strm, FoldCase (Tokens strm)) =>
Tokens strm -> HeadedParsec err strm (Tokens strm)
string' Tokens strm
"<>",
      MathOp
GreaterEqualsMathOp forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall err strm.
(Ord err, Stream strm, FoldCase (Tokens strm)) =>
Tokens strm -> HeadedParsec err strm (Tokens strm)
string' Tokens strm
">=",
      MathOp
ExclamationEqualsMathOp forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall err strm.
(Ord err, Stream strm, FoldCase (Tokens strm)) =>
Tokens strm -> HeadedParsec err strm (Tokens strm)
string' Tokens strm
"!=",
      MathOp
LessEqualsMathOp forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall err strm.
(Ord err, Stream strm, FoldCase (Tokens strm)) =>
Tokens strm -> HeadedParsec err strm (Tokens strm)
string' Tokens strm
"<=",
      MathOp
PlusMathOp forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
Char -> HeadedParsec err strm Char
char Char
'+',
      MathOp
MinusMathOp forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
Char -> HeadedParsec err strm Char
char Char
'-',
      MathOp
AsteriskMathOp forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
Char -> HeadedParsec err strm Char
char Char
'*',
      MathOp
SlashMathOp forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
Char -> HeadedParsec err strm Char
char Char
'/',
      MathOp
PercentMathOp forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
Char -> HeadedParsec err strm Char
char Char
'%',
      MathOp
ArrowUpMathOp forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
Char -> HeadedParsec err strm Char
char Char
'^',
      MathOp
ArrowLeftMathOp forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
Char -> HeadedParsec err strm Char
char Char
'<',
      MathOp
ArrowRightMathOp forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
Char -> HeadedParsec err strm Char
char Char
'>',
      MathOp
EqualsMathOp forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
Char -> HeadedParsec err strm Char
char Char
'='
    ]

-- * Constants

-- |
-- >>> testParser aexprConst "32948023849023"
-- IAexprConst 32948023849023
--
-- >>> testParser aexprConst "'abc''de'"
-- SAexprConst "abc'de"
--
-- >>> testParser aexprConst "23.43234"
-- FAexprConst 23.43234
--
-- >>> testParser aexprConst "32423423.324324872"
-- FAexprConst 3.2423423324324872e7
--
-- >>> testParser aexprConst "NULL"
-- NullAexprConst
--
-- ==== References
-- @
-- AexprConst: Iconst
--       | FCONST
--       | Sconst
--       | BCONST
--       | XCONST
--       | func_name Sconst
--       | func_name '(' func_arg_list opt_sort_clause ')' Sconst
--       | ConstTypename Sconst
--       | ConstInterval Sconst opt_interval
--       | ConstInterval '(' Iconst ')' Sconst
--       | TRUE_P
--       | FALSE_P
--       | NULL_P
-- @
aexprConst :: HeadedParsec Void Text AexprConst
aexprConst =
  forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
    [ do
        forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"interval"
        forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
        forall strm err. Stream strm => HeadedParsec err strm ()
endHead
        AexprConst
a <-
          forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
            [ do
                Text
a <- Parser Text
sconst
                forall strm err. Stream strm => HeadedParsec err strm ()
endHead
                Maybe Interval
b <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text Interval
interval)
                return (Text -> Maybe Interval -> AexprConst
StringIntervalAexprConst Text
a Maybe Interval
b),
              do
                Int64
a <- forall a. Parser a -> Parser a
inParens forall {strm} {decimal} {err}.
(Token strm ~ Char, Stream strm, Integral decimal, Ord err) =>
HeadedParsec err strm decimal
iconst
                forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
                forall strm err. Stream strm => HeadedParsec err strm ()
endHead
                Text
b <- Parser Text
sconst
                return (Int64 -> Text -> AexprConst
IntIntervalAexprConst Int64
a Text
b)
            ]
        return AexprConst
a,
      do
        ConstTypename
a <- HeadedParsec Void Text ConstTypename
constTypename
        forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
        forall strm err. Stream strm => HeadedParsec err strm ()
endHead
        Text
b <- Parser Text
sconst
        return (ConstTypename -> Text -> AexprConst
ConstTypenameAexprConst ConstTypename
a Text
b),
      Bool -> AexprConst
BoolAexprConst Bool
True forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"true",
      Bool -> AexprConst
BoolAexprConst Bool
False forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"false",
      AexprConst
NullAexprConst forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"null" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall err strm a. Parsec err strm a -> HeadedParsec err strm a
parse (forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m ()
Megaparsec.notFollowedBy forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m (Token s)
MegaparsecChar.alphaNumChar),
      forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either Int64 -> AexprConst
IAexprConst Fconst -> AexprConst
FAexprConst forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall {strm} {a} {a} {err}.
(Token strm ~ Char, Stream strm, RealFloat a, Integral a,
 Ord err) =>
HeadedParsec err strm (Either a a)
iconstOrFconst,
      Text -> AexprConst
SAexprConst forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Text
sconst,
      forall err strm a.
(Ord err, Stream strm) =>
String -> HeadedParsec err strm a -> HeadedParsec err strm a
label String
"bit literal" forall a b. (a -> b) -> a -> b
$ do
        forall err strm.
(Ord err, Stream strm, FoldCase (Tokens strm)) =>
Tokens strm -> HeadedParsec err strm (Tokens strm)
string' Text
"b'"
        forall strm err. Stream strm => HeadedParsec err strm ()
endHead
        Text
a <- forall err strm.
(Ord err, Stream strm) =>
Maybe String
-> (Token strm -> Bool) -> HeadedParsec err strm (Tokens strm)
takeWhile1P (forall a. a -> Maybe a
Just String
"0 or 1") (\Token Text
b -> Token Text
b forall a. Eq a => a -> a -> Bool
== Char
'0' Bool -> Bool -> Bool
|| Token Text
b forall a. Eq a => a -> a -> Bool
== Char
'1')
        forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
Char -> HeadedParsec err strm Char
char Char
'\''
        return (Text -> AexprConst
BAexprConst Text
a),
      forall err strm a.
(Ord err, Stream strm) =>
String -> HeadedParsec err strm a -> HeadedParsec err strm a
label String
"hex literal" forall a b. (a -> b) -> a -> b
$ do
        forall err strm.
(Ord err, Stream strm, FoldCase (Tokens strm)) =>
Tokens strm -> HeadedParsec err strm (Tokens strm)
string' Text
"x'"
        forall strm err. Stream strm => HeadedParsec err strm ()
endHead
        Text
a <- forall err strm.
(Ord err, Stream strm) =>
Maybe String
-> (Token strm -> Bool) -> HeadedParsec err strm (Tokens strm)
takeWhile1P (forall a. a -> Maybe a
Just String
"Hex digit") Char -> Bool
Predicate.hexDigit
        forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
Char -> HeadedParsec err strm Char
char Char
'\''
        return (Text -> AexprConst
XAexprConst Text
a),
      forall err strm a.
(Ord err, Stream strm) =>
HeadedParsec err strm a -> HeadedParsec err strm a
wrapToHead forall a b. (a -> b) -> a -> b
$ do
        FuncName
a <- Parser FuncName
funcName
        forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space
        forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
Char -> HeadedParsec err strm Char
char Char
'('
        forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space
        NonEmpty FuncArgExpr
b <- forall err strm separtor a.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm separtor
-> HeadedParsec err strm a -> HeadedParsec err strm (NonEmpty a)
sep1 Parser ()
commaSeparator HeadedParsec Void Text FuncArgExpr
funcArgExpr
        Maybe SortClause
c <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text SortClause
sortClause)
        forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space
        forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
Char -> HeadedParsec err strm Char
char Char
')'
        forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
        Text
d <- Parser Text
sconst
        return (FuncName -> Maybe FuncConstArgs -> Text -> AexprConst
FuncAexprConst FuncName
a (forall a. a -> Maybe a
Just (NonEmpty FuncArgExpr -> Maybe SortClause -> FuncConstArgs
FuncConstArgs NonEmpty FuncArgExpr
b Maybe SortClause
c)) Text
d),
      FuncName -> Maybe FuncConstArgs -> Text -> AexprConst
FuncAexprConst forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall err strm a.
(Ord err, Stream strm) =>
HeadedParsec err strm a -> HeadedParsec err strm a
wrapToHead Parser FuncName
funcName forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1) forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a. Maybe a
Nothing forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Text
sconst
    ]

iconstOrFconst :: HeadedParsec err strm (Either a a)
iconstOrFconst = forall a b. b -> Either a b
Right forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall {strm} {float} {err}.
(Token strm ~ Char, Stream strm, RealFloat float, Ord err) =>
HeadedParsec err strm float
fconst forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall a b. a -> Either a b
Left forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall {strm} {decimal} {err}.
(Token strm ~ Char, Stream strm, Integral decimal, Ord err) =>
HeadedParsec err strm decimal
iconst

iconst :: HeadedParsec err strm decimal
iconst = forall err strm decimal.
(Ord err, Stream strm, Token strm ~ Char, Integral decimal) =>
HeadedParsec err strm decimal
decimal

fconst :: HeadedParsec err strm float
fconst = forall err strm float.
(Ord err, Stream strm, Token strm ~ Char, RealFloat float) =>
HeadedParsec err strm float
float

sconst :: Parser Text
sconst = Char -> Parser Text
quotedString Char
'\''

constTypename :: HeadedParsec Void Text ConstTypename
constTypename =
  forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
    [ Numeric -> ConstTypename
NumericConstTypename forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HeadedParsec Void Text Numeric
numeric,
      ConstBit -> ConstTypename
ConstBitConstTypename forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HeadedParsec Void Text ConstBit
constBit,
      ConstCharacter -> ConstTypename
ConstCharacterConstTypename forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HeadedParsec Void Text ConstCharacter
constCharacter,
      ConstDatetime -> ConstTypename
ConstDatetimeConstTypename forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HeadedParsec Void Text ConstDatetime
constDatetime
    ]

numeric :: HeadedParsec Void Text Numeric
numeric =
  forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
    [ Numeric
IntegerNumeric forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"integer",
      Numeric
IntNumeric forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"int",
      Numeric
SmallintNumeric forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"smallint",
      Numeric
BigintNumeric forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"bigint",
      Numeric
RealNumeric forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"real",
      Maybe Int64 -> Numeric
FloatNumeric forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"float" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall strm err. Stream strm => HeadedParsec err strm ()
endHead forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall a. Parser a -> Parser a
inParens forall {strm} {decimal} {err}.
(Token strm ~ Char, Stream strm, Integral decimal, Ord err) =>
HeadedParsec err strm decimal
iconst)),
      Numeric
DoublePrecisionNumeric forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Token s ~ Char, Tokens s ~ Text, Ord e, Stream s,
 FoldCase (Tokens s)) =>
Text -> HeadedParsec e s Text
keyphrase Text
"double precision",
      Maybe ExprList -> Numeric
DecimalNumeric forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"decimal" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall strm err. Stream strm => HeadedParsec err strm ()
endHead forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text ExprList
exprListInParens)),
      Maybe ExprList -> Numeric
DecNumeric forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"dec" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall strm err. Stream strm => HeadedParsec err strm ()
endHead forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text ExprList
exprListInParens)),
      Maybe ExprList -> Numeric
NumericNumeric forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"numeric" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall strm err. Stream strm => HeadedParsec err strm ()
endHead forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text ExprList
exprListInParens)),
      Numeric
BooleanNumeric forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"boolean"
    ]

bit :: HeadedParsec Void Text ConstBit
bit = do
  forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"bit"
  Bool
a <- forall (m :: * -> *) a. Alternative m => a -> m a -> m a
option Bool
False (Bool
True forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"varying")
  Maybe ExprList
b <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text ExprList
exprListInParens)
  return (Bool -> Maybe ExprList -> ConstBit
Bit Bool
a Maybe ExprList
b)

constBit :: HeadedParsec Void Text ConstBit
constBit = HeadedParsec Void Text ConstBit
bit

constCharacter :: HeadedParsec Void Text ConstCharacter
constCharacter = Character -> Maybe Int64 -> ConstCharacter
ConstCharacter forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s,
 FoldCase (Tokens s)) =>
HeadedParsec e s Character
character forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall strm err. Stream strm => HeadedParsec err strm ()
endHead) forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall a. Parser a -> Parser a
inParens forall {strm} {decimal} {err}.
(Token strm ~ Char, Stream strm, Integral decimal, Ord err) =>
HeadedParsec err strm decimal
iconst)

character :: HeadedParsec e s Character
character =
  forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
    [ Bool -> Character
CharacterCharacter forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"character" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall {strm} {err}.
(Token strm ~ Char, Tokens strm ~ Text, Ord err, Stream strm) =>
HeadedParsec err strm Bool
optVaryingAfterSpace),
      Bool -> Character
CharCharacter forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"char" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall {strm} {err}.
(Token strm ~ Char, Tokens strm ~ Text, Ord err, Stream strm) =>
HeadedParsec err strm Bool
optVaryingAfterSpace),
      Character
VarcharCharacter forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"varchar",
      Bool -> Character
NationalCharacterCharacter forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall {s} {e}.
(Token s ~ Char, Tokens s ~ Text, Ord e, Stream s,
 FoldCase (Tokens s)) =>
Text -> HeadedParsec e s Text
keyphrase Text
"national character" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall {strm} {err}.
(Token strm ~ Char, Tokens strm ~ Text, Ord err, Stream strm) =>
HeadedParsec err strm Bool
optVaryingAfterSpace),
      Bool -> Character
NationalCharCharacter forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall {s} {e}.
(Token s ~ Char, Tokens s ~ Text, Ord e, Stream s,
 FoldCase (Tokens s)) =>
Text -> HeadedParsec e s Text
keyphrase Text
"national char" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall {strm} {err}.
(Token strm ~ Char, Tokens strm ~ Text, Ord err, Stream strm) =>
HeadedParsec err strm Bool
optVaryingAfterSpace),
      Bool -> Character
NcharCharacter forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"nchar" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall {strm} {err}.
(Token strm ~ Char, Tokens strm ~ Text, Ord err, Stream strm) =>
HeadedParsec err strm Bool
optVaryingAfterSpace)
    ]
  where
    optVaryingAfterSpace :: HeadedParsec err strm Bool
optVaryingAfterSpace = Bool
True forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"varying" forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (f :: * -> *) a. Applicative f => a -> f a
pure Bool
False

-- |
-- ==== References
-- @
-- ConstDatetime:
--   | TIMESTAMP '(' Iconst ')' opt_timezone
--   | TIMESTAMP opt_timezone
--   | TIME '(' Iconst ')' opt_timezone
--   | TIME opt_timezone
-- @
constDatetime :: HeadedParsec Void Text ConstDatetime
constDatetime =
  forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
    [ do
        forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"timestamp"
        Maybe Int64
a <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall a. Parser a -> Parser a
inParens forall {strm} {decimal} {err}.
(Token strm ~ Char, Stream strm, Integral decimal, Ord err) =>
HeadedParsec err strm decimal
iconst)
        Maybe Bool
b <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall {s} {e}.
(Token s ~ Char, Tokens s ~ Text, Ord e, Stream s,
 FoldCase (Tokens s)) =>
HeadedParsec e s Bool
timezone)
        return (Maybe Int64 -> Maybe Bool -> ConstDatetime
TimestampConstDatetime Maybe Int64
a Maybe Bool
b),
      do
        forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"time"
        Maybe Int64
a <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall a. Parser a -> Parser a
inParens forall {strm} {decimal} {err}.
(Token strm ~ Char, Stream strm, Integral decimal, Ord err) =>
HeadedParsec err strm decimal
iconst)
        Maybe Bool
b <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall {s} {e}.
(Token s ~ Char, Tokens s ~ Text, Ord e, Stream s,
 FoldCase (Tokens s)) =>
HeadedParsec e s Bool
timezone)
        return (Maybe Int64 -> Maybe Bool -> ConstDatetime
TimeConstDatetime Maybe Int64
a Maybe Bool
b)
    ]

timezone :: HeadedParsec e s Bool
timezone =
  forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
    [ Bool
False forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Token s ~ Char, Tokens s ~ Text, Ord e, Stream s,
 FoldCase (Tokens s)) =>
Text -> HeadedParsec e s Text
keyphrase Text
"with time zone",
      Bool
True forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Token s ~ Char, Tokens s ~ Text, Ord e, Stream s,
 FoldCase (Tokens s)) =>
Text -> HeadedParsec e s Text
keyphrase Text
"without time zone"
    ]

interval :: HeadedParsec Void Text Interval
interval =
  forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
    [ Interval
YearToMonthInterval forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Token s ~ Char, Tokens s ~ Text, Ord e, Stream s,
 FoldCase (Tokens s)) =>
Text -> HeadedParsec e s Text
keyphrase Text
"year to month",
      Interval
DayToHourInterval forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Token s ~ Char, Tokens s ~ Text, Ord e, Stream s,
 FoldCase (Tokens s)) =>
Text -> HeadedParsec e s Text
keyphrase Text
"day to hour",
      Interval
DayToMinuteInterval forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Token s ~ Char, Tokens s ~ Text, Ord e, Stream s,
 FoldCase (Tokens s)) =>
Text -> HeadedParsec e s Text
keyphrase Text
"day to minute",
      Maybe Int64 -> Interval
DayToSecondInterval forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall {s} {e}.
(Token s ~ Char, Tokens s ~ Text, Ord e, Stream s,
 FoldCase (Tokens s)) =>
Text -> HeadedParsec e s Text
keyphrase Text
"day to" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall strm err. Stream strm => HeadedParsec err strm ()
endHead forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall {a}. Integral a => HeadedParsec Void Text (Maybe a)
intervalSecond),
      Interval
HourToMinuteInterval forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Token s ~ Char, Tokens s ~ Text, Ord e, Stream s,
 FoldCase (Tokens s)) =>
Text -> HeadedParsec e s Text
keyphrase Text
"hour to minute",
      Maybe Int64 -> Interval
HourToSecondInterval forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall {s} {e}.
(Token s ~ Char, Tokens s ~ Text, Ord e, Stream s,
 FoldCase (Tokens s)) =>
Text -> HeadedParsec e s Text
keyphrase Text
"hour to" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall strm err. Stream strm => HeadedParsec err strm ()
endHead forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall {a}. Integral a => HeadedParsec Void Text (Maybe a)
intervalSecond),
      Maybe Int64 -> Interval
MinuteToSecondInterval forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall {s} {e}.
(Token s ~ Char, Tokens s ~ Text, Ord e, Stream s,
 FoldCase (Tokens s)) =>
Text -> HeadedParsec e s Text
keyphrase Text
"minute to" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall strm err. Stream strm => HeadedParsec err strm ()
endHead forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall {a}. Integral a => HeadedParsec Void Text (Maybe a)
intervalSecond),
      Interval
YearInterval forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"year",
      Interval
MonthInterval forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"month",
      Interval
DayInterval forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"day",
      Interval
HourInterval forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"hour",
      Interval
MinuteInterval forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"minute",
      Maybe Int64 -> Interval
SecondInterval forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall {a}. Integral a => HeadedParsec Void Text (Maybe a)
intervalSecond
    ]

intervalSecond :: HeadedParsec Void Text (Maybe a)
intervalSecond = do
  forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"second"
  Maybe a
a <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall a. Parser a -> Parser a
inParens forall {strm} {decimal} {err}.
(Token strm ~ Char, Stream strm, Integral decimal, Ord err) =>
HeadedParsec err strm decimal
iconst)
  return Maybe a
a

-- * Clauses

-- |
-- ==== References
-- @
-- select_limit:
--   | limit_clause offset_clause
--   | offset_clause limit_clause
--   | limit_clause
--   | offset_clause
-- @
selectLimit :: HeadedParsec Void Text SelectLimit
selectLimit =
  forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
    [ do
        LimitClause
a <- HeadedParsec Void Text LimitClause
limitClause
        LimitClause -> OffsetClause -> SelectLimit
LimitOffsetSelectLimit LimitClause
a forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text OffsetClause
offsetClause) forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (f :: * -> *) a. Applicative f => a -> f a
pure (LimitClause -> SelectLimit
LimitSelectLimit LimitClause
a),
      do
        OffsetClause
a <- HeadedParsec Void Text OffsetClause
offsetClause
        OffsetClause -> LimitClause -> SelectLimit
OffsetLimitSelectLimit OffsetClause
a forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text LimitClause
limitClause) forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (f :: * -> *) a. Applicative f => a -> f a
pure (OffsetClause -> SelectLimit
OffsetSelectLimit OffsetClause
a)
    ]

-- |
-- ==== References
-- @
-- limit_clause:
--   | LIMIT select_limit_value
--   | LIMIT select_limit_value ',' select_offset_value
--   | FETCH first_or_next select_fetch_first_value row_or_rows ONLY
--   | FETCH first_or_next row_or_rows ONLY
-- @
limitClause :: HeadedParsec Void Text LimitClause
limitClause =
  ( do
      forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"limit"
      forall strm err. Stream strm => HeadedParsec err strm ()
endHead
      forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
      SelectLimitValue
a <- HeadedParsec Void Text SelectLimitValue
selectLimitValue
      Maybe WhereClause
b <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional forall a b. (a -> b) -> a -> b
$ do
        Parser ()
commaSeparator
        HeadedParsec Void Text WhereClause
aExpr
      return (SelectLimitValue -> Maybe WhereClause -> LimitClause
LimitLimitClause SelectLimitValue
a Maybe WhereClause
b)
  )
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ( do
            forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"fetch"
            forall strm err. Stream strm => HeadedParsec err strm ()
endHead
            forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
            Bool
a <- forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
HeadedParsec e s Bool
firstOrNext
            forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
            forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
              [ do
                  Bool
b <- forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
HeadedParsec e s Bool
rowOrRows
                  forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
                  forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"only"
                  return (Bool -> Maybe SelectFetchFirstValue -> Bool -> LimitClause
FetchOnlyLimitClause Bool
a forall a. Maybe a
Nothing Bool
b),
                do
                  SelectFetchFirstValue
b <- HeadedParsec Void Text SelectFetchFirstValue
selectFetchFirstValue
                  forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
                  Bool
c <- forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
HeadedParsec e s Bool
rowOrRows
                  forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
                  forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"only"
                  return (Bool -> Maybe SelectFetchFirstValue -> Bool -> LimitClause
FetchOnlyLimitClause Bool
a (forall a. a -> Maybe a
Just SelectFetchFirstValue
b) Bool
c)
              ]
        )

offsetClause :: HeadedParsec Void Text OffsetClause
offsetClause = do
  forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"offset"
  forall strm err. Stream strm => HeadedParsec err strm ()
endHead
  forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
  HeadedParsec Void Text OffsetClause
offsetClauseParams

offsetClauseParams :: HeadedParsec Void Text OffsetClause
offsetClauseParams =
  SelectFetchFirstValue -> Bool -> OffsetClause
FetchFirstOffsetClause forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall err strm a.
(Ord err, Stream strm) =>
HeadedParsec err strm a -> HeadedParsec err strm a
wrapToHead HeadedParsec Void Text SelectFetchFirstValue
selectFetchFirstValue forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
HeadedParsec e s Bool
rowOrRows)
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> WhereClause -> OffsetClause
ExprOffsetClause forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HeadedParsec Void Text WhereClause
aExpr

-- |
-- ==== References
-- @
-- select_limit_value:
--   | a_expr
--   | ALL
-- @
selectLimitValue :: HeadedParsec Void Text SelectLimitValue
selectLimitValue =
  SelectLimitValue
AllSelectLimitValue forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"all"
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> WhereClause -> SelectLimitValue
ExprSelectLimitValue forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HeadedParsec Void Text WhereClause
aExpr

rowOrRows :: HeadedParsec e s Bool
rowOrRows =
  Bool
True forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"rows"
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Bool
False forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"row"

firstOrNext :: HeadedParsec e s Bool
firstOrNext =
  Bool
False forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"first"
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Bool
True forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"next"

selectFetchFirstValue :: HeadedParsec Void Text SelectFetchFirstValue
selectFetchFirstValue =
  CExpr -> SelectFetchFirstValue
ExprSelectFetchFirstValue forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HeadedParsec Void Text CExpr
cExpr
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Bool -> Either Int64 Fconst -> SelectFetchFirstValue
NumSelectFetchFirstValue forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall {strm} {err}.
(Token strm ~ Char, Stream strm, Ord err) =>
HeadedParsec err strm Bool
plusOrMinus forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall strm err. Stream strm => HeadedParsec err strm ()
endHead forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space) forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall {strm} {a} {a} {err}.
(Token strm ~ Char, Stream strm, RealFloat a, Integral a,
 Ord err) =>
HeadedParsec err strm (Either a a)
iconstOrFconst

plusOrMinus :: HeadedParsec err strm Bool
plusOrMinus = Bool
False forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
Char -> HeadedParsec err strm Char
char Char
'+' forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Bool
True forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
Char -> HeadedParsec err strm Char
char Char
'-'

-- * For Locking

-- |
-- ==== References
-- @
-- for_locking_clause:
--   | for_locking_items
--   | FOR READ ONLY
-- for_locking_items:
--   | for_locking_item
--   | for_locking_items for_locking_item
-- @
forLockingClause :: HeadedParsec Void Text ForLockingClause
forLockingClause = forall {s} {e}.
(Token s ~ Char, Tokens s ~ Text, Ord e, Stream s,
 FoldCase (Tokens s)) =>
HeadedParsec e s ForLockingClause
readOnly forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> HeadedParsec Void Text ForLockingClause
items
  where
    readOnly :: HeadedParsec e s ForLockingClause
readOnly = ForLockingClause
ReadOnlyForLockingClause forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Token s ~ Char, Tokens s ~ Text, Ord e, Stream s,
 FoldCase (Tokens s)) =>
Text -> HeadedParsec e s Text
keyphrase Text
"for read only"
    items :: HeadedParsec Void Text ForLockingClause
items = NonEmpty ForLockingItem -> ForLockingClause
ItemsForLockingClause forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall err strm separtor a.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm separtor
-> HeadedParsec err strm a -> HeadedParsec err strm (NonEmpty a)
sep1 forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 HeadedParsec Void Text ForLockingItem
forLockingItem

-- |
-- ==== References
-- @
-- for_locking_item:
--   | for_locking_strength locked_rels_list opt_nowait_or_skip
-- locked_rels_list:
--   | OF qualified_name_list
--   | EMPTY
-- opt_nowait_or_skip:
--   | NOWAIT
--   | SKIP LOCKED
--   | EMPTY
-- @
forLockingItem :: HeadedParsec Void Text ForLockingItem
forLockingItem = do
  ForLockingStrength
strength <- forall {s} {e}.
(Token s ~ Char, Tokens s ~ Text, Ord e, Stream s,
 FoldCase (Tokens s)) =>
HeadedParsec e s ForLockingStrength
forLockingStrength
  Maybe (NonEmpty QualifiedName)
rels <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional forall a b. (a -> b) -> a -> b
$ forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"of" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall strm err. Stream strm => HeadedParsec err strm ()
endHead forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm separtor a.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm separtor
-> HeadedParsec err strm a -> HeadedParsec err strm (NonEmpty a)
sep1 Parser ()
commaSeparator HeadedParsec Void Text QualifiedName
qualifiedName
  Maybe Bool
nowaitOrSkip <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s,
 FoldCase (Tokens s)) =>
HeadedParsec e s Bool
nowaitOrSkip)
  return (ForLockingStrength
-> Maybe (NonEmpty QualifiedName) -> Maybe Bool -> ForLockingItem
ForLockingItem ForLockingStrength
strength Maybe (NonEmpty QualifiedName)
rels Maybe Bool
nowaitOrSkip)

-- |
-- ==== References
-- @
-- for_locking_strength:
--   | FOR UPDATE
--   | FOR NO KEY UPDATE
--   | FOR SHARE
--   | FOR KEY SHARE
-- @
forLockingStrength :: HeadedParsec e s ForLockingStrength
forLockingStrength =
  ForLockingStrength
UpdateForLockingStrength forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Token s ~ Char, Tokens s ~ Text, Ord e, Stream s,
 FoldCase (Tokens s)) =>
Text -> HeadedParsec e s Text
keyphrase Text
"for update"
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ForLockingStrength
NoKeyUpdateForLockingStrength forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Token s ~ Char, Tokens s ~ Text, Ord e, Stream s,
 FoldCase (Tokens s)) =>
Text -> HeadedParsec e s Text
keyphrase Text
"for no key update"
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ForLockingStrength
ShareForLockingStrength forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Token s ~ Char, Tokens s ~ Text, Ord e, Stream s,
 FoldCase (Tokens s)) =>
Text -> HeadedParsec e s Text
keyphrase Text
"for share"
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ForLockingStrength
KeyForLockingStrength forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Token s ~ Char, Tokens s ~ Text, Ord e, Stream s,
 FoldCase (Tokens s)) =>
Text -> HeadedParsec e s Text
keyphrase Text
"for key share"

nowaitOrSkip :: HeadedParsec e s Bool
nowaitOrSkip = Bool
False forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"nowait" forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Bool
True forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Token s ~ Char, Tokens s ~ Text, Ord e, Stream s,
 FoldCase (Tokens s)) =>
Text -> HeadedParsec e s Text
keyphrase Text
"skip locked"

-- * References & Names

quotedName :: HeadedParsec Void Text Ident
quotedName = forall strm a err.
Stream strm =>
(a -> String)
-> (a -> Bool)
-> HeadedParsec err strm a
-> HeadedParsec err strm a
filter (forall a b. a -> b -> a
const String
"Empty name") (Bool -> Bool
not forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. Text -> Bool
Text.null) (Char -> Parser Text
quotedString Char
'"') forall a b. a -> (a -> b) -> b
& forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Text -> Ident
QuotedIdent

-- |
-- ==== References
-- @
-- ident_start   [A-Za-z\200-\377_]
-- ident_cont    [A-Za-z\200-\377_0-9\$]
-- identifier    {ident_start}{ident_cont}*
-- @
ident :: HeadedParsec Void Text Ident
ident = HeadedParsec Void Text Ident
quotedName forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall {strm} {err}.
(Tokens strm ~ Text, Token strm ~ Char, Stream strm, Ord err) =>
(Text -> Bool) -> HeadedParsec err strm Ident
keywordNameByPredicate (Bool -> Bool
not forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. Text -> Bool
Predicate.keyword)

-- |
-- ==== References
-- @
-- ColId:
--   |  IDENT
--   |  unreserved_keyword
--   |  col_name_keyword
-- @
{-# NOINLINE colId #-}
colId :: HeadedParsec Void Text Ident
colId =
  forall err strm a.
(Ord err, Stream strm) =>
String -> HeadedParsec err strm a -> HeadedParsec err strm a
label String
"identifier"
    forall a b. (a -> b) -> a -> b
$ HeadedParsec Void Text Ident
ident
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall {strm} {err}.
(Tokens strm ~ Text, Token strm ~ Char, Stream strm, Ord err) =>
HashSet Text -> HeadedParsec err strm Ident
keywordNameFromSet (HashSet Text
KeywordSet.unreservedKeyword forall a. Semigroup a => a -> a -> a
<> HashSet Text
KeywordSet.colNameKeyword)

{-# NOINLINE filteredColId #-}
filteredColId :: t Text -> HeadedParsec Void Text Ident
filteredColId =
  let originalSet :: HashSet Text
originalSet = HashSet Text
KeywordSet.unreservedKeyword forall a. Semigroup a => a -> a -> a
<> HashSet Text
KeywordSet.colNameKeyword
      filteredSet :: t Text -> HashSet Text
filteredSet = forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr forall a. (Eq a, Hashable a) => a -> HashSet a -> HashSet a
HashSet.delete HashSet Text
originalSet
   in \t Text
reservedKeywords -> forall err strm a.
(Ord err, Stream strm) =>
String -> HeadedParsec err strm a -> HeadedParsec err strm a
label String
"identifier" forall a b. (a -> b) -> a -> b
$ HeadedParsec Void Text Ident
ident forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall {strm} {err}.
(Tokens strm ~ Text, Token strm ~ Char, Stream strm, Ord err) =>
HashSet Text -> HeadedParsec err strm Ident
keywordNameFromSet (forall {t :: * -> *}. Foldable t => t Text -> HashSet Text
filteredSet t Text
reservedKeywords)

-- |
-- ==== References
-- @
-- ColLabel:
--   |  IDENT
--   |  unreserved_keyword
--   |  col_name_keyword
--   |  type_func_name_keyword
--   |  reserved_keyword
-- @
colLabel :: HeadedParsec Void Text Ident
colLabel =
  forall err strm a.
(Ord err, Stream strm) =>
String -> HeadedParsec err strm a -> HeadedParsec err strm a
label String
"column label"
    forall a b. (a -> b) -> a -> b
$ forall {strm} {err}.
(Tokens strm ~ Text, Token strm ~ Char, Stream strm, Ord err) =>
HashSet Text -> HeadedParsec err strm Ident
keywordNameFromSet HashSet Text
KeywordSet.keyword
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> HeadedParsec Void Text Ident
ident

-- |
-- >>> testParser qualifiedName "a.b"
-- IndirectedQualifiedName (UnquotedIdent "a") (AttrNameIndirectionEl (UnquotedIdent "b") :| [])
--
-- >>> testParser qualifiedName "a.-"
-- ...
-- expecting '*', column label, or white space
--
-- ==== References
-- @
-- qualified_name:
--   | ColId
--   | ColId indirection
-- @
qualifiedName :: HeadedParsec Void Text QualifiedName
qualifiedName =
  Ident -> Indirection -> QualifiedName
IndirectedQualifiedName forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall err strm a.
(Ord err, Stream strm) =>
HeadedParsec err strm a -> HeadedParsec err strm a
wrapToHead HeadedParsec Void Text Ident
colId forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text Indirection
indirection)
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Ident -> QualifiedName
SimpleQualifiedName forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HeadedParsec Void Text Ident
colId

columnref :: HeadedParsec Void Text Columnref
columnref = HeadedParsec Void Text Ident -> HeadedParsec Void Text Columnref
customizedColumnref HeadedParsec Void Text Ident
colId

filteredColumnref :: [Text] -> HeadedParsec Void Text Columnref
filteredColumnref [Text]
keywords = HeadedParsec Void Text Ident -> HeadedParsec Void Text Columnref
customizedColumnref (forall {t :: * -> *}.
Foldable t =>
t Text -> HeadedParsec Void Text Ident
filteredColId [Text]
keywords)

customizedColumnref :: HeadedParsec Void Text Ident -> HeadedParsec Void Text Columnref
customizedColumnref HeadedParsec Void Text Ident
colId = do
  Ident
a <- forall err strm a.
(Ord err, Stream strm) =>
HeadedParsec err strm a -> HeadedParsec err strm a
wrapToHead HeadedParsec Void Text Ident
colId
  forall strm err. Stream strm => HeadedParsec err strm ()
endHead
  Maybe Indirection
b <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text Indirection
indirection)
  return (Ident -> Maybe Indirection -> Columnref
Columnref Ident
a Maybe Indirection
b)

anyName :: HeadedParsec Void Text AnyName
anyName = HeadedParsec Void Text Ident -> HeadedParsec Void Text AnyName
customizedAnyName HeadedParsec Void Text Ident
colId

filteredAnyName :: t Text -> HeadedParsec Void Text AnyName
filteredAnyName t Text
keywords = HeadedParsec Void Text Ident -> HeadedParsec Void Text AnyName
customizedAnyName (forall {t :: * -> *}.
Foldable t =>
t Text -> HeadedParsec Void Text Ident
filteredColId t Text
keywords)

customizedAnyName :: HeadedParsec Void Text Ident -> HeadedParsec Void Text AnyName
customizedAnyName HeadedParsec Void Text Ident
colId = do
  Ident
a <- forall err strm a.
(Ord err, Stream strm) =>
HeadedParsec err strm a -> HeadedParsec err strm a
wrapToHead HeadedParsec Void Text Ident
colId
  forall strm err. Stream strm => HeadedParsec err strm ()
endHead
  Maybe (NonEmpty Ident)
b <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text (NonEmpty Ident)
attrs)
  return (Ident -> Maybe (NonEmpty Ident) -> AnyName
AnyName Ident
a Maybe (NonEmpty Ident)
b)

name :: HeadedParsec Void Text Ident
name = HeadedParsec Void Text Ident
colId

nameList :: HeadedParsec Void Text (NonEmpty Ident)
nameList = forall err strm separtor a.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm separtor
-> HeadedParsec err strm a -> HeadedParsec err strm (NonEmpty a)
sep1 Parser ()
commaSeparator HeadedParsec Void Text Ident
name

cursorName :: HeadedParsec Void Text Ident
cursorName = HeadedParsec Void Text Ident
name

-- |
-- ==== References
-- @
-- func_name:
--   | type_function_name
--   | ColId indirection
-- @
funcName :: Parser FuncName
funcName =
  Ident -> Indirection -> FuncName
IndirectedFuncName forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall err strm a.
(Ord err, Stream strm) =>
HeadedParsec err strm a -> HeadedParsec err strm a
wrapToHead HeadedParsec Void Text Ident
colId forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text Indirection
indirection)
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Ident -> FuncName
TypeFuncName forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HeadedParsec Void Text Ident
typeFunctionName

-- |
-- ==== References
-- @
-- type_function_name:
--   | IDENT
--   | unreserved_keyword
--   | type_func_name_keyword
-- @
typeFunctionName :: HeadedParsec Void Text Ident
typeFunctionName =
  forall {strm} {err}.
(Tokens strm ~ Text, Token strm ~ Char, Stream strm, Ord err) =>
HashSet Text -> HeadedParsec err strm Ident
keywordNameFromSet HashSet Text
KeywordSet.typeFunctionName
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> HeadedParsec Void Text Ident
ident

-- |
-- ==== References
-- @
-- indirection:
--   | indirection_el
--   | indirection indirection_el
-- @
indirection :: HeadedParsec Void Text Indirection
indirection = forall (m :: * -> *) a. Alternative m => m a -> m (NonEmpty a)
some HeadedParsec Void Text IndirectionEl
indirectionEl

-- |
-- ==== References
-- @
-- indirection_el:
--   | '.' attr_name
--   | '.' '*'
--   | '[' a_expr ']'
--   | '[' opt_slice_bound ':' opt_slice_bound ']'
-- opt_slice_bound:
--   | a_expr
--   | EMPTY
-- @
indirectionEl :: HeadedParsec Void Text IndirectionEl
indirectionEl =
  forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
    [ do
        forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
Char -> HeadedParsec err strm Char
char Char
'.'
        forall strm err. Stream strm => HeadedParsec err strm ()
endHead
        forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space
        IndirectionEl
AllIndirectionEl forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
Char -> HeadedParsec err strm Char
char Char
'*' forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Ident -> IndirectionEl
AttrNameIndirectionEl forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HeadedParsec Void Text Ident
attrName,
      do
        forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
Char -> HeadedParsec err strm Char
char Char
'['
        forall strm err. Stream strm => HeadedParsec err strm ()
endHead
        forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space
        IndirectionEl
a <-
          forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
            [ do
                forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
Char -> HeadedParsec err strm Char
char Char
':'
                forall strm err. Stream strm => HeadedParsec err strm ()
endHead
                forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space
                Maybe WhereClause
b <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional HeadedParsec Void Text WhereClause
aExpr
                return (Maybe WhereClause -> Maybe WhereClause -> IndirectionEl
SliceIndirectionEl forall a. Maybe a
Nothing Maybe WhereClause
b),
              do
                WhereClause
a <- HeadedParsec Void Text WhereClause
aExpr
                forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
                  [ do
                      forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space
                      forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
Char -> HeadedParsec err strm Char
char Char
':'
                      forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space
                      Maybe WhereClause
b <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional HeadedParsec Void Text WhereClause
aExpr
                      return (Maybe WhereClause -> Maybe WhereClause -> IndirectionEl
SliceIndirectionEl (forall a. a -> Maybe a
Just WhereClause
a) Maybe WhereClause
b),
                    forall (m :: * -> *) a. Monad m => a -> m a
return (WhereClause -> IndirectionEl
ExprIndirectionEl WhereClause
a)
                  ]
            ]
        forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space
        forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
Char -> HeadedParsec err strm Char
char Char
']'
        return IndirectionEl
a
    ]

-- |
-- ==== References
-- @
-- attr_name:
--   | ColLabel
-- @
attrName :: HeadedParsec Void Text Ident
attrName = HeadedParsec Void Text Ident
colLabel

keywordNameFromSet :: HashSet Text -> HeadedParsec err strm Ident
keywordNameFromSet HashSet Text
set = forall {strm} {err}.
(Tokens strm ~ Text, Token strm ~ Char, Stream strm, Ord err) =>
(Text -> Bool) -> HeadedParsec err strm Ident
keywordNameByPredicate (forall a. (Eq a, Hashable a) => HashSet a -> a -> Bool
Predicate.inSet HashSet Text
set)

keywordNameByPredicate :: (Text -> Bool) -> HeadedParsec err strm Ident
keywordNameByPredicate Text -> Bool
predicate =
  forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Text -> Ident
UnquotedIdent
    forall a b. (a -> b) -> a -> b
$ forall strm a err.
Stream strm =>
(a -> String)
-> (a -> Bool)
-> HeadedParsec err strm a
-> HeadedParsec err strm a
filter
      (\Text
a -> String
"Reserved keyword " forall a. Semigroup a => a -> a -> a
<> forall a. Show a => a -> String
show Text
a forall a. Semigroup a => a -> a -> a
<> String
" used as an identifier. If that's what you intend, you have to wrap it in double quotes.")
      Text -> Bool
predicate
      forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
HeadedParsec e s Text
anyKeyword

anyKeyword :: HeadedParsec e s Text
anyKeyword = forall err strm a. Parsec err strm a -> HeadedParsec err strm a
parse
  forall a b. (a -> b) -> a -> b
$ forall e s (m :: * -> *) a.
MonadParsec e s m =>
String -> m a -> m a
Megaparsec.label String
"keyword"
  forall a b. (a -> b) -> a -> b
$ do
    Char
firstChar <- forall e s (m :: * -> *).
MonadParsec e s m =>
(Token s -> Bool) -> m (Token s)
Megaparsec.satisfy Char -> Bool
Predicate.firstIdentifierChar
    Text
remainder <- forall e s (m :: * -> *).
MonadParsec e s m =>
Maybe String -> (Token s -> Bool) -> m (Tokens s)
Megaparsec.takeWhileP forall a. Maybe a
Nothing Char -> Bool
Predicate.notFirstIdentifierChar
    return (Text -> Text
Text.toLower (Char -> Text -> Text
Text.cons Char
firstChar Text
remainder))

-- | Expected keyword
keyword :: Text -> HeadedParsec e s Text
keyword Text
a = forall (m :: * -> *) a. MonadPlus m => (a -> Bool) -> m a -> m a
mfilter (Text
a forall a. Eq a => a -> a -> Bool
==) forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
HeadedParsec e s Text
anyKeyword

-- |
-- Consume a keyphrase, ignoring case and types of spaces between words.
keyphrase :: Text -> HeadedParsec e s Text
keyphrase Text
a =
  Text -> [Text]
Text.words Text
a
    forall a b. a -> (a -> b) -> b
& forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall (f :: * -> *) a. Functor f => f a -> f ()
void forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall e s (m :: * -> *).
(MonadParsec e s m, FoldCase (Tokens s)) =>
Tokens s -> m (Tokens s)
MegaparsecChar.string')
    forall a b. a -> (a -> b) -> b
& forall a. a -> [a] -> [a]
intersperse forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
MegaparsecChar.space1
    forall a b. a -> (a -> b) -> b
& forall (t :: * -> *) (m :: * -> *) a.
(Foldable t, Monad m) =>
t (m a) -> m ()
sequence_
    forall a b. a -> (a -> b) -> b
& (forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m ()
Megaparsec.notFollowedBy (forall e s (m :: * -> *).
MonadParsec e s m =>
(Token s -> Bool) -> m (Token s)
Megaparsec.satisfy Char -> Bool
Predicate.notFirstIdentifierChar))
    forall a b. a -> (a -> b) -> b
& forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall a b. a -> b -> a
const (Text -> Text
Text.toUpper Text
a))
    forall a b. a -> (a -> b) -> b
& forall e s (m :: * -> *) a.
MonadParsec e s m =>
String -> m a -> m a
Megaparsec.label (forall a. Show a => a -> String
show Text
a)
    forall a b. a -> (a -> b) -> b
& forall err strm a. Parsec err strm a -> HeadedParsec err strm a
parse
    forall a b. a -> (a -> b) -> b
& (forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall strm err. Stream strm => HeadedParsec err strm ()
endHead)

-- * Typename

typeList :: HeadedParsec Void Text TypeList
typeList = forall err strm separtor a.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm separtor
-> HeadedParsec err strm a -> HeadedParsec err strm (NonEmpty a)
sep1 Parser ()
commaSeparator HeadedParsec Void Text Typename
typename

typename :: HeadedParsec Void Text Typename
typename =
  do
    Bool
a <- forall (m :: * -> *) a. Alternative m => a -> m a -> m a
option Bool
False (forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"setof" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Bool
True)
    SimpleTypename
b <- HeadedParsec Void Text SimpleTypename
simpleTypename
    forall strm err. Stream strm => HeadedParsec err strm ()
endHead
    Bool
c <- forall a. Parser a -> Parser Bool
trueIfPresent (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
Char -> HeadedParsec err strm Char
char Char
'?')
    forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
      [ do
          forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1
          forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"array"
          forall strm err. Stream strm => HeadedParsec err strm ()
endHead
          Maybe Int64
d <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall a. Parser a -> Parser a
inBrackets forall {strm} {decimal} {err}.
(Token strm ~ Char, Stream strm, Integral decimal, Ord err) =>
HeadedParsec err strm decimal
iconst)
          Bool
e <- forall a. Parser a -> Parser Bool
trueIfPresent (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
Char -> HeadedParsec err strm Char
char Char
'?')
          return (Bool
-> SimpleTypename
-> Bool
-> Maybe (TypenameArrayDimensions, Bool)
-> Typename
Typename Bool
a SimpleTypename
b Bool
c (forall a. a -> Maybe a
Just (Maybe Int64 -> TypenameArrayDimensions
ExplicitTypenameArrayDimensions Maybe Int64
d, Bool
e))),
        do
          forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space
          NonEmpty (Maybe Int64)
d <- forall {a}.
Integral a =>
HeadedParsec Void Text (NonEmpty (Maybe a))
arrayBounds
          forall strm err. Stream strm => HeadedParsec err strm ()
endHead
          Bool
e <- forall a. Parser a -> Parser Bool
trueIfPresent (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
Char -> HeadedParsec err strm Char
char Char
'?')
          return (Bool
-> SimpleTypename
-> Bool
-> Maybe (TypenameArrayDimensions, Bool)
-> Typename
Typename Bool
a SimpleTypename
b Bool
c (forall a. a -> Maybe a
Just (NonEmpty (Maybe Int64) -> TypenameArrayDimensions
BoundsTypenameArrayDimensions NonEmpty (Maybe Int64)
d, Bool
e))),
        forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
-> SimpleTypename
-> Bool
-> Maybe (TypenameArrayDimensions, Bool)
-> Typename
Typename Bool
a SimpleTypename
b Bool
c forall a. Maybe a
Nothing)
      ]

arrayBounds :: HeadedParsec Void Text (NonEmpty (Maybe a))
arrayBounds = forall err strm separtor a.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm separtor
-> HeadedParsec err strm a -> HeadedParsec err strm (NonEmpty a)
sep1 forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space (forall a. Parser a -> Parser a
inBrackets (forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional forall {strm} {decimal} {err}.
(Token strm ~ Char, Stream strm, Integral decimal, Ord err) =>
HeadedParsec err strm decimal
iconst))

simpleTypename :: HeadedParsec Void Text SimpleTypename
simpleTypename =
  forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
    forall a b. (a -> b) -> a -> b
$ [ do
          forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"interval"
          forall strm err. Stream strm => HeadedParsec err strm ()
endHead
          forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
            [ Either (Maybe Interval) Int64 -> SimpleTypename
ConstIntervalSimpleTypename forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a b. b -> Either a b
Right forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall a. Parser a -> Parser a
inParens forall {strm} {decimal} {err}.
(Token strm ~ Char, Stream strm, Integral decimal, Ord err) =>
HeadedParsec err strm decimal
iconst),
              Either (Maybe Interval) Int64 -> SimpleTypename
ConstIntervalSimpleTypename forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a b. a -> Either a b
Left forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text Interval
interval)
            ],
        ConstDatetime -> SimpleTypename
ConstDatetimeSimpleTypename forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HeadedParsec Void Text ConstDatetime
constDatetime,
        Numeric -> SimpleTypename
NumericSimpleTypename forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HeadedParsec Void Text Numeric
numeric,
        ConstBit -> SimpleTypename
BitSimpleTypename forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HeadedParsec Void Text ConstBit
bit,
        Character -> SimpleTypename
CharacterSimpleTypename forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s,
 FoldCase (Tokens s)) =>
HeadedParsec e s Character
character,
        GenericType -> SimpleTypename
GenericTypeSimpleTypename forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HeadedParsec Void Text GenericType
genericType
      ]

genericType :: HeadedParsec Void Text GenericType
genericType = do
  Ident
a <- HeadedParsec Void Text Ident
typeFunctionName
  forall strm err. Stream strm => HeadedParsec err strm ()
endHead
  Maybe (NonEmpty Ident)
b <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text (NonEmpty Ident)
attrs)
  Maybe ExprList
c <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text ExprList
typeModifiers)
  return (Ident -> Maybe (NonEmpty Ident) -> Maybe ExprList -> GenericType
GenericType Ident
a Maybe (NonEmpty Ident)
b Maybe ExprList
c)

attrs :: HeadedParsec Void Text (NonEmpty Ident)
attrs = forall (m :: * -> *) a. Alternative m => m a -> m (NonEmpty a)
some (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
Char -> HeadedParsec err strm Char
char Char
'.' forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall strm err. Stream strm => HeadedParsec err strm ()
endHead forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text Ident
attrName)

typeModifiers :: HeadedParsec Void Text ExprList
typeModifiers = forall a. Parser a -> Parser a
inParens HeadedParsec Void Text ExprList
exprList

-- * Indexes

indexParams :: HeadedParsec Void Text IndexParams
indexParams = forall err strm separtor a.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm separtor
-> HeadedParsec err strm a -> HeadedParsec err strm (NonEmpty a)
sep1 Parser ()
commaSeparator HeadedParsec Void Text IndexElem
indexElem

indexElem :: HeadedParsec Void Text IndexElem
indexElem =
  IndexElemDef
-> Maybe AnyName
-> Maybe AnyName
-> Maybe AscDesc
-> Maybe NullsOrder
-> IndexElem
IndexElem
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (HeadedParsec Void Text IndexElemDef
indexElemDef forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall strm err. Stream strm => HeadedParsec err strm ()
endHead)
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text AnyName
collate)
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text AnyName
class_)
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
HeadedParsec e s AscDesc
ascDesc)
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
HeadedParsec e s NullsOrder
nullsOrder)

indexElemDef :: HeadedParsec Void Text IndexElemDef
indexElemDef =
  WhereClause -> IndexElemDef
ExprIndexElemDef forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. Parser a -> Parser a
inParens HeadedParsec Void Text WhereClause
aExpr
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> FuncExprWindowless -> IndexElemDef
FuncIndexElemDef forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HeadedParsec Void Text FuncExprWindowless
funcExprWindowless
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Ident -> IndexElemDef
IdIndexElemDef forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HeadedParsec Void Text Ident
colId

collate :: HeadedParsec Void Text AnyName
collate = forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"collate" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall strm err. Stream strm => HeadedParsec err strm ()
endHead forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text AnyName
anyName

class_ :: HeadedParsec Void Text AnyName
class_ = forall {t :: * -> *}.
Foldable t =>
t Text -> HeadedParsec Void Text AnyName
filteredAnyName [Text
"asc", Text
"desc", Text
"nulls"]

ascDesc :: HeadedParsec e s AscDesc
ascDesc = forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"asc" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> AscDesc
AscAscDesc forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"desc" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> AscDesc
DescAscDesc

nullsOrder :: HeadedParsec e s NullsOrder
nullsOrder = forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"nulls" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall strm err. Stream strm => HeadedParsec err strm ()
endHead forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> (NullsOrder
FirstNullsOrder forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"first" forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> NullsOrder
LastNullsOrder forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
keyword Text
"last")