feat: Implement logical expressions (math, bools).

This commit introduces support for the following logical expressions :

[x] Literal values: "domo", 3.14, 65536
[x] Column references: named (user_id, dept_id..) and index: (1, 2...)
[x] Math expressions: salary * raise_pct
[x] Comparison expressions: salary > 3000, dept != "antimemetics"
[x] Cast expressions : "(id AS INT64)"
[x] Alias expressions: "(user_name AS name)"

With aggregate, scalar functions left for later; tests are also included
for the relevant functionality that we currently support here.

Author: clflushopt

glint/src/main/java/co/clflushopt/glint/query/plan/logical/AliasExpr.java

@@ -0,0 +1,29 @@
+package co.clflushopt.glint.query.plan.logical;
+
+import co.clflushopt.glint.types.Field;
+
+/**
+ * Aliased expression e.g `expr AS alias`.
+ *
+ * AliasExpr
+ */
+public class AliasExpr implements LogicalExpr {
+    private String alias;
+    private LogicalExpr expr;
+
+    public AliasExpr(LogicalExpr expr, String alias) {
+        this.expr = expr;
+        this.alias = alias;
+    }
+
+    @Override
+    public Field toField(LogicalPlan plan) {
+        return new Field(expr.toField(plan).name(), expr.toField(plan).dataType());
+    }
+
+    @Override
+    public String toString() {
+        return String.format("%s AS %s", this.expr, this.alias);
+    }
+
+}

glint/src/main/java/co/clflushopt/glint/query/plan/logical/BinaryExpr.java

@@ -0,0 +1,36 @@
+package co.clflushopt.glint.query.plan.logical;
+
+public abstract class BinaryExpr {
+    private String name;
+    private String operator;
+    private LogicalExpr lhs;
+    private LogicalExpr rhs;
+
+    public BinaryExpr(String name, String operator, LogicalExpr lhs, LogicalExpr rhs) {
+        this.name = name;
+        this.operator = operator;
+        this.lhs = lhs;
+        this.rhs = rhs;
+    }
+
+    @Override
+    public String toString() {
+        return String.format("%s %s %s", lhs.toString(), this.operator, rhs.toString());
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public String getOperator() {
+        return operator;
+    }
+
+    public LogicalExpr getLhs() {
+        return lhs;
+    }
+
+    public LogicalExpr getRhs() {
+        return rhs;
+    }
+}

glint/src/main/java/co/clflushopt/glint/query/plan/logical/BooleanExpr.java

@@ -0,0 +1,111 @@
+package co.clflushopt.glint.query.plan.logical;
+
+import co.clflushopt.glint.types.ArrowTypes;
+import co.clflushopt.glint.types.Field;
+
+/**
+ * Binary expressions that return a boolean value.
+ *
+ * BooleanBinaryExpr
+ */
+public class BooleanExpr extends BinaryExpr implements LogicalExpr {
+
+    public BooleanExpr(String name, String operator, LogicalExpr lhs, LogicalExpr rhs) {
+        super(name, operator, lhs, rhs);
+    }
+
+    @Override
+    public Field toField(LogicalPlan plan) {
+        return new Field(this.getName(), ArrowTypes.BooleanType);
+    }
+
+    /**
+     * Returns an instance of `BooleanBinaryExpr` specialized for equality.
+     *
+     * @param lhs
+     * @param rhs
+     * @return
+     */
+    public static BooleanExpr Eq(LogicalExpr lhs, LogicalExpr rhs) {
+        return new BooleanExpr("eq", "=", lhs, rhs);
+    }
+
+    /**
+     * Returns an instance of `BooleanBinaryExpr` specialized for inequality.
+     *
+     * @param lhs
+     * @param rhs
+     * @return
+     */
+    public static BooleanExpr Neq(LogicalExpr lhs, LogicalExpr rhs) {
+        return new BooleanExpr("neq", "!=", lhs, rhs);
+    }
+
+    /**
+     * Returns an instance of `BooleanBinaryExpr` specialized for greater-than.
+     *
+     * @param lhs
+     * @param rhs
+     * @return
+     */
+    public static BooleanExpr Gt(LogicalExpr lhs, LogicalExpr rhs) {
+        return new BooleanExpr("gt", ">", lhs, rhs);
+    }
+
+    /**
+     * Returns an instance of `BooleanBinaryExpr` specialized for greater-than or
+     * equal.
+     *
+     * @param lhs
+     * @param rhs
+     * @return
+     */
+    public static BooleanExpr Gte(LogicalExpr lhs, LogicalExpr rhs) {
+        return new BooleanExpr("gte", ">=", lhs, rhs);
+    }
+
+    /**
+     * Returns an instance of `BooleanBinaryExpr` specialized for lesser-than.
+     *
+     * @param lhs
+     * @param rhs
+     * @return
+     */
+    public static BooleanExpr Lt(LogicalExpr lhs, LogicalExpr rhs) {
+        return new BooleanExpr("lt", "<", lhs, rhs);
+    }
+
+    /**
+     * Returns an instance of `BooleanBinaryExpr` specialized for lesser-than or
+     * equal.
+     *
+     * @param lhs
+     * @param rhs
+     * @return
+     */
+    public static BooleanExpr Lte(LogicalExpr lhs, LogicalExpr rhs) {
+        return new BooleanExpr("lte", "<=", lhs, rhs);
+    }
+
+    /**
+     * Returns an instance of `BooleanBinaryExpr` specialized for boolean AND.
+     *
+     * @param lhs
+     * @param rhs
+     * @return
+     */
+    public static BooleanExpr And(LogicalExpr lhs, LogicalExpr rhs) {
+        return new BooleanExpr("and", "AND", lhs, rhs);
+    }
+
+    /**
+     * Returns an instance of `BooleanBinaryExpr` specialized for boolean OR.
+     *
+     * @param lhs
+     * @param rhs
+     * @return
+     */
+    public static BooleanExpr Or(LogicalExpr lhs, LogicalExpr rhs) {
+        return new BooleanExpr("or", "OR", lhs, rhs);
+    }
+}

glint/src/main/java/co/clflushopt/glint/query/plan/logical/CastExpr.java

@@ -0,0 +1,32 @@
+package co.clflushopt.glint.query.plan.logical;
+
+import org.apache.arrow.vector.types.pojo.ArrowType;
+
+import co.clflushopt.glint.types.ArrowTypes;
+import co.clflushopt.glint.types.Field;
+
+/**
+ * Cast expression represents explicit type casts `CAST(i AS TYPE)`.
+ *
+ * CastExpr
+ */
+public class CastExpr implements LogicalExpr {
+    private LogicalExpr expr;
+    private ArrowType dataType;
+
+    public CastExpr(LogicalExpr expr, ArrowType dataType) {
+        this.expr = expr;
+        this.dataType = dataType;
+    }
+
+    @Override
+    public Field toField(LogicalPlan plan) {
+        return new Field(expr.toField(plan).name(), dataType);
+    }
+
+    @Override
+    public String toString() {
+        return String.format("CAST(%s AS %s)", this.expr, ArrowTypes.toString(dataType));
+    }
+
+}

glint/src/main/java/co/clflushopt/glint/query/plan/logical/ColumnIndex.java

@@ -0,0 +1,24 @@
+package co.clflushopt.glint.query.plan.logical;
+
+import co.clflushopt.glint.types.Field;
+
+/**
+ * Logical expression representing a referenced column by an index. ColumnIndex
+ */
+public class ColumnIndex implements LogicalExpr {
+    private Integer index;
+
+    public ColumnIndex(Integer index) {
+        this.index = index;
+    }
+
+    @Override
+    public Field toField(LogicalPlan plan) {
+        return plan.getSchema().getFields().get(this.index);
+    }
+
+    @Override
+    public String toString() {
+        return "#" + index.toString();
+    }
+}

glint/src/main/java/co/clflushopt/glint/query/plan/logical/LiteralDouble.java

@@ -0,0 +1,25 @@
+package co.clflushopt.glint.query.plan.logical;
+
+import co.clflushopt.glint.types.ArrowTypes;
+import co.clflushopt.glint.types.Field;
+
+/**
+ * Logical expression representing a Double literal.
+ */
+public class LiteralDouble implements LogicalExpr {
+    private Double value;
+
+    public LiteralDouble(Double value) {
+        this.value = value;
+    }
+
+    @Override
+    public Field toField(LogicalPlan plan) {
+        return new Field(value.toString(), ArrowTypes.DoubleType);
+    }
+
+    @Override
+    public String toString() {
+        return value.toString();
+    }
+}

glint/src/main/java/co/clflushopt/glint/query/plan/logical/LiteralLong.java

@@ -0,0 +1,25 @@
+package co.clflushopt.glint.query.plan.logical;
+
+import co.clflushopt.glint.types.ArrowTypes;
+import co.clflushopt.glint.types.Field;
+
+/**
+ * Logical expression representing a Long literal.
+ */
+public class LiteralLong implements LogicalExpr {
+    private Long value;
+
+    public LiteralLong(Long value) {
+        this.value = value;
+    }
+
+    @Override
+    public Field toField(LogicalPlan plan) {
+        return new Field(value.toString(), ArrowTypes.Int64Type);
+    }
+
+    @Override
+    public String toString() {
+        return value.toString();
+    }
+}

glint/src/main/java/co/clflushopt/glint/query/plan/logical/LiteralString.java

@@ -0,0 +1,26 @@
+package co.clflushopt.glint.query.plan.logical;
+
+import co.clflushopt.glint.types.ArrowTypes;
+import co.clflushopt.glint.types.Field;
+
+/**
+ * Logical expression representing a string literal.
+ */
+public class LiteralString implements LogicalExpr {
+    private String literal;
+
+    public LiteralString(String literal) {
+        this.literal = literal;
+    }
+
+    @Override
+    public Field toField(LogicalPlan plan) {
+        return new Field(literal, ArrowTypes.StringType);
+    }
+
+    @Override
+    public String toString() {
+        return "'" + literal + "'";
+    }
+
+}

glint/src/main/java/co/clflushopt/glint/query/plan/logical/MathExpr.java

@@ -0,0 +1,64 @@
+package co.clflushopt.glint.query.plan.logical;
+
+import co.clflushopt.glint.types.Field;
+
+/**
+ * Mathematical expressions that return a numerical value.
+ *
+ * MathExpr
+ */
+public class MathExpr extends BinaryExpr implements LogicalExpr {
+
+    public MathExpr(String name, String operator, LogicalExpr lhs, LogicalExpr rhs) {
+        super(name, operator, lhs, rhs);
+    }
+
+    @Override
+    public Field toField(LogicalPlan plan) {
+        return new Field(this.getName(), this.getLhs().toField(plan).dataType());
+    }
+
+    /**
+     * Returns an instance of `BinaryExpr` specialized for addition.
+     *
+     * @param lhs
+     * @param rhs
+     * @return
+     */
+    public static MathExpr Add(LogicalExpr lhs, LogicalExpr rhs) {
+        return new MathExpr("add", "+", lhs, rhs);
+    }
+
+    /**
+     * Returns an instance of `BinaryExpr` specialized for substraction.
+     *
+     * @param lhs
+     * @param rhs
+     * @return
+     */
+    public static MathExpr Sub(LogicalExpr lhs, LogicalExpr rhs) {
+        return new MathExpr("sub", "-", lhs, rhs);
+    }
+
+    /**
+     * Returns an instance of `BinaryExpr` specialized for multiplication.
+     *
+     * @param lhs
+     * @param rhs
+     * @return
+     */
+    public static MathExpr Mul(LogicalExpr lhs, LogicalExpr rhs) {
+        return new MathExpr("mul", "*", lhs, rhs);
+    }
+
+    /**
+     * Returns an instance of `BinaryExpr` specialized for division.
+     *
+     * @param lhs
+     * @param rhs
+     * @return
+     */
+    public static MathExpr Div(LogicalExpr lhs, LogicalExpr rhs) {
+        return new MathExpr("div", "/", lhs, rhs);
+    }
+}