Method optimize

basex-core/src/main/java/org/basex/query/expr/Arith.java:40–115

(final CompileContext cc)

  }

  @Override
  public Expr optimize(final CompileContext cc) throws QueryException {
    exprs = simplifyAll(Simplify.NUMBER, cc);
    if(values(false, cc)) return cc.preEval(this);

    // move values to second position
    // 1 + position() → position() + 1
    Expr expr1 = exprs[0], expr2 = exprs[1];
    if((calc == Calc.ADD || calc == Calc.MULTIPLY) && expr1 instanceof Value &&
        !(expr2 instanceof Value)) {
      cc.info(OPTSWAP_X, this);
      exprs[0] = expr2;
      exprs[1] = expr1;
      expr1 = exprs[0];
      expr2 = exprs[1];
    }

    final SeqType st1 = expr1.seqType(), st2 = expr2.seqType();
    final Type type1 = st1.type, type2 = st2.type;
    final boolean numbers = type1.isNumberOrUntyped() && type2.isNumberOrUntyped();

    final Type type = calc.type(type1, type2);
    final boolean noArrays = !st1.mayBeWrapped() && !st2.mayBeWrapped();
    final boolean oneOrMore = noArrays && st1.oneOrMore() && st2.oneOrMore();
    exprType.assign(type, oneOrMore ? Occ.EXACTLY_ONE : Occ.ZERO_OR_ONE);

    Expr expr = emptyExpr();
    // 0 - $x → -$x
    if(expr == this && expr1 == Itr.ZERO && calc == Calc.SUBTRACT) {
      expr = new Unary(info, expr2, true).optimize(cc);
    }
    // count($n/@*) + count($n/*) → count(($n/@*, $n/*))
    if(expr == this && Function.COUNT.is(expr1) && calc == Calc.ADD && Function.COUNT.is(expr2)) {
      expr = cc.function(Function.COUNT, info, List.get(cc, info, expr1.arg(0), expr2.arg(0)));
    }
    if(expr == this && numbers && noArrays && st1.one() && st2.one()) {
      // example: number($a) + 0 → number($a)
      final Expr ex = calc.optimize(expr1, expr2, info, cc);
      if(ex != null) {
        expr = ex;
      } else if(expr1 instanceof final Arith arth1) {
        final Calc acalc = arth1.calc;
        final boolean add = acalc.oneOf(Calc.ADD, Calc.MULTIPLY);
        final boolean sub = acalc.oneOf(Calc.SUBTRACT, Calc.DIVIDE);
        final boolean inverse = acalc == calc.invert();
        final Expr arg1 = arth1.arg(0), arg2 = arth1.arg(1);

        if(arg2 instanceof ANum && expr2 instanceof ANum && (acalc == calc || inverse)) {
          // (E - 3) + 2 → E - (3 - 2)
          // (E * 3 div 2 → E * (3 div 2)
          final Calc ncalc = add ? calc : sub ? calc.invert() : null;
          if(ncalc != null) expr = new Arith(info, arg1,
              new Arith(info, arg2, expr2, ncalc).optimize(cc), acalc).optimize(cc);
        } else if(inverse) {
          // E + NUMBER - NUMBER → E
          // NUMBER * E div NUMBER → E
          expr = arg2.equals(expr2) ? arg1 : arg1.equals(expr2) && add ? arg2 : this;
          if(expr != this) expr = new Cast(info, expr, Types.NUMERIC_O).optimize(cc);