org.bytedeco.arrow_dataset

Class AndExpression

java.lang.Object

org.bytedeco.javacpp.Pointer

org.bytedeco.arrow_dataset.Expression

org.bytedeco.arrow_dataset.BinaryExpression

org.bytedeco.arrow_dataset.AndExpressionImpl

org.bytedeco.arrow_dataset.AndExpression

All Implemented Interfaces:

AutoCloseable

@Namespace(value="arrow::dataset")
 @Properties(inherit=arrow_dataset.class)
public class AndExpression
extends AndExpressionImpl

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
AndExpression() Default native constructor.
AndExpression(long size) Native array allocator.
AndExpression(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.
AndExpression	position(long position)
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.AndExpressionImpl

Copy, expression_type

Methods inherited from class org.bytedeco.arrow_dataset.BinaryExpression

Equals, left_operand, right_operand

Methods inherited from class org.bytedeco.arrow_dataset.Expression

CastLike, CastLike, CastTo, CastTo, In, IsNull, IsValid, 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, hashCode, isNull, isNull, limit, limit, malloc, maxBytes, maxPhysicalBytes, memchr, memcmp, memcpy, memmove, memset, offsetof, parseBytes, physicalBytes, position, put, realloc, referenceCount, releaseReference, retainReference, setNull, sizeof, toString, totalBytes, totalPhysicalBytes, withDeallocator, zero

Methods inherited from class java.lang.Object

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

Constructor Detail

AndExpression

public AndExpression()

Default native constructor.

AndExpression

public AndExpression(long size)

Native array allocator. Access with Pointer.position(long).

AndExpression

public AndExpression(Pointer p)

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

Method Detail

position

public AndExpression position(long position)

Overrides:

position in class AndExpressionImpl

ToString

@StdString
public String ToString()

Description copied from class: Expression

returns a debug string representing this expression

Overrides:

ToString in class Expression

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

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