public ComparisonExpression clone(List<Expression> children) { return new ComparisonExpression(children, this.getFilterOp()); }
private static void addEqualityExpression(Expression lhs, Expression rhs, List<Expression> andNodes, ImmutableBytesWritable ptr, boolean rowKeyOrderOptimizable) throws SQLException { boolean isLHSNull = ExpressionUtil.isNull(lhs, ptr); boolean isRHSNull = ExpressionUtil.isNull(rhs, ptr); if (isLHSNull && isRHSNull) { // null == null will end up making the query degenerate andNodes.add(LiteralExpression.newConstant(false, PBoolean.INSTANCE)); } else if (isLHSNull) { // AND rhs IS NULL andNodes.add(IsNullExpression.create(rhs, false, ptr)); } else if (isRHSNull) { // AND lhs IS NULL andNodes.add(IsNullExpression.create(lhs, false, ptr)); } else { // AND lhs = rhs andNodes.add(ComparisonExpression.create(CompareOp.EQUAL, Arrays.asList(lhs, rhs), ptr, rowKeyOrderOptimizable)); } }
@Override public final <T> T accept(ExpressionVisitor<T> visitor) { List<T> l = acceptChildren(visitor, visitor.visitEnter(this)); T t = visitor.visitLeave(this, l); if (t == null) { t = visitor.defaultReturn(this, l); } return t; }
@Override public String toString() { return toString(getFilterOp(), children); } }
@Override public Iterator<Expression> visitEnter(ComparisonExpression node) { Expression rhs = node.getChildren().get(1); if (!rhs.isStateless() || node.getFilterOp() == CompareOp.NOT_EQUAL) { return Collections.emptyIterator(); } return Iterators.singletonIterator(node.getChildren().get(0)); }
if (op == CompareOp.EQUAL || op == CompareOp.NOT_EQUAL) { List<Expression> andNodes = Lists.<Expression>newArrayListWithExpectedSize(Math.max(lhsExpr.getChildren().size(), rhsExpr.getChildren().size())); rewriteRVCAsEqualityExpression(lhsExpr, rhsExpr, andNodes, ptr, rowKeyOrderOptimizable); Expression expr = AndExpression.create(andNodes); if (op == CompareOp.NOT_EQUAL) { } else if(lhsExprDataType != null && rhsExprDataType != null && !lhsExprDataType.isComparableTo(rhsExprDataType)) { throw TypeMismatchException.newException(lhsExprDataType, rhsExprDataType, toString(op, children)); return new ComparisonExpression(children, op);
public static Expression columnComparison(CompareOp op, Expression c1, Expression c2) { return new ComparisonExpression(Arrays.<Expression>asList(c1, c2), op); }
@Override public Boolean visitLeave(ComparisonExpression node, List<Boolean> l) { if (l.isEmpty()) { return null; } node.getChildren().get(1).evaluate(null, ptr); // Set the columnValue at the position of the column to the // constant with which it is being compared. // We always strip the last byte so that we can recognize null // as a value with a single byte. columnValues[position] = new byte [ptr.getLength() + 1]; System.arraycopy(ptr.get(), ptr.getOffset(), columnValues[position], 0, ptr.getLength()); return Boolean.TRUE; }
@Override public Expression visitLeave(ComparisonExpression node, List<Expression> l) { return isCloneNode(node, l) ? node.clone(l) : node; }
int i = 0; for (; i < Math.min(lhs.getChildren().size(),rhs.getChildren().size()); i++) { addEqualityExpression(lhs.getChildren().get(i), rhs.getChildren().get(i), andNodes, ptr, rowKeyOrderOptimizable); addEqualityExpression(lhs.getChildren().get(i), LiteralExpression.newConstant(null, lhs.getChildren().get(i).getDataType()), andNodes, ptr, rowKeyOrderOptimizable); addEqualityExpression(LiteralExpression.newConstant(null, rhs.getChildren().get(i).getDataType()), rhs.getChildren().get(i), andNodes, ptr, rowKeyOrderOptimizable); addEqualityExpression(lhs.getChildren().get(0), rhs, andNodes, ptr, rowKeyOrderOptimizable); for (int i = 1; i < lhs.getChildren().size(); i++) { addEqualityExpression(lhs.getChildren().get(i), LiteralExpression.newConstant(null, lhs.getChildren().get(i).getDataType()), andNodes, ptr, rowKeyOrderOptimizable); addEqualityExpression(lhs, rhs.getChildren().get(0), andNodes, ptr, rowKeyOrderOptimizable); for (int i = 1; i < rhs.getChildren().size(); i++) { addEqualityExpression(LiteralExpression.newConstant(null, rhs.getChildren().get(i).getDataType()), rhs.getChildren().get(i), andNodes, ptr, rowKeyOrderOptimizable);
@Override public Iterator<Expression> visitEnter(ComparisonExpression node) { if (node.getFilterOp() == CompareOp.EQUAL && node.getChildren().get(1).isStateless() && node.getChildren().get(1).getDeterminism() == Determinism.ALWAYS ) { return Iterators.singletonIterator(node.getChildren().get(0)); } return super.visitEnter(node); }
if (op == CompareOp.EQUAL || op == CompareOp.NOT_EQUAL) { List<Expression> andNodes = Lists.<Expression>newArrayListWithExpectedSize(Math.max(lhsExpr.getChildren().size(), rhsExpr.getChildren().size())); rewriteRVCAsEqualityExpression(lhsExpr, rhsExpr, andNodes, ptr, rowKeyOrderOptimizable); Expression expr = AndExpression.create(andNodes); if (op == CompareOp.NOT_EQUAL) { } else if(lhsExprDataType != null && rhsExprDataType != null && !lhsExprDataType.isComparableTo(rhsExprDataType)) { throw TypeMismatchException.newException(lhsExprDataType, rhsExprDataType, toString(op, children)); return new ComparisonExpression(children, op);
public static Expression constantComparison(CompareOp op, Expression e, Object o) { return new ComparisonExpression(Arrays.asList(e, LiteralExpression.newConstant(o)), op); }
@Override public String toString() { return toString(getFilterOp(), children); } }
@Override public boolean evaluate(Tuple tuple, ImmutableBytesWritable ptr) { Expression arrayKVExpression = children.get(0); if (!arrayKVExpression.evaluate(tuple, ptr)) { return false; } else if (ptr.getLength() == 0) { return true; } int length = PArrayDataType.getArrayLength(ptr, PDataType.fromTypeId(children.get(0).getDataType().getSqlType() - PDataType.ARRAY_TYPE_BASE), arrayKVExpression.getMaxLength()); boolean elementAvailable = false; for (int i = 0; i < length; i++) { Expression comparisonExpr = children.get(1); Expression arrayElemRef = ((ComparisonExpression)comparisonExpr).getChildren().get(1); ((ArrayElemRefExpression)arrayElemRef).setIndex(i + 1); comparisonExpr.evaluate(tuple, ptr); if (expectedReturnResult(resultFound(ptr))) { return result(); } elementAvailable = true; } if (!elementAvailable) { return false; } return true; } protected boolean resultFound(ImmutableBytesWritable ptr) {
@Override public Expression visitLeave(ComparisonExpression node, List<Expression> l) { return isCloneNode(node, l) ? node.clone(l) : node; }
int i = 0; for (; i < Math.min(lhs.getChildren().size(),rhs.getChildren().size()); i++) { addEqualityExpression(lhs.getChildren().get(i), rhs.getChildren().get(i), andNodes, ptr, rowKeyOrderOptimizable); addEqualityExpression(lhs.getChildren().get(i), LiteralExpression.newConstant(null, lhs.getChildren().get(i).getDataType()), andNodes, ptr, rowKeyOrderOptimizable); addEqualityExpression(LiteralExpression.newConstant(null, rhs.getChildren().get(i).getDataType()), rhs.getChildren().get(i), andNodes, ptr, rowKeyOrderOptimizable); addEqualityExpression(lhs.getChildren().get(0), rhs, andNodes, ptr, rowKeyOrderOptimizable); for (int i = 1; i < lhs.getChildren().size(); i++) { addEqualityExpression(lhs.getChildren().get(i), LiteralExpression.newConstant(null, lhs.getChildren().get(i).getDataType()), andNodes, ptr, rowKeyOrderOptimizable); addEqualityExpression(lhs, rhs.getChildren().get(0), andNodes, ptr, rowKeyOrderOptimizable); for (int i = 1; i < rhs.getChildren().size(); i++) { addEqualityExpression(LiteralExpression.newConstant(null, rhs.getChildren().get(i).getDataType()), rhs.getChildren().get(i), andNodes, ptr, rowKeyOrderOptimizable);
@Override public KeySlots visitLeave(ComparisonExpression node, List<KeySlots> childParts) { // Delay adding to extractedNodes, until we're done traversing, // since we can't yet tell whether or not the PK column references // are contiguous if (childParts.isEmpty()) { return null; } Expression rhs = node.getChildren().get(1); KeySlots childSlots = childParts.get(0); KeySlot childSlot = childSlots.getSlots().get(0); KeyPart childPart = childSlot.getKeyPart(); //SortOrder sortOrder = childPart.getColumn().getSortOrder(); CompareOp op = node.getFilterOp(); //CompareOp op = sortOrder.transform(node.getFilterOp()); KeyRange keyRange = childPart.getKeyRange(op, rhs); return newKeyParts(childSlot, node, keyRange); }
if (op == CompareOp.EQUAL || op == CompareOp.NOT_EQUAL) { List<Expression> andNodes = Lists.<Expression>newArrayListWithExpectedSize(Math.max(lhsExpr.getChildren().size(), rhsExpr.getChildren().size())); rewriteRVCAsEqualityExpression(lhsExpr, rhsExpr, andNodes, ptr, rowKeyOrderOptimizable); Expression expr = AndExpression.create(andNodes); if (op == CompareOp.NOT_EQUAL) { } else if(lhsExprDataType != null && rhsExprDataType != null && !lhsExprDataType.isComparableTo(rhsExprDataType)) { throw TypeMismatchException.newException(lhsExprDataType, rhsExprDataType, toString(op, children)); return new ComparisonExpression(children, op);
return ComparisonExpression.create(isNegate ? CompareOp.NOT_EQUAL : CompareOp.EQUAL, children, ptr, rowKeyOrderOptimizable);