org.bytedeco.arrow_dataset

Class ComparisonExpression

java.lang.Object

org.bytedeco.javacpp.Pointer

org.bytedeco.arrow_dataset.Expression

org.bytedeco.arrow_dataset.BinaryExpression

org.bytedeco.arrow_dataset.ComparisonExpressionImpl

org.bytedeco.arrow_dataset.ComparisonExpression

All Implemented Interfaces:

AutoCloseable

@Namespace(value="arrow::dataset")
 @NoOffset
 @Properties(inherit=arrow_dataset.class)
public class ComparisonExpression
extends ComparisonExpressionImpl

Nested Class Summary

Nested classes/interfaces inherited from class org.bytedeco.javacpp.Pointer

Pointer.CustomDeallocator, Pointer.Deallocator, Pointer.NativeDeallocator, Pointer.ReferenceCounter

Field Summary

Fields inherited from class org.bytedeco.javacpp.Pointer

address, capacity, limit, position

Constructor Summary

Constructors

Constructor and Description
ComparisonExpression(arrow.CompareOperator op, Expression left_operand, Expression right_operand)
ComparisonExpression(byte op, Expression left_operand, Expression right_operand)
ComparisonExpression(Pointer p) Pointer cast constructor.

Method Summary

Modifier and Type	Method and Description
Expression	Assume(Expression given) \brief Simplify to an equivalent Expression given assumed constraints on input.
boolean	Equals(Expression other) Returns true iff the expressions are identical; does not check for equivalence.
arrow.CompareOperator	op()
String	ToString() returns a debug string representing this expression
DataTypeResult	Validate(Schema schema) Validate this expression for execution against a schema.

Methods inherited from class org.bytedeco.arrow_dataset.ComparisonExpressionImpl

Copy, expression_type, getPointer, position

Methods inherited from class org.bytedeco.arrow_dataset.BinaryExpression

left_operand, right_operand

Methods inherited from class org.bytedeco.arrow_dataset.Expression

CastLike, CastLike, CastTo, CastTo, Deserialize, In, IsNull, IsSatisfiable, IsSatisfiableWith, IsValid, Serialize, type

Methods inherited from class org.bytedeco.javacpp.Pointer

address, asBuffer, asByteBuffer, availablePhysicalBytes, calloc, capacity, capacity, close, deallocate, deallocate, deallocateReferences, deallocator, deallocator, equals, fill, formatBytes, free, getPointer, getPointer, getPointer, hashCode, isNull, isNull, limit, limit, malloc, maxBytes, maxPhysicalBytes, memchr, memcmp, memcpy, memmove, memset, offsetof, offsetof, parseBytes, physicalBytes, position, put, realloc, referenceCount, releaseReference, retainReference, setNull, sizeof, sizeof, toString, totalBytes, totalCount, totalPhysicalBytes, withDeallocator, zero

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Constructor Detail

ComparisonExpression

public ComparisonExpression(Pointer p)

Pointer cast constructor. Invokes Pointer.Pointer(Pointer).

ComparisonExpression

public ComparisonExpression(arrow.CompareOperator op,
                            @SharedPtr @ByVal
                            Expression left_operand,
                            @SharedPtr @ByVal
                            Expression right_operand)

ComparisonExpression

public ComparisonExpression(@Cast(value="arrow::compute::CompareOperator")
                            byte op,
                            @SharedPtr @ByVal
                            Expression left_operand,
                            @SharedPtr @ByVal
                            Expression right_operand)

Method Detail

ToString

@StdString
public String ToString()

Description copied from class: Expression

returns a debug string representing this expression

Overrides:

ToString in class Expression

Equals

@Cast(value="bool")
public boolean Equals(@Const @ByRef
                                           Expression other)

Description copied from class: Expression

Returns true iff the expressions are identical; does not check for equivalence. For example, (A and B) is not equal to (B and A) nor is (A and not A) equal to (false).

Overrides:

Equals in class BinaryExpression

Assume

@SharedPtr
 @ByVal
public Expression Assume(@Const @ByRef
                                              Expression given)

Description copied from class: Expression

\brief Simplify to an equivalent Expression given assumed constraints on input. This can be used to do less filtering work using predicate push down. Both expressions must pass validation against a schema before Assume may be used. Two expressions can be considered equivalent for a given subset of possible inputs if they yield identical results. Formally, if given.Evaluate(input).Equals(input) then Assume guarantees that: expr.Assume(given).Evaluate(input).Equals(expr.Evaluate(input)) For example if we are given that all inputs will satisfy ("a"_ == 1) then the expression ("a"_ > 0 and "b"_ > 0) is equivalent to ("b"_ > 0). It is impossible that the comparison ("a"_ > 0) will evaluate false given ("a"_ == 1), so both expressions will yield identical results. Thus we can write: ("a"_ > 0 and "b"_ > 0).Assume("a"_ == 1).Equals("b"_ > 0) filter.Assume(partition) is trivial if filter and partition are disjoint or if partition is a subset of filter. FIXME(bkietz) write this better - If the two are disjoint, then (false) may be substituted for filter. - If partition is a subset of filter then (true) may be substituted for filter. filter.Assume(partition) is straightforward if both filter and partition are simple comparisons. - filter may be a superset of partition, in which case the filter is satisfied by all inputs: ("a"_ > 0).Assume("a"_ == 1).Equals(true) - filter may be disjoint with partition, in which case there are no inputs which satisfy filter: ("a"_ < 0).Assume("a"_ == 1).Equals(false) - If neither of these is the case, partition provides no information which can simplify filter: ("a"_ == 1).Assume("a"_ > 0).Equals("a"_ == 1) ("a"_ == 1).Assume("b"_ == 1).Equals("a"_ == 1) If filter is compound, Assume can be distributed across the boolean operator. To prove this is valid, we again demonstrate that the simplified expression will yield identical results. For conjunction of filters lhs and rhs: (lhs.Assume(p) and rhs.Assume(p)).Evaluate(input) == Intersection(lhs.Assume(p).Evaluate(input), rhs.Assume(p).Evaluate(input)) == Intersection(lhs.Evaluate(input), rhs.Evaluate(input)) == (lhs and rhs).Evaluate(input) - The proof for disjunction is symmetric; just replace Intersection with Union. Thus we can write: (lhs and rhs).Assume(p).Equals(lhs.Assume(p) and rhs.Assume(p)) (lhs or rhs).Assume(p).Equals(lhs.Assume(p) or rhs.Assume(p)) - For negation: (not e.Assume(p)).Evaluate(input) == Difference(input, e.Assume(p).Evaluate(input)) == Difference(input, e.Evaluate(input)) == (not e).Evaluate(input) - Thus we can write: (not e).Assume(p).Equals(not e.Assume(p)) If the partition expression is a conjunction then each of its subexpressions is true for all input and can be used independently: filter.Assume(lhs).Assume(rhs).Evaluate(input) == filter.Assume(lhs).Evaluate(input) == filter.Evaluate(input) - Thus we can write: filter.Assume(lhs and rhs).Equals(filter.Assume(lhs).Assume(rhs)) FIXME(bkietz) disjunction proof filter.Assume(lhs or rhs).Equals(filter.Assume(lhs) and filter.Assume(rhs)) - This may not result in a simpler expression so it is only used when filter.Assume(lhs).Equals(filter.Assume(rhs)) If the partition expression is a negation then we can use the above relations by replacing comparisons with their complements and using the properties: (not (a and b)).Equals(not a or not b) (not (a or b)).Equals(not a and not b)

Overrides:

Assume in class Expression

op

public arrow.CompareOperator op()

Validate

@ByVal
public DataTypeResult Validate(@Const @ByRef
                                       Schema schema)

Description copied from class: Expression

Validate this expression for execution against a schema. This will check that all reference fields are present (fields not in the schema will be replaced with null) and all subexpressions are executable. Returns the type to which this expression will evaluate.

Overrides:

Validate in class Expression