src/main/java/org/redkale/source/FilterExpress.java

@@ -39,8 +39,8 @@ public enum FilterExpress {
     OPAND("&"), //与运算 > 0
     OPOR("|"), //或运算 > 0
     OPANDNO("&"), //与运算 == 0
-    MOD("%"), //取模运算 > 0
+    FV_MOD("%"), //取模运算，需要与FilterValue配合使用
-    MODNO("%"), //取模运算 == 0
+    FV_DIV("DIV"), //整除运算，需要与FilterValue配合使用
     AND("AND"),
     OR("OR");
 

src/main/java/org/redkale/source/FilterNode.java

@@ -215,7 +215,14 @@ public class FilterNode {
         if (express == ISNULL || express == ISNOTNULL) {
             return new StringBuilder().append(info.getSQLColumn(talis, column)).append(' ').append(express.value());
         }
-        CharSequence val = formatToString(express, getValue());
+        Object val0 = getValue();
+        if(val0 == null) return null;
+        if (express == FV_MOD || express == FV_DIV) {
+            FilterValue fv = (FilterValue)val0;
+            return new StringBuilder().append(info.getSQLColumn(talis, column)).append(' ').append(express.value()).append(' ').append(fv.getOptvalue())
+                .append(' ').append(fv.getExpress().value()).append(' ').append(fv.getDestvalue());
+        }
+        CharSequence val = formatToString(express, val0);
         if (val == null) return null;
         StringBuilder sb = new StringBuilder(32);
         if (express == CONTAIN) return info.containSQL.replace("${column}", info.getSQLColumn(talis, column)).replace("${keystr}", val);
@@ -232,10 +239,8 @@ public class FilterNode {
         switch (express) {
             case OPAND:
             case OPOR:
-            case MOD:
                 sb.append(express.value()).append(' ').append(val).append(" > 0");
                 break;
-            case MODNO:
             case OPANDNO:
                 sb.append(express.value()).append(' ').append(val).append(" = 0");
                 break;
@@ -525,19 +530,174 @@ public class FilterNode {
                         return field + " & " + val + " > 0";
                     }
                 };
-            case MOD:
+            case FV_MOD:
-                return new Predicate<T>() {
+                FilterValue fv0 = (FilterValue)val;
+                switch(fv0.getExpress()) {
+                    case EQUAL :
+                        return new Predicate<T>() {
 
-                    @Override
+                            @Override
-                    public boolean test(T t) {
+                            public boolean test(T t) {
-                        return (((Number) attr.get(t)).longValue() % ((Number) val).longValue()) > 0;
+                                return (((Number) attr.get(t)).longValue() % fv0.getOptvalue().longValue()) == fv0.getDestvalue().longValue();
-                    }
+                            }
 
-                    @Override
+                            @Override
-                    public String toString() {
+                            public String toString() {
-                        return field + " % " + val + " > 0";
+                                return field + " " + express.value() + " " + fv0.getOptvalue() + " " + fv0.getExpress().value() + " " + fv0.getDestvalue();
-                    }
+                            }
-                };
+                        };
+                    case NOTEQUAL :
+                        return new Predicate<T>() {
+
+                            @Override
+                            public boolean test(T t) {
+                                return (((Number) attr.get(t)).longValue() % fv0.getOptvalue().longValue()) != fv0.getDestvalue().longValue();
+                            }
+
+                            @Override
+                            public String toString() {
+                                return field + " " + express.value() + " " + fv0.getOptvalue() + " " + fv0.getExpress().value() + " " + fv0.getDestvalue();
+                            }
+                        };
+                    case GREATERTHAN :
+                        return new Predicate<T>() {
+
+                            @Override
+                            public boolean test(T t) {
+                                return (((Number) attr.get(t)).longValue() % fv0.getOptvalue().longValue()) > fv0.getDestvalue().longValue();
+                            }
+
+                            @Override
+                            public String toString() {
+                                return field + " " + express.value() + " " + fv0.getOptvalue() + " " + fv0.getExpress().value() + " " + fv0.getDestvalue();
+                            }
+                        };
+                    case LESSTHAN :
+                        return new Predicate<T>() {
+
+                            @Override
+                            public boolean test(T t) {
+                                return (((Number) attr.get(t)).longValue() % fv0.getOptvalue().longValue()) < fv0.getDestvalue().longValue();
+                            }
+
+                            @Override
+                            public String toString() {
+                                return field + " " + express.value() + " " + fv0.getOptvalue() + " " + fv0.getExpress().value() + " " + fv0.getDestvalue();
+                            }
+                        };
+                    case GREATERTHANOREQUALTO :
+                        return new Predicate<T>() {
+
+                            @Override
+                            public boolean test(T t) {
+                                return (((Number) attr.get(t)).longValue() % fv0.getOptvalue().longValue()) >= fv0.getDestvalue().longValue();
+                            }
+
+                            @Override
+                            public String toString() {
+                                return field + " " + express.value() + " " + fv0.getOptvalue() + " " + fv0.getExpress().value() + " " + fv0.getDestvalue();
+                            }
+                        };
+                    case LESSTHANOREQUALTO :
+                        return new Predicate<T>() {
+
+                            @Override
+                            public boolean test(T t) {
+                                return (((Number) attr.get(t)).longValue() % fv0.getOptvalue().longValue()) <= fv0.getDestvalue().longValue();
+                            }
+
+                            @Override
+                            public String toString() {
+                                return field + " " + express.value() + " " + fv0.getOptvalue() + " " + fv0.getExpress().value() + " " + fv0.getDestvalue();
+                            }
+                        };
+                    default :
+                        throw  new RuntimeException("(" + fv0 + ")'s express illegal, must be =, !=, <, >, <=, >=");
+                }                
+            case FV_DIV:
+                FilterValue fv1 = (FilterValue)val;
+                switch(fv1.getExpress()) {
+                    case EQUAL :
+                        return new Predicate<T>() {
+
+                            @Override
+                            public boolean test(T t) {
+                                return (((Number) attr.get(t)).longValue() / fv1.getOptvalue().longValue()) == fv1.getDestvalue().longValue();
+                            }
+
+                            @Override
+                            public String toString() {
+                                return field + " " + express.value() + " " + fv1.getOptvalue() + " " + fv1.getExpress().value() + " " + fv1.getDestvalue();
+                            }
+                        };
+                    case NOTEQUAL :
+                        return new Predicate<T>() {
+
+                            @Override
+                            public boolean test(T t) {
+                                return (((Number) attr.get(t)).longValue() / fv1.getOptvalue().longValue()) != fv1.getDestvalue().longValue();
+                            }
+
+                            @Override
+                            public String toString() {
+                                return field + " " + express.value() + " " + fv1.getOptvalue() + " " + fv1.getExpress().value() + " " + fv1.getDestvalue();
+                            }
+                        };
+                    case GREATERTHAN :
+                        return new Predicate<T>() {
+
+                            @Override
+                            public boolean test(T t) {
+                                return (((Number) attr.get(t)).longValue() / fv1.getOptvalue().longValue()) > fv1.getDestvalue().longValue();
+                            }
+
+                            @Override
+                            public String toString() {
+                                return field + " " + express.value() + " " + fv1.getOptvalue() + " " + fv1.getExpress().value() + " " + fv1.getDestvalue();
+                            }
+                        };
+                    case LESSTHAN :
+                        return new Predicate<T>() {
+
+                            @Override
+                            public boolean test(T t) {
+                                return (((Number) attr.get(t)).longValue() / fv1.getOptvalue().longValue()) < fv1.getDestvalue().longValue();
+                            }
+
+                            @Override
+                            public String toString() {
+                                return field + " " + express.value() + " " + fv1.getOptvalue() + " " + fv1.getExpress().value() + " " + fv1.getDestvalue();
+                            }
+                        };
+                    case GREATERTHANOREQUALTO :
+                        return new Predicate<T>() {
+
+                            @Override
+                            public boolean test(T t) {
+                                return (((Number) attr.get(t)).longValue() / fv1.getOptvalue().longValue()) >= fv1.getDestvalue().longValue();
+                            }
+
+                            @Override
+                            public String toString() {
+                                return field + " " + express.value() + " " + fv1.getOptvalue() + " " + fv1.getExpress().value() + " " + fv1.getDestvalue();
+                            }
+                        };
+                    case LESSTHANOREQUALTO :
+                        return new Predicate<T>() {
+
+                            @Override
+                            public boolean test(T t) {
+                                return (((Number) attr.get(t)).longValue() / fv1.getOptvalue().longValue()) <= fv1.getDestvalue().longValue();
+                            }
+
+                            @Override
+                            public String toString() {
+                                return field + " " + express.value() + " " + fv1.getOptvalue() + " " + fv1.getExpress().value() + " " + fv1.getDestvalue();
+                            }
+                        };
+                    default :
+                        throw  new RuntimeException("(" + fv1 + ")'s express illegal, must be =, !=, <, >, <=, >=");
+                }
             case OPOR:
                 return new Predicate<T>() {
 
@@ -564,19 +724,6 @@ public class FilterNode {
                         return field + " & " + val + " = 0";
                     }
                 };
-            case MODNO:
-                return new Predicate<T>() {
-
-                    @Override
-                    public boolean test(T t) {
-                        return (((Number) attr.get(t)).longValue() % ((Number) val).longValue()) == 0;
-                    }
-
-                    @Override
-                    public String toString() {
-                        return field + " % " + val + " = 0";
-                    }
-                };
             case LIKE:
                 return new Predicate<T>() {
 

src/main/java/org/redkale/source/FilterValue.java

@@ -0,0 +1,62 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.redkale.source;
+
+/**
+ * FilterValue主要用于复杂的表达式， 例如: col / 10 = 3 、MOD(col, 8) > 0 这些都不是单独一个数值能表达的，因此需要FilterValue 才构建 8 、 > 、0 组合值.
+ *
+ * @author zhangjx
+ */
+public class FilterValue implements java.io.Serializable {
+
+    private Number optvalue;
+
+    private FilterExpress express;
+
+    private Number destvalue;
+
+    public FilterValue() {
+    }
+
+    public FilterValue(Number optvalue, Number destvalue) {
+        this(optvalue, FilterExpress.EQUAL, destvalue);
+    }
+
+    public FilterValue(Number optvalue, FilterExpress express) {
+        this(optvalue, express, 0);
+    }
+
+    public FilterValue(Number optvalue, FilterExpress express, Number destvalue) {
+        this.optvalue = optvalue;
+        this.express = express;
+        this.destvalue = destvalue;
+    }
+
+    public Number getOptvalue() {
+        return optvalue == null ? 0 : optvalue;
+    }
+
+    public void setOptvalue(Number optvalue) {
+        this.optvalue = optvalue;
+    }
+
+    public FilterExpress getExpress() {
+        return express == null ? FilterExpress.EQUAL : express;
+    }
+
+    public void setExpress(FilterExpress express) {
+        this.express = express;
+    }
+
+    public Number getDestvalue() {
+        return destvalue == null ? 0 : destvalue;
+    }
+
+    public void setDestvalue(Number destvalue) {
+        this.destvalue = destvalue;
+    }
+
+}