org.bytedeco.gandiva

Class TreeExprBuilder

java.lang.Object

org.bytedeco.javacpp.Pointer

org.bytedeco.gandiva.TreeExprBuilder

All Implemented Interfaces:

AutoCloseable

@Namespace(value="gandiva")
 @Properties(inherit=gandiva.class)
public class TreeExprBuilder
extends Pointer

\brief Tree Builder for a nested expression.

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
TreeExprBuilder() Default native constructor.
TreeExprBuilder(long size) Native array allocator.
TreeExprBuilder(Pointer p) Pointer cast constructor.

Method Summary

Modifier and Type	Method and Description
TreeExprBuilder	getPointer(long i)
static Node	MakeAnd(Node children) \brief create a node with a boolean AND expression.
static Node	MakeBinaryLiteral(BytePointer value)
static Node	MakeBinaryLiteral(String value)
static Condition	MakeCondition(BytePointer function, FieldVector in_fields)
static Condition	MakeCondition(Node root_node) \brief create a condition with the specified root_node
static Condition	MakeCondition(String function, FieldVector in_fields) \brief convenience function for simple function conditions.
static Node	MakeDecimalLiteral(DecimalScalar128 value)
static Expression	MakeExpression(BytePointer function, FieldVector in_fields, Field out_field)
static Expression	MakeExpression(Node root_node, Field result_field) \brief create an expression with the specified root_node, and the result written to result_field.
static Expression	MakeExpression(String function, FieldVector in_fields, Field out_field) \brief convenience function for simple function expressions.
static Node	MakeField(Field field) \brief create a node on arrow field.
static Node	MakeFunction(BytePointer name, Node params, DataType return_type)
static Node	MakeFunction(String name, Node params, DataType return_type) \brief create a node with a function.
static Node	MakeIf(Node condition, Node then_node, Node else_node, DataType result_type) \brief create a node with an if-else expression.
static Node	MakeInExpressionBinary(Node node, StringSet constants)
static Node	MakeInExpressionDate32(Node node, IntSet constants) \brief Date as s/millis since epoch.
static Node	MakeInExpressionDate64(Node node, LongSet constants) \brief Date as millis/us/ns since epoch.
static Node	MakeInExpressionDecimal(Node node, DecimalScalar128Set constants)
static Node	MakeInExpressionDouble(Node node, DoubleSet constants) \brief creates an in expression for double
static Node	MakeInExpressionFloat(Node node, FloatSet constants) \brief creates an in expression for float
static Node	MakeInExpressionInt32(Node node, IntSet constants) \brief creates an in expression
static Node	MakeInExpressionInt64(Node node, LongSet constants)
static Node	MakeInExpressionString(Node node, StringSet constants)
static Node	MakeInExpressionTime32(Node node, IntSet constants) \brief Time as s/millis of day
static Node	MakeInExpressionTime64(Node node, LongSet constants) \brief Time as millis/us/ns of day
static Node	MakeInExpressionTimeStamp(Node node, LongSet constants) \brief Timestamp as millis since epoch.
static Node	MakeLiteral(boolean value) \brief create a node on a literal.
static Node	MakeLiteral(byte value)
static Node	MakeLiteral(double value)
static Node	MakeLiteral(float value)
static Node	MakeLiteral(int value)
static Node	MakeLiteral(long value)
static Node	MakeLiteral(short value)
static Node	MakeNull(DataType data_type) \brief create a node on a null literal.
static Node	MakeOr(Node children) \brief create a node with a boolean OR expression.
static Node	MakeStringLiteral(BytePointer value)
static Node	MakeStringLiteral(String value)
TreeExprBuilder	position(long position)

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, getDirectBufferAddress, getPointer, getPointer, getPointer, hashCode, interruptDeallocatorThread, isNull, isNull, limit, limit, malloc, maxBytes, maxPhysicalBytes, memchr, memcmp, memcpy, memmove, memset, offsetAddress, offsetof, offsetof, parseBytes, physicalBytes, physicalBytesInaccurate, 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

TreeExprBuilder

public TreeExprBuilder()

Default native constructor.

TreeExprBuilder

public TreeExprBuilder(long size)

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

TreeExprBuilder

public TreeExprBuilder(Pointer p)

Pointer cast constructor. Invokes Pointer(Pointer).

Method Detail

position

public TreeExprBuilder position(long position)

Overrides:

position in class Pointer

getPointer

public TreeExprBuilder getPointer(long i)

Overrides:

getPointer in class Pointer

MakeLiteral

@SharedPtr
public static Node MakeLiteral(@Cast(value="bool")
                                           boolean value)

\brief create a node on a literal.

MakeLiteral

@SharedPtr
public static Node MakeLiteral(@Cast(value="uint8_t")
                                           byte value)

MakeLiteral

@SharedPtr
public static Node MakeLiteral(@Cast(value="uint16_t")
                                           short value)

MakeLiteral

@SharedPtr
public static Node MakeLiteral(@Cast(value="uint32_t")
                                           int value)

MakeLiteral

@SharedPtr
public static Node MakeLiteral(@Cast(value="uint64_t")
                                           long value)

MakeLiteral

@SharedPtr
public static Node MakeLiteral(float value)

MakeLiteral

@SharedPtr
public static Node MakeLiteral(double value)

MakeStringLiteral

@SharedPtr
public static Node MakeStringLiteral(@StdString
                                                 String value)

MakeStringLiteral

@SharedPtr
public static Node MakeStringLiteral(@StdString
                                                 BytePointer value)

MakeBinaryLiteral

@SharedPtr
public static Node MakeBinaryLiteral(@StdString
                                                 String value)

MakeBinaryLiteral

@SharedPtr
public static Node MakeBinaryLiteral(@StdString
                                                 BytePointer value)

MakeDecimalLiteral

@SharedPtr
public static Node MakeDecimalLiteral(@Const @ByRef
                                                  DecimalScalar128 value)

MakeNull

@SharedPtr
public static Node MakeNull(@SharedPtr @Cast(value={"","std::shared_ptr<arrow::DataType>"})
                                        DataType data_type)

\brief create a node on a null literal. returns null if data_type is null or if it's not a supported datatype.

MakeField

@SharedPtr
public static Node MakeField(@SharedPtr @Cast(value={"","std::shared_ptr<arrow::Field>"})
                                         Field field)

\brief create a node on arrow field. returns null if input is null.

MakeFunction

@SharedPtr
public static Node MakeFunction(@StdString
                                            String name,
                                            @SharedPtr
                                            Node params,
                                            @SharedPtr @Cast(value={"","std::shared_ptr<arrow::DataType>"})
                                            DataType return_type)

\brief create a node with a function. returns null if return_type is null

MakeFunction

@SharedPtr
public static Node MakeFunction(@StdString
                                            BytePointer name,
                                            @SharedPtr
                                            Node params,
                                            @SharedPtr @Cast(value={"","std::shared_ptr<arrow::DataType>"})
                                            DataType return_type)

MakeIf

@SharedPtr
public static Node MakeIf(@SharedPtr
                                      Node condition,
                                      @SharedPtr
                                      Node then_node,
                                      @SharedPtr
                                      Node else_node,
                                      @SharedPtr @Cast(value={"","std::shared_ptr<arrow::DataType>"})
                                      DataType result_type)

\brief create a node with an if-else expression. returns null if any of the inputs is null.

MakeAnd

@SharedPtr
public static Node MakeAnd(@SharedPtr
                                       Node children)

\brief create a node with a boolean AND expression.

MakeOr

@SharedPtr
public static Node MakeOr(@SharedPtr
                                      Node children)

\brief create a node with a boolean OR expression.

MakeExpression

@SharedPtr
public static Expression MakeExpression(@SharedPtr
                                                    Node root_node,
                                                    @SharedPtr @Cast(value={"","std::shared_ptr<arrow::Field>"})
                                                    Field result_field)

\brief create an expression with the specified root_node, and the result written to result_field. returns null if the result_field is null.

MakeExpression

@SharedPtr
public static Expression MakeExpression(@StdString
                                                    String function,
                                                    @Const @ByRef
                                                    FieldVector in_fields,
                                                    @SharedPtr @Cast(value={"","std::shared_ptr<arrow::Field>"})
                                                    Field out_field)

\brief convenience function for simple function expressions. returns null if the out_field is null.

MakeExpression

@SharedPtr
public static Expression MakeExpression(@StdString
                                                    BytePointer function,
                                                    @Const @ByRef
                                                    FieldVector in_fields,
                                                    @SharedPtr @Cast(value={"","std::shared_ptr<arrow::Field>"})
                                                    Field out_field)

MakeCondition

@SharedPtr
public static Condition MakeCondition(@SharedPtr
                                                  Node root_node)

\brief create a condition with the specified root_node

MakeCondition

@SharedPtr
public static Condition MakeCondition(@StdString
                                                  String function,
                                                  @Const @ByRef
                                                  FieldVector in_fields)

\brief convenience function for simple function conditions.

MakeCondition

@SharedPtr
public static Condition MakeCondition(@StdString
                                                  BytePointer function,
                                                  @Const @ByRef
                                                  FieldVector in_fields)

MakeInExpressionInt32

@SharedPtr
public static Node MakeInExpressionInt32(@SharedPtr
                                                     Node node,
                                                     @Const @ByRef
                                                     IntSet constants)

\brief creates an in expression

MakeInExpressionInt64

@SharedPtr
public static Node MakeInExpressionInt64(@SharedPtr
                                                     Node node,
                                                     @Const @ByRef
                                                     LongSet constants)

MakeInExpressionDecimal

@SharedPtr
public static Node MakeInExpressionDecimal(@SharedPtr
                                                       Node node,
                                                       @ByRef
                                                       DecimalScalar128Set constants)

MakeInExpressionString

@SharedPtr
public static Node MakeInExpressionString(@SharedPtr
                                                      Node node,
                                                      @Const @ByRef
                                                      StringSet constants)

MakeInExpressionBinary

@SharedPtr
public static Node MakeInExpressionBinary(@SharedPtr
                                                      Node node,
                                                      @Const @ByRef
                                                      StringSet constants)

MakeInExpressionFloat

@SharedPtr
public static Node MakeInExpressionFloat(@SharedPtr
                                                     Node node,
                                                     @Const @ByRef
                                                     FloatSet constants)

\brief creates an in expression for float

MakeInExpressionDouble

@SharedPtr
public static Node MakeInExpressionDouble(@SharedPtr
                                                      Node node,
                                                      @Const @ByRef
                                                      DoubleSet constants)

\brief creates an in expression for double

MakeInExpressionDate32

@SharedPtr
public static Node MakeInExpressionDate32(@SharedPtr
                                                      Node node,
                                                      @Const @ByRef
                                                      IntSet constants)

\brief Date as s/millis since epoch.

MakeInExpressionDate64

@SharedPtr
public static Node MakeInExpressionDate64(@SharedPtr
                                                      Node node,
                                                      @Const @ByRef
                                                      LongSet constants)

\brief Date as millis/us/ns since epoch.

MakeInExpressionTime32

@SharedPtr
public static Node MakeInExpressionTime32(@SharedPtr
                                                      Node node,
                                                      @Const @ByRef
                                                      IntSet constants)

\brief Time as s/millis of day

MakeInExpressionTime64

@SharedPtr
public static Node MakeInExpressionTime64(@SharedPtr
                                                      Node node,
                                                      @Const @ByRef
                                                      LongSet constants)

\brief Time as millis/us/ns of day

MakeInExpressionTimeStamp

@SharedPtr
public static Node MakeInExpressionTimeStamp(@SharedPtr
                                                         Node node,
                                                         @Const @ByRef
                                                         LongSet constants)

\brief Timestamp as millis since epoch.