queryimpl.java

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

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

    InvokeAnyNode(Node target, String name, Node arguments[], String containsFieldName) { 
        super(tpAny, opInvokeAny);
        this.target = target;
        this.containsFieldName = containsFieldName;
        methodName = name;
        this.arguments = arguments;
        profile = new Class[arguments.length];
    }

    Object evaluateObj(FilterIterator t) {
        Class cls;
        Method m;
        Object obj = t.currObj;
        if (target != null) { 
            obj = target.evaluateObj(t);
            if (obj == null) { 
                throw new JSQLNullPointerException(null, methodName);
            }
        }
        Object[] parameters = null;
        int n = arguments.length; 
        if (n > 0) { 
            parameters = new Object[n];
            for (int i = 0; i < n; i++) { 
                Node arg = arguments[i];
                Object value;
                Class type;
                switch (arg.type) { 
                case Node.tpInt:
                    value = new Long(arg.evaluateInt(t));
                    type = long.class;
                    break;
                case Node.tpReal:
                    value = new Double(arg.evaluateReal(t)); 
                    type = double.class;
                    break;
                case Node.tpStr:
                    value = arg.evaluateStr(t);
                    type = String.class;
                    break;
                case Node.tpBool:
                    value = new Boolean(arg.evaluateBool(t));
                    type = boolean.class;
                    break;
                default:
                    value = arg.evaluateObj(t);
                    if (value != null) {
                        type = value.getClass();
                        if (type.equals(Long.class) || type.equals(Integer.class) || type.equals(Byte.class)
                            || type.equals(Character.class) || type.equals(Short.class))
                        { 
                            type = long.class;
                        } else if (type.equals(Float.class) || type.equals(Double.class)) { 
                            type = double.class;
                        } else if (type.equals(Boolean.class)) { 
                            type = boolean.class;
                        }
                    } else { 
                        type = Object.class;
                    }
                }
                parameters[i] = value;
                profile[i] = type;
            }
        }
        try { 
            if (target == null && t.containsElem != null) { 
                if ((m = QueryImpl.lookupMethod(t.containsElem.getClass(), methodName, profile)) != null) {
                    return t.query.resolve(m.invoke(t.containsElem, parameters));
                }
            }
            cls = obj.getClass();
            if ((m = QueryImpl.lookupMethod(cls, methodName, profile)) != null) { 
                return t.query.resolve(m.invoke(t.containsElem, parameters));
            } 
        } catch (InvocationTargetException x) {
            x.printStackTrace();
            throw new IllegalAccessError();            
        } catch(IllegalAccessException x) { 
            x.printStackTrace();
            throw new IllegalAccessError();
        }

        throw new JSQLNoSuchFieldException(cls, methodName);
    }
}        


class ConvertAnyNode extends Node { 
    public boolean equals(Object o) { 
        return o instanceof ConvertAnyNode && super.equals(o) && ((ConvertAnyNode)o).expr.equals(expr);
    }

    boolean evaluateBool(FilterIterator t) { 
        return ((Boolean)evaluateObj(t)).booleanValue();
    }

    long evaluateInt(FilterIterator t) { 
        return ((Number)evaluateObj(t)).longValue();
    }

    double evaluateReal(FilterIterator t) { 
        return ((Number)evaluateObj(t)).doubleValue();
    }
    
    Object evaluateObj(FilterIterator t) { 
        return expr.evaluateObj(t);
    }

    ConvertAnyNode(int type, Node expr) { 
        super(type, opConvertAny);
        this.expr = expr;
    }
    Node expr;
}

class BinOpNode extends Node { 
    Node left;
    Node right;

    public boolean equals(Object o) { 
        return o instanceof BinOpNode 
            && super.equals(o)
            && ((BinOpNode)o).left.equals(left) 
            && ((BinOpNode)o).right.equals(right);
    }

    long evaluateInt(FilterIterator t) {
        long lval = left.evaluateInt(t);
        long rval = right.evaluateInt(t);
        long res;
        switch (tag) { 
          case opIntAdd:
            return lval + rval;
          case opIntSub:
            return lval - rval;
          case opIntMul:
            return lval * rval;
          case opIntDiv:
            if (rval == 0) { 
                throw new JSQLArithmeticException("Divided by zero");
            }
            return lval / rval;
          case opIntAnd:
            return lval & rval;
          case opIntOr:
            return lval | rval;
          case opIntPow:
            res = 1;
            if (rval < 0) {
                lval = 1/lval;
                rval = -rval;
            }
            while (rval != 0) {
                if ((rval & 1) != 0) { 
                    res *= lval;
                }
                lval *= lval;
                rval >>>= 1;
            }
            return res; 
          default:
            throw new Error("Invalid tag");
        }
    }

    double evaluateReal(FilterIterator t) {
        double lval = left.evaluateReal(t);
        double rval = right.evaluateReal(t);
        switch (tag) { 
          case opRealAdd:
            return lval + rval;
          case opRealSub:
            return lval - rval;
          case opRealMul:
            return lval * rval;
          case opRealDiv:
            return lval / rval;
          case opRealPow:
            return Math.pow(lval, rval);
          default:
            throw new Error("Invalid tag");
        }
    }

    String evaluateStr(FilterIterator t) {
        String lval = left.evaluateStr(t);
        String rval = right.evaluateStr(t);
        return lval + rval;
    }

    Object evaluateObj(FilterIterator t) { 
        Object lval, rval;
        try { 
            lval = left.evaluateObj(t);
        } catch (JSQLRuntimeException x) { 
            t.query.reportRuntimeError(x);
            rval = right.evaluateObj(t);
            if (rval instanceof Boolean) { 
                return ((Boolean)rval).booleanValue()? Boolean.TRUE : Boolean.FALSE;
            }
            throw x;
        }
            
        if (lval instanceof Boolean) { 
            switch (tag) { 
              case opAnyAnd:
                return ((Boolean)lval).booleanValue() && ((Boolean)right.evaluateObj(t)).booleanValue()
                    ? Boolean.TRUE : Boolean.FALSE;
              case opAnyOr:
                return ((Boolean)lval).booleanValue() || ((Boolean)right.evaluateObj(t)).booleanValue()
                    ? Boolean.TRUE : Boolean.FALSE;
              default:
                throw new Error("Operation is not applicable to operands of boolean type");
            }
        }
        rval = right.evaluateObj(t);
        if (lval instanceof Double || lval instanceof Float 
            || rval instanceof Double || rval instanceof Float)
        {
            double r1 = ((Number)lval).doubleValue();
            double r2 = ((Number)rval).doubleValue();
            switch (tag) {
              case opAnyAdd:
                return new Double(r1 + r2);
              case opAnySub:
                return new Double(r1 - r2);
              case opAnyMul:
                return new Double(r1 * r2);
              case opAnyDiv:
                return new Double(r1 / r2);
              case opAnyPow:
                return new Double(Math.pow(r1, r2));
              default:
                throw new Error("Operation is not applicable to operands of real type");
            }
        } else if (lval instanceof String && rval instanceof String) { 
            return (String)lval + (String)rval;
        } else { 
            long i1 = ((Number)lval).longValue();
            long i2 = ((Number)rval).longValue();
            long res;
            switch (tag) { 
              case opAnyAdd:
                return new Long(i1 + i2);
              case opAnySub:
                return new Long(i1 - i2);
              case opAnyMul:
                return new Long(i1 * i2);
              case opAnyDiv:
                if (i2 == 0) { 
                    throw new JSQLArithmeticException("Divided by zero");
                }
                return new Long(i1 / i2);
              case opAnyAnd:
                return new Long(i1 & i2);
              case opAnyOr:
                return new Long(i1 | i2);
              case opAnyPow:
                res = 1;
                if (i1 < 0) {
                    i2 = 1/i2;
                    i1 = -i1;
                }
                while (i1 != 0) {
                    if ((i1 & 1) != 0) { 
                        res *= i2;
                    }
                    i2 *= i2;
                    i1 >>>= 1;
                }
                return new Long(res);             
              default:
                throw new Error("Operation is not applicable to operands of integer type");
            }
        }
    }

    static boolean areEqual(Object a, Object b) { 
        if (a == b) {
            return true;
        }
        if (a instanceof Double || a instanceof Float || b instanceof Double || b instanceof Float) { 
            return ((Number)a).doubleValue() == ((Number)b).doubleValue();
        } else if (a instanceof Number || b instanceof Number) { 
            return ((Number)a).longValue() == ((Number)b).longValue();
        } else if (a != null) { 
            return a.equals(b);
        }
        return false;
    }

    static int compare(Object a, Object b) { 
        if (a instanceof Double || a instanceof Float || b instanceof Double || b instanceof Float) { 
            double r1 = ((Number)a).doubleValue();
            double r2 = ((Number)b).doubleValue();
            return r1 < r2 ? -1 : r1 == r2 ? 0 : 1;
        } else if (a instanceof Number || b instanceof Number) { 
            long i1 = ((Number)a).longValue();
            long i2 = ((Number)b).longValue();
            return i1 < i2 ? -1 : i1 == i2 ? 0 : 1; 
        } else { 
            return ((Comparable)a).compareTo(b);
        }
    }

    boolean evaluateBool(FilterIterator t) {
        switch (tag) { 
          case opAnyEq:
            return areEqual(left.evaluateObj(t), right.evaluateObj(t));
          case opAnyNe:
            return !areEqual(left.evaluateObj(t), right.evaluateObj(t));
          case opAnyLt:
            return compare(left.evaluateObj(t), right.evaluateObj(t)) < 0;
          case opAnyLe:
            return compare(left.evaluateObj(t), right.evaluateObj(t)) <= 0;
          case opAnyGt:
            return compare(left.evaluateObj(t), right.evaluateObj(t)) > 0;
          case opAnyGe:
            return compare(left.evaluateObj(t), right.evaluateObj(t)) >= 0;
          case opInAny:
          {
              Object elem = left.evaluateObj(t);
              Object set =  right.evaluateObj(t);
              if (set instanceof String) {
                  return ((String)set).indexOf((String)elem) >= 0;
              } else {  
                  Object[] arr = (Object[])set;
                  for (int i = arr.length; --i >= 0;) { 
                      if (elem.equals(arr[i])) { 
                          return true;
                      }
                  }
                  return false;
              }
          }
          case opBoolAnd:
            try { 
                if (!left.evaluateBool(t)) { 
                    return false;
                }
            } catch (JSQLRuntimeException x) { 
                t.query.reportRuntimeError(x);
            }
            return right.evaluateBool(t);
          case opBoolOr:
            try { 
                if (left.evaluateBool(t)) { 
                    return true;
                }
            } catch (JSQLRuntimeException x) { 
                t.query.reportRuntimeError(x);
            }
            return right.evaluateBool(t);

          case opIntEq:
            return left.evaluateInt(t) == right.evaluateInt(t);
          case opIntNe:
            return left.evaluateInt(t) != right.evaluateInt(t);
          case opIntLt:
            return left.evaluateInt(t) < right.evaluateInt(t);
          case opIntLe:
            return left.evaluateInt(t) <= right.evaluateInt(t);
          case opIntGt:
            return left.evaluateInt(t) > right.evaluateInt(t);
          case opIntGe:
            return left.evaluateInt(t) >= right.evaluateInt(t);

          case opRealEq:
            return left.evaluateReal(t) == right.evaluateReal(t);
          case opRealNe:
            return left.evaluateReal(t) != right.evaluateReal(t);
          case opRealLt:
            return left.evaluateReal(t) <  right.evaluateReal(t);
          case opRealLe:
            return left.evaluateReal(t) <= right.evaluateReal(t);
          case opRealGt:
            return left.evaluateReal(t) >  right.evaluateReal(t);
          case opRealGe:
            return left.evaluateReal(t) >= right.evaluateReal(t);

          case opStrEq:
            return left.evaluateStr(t).equals(right.evaluateStr(t));
          case opStrNe:
            return !left.evaluateStr(t).equals(right.evaluateStr(t));
          case opStrLt:
            return left.evaluateStr(t).compareTo(right.evaluateStr(t)) < 0;
          case opStrLe:
            return left.evaluateStr(t).compareTo(right.evaluateStr(t)) <= 0;
          case opStrGt:
            return left.evaluateStr(t).compareTo(right.evaluateStr(t)) > 0;
          case opStrGe:
            return left.evaluateStr(t).compareTo(right.evaluateStr(t)) >= 0;

          case opBoolEq:
            return left.evaluateBool(t) == right.evaluateBool(t);
          case opBoolNe: