queryimpl.java

这个是perst-269.zip下面的SOURCECODE,和大家分享了。

          case opObjEq:
            return areEqual(left.evaluateObj(t), right.evaluateObj(t));
          case opObjNe:
            return areEqual(left.evaluateObj(t), right.evaluateObj(t));

          case opScanCollection:
            return ((Collection)right.evaluateObj(t)).contains(left.evaluateObj(t));
          case opScanArrayBool:
          {
            boolean val = left.evaluateBool(t);
            boolean[] arr = (boolean[])right.evaluateObj(t);  
            for (int i = arr.length; --i >= 0;) { 
                if (arr[i] == val) { 
                    return true;
                }
            }
            return false;
          }
          case opScanArrayInt1:
          {
            long val = left.evaluateInt(t);
            byte[] arr = (byte[])right.evaluateObj(t);  
            for (int i = arr.length; --i >= 0;) { 
                if (arr[i] == val) { 
                    return true;
                }
            }
            return false;
          }
          case opScanArrayChar:
          {
            long val = left.evaluateInt(t);
            char[] arr = (char[])right.evaluateObj(t);  
            for (int i = arr.length; --i >= 0;) { 
                if (arr[i] == val) { 
                    return true;
                }
            }
            return false;
          }
          case opScanArrayInt2:
          {
            long val = left.evaluateInt(t);
            short[] arr = (short[])right.evaluateObj(t);  
            for (int i = arr.length; --i >= 0;) { 
                if (arr[i] == val) { 
                    return true;
                }
            }
            return false;
          }
          case opScanArrayInt4:
          {
            long val = left.evaluateInt(t);
            int[] arr = (int[])right.evaluateObj(t);  
            for (int i = arr.length; --i >= 0;) { 
                if (arr[i] == val) { 
                    return true;
                }
            }
            return false;
          }
          case opScanArrayInt8:
          {
            long val = left.evaluateInt(t);
            long[] arr = (long[])right.evaluateObj(t);  
            for (int i = arr.length; --i >= 0;) { 
                if (arr[i] == val) { 
                    return true;
                }
            }
            return false;
          }
          case opScanArrayReal4:
          {
            double val = left.evaluateReal(t);
            float[] arr = (float[])right.evaluateObj(t);  
            for (int i = arr.length; --i >= 0;) { 
                if (arr[i] == val) { 
                    return true;
                }
            }
            return false;
          }
          case opScanArrayReal8:
          {
            double val = left.evaluateReal(t);
            double[] arr = (double[])right.evaluateObj(t);  
            for (int i = arr.length; --i >= 0;) { 
                if (arr[i] == val) { 
                    return true;
                }
            }
            return false;
          }
          case opScanArrayStr:
          {
            String val = left.evaluateStr(t);
            String[] arr = (String[])right.evaluateObj(t);  
            for (int i = arr.length; --i >= 0;) { 
                if (val.equals(arr[i])) { 
                    return true;
                }
            }
            return false;
          }
          case opScanArrayObj:
          {
            Object val = left.evaluateObj(t);
            Object[] arr = (Object[])right.evaluateObj(t);  
            for (int i = arr.length; --i >= 0;) { 
                if (areEqual(val, arr[i])) { 
                    return true;
                }
            }
            return false;
          }
          case opInString:
          {
            String substr = left.evaluateStr(t);
            String str = right.evaluateStr(t);
            return str.indexOf(substr) >= 0;
          }
          default:
            throw new Error("Invalid tag " + tag);
        }
    }

    BinOpNode(int type, int tag, Node left, Node right) {
        super(type, tag);
        this.left = left;
        this.right = right;
    }
}

class CompareNode extends Node {
    Node o1, o2, o3;

    public boolean equals(Object o) { 
        return o instanceof CompareNode
            && super.equals(o) 
            && ((CompareNode)o).o1.equals(o1) && ((CompareNode)o).o2.equals(o2)
            && equalObjects(((CompareNode)o).o3, o3);
    }

    boolean evaluateBool(FilterIterator t) {
        switch(tag) { 
          case opAnyBetween:
          {
              Object val = o1.evaluateObj(t);
              return BinOpNode.compare(val, o2.evaluateObj(t)) >= 0 && BinOpNode.compare(val, o3.evaluateObj(t)) <= 0;
          }
          case opIntBetween:
          {
            long val = o1.evaluateInt(t);
            return val >= o2.evaluateInt(t) && val <= o3.evaluateInt(t);
          }       
          case opRealBetween:
          {
            double val = o1.evaluateReal(t);
            return val >= o2.evaluateReal(t) && val <= o3.evaluateReal(t);
          }
          case opStrBetween:
          {
            String val = o1.evaluateStr(t);
            return val.compareTo(o2.evaluateStr(t)) >= 0 
                && val.compareTo(o3.evaluateStr(t)) <= 0;
          }
          case opStrLike:
          {
            String str = o1.evaluateStr(t);
            String pat = o2.evaluateStr(t);
            int pi = 0, si = 0, pn = pat.length(), sn = str.length(); 
            int wildcard = -1, strpos = -1;
            while (true) { 
                if (pi < pn && pat.charAt(pi) == '%') { 
                    wildcard = ++pi;
                    strpos = si;
                } else if (si == sn) { 
                    return pi == pn;
                } else if (pi < pn && (str.charAt(si) == pat.charAt(pi) 
                                       || pat.charAt(pi) == '_')) {
                    si += 1;
                    pi += 1;
                } else if (wildcard >= 0) { 
                    si = ++strpos;
                    pi = wildcard;
                } else { 
                    return false;
                }
            }
          }
          case opStrLikeEsc:
          {
            String str = o1.evaluateStr(t);
            String pat = o2.evaluateStr(t);
            char escape = o3.evaluateStr(t).charAt(0);
            int pi = 0, si = 0, pn = pat.length(), sn = str.length(); 
            int wildcard = -1, strpos = -1;
            while (true) { 
                if (pi < pn && pat.charAt(pi) == '%') { 
                    wildcard = ++pi;
                    strpos = si;
                } else if (si == sn) { 
                    return pi == pn;
                } else if (pi+1 < pn && pat.charAt(pi) == escape && 
                           pat.charAt(pi+1) == str.charAt(si)) {
                    si += 1;
                    pi += 2;
                } else if (pi < pn && ((pat.charAt(pi) != escape 
                                        && (str.charAt(si) == pat.charAt(pi) 
                                            || pat.charAt(pi) == '_')))) {
                    si += 1;
                    pi += 1;
                } else if (wildcard >= 0) { 
                    si = ++strpos;
                    pi = wildcard;
                } else { 
                    return false;
                }
            }
          }
          default:
            throw new Error("Invalid tag " + tag);
        }
    }

    CompareNode(int tag, Node a, Node b, Node c) { 
        super(tpBool, tag);
        o1 = a;
        o2 = b;
        o3 = c;
    }
}


class UnaryOpNode extends Node { 
    Node opd;

    public boolean equals(Object o) { 
        return o instanceof UnaryOpNode && super.equals(o) && ((UnaryOpNode)o).opd.equals(opd);
    }

    Object evaluateObj(FilterIterator t) { 
        Object val = opd.evaluateObj(t);
        switch (tag) {
          case opAnyNeg:
            return val instanceof Double || val instanceof Float 
                ? (Object)new Double(-((Number)val).doubleValue())
                : (Object)new Long(-((Number)val).longValue());
          case opAnyAbs:
            if (val instanceof Double || val instanceof Float) { 
                double rval = ((Number)val).doubleValue();
                return new Double(rval < 0 ? -rval : rval);
            } else { 
                long ival = ((Number)val).longValue();
                return new Long(ival < 0 ? -ival : ival);
            }
          case opAnyNot:
            return val instanceof Boolean 
                ? ((Boolean)val).booleanValue() ? Boolean.FALSE : Boolean.TRUE
                : (Object)new Long(~((Number)val).longValue());
          default:
            throw new Error("Invalid tag " + tag);
        } 
    }

    long evaluateInt(FilterIterator t) {
        long val;
        switch (tag) {
          case opIntNot:
            return ~opd.evaluateInt(t);
          case opIntNeg:
            return -opd.evaluateInt(t);
          case opIntAbs:
            val = opd.evaluateInt(t);
            return val < 0 ? -val : val;
          case opRealToInt:
            return (long)opd.evaluateReal(t);
          case opAnyLength:
            { 
                Object obj = opd.evaluateObj(t);
                if (obj instanceof String) { 
                    return ((String)obj).length();
                } else { 
                    try { 
                        return Array.getLength(obj);
                    } catch (IllegalArgumentException x) {
                        throw new Error("Argument is not array");
                    }
                }                  
            }
          case opLength:
            try { 
                return Array.getLength(opd.evaluateObj(t));
            } catch (IllegalArgumentException x) {
                throw new Error("Argument is not array");
            }
          case opStrLength:
            return opd.evaluateStr(t).length();
          default:
            throw new Error("Invalid tag " + tag);
        }
    }
    
    double evaluateReal(FilterIterator t) { 
        double val;
        switch (tag) { 
          case opRealNeg:
            return -opd.evaluateReal(t);
          case opRealAbs:
            val = opd.evaluateReal(t);
            return val < 0 ? -val : val;
          case opRealSin:
            return Math.sin(opd.evaluateReal(t));
          case opRealCos:
            return Math.cos(opd.evaluateReal(t));
          case opRealTan:
            return Math.tan(opd.evaluateReal(t));
          case opRealAsin:
            return Math.asin(opd.evaluateReal(t));
          case opRealAcos:
            return Math.acos(opd.evaluateReal(t));
          case opRealAtan:
            return Math.atan(opd.evaluateReal(t));
          case opRealExp:
            return Math.exp(opd.evaluateReal(t));
          case opRealLog:
            return Math.log(opd.evaluateReal(t));
          case opRealSqrt:
            return Math.sqrt(opd.evaluateReal(t));
          case opRealCeil:
            return Math.ceil(opd.evaluateReal(t));
          case opRealFloor:
            return Math.floor(opd.evaluateReal(t));
          case opIntToReal:
            return (double)opd.evaluateInt(t);
          default:
            throw new Error("Invalid tag " + tag);
        }
    }
    
    String evaluateStr(FilterIterator t) { 
        switch (tag) { 
          case opStrUpper:
            return opd.evaluateStr(t).toUpperCase();
          case opStrLower:
            return opd.evaluateStr(t).toLowerCase();
          case opIntToStr:
            return Long.toString(opd.evaluateInt(t), 10);
          case opRealToStr:
            return Double.toString(opd.evaluateReal(t));
          case opAnyToStr:
            return opd.evaluateObj(t).toString();
          default:
            throw new Error("Invalid tag " + tag);
        }
    }
    
    boolean evaluateBool(FilterIterator t) { 
        switch (tag) { 
          case opBoolNot:
            return !opd.evaluateBool(t);
          case opIsNull:
            return opd.evaluateObj(t) == null;
          default:
            throw new Error("Invalid tag " + tag);
        }
    }

    UnaryOpNode(int type, int tag, Node node) { 
        super(type, tag);
        opd = node;
    }
}


class LoadAnyNode extends Node { 
    String fieldName;
    String containsFieldName;
    Node   base;
    Field  f;
    Method m;
    
    public boolean equals(Object o) { 
        if (!(o instanceof LoadAnyNode)) { 
            return false;
        }
        LoadAnyNode node = (LoadAnyNode)o;        
        return equalObjects(node.base, base)
            && equalObjects(node.fieldName, fieldName)
            && equalObjects(node.f, f)
            && equalObjects(node.m, m);
    }

    Class getType() { 
        return Object.class;
    }

    String getFieldName() { 
        if (base != null) { 
            if (base.tag != opCurrent) { 
                String baseName = base.getFieldName();
                return (baseName != null) ? baseName + "." + fieldName : null;
            } else { 
                return fieldName;