org.bytedeco.arrow_dataset

Class CastExpression

java.lang.Object

org.bytedeco.javacpp.Pointer

org.bytedeco.arrow_dataset.Expression

org.bytedeco.arrow_dataset.UnaryExpression

org.bytedeco.arrow_dataset.CastExpressionImpl

org.bytedeco.arrow_dataset.CastExpression

All Implemented Interfaces:

AutoCloseable

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

Explicitly cast an expression to a different type

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
CastExpression(Expression operand, DataType to, CastOptions options)
CastExpression(Expression operand, Expression like, CastOptions options) The operand will be cast to whatever type like would evaluate to, given the same schema.
CastExpression(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.
CastOptions	options()
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.CastExpressionImpl

Copy, expression_type, position

Methods inherited from class org.bytedeco.arrow_dataset.UnaryExpression

Equals, 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

CastExpression

public CastExpression(Pointer p)

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

CastExpression

public CastExpression(@SharedPtr @ByVal
                      Expression operand,
                      @SharedPtr @Cast(value={"","std::shared_ptr<arrow::DataType>"})
                      DataType to,
                      @ByVal
                      CastOptions options)

CastExpression

public CastExpression(@SharedPtr @ByVal
                      Expression operand,
                      @SharedPtr @ByVal
                      Expression like,
                      @ByVal
                      CastOptions options)

The operand will be cast to whatever type like would evaluate to, given the same schema.

Method Detail

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

options

@Const
 @ByRef
public CastOptions options()