feat: Implement a SQL front-end (tokenizer and pratt-based parser)

Author: clflushopt

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

@@ -0,0 +1,43 @@
+package co.clflushopt.glint.sql;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * SQL keywords.
+ *
+ */
+public enum Keyword implements TokenType {
+    SCHEMA, DATABASE, TABLE, COLUMN, VIEW, INDEX, TRIGGER, PROCEDURE, TABLESPACE, FUNCTION,
+    SEQUENCE, CURSOR, FROM, TO, OF, IF, ON, FOR, WHILE, DO, NO, BY, WITH, WITHOUT, TRUE, FALSE,
+    TEMPORARY, TEMP, COMMENT, CREATE, REPLACE, BEFORE, AFTER, INSTEAD, EACH, ROW, STATEMENT,
+    EXECUTE, BITMAP, NOSORT, REVERSE, COMPILE, ALTER, ADD, MODIFY, RENAME, ENABLE, DISABLE,
+    VALIDATE, USER, IDENTIFIED, TRUNCATE, DROP, CASCADE, INSERT, INTO, VALUES, UPDATE, SET, DELETE,
+    SELECT, DISTINCT, AS, CASE, WHEN, ELSE, THEN, END, LEFT, RIGHT, FULL, INNER, OUTER, CROSS, JOIN,
+    USE, USING, NATURAL, WHERE, ORDER, ASC, DESC, GROUP, HAVING, UNION, DECLARE, GRANT, FETCH,
+    REVOKE, CLOSE, CAST, NEW, ESCAPE, LOCK, SOME, LEAVE, ITERATE, REPEAT, UNTIL, OPEN, OUT, INOUT,
+    OVER, ADVISE, SIBLINGS, LOOP, EXPLAIN, DEFAULT, EXCEPT, INTERSECT, MINUS, PASSWORD, LOCAL,
+    GLOBAL, STORAGE, DATA, COALESCE, CHAR, CHARACTER, VARYING, VARCHAR, VARCHAR2, INTEGER, INT,
+    SMALLINT, DECIMAL, DEC, NUMERIC, FLOAT, REAL, DOUBLE, PRECISION, DATE, TIME, INTERVAL, BOOLEAN,
+    BLOB, AND, OR, XOR, IS, NOT, NULL, IN, BETWEEN, LIKE, ANY, ALL, EXISTS, AVG, MAX, MIN, SUM,
+    COUNT, GREATEST, LEAST, ROUND, TRUNC, POSITION, EXTRACT, LENGTH, CHAR_LENGTH, SUBSTRING, SUBSTR,
+    INSTR, INITCAP, UPPER, LOWER, TRIM, LTRIM, RTRIM, BOTH, LEADING, TRAILING, TRANSLATE, CONVERT,
+    LPAD, RPAD, DECODE, NVL, CONSTRAINT, UNIQUE, PRIMARY, FOREIGN, KEY, CHECK, REFERENCES;
+
+    /**
+     * Keyword lookups.
+     *
+     */
+    private static final Map<String, Keyword> KEYWORDS;
+
+    static {
+        KEYWORDS = new HashMap<>();
+        for (Keyword keyword : values()) {
+            KEYWORDS.put(keyword.name(), keyword);
+        }
+    }
+
+    public static Keyword textOf(String text) {
+        return KEYWORDS.get(text.toUpperCase());
+    }
+}

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

@@ -0,0 +1,49 @@
+package co.clflushopt.glint.sql;
+
+/**
+ * Literals for (long, double, string datatypes).
+ *
+ */
+public enum Literal implements TokenType {
+    LONG, DOUBLE, STRING, IDENTIFIER;
+
+    /**
+     * Check if it's a digit or a decimal
+     *
+     * @param ch
+     * @return
+     */
+    public static boolean isNumber(char ch) {
+        return Character.isDigit(ch) || '.' == ch;
+    }
+
+    /**
+     * Check if it's an identifier.
+     *
+     * @param ch
+     * @return
+     */
+    public static boolean isIdentifier(char ch) {
+        return Character.isLetter(ch);
+    }
+
+    /**
+     * Check if we are within a keyword space.
+     *
+     * @param ch
+     * @return
+     */
+    public static boolean isIdentifierPart(char ch) {
+        return Character.isLetter(ch) || Character.isDigit(ch) || ch == '_';
+    }
+
+    /**
+     * Check if we are within a literal space.
+     *
+     * @param ch
+     * @return
+     */
+    public static boolean isCharsStart(char ch) {
+        return '\'' == ch || '"' == ch;
+    }
+}

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

@@ -0,0 +1,261 @@
+package co.clflushopt.glint.sql;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.logging.Logger;
+
+public class Parser {
+    private static final Logger logger = Logger.getLogger(Parser.class.getSimpleName());
+
+    private final TokenStream tokens;
+
+    public Parser(TokenStream tokens) {
+        this.tokens = tokens;
+    }
+
+    public int nextPrecedence() {
+        Token token = tokens.peek();
+        if (token == null) {
+            return 0;
+        }
+
+        int precedence;
+        TokenType type = token.getType();
+
+        if (type == Keyword.AS || type == Keyword.ASC || type == Keyword.DESC) {
+            precedence = 10;
+        } else if (type == Keyword.OR) {
+            precedence = 20;
+        } else if (type == Keyword.AND) {
+            precedence = 30;
+        } else if (type == Symbol.LT || type == Symbol.LT_EQ || type == Symbol.EQ
+                || type == Symbol.BANG_EQ || type == Symbol.GT_EQ || type == Symbol.GT) {
+            precedence = 40;
+        } else if (type == Symbol.PLUS || type == Symbol.SUB) {
+            precedence = 50;
+        } else if (type == Symbol.STAR || type == Symbol.SLASH) {
+            precedence = 60;
+        } else if (type == Symbol.LEFT_PAREN) {
+            precedence = 70;
+        } else {
+            precedence = 0;
+        }
+
+        logger.fine("nextPrecedence(" + token + ") returning " + precedence);
+        return precedence;
+    }
+
+    public SqlExpression parsePrefix() {
+        logger.fine("parsePrefix() next token = " + tokens.peek());
+        Token token = tokens.next();
+        if (token == null) {
+            return null;
+        }
+
+        SqlExpression expr;
+        TokenType type = token.getType();
+
+        if (type == Keyword.SELECT) {
+            expr = parseSelect();
+        } else if (type == Keyword.CAST) {
+            expr = parseCast();
+        } else if (type == Keyword.MAX) {
+            expr = new SqlIdentifier(token.getText());
+        } else if (type == Keyword.INT || type == Keyword.DOUBLE) {
+            expr = new SqlIdentifier(token.getText());
+        } else if (type == Literal.IDENTIFIER) {
+            expr = new SqlIdentifier(token.getText());
+        } else if (type == Literal.STRING) {
+            expr = new SqlString(token.getText());
+        } else if (type == Literal.LONG) {
+            expr = new SqlLong(Long.parseLong(token.getText()));
+        } else if (type == Literal.DOUBLE) {
+            expr = new SqlDouble(Double.parseDouble(token.getText()));
+        } else {
+            throw new IllegalStateException("Unexpected token " + token);
+        }
+
+        logger.fine("parsePrefix() returning " + expr);
+        return expr;
+    }
+
+    public SqlExpression parseInfix(SqlExpression left, int precedence) {
+        logger.fine("parseInfix() next token = " + tokens.peek());
+        Token token = tokens.peek();
+        if (token == null) {
+            throw new IllegalStateException("Unexpected end of input");
+        }
+
+        SqlExpression expr;
+        TokenType type = token.getType();
+
+        if (type == Symbol.PLUS || type == Symbol.SUB || type == Symbol.STAR || type == Symbol.SLASH
+                || type == Symbol.EQ || type == Symbol.GT || type == Symbol.LT) {
+            tokens.next(); // consume the token
+            expr = new SqlBinaryExpression(left, token.getText(), parse(precedence));
+        } else if (type == Keyword.AS) {
+            tokens.next(); // consume the token
+            expr = new SqlAlias(left, parseIdentifier());
+        } else if (type == Keyword.AND || type == Keyword.OR) {
+            tokens.next(); // consume the token
+            expr = new SqlBinaryExpression(left, token.getText(), parse(precedence));
+        } else if (type == Keyword.ASC || type == Keyword.DESC) {
+            tokens.next();
+            expr = new SqlSort(left, type == Keyword.ASC);
+        } else if (type == Symbol.LEFT_PAREN) {
+            if (left instanceof SqlIdentifier) {
+                tokens.next(); // consume the token
+                List<SqlExpression> args = parseExprList();
+                Token next = tokens.next();
+                if (next == null || next.getType() != Symbol.RIGHT_PAREN) {
+                    throw new IllegalStateException("Expected right parenthesis");
+                }
+                expr = new SqlFunction(((SqlIdentifier) left).getId(), args);
+            } else {
+                throw new IllegalStateException("Unexpected LPAREN");
+            }
+        } else {
+            throw new IllegalStateException("Unexpected infix token " + token);
+        }
+
+        logger.fine("parseInfix() returning " + expr);
+        return expr;
+    }
+
+    private List<SqlExpression> parseOrder() {
+        List<SqlExpression> sortList = new ArrayList<>();
+        SqlExpression sort = parseExpr();
+
+        while (sort != null) {
+            if (sort instanceof SqlIdentifier) {
+                sort = new SqlSort(sort, true);
+            } else if (!(sort instanceof SqlSort)) {
+                throw new IllegalStateException(
+                        "Unexpected expression " + sort + " after order by.");
+            }
+
+            sortList.add((SqlSort) sort);
+
+            if (tokens.peek() != null && tokens.peek().getType() == Symbol.COMMA) {
+                tokens.next();
+            } else {
+                break;
+            }
+            sort = parseExpr();
+        }
+        return sortList;
+    }
+
+    private SqlCast parseCast() {
+        if (!tokens.consumeTokenType(Symbol.LEFT_PAREN)) {
+            throw new IllegalStateException("Expected left parenthesis");
+        }
+
+        SqlExpression expr = parseExpr();
+        if (expr == null) {
+            throw new RuntimeException("Expected expression in CAST");
+        }
+
+        if (!(expr instanceof SqlAlias)) {
+            throw new IllegalStateException("Expected AS in CAST");
+        }
+
+        SqlAlias alias = (SqlAlias) expr;
+
+        if (!tokens.consumeTokenType(Symbol.RIGHT_PAREN)) {
+            throw new IllegalStateException("Expected right parenthesis");
+        }
+
+        return new SqlCast(alias.getExpr(), alias.getAlias());
+    }
+
+    private SqlSelect parseSelect() {
+        List<SqlExpression> projection = parseExprList();
+
+        if (!tokens.consumeKeyword("FROM")) {
+            throw new IllegalStateException("Expected FROM keyword, found " + tokens.peek());
+        }
+
+        SqlExpression tableExpr = parseExpr();
+        if (!(tableExpr instanceof SqlIdentifier)) {
+            throw new IllegalStateException("Expected table name");
+        }
+        SqlIdentifier table = (SqlIdentifier) tableExpr;
+
+        // parse optional WHERE clause
+        SqlExpression filterExpr = null;
+        if (tokens.consumeKeyword("WHERE")) {
+            filterExpr = parseExpr();
+        }
+
+        // parse optional GROUP BY clause
+        List<SqlExpression> groupBy = Collections.emptyList();
+        if (tokens.consumeKeywords(Arrays.asList("GROUP", "BY"))) {
+            groupBy = parseExprList();
+        }
+
+        // parse optional HAVING clause
+        SqlExpression havingExpr = null;
+        if (tokens.consumeKeyword("HAVING")) {
+            havingExpr = parseExpr();
+        }
+
+        // parse optional ORDER BY clause
+        List<SqlExpression> orderBy = Collections.emptyList();
+        if (tokens.consumeKeywords(Arrays.asList("ORDER", "BY"))) {
+            orderBy = parseOrder();
+        }
+
+        return new SqlSelect(projection, filterExpr, groupBy, orderBy, havingExpr, table.getId());
+    }
+
+    private List<SqlExpression> parseExprList() {
+        logger.fine("parseExprList()");
+        List<SqlExpression> list = new ArrayList<>();
+        SqlExpression expr = parseExpr();
+
+        while (expr != null) {
+            list.add(expr);
+
+            if (tokens.peek() != null && tokens.peek().getType() == Symbol.COMMA) {
+                tokens.next();
+            } else {
+                break;
+            }
+            expr = parseExpr();
+        }
+
+        logger.fine("parseExprList() returning " + list);
+        return list;
+    }
+
+    private SqlExpression parseExpr() {
+        return parse(0);
+    }
+
+    private SqlIdentifier parseIdentifier() {
+        SqlExpression expr = parseExpr();
+        if (expr == null) {
+            throw new RuntimeException("Expected identifier, found EOF");
+        }
+        if (!(expr instanceof SqlIdentifier)) {
+            throw new RuntimeException("Expected identifier, found " + expr);
+        }
+        return (SqlIdentifier) expr;
+    }
+
+    protected SqlExpression parse(int precedence) {
+        SqlExpression left = parsePrefix();
+        if (left == null) {
+            return null;
+        }
+
+        while (precedence < nextPrecedence()) {
+            left = parseInfix(left, precedence);
+        }
+
+        return left;
+    }
+}