fix: Parsing bugs (as always) via some nice little tests

Author: clflushopt

glint/src/main/java/co/clflushopt/glint/sql/Parser.java

@@ -4,6 +4,7 @@
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
+import java.util.logging.Level;
 import java.util.logging.Logger;
 
 public class Parser {
@@ -13,6 +14,11 @@ public class Parser {
 
     public Parser(TokenStream tokens) {
         this.tokens = tokens;
+        logger.setLevel(Level.FINE);
+    }
+
+    public SqlExpression parse() {
+        return parse(0);
     }
 
     public int nextPrecedence() {
@@ -253,7 +259,7 @@ protected SqlExpression parse(int precedence) {
         }
 
         while (precedence < nextPrecedence()) {
-            left = parseInfix(left, precedence);
+            left = parseInfix(left, nextPrecedence());
         }
 
         return left;

glint/src/main/java/co/clflushopt/glint/sql/SqlBinaryExpression.java

@@ -31,7 +31,7 @@ public SqlExpression getRight() {
 
     @Override
     public String toString() {
-        return left + " " + operator + " " + right;
+        return "(" + left + " " + operator + " " + right + ")";
     }
 
     @Override

glint/src/test/java/co/clflushopt/glint/sql/ParserTest.java

@@ -0,0 +1,58 @@
+package co.clflushopt.glint.sql;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import java.util.List;
+
+import org.junit.Test;
+
+public class ParserTest {
+
+    @Test
+    public void canParseArithmeticExpressions() {
+        var sql = "1 + 2 * 3";
+        var tokens = new Tokenizer(sql).tokenize();
+        var actual = new Parser(tokens).parse();
+        var expected = new SqlBinaryExpression(new SqlLong(1), "+",
+                new SqlBinaryExpression(new SqlLong(2), "*", new SqlLong(3)));
+
+        assertEquals(actual, expected);
+    }
+
+    @Test
+    public void canParseArithmeticExpressionWithLeftPrec() {
+        var sql = "1 * 2 + 3";
+        var tokens = new Tokenizer(sql).tokenize();
+        var actual = new Parser(tokens).parse();
+        var expected = new SqlBinaryExpression(
+                new SqlBinaryExpression(new SqlLong(1), "*", new SqlLong(2)), "+", new SqlLong(3));
+
+        assertEquals(actual, expected);
+    }
+
+    @Test
+    public void canParseSimpleSelectStatement() {
+        var sql = "SELECT id, first_name FROM employees";
+        var tokens = new Tokenizer(sql).tokenize();
+        var actual = new Parser(tokens).parse();
+        assertTrue(actual instanceof SqlSelect);
+        var select = (SqlSelect) actual;
+        assertEquals(select.getTableName(), "employees");
+        assertEquals(select.getProjection(),
+                List.of(new SqlIdentifier("id"), new SqlIdentifier("first_name")));
+    }
+
+    @Test
+    public void canParseSelectStatementWithBinaryExpression() {
+        var sql = "SELECT salary * 0.1 FROM employees";
+        var tokens = new Tokenizer(sql).tokenize();
+        var actual = new Parser(tokens).parse();
+        assertTrue(actual instanceof SqlSelect);
+        var select = (SqlSelect) actual;
+        assertEquals(select.getTableName(), "employees");
+        assertEquals(select.getProjection(), List
+                .of(new SqlBinaryExpression(new SqlIdentifier("salary"), "*", new SqlDouble(0.1))));
+
+    }
+}

glint/src/test/java/co/clflushopt/glint/sql/TokenizerTest.java

@@ -10,7 +10,7 @@
 public class TokenizerTest {
 
     @Test
-    public void testTokenizeSimpleSelect() {
+    public void canTokenizeSimpleSelect() {
         List<Token> expected = Arrays.asList(new Token("SELECT", Keyword.SELECT, 6),
                 new Token("id", Literal.IDENTIFIER, 9), new Token(",", Symbol.COMMA, 10),
                 new Token("first_name", Literal.IDENTIFIER, 21), new Token(",", Symbol.COMMA, 22),
@@ -24,7 +24,7 @@ public void testTokenizeSimpleSelect() {
     }
 
     @Test
-    public void testProjectionWithBinaryExpression() {
+    public void canTokenizeProjectionWithBinaryExpression() {
         List<Token> expected = Arrays.asList(new Token("SELECT", Keyword.SELECT, 6),
                 new Token("salary", Literal.IDENTIFIER, 13), new Token("*", Symbol.STAR, 15),
                 new Token("0.1", Literal.DOUBLE, 19), new Token("FROM", Keyword.FROM, 24),
@@ -51,7 +51,7 @@ public void testProjectionWithAliasedBinaryExpression() {
     }
 
     @Test
-    public void testTokenizeSelectWithWhere() {
+    public void canTokenizeSelectWithWhere() {
         List<Token> expected = Arrays.asList(new Token("SELECT", Keyword.SELECT, 6),
                 new Token("a", Literal.IDENTIFIER, 8), new Token(",", Symbol.COMMA, 9),
                 new Token("b", Literal.IDENTIFIER, 11), new Token("FROM", Keyword.FROM, 16),
@@ -66,7 +66,7 @@ public void testTokenizeSelectWithWhere() {
     }
 
     @Test
-    public void testTokenizeSelectWithAggregates() {
+    public void canTokenizeSelectWithAggregates() {
         List<Token> expected = Arrays.asList(new Token("SELECT", Keyword.SELECT, 6),
                 new Token("state", Literal.IDENTIFIER, 12), new Token(",", Symbol.COMMA, 13),
                 new Token("MAX", Keyword.MAX, 17), new Token("(", Symbol.LEFT_PAREN, 18),
@@ -82,7 +82,7 @@ public void testTokenizeSelectWithAggregates() {
     }
 
     @Test
-    public void testTokenizeSelectWithAggregatesAndHaving() {
+    public void canTokenizeSelectWithAggregatesAndHaving() {
         List<Token> expected = Arrays.asList(new Token("SELECT", Keyword.SELECT, 6),
                 new Token("state", Literal.IDENTIFIER, 12), new Token(",", Symbol.COMMA, 13),
                 new Token("MAX", Keyword.MAX, 17), new Token("(", Symbol.LEFT_PAREN, 18),
@@ -102,7 +102,7 @@ public void testTokenizeSelectWithAggregatesAndHaving() {
     }
 
     @Test
-    public void testTokenizeCompoundOperators() {
+    public void canTokenizeCompoundOperators() {
         List<Token> expected = Arrays.asList(new Token("a", Literal.IDENTIFIER, 1),
                 new Token(">=", Symbol.GT_EQ, 4), new Token("b", Literal.IDENTIFIER, 6),
                 new Token("OR", Keyword.OR, 9), new Token("a", Literal.IDENTIFIER, 11),
@@ -119,7 +119,7 @@ public void testTokenizeCompoundOperators() {
     }
 
     @Test
-    public void testTokenizeLongValues() {
+    public void canTokenizeLongValues() {
         List<Token> expected = Arrays.asList(new Token("123456789", Literal.LONG, 9),
                 new Token("+", Symbol.PLUS, 11), new Token("987654321", Literal.LONG, 21));
 
@@ -129,7 +129,7 @@ public void testTokenizeLongValues() {
     }
 
     @Test
-    public void testTokenizeFloatDoubleValues() {
+    public void canTokenizeFloatDoubleValues() {
         List<Token> expected = Arrays.asList(new Token("123456789.00", Literal.DOUBLE, 12),
                 new Token("+", Symbol.PLUS, 14), new Token("987654321.001", Literal.DOUBLE, 28));
 
@@ -139,7 +139,7 @@ public void testTokenizeFloatDoubleValues() {
     }
 
     @Test
-    public void testTokenizeTableGroup() {
+    public void canTokenizeTableGroup() {
         List<Token> expected = Arrays.asList(new Token("select", Keyword.SELECT, 6),
                 new Token("*", Symbol.STAR, 8), new Token("from", Keyword.FROM, 13),
                 new Token("group", Literal.IDENTIFIER, 19));