diff --git a/Language/SQL/SimpleSQL/Dialect.lhs b/Language/SQL/SimpleSQL/Dialect.lhs
index 59a5191..17229cf 100644
--- a/Language/SQL/SimpleSQL/Dialect.lhs
+++ b/Language/SQL/SimpleSQL/Dialect.lhs
@@ -5,7 +5,6 @@ Data types to represent different dialect options
> {-# LANGUAGE DeriveDataTypeable #-}
> module Language.SQL.SimpleSQL.Dialect
> (Dialect(..)
-> ,SyntaxFlavour(..)
> ,ansi2011
> ,mysql
> ,postgres
@@ -16,49 +15,78 @@ Data types to represent different dialect options
> import Data.Data
-
-hack for now, later will expand to flags on a feature by feature basis
-
-> data SyntaxFlavour = ANSI2011
-> | MySQL
-> | Postgres
-> | Oracle
-> | SQLServer
-> deriving (Eq,Show,Read,Data,Typeable)
-
> -- | Used to set the dialect used for parsing and pretty printing,
> -- very unfinished at the moment.
-> data Dialect = Dialect {diKeywords :: [String]
-> ,diSyntaxFlavour :: SyntaxFlavour
-> ,diFetchFirst :: Bool
-> ,diLimit :: Bool
-> ,diOdbc :: Bool}
+> data Dialect = Dialect
+> { -- | The list of reserved keywords
+> diKeywords :: [String]
+> -- | does the dialect support ansi fetch first syntax
+> ,diFetchFirst :: Bool
+> -- | does the dialect support limit keyword (mysql, postgres, ...)
+> ,diLimit :: Bool
+> -- | allow parsing ODBC syntax
+> ,diOdbc :: Bool
+> -- | allow quoting identifiers with `backquotes`
+> ,diBackquotedIden :: Bool
+> -- | allow quoting identifiers with [square brackets]
+> ,diSquareBracketQuotedIden :: Bool
+> -- | allow identifiers with a leading at @example
+> ,diAtIdentifier :: Bool
+> -- | allow identifiers with a leading # #example
+> ,diHashIdentifier :: Bool
+> -- | allow positional identifiers like this: $1
+> ,diPositionalArg :: Bool
+> -- | allow postgres style dollar strings
+> ,diDollarString :: Bool
+> -- | allow strings with an e - e"example"
+> ,diEString :: Bool
+> -- | allow postgres style symbols
+> ,diPostgresSymbols :: Bool
+> -- | allow sql server style symbols
+> ,diSqlServerSymbols :: Bool
+> }
> deriving (Eq,Show,Read,Data,Typeable)
> -- | ansi sql 2011 dialect
> ansi2011 :: Dialect
> ansi2011 = Dialect {diKeywords = ansi2011ReservedKeywords
-> ,diSyntaxFlavour = ANSI2011
> ,diFetchFirst = True
> ,diLimit = False
-> ,diOdbc = False}
+> ,diOdbc = False
+> ,diBackquotedIden = False
+> ,diSquareBracketQuotedIden = False
+> ,diAtIdentifier = False
+> ,diHashIdentifier = False
+> ,diPositionalArg = False
+> ,diDollarString = False
+> ,diEString = False
+> ,diPostgresSymbols = False
+> ,diSqlServerSymbols = False
+> }
> -- | mysql dialect
> mysql :: Dialect
-> mysql = addLimit ansi2011 {diSyntaxFlavour = MySQL
-> ,diFetchFirst = False }
+> mysql = addLimit ansi2011 {diFetchFirst = False
+> ,diBackquotedIden = True
+> }
> -- | postgresql dialect
> postgres :: Dialect
-> postgres = addLimit ansi2011 {diSyntaxFlavour = Postgres}
+> postgres = addLimit ansi2011 {diPositionalArg = True
+> ,diDollarString = True
+> ,diEString = True
+> ,diPostgresSymbols = True}
> -- | oracle dialect
> oracle :: Dialect
-> oracle = ansi2011 {diSyntaxFlavour = Oracle}
+> oracle = ansi2011 -- {}
> -- | microsoft sql server dialect
> sqlserver :: Dialect
-> sqlserver = ansi2011 {diSyntaxFlavour = SQLServer}
+> sqlserver = ansi2011 {diSquareBracketQuotedIden = True
+> ,diAtIdentifier = True
+> ,diHashIdentifier = True
+> ,diSqlServerSymbols = True }
> addLimit :: Dialect -> Dialect
> addLimit d = d {diKeywords = "limit": diKeywords d
diff --git a/Language/SQL/SimpleSQL/Lex.lhs b/Language/SQL/SimpleSQL/Lex.lhs
index 01c4192..83eab3e 100644
--- a/Language/SQL/SimpleSQL/Lex.lhs
+++ b/Language/SQL/SimpleSQL/Lex.lhs
@@ -174,8 +174,8 @@ u&"unicode quoted identifier"
> [quotedIden
> ,unicodeQuotedIden
> ,regularIden
-> ,guard (diSyntaxFlavour d == MySQL) >> mySqlQuotedIden
-> ,guard (diSyntaxFlavour d == SQLServer) >> sqlServerQuotedIden
+> ,guard (diBackquotedIden d) >> mySqlQuotedIden
+> ,guard (diSquareBracketQuotedIden d) >> sqlServerQuotedIden
> ]
> where
> regularIden = Identifier Nothing <$> identifierString
@@ -217,15 +217,15 @@ use try because : and @ can be part of other things also
> prefixedVariable :: Dialect -> Parser Token
> prefixedVariable d = try $ choice
> [PrefixedVariable <$> char ':' <*> identifierString
-> ,guard (diSyntaxFlavour d == SQLServer) >>
+> ,guard (diAtIdentifier d) >>
> PrefixedVariable <$> char '@' <*> identifierString
-> ,guard (diSyntaxFlavour d == SQLServer) >>
+> ,guard (diHashIdentifier d) >>
> PrefixedVariable <$> char '#' <*> identifierString
> ]
> positionalArg :: Dialect -> Parser Token
> positionalArg d =
-> guard (diSyntaxFlavour d == Postgres) >>
+> guard (diPositionalArg d) >>
> -- use try to avoid ambiguities with other syntax which starts with dollar
> PositionalArg <$> try (char '$' *> (read <$> many1 digit))
@@ -243,7 +243,7 @@ x'hexidecimal string'
> sqlString d = dollarString <|> csString <|> normalString
> where
> dollarString = do
-> guard $ diSyntaxFlavour d == Postgres
+> guard $ diDollarString d
> -- use try because of ambiguity with symbols and with
> -- positional arg
> delim <- (\x -> concat ["$",x,"$"])
@@ -270,7 +270,7 @@ x'hexidecimal string'
> -- error messages and user predictability make it a good
> -- pragmatic choice
> csString
-> | diSyntaxFlavour d == Postgres =
+> | diEString d =
> choice [SqlString <$> try (string "e'" <|> string "E'")
> <*> return "'" <*> normalStringSuffix True ""
> ,csString']
@@ -304,7 +304,7 @@ constant.
> SqlNumber <$> completeNumber
> -- this is for definitely avoiding possibly ambiguous source
> <* choice [-- special case to allow e.g. 1..2
-> guard (diSyntaxFlavour d == Postgres)
+> guard (diPostgresSymbols d)
> *> (void $ lookAhead $ try $ string "..")
> <|> void (notFollowedBy (oneOf "eE."))
> ,notFollowedBy (oneOf "eE.")
@@ -324,7 +324,7 @@ constant.
> -- special case for postgresql, we backtrack if we see two adjacent dots
> -- to parse 1..2, but in other dialects we commit to the failure
> dot = let p = string "." <* notFollowedBy (char '.')
-> in if (diSyntaxFlavour d == Postgres)
+> in if diPostgresSymbols d
> then try p
> else p
> expon = (:) <$> oneOf "eE" <*> sInt
@@ -342,12 +342,12 @@ compared with ansi and other dialects
> symbol :: Dialect -> Parser Token
> symbol d = Symbol <$> choice (concat
> [dots
-> ,if (diSyntaxFlavour d == Postgres)
+> ,if diPostgresSymbols d
> then postgresExtraSymbols
> else []
> ,miscSymbol
> ,if diOdbc d then odbcSymbol else []
-> ,if (diSyntaxFlavour d == Postgres)
+> ,if diPostgresSymbols d
> then generalizedPostgresqlOperator
> else basicAnsiOps
> ])
@@ -360,10 +360,10 @@ compared with ansi and other dialects
> ,try (string "::" <* notFollowedBy (char ':'))
> ,try (string ":" <* notFollowedBy (char ':'))]
> miscSymbol = map (string . (:[])) $
-> case diSyntaxFlavour d of
-> SQLServer -> ",;():?"
-> Postgres -> "[],;()"
-> _ -> "[],;():?"
+> case () of
+> _ | diSqlServerSymbols d -> ",;():?"
+> | diPostgresSymbols d -> "[],;()"
+> | otherwise -> "[],;():?"
try is used because most of the first characters of the two character
symbols can also be part of a single character symbol
@@ -562,7 +562,7 @@ followed by = or : makes a different symbol
two symbols next to eachother will fail if the symbols can combine and
(possibly just the prefix) look like a different symbol
-> | Dialect {diSyntaxFlavour = Postgres} <- d
+> | diPostgresSymbols d
> , Symbol a' <- a
> , Symbol b' <- b
> , b' `notElem` ["+", "-"] || or (map (`elem` a') "~!@#%^&|`?") = False