consistent toString functions for expressions, parentasis are added if neccessary

src/main/java/jef/expressions/AndExpression.java

@@ -20,10 +20,15 @@ public class AndExpression implements Expression {
         return Type.AND;
     }
 
+    @Override
+    public Priority getPriority() {
+        return Priority.LOGIC_AND;
+    }
+
     @Override
     public String toString() {
         return exprs.stream().map(e -> {
-            if (e instanceof OrExpression) {
+            if (e.getPriority().getValue() < getPriority().getValue()) {
                 return "(" + e + ")";
             } else {
                 return e.toString();

src/main/java/jef/expressions/BinaryExpression.java

@@ -17,9 +17,31 @@ public class BinaryExpression implements Expression {
         return Type.BINARY;
     }
 
+    @Override
+    public Priority getPriority() {
+        return switch (operator) {
+            case EQ, NE, IS -> Priority.EQUALITY;
+            case LT, LE, GT, GE -> Priority.RELATIONAL;
+            case IN -> Priority.RELATIONAL; //or equality?
+            default -> throw new IllegalStateException();
+        };
+    }
+
     @Override
     public String toString() {
-        return left + " " + operator + " " + right;
+        String ret = "";
+        if (left.getPriority().getValue() < getPriority().getValue()) {
+            ret += "(" + left + ")";
+        } else {
+            ret += left.toString();
+        }
+        ret += " " + operator + " ";
+        if (right.getPriority().getValue() < getPriority().getValue()) {
+            ret += "(" + right + ")";
+        } else {
+            ret += right.toString();
+        }
+        return ret;
     }
 
     @AllArgsConstructor
@@ -30,8 +52,10 @@ public class BinaryExpression implements Expression {
         LE("<="),
         GT(">"),
         GE(">="),
-        //        OR("OR"),
+//
-//        AND("AND"),
+//        ADD("+"),
+//        SUB("-"),
+
         IN("IN"),
         IS("IS"),
         ;
@@ -48,7 +72,11 @@ public class BinaryExpression implements Expression {
                 LT, GE,
                 GE, LT,
                 LE, GT,
-                GT, LE);
+                GT, LE
+
+//                ADD, SUB,
+//                SUB, ADD
+        );
 
         public Operator invert() {
             return INVERSION.get(this);

src/main/java/jef/expressions/ConstantExpression.java

@@ -20,6 +20,11 @@ public class ConstantExpression implements Expression {
         return Type.CONSTANT;
     }
 
+    @Override
+    public Priority getPriority() {
+        return Priority.CONSTANT;
+    }
+
     @Override
     public String toString() {
         return value.toString();

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

@@ -1,8 +1,13 @@
 package jef.expressions;
 
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
 public interface Expression {
     Type getType();
 
+    Priority getPriority();
+
     public enum Type {
         AND,
         BINARY,
@@ -17,4 +22,28 @@ public interface Expression {
         UNARY,
         WHERE,
     }
+
+    @AllArgsConstructor
+    @Getter
+    public enum Priority {
+        UNDEFINED(0),
+        ASSIGNMENT(1),   // =, +=, -=, *=, /=
+        TERNARY(2),      // ? :
+        LOGIC_OR(3),     // ||
+        LOGIC_AND(4),    // &&
+        BITWISE_OR(5),   // |
+        BITWISE_XOR(6),  // ^
+        BITWISE_AND(7),  // &
+        EQUALITY(8),     // ==, !=
+        RELATIONAL(9),   // <, <=, =>, >
+        BIT_SHIFT(10),   // <<, >>
+        ADD_SUB(13),     // +, -
+        MUL_DIV_MOD(14), // *, /, %
+        UNARY_PRE(15),   // +, -, !, ~, --i, ++i
+        UNARY_POST(16),  // i++, i--
+        CONSTANT(17),    // constant values
+        ;
+
+        private final int value;
+    }
 }

src/main/java/jef/expressions/OrExpression.java

@@ -20,8 +20,19 @@ public class OrExpression implements Expression {
         return Type.OR;
     }
 
+    @Override
+    public Priority getPriority() {
+        return Priority.LOGIC_OR;
+    }
+
     @Override
     public String toString() {
-        return exprs.stream().map(Expression::toString).collect(Collectors.joining(" OR "));
+        return exprs.stream().map(e -> {
+            if (e.getPriority().getValue() < getPriority().getValue()) {
+                return "(" + e + ")";
+            } else {
+                return e.toString();
+            }
+        }).collect(Collectors.joining(" OR "));
     }
 }

src/main/java/jef/expressions/ParameterExpression.java

@@ -29,7 +29,7 @@ public class ParameterExpression extends ConstantExpression implements Expressio
         } else if (this.value == null) {
             return "null";
         } else if (this.value instanceof Collection) {
-            return "(" + ((Collection<?>) this.value).stream().map(Objects::toString).collect(Collectors.joining(", ")) + ")";
+            return "(" + ((Collection<?>) this.value).stream().map(e -> e == null ? "NULL" : Objects.toString(e)).collect(Collectors.joining(", ")) + ")";
         }
         return value.toString();
     }

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

@@ -18,6 +18,11 @@ public class SelectExpression implements Expression {
         return Type.SELECT;
     }
 
+    @Override
+    public Priority getPriority() {
+        return Priority.UNDEFINED;
+    }
+
     @Override
     public String toString() {
         return "SELECT " + fields.stream().map(e -> e.equals("*") ? e : "`" + e + "`").collect(Collectors.joining(", ")) + " FROM "

src/main/java/jef/expressions/TernaryExpression.java

@@ -15,6 +15,11 @@ public class TernaryExpression implements Expression {
         return Type.TERNARY;
     }
 
+    @Override
+    public Priority getPriority() {
+        return Priority.TERNARY;
+    }
+
     @Override
     public String toString() {
         return "IF(" + cond + ", " + whenTrue + ", " + whenFalse + ")";

src/main/java/jef/expressions/UnaryExpression.java

@@ -14,12 +14,17 @@ public class UnaryExpression implements Expression {
         return Type.UNARY;
     }
 
+    @Override
+    public Priority getPriority() {
+        return Priority.UNARY_PRE;
+    }
+
     @Override
     public String toString() {
-        if (expr instanceof ConstantExpression) {
+        if (expr.getPriority().getValue() < getPriority().getValue()) {
-            return operator + " " + expr;
-        } else {
             return operator + " (" + expr + ")";
+        } else {
+            return operator + " " + expr;
         }
     }
 

src/main/java/jef/expressions/WhereExpression.java

@@ -14,6 +14,11 @@ public class WhereExpression implements Expression {
         return Type.WHERE;
     }
 
+    @Override
+    public Priority getPriority() {
+        return Priority.UNDEFINED;
+    }
+
     @Override
     public String toString() {
         return queryable + " WHERE " + where;

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

@@ -101,6 +101,11 @@ public class ExpressionOptimizerBottomUp extends ExpressionModifier {
                 && b.getOperator().isInvertible()) {
             //!(a < b) -> a >= b
             return new BinaryExpression(b.getLeft(), b.getRight(), b.getOperator().invert());
+        } else if (inner instanceof BinaryExpression b
+                && expr.getOperator() == UnaryExpression.Operator.NOT
+                && b.getOperator() == BinaryExpression.Operator.IS) {
+            //!(a < b) -> a >= b
+            return new BinaryExpression(b.getLeft(), new UnaryExpression(b.getRight(), UnaryExpression.Operator.NOT), b.getOperator());
         } else {
             return super.modifyUnary(expr);
         }

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

@@ -10,7 +10,7 @@ import jef.expressions.UnaryExpression;
 
 import java.util.ArrayList;
 
-public class ExpressionOptimizer extends ExpressionModifier {
+public class ExpressionOptimizerTopDown extends ExpressionModifier {
     @Override
     public Expression modifyAnd(AndExpression expr) {
         var ands = new ArrayList<Expression>(expr.getExprs().size() * 2);

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

@@ -6,7 +6,6 @@ import jef.asm.PredicateParser;
 import jef.expressions.Expression;
 import jef.expressions.SelectExpression;
 import jef.expressions.WhereExpression;
-import jef.expressions.modifier.ExpressionOptimizer;
 import jef.expressions.modifier.ExpressionOptimizerBottomUp;
 import jef.expressions.modifier.TableAliasInjector;
 import jef.expressions.modifier.TernaryRewriter;

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

@@ -6,201 +6,202 @@ import org.junit.jupiter.api.Test;
 
 import java.io.Serializable;
 import java.util.Arrays;
+import java.util.List;
 
 public class FilterOpTest {
 
     @Test
     public void testTrue() {
-//        String act;
+        String act;
-//        act = new DBSet<TestClass>("table1")
+        act = new DBSet<TestClass>("table1")
-//                .filter(e -> true)
+                .filter(e -> true)
-//                .toString();
+                .toString();
-//        Assertions.assertEquals("SELECT * FROM (SELECT * FROM `table1`) a WHERE 1", act);
+        Assertions.assertEquals("SELECT * FROM (SELECT * FROM `table1`) a WHERE 1", act);
     }
 
-//    @Test
+    @Test
-//    public void testCompareWithEntityMember() {
+    public void testCompareWithEntityMember() {
-//        String act;
+        String act;
-//        act = new DBSet<TestClass>("table1")
+        act = new DBSet<TestClass>("table1")
-//                .filter(e -> e.b == 1)
+                .filter(e -> e.i == 1)
-//                .toString();
+                .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.b != 1)
-//                .toString();
-//        Assertions.assertEquals("SELECT * FROM (SELECT * FROM `table1`) a WHERE a.i <> 1", act);
-//
-//
-//        act = new DBSet<TestClass>("table1")
-//                .filter(e -> e.b < 1)
-//                .toString();
-//        Assertions.assertEquals("SELECT * FROM (SELECT * FROM `table1`) a WHERE a.i < 1", act);
-//
-//
-//        act = new DBSet<TestClass>("table1")
-//                .filter(e -> e.b > 1)
-//                .toString();
-//        Assertions.assertEquals("SELECT * FROM (SELECT * FROM `table1`) a WHERE a.i > 1", act);
-//
-//
-//        act = new DBSet<TestClass>("table1")
-//                .filter(e -> e.b <= 1)
-//                .toString();
-//        Assertions.assertEquals("SELECT * FROM (SELECT * FROM `table1`) a WHERE a.i <= 1", act);
-//
-//
-//        act = new DBSet<TestClass>("table1")
-//                .filter(e -> e.b >= 1)
-//                .toString();
-//        Assertions.assertEquals("SELECT * FROM (SELECT * FROM `table1`) a WHERE a.i >= 1", act);
-//
-//
-//        act = new DBSet<TestClass>("table1")
-//                .filter(e -> e.b == 1337)
-//                .toString();
-//        Assertions.assertEquals("SELECT * FROM (SELECT * FROM `table1`) a WHERE a.i = 1337", act);
-//    }
-//
-//    @Test
-//    public void testContainsWithEntityMember() {
-//        var s = List.of(1, 3);
-//        String act;
-//        act = new DBSet<TestClass>("table1")
-//                .filter(e -> s.contains(e.b))
-//                .toString();
-//        Assertions.assertEquals("SELECT * FROM (SELECT * FROM `table1`) a WHERE a.i IN (1,3)", act);
-//    }
-//
-//    @Test
-//    public void testMultipleFilter() {
-//        String act;
-//        var s = List.of(1, 3);
-//        act = new DBSet<TestClass>("table1")
-//                .filter(e -> s.contains(e.b))
-//                .filter(e -> e.b == 1337)
-//                .toString();
-//        Assertions.assertEquals("SELECT * FROM (SELECT * FROM (SELECT * FROM `table1`) a WHERE a.i IN (1,3)) b WHERE b.b = 1337", act);
-//    }
-//
-//    @Test
-//    public void testComplexExpression() {
-//        String act;
-//        var s = List.of(1, 3);
-//        act = new DBSet<TestClass>("table1")
-//                .filter(e -> s.contains(e.b) && e.b == 1337)
-//                .toString();
-//        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.b) && e.b == 1337 && e.b == 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);
-//
-//
-//        act = new DBSet<TestClass>("table1")
-//                .filter(e -> e.b == 1337 || e.b != 420 || s.contains(e.b))
-//                .toString();
-//        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.b == 1337 || e.b == 420 || s.contains(e.b))
-//                .toString();
-//        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.b == 1337 || s.contains(e.b) || e.b == 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);
-//    }
-//
-//    @Test
-//    public void testComplexExpressionMixedAndOr() {
-//        String act;
-//        var s = List.of(1, 3);
-//        act = new DBSet<TestClass>("table1")
-//                .filter(e -> s.contains(e.b) && (e.b == 1337 || e.b == 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);
-//
-//
-//        act = new DBSet<TestClass>("table1")
-//                .filter(e -> (e.b == 1337 || e.b == 420) && s.contains(e.b))
-//                .toString();
-//        Assertions.assertEquals("SELECT * FROM (SELECT * FROM `table1`) a WHERE (a.i = 1337 OR a.i = 420) AND a.i IN (1,3)", act);
-//    }
-//
-//    @Test
-//    public void testObject() {
-//        String act;
-//        var s = Arrays.asList(null, new Object());
-//        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);
-//
-//
-//        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);
-//
-//
-//        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)", act);
-//    }
 
-//    @Test
+
-//    public void testFloatingPoint() {
+        act = new DBSet<TestClass>("table1")
-//        String act;
+                .filter(e -> e.i != 1)
-//        var s = Arrays.asList(null, 2);
+                .toString();
-//        act = new DBSet<TestClass>("table1")
+        Assertions.assertEquals("SELECT * FROM (SELECT * FROM `table1`) a WHERE a.i <> 1", act);
-//                .filter(e -> e.d == 3.14d)
+
-//                .toString();
+
-//        Assertions.assertEquals("SELECT * FROM (SELECT * FROM `table1`) a WHERE a.d = 3.14", act);
+        act = new DBSet<TestClass>("table1")
-//
+                .filter(e -> e.i < 1)
-//
+                .toString();
-//        act = new DBSet<TestClass>("table1")
+        Assertions.assertEquals("SELECT * FROM (SELECT * FROM `table1`) a WHERE a.i < 1", act);
-//                .filter(e -> e.f == 3.14f)
+
-//                .toString();
+
-//        Assertions.assertEquals("SELECT * FROM (SELECT * FROM `table1`) a WHERE a.f = 3.14", act);
+        act = new DBSet<TestClass>("table1")
-//
+                .filter(e -> e.i > 1)
-//
+                .toString();
-//        act = new DBSet<TestClass>("table1")
+        Assertions.assertEquals("SELECT * FROM (SELECT * FROM `table1`) a WHERE a.i > 1", act);
-//                .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);
+        act = new DBSet<TestClass>("table1")
-//    }
+                .filter(e -> e.i <= 1)
+                .toString();
+        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);
+
+
+        act = new DBSet<TestClass>("table1")
+                .filter(e -> e.i == 1337)
+                .toString();
+        Assertions.assertEquals("SELECT * FROM (SELECT * FROM `table1`) a WHERE a.i = 1337", act);
+    }
+
+    @Test
+    public void testContainsWithEntityMember() {
+        var s = List.of(1, 3);
+        String act;
+        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);
+    }
+
+    @Test
+    public void testMultipleFilter() {
+        String act;
+        var s = List.of(1, 3);
+        act = new DBSet<TestClass>("table1")
+                .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);
+    }
+
+    @Test
+    public void testComplexExpression() {
+        String act;
+        var s = List.of(1, 3);
+        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);
+
+
+        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);
+
+
+        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);
+
+
+        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);
+
+
+        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);
+    }
+
+    @Test
+    public void testComplexExpressionMixedAndOr() {
+        String act;
+        var s = List.of(1, 3);
+        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);
+
+
+        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);
+    }
+
+    @Test
+    public void testObject() {
+        String act;
+        var s = Arrays.asList(null, 4);
+        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);
+
+
+        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);
+
+
+        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);
+    }
+
+    @Test
+    public void testFloatingPoint() {
+        String act;
+        var s = Arrays.asList(null, 2);
+        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);
+
+
+        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);
+
+
+        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);
+    }
 
     @Test
     public void testIDFLConst() {
         String act;
-//        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);
-
-
-//        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);
-//
-//
-//        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);
-//
-//
         act = new DBSet<TestClass>("table1")
-                .filter(e -> e.l == 0l || e.l == 1l)
+                .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);
+
+
+        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);
+
+
+        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);
+
+
+        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);
     }