Java Code Examples for org.apache.pig.Expression#getOpType()

/**
 * Return cql where clauses for the corresponding partition filter. Make sure the data format matches
 * Only support the following Pig data types: int, long, float, double, boolean and chararray
 * */
private String partitionFilterToWhereClauseString(Expression expression) throws IOException
{
    Expression.BinaryExpression be = (Expression.BinaryExpression) expression;
    OpType op = expression.getOpType();
    String opString = op.toString();
    switch (op)
    {
        case OP_EQ:
            opString = " = ";
        case OP_GE:
        case OP_GT:
        case OP_LE:
        case OP_LT:
            String name = be.getLhs().toString();
            String value = be.getRhs().toString();
            return String.format("%s %s %s", name, opString, value);
        case OP_AND:
            return String.format("%s AND %s", partitionFilterToWhereClauseString(be.getLhs()), partitionFilterToWhereClauseString(be.getRhs()));
        default:
            throw new IOException("Unsupported expression type: " + opString);
    }
}
 

/** get a list of Cassandra IndexExpression from Pig expression */
private List<IndexExpression> filterToIndexExpressions(Expression expression) throws IOException
{
    List<IndexExpression> indexExpressions = new ArrayList<IndexExpression>();
    Expression.BinaryExpression be = (Expression.BinaryExpression)expression;
    ByteBuffer name = ByteBuffer.wrap(be.getLhs().toString().getBytes());
    ByteBuffer value = ByteBuffer.wrap(be.getRhs().toString().getBytes());
    switch (expression.getOpType())
    {
        case OP_EQ:
            indexExpressions.add(new IndexExpression(name, IndexOperator.EQ, value));
            break;
        case OP_GE:
            indexExpressions.add(new IndexExpression(name, IndexOperator.GTE, value));
            break;
        case OP_GT:
            indexExpressions.add(new IndexExpression(name, IndexOperator.GT, value));
            break;
        case OP_LE:
            indexExpressions.add(new IndexExpression(name, IndexOperator.LTE, value));
            break;
        case OP_LT:
            indexExpressions.add(new IndexExpression(name, IndexOperator.LT, value));
            break;
        case OP_AND:
            indexExpressions.addAll(filterToIndexExpressions(be.getLhs()));
            indexExpressions.addAll(filterToIndexExpressions(be.getRhs()));
            break;
        default:
            throw new IOException("Unsupported expression type: " + expression.getOpType().name());
    }
    return indexExpressions;
}
 

private Object getExpressionValue(Expression expr) {
    switch(expr.getOpType()) {
    case TERM_COL:
        return ((Column) expr).getName();
    case TERM_CONST:
        return getSearchArgObjValue(((Const) expr).getValue());
    default:
        throw new RuntimeException("Unsupported expression type: " + expr.getOpType() + " in " + expr);
    }
}
 

private org.apache.iceberg.expressions.Expression convert(Expression expression) throws IOException {
  OpType op = expression.getOpType();

  if (expression instanceof BinaryExpression) {
    Expression lhs = ((BinaryExpression) expression).getLhs();
    Expression rhs = ((BinaryExpression) expression).getRhs();

    switch (op) {
      case OP_AND:
        return Expressions.and(convert(lhs), convert(rhs));
      case OP_OR:
        return Expressions.or(convert(lhs), convert(rhs));
      case OP_BETWEEN:
        BetweenExpression between = (BetweenExpression) rhs;
        return Expressions.and(
            convert(OpType.OP_GE, (Column) lhs, (Const) between.getLower()),
            convert(OpType.OP_LE, (Column) lhs, (Const) between.getUpper())
        );
      case OP_IN:
        return ((InExpression) rhs).getValues().stream()
            .map(value -> convert(OpType.OP_EQ, (Column) lhs, (Const) value))
            .reduce(Expressions.alwaysFalse(), Expressions::or);
      default:
        if (lhs instanceof Column && rhs instanceof Const) {
          return convert(op, (Column) lhs, (Const) rhs);
        } else if (lhs instanceof Const && rhs instanceof Column) {
          throw new FrontendException("Invalid expression ordering " + expression);
        }
    }

  } else if (expression instanceof UnaryExpression) {
    Expression unary = ((UnaryExpression) expression).getExpression();

    switch (op) {
      case OP_NOT:  return Expressions.not(convert(unary));
      case OP_NULL: return Expressions.isNull(((Column) unary).getName());
      default: throw new FrontendException("Unsupported unary operator" + op);
    }
  }

  throw new FrontendException("Failed to pushdown expression " + expression);
}
 

private com.netflix.iceberg.expressions.Expression convert(Expression e) throws IOException {
  OpType op = e.getOpType();

  if (e instanceof BinaryExpression) {
    Expression lhs = ((BinaryExpression) e).getLhs();
    Expression rhs = ((BinaryExpression) e).getRhs();

    switch (op) {
      case OP_AND:
        return and(convert(lhs), convert(rhs));
      case OP_OR:
        return or(convert(lhs), convert(rhs));
      case OP_BETWEEN:
        BetweenExpression between = (BetweenExpression) rhs;
        return and(
            convert(OP_GE, (Column) lhs, (Const) between.getLower()),
            convert(OP_LE, (Column) lhs, (Const) between.getUpper())
        );
      case OP_IN:
        return ((InExpression) rhs).getValues().stream()
            .map((value) -> convert(OP_EQ, (Column) lhs, (Const) value))
            .reduce(Expressions.alwaysFalse(), (m, v) -> (or(m, v)));
      default:
        if (lhs instanceof Column && rhs instanceof Const) {
          return convert(op, (Column) lhs, (Const) rhs);
        } else if (lhs instanceof Const && rhs instanceof Column) {
          throw new FrontendException("Invalid expression ordering " + e);
        }
    }

  } else if (e instanceof UnaryExpression) {
    Expression unary = ((UnaryExpression) e).getExpression();

    switch (op) {
      case OP_NOT:  return not(convert(unary));
      case OP_NULL: return isNull(((Column)unary).getName());
      default:
        throw new FrontendException("Unsupported unary operator" + op);
    }
  }

  throw new FrontendException("Failed to pushdown expression " + e);
}
 

private FilterPredicate buildFilter(Expression e) {
  OpType op = e.getOpType();

  if (e instanceof BinaryExpression) {
    Expression lhs = ((BinaryExpression) e).getLhs();
    Expression rhs = ((BinaryExpression) e).getRhs();

    switch (op) {
      case OP_AND:
        return and(buildFilter(lhs), buildFilter(rhs));
      case OP_OR:
        return or(buildFilter(lhs), buildFilter(rhs));
      case OP_BETWEEN:
        BetweenExpression between = (BetweenExpression) rhs;
        return and(
            buildFilter(OpType.OP_GE, (Column) lhs, (Const) between.getLower()),
            buildFilter(OpType.OP_LE, (Column) lhs, (Const) between.getUpper()));
      case OP_IN:
        FilterPredicate current = null;
        for (Object value : ((InExpression) rhs).getValues()) {
          FilterPredicate next = buildFilter(OpType.OP_EQ, (Column) lhs, (Const) value);
          if (current != null) {
            current = or(current, next);
          } else {
            current = next;
          }
        }
        return current;
    }

    if (lhs instanceof Column && rhs instanceof Const) {
      return buildFilter(op, (Column) lhs, (Const) rhs);
    } else if (lhs instanceof Const && rhs instanceof Column) {
      return buildFilter(op, (Column) rhs, (Const) lhs);
    }
  } else if (e instanceof UnaryExpression && op == OpType.OP_NOT) {
    return LogicalInverseRewriter.rewrite(
        not(buildFilter(((UnaryExpression) e).getExpression())));
  }

  throw new RuntimeException("Could not build filter for expression: " + e);
}
 

private void buildSearchArgument(Expression expr, Builder builder) {
    if (expr instanceof BinaryExpression) {
        Expression lhs = ((BinaryExpression) expr).getLhs();
        Expression rhs = ((BinaryExpression) expr).getRhs();
        switch (expr.getOpType()) {
        case OP_AND:
            builder.startAnd();
            buildSearchArgument(lhs, builder);
            buildSearchArgument(rhs, builder);
            builder.end();
            break;
        case OP_OR:
            builder.startOr();
            buildSearchArgument(lhs, builder);
            buildSearchArgument(rhs, builder);
            builder.end();
            break;
        case OP_EQ:
            builder.equals(getColumnName(lhs), getExpressionValue(rhs));
            break;
        case OP_NE:
            builder.startNot();
            builder.equals(getColumnName(lhs), getExpressionValue(rhs));
            builder.end();
            break;
        case OP_LT:
            builder.lessThan(getColumnName(lhs), getExpressionValue(rhs));
            break;
        case OP_LE:
            builder.lessThanEquals(getColumnName(lhs), getExpressionValue(rhs));
            break;
        case OP_GT:
            builder.startNot();
            builder.lessThanEquals(getColumnName(lhs), getExpressionValue(rhs));
            builder.end();
            break;
        case OP_GE:
            builder.startNot();
            builder.lessThan(getColumnName(lhs), getExpressionValue(rhs));
            builder.end();
            break;
        case OP_BETWEEN:
            BetweenExpression between = (BetweenExpression) rhs;
            builder.between(getColumnName(lhs), getSearchArgObjValue(between.getLower()),  getSearchArgObjValue(between.getUpper()));
        case OP_IN:
            InExpression in = (InExpression) rhs;
            builder.in(getColumnName(lhs), getSearchArgObjValues(in.getValues()).toArray());
        default:
            throw new RuntimeException("Unsupported binary expression type: " + expr.getOpType() + " in " + expr);
        }
    } else if (expr instanceof UnaryExpression) {
        Expression unaryExpr = ((UnaryExpression) expr).getExpression();
        switch (expr.getOpType()) {
        case OP_NULL:
            builder.isNull(getColumnName(unaryExpr));
            break;
        case OP_NOT:
            builder.startNot();
            buildSearchArgument(unaryExpr, builder);
            builder.end();
            break;
        default:
            throw new RuntimeException("Unsupported unary expression type: " +
                    expr.getOpType() + " in " + expr);
        }
    } else {
        throw new RuntimeException("Unsupported expression type: " + expr.getOpType() + " in " + expr);
    }
}