org.bytedeco.arrow

Class Table

java.lang.Object

org.bytedeco.javacpp.Pointer

org.bytedeco.arrow.Table

All Implemented Interfaces:

AutoCloseable

@Namespace(value="arrow")
 @NoOffset
 @Properties(inherit=arrow.class)
public class Table
extends Pointer

\class Table \brief Logical table as sequence of chunked arrays

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
Table(Pointer p) Pointer cast constructor.

Method Summary

Modifier and Type	Method and Description
TableResult	AddColumn(int i, Field field_arg, ChunkedArray column) \brief Add column to the table, producing a new Table
ChunkedArray	column(int i) \brief Return a column by index
StringVector	ColumnNames() \brief Return names of all columns
ChunkedArrayVector	columns() \brief Return vector of all columns for table
TableResult	CombineChunks()
TableResult	CombineChunks(MemoryPool pool) \brief Make a new table by combining the chunks this table has.
boolean	Equals(Table other)
boolean	Equals(Table other, boolean check_metadata) \brief Determine if tables are equal Two tables can be equal only if they have equal schemas.
Field	field(int i) Return a column's field by index
FieldVector	fields() \brief Return vector of all fields for table
TableResult	Flatten()
TableResult	Flatten(MemoryPool pool) \brief Flatten the table, producing a new Table.
static TableResult	FromChunkedStructArray(ChunkedArray array) \brief Construct a Table from a chunked StructArray.
static TableResult	FromRecordBatches(RecordBatchVector batches) \brief Construct a Table from RecordBatches, using schema supplied by the first RecordBatch.
static TableResult	FromRecordBatches(Schema schema, RecordBatchVector batches) \brief Construct a Table from RecordBatches, using supplied schema.
static TableResult	FromRecordBatchReader(RecordBatchReader reader) \brief Construct a Table from a RecordBatchReader.
ChunkedArray	GetColumnByName(BytePointer name)
ChunkedArray	GetColumnByName(String name) \brief Return a column by name
static Table	Make(Schema schema, ArrayVector arrays)
static Table	Make(Schema schema, ArrayVector arrays, long num_rows) \brief Construct a Table from schema and arrays
static Table	Make(Schema schema, ChunkedArrayVector columns)
static Table	Make(Schema schema, ChunkedArrayVector columns, long num_rows) \brief Construct a Table from schema and columns If columns is zero-length, the table's number of rows is zero
int	num_columns() \brief Return the number of columns in the table
long	num_rows() \brief Return the number of rows (equal to each column's logical length)
TableResult	RemoveColumn(int i) \brief Remove column from the table, producing a new Table
TableResult	RenameColumns(StringVector names) \brief Rename columns with provided names
Table	ReplaceSchemaMetadata(KeyValueMetadata metadata) \brief Replace schema key-value metadata with new metadata (EXPERIMENTAL)
Schema	schema() \brief Return the table schema
TableResult	SelectColumns(int[] indices)
TableResult	SelectColumns(IntBuffer indices)
TableResult	SelectColumns(IntPointer indices) \brief Return new table with specified columns
TableResult	SetColumn(int i, Field field_arg, ChunkedArray column) \brief Replace a column in the table, producing a new Table
Table	Slice(long offset) \brief Slice from first row at offset until end of the table
Table	Slice(long offset, long length) \brief Construct a zero-copy slice of the table with the indicated offset and length
String	ToString()
Status	Validate() \brief Perform cheap validation checks to determine obvious inconsistencies within the table's schema and internal data.
Status	ValidateFull() \brief Perform extensive validation checks to determine inconsistencies within the table's schema and internal data.

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

Table

public Table(Pointer p)

Pointer cast constructor. Invokes Pointer(Pointer).

Method Detail

Make

@SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::Table>"})
public static Table Make(@SharedPtr @ByVal
                                                                                       Schema schema,
                                                                                       @ByVal
                                                                                       ChunkedArrayVector columns,
                                                                                       @Cast(value="int64_t")
                                                                                       long num_rows)

\brief Construct a Table from schema and columns If columns is zero-length, the table's number of rows is zero

Parameters:

schema - [in] The table schema (column types)

columns - [in] The table's columns as chunked arrays

num_rows - [in] number of rows in table, -1 (default) to infer from columns

Make

@SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::Table>"})
public static Table Make(@SharedPtr @ByVal
                                                                                       Schema schema,
                                                                                       @ByVal
                                                                                       ChunkedArrayVector columns)

Make

@SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::Table>"})
public static Table Make(@SharedPtr @ByVal
                                                                                       Schema schema,
                                                                                       @Const @ByRef
                                                                                       ArrayVector arrays,
                                                                                       @Cast(value="int64_t")
                                                                                       long num_rows)

\brief Construct a Table from schema and arrays

Parameters:

schema - [in] The table schema (column types)

arrays - [in] The table's columns as arrays

num_rows - [in] number of rows in table, -1 (default) to infer from columns

Make

@SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::Table>"})
public static Table Make(@SharedPtr @ByVal
                                                                                       Schema schema,
                                                                                       @Const @ByRef
                                                                                       ArrayVector arrays)

FromRecordBatchReader

@ByVal
public static TableResult FromRecordBatchReader(RecordBatchReader reader)

\brief Construct a Table from a RecordBatchReader.

Parameters:

reader - [in] the arrow::Schema for each batch

FromRecordBatches

@ByVal
public static TableResult FromRecordBatches(@Const @ByRef
                                                   RecordBatchVector batches)

\brief Construct a Table from RecordBatches, using schema supplied by the first RecordBatch.

Parameters:

batches - [in] a std::vector of record batches

FromRecordBatches

@ByVal
public static TableResult FromRecordBatches(@SharedPtr @ByVal
                                                   Schema schema,
                                                   @Const @ByRef
                                                   RecordBatchVector batches)

\brief Construct a Table from RecordBatches, using supplied schema. There may be zero record batches

Parameters:

schema - [in] the arrow::Schema for each batch

batches - [in] a std::vector of record batches

FromChunkedStructArray

@ByVal
public static TableResult FromChunkedStructArray(@SharedPtr @Cast(value={"","std::shared_ptr<arrow::ChunkedArray>"})
                                                        ChunkedArray array)

\brief Construct a Table from a chunked StructArray. One column will be produced for each field of the StructArray.

Parameters:

array - [in] a chunked StructArray

schema

@SharedPtr
 @ByVal
public Schema schema()

\brief Return the table schema

column

@SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::ChunkedArray>"})
public ChunkedArray column(int i)

\brief Return a column by index

columns

@ByVal
public ChunkedArrayVector columns()

\brief Return vector of all columns for table

field

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

Return a column's field by index

fields

@ByVal
public FieldVector fields()

\brief Return vector of all fields for table

Slice

@SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::Table>"})
public Table Slice(@Cast(value="int64_t")
                                                                                 long offset,
                                                                                 @Cast(value="int64_t")
                                                                                 long length)

\brief Construct a zero-copy slice of the table with the indicated offset and length

Parameters:

offset - [in] the index of the first row in the constructed slice

length - [in] the number of rows of the slice. If there are not enough rows in the table, the length will be adjusted accordingly

Returns:

a new object wrapped in std::shared_ptr

Slice

@SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::Table>"})
public Table Slice(@Cast(value="int64_t")
                                                                                 long offset)

\brief Slice from first row at offset until end of the table

GetColumnByName

@SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::ChunkedArray>"})
public ChunkedArray GetColumnByName(@StdString
                                                                                                         String name)

\brief Return a column by name

Parameters:

name - [in] field name

Returns:

an Array or null if no field was found

GetColumnByName

@SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::ChunkedArray>"})
public ChunkedArray GetColumnByName(@StdString
                                                                                                         BytePointer name)

RemoveColumn

@ByVal
public TableResult RemoveColumn(int i)

\brief Remove column from the table, producing a new Table

AddColumn

@ByVal
public TableResult AddColumn(int i,
                                    @SharedPtr @Cast(value={"","std::shared_ptr<arrow::Field>"})
                                    Field field_arg,
                                    @SharedPtr @Cast(value={"","std::shared_ptr<arrow::ChunkedArray>"})
                                    ChunkedArray column)

\brief Add column to the table, producing a new Table

SetColumn

@ByVal
public TableResult SetColumn(int i,
                                    @SharedPtr @Cast(value={"","std::shared_ptr<arrow::Field>"})
                                    Field field_arg,
                                    @SharedPtr @Cast(value={"","std::shared_ptr<arrow::ChunkedArray>"})
                                    ChunkedArray column)

\brief Replace a column in the table, producing a new Table

ColumnNames

@ByVal
public StringVector ColumnNames()

\brief Return names of all columns

RenameColumns

@ByVal
public TableResult RenameColumns(@Const @ByRef
                                        StringVector names)

\brief Rename columns with provided names

SelectColumns

@ByVal
public TableResult SelectColumns(@StdVector
                                        IntPointer indices)

\brief Return new table with specified columns

SelectColumns

@ByVal
public TableResult SelectColumns(@StdVector
                                        IntBuffer indices)

SelectColumns

@ByVal
public TableResult SelectColumns(@StdVector
                                        int[] indices)

ReplaceSchemaMetadata

@SharedPtr
 @Cast(value={"","std::shared_ptr<arrow::Table>"})
public Table ReplaceSchemaMetadata(@SharedPtr @Cast(value={"const arrow::KeyValueMetadata*","std::shared_ptr<const arrow::KeyValueMetadata>"})
                                                                                                 KeyValueMetadata metadata)

\brief Replace schema key-value metadata with new metadata (EXPERIMENTAL)

Parameters:

metadata - [in] new KeyValueMetadata

Returns:

new Table

Since:

0.5.0

Flatten

@ByVal
public TableResult Flatten(MemoryPool pool)

\brief Flatten the table, producing a new Table. Any column with a struct type will be flattened into multiple columns

Parameters:

pool - [in] The pool for buffer allocations, if any

Flatten

@ByVal
public TableResult Flatten()

ToString

@StdString
public String ToString()

Returns:

PrettyPrint representation suitable for debugging

Validate

@ByVal
public Status Validate()

\brief Perform cheap validation checks to determine obvious inconsistencies within the table's schema and internal data. This is O(k*m) where k is the total number of field descendents, and m is the number of chunks.

Returns:

Status

ValidateFull

@ByVal
public Status ValidateFull()

\brief Perform extensive validation checks to determine inconsistencies within the table's schema and internal data. This is O(k*n) where k is the total number of field descendents, and n is the number of rows.

Returns:

Status

num_columns

public int num_columns()

\brief Return the number of columns in the table

num_rows

@Cast(value="int64_t")
public long num_rows()

\brief Return the number of rows (equal to each column's logical length)

Equals

@Cast(value="bool")
public boolean Equals(@Const @ByRef
                                          Table other,
                                          @Cast(value="bool")
                                          boolean check_metadata)

\brief Determine if tables are equal Two tables can be equal only if they have equal schemas. However, they may be equal even if they have different chunkings.

Equals

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

CombineChunks

@ByVal
public TableResult CombineChunks(MemoryPool pool)

\brief Make a new table by combining the chunks this table has. All the underlying chunks in the ChunkedArray of each column are concatenated into zero or one chunk.

Parameters:

pool - [in] The pool for buffer allocations

CombineChunks

@ByVal
public TableResult CombineChunks()

Skip navigation links

• Overview
• Package
• Class
• Use
• Tree
• Deprecated
• Index
• Help

• Prev Class
• Next Class

• Frames
• No Frames

• All Classes

• Summary:
• Nested |
• Field |
• Constr |
• Method

• Detail:
• Field |
• Constr |
• Method

Copyright © 2021. All rights reserved.