org.bytedeco.arrow.global

Class arrow_dataset

java.lang.Object

org.bytedeco.arrow.presets.arrow_dataset

org.bytedeco.arrow.global.arrow_dataset

All Implemented Interfaces:

InfoMapper

public class arrow_dataset
extends arrow_dataset

Constructor Summary

Constructors

Constructor and Description
arrow_dataset()

Method Summary

Modifier and Type	Method and Description
static AndExpression	and_(Expression lhs, Expression rhs)
static Expression	and_(ExpressionVector subexpressions)
static AndExpression	and(Expression lhs, Expression rhs)
static void	DieWithMessage(BytePointer msg)
static void	DieWithMessage(String msg)
static ComparisonExpression	equal(Expression lhs, Expression rhs)
static ComparisonExpression	equals(Expression lhs, Expression rhs)
static FieldExpression	field_ref(BytePointer name)
static FieldExpression	field_ref(String name)
static StringVector	FieldsInExpression(Expression expr) \brief Returns field names referenced in the expression.
static ThreadPool	GetCpuThreadPool()
static int	GetCpuThreadPoolCapacity() \brief Get the capacity of the global thread pool Return the number of worker threads in the thread pool to which Arrow dispatches various CPU-bound tasks.
static ComparisonExpression	greater_equal(Expression lhs, Expression rhs)
static ComparisonExpression	greater(Expression lhs, Expression rhs)
static ComparisonExpression	greaterThan(Expression lhs, Expression rhs)
static ComparisonExpression	greaterThanEquals(Expression lhs, Expression rhs)
static ExpressionResult	InsertImplicitCasts(Expression expr, Schema schema) \brief Insert CastExpressions where necessary to make a valid expression.
static ComparisonExpression	less_equal(Expression lhs, Expression rhs)
static ComparisonExpression	less(Expression lhs, Expression rhs)
static ComparisonExpression	lessThan(Expression lhs, Expression rhs)
static ComparisonExpression	lessThanEquals(Expression lhs, Expression rhs)
static NotExpression	not_(Expression operand)
static ComparisonExpression	not_equal(Expression lhs, Expression rhs)
static NotExpression	not(Expression rhs)
static ComparisonExpression	notEquals(Expression lhs, Expression rhs)
static OrExpression	or_(Expression lhs, Expression rhs)
static Expression	or_(ExpressionVector subexpressions)
static OrExpression	or(Expression lhs, Expression rhs)
static ScalarExpression	scalar(Scalar value)
static ScanTaskIteratorResult	ScanTaskIteratorFromRecordBatch(RecordBatchVector batches, ScanOptions options, ScanContext arg2) Logic for automatically determining the structure of multi-file dataset with possible partitioning according to available partitioning
static Status	SetCpuThreadPoolCapacity(int threads) \brief Set the capacity of the global thread pool Set the number of worker threads int the thread pool to which Arrow dispatches various CPU-bound tasks.

Methods inherited from class org.bytedeco.arrow.presets.arrow_dataset

map

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

arrow_dataset

public arrow_dataset()

Method Detail

GetCpuThreadPoolCapacity

@Namespace(value="arrow")
public static int GetCpuThreadPoolCapacity()

\brief Get the capacity of the global thread pool Return the number of worker threads in the thread pool to which Arrow dispatches various CPU-bound tasks. This is an ideal number, not necessarily the exact number of threads at a given point in time. You can change this number using SetCpuThreadPoolCapacity().

SetCpuThreadPoolCapacity

@Namespace(value="arrow")
 @ByVal
public static Status SetCpuThreadPoolCapacity(int threads)

\brief Set the capacity of the global thread pool Set the number of worker threads int the thread pool to which Arrow dispatches various CPU-bound tasks. The current number is returned by GetCpuThreadPoolCapacity().

GetCpuThreadPool

@Namespace(value="arrow::internal")
public static ThreadPool GetCpuThreadPool()

DieWithMessage

@Namespace(value="arrow::internal")
public static void DieWithMessage(@StdString
                                                                      String msg)

DieWithMessage

@Namespace(value="arrow::internal")
public static void DieWithMessage(@StdString
                                                                      BytePointer msg)

ScanTaskIteratorFromRecordBatch

@Namespace(value="arrow::dataset")
 @ByVal
public static ScanTaskIteratorResult ScanTaskIteratorFromRecordBatch(@ByVal
                                                                                                                RecordBatchVector batches,
                                                                                                                @SharedPtr
                                                                                                                ScanOptions options,
                                                                                                                @SharedPtr
                                                                                                                ScanContext arg2)

Logic for automatically determining the structure of multi-file dataset with possible partitioning according to available partitioning

and_

@Namespace(value="arrow::dataset")
 @SharedPtr
public static AndExpression and_(@SharedPtr @ByVal
                                                                                Expression lhs,
                                                                                @SharedPtr @ByVal
                                                                                Expression rhs)

and_

@Namespace(value="arrow::dataset")
 @SharedPtr
 @ByVal
public static Expression and_(@Const @ByRef
                                                                                     ExpressionVector subexpressions)

and

@Namespace(value="arrow::dataset")
 @ByVal
 @Name(value="operator &&")
public static AndExpression and(@Const @ByRef
                                                                                                       Expression lhs,
                                                                                                       @Const @ByRef
                                                                                                       Expression rhs)

or_

@Namespace(value="arrow::dataset")
 @SharedPtr
public static OrExpression or_(@SharedPtr @ByVal
                                                                              Expression lhs,
                                                                              @SharedPtr @ByVal
                                                                              Expression rhs)

or_

@Namespace(value="arrow::dataset")
 @SharedPtr
 @ByVal
public static Expression or_(@Const @ByRef
                                                                                    ExpressionVector subexpressions)

or

@Namespace(value="arrow::dataset")
 @ByVal
 @Name(value="operator ||")
public static OrExpression or(@Const @ByRef
                                                                                                     Expression lhs,
                                                                                                     @Const @ByRef
                                                                                                     Expression rhs)

not_

@Namespace(value="arrow::dataset")
 @SharedPtr
public static NotExpression not_(@SharedPtr @ByVal
                                                                                Expression operand)

not

@Namespace(value="arrow::dataset")
 @ByVal
 @Name(value="operator !")
public static NotExpression not(@Const @ByRef
                                                                                                      Expression rhs)

scalar

@Namespace(value="arrow::dataset")
 @SharedPtr
public static ScalarExpression scalar(@SharedPtr @Cast(value={"","std::shared_ptr<arrow::Scalar>"})
                                                                                     Scalar value)

equal

@Namespace(value="arrow::dataset")
 @SharedPtr
public static ComparisonExpression equal(@Const @SharedPtr @ByRef
                                                                                        Expression lhs,
                                                                                        @Const @SharedPtr @ByRef
                                                                                        Expression rhs)

equals

@Namespace(value="arrow::dataset")
 @ByVal
 @Name(value="operator ==")
public static ComparisonExpression equals(@Const @ByRef
                                                                                                                 Expression lhs,
                                                                                                                 @Const @ByRef
                                                                                                                 Expression rhs)

not_equal

@Namespace(value="arrow::dataset")
 @SharedPtr
public static ComparisonExpression not_equal(@Const @SharedPtr @ByRef
                                                                                            Expression lhs,
                                                                                            @Const @SharedPtr @ByRef
                                                                                            Expression rhs)

notEquals

@Namespace(value="arrow::dataset")
 @ByVal
 @Name(value="operator !=")
public static ComparisonExpression notEquals(@Const @ByRef
                                                                                                                    Expression lhs,
                                                                                                                    @Const @ByRef
                                                                                                                    Expression rhs)

greater

@Namespace(value="arrow::dataset")
 @SharedPtr
public static ComparisonExpression greater(@Const @SharedPtr @ByRef
                                                                                          Expression lhs,
                                                                                          @Const @SharedPtr @ByRef
                                                                                          Expression rhs)

greaterThan

@Namespace(value="arrow::dataset")
 @ByVal
 @Name(value="operator >")
public static ComparisonExpression greaterThan(@Const @ByRef
                                                                                                                     Expression lhs,
                                                                                                                     @Const @ByRef
                                                                                                                     Expression rhs)

greater_equal

@Namespace(value="arrow::dataset")
 @SharedPtr
public static ComparisonExpression greater_equal(@Const @SharedPtr @ByRef
                                                                                                Expression lhs,
                                                                                                @Const @SharedPtr @ByRef
                                                                                                Expression rhs)

greaterThanEquals

@Namespace(value="arrow::dataset")
 @ByVal
 @Name(value="operator >=")
public static ComparisonExpression greaterThanEquals(@Const @ByRef
                                                                                                                            Expression lhs,
                                                                                                                            @Const @ByRef
                                                                                                                            Expression rhs)

less

@Namespace(value="arrow::dataset")
 @SharedPtr
public static ComparisonExpression less(@Const @SharedPtr @ByRef
                                                                                       Expression lhs,
                                                                                       @Const @SharedPtr @ByRef
                                                                                       Expression rhs)

lessThan

@Namespace(value="arrow::dataset")
 @ByVal
 @Name(value="operator <")
public static ComparisonExpression lessThan(@Const @ByRef
                                                                                                                  Expression lhs,
                                                                                                                  @Const @ByRef
                                                                                                                  Expression rhs)

less_equal

@Namespace(value="arrow::dataset")
 @SharedPtr
public static ComparisonExpression less_equal(@Const @SharedPtr @ByRef
                                                                                             Expression lhs,
                                                                                             @Const @SharedPtr @ByRef
                                                                                             Expression rhs)

lessThanEquals

@Namespace(value="arrow::dataset")
 @ByVal
 @Name(value="operator <=")
public static ComparisonExpression lessThanEquals(@Const @ByRef
                                                                                                                         Expression lhs,
                                                                                                                         @Const @ByRef
                                                                                                                         Expression rhs)

field_ref

@Namespace(value="arrow::dataset")
 @SharedPtr
public static FieldExpression field_ref(@StdString
                                                                                       String name)

field_ref

@Namespace(value="arrow::dataset")
 @SharedPtr
public static FieldExpression field_ref(@StdString
                                                                                       BytePointer name)

InsertImplicitCasts

@Namespace(value="arrow::dataset")
 @ByVal
public static ExpressionResult InsertImplicitCasts(@Const @ByRef
                                                                                              Expression expr,
                                                                                              @Const @ByRef
                                                                                              Schema schema)

\brief Insert CastExpressions where necessary to make a valid expression.

FieldsInExpression

@Namespace(value="arrow::dataset")
 @ByVal
public static StringVector FieldsInExpression(@Const @ByRef
                                                                                         Expression expr)

\brief Returns field names referenced in the expression.