Add quasar regression test examples, bugfixes

Author: natefaubion

src/SqlSquared/Parser.purs

@@ -20,7 +20,7 @@ import Data.Either as E
 import Data.Foldable as F
 import Data.List ((:))
 import Data.List as L
-import Data.Maybe (Maybe(..), fromMaybe, isJust, maybe)
+import Data.Maybe (Maybe(..), fromMaybe, isJust)
 import Data.NonEmpty ((:|))
 import Data.Json.Extended as EJ
 import Data.Tuple (Tuple(..), uncurry)
@@ -88,7 +88,7 @@ prettyParse parser input =
       nums = A.mapWithIndex (\n l → padLeft 4 (show (n + pos.line - (A.length pre))) <> " | " <> l) (pre <> line <> post)
       pointer = pure $ S.fromCharArray (A.replicate (pos.column - 1 + 7) '-') <> "^ " <> message
     in
-      S.joinWith "\n" $ A.take 3 nums <> pointer <> A.drop 3 nums
+      S.joinWith "\n" $ A.take (A.length pre + 1) nums <> pointer <> A.drop 3 nums
 
 parse
   ∷ ∀ t
@@ -215,7 +215,7 @@ andExpr = prod cmpExpr (keyword "and") $ _BINOP' Sig.And
 cmpExpr ∷ ∀ m t. SqlParser' m t
 cmpExpr = do
   e ← defaultExpr
-  modifiers ← A.many $ negatableSuffix <|> relationalSuffix
+  modifiers ← A.many $ PC.try negatableSuffix <|> relationalSuffix
   pure $ F.foldl (\acc fn → fn acc) e modifiers
 
 defaultExpr ∷ ∀ m t. SqlParser' m t
@@ -280,7 +280,7 @@ derefExpr = do
 
   fieldDeref = do
     operator "."
-    k ← ident
+    k ← ident <|> anyKeyword <|> stringLiteral
     pure \e → C.binop Sig.FieldDeref e (C.ident k)
 
   fieldDerefExpr = do
@@ -385,7 +385,7 @@ unaryOperator = do
 
 functionExpr ∷ ∀ m t. SqlParser' m t
 functionExpr = PC.try do
-  name ← ident
+  name ← ident <|> anyKeyword
   args ← parenList
   pure $ C.invokeFunction name args
 
@@ -427,15 +427,20 @@ variableString = asErrorMessage "variable" $ PC.try do
   pure s
 
 literal ∷ ∀ m t. SqlParser' m t
-literal = PC.tryRethrow $ token >>= case _ of
+literal = withToken "literal" case _ of
   Lit (String s) → pure $ embed $ Sig.Literal $ EJ.String s
   Lit (Integer i) → pure $ embed $ Sig.Literal $ EJ.Integer i
   Lit (Decimal d) → pure $ embed $ Sig.Literal $ EJ.Decimal d
   Kw s
     | s == "null" → pure $ embed $ Sig.Literal $ EJ.Null
     | s == "true" → pure $ embed $ Sig.Literal $ EJ.Boolean true
     | s == "false" → pure $ embed $ Sig.Literal $ EJ.Boolean false
-  _ → P.fail "incorrect literal"
+  _ → P.fail "not a literal"
+
+stringLiteral ∷ ∀ m. Monad m ⇒ P.ParserT TokenStream m String
+stringLiteral = withToken "string literal" case _ of
+  Lit (String s) → pure s
+  _ → P.fail "not a string"
 
 arrayLiteral ∷ ∀ m t. SqlParser' m t
 arrayLiteral = do
@@ -461,11 +466,10 @@ keyValuePair = do
 negatableSuffix ∷ ∀ m t. SqlParser m t (t → t)
 negatableSuffix = do
   inv ← do
-    _ ← PC.optionMaybe $ keyword "is"
+    _ ← PC.optionMaybe (keyword "is")
     n ← PC.optionMaybe $ keyword "not"
     pure $ isJust n
-  suffix ← asErrorMessage "`LIKE`, `IN`, or `BETWEEN`" do
-    betweenSuffix <|> inSuffix <|> likeSuffix
+  suffix ← betweenSuffix <|> inSuffix <|> likeSuffix
   pure \e → (if inv then _NOT else id) $ suffix e
 
 betweenSuffix ∷ ∀ m t. SqlParser m t (t → t)
@@ -563,12 +567,8 @@ tableRelation = do
     Pt.parsePath
       (const $ P.fail "incorrect path")
       (const $ P.fail "incorrect path")
-      (maybe (P.fail "incorrect path")
-       (pure ∘ E.Right)
-       ∘ Pt.sandbox Pt.currentDir)
-      (maybe (P.fail "incorrect path")
-       (pure ∘ E.Left ∘ (Pt.rootDir Pt.</> _))
-       ∘ Pt.sandbox Pt.rootDir)
+      (pure ∘ E.Right)
+      (pure ∘ E.Left)
       i
   a ← PC.optionMaybe do
     _ ← keyword "as"

src/SqlSquared/Parser/Tokenizer.purs

@@ -12,12 +12,16 @@ import Prelude
 import Control.Alt ((<|>))
 import Control.Monad.State (get)
 import Data.Array as A
+import Data.Char as Char
 import Data.Either (Either)
 import Data.HugeInt as HI
 import Data.HugeNum as HN
+import Data.Int as Int
 import Data.Json.Extended.Signature.Parse as EJP
+import Data.Maybe (Maybe(..))
 import Data.Set as Set
 import Data.String as S
+import Data.Traversable (sequence)
 import SqlSquared.Utils ((∘))
 import Text.Parsing.Parser as P
 import Text.Parsing.Parser.Pos as PP
@@ -182,7 +186,7 @@ identOrKeyword = PC.try quotedIdent <|> notQuotedIdentOrKeyword
 
 oneLineComment ∷ ∀ m. Monad m ⇒ P.ParserT String m Token
 oneLineComment =
-  PC.between (PC.try $ PS.string "--") (PS.string "\n")
+  PC.between (PS.string "--") (PS.string "\n")
     $ map (Comment ∘ S.fromCharArray)
     $ A.many $ PS.satisfy
     $ not ∘ eq '\n'
@@ -234,6 +238,23 @@ numLit = Lit ∘ Decimal <$> EJP.parseDecimalLiteral
 intLit ∷ ∀ m. Monad m ⇒ P.ParserT String m Token
 intLit = Lit ∘ Integer <$> EJP.parseHugeIntLiteral
 
+charLit ∷ ∀ m. Monad m ⇒ P.ParserT String m Token
+charLit = PS.char '\'' *> charAtom <* PS.char '\''
+  where
+  charAtom = PC.tryRethrow do
+    ch ← PS.anyChar
+    Lit ∘ String ∘ S.singleton <$> case ch of
+      '\'' → P.fail "Expected character"
+      '\\' → charEscape <|> PS.anyChar
+      _    → pure ch
+
+  charEscape = do
+    _ ← PS.char 'u'
+    hex ← S.fromCharArray <$> sequence (A.replicate 4 PT.hexDigit)
+    case Int.fromStringAs Int.hexadecimal hex of
+      Nothing → P.fail "Expected character escape sequence"
+      Just i → pure $ Char.fromCharCode i
+
 positioned ∷ ∀ m. Monad m ⇒ P.ParserT String m Token → P.ParserT String m PositionedToken
 positioned m = do
   P.ParseState _ position _ ← get
@@ -247,13 +268,14 @@ tokens = do
     , skipped multiLineComment
     , skipped op
     , skipped identOrKeyword
-    , skipped numLit
+    , skipped (PC.try numLit)
     , skipped intLit
     , skipped stringLit
+    , skipped charLit
     ]
   where
-  skipped r = PC.try (r <* PS.skipSpaces)
+  skipped r = r <* PS.skipSpaces
 
 tokenize ∷ String → Either P.ParseError TokenStream
 tokenize input =
-  A.filter (not ∘ isComment ∘ _.token) <$>  P.runParser input tokens
+  A.filter (not ∘ isComment ∘ _.token) <$>  P.runParser input (tokens <* PS.eof)