replace field string list with SelectableExpression list in SelectExpression

src/main/java/jef/DBSet.java

@@ -3,6 +3,7 @@ package jef;
 import jef.expressions.Expression;
 import jef.expressions.SelectExpression;
 import jef.expressions.TableExpression;
+import jef.expressions.selectable.DatabaseSelectAllExpression;
 
 import java.io.Serializable;
 import java.util.Iterator;
@@ -23,7 +24,7 @@ public class DBSet<T extends Serializable> implements Queryable<T> {
 
     @Override
     public Expression getExpression() {
-        return new SelectExpression(List.of("*"), new TableExpression(table), "");
+        return new SelectExpression(List.of(new DatabaseSelectAllExpression()), new TableExpression(table), "");
     }
 
     @Override

src/main/java/jef/Queryable.java

@@ -1,6 +1,7 @@
 package jef;
 
 import jef.expressions.Expression;
+import jef.operations.CountOp;
 import jef.operations.FilterOp;
 import jef.serializable.SerializablePredicate;
 
@@ -52,7 +53,7 @@ public interface Queryable<T extends Serializable> {
 
     //stream
     default Queryable<T> filter(SerializablePredicate<? super T> predicate) {
-        return new FilterOp<T>(this, predicate);
+        return new FilterOp<>(this, predicate);
     }
 
 //    default <R extends Serializable> Queryable<R> map(Function<? super T, ? extends R> function) {

src/main/java/jef/asm/FilterMethodVisitor.java

@@ -3,7 +3,7 @@ package jef.asm;
 import jef.expressions.BinaryExpression;
 import jef.expressions.ConstantExpression;
 import jef.expressions.Expression;
-import jef.expressions.FieldExpression;
+import jef.expressions.IntermediateFieldExpression;
 import jef.expressions.NullExpression;
 import jef.expressions.ParameterExpression;
 import jef.expressions.SelectExpression;
@@ -11,6 +11,7 @@ import jef.expressions.TableExpression;
 import jef.expressions.TernaryExpression;
 import jef.expressions.UnaryExpression;
 import jef.expressions.WhereExpression;
+import jef.expressions.selectable.DatabaseSelectAllExpression;
 import lombok.ToString;
 import org.objectweb.asm.Attribute;
 import org.objectweb.asm.Label;
@@ -66,7 +67,7 @@ class FilterMethodVisitor extends MethodVisitor {
             var v = varStack.pop();
             if (v instanceof ParameterExpression p) {
                 if (p.isInput()) {
-                    varStack.push(new FieldExpression(name, descriptor));
+                    varStack.push(new IntermediateFieldExpression(name, descriptor));
                 } else {
                     throw new RuntimeException("field insn: unsupported GETFIELD expression");
                 }
@@ -106,7 +107,7 @@ class FilterMethodVisitor extends MethodVisitor {
                         var v = varStack.pop();
                         if (v instanceof ParameterExpression p) {
                             if (p.isInput()) {
-                                varStack.push(new FieldExpression(field.get().getName(), descriptor.substring(2)));
+                                varStack.push(new IntermediateFieldExpression(field.get().getName(), descriptor.substring(2)));
                             } else {
                                 throw new RuntimeException("method insn: getter support only to predicate parameter");
                             }
@@ -463,7 +464,7 @@ class FilterMethodVisitor extends MethodVisitor {
 
     private void debugExpr() {
         if (!varStack.isEmpty()) {
-            System.out.println("-------------------> " + new WhereExpression(new SelectExpression(List.of("*"), new TableExpression("dummy"), ""), varStack.peek()));
+            System.out.println("-------------------> " + new WhereExpression(new SelectExpression(List.of(new DatabaseSelectAllExpression()), new TableExpression("dummy"), ""), varStack.peek()));
         }
     }
 

src/main/java/jef/expressions/Expression.java

@@ -13,6 +13,7 @@ public interface Expression {
         BINARY,
         CONSTANT,
         FIELD,
+        INTERMEDIATE_FIELD,
         NULL,
         OR,
         PARAMETER,

src/main/java/jef/expressions/FieldExpression.java

@@ -1,14 +1,19 @@
 package jef.expressions;
 
+import jef.expressions.selectable.SelectableExpression;
 import lombok.Getter;
 
 @Getter
-public class FieldExpression extends ConstantExpression implements Expression {
+public class FieldExpression extends ConstantExpression implements SelectableExpression, Expression {
+    private final String schema;
+    private final String table;
     private final String name;
     private final String classDescriptor;
 
-    public FieldExpression(String name, String classDescriptor) {
+    public FieldExpression(String schema, String table, String name, String classDescriptor) {
         super(name);
+        this.schema = schema;
+        this.table = table;
         this.name = name;
         this.classDescriptor = classDescriptor;
     }
@@ -20,6 +25,8 @@ public class FieldExpression extends ConstantExpression implements Expression {
 
     @Override
     public String toString() {
-        return name;
+        return (schema != null && !schema.isEmpty() ? "`" + schema + "`." : "")
+                + (table != null && !table.isEmpty() ? "`" + table + "`." : "")
+                + "`" + name + "`";
     }
 }

src/main/java/jef/expressions/IntermediateFieldExpression.java

@@ -0,0 +1,26 @@
+package jef.expressions;
+
+import jef.expressions.selectable.SelectableExpression;
+import lombok.Getter;
+
+@Getter
+public class IntermediateFieldExpression extends ConstantExpression implements SelectableExpression, Expression {
+    private final String name;
+    private final String classDescriptor;
+
+    public IntermediateFieldExpression(String name, String classDescriptor) {
+        super(name);
+        this.name = name;
+        this.classDescriptor = classDescriptor;
+    }
+
+    @Override
+    public Type getType() {
+        return Type.INTERMEDIATE_FIELD;
+    }
+
+    @Override
+    public String toString() {
+        return name;
+    }
+}

src/main/java/jef/expressions/SelectExpression.java

@@ -1,5 +1,6 @@
 package jef.expressions;
 
+import jef.expressions.selectable.SelectableExpression;
 import lombok.AllArgsConstructor;
 import lombok.Getter;
 
@@ -9,7 +10,7 @@ import java.util.stream.Collectors;
 @Getter
 @AllArgsConstructor
 public class SelectExpression implements Expression {
-    private final List<String> fields;
+    private final List<SelectableExpression> fields;
     private final Expression from;
     private final String fromAlias;
 
@@ -25,8 +26,9 @@ public class SelectExpression implements Expression {
 
     @Override
     public String toString() {
-        return "SELECT " + fields.stream().map(e -> e.equals("*") ? e : "`" + e + "`").collect(Collectors.joining(", ")) + " FROM "
+        return "SELECT " + fields.stream().map(SelectableExpression::toString).collect(Collectors.joining(", ")) + " FROM "
                 + (!(from instanceof TableExpression) ? "(" + from + ")" : from)
                 + ((fromAlias == null || fromAlias.isBlank()) ? "" : " " + fromAlias);
     }
+
 }

src/main/java/jef/expressions/modifier/ExpressionModifier.java

@@ -5,6 +5,7 @@ import jef.expressions.BinaryExpression;
 import jef.expressions.ConstantExpression;
 import jef.expressions.Expression;
 import jef.expressions.FieldExpression;
+import jef.expressions.IntermediateFieldExpression;
 import jef.expressions.NullExpression;
 import jef.expressions.OrExpression;
 import jef.expressions.ParameterExpression;
@@ -25,6 +26,7 @@ public abstract class ExpressionModifier {
             case BINARY -> modifyBinary((BinaryExpression) expr);
             case CONSTANT -> modifyConstant((ConstantExpression) expr);
             case FIELD -> modifyField((FieldExpression) expr);
+            case INTERMEDIATE_FIELD -> modifyIntermediateField((IntermediateFieldExpression) expr);
             case NULL -> modifyNull((NullExpression) expr);
             case OR -> modifyOr((OrExpression) expr);
             case PARAMETER -> modifyParameter((ParameterExpression) expr);
@@ -57,6 +59,10 @@ public abstract class ExpressionModifier {
         return expr;
     }
 
+    public Expression modifyIntermediateField(IntermediateFieldExpression expr) {
+        return expr;
+    }
+
     public Expression modifyNull(NullExpression expr) {
         return expr;
     }

src/main/java/jef/expressions/modifier/IConst0Fixer.java

@@ -4,6 +4,7 @@ import jef.expressions.BinaryExpression;
 import jef.expressions.ConstantExpression;
 import jef.expressions.Expression;
 import jef.expressions.FieldExpression;
+import jef.expressions.IntermediateFieldExpression;
 import jef.expressions.UnaryExpression;
 
 import java.util.Set;
@@ -18,6 +19,10 @@ public class IConst0Fixer extends ExpressionModifier {
                 && expr.getExpr().getType() == Expression.Type.FIELD
                 && DESCRIPTORS.contains(((FieldExpression) expr.getExpr()).getClassDescriptor())) {
             return modify(new BinaryExpression(expr.getExpr(), ConstantExpression.V0, BinaryExpression.Operator.EQ));
+        } else if (expr.getOperator() == UnaryExpression.Operator.NOT
+                && expr.getExpr().getType() == Expression.Type.INTERMEDIATE_FIELD
+                && DESCRIPTORS.contains(((IntermediateFieldExpression) expr.getExpr()).getClassDescriptor())) {
+            return modify(new BinaryExpression(expr.getExpr(), ConstantExpression.V0, BinaryExpression.Operator.EQ));
         }
         return super.modifyUnary(expr);
     }

src/main/java/jef/expressions/modifier/TableAliasInjector.java

@@ -2,18 +2,17 @@ package jef.expressions.modifier;
 
 import jef.expressions.Expression;
 import jef.expressions.FieldExpression;
+import jef.expressions.IntermediateFieldExpression;
 
 public class TableAliasInjector extends ExpressionModifier {
     private final String tableAlias;
-    private final String prefix;
 
     public TableAliasInjector(String tableAlias) {
         this.tableAlias = tableAlias;
-        this.prefix = (tableAlias == null || tableAlias.isBlank()) ? "" : tableAlias + ".";
     }
 
     @Override
-    public Expression modifyField(FieldExpression expr) {
+    public Expression modifyIntermediateField(IntermediateFieldExpression expr) {
-        return new FieldExpression(prefix + expr.getName(), expr.getClassDescriptor());
+        return new FieldExpression(null, tableAlias, expr.getName(), expr.getClassDescriptor());
     }
 }

src/main/java/jef/expressions/selectable/DatabaseFunctionExpression.java

@@ -0,0 +1,25 @@
+package jef.expressions.selectable;
+
+import jef.expressions.Expression;
+
+public class DatabaseFunctionExpression implements Expression, SelectableExpression {
+    private final String function;
+    public DatabaseFunctionExpression(String function) {
+        this.function = function;
+    }
+
+    @Override
+    public Type getType() {
+        return Type.CONSTANT;
+    }
+
+    @Override
+    public Priority getPriority() {
+        return Priority.UNDEFINED;
+    }
+
+    @Override
+    public String toString() {
+        return function;
+    }
+}

src/main/java/jef/expressions/selectable/DatabaseSelectAllExpression.java

@@ -0,0 +1,20 @@
+package jef.expressions.selectable;
+
+import jef.expressions.Expression;
+
+public class DatabaseSelectAllExpression implements Expression, SelectableExpression {
+    @Override
+    public Expression.Type getType() {
+        return Expression.Type.CONSTANT;
+    }
+
+    @Override
+    public Expression.Priority getPriority() {
+        return Expression.Priority.UNDEFINED;
+    }
+
+    @Override
+    public String toString() {
+        return "*";
+    }
+}

src/main/java/jef/expressions/selectable/SelectableExpression.java

@@ -0,0 +1,5 @@
+package jef.expressions.selectable;
+
+public interface SelectableExpression {
+
+}

src/main/java/jef/expressions/visitors/DebugExpressionVisitor.java

@@ -4,6 +4,7 @@ import jef.expressions.AndExpression;
 import jef.expressions.BinaryExpression;
 import jef.expressions.ConstantExpression;
 import jef.expressions.FieldExpression;
+import jef.expressions.IntermediateFieldExpression;
 import jef.expressions.NullExpression;
 import jef.expressions.OrExpression;
 import jef.expressions.ParameterExpression;
@@ -12,6 +13,7 @@ import jef.expressions.TableExpression;
 import jef.expressions.TernaryExpression;
 import jef.expressions.UnaryExpression;
 import jef.expressions.WhereExpression;
+import jef.expressions.selectable.SelectableExpression;
 
 import java.util.Collection;
 import java.util.stream.Collectors;
@@ -48,7 +50,12 @@ public class DebugExpressionVisitor extends ExpressionVisitor {
 
     @Override
     public void visitField(FieldExpression expr) {
-        System.out.println(i() + expr.getName());
+        System.out.println(i() + expr.toString());
+    }
+
+    @Override
+    public void visitIntermediateField(IntermediateFieldExpression expr) {
+        System.out.println(i() + expr.toString());
     }
 
     @Override
@@ -81,7 +88,7 @@ public class DebugExpressionVisitor extends ExpressionVisitor {
         var table = expr.getFrom() instanceof TableExpression;
         var tableName = table ? ((TableExpression) expr.getFrom()).getName() : null;
         var tableAlias = (expr.getFromAlias() == null || expr.getFromAlias().isBlank()) ? "" : " " + expr.getFromAlias();
-        System.out.println(i() + "SELECT " + expr.getFields().stream().collect(Collectors.joining(", "))
+        System.out.println(i() + "SELECT " + expr.getFields().stream().map(SelectableExpression::toString).collect(Collectors.joining(", "))
                 + " FROM" + (!table ? " (" : tableName + " " + tableAlias));
         if (!table) {
             indent++;

src/main/java/jef/expressions/visitors/ExpressionVisitor.java

@@ -5,6 +5,7 @@ import jef.expressions.BinaryExpression;
 import jef.expressions.ConstantExpression;
 import jef.expressions.Expression;
 import jef.expressions.FieldExpression;
+import jef.expressions.IntermediateFieldExpression;
 import jef.expressions.NullExpression;
 import jef.expressions.OrExpression;
 import jef.expressions.ParameterExpression;
@@ -21,6 +22,7 @@ public abstract class ExpressionVisitor {
             case BINARY -> visitBinary((BinaryExpression) expr);
             case CONSTANT -> visitConstant((ConstantExpression) expr);
             case FIELD -> visitField((FieldExpression) expr);
+            case INTERMEDIATE_FIELD -> visitIntermediateField((IntermediateFieldExpression) expr);
             case NULL -> visitNull((NullExpression) expr);
             case OR -> visitOr((OrExpression) expr);
             case PARAMETER -> visitParameter((ParameterExpression) expr);
@@ -50,6 +52,9 @@ public abstract class ExpressionVisitor {
     public void visitField(FieldExpression expr) {
     }
 
+    public void visitIntermediateField(IntermediateFieldExpression expr) {
+    }
+
     public void visitNull(NullExpression expr) {
     }
 

src/main/java/jef/operations/FilterOp.java

@@ -10,6 +10,7 @@ import jef.expressions.modifier.ExpressionOptimizerBottomUp;
 import jef.expressions.modifier.IConst0Fixer;
 import jef.expressions.modifier.TableAliasInjector;
 import jef.expressions.modifier.TernaryRewriter;
+import jef.expressions.selectable.DatabaseSelectAllExpression;
 import jef.serializable.SerializablePredicate;
 
 import java.io.Serializable;
@@ -50,7 +51,7 @@ public class FilterOp<T extends Serializable> implements Queryable<T>, Operation
 
     @Override
     public Expression getExpression() {
-        return new WhereExpression(new SelectExpression(List.of("*"), queryable.getExpression(), getTableAlias()), predicateExpr);
+        return new WhereExpression(new SelectExpression(List.of(new DatabaseSelectAllExpression()), queryable.getExpression(), getTableAlias()), predicateExpr);
     }
 
     @Override

src/test/java/jef/operations/FilterOpTest.java

@@ -26,43 +26,43 @@ public class FilterOpTest {
         act = new DBSet<TestClass>("table1")
                 .filter(e -> e.i == 1)
                 .toString();
-        Assertions.assertEquals("SELECT * FROM (SELECT * FROM `table1`) a WHERE a.i = 1", act);
+        Assertions.assertEquals("SELECT * FROM (SELECT * FROM `table1`) a WHERE `a`.`i` = 1", act);
 
 
         act = new DBSet<TestClass>("table1")
                 .filter(e -> e.i != 1)
                 .toString();
-        Assertions.assertEquals("SELECT * FROM (SELECT * FROM `table1`) a WHERE a.i <> 1", act);
+        Assertions.assertEquals("SELECT * FROM (SELECT * FROM `table1`) a WHERE `a`.`i` <> 1", act);
 
 
         act = new DBSet<TestClass>("table1")
                 .filter(e -> e.i < 1)
                 .toString();
-        Assertions.assertEquals("SELECT * FROM (SELECT * FROM `table1`) a WHERE a.i < 1", act);
+        Assertions.assertEquals("SELECT * FROM (SELECT * FROM `table1`) a WHERE `a`.`i` < 1", act);
 
 
         act = new DBSet<TestClass>("table1")
                 .filter(e -> e.i > 1)
                 .toString();
-        Assertions.assertEquals("SELECT * FROM (SELECT * FROM `table1`) a WHERE a.i > 1", act);
+        Assertions.assertEquals("SELECT * FROM (SELECT * FROM `table1`) a WHERE `a`.`i` > 1", act);
 
 
         act = new DBSet<TestClass>("table1")
                 .filter(e -> e.i <= 1)
                 .toString();
-        Assertions.assertEquals("SELECT * FROM (SELECT * FROM `table1`) a WHERE a.i <= 1", act);
+        Assertions.assertEquals("SELECT * FROM (SELECT * FROM `table1`) a WHERE `a`.`i` <= 1", act);
 
 
         act = new DBSet<TestClass>("table1")
                 .filter(e -> e.i >= 1)
                 .toString();
-        Assertions.assertEquals("SELECT * FROM (SELECT * FROM `table1`) a WHERE a.i >= 1", act);
+        Assertions.assertEquals("SELECT * FROM (SELECT * FROM `table1`) a WHERE `a`.`i` >= 1", act);
 
 
         act = new DBSet<TestClass>("table1")
                 .filter(e -> e.i == 1337)
                 .toString();
-        Assertions.assertEquals("SELECT * FROM (SELECT * FROM `table1`) a WHERE a.i = 1337", act);
+        Assertions.assertEquals("SELECT * FROM (SELECT * FROM `table1`) a WHERE `a`.`i` = 1337", act);
     }
 
     @Test
@@ -72,7 +72,7 @@ public class FilterOpTest {
         act = new DBSet<TestClass>("table1")
                 .filter(e -> s.contains(e.i))
                 .toString();
-        Assertions.assertEquals("SELECT * FROM (SELECT * FROM `table1`) a WHERE a.i IN (1, 3)", act);
+        Assertions.assertEquals("SELECT * FROM (SELECT * FROM `table1`) a WHERE `a`.`i` IN (1, 3)", act);
     }
 
     @Test
@@ -83,7 +83,7 @@ public class FilterOpTest {
                 .filter(e -> s.contains(e.i))
                 .filter(e -> e.i == 1337)
                 .toString();
-        Assertions.assertEquals("SELECT * FROM (SELECT * FROM (SELECT * FROM `table1`) a WHERE a.i IN (1, 3)) b WHERE b.i = 1337", act);
+        Assertions.assertEquals("SELECT * FROM (SELECT * FROM (SELECT * FROM `table1`) a WHERE `a`.`i` IN (1, 3)) b WHERE `b`.`i` = 1337", act);
     }
 
     @Test
@@ -93,31 +93,31 @@ public class FilterOpTest {
         act = new DBSet<TestClass>("table1")
                 .filter(e -> s.contains(e.i) && e.i == 1337)
                 .toString();
-        Assertions.assertEquals("SELECT * FROM (SELECT * FROM `table1`) a WHERE a.i IN (1, 3) AND a.i = 1337", act);
+        Assertions.assertEquals("SELECT * FROM (SELECT * FROM `table1`) a WHERE `a`.`i` IN (1, 3) AND `a`.`i` = 1337", act);
 
 
         act = new DBSet<TestClass>("table1")
                 .filter(e -> s.contains(e.i) && e.i == 1337 && e.i == 420)
                 .toString();
-        Assertions.assertEquals("SELECT * FROM (SELECT * FROM `table1`) a WHERE a.i IN (1, 3) AND a.i = 1337 AND a.i = 420", act);
+        Assertions.assertEquals("SELECT * FROM (SELECT * FROM `table1`) a WHERE `a`.`i` IN (1, 3) AND `a`.`i` = 1337 AND `a`.`i` = 420", act);
 
 
         act = new DBSet<TestClass>("table1")
                 .filter(e -> e.i == 1337 || e.i != 420 || s.contains(e.i))
                 .toString();
-        Assertions.assertEquals("SELECT * FROM (SELECT * FROM `table1`) a WHERE a.i = 1337 OR a.i <> 420 OR a.i IN (1, 3)", act);
+        Assertions.assertEquals("SELECT * FROM (SELECT * FROM `table1`) a WHERE `a`.`i` = 1337 OR `a`.`i` <> 420 OR `a`.`i` IN (1, 3)", act);
 
 
         act = new DBSet<TestClass>("table1")
                 .filter(e -> e.i == 1337 || e.i == 420 || s.contains(e.i))
                 .toString();
-        Assertions.assertEquals("SELECT * FROM (SELECT * FROM `table1`) a WHERE a.i = 1337 OR a.i = 420 OR a.i IN (1, 3)", act);
+        Assertions.assertEquals("SELECT * FROM (SELECT * FROM `table1`) a WHERE `a`.`i` = 1337 OR `a`.`i` = 420 OR `a`.`i` IN (1, 3)", act);
 
 
         act = new DBSet<TestClass>("table1")
                 .filter(e -> e.i == 1337 || s.contains(e.i) || e.i == 420)
                 .toString();
-        Assertions.assertEquals("SELECT * FROM (SELECT * FROM `table1`) a WHERE a.i = 1337 OR a.i IN (1, 3) OR a.i = 420", act);
+        Assertions.assertEquals("SELECT * FROM (SELECT * FROM `table1`) a WHERE `a`.`i` = 1337 OR `a`.`i` IN (1, 3) OR `a`.`i` = 420", act);
     }
 
     @Test
@@ -127,13 +127,13 @@ public class FilterOpTest {
         act = new DBSet<TestClass>("table1")
                 .filter(e -> s.contains(e.i) && (e.i == 1337 || e.i == 420))
                 .toString();
-        Assertions.assertEquals("SELECT * FROM (SELECT * FROM `table1`) a WHERE a.i IN (1, 3) AND (a.i = 1337 OR a.i = 420)", act);
+        Assertions.assertEquals("SELECT * FROM (SELECT * FROM `table1`) a WHERE `a`.`i` IN (1, 3) AND (`a`.`i` = 1337 OR `a`.`i` = 420)", act);
 
 
         act = new DBSet<TestClass>("table1")
                 .filter(e -> (e.i == 1337 || e.i == 420) && s.contains(e.i))
                 .toString();
-        Assertions.assertEquals("SELECT * FROM (SELECT * FROM `table1`) a WHERE (a.i = 1337 OR a.i = 420) AND a.i IN (1, 3)", act);
+        Assertions.assertEquals("SELECT * FROM (SELECT * FROM `table1`) a WHERE (`a`.`i` = 1337 OR `a`.`i` = 420) AND `a`.`i` IN (1, 3)", act);
     }
 
     @Test
@@ -143,19 +143,19 @@ public class FilterOpTest {
         act = new DBSet<TestClass>("table1")
                 .filter(e -> e.o == null)
                 .toString();
-        Assertions.assertEquals("SELECT * FROM (SELECT * FROM `table1`) a WHERE a.o IS NULL", act);
+        Assertions.assertEquals("SELECT * FROM (SELECT * FROM `table1`) a WHERE `a`.`o` IS NULL", act);
 
 
         act = new DBSet<TestClass>("table1")
                 .filter(e -> e.o != null)
                 .toString();
-        Assertions.assertEquals("SELECT * FROM (SELECT * FROM `table1`) a WHERE a.o IS NOT NULL", act);
+        Assertions.assertEquals("SELECT * FROM (SELECT * FROM `table1`) a WHERE `a`.`o` IS NOT NULL", act);
 
 
         act = new DBSet<TestClass>("table1")
                 .filter(e -> e.o != null || s.contains(e.o))
                 .toString();
-        Assertions.assertEquals("SELECT * FROM (SELECT * FROM `table1`) a WHERE a.o IS NOT NULL OR a.o IN (NULL, 4)", act);
+        Assertions.assertEquals("SELECT * FROM (SELECT * FROM `table1`) a WHERE `a`.`o` IS NOT NULL OR `a`.`o` IN (NULL, 4)", act);
     }
 
     @Test
@@ -165,19 +165,19 @@ public class FilterOpTest {
         act = new DBSet<TestClass>("table1")
                 .filter(e -> e.d == 3.14d)
                 .toString();
-        Assertions.assertEquals("SELECT * FROM (SELECT * FROM `table1`) a WHERE a.d = 3.14", act);
+        Assertions.assertEquals("SELECT * FROM (SELECT * FROM `table1`) a WHERE `a`.`d` = 3.14", act);
 
 
         act = new DBSet<TestClass>("table1")
                 .filter(e -> e.f == 3.14f)
                 .toString();
-        Assertions.assertEquals("SELECT * FROM (SELECT * FROM `table1`) a WHERE a.f = 3.14", act);
+        Assertions.assertEquals("SELECT * FROM (SELECT * FROM `table1`) a WHERE `a`.`f` = 3.14", act);
 
 
         act = new DBSet<TestClass>("table1")
                 .filter(e -> e.d != 1d || e.f != 1 || s.contains(e.d))
                 .toString();
-        Assertions.assertEquals("SELECT * FROM (SELECT * FROM `table1`) a WHERE a.d <> 1 OR a.f <> 1 OR a.d IN (NULL, 2)", act);
+        Assertions.assertEquals("SELECT * FROM (SELECT * FROM `table1`) a WHERE `a`.`d` <> 1 OR `a`.`f` <> 1 OR `a`.`d` IN (NULL, 2)", act);
     }
 
     @Test
@@ -186,25 +186,25 @@ public class FilterOpTest {
         act = new DBSet<TestClass>("table1")
                 .filter(e -> e.i == 0 || e.i == 1 || e.i == 2 || e.i == 3 || e.i == 4 || e.i == 5)
                 .toString();
-        Assertions.assertEquals("SELECT * FROM (SELECT * FROM `table1`) a WHERE a.i = 0 OR a.i = 1 OR a.i = 2 OR a.i = 3 OR a.i = 4 OR a.i = 5", act);
+        Assertions.assertEquals("SELECT * FROM (SELECT * FROM `table1`) a WHERE `a`.`i` = 0 OR `a`.`i` = 1 OR `a`.`i` = 2 OR `a`.`i` = 3 OR `a`.`i` = 4 OR `a`.`i` = 5", act);
 
 
         act = new DBSet<TestClass>("table1")
                 .filter(e -> e.d == 0D || e.d == 1D)
                 .toString();
-        Assertions.assertEquals("SELECT * FROM (SELECT * FROM `table1`) a WHERE a.d = 0 OR a.d = 1", act);
+        Assertions.assertEquals("SELECT * FROM (SELECT * FROM `table1`) a WHERE `a`.`d` = 0 OR `a`.`d` = 1", act);
 
 
         act = new DBSet<TestClass>("table1")
                 .filter(e -> e.f == 0F || e.f == 1F || e.f == 2F)
                 .toString();
-        Assertions.assertEquals("SELECT * FROM (SELECT * FROM `table1`) a WHERE a.f = 0 OR a.f = 1 OR a.f = 2", act);
+        Assertions.assertEquals("SELECT * FROM (SELECT * FROM `table1`) a WHERE `a`.`f` = 0 OR `a`.`f` = 1 OR `a`.`f` = 2", act);
 
 
         act = new DBSet<TestClass>("table1")
                 .filter(e -> e.l == 0L || e.l == 1L)
                 .toString();
-        Assertions.assertEquals("SELECT * FROM (SELECT * FROM `table1`) a WHERE a.l = 0 OR a.l = 1", act);
+        Assertions.assertEquals("SELECT * FROM (SELECT * FROM `table1`) a WHERE `a`.`l` = 0 OR `a`.`l` = 1", act);
     }
 
     @Test
@@ -213,7 +213,7 @@ public class FilterOpTest {
         act = new DBSet<TestClass>("table1")
                 .filter(e -> e.getI() == 1337)
                 .toString();
-        Assertions.assertEquals("SELECT * FROM (SELECT * FROM `table1`) a WHERE a.i = 1337", act);
+        Assertions.assertEquals("SELECT * FROM (SELECT * FROM `table1`) a WHERE `a`.`i` = 1337", act);
     }
 
     @Getter