Example #1
0
    /** @see java.util.Comparator#compare(java.lang.Object, java.lang.Object) */
    public int compare(Object o1, Object o2) {
      try {
        int i1 = ((Integer) o1).intValue();
        int i2 = ((Integer) o2).intValue();

        for (int i = 0; i < orders.length; i++) {
          Value v1 = columnCache[i1][i];
          Value v2 = columnCache[i2][i];

          if (v1 instanceof NullValue) return -1 * orders[i];
          if (v2 instanceof NullValue) return 1 * orders[i];

          if (v1 instanceof StringValue && v2 instanceof StringValue) {
            String s1 = ((StringValue) v1).getValue();
            String s2 = ((StringValue) v2).getValue();
            if (collator.equals(s1.toLowerCase(), (s2.toLowerCase()))) {
              if (collator.compare(s1, s2) < 0) {
                return -1 * orders[i];
              } else {
                return 1 * orders[i];
              }
            }
            if (collator.compare(s1.toLowerCase(), s2.toLowerCase()) < 0) {
              return -1 * orders[i];
            } else {
              return 1 * orders[i];
            }
          }

          if (((BooleanValue) v1.less(v2)).getValue()) {
            return -1 * orders[i];
          } else if (((BooleanValue) v2.less(v1)).getValue()) {
            return 1 * orders[i];
          }
        }
        /*
         * Because none of the orders criteria defined an order. The first
         * value will be less than the second
         *
         */
        return -1;
      } catch (IncompatibleTypesException e) {
        throw new RuntimeException(e);
      }
    }
  /**
   * Evalua expresión invocando el método adecuado en función del tipo de expresion (suma, producto,
   * ...) de los objetos Value de la expresion, de las subexpresiones y de los objetos Field
   *
   * @param row Fila en la que se evalúa la expresión, en este caso no es necesario, pero las
   *     subexpresiones sobre las que se opera pueden ser campos de una tabla, en cuyo caso si es
   *     necesario
   * @return Objeto Value resultado de la operación propia de la expresión representada por el nodo
   *     sobre el cual éste objeto es adaptador
   * @throws SemanticException Si se produce un error semántico
   * @throws DriverException Si se produce un error de I/O
   */
  public Value evaluate(long row) throws EvaluationException {
    Value ret = null;

    Adapter[] expr = getChilds();

    if (expr.length > 0) {
      ret = ((Expression) expr[0]).evaluateExpression(row);

      for (int i = 1; i < expr.length; i++) {
        try {
          ret = ret.or(((Expression) expr[i]).evaluateExpression(row));
        } catch (IncompatibleTypesException e) {
          throw new EvaluationException();
        }
      }
    }

    return ret;
  }