Table (cudfjni 21.06.1 API)

java.lang.Object
- ai.rapids.cudf.Table

All Implemented Interfaces:

AutoCloseable
```
public final class Table
extends Object
implements AutoCloseable
```
Class to represent a collection of ColumnVectors and operations that can be performed on them collectively. The refcount on the columns will be increased once they are passed in

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`Table.GroupByOperation` Class representing groupby operations
`static class`	`Table.TableOperation`
`static class`	`Table.TestBuilder` Create a table on the GPU with data from the CPU.

Constructor Summary

Constructors
Constructor and Description
`Table(ColumnVector... columns)` Table class makes a copy of the array of `ColumnVector`s passed to it.
`Table(long[] cudfColumns)` Create a Table from an array of existing on device cudf::column pointers.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`void`	`close()`
`static Table`	`concatenate(Table... tables)` Concatenate multiple tables together to form a single table.
`ContiguousTable[]`	`contiguousSplit(int... indices)` Split a table at given boundaries, but the result of each split has memory that is laid out in a contiguous range of memory.
`static Table`	`convertFromRows(ColumnView vec, DType... schema)` Convert a column of list of bytes that is formatted like the output from `convertToRows` and convert it back to a table.
`ColumnVector[]`	`convertToRows()` Convert this table of columns into a row major format that is useful for interacting with other systems that do row major processing of the data.
`Table`	`crossJoin(Table right)` Joins two tables all of the left against all of the right.
`Table`	`explode(int index)` Explodes a list column's elements.
`Table`	`explodeOuter(int index)` Explodes a list column's elements.
`Table`	`explodeOuterPosition(int index)` Explodes a list column's elements retaining any null entries or empty lists and includes a position column.
`Table`	`explodePosition(int index)` Explodes a list column's elements and includes a position column.
`Table`	`filter(ColumnView mask)` Filters this table using a column of boolean values as a mask, returning a new one.
`static Table`	`fromPackedTable(ByteBuffer metadata, DeviceMemoryBuffer data)` Construct a table from a packed representation.
`GatherMap[]`	`fullJoinGatherMaps(Table rightKeys, boolean compareNullsEqual)` Computes the gather maps that can be used to manifest the result of an full equi-join between two tables.
`Table`	`gather(ColumnView gatherMap)` Gathers the rows of this table according to `gatherMap` such that row "i" in the resulting table's columns will contain row "gatherMap[i]" from this table.
`Table`	`gather(ColumnView gatherMap, boolean checkBounds)` Gathers the rows of this table according to `gatherMap` such that row "i" in the resulting table's columns will contain row "gatherMap[i]" from this table.
`ColumnVector`	`getColumn(int index)` Return the `ColumnVector` at the specified index.
`long`	`getDeviceMemorySize()` Returns the Device memory buffer size.
`int`	`getNumberOfColumns()`
`long`	`getRowCount()`
`Table.GroupByOperation`	`groupBy(GroupByOptions groupByOptions, int... indices)` Returns aggregate operations grouped by columns provided in indices
`Table.GroupByOperation`	`groupBy(int... indices)` Returns aggregate operations grouped by columns provided in indices with default options as below: - null is considered as key while grouping.
`GatherMap[]`	`innerJoinGatherMaps(Table rightKeys, boolean compareNullsEqual)` Computes the gather maps that can be used to manifest the result of an inner equi-join between two tables.
`ColumnVector`	`interleaveColumns()` Interleave all columns into a single column.
`GatherMap`	`leftAntiJoinGatherMap(Table rightKeys, boolean compareNullsEqual)` Computes the gather map that can be used to manifest the result of a left anti-join between two tables.
`GatherMap[]`	`leftJoinGatherMaps(Table rightKeys, boolean compareNullsEqual)` Computes the gather maps that can be used to manifest the result of a left equi-join between two tables.
`GatherMap`	`leftSemiJoinGatherMap(Table rightKeys, boolean compareNullsEqual)` Computes the gather map that can be used to manifest the result of a left semi-join between two tables.
`ColumnVector`	`lowerBound(boolean[] areNullsSmallest, Table valueTable, boolean[] descFlags)` Find smallest indices in a sorted table where values should be inserted to maintain order.
`ColumnVector`	`lowerBound(Table valueTable, OrderByArg... args)` Find smallest indices in a sorted table where values should be inserted to maintain order.
`static Table`	`merge(List<Table> tables, OrderByArg... args)` Merge multiple already sorted tables keeping the sort order the same.
`static Table`	`merge(Table[] tables, OrderByArg... args)` Merge multiple already sorted tables keeping the sort order the same.
`Table.TableOperation`	`onColumns(int... indices)`
`Table`	`orderBy(OrderByArg... args)` Orders the table using the sortkeys returning a new allocated table.
`PartitionedTable`	`partition(ColumnView partitionMap, int numberOfPartitions)` Partition this table using the mapping in partitionMap.
`static StreamedTableReader`	`readArrowIPCChunked(ArrowIPCOptions options, File inputFile)` Get a reader that will return tables.
`static StreamedTableReader`	`readArrowIPCChunked(ArrowIPCOptions options, HostBufferProvider provider)` Get a reader that will return tables.
`static StreamedTableReader`	`readArrowIPCChunked(File inputFile)` Get a reader that will return tables.
`static StreamedTableReader`	`readArrowIPCChunked(HostBufferProvider provider)` Get a reader that will return tables.
`static Table`	`readCSV(Schema schema, byte[] buffer)` Read CSV formatted data using the default CSVOptions.
`static Table`	`readCSV(Schema schema, CSVOptions opts, byte[] buffer)` Read CSV formatted data.
`static Table`	`readCSV(Schema schema, CSVOptions opts, byte[] buffer, long offset, long len)` Read CSV formatted data.
`static Table`	`readCSV(Schema schema, CSVOptions opts, File path)` Read a CSV file.
`static Table`	`readCSV(Schema schema, CSVOptions opts, HostMemoryBuffer buffer, long offset, long len)` Read CSV formatted data.
`static Table`	`readCSV(Schema schema, File path)` Read a CSV file using the default CSVOptions.
`static Table`	`readORC(byte[] buffer)` Read ORC formatted data.
`static Table`	`readORC(File path)` Read a ORC file using the default ORCOptions.
`static Table`	`readORC(ORCOptions opts, byte[] buffer)` Read ORC formatted data.
`static Table`	`readORC(ORCOptions opts, byte[] buffer, long offset, long len)` Read ORC formatted data.
`static Table`	`readORC(ORCOptions opts, File path)` Read a ORC file.
`static Table`	`readORC(ORCOptions opts, HostMemoryBuffer buffer, long offset, long len)` Read ORC formatted data.
`static Table`	`readParquet(byte[] buffer)` Read parquet formatted data.
`static Table`	`readParquet(File path)` Read a Parquet file using the default ParquetOptions.
`static Table`	`readParquet(ParquetOptions opts, byte[] buffer)` Read parquet formatted data.
`static Table`	`readParquet(ParquetOptions opts, byte[] buffer, long offset, long len)` Read parquet formatted data.
`static Table`	`readParquet(ParquetOptions opts, File path)` Read a Parquet file.
`static Table`	`readParquet(ParquetOptions opts, HostMemoryBuffer buffer, long offset, long len)` Read parquet formatted data.
`Table`	`repeat(ColumnView counts)` Create a new table by repeating each row of this table.
`Table`	`repeat(ColumnView counts, boolean checkCount)` Create a new table by repeating each row of this table.
`Table`	`repeat(int count)` Repeat each row of this table count times.
`PartitionedTable`	`roundRobinPartition(int numberOfPartitions, int startPartition)` Round-robin partition a table into the specified number of partitions.
`ColumnVector`	`rowBitCount()` Returns an approximate cumulative size in bits of all columns in the `table_view` for each row.
`ColumnVector`	`sortOrder(OrderByArg... args)` Get back a gather map that can be used to sort the data.
`String`	`toString()`
`ColumnVector`	`upperBound(boolean[] areNullsSmallest, Table valueTable, boolean[] descFlags)` Find largest indices in a sorted table where values should be inserted to maintain order.
`ColumnVector`	`upperBound(Table valueTable, OrderByArg... args)` Find largest indices in a sorted table where values should be inserted to maintain order.
`static TableWriter`	`writeArrowIPCChunked(ArrowIPCWriterOptions options, File outputFile)` Get a table writer to write arrow IPC data to a file.
`static TableWriter`	`writeArrowIPCChunked(ArrowIPCWriterOptions options, HostBufferConsumer consumer)` Get a table writer to write arrow IPC data and handle each chunk with a callback.
`void`	`writeORC(File outputFile)` Deprecated. please use writeORCChunked instead
`void`	`writeORC(ORCWriterOptions options, File outputFile)` Deprecated. please use writeORCChunked instead
`static TableWriter`	`writeORCChunked(ORCWriterOptions options, File outputFile)` Get a table writer to write ORC data to a file.
`static TableWriter`	`writeORCChunked(ORCWriterOptions options, HostBufferConsumer consumer)` Get a table writer to write ORC data and handle each chunk with a callback.
`void`	`writeParquet(ParquetWriterOptions options, File outputFile)` Deprecated. please use writeParquetChunked instead
`static TableWriter`	`writeParquetChunked(ParquetWriterOptions options, File outputFile)` Get a table writer to write parquet data to a file.
`static TableWriter`	`writeParquetChunked(ParquetWriterOptions options, HostBufferConsumer consumer)` Get a table writer to write parquet data and handle each chunk with a callback.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Constructor Detail
  - Table
```
public Table(ColumnVector... columns)
```
    Table class makes a copy of the array of ColumnVectors passed to it. The class will decrease the refcount on itself and all its contents when closed and free resources if refcount is zero
    
    Parameters:
    
    columns - - Array of ColumnVectors
  - Table
```
public Table(long[] cudfColumns)
```
    Create a Table from an array of existing on device cudf::column pointers. Ownership of the columns is transferred to the ColumnVectors held by the new Table. In the case of an exception the columns will be deleted.
    
    Parameters:
    
    cudfColumns - - Array of nativeHandles
- Method Detail
  - getColumn
```
public ColumnVector getColumn(int index)
```
    Return the ColumnVector at the specified index. If you want to keep a reference to the column around past the life time of the table, you will need to increment the reference count on the column yourself.
  - getRowCount
```
public final long getRowCount()
```
  - getNumberOfColumns
```
public final int getNumberOfColumns()
```
  - close
```
public void close()
```
    Specified by:
    
    close in interface AutoCloseable
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - getDeviceMemorySize
```
public long getDeviceMemorySize()
```
    Returns the Device memory buffer size.
  - readCSV
```
public static Table readCSV(Schema schema,
                            File path)
```
    Read a CSV file using the default CSVOptions.
    
    Parameters:
    
    schema - the schema of the file. You may use Schema.INFERRED to infer the schema.
    
    path - the local file to read.
    
    Returns:
    
    the file parsed as a table on the GPU.
  - readCSV
```
public static Table readCSV(Schema schema,
                            CSVOptions opts,
                            File path)
```
    Read a CSV file.
    
    Parameters:
    
    schema - the schema of the file. You may use Schema.INFERRED to infer the schema.
    
    opts - various CSV parsing options.
    
    path - the local file to read.
    
    Returns:
    
    the file parsed as a table on the GPU.
  - readCSV
```
public static Table readCSV(Schema schema,
                            byte[] buffer)
```
    Read CSV formatted data using the default CSVOptions.
    
    Parameters:
    
    schema - the schema of the data. You may use Schema.INFERRED to infer the schema.
    
    buffer - raw UTF8 formatted bytes.
    
    Returns:
    
    the data parsed as a table on the GPU.
  - readCSV
```
public static Table readCSV(Schema schema,
                            CSVOptions opts,
                            byte[] buffer)
```
    Read CSV formatted data.
    
    Parameters:
    
    schema - the schema of the data. You may use Schema.INFERRED to infer the schema.
    
    opts - various CSV parsing options.
    
    buffer - raw UTF8 formatted bytes.
    
    Returns:
    
    the data parsed as a table on the GPU.
  - readCSV
```
public static Table readCSV(Schema schema,
                            CSVOptions opts,
                            byte[] buffer,
                            long offset,
                            long len)
```
    Read CSV formatted data.
    
    Parameters:
    
    schema - the schema of the data. You may use Schema.INFERRED to infer the schema.
    
    opts - various CSV parsing options.
    
    buffer - raw UTF8 formatted bytes.
    
    offset - the starting offset into buffer.
    
    len - the number of bytes to parse.
    
    Returns:
    
    the data parsed as a table on the GPU.
  - readCSV
```
public static Table readCSV(Schema schema,
                            CSVOptions opts,
                            HostMemoryBuffer buffer,
                            long offset,
                            long len)
```
    Read CSV formatted data.
    
    Parameters:
    
    schema - the schema of the data. You may use Schema.INFERRED to infer the schema.
    
    opts - various CSV parsing options.
    
    buffer - raw UTF8 formatted bytes.
    
    offset - the starting offset into buffer.
    
    len - the number of bytes to parse.
    
    Returns:
    
    the data parsed as a table on the GPU.
  - readParquet
```
public static Table readParquet(File path)
```
    Read a Parquet file using the default ParquetOptions.
    
    Parameters:
    
    path - the local file to read.
    
    Returns:
    
    the file parsed as a table on the GPU.
  - readParquet
```
public static Table readParquet(ParquetOptions opts,
                                File path)
```
    Read a Parquet file.
    
    Parameters:
    
    opts - various parquet parsing options.
    
    path - the local file to read.
    
    Returns:
    
    the file parsed as a table on the GPU.
  - readParquet
```
public static Table readParquet(byte[] buffer)
```
    Read parquet formatted data.
    
    Parameters:
    
    buffer - raw parquet formatted bytes.
    
    Returns:
    
    the data parsed as a table on the GPU.
  - readParquet
```
public static Table readParquet(ParquetOptions opts,
                                byte[] buffer)
```
    Read parquet formatted data.
    
    Parameters:
    
    opts - various parquet parsing options.
    
    buffer - raw parquet formatted bytes.
    
    Returns:
    
    the data parsed as a table on the GPU.
  - readParquet
```
public static Table readParquet(ParquetOptions opts,
                                byte[] buffer,
                                long offset,
                                long len)
```
    Read parquet formatted data.
    
    Parameters:
    
    opts - various parquet parsing options.
    
    buffer - raw parquet formatted bytes.
    
    offset - the starting offset into buffer.
    
    len - the number of bytes to parse.
    
    Returns:
    
    the data parsed as a table on the GPU.
  - readParquet
```
public static Table readParquet(ParquetOptions opts,
                                HostMemoryBuffer buffer,
                                long offset,
                                long len)
```
    Read parquet formatted data.
    
    Parameters:
    
    opts - various parquet parsing options.
    
    buffer - raw parquet formatted bytes.
    
    offset - the starting offset into buffer.
    
    len - the number of bytes to parse.
    
    Returns:
    
    the data parsed as a table on the GPU.
  - readORC
```
public static Table readORC(File path)
```
    Read a ORC file using the default ORCOptions.
    
    Parameters:
    
    path - the local file to read.
    
    Returns:
    
    the file parsed as a table on the GPU.
  - readORC
```
public static Table readORC(ORCOptions opts,
                            File path)
```
    Read a ORC file.
    
    Parameters:
    
    opts - ORC parsing options.
    
    path - the local file to read.
    
    Returns:
    
    the file parsed as a table on the GPU.
  - readORC
```
public static Table readORC(byte[] buffer)
```
    Read ORC formatted data.
    
    Parameters:
    
    buffer - raw ORC formatted bytes.
    
    Returns:
    
    the data parsed as a table on the GPU.
  - readORC
```
public static Table readORC(ORCOptions opts,
                            byte[] buffer)
```
    Read ORC formatted data.
    
    Parameters:
    
    opts - various ORC parsing options.
    
    buffer - raw ORC formatted bytes.
    
    Returns:
    
    the data parsed as a table on the GPU.
  - readORC
```
public static Table readORC(ORCOptions opts,
                            byte[] buffer,
                            long offset,
                            long len)
```
    Read ORC formatted data.
    
    Parameters:
    
    opts - various ORC parsing options.
    
    buffer - raw ORC formatted bytes.
    
    offset - the starting offset into buffer.
    
    len - the number of bytes to parse.
    
    Returns:
    
    the data parsed as a table on the GPU.
  - readORC
```
public static Table readORC(ORCOptions opts,
                            HostMemoryBuffer buffer,
                            long offset,
                            long len)
```
    Read ORC formatted data.
    
    Parameters:
    
    opts - various ORC parsing options.
    
    buffer - raw ORC formatted bytes.
    
    offset - the starting offset into buffer.
    
    len - the number of bytes to parse.
    
    Returns:
    
    the data parsed as a table on the GPU.
  - writeParquetChunked
```
public static TableWriter writeParquetChunked(ParquetWriterOptions options,
                                              File outputFile)
```
    Get a table writer to write parquet data to a file.
    
    Parameters:
    
    options - the parquet writer options.
    
    outputFile - where to write the file.
    
    Returns:
    
    a table writer to use for writing out multiple tables.
  - writeParquetChunked
```
public static TableWriter writeParquetChunked(ParquetWriterOptions options,
                                              HostBufferConsumer consumer)
```
    Get a table writer to write parquet data and handle each chunk with a callback.
    
    Parameters:
    
    options - the parquet writer options.
    
    consumer - a class that will be called when host buffers are ready with parquet formatted data in them.
    
    Returns:
    
    a table writer to use for writing out multiple tables.
  - writeParquet
```
@Deprecated
public void writeParquet(ParquetWriterOptions options,
                                     File outputFile)
```
    Deprecated. please use writeParquetChunked instead
    
    Writes this table to a Parquet file on the host
    
    Parameters:
    
    options - parameters for the writer
    
    outputFile - file to write the table to
  - writeORCChunked
```
public static TableWriter writeORCChunked(ORCWriterOptions options,
                                          File outputFile)
```
    Get a table writer to write ORC data to a file.
    
    Parameters:
    
    options - the ORC writer options.
    
    outputFile - where to write the file.
    
    Returns:
    
    a table writer to use for writing out multiple tables.
  - writeORCChunked
```
public static TableWriter writeORCChunked(ORCWriterOptions options,
                                          HostBufferConsumer consumer)
```
    Get a table writer to write ORC data and handle each chunk with a callback.
    
    Parameters:
    
    options - the ORC writer options.
    
    consumer - a class that will be called when host buffers are ready with ORC formatted data in them.
    
    Returns:
    
    a table writer to use for writing out multiple tables.
  - writeORC
```
@Deprecated
public void writeORC(File outputFile)
```
    Deprecated. please use writeORCChunked instead
    
    Writes this table to a file on the host.
    
    Parameters:
    
    outputFile - - File to write the table to
  - writeORC
```
@Deprecated
public void writeORC(ORCWriterOptions options,
                                 File outputFile)
```
    Deprecated. please use writeORCChunked instead
    
    Writes this table to a file on the host.
    
    Parameters:
    
    outputFile - - File to write the table to
  - writeArrowIPCChunked
```
public static TableWriter writeArrowIPCChunked(ArrowIPCWriterOptions options,
                                               File outputFile)
```
    Get a table writer to write arrow IPC data to a file.
    
    Parameters:
    
    options - the arrow IPC writer options.
    
    outputFile - where to write the file.
    
    Returns:
    
    a table writer to use for writing out multiple tables.
  - writeArrowIPCChunked
```
public static TableWriter writeArrowIPCChunked(ArrowIPCWriterOptions options,
                                               HostBufferConsumer consumer)
```
    Get a table writer to write arrow IPC data and handle each chunk with a callback.
    
    Parameters:
    
    options - the arrow IPC writer options.
    
    consumer - a class that will be called when host buffers are ready with arrow IPC formatted data in them.
    
    Returns:
    
    a table writer to use for writing out multiple tables.
  - readArrowIPCChunked
```
public static StreamedTableReader readArrowIPCChunked(ArrowIPCOptions options,
                                                      File inputFile)
```
    Get a reader that will return tables.
    
    Parameters:
    
    options - options for reading.
    
    inputFile - the file to read the Arrow IPC formatted data from
    
    Returns:
    
    a reader.
  - readArrowIPCChunked
```
public static StreamedTableReader readArrowIPCChunked(File inputFile)
```
    Get a reader that will return tables.
    
    Parameters:
    
    inputFile - the file to read the Arrow IPC formatted data from
    
    Returns:
    
    a reader.
  - readArrowIPCChunked
```
public static StreamedTableReader readArrowIPCChunked(ArrowIPCOptions options,
                                                      HostBufferProvider provider)
```
    Get a reader that will return tables.
    
    Parameters:
    
    options - options for reading.
    
    provider - what will provide the data being read.
    
    Returns:
    
    a reader.
  - readArrowIPCChunked
```
public static StreamedTableReader readArrowIPCChunked(HostBufferProvider provider)
```
    Get a reader that will return tables.
    
    Parameters:
    
    provider - what will provide the data being read.
    
    Returns:
    
    a reader.
  - concatenate
```
public static Table concatenate(Table... tables)
```
    Concatenate multiple tables together to form a single table. The schema of each table (i.e.: number of columns and types of each column) must be equal across all tables and will determine the schema of the resulting table.
  - interleaveColumns
```
public ColumnVector interleaveColumns()
```
    Interleave all columns into a single column. Columns must all have the same data type and length. Example: ``` input = [[A1, A2, A3], [B1, B2, B3]] return = [A1, B1, A2, B2, A3, B3] ```
    
    Returns:
    
    The interleaved columns as a single column
  - repeat
```
public Table repeat(int count)
```
    Repeat each row of this table count times.
    
    Parameters:
    
    count - the number of times to repeat each row.
    
    Returns:
    
    the new Table.
  - repeat
```
public Table repeat(ColumnView counts)
```
    Create a new table by repeating each row of this table. The number of repetitions of each row is defined by the corresponding value in counts.
    
    Parameters:
    
    counts - the number of times to repeat each row. Cannot have nulls, must be an Integer type, and must have one entry for each row in the table.
    
    Returns:
    
    the new Table.
    
    Throws:
    
    CudfException - on any error.
  - repeat
```
public Table repeat(ColumnView counts,
                    boolean checkCount)
```
    Create a new table by repeating each row of this table. The number of repetitions of each row is defined by the corresponding value in counts.
    
    Parameters:
    
    counts - the number of times to repeat each row. Cannot have nulls, must be an Integer type, and must have one entry for each row in the table.
    
    checkCount - should counts be checked for errors before processing. Be careful if you disable this because if you pass in bad data you might just get back an empty table or bad data.
    
    Returns:
    
    the new Table.
    
    Throws:
    
    CudfException - on any error.
  - partition
```
public PartitionedTable partition(ColumnView partitionMap,
                                  int numberOfPartitions)
```
    Partition this table using the mapping in partitionMap. partitionMap must be an integer column. The number of rows in partitionMap must be the same as this table. Each row in the map will indicate which partition the rows in the table belong to.
    
    Parameters:
    
    partitionMap - the partitions for each row.
    
    numberOfPartitions - number of partitions
    
    Returns:
    
    PartitionedTable Table that exposes a limited functionality of the Table class
  - lowerBound
```
public ColumnVector lowerBound(boolean[] areNullsSmallest,
                               Table valueTable,
                               boolean[] descFlags)
```
    Find smallest indices in a sorted table where values should be inserted to maintain order.
```
 Example:

  Single column:
      idx            0   1   2   3   4
   inputTable  =   { 10, 20, 20, 30, 50 }
   valuesTable =   { 20 }
   result      =   { 1 }

  Multi Column:
      idx                0    1    2    3    4
   inputTable      = {{  10,  20,  20,  20,  20 },
                      { 5.0,  .5,  .5,  .7,  .7 },
                      {  90,  77,  78,  61,  61 }}
   valuesTable     = {{ 20 },
                      { .7 },
                      { 61 }}
   result          = {  3 }
 
```
    The input table and the values table need to be non-empty (row count > 0)
    Parameters:
    
    areNullsSmallest - per column, true if nulls are assumed smallest
    
    valueTable - the table of values to find insertion locations for
    
    descFlags - per column indicates the ordering, true if descending.
    
    Returns:
    
    ColumnVector with lower bound indices for all rows in valueTable
  - lowerBound
```
public ColumnVector lowerBound(Table valueTable,
                               OrderByArg... args)
```
    Find smallest indices in a sorted table where values should be inserted to maintain order. This is a convenience method. It pulls out the columns indicated by the args and sets up the ordering properly to call `lowerBound`.
    
    Parameters:
    
    valueTable - the table of values to find insertion locations for
    
    args - the sort order used to sort this table.
    
    Returns:
    
    ColumnVector with lower bound indices for all rows in valueTable
  - upperBound
```
public ColumnVector upperBound(boolean[] areNullsSmallest,
                               Table valueTable,
                               boolean[] descFlags)
```
    Find largest indices in a sorted table where values should be inserted to maintain order. Given a sorted table return the upper bound.
```
 Example:

  Single column:
      idx            0   1   2   3   4
   inputTable  =   { 10, 20, 20, 30, 50 }
   valuesTable =   { 20 }
   result      =   { 3 }

  Multi Column:
      idx                0    1    2    3    4
   inputTable      = {{  10,  20,  20,  20,  20 },
                      { 5.0,  .5,  .5,  .7,  .7 },
                      {  90,  77,  78,  61,  61 }}
   valuesTable     = {{ 20 },
                      { .7 },
                      { 61 }}
   result          = {  5 }
 
```
    The input table and the values table need to be non-empty (row count > 0)
    Parameters:
    
    areNullsSmallest - per column, true if nulls are assumed smallest
    
    valueTable - the table of values to find insertion locations for
    
    descFlags - per column indicates the ordering, true if descending.
    
    Returns:
    
    ColumnVector with upper bound indices for all rows in valueTable
  - upperBound
```
public ColumnVector upperBound(Table valueTable,
                               OrderByArg... args)
```
    Find largest indices in a sorted table where values should be inserted to maintain order. This is a convenience method. It pulls out the columns indicated by the args and sets up the ordering properly to call `upperBound`.
    
    Parameters:
    
    valueTable - the table of values to find insertion locations for
    
    args - the sort order used to sort this table.
    
    Returns:
    
    ColumnVector with upper bound indices for all rows in valueTable
  - crossJoin
```
public Table crossJoin(Table right)
```
    Joins two tables all of the left against all of the right. Be careful as this gets very big and you can easily use up all of the GPUs memory.
    
    Parameters:
    
    right - the right table
    
    Returns:
    
    the joined table. The order of the columns returned will be left columns, right columns.
  - sortOrder
```
public ColumnVector sortOrder(OrderByArg... args)
```
    Get back a gather map that can be used to sort the data. This allows you to sort by data that does not appear in the final result and not pay the cost of gathering the data that is only needed for sorting.
    
    Parameters:
    
    args - what order to sort the data by
    
    Returns:
    
    a gather map
  - orderBy
```
public Table orderBy(OrderByArg... args)
```
    Orders the table using the sortkeys returning a new allocated table. The caller is responsible for cleaning up the ColumnVector returned as part of the output Table
    Example usage: orderBy(true, OrderByArg.asc(0), OrderByArg.desc(3)...);
    
    Parameters:
    
    args - Suppliers to initialize sortKeys.
    
    Returns:
    
    Sorted Table
  - merge
```
public static Table merge(Table[] tables,
                          OrderByArg... args)
```
    Merge multiple already sorted tables keeping the sort order the same. This is a more efficient version of concatenate followed by orderBy, but requires that the input already be sorted.
    
    Parameters:
    
    tables - the tables that should be merged.
    
    args - the ordering of the tables. Should match how they were sorted initially.
    
    Returns:
    
    a combined sorted table.
  - merge
```
public static Table merge(List<Table> tables,
                          OrderByArg... args)
```
    Merge multiple already sorted tables keeping the sort order the same. This is a more efficient version of concatenate followed by orderBy, but requires that the input already be sorted.
    
    Parameters:
    
    tables - the tables that should be merged.
    
    args - the ordering of the tables. Should match how they were sorted initially.
    
    Returns:
    
    a combined sorted table.
  - groupBy
```
public Table.GroupByOperation groupBy(GroupByOptions groupByOptions,
                                      int... indices)
```
    Returns aggregate operations grouped by columns provided in indices
    
    Parameters:
    
    groupByOptions - Options provided in the builder
    
    indices - columns to be considered for groupBy
  - groupBy
```
public Table.GroupByOperation groupBy(int... indices)
```
    Returns aggregate operations grouped by columns provided in indices with default options as below: - null is considered as key while grouping. - keys are not presorted. - empty key order array. - empty null order array.
    
    Parameters:
    
    indices - columns to be considered for groupBy
  - roundRobinPartition
```
public PartitionedTable roundRobinPartition(int numberOfPartitions,
                                            int startPartition)
```
    Round-robin partition a table into the specified number of partitions. The first row is placed in the specified starting partition, the next row is placed in the next partition, and so on. When the last partition is reached then next partition is partition 0 and the algorithm continues until all rows have been placed in partitions, evenly distributing the rows among the partitions.
    
    Parameters:
    
    numberOfPartitions - - number of partitions to use
    
    startPartition - - starting partition index (i.e.: where first row is placed).
    
    Returns:
    
    - PartitionedTable - Table that exposes a limited functionality of the Table class
  - onColumns
```
public Table.TableOperation onColumns(int... indices)
```
  - filter
```
public Table filter(ColumnView mask)
```
    Filters this table using a column of boolean values as a mask, returning a new one.
    Given a mask column, each element `i` from the input columns is copied to the output columns if the corresponding element `i` in the mask is non-null and `true`. This operation is stable: the input order is preserved.
    This table and mask columns must have the same number of rows.
    The output table has size equal to the number of elements in boolean_mask that are both non-null and `true`.
    If the original table row count is zero, there is no error, and an empty table is returned.
    
    Parameters:
    
    mask - column of type DType.BOOL8 used as a mask to filter the input column
    
    Returns:
    
    table containing copy of all elements of this table passing the filter defined by the boolean mask
  - contiguousSplit
```
public ContiguousTable[] contiguousSplit(int... indices)
```
    Split a table at given boundaries, but the result of each split has memory that is laid out in a contiguous range of memory. This allows for us to optimize copying the data in a single operation. Example: input: [{10, 12, 14, 16, 18, 20, 22, 24, 26, 28}, {50, 52, 54, 56, 58, 60, 62, 64, 66, 68}] splits: {2, 5, 9} output: [{{10, 12}, {14, 16, 18}, {20, 22, 24, 26}, {28}}, {{50, 52}, {54, 56, 58}, {60, 62, 64, 66}, {68}}]
    
    Parameters:
    
    indices - A vector of indices where to make the split
    
    Returns:
    
    The tables split at those points. NOTE: It is the responsibility of the caller to close the result. Each table and column holds a reference to the original buffer. But both the buffer and the table must be closed for the memory to be released.
  - explode
```
public Table explode(int index)
```
    Explodes a list column's elements. Any list is exploded, which means the elements of the list in each row are expanded into new rows in the output. The corresponding rows for other columns in the input are duplicated. Example: input: [[5,10,15], 100], [[20,25], 200], [[30], 300] index: 0 output: [5, 100], [10, 100], [15, 100], [20, 200], [25, 200], [30, 300] Nulls propagate in different ways depending on what is null. input: [[5,null,15], 100], [null, 200] index: 0 output: [5, 100], [null, 100], [15, 100] Note that null lists are completely removed from the output and nulls inside lists are pulled out and remain.
    
    Parameters:
    
    index - Column index to explode inside the table.
    
    Returns:
    
    A new table with explode_col exploded.
  - explodePosition
```
public Table explodePosition(int index)
```
    Explodes a list column's elements and includes a position column. Any list is exploded, which means the elements of the list in each row are expanded into new rows in the output. The corresponding rows for other columns in the input are duplicated. A position column is added that has the index inside the original list for each row. Example: input: [[5,10,15], 100], [[20,25], 200], [[30], 300] index: 0 output: [0, 5, 100], [1, 10, 100], [2, 15, 100], [0, 20, 200], [1, 25, 200], [0, 30, 300] Nulls and empty lists propagate in different ways depending on what is null or empty. input: [[5,null,15], 100], [null, 200] index: 0 output: [5, 100], [null, 100], [15, 100] Note that null lists are not included in the resulting table, but nulls inside lists and empty lists will be represented with a null entry for that column in that row.
    
    Parameters:
    
    index - Column index to explode inside the table.
    
    Returns:
    
    A new table with exploded value and position. The column order of return table is [cols before explode_input, explode_position, explode_value, cols after explode_input].
  - explodeOuter
```
public Table explodeOuter(int index)
```
    Explodes a list column's elements. Any list is exploded, which means the elements of the list in each row are expanded into new rows in the output. The corresponding rows for other columns in the input are duplicated. Example: input: [[5,10,15], 100], [[20,25], 200], [[30], 300], index: 0 output: [5, 100], [10, 100], [15, 100], [20, 200], [25, 200], [30, 300] Nulls propagate in different ways depending on what is null. input: [[5,null,15], 100], [null, 200] index: 0 output: [5, 100], [null, 100], [15, 100], [null, 200] Note that null lists are completely removed from the output and nulls inside lists are pulled out and remain.
    
    Parameters:
    
    index - Column index to explode inside the table.
    
    Returns:
    
    A new table with explode_col exploded.
  - explodeOuterPosition
```
public Table explodeOuterPosition(int index)
```
    Explodes a list column's elements retaining any null entries or empty lists and includes a position column. Any list is exploded, which means the elements of the list in each row are expanded into new rows in the output. The corresponding rows for other columns in the input are duplicated. A position column is added that has the index inside the original list for each row. Example: Example: input: [[5,10,15], 100], [[20,25], 200], [[30], 300], index: 0 output: [0, 5, 100], [1, 10, 100], [2, 15, 100], [0, 20, 200], [1, 25, 200], [0, 30, 300] Nulls and empty lists propagate as null entries in the result. input: [[5,null,15], 100], [null, 200], [[], 300] index: 0 output: [0, 5, 100], [1, null, 100], [2, 15, 100], [0, null, 200], [0, null, 300] returns
    
    Parameters:
    
    index - Column index to explode inside the table.
    
    Returns:
    
    A new table with exploded value and position. The column order of return table is [cols before explode_input, explode_position, explode_value, cols after explode_input].
  - rowBitCount
```
public ColumnVector rowBitCount()
```
    Returns an approximate cumulative size in bits of all columns in the `table_view` for each row. This function counts bits instead of bytes to account for the null mask which only has one bit per row. Each row in the returned column is the sum of the per-row bit size for each column in the table. In some cases, this is an inexact approximation. Specifically, columns of lists and strings require N+1 offsets to represent N rows. It is up to the caller to calculate the small additional overhead of the terminating offset for any group of rows being considered. This function returns the per-row bit sizes as the columns are currently formed. This can end up being larger than the number you would get by gathering the rows. Specifically, the push-down of struct column validity masks can nullify rows that contain data for string or list columns. In these cases, the size returned is conservative such that: row_bit_count(column(x)) >= row_bit_count(gather(column(x)))
    
    Returns:
    
    INT32 column of bit size per row of the table
  - gather
```
public Table gather(ColumnView gatherMap)
```
    Gathers the rows of this table according to `gatherMap` such that row "i" in the resulting table's columns will contain row "gatherMap[i]" from this table. The number of rows in the result table will be equal to the number of elements in `gatherMap`. A negative value `i` in the `gatherMap` is interpreted as `i+n`, where `n` is the number of rows in this table.
    
    Parameters:
    
    gatherMap - the map of indexes. Must be non-nullable and integral type.
    
    Returns:
    
    the resulting Table.
  - gather
```
public Table gather(ColumnView gatherMap,
                    boolean checkBounds)
```
    Gathers the rows of this table according to `gatherMap` such that row "i" in the resulting table's columns will contain row "gatherMap[i]" from this table. The number of rows in the result table will be equal to the number of elements in `gatherMap`. A negative value `i` in the `gatherMap` is interpreted as `i+n`, where `n` is the number of rows in this table.
    
    Parameters:
    
    gatherMap - the map of indexes. Must be non-nullable and integral type.
    
    checkBounds - if true bounds checking is performed on the value. Be very careful when setting this to false.
    
    Returns:
    
    the resulting Table.
  - leftJoinGatherMaps
```
public GatherMap[] leftJoinGatherMaps(Table rightKeys,
                                      boolean compareNullsEqual)
```
    Computes the gather maps that can be used to manifest the result of a left equi-join between two tables. It is assumed this table instance holds the key columns from the left table, and the table argument represents the key columns from the right table. Two GatherMap instances will be returned that can be used to gather the left and right tables, respectively, to produce the result of the left join. It is the responsibility of the caller to close the resulting gather map instances.
    
    Parameters:
    
    rightKeys - join key columns from the right table
    
    compareNullsEqual - true if null key values should match otherwise false
    
    Returns:
    
    left and right table gather maps
  - innerJoinGatherMaps
```
public GatherMap[] innerJoinGatherMaps(Table rightKeys,
                                       boolean compareNullsEqual)
```
    Computes the gather maps that can be used to manifest the result of an inner equi-join between two tables. It is assumed this table instance holds the key columns from the left table, and the table argument represents the key columns from the right table. Two GatherMap instances will be returned that can be used to gather the left and right tables, respectively, to produce the result of the inner join. It is the responsibility of the caller to close the resulting gather map instances.
    
    Parameters:
    
    rightKeys - join key columns from the right table
    
    compareNullsEqual - true if null key values should match otherwise false
    
    Returns:
    
    left and right table gather maps
  - fullJoinGatherMaps
```
public GatherMap[] fullJoinGatherMaps(Table rightKeys,
                                      boolean compareNullsEqual)
```
    Computes the gather maps that can be used to manifest the result of an full equi-join between two tables. It is assumed this table instance holds the key columns from the left table, and the table argument represents the key columns from the right table. Two GatherMap instances will be returned that can be used to gather the left and right tables, respectively, to produce the result of the full join. It is the responsibility of the caller to close the resulting gather map instances.
    
    Parameters:
    
    rightKeys - join key columns from the right table
    
    compareNullsEqual - true if null key values should match otherwise false
    
    Returns:
    
    left and right table gather maps
  - leftSemiJoinGatherMap
```
public GatherMap leftSemiJoinGatherMap(Table rightKeys,
                                       boolean compareNullsEqual)
```
    Computes the gather map that can be used to manifest the result of a left semi-join between two tables. It is assumed this table instance holds the key columns from the left table, and the table argument represents the key columns from the right table. The GatherMap instance returned can be used to gather the left table to produce the result of the left semi-join. It is the responsibility of the caller to close the resulting gather map instance.
    
    Parameters:
    
    rightKeys - join key columns from the right table
    
    compareNullsEqual - true if null key values should match otherwise false
    
    Returns:
    
    left table gather map
  - leftAntiJoinGatherMap
```
public GatherMap leftAntiJoinGatherMap(Table rightKeys,
                                       boolean compareNullsEqual)
```
    Computes the gather map that can be used to manifest the result of a left anti-join between two tables. It is assumed this table instance holds the key columns from the left table, and the table argument represents the key columns from the right table. The GatherMap instance returned can be used to gather the left table to produce the result of the left anti-join. It is the responsibility of the caller to close the resulting gather map instance.
    
    Parameters:
    
    rightKeys - join key columns from the right table
    
    compareNullsEqual - true if null key values should match otherwise false
    
    Returns:
    
    left table gather map
  - convertToRows
```
public ColumnVector[] convertToRows()
```
    Convert this table of columns into a row major format that is useful for interacting with other systems that do row major processing of the data. Currently only fixed-width column types are supported.
    The output is one or more ColumnVectors that are lists of bytes. A ColumnVector that is a list of bytes can have at most 2GB of data stored in it. Multiple ColumnVectors are returned if not all of the data can fit in a single one.
    Each row in the returned ColumnVector array corresponds to a row in the input table. The rows will be in the same order as the input Table. The first ColumnVector in the array will hold the first N rows followed by the second ColumnVector and so on. The following illustrates this and also shows some of the internal structure that will be explained later.
```
 result[0]:
  | row 0 | validity for row 0 | padding |
  ...
  | row N | validity for row N | padding |
  result[1]:
  |row N+1 | validity for row N+1 | padding |
  ...
 
```
    The format of each row is similar in layout to a C struct where each column will have padding in front of it to align it properly. Each row has padding inserted at the end so the next row is aligned to a 64-bit boundary. This is so that the first column will always start at the beginning (first byte) of the list of bytes and each row has a consistent layout for fixed width types.
    Validity bytes are added to the end of the row. There will be one byte for each 8 columns in a row. Because the validity is byte aligned there is no padding between it and the last column in the row.
    For example a table consisting of the following columns A, B, C with the corresponding types
```
   | A - BOOL8 (8-bit) | B - INT16 (16-bit) | C - DURATION_DAYS (32-bit) |
 
```
    Will have a layout that looks like
```
  | A_0 | P | B_0 | B_1 | C_0 | C_1 | C_2 | C_3 | V0 | P | P | P | P | P | P | P |
 
```
    In this P corresponds to a byte of padding, [LETTER]_[NUMBER] represents the NUMBER byte of the corresponding LETTER column, and V[NUMBER] is a validity byte for the `NUMBER * 8` to `(NUMBER + 1) * 8` columns.
    The order of the columns will not be changed, but to reduce the total amount of padding it is recommended to order the columns in the following way.
    1. 64-bit columns
    2. 32-bit columns
    3. 16-bit columns
    4. 8-bit columns
    This way padding is only inserted at the end of a row to make the next column 64-bit aligned. So for the example above if the columns were ordered C, B, A the layout would be.
```
 | C_0 | C_1 | C_2 | C_3 | B_0 | B_1 | A_0 | V0 |
 
```
    This would have reduced the overall size of the data transferred by half.
    One of the main motivations for doing a row conversion on the GPU is to avoid cache problems when walking through columnar data on the CPU in a row wise manner. If you are not transferring very many columns it is likely to be more efficient to just pull back the columns and walk through them. This is especially true of a single column of fixed width data. The extra padding will slow down the transfer and looking at only a handful of buffers is not likely to cause cache issues.
    There are some limits on the size of a single row. If the row is larger than 1KB this will throw an exception.
  - convertFromRows
```
public static Table convertFromRows(ColumnView vec,
                                    DType... schema)
```
    Convert a column of list of bytes that is formatted like the output from `convertToRows` and convert it back to a table.
    
    Parameters:
    
    vec - the row data to process.
    
    schema - the types of each column.
    
    Returns:
    
    the parsed table.
  - fromPackedTable
```
public static Table fromPackedTable(ByteBuffer metadata,
                                    DeviceMemoryBuffer data)
```
    Construct a table from a packed representation.
    
    Parameters:
    
    metadata - host-based metadata for the table
    
    data - GPU data buffer for the table
    
    Returns:
    
    table which is zero-copy reconstructed from the packed-form

Class Table

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

Table

Table

Method Detail

getColumn

getRowCount

getNumberOfColumns

close

toString

getDeviceMemorySize

readCSV

readCSV

readCSV

readCSV

readCSV

readCSV

readParquet

readParquet

readParquet

readParquet

readParquet

readParquet

readORC

readORC

readORC

readORC

readORC

readORC

writeParquetChunked

writeParquetChunked

writeParquet

writeORCChunked

writeORCChunked

writeORC

writeORC

writeArrowIPCChunked

writeArrowIPCChunked

readArrowIPCChunked

readArrowIPCChunked

readArrowIPCChunked

readArrowIPCChunked

concatenate

interleaveColumns

repeat

repeat

repeat

partition

lowerBound

lowerBound

upperBound

upperBound

crossJoin

sortOrder

orderBy

merge

merge

groupBy

groupBy

roundRobinPartition

onColumns

filter

contiguousSplit

explode

explodePosition

explodeOuter

explodeOuterPosition

rowBitCount

gather

gather

leftJoinGatherMaps

innerJoinGatherMaps

fullJoinGatherMaps

leftSemiJoinGatherMap

leftAntiJoinGatherMap

convertToRows