All Classes and Interfaces
Class
Description
The base class for concrete compression codecs, providing common logic for all compression
codecs.
Base class for composite vectors.
Base class for StructVectors.
Policy to determine how to react when duplicate columns are encountered.
An opaque action for the service to perform.
POJO wrapper around protocol specifics for Flight actions.
Tuple class containing a vector and whether it was created.
Allow a user to add a ByteBuf based InputStream directly into GRPC WritableBuffer to avoid an
extra copy.
Helper utility methods for allocating storage for Vectors.
An allocation listener being notified for allocation/deallocation
An AllocationManager is the implementation of a physical memory allocation.
A factory interface for creating
AllocationManager.Describes the type of outcome that occurred when trying to account for allocation of memory.
Allocation status code.
Captures details of allocation for each accountant in the hierarchical chain.
Outcome of the allocation request at one accountant in the hierarchy.
Supports cumulative allocation reservation.
Exception thrown when a closed BufferAllocator is used.
Visitor to compare floating point vectors approximately.
Consumer which consume array type values from
ResultSet.Metadata for an arrow message in a channel.
Compression information about data written to a channel.
ArrowBuf serves as a facade over underlying memory by providing several access APIs to read/write
data into a chunk of direct memory.
Metadata for a buffer written to a channel.
Utility for calculating the hash code for a consecutive memory region.
Pointer to a memory region within an
ArrowBuf.POJO wrapper around a Dictionary Batch IPC messages.
Metadata about Vectors/Arrays that is written to a channel.
An implementation of
ArrowReader that reads the standard arrow binary file format.ArrowWriter that writes out a Arrow files
(https://arrow.apache.org/docs/format/IPC.html#file-format).Footer metadata for the arrow file format.
Interface for Arrow IPC messages (https://arrow.apache.org/docs/format/IPC.html).
Visitor interface for implementations of
ArrowMessage.Abstract class to read Schema and ArrowRecordBatches.
POJO representation of a RecordBatch IPC message
(https://arrow.apache.org/docs/format/Columnar.html#recordbatch-message).
This class reads from an input stream and produces ArrowRecordBatches.
Writer for the Arrow stream format to send ArrowRecordBatches over a WriteChannel.
Arrow types
Source code generated using FreeMarker template ArrowType.java
to visit the ArrowTypes
type.accept(new ArrowTypeVisitor<Type>() {
...to visit the Complex ArrowTypes and bundle Primitive ones in one case
A user-defined data type that wraps an underlying storage type.
to visit the Primitive ArrowTypes and bundle Complex ones under one case
VectorSchemaRoot iterator for partially converting JDBC data.
Abstract base class for implementing Arrow writers for IPC over a WriteChannel.
Utility class to that provides
AssertionUtil.ASSERT_ENABLED constant to determine if assertions are
enabled.A handler for server-sent application metadata messages during a Flight DoPut operation.
Constants used in authorization of flight connections.
Constants used in authorization of flight connections.
Utility class for completing the auth process.
Simple wrapper class that allows Locks to be released via a try-with-resources block.
Utilities for AutoCloseable classes.
A closeable wrapper that will close the underlying closeables if a commit does not occur.
Consumer which consume array type values from avro decoder.
Consumer which consume boolean type values from avro decoder.
Consumer which consume bytes type values from avro decoder.
Consumer which consume date type values from avro decoder.
Consumer which consume decimal type values from avro decoder.
Consumer for decimal logical type with original bytes type.
Consumer for decimal logical type with original fixed type.
Consumer which consume double type values from avro decoder.
Consumer which consume enum type values from avro decoder.
Consumer which consume fixed type values from avro decoder.
Consumer which consume float type values from avro decoder.
Consumer which consume int type values from avro decoder.
Consumer which consume long type values from avro decoder.
Consumer which consume map type values from avro decoder.
Consumer which consume null type values from avro decoder.
Consumer which consume string type values from avro decoder.
Consumer which consume nested record type values from avro decoder.
Consumer which consume date time-micro values from avro decoder.
Consumer which consume date time-millis values from avro decoder.
Consumer which consume date timestamp-micro values from avro decoder.
Consumer which consume date timestamp-millis values from avro decoder.
Utility class to convert Avro objects to columnar Arrow format objects.
This class configures the Avro-to-Arrow conversion process.
This class builds
AvroToArrowConfigs.Class that does most of the work to convert Avro data into Arrow columnar format Vector objects.
VectorSchemaRoot iterator for partially converting avro data.
Consumer which consume unions type values from avro decoder.
Helper interface to dynamically handle backpressure when implementing FlightProducers.
A back pressure strategy that uses callbacks to notify when the client is ready or cancelled.
The state of the client after a call to waitForListener.
Base class for non-skippable avro consumers.
Base class for ColumnBinder implementations.
Base class for all consumers.
BaseFixedWidthVector provides an abstract interface for implementing vectors of fixed width
values.
Interface for all int type vectors.
BaseLargeVariableWidthVector is a base class providing functionality for large strings/large
bytes types.
Abstraction for all list type vectors.
Source code generated using FreeMarker template BaseReader.java
Base class for Vectors that contain repeated values.
Abstract base class for Table.
Base class for other Arrow Vector Types.
BaseVariableWidthVector is a base class providing functionality for strings/bytes types.
BaseVariableWidthViewVector is a base class providing functionality for strings/bytes types in
view format.
Client credentials that use a username and password.
A ServerAuthHandler for username/password authentication.
Interface that this handler delegates to for validating the incoming headers.
A client auth handler that supports username and password.
A
FlightSqlProducer that implements getting FlightInfo for each metadata request.A ServerAuthHandler for username/password authentication.
Interface that this handler delegates for determining if credentials are valid.
Client credentials that use a bearer token.
Partial implementation of
CallHeaderAuthenticator for bearer-token based authentication.A column binder for 8-bit integers.
Consumer which consume bigint type values from
ResultSet.Source code generated using FreeMarker template ValueHolders.java
Source code generated using FreeMarker template ComplexReaders.java
Source code generated using FreeMarker template ComplexReaders.java
BigIntVector implements a fixed width vector (8 bytes) of integer values which could be null.
Opaque binary data
Consumer which consume binary type values from
ResultSet.Logically the same as Binary, but the internal representation uses a view
struct that contains the string length and either the string's entire data
inline (for small strings) or an inlined prefix, an index of another buffer,
and an offset pointing to a slice in that buffer (for non-small strings).
A column binder for booleans.
Consumer which consume bit type values from
ResultSet.Source code generated using FreeMarker template ValueHolders.java
Source code generated using FreeMarker template ComplexReaders.java
Source code generated using FreeMarker template ComplexReaders.java
BitVector implements a fixed width (1 bit) vector of boolean values which could be null.
Helper class for performing generic operations on a bit vector buffer.
Consumer which consume blob type values from
ResultSet.Optional compression for the memory buffers constituting IPC message
bodies.
Provided for forward compatibility in case we need to support different
strategies for compressing the IPC message body (like whole-body
compression rather than buffer-level) in the future
Configuration class to determine if bounds checking should be turned on or off.
----------------------------------------------------------------------
A Buffer represents a single contiguous memory segment
Wrapper class to deal with byte buffer allocation.
Content is backed by a buffer and can be loaded/unloaded.
Metadata class that captures the "type" of an Arrow buffer.
Enumeration of the different logical types a buffer can have.
The outcome of a Transfer.
Manages a list of
ArrowBufs that can be reallocated as needed.A
SeekableByteChannel backed by a byte array.Utility methods for memory comparison at a byte level.
Generic callback interface to be notified of events on value vectors.
Adapter class to utilize a CredentialWriter to implement Grpc CallCredentials.
Interface for Server side authentication handlers.
Encapsulates the result of the
CallHeaderAuthenticator analysis of headers.A set of metadata key value pairs for a call (request or response).
A description of a Flight call for middleware to inspect.
Per-call RPC options.
Common call options.
CallOptions specific to GRPC stubs.
The result of a Flight RPC, consisting of a status code with an optional description and/or
exception that led to the status.
A request to cancel a FlightInfo.
The result of cancelling a FlightInfo.
Deprecated.
The result of cancelling a FlightInfo.
Deprecated.
As of 14.0.0.
A communication channel to the server during initial connection.
GRPC client intercepter that handles authentication with the server.
Utility class for performing authorization over using a GRPC stub.
A client header handler that parses the incoming headers for a bearer token.
A client middleware for receiving and sending cookie information.
Factory used within FlightClient.
Utility class for executing a handshake with a FlightServer.
Interface for client side header parsing and conversion to CredentialCallOption.
Middleware for capturing bearer tokens sent back from the Flight server.
Factory used within FlightClient.
An adapter between Flight client middleware and gRPC interceptors.
Consumer which consume clob type values from
ResultSet.A request to close/invalidate a server session context.
The result of attempting to close/invalidate a server session context.
Close operation result status values.
Typed StreamListener for closeSession.
Utility methods for manipulating
Collections and their
subclasses/implementations.A helper to bind values from a wrapped Arrow vector to a JDBC PreparedStatement.
Visitor to create the base ColumnBinder for a vector.
Default implementation of factory supported LZ4 and ZSTD compression.
Utilities and static methods needed for arrow-memory.
Represents a single value of a complex type (e.g.
Concrete implementation of
BaseWriter.ComplexWriter.Composite consumer which hold all consumers.
Composite consumer which hold all consumers.
A composite vector comparator compares a number of vectors by a number of inner comparators.
The codec for compression/decompression.
Factory to create compression codec.
Utilities for data compression/decompression.
Compression codec types corresponding to flat buffer implementation in
CompressionType.String constants used for metadata returned on Vectors.
Interface that is used to consume values from avro decoder.
An
ExecutorService that propagates the Context.Method option for supplying credentials to method calls.
An opaque object that can be used to filter a list of streams available from a server.
Utilities for rounding data size.
Date is either a 32-bit or 64-bit signed integer type representing an
elapsed time since UNIX epoch (1970-01-01), stored in either of two units:
* Milliseconds (64 bits) indicating UNIX time elapsed since the epoch (no
leap seconds), where the values are evenly divisible by 86400000
* Days (32 bits) since the UNIX epoch
Consumer which consume date type values from
ResultSet.A column binder for 32-bit dates.
Source code generated using FreeMarker template ValueHolders.java
Source code generated using FreeMarker template ComplexReaders.java
Source code generated using FreeMarker template ComplexReaders.java
DateDayVector implements a fixed width (4 bytes) vector of date values which could be null.
A column binder for 64-bit dates.
Source code generated using FreeMarker template ValueHolders.java
Source code generated using FreeMarker template ComplexReaders.java
Source code generated using FreeMarker template ComplexReaders.java
DateMilliVector implements a fixed width vector (8 bytes) of date values which could be null.
Resolutions that dates can be stored at.
Utility class for Date, DateTime, TimeStamp, Interval data types.
Exact decimal value represented as an integer value in two's
complement.
A binder for 128-bit decimals.
A binder for 256-bit decimals.
Consumer which consume decimal type values from
ResultSet.Source code generated using FreeMarker template ValueHolders.java
Source code generated using FreeMarker template ComplexReaders.java
Source code generated using FreeMarker template ComplexReaders.java
Decimal256Vector implements a fixed width vector (32 bytes) of decimal values which could be
null.
Consumer which consume decimal type values from
ResultSet.Source code generated using FreeMarker template ValueHolders.java
Source code generated using FreeMarker template ComplexReaders.java
Source code generated using FreeMarker template ComplexReaders.java
Utility methods for configurable precision Decimal values (e.g.
DecimalVector implements a fixed width vector (16 bytes) of decimal values which could be null.
The default Allocation Manager Factory for a module.
A class for choosing the default allocation manager.
The allocation manager type.
The default rounding policy.
Default comparator implementations for different types of vectors.
Default comparator for bit type.
Default comparator for bytes.
Default comparator for DateDay type.
Default comparator for DateMilli type.
Default comparator for Decimal256 type.
Default comparator for Decimal type.
Default comparator for Duration type.
Default comparator for
FixedSizeBinaryVector.Default comparator for
RepeatedValueVector.Default comparator for float type.
Default comparator for double type.
Default comparator for 32-bit integers.
Default comparator for IntervalDay type.
Default comparator for long integers.
Default comparator for
NullVector.Default comparator for
RepeatedValueVector.Default comparator for short integers.
Default comparator for TimeMicro type.
Default comparator for TimeMilli type.
Default comparator for TimeNano type.
Default comparator for TimeSec type.
Default comparator for TimeSec type.
Default comparator for unsigned bytes.
Default comparator for unsigned short integer.
Default comparator for unsigned integer.
Default comparator for unsigned long integer.
Default comparator for
VariableWidthVector.ValueHolder for Dense Union Vectors.Source code generated using FreeMarker template DenseUnionReader.java
Vector that support density aware initial capacity settings.
A dictionary (integer to Value mapping) that is used to facilitate dictionary encoding
compression.
For sending dictionary encoding information.
A dictionary builder is intended for the scenario frequently encountered in practice: the
dictionary is not known a priori, so it is generated dynamically.
A dictionary encoder translates one vector into another one based on a dictionary vector.
Encoder/decoder for Dictionary encoded
ValueVector.A POJO representation of Arrow Dictionary metadata.
HashTable used for Dictionary encoding.
----------------------------------------------------------------------
Dictionary encoding metadata
Maintained for forwards compatibility, in the future
Dictionaries might be explicit maps between integers and values
allowing for non-contiguous index values
A manager for association of dictionary IDs to their corresponding
Dictionary.Implementation of
DictionaryProvider that is backed by a hash-map.Utility methods for working with Dictionaries used in Dictionary encodings.
Consumer which consume double type values from
ResultSet.Source code generated using FreeMarker template ValueHolders.java
Source code generated using FreeMarker template ComplexReaders.java
Source code generated using FreeMarker template ComplexReaders.java
DurationVector implements a fixed width vector (8 bytes) of a configurable TimeUnit granularity
duration values which could be null.
Simple server that echoes back data received.
Handler for each client connection to the server.
Vector for which each data element resides in a continuous memory region, so it can be pointed to
by an
ArrowBufPointer.Iterator for traversing elements of a
ElementAddressableVector.A helper class that is used to track and populate empty values in repeated value vectors.
----------------------------------------------------------------------
Endianness of the platform producing the data
metadata container specific to the binary metadata held in the grpc trailer.
A registry of recognized extension types.
A vector that wraps an underlying vector, used to help implement extension types.
Interface for serializing to FlatBuffers.
Utility methods for FBSerializables.
Represents Arrow Features that might not have full support
within implementations.
----------------------------------------------------------------------
A field represents a named column in a record / row batch or child of a
nested type.
A POJO abstraction for the Flatbuffer description of Vector Type.
----------------------------------------------------------------------
Data structures for describing a table row batch (a collection of
equal-length Arrow arrays)
Metadata about a field at some level of a nested type tree (but not
its children).
Composite of all Reader types (e.g.
POJO representation of an Arrow field type.
A vector corresponding to a Field in the schema.
Composite of all writer types.
Application that verifies data can be round-tripped through a file.
Converts an Arrow file to an Arrow stream.
A binder for fixed-width binary types.
Source code generated using FreeMarker template ValueHolders.java
Source code generated using FreeMarker template ComplexReaders.java
Source code generated using FreeMarker template ComplexReaders.java
FixedSizeBinaryVector implements a fixed width vector of binary values which could be null.
A ListVector where every list value is of the same size.
Default in-place sorter for fixed-width vectors.
Default out-of-place sorter for fixed-width vectors.
Interface for all fixed width
ElementAddressableVector (e.g.
An opaque action specific for the service.
An opaque action specific for the service.
Describes an available action, including both the name used for execution
along with a short description of the purpose of the action.
Describes an available action, including both the name used for execution
along with a short description of the purpose of the action.
A message for doing simple auth.
A message for doing simple auth.
The request of the CancelFlightInfo action.
The request of the CancelFlightInfo action.
The result of the CancelFlightInfo action.
The result of the CancelFlightInfo action.
The result of a cancel operation.
Request message for the "Close Session" action.
Request message for the "Close Session" action.
The result of closing a session.
The result of closing a session.
Protobuf enum
arrow.flight.protocol.CloseSessionResult.Status
A service specific expression that can be used to return a limited set
of available Arrow Flight streams.
A service specific expression that can be used to return a limited set
of available Arrow Flight streams.
Protobuf type
arrow.flight.protocol.EmptyProtobuf type
arrow.flight.protocol.Empty
A batch of Arrow data as part of a stream of batches.
A batch of Arrow data as part of a stream of batches.
The name or tag for a Flight.
The name or tag for a Flight.
Describes what type of descriptor is defined.
A particular stream or split associated with a flight.
A particular stream or split associated with a flight.
The access coordinates for retrieval of a dataset.
The access coordinates for retrieval of a dataset.
EXPERIMENTAL: A request to access the session options for the current server session.
EXPERIMENTAL: A request to access the session options for the current server session.
EXPERIMENTAL: The result containing the current server session options.
EXPERIMENTAL: The result containing the current server session options.
The request that a client provides to a server on handshake.
The request that a client provides to a server on handshake.
Protobuf type
arrow.flight.protocol.HandshakeResponseProtobuf type
arrow.flight.protocol.HandshakeResponse
A location where a Flight service will accept retrieval of a particular
stream given a ticket.
A location where a Flight service will accept retrieval of a particular
stream given a ticket.
The information to process a long-running query.
The information to process a long-running query.
The response message associated with the submission of a DoPut.
The response message associated with the submission of a DoPut.
The request of the RenewFlightEndpoint action.
The request of the RenewFlightEndpoint action.
An opaque result returned after executing an action.
An opaque result returned after executing an action.
Wrap the result of a getSchema call
Wrap the result of a getSchema call
EXPERIMENTAL: Union of possible value types for a Session Option to be set to.
EXPERIMENTAL: Union of possible value types for a Session Option to be set to.
Protobuf type
arrow.flight.protocol.SessionOptionValue.StringListValueProtobuf type
arrow.flight.protocol.SessionOptionValue.StringListValue
EXPERIMENTAL: A request to set session options for an existing or new (implicit)
server session.
EXPERIMENTAL: A request to set session options for an existing or new (implicit)
server session.
EXPERIMENTAL: The results (individually) of setting a set of session options.
EXPERIMENTAL: The results (individually) of setting a set of session options.
Protobuf type
arrow.flight.protocol.SetSessionOptionsResult.ErrorProtobuf type
arrow.flight.protocol.SetSessionOptionsResult.ErrorProtobuf enum
arrow.flight.protocol.SetSessionOptionsResult.ErrorValue
An opaque identifier that the service can use to retrieve a particular
portion of a stream.
An opaque identifier that the service can use to retrieve a particular
portion of a stream.
An implementation of the Flight headers interface for headers.
Client for Flight services.
A builder for Flight clients.
Interface for writers to an Arrow data stream.
A pair of a reader and a writer for a DoExchange call.
A handler for server-sent application metadata messages during a Flight DoPut operation.
Client-side middleware for Flight.
A factory for client middleware instances.
String constants relevant to flight implementations.
An identifier for a particular set of data.
POJO to convert to/from the underlying protobuf FlightEndpoint.
Builder for FlightEndpoint.
Typed StreamListener for renewFlightEndpoint.
Exposes Flight GRPC service & client.
A POJO representation of a FlightInfo, metadata associated with a set of data records.
Builder for FlightInfo.
All the RPC methods available in Flight.
API to Implement an Arrow Flight producer.
Call-specific context.
An interface for sending Arrow data back to a client.
Callbacks for pushing objects to a receiver.
An exception raised from a Flight RPC.
Generic server of flight data that is customized via construction with delegate classes for the
actual logic.
A builder for Flight servers.
Server-side middleware for Flight calls.
A factory for Flight server middleware.
A key for Flight server middleware.
A flight service is an endpoint for retrieving or storing Arrow data.
A flight service is an endpoint for retrieving or storing Arrow data.
A stub to allow clients to do synchronous rpc calls to service FlightService.
A stub to allow clients to do ListenableFuture-style rpc calls to service FlightService.
Base class for the server implementation of the service FlightService.
A stub to allow clients to do asynchronous rpc calls to service FlightService.
Request message for the "BeginSavepoint" action.
Request message for the "BeginSavepoint" action.
The result of a "BeginSavepoint" action.
The result of a "BeginSavepoint" action.
Request message for the "BeginTransaction" action.
Request message for the "BeginTransaction" action.
The result of a "BeginTransaction" action.
The result of a "BeginTransaction" action.
Deprecated.
Request message for the "CancelQuery" action.
Deprecated.
Deprecated.
The result of cancelling a query.
Protobuf enum
arrow.flight.protocol.sql.ActionCancelQueryResult.CancelResultDeprecated.
Request message for the "ClosePreparedStatement" action on a Flight SQL enabled backend.
Request message for the "ClosePreparedStatement" action on a Flight SQL enabled backend.
Request message for the "CreatePreparedStatement" action on a Flight SQL enabled backend.
Request message for the "CreatePreparedStatement" action on a Flight SQL enabled backend.
Wrap the result of a "CreatePreparedStatement" or "CreatePreparedSubstraitPlan" action.
Wrap the result of a "CreatePreparedStatement" or "CreatePreparedSubstraitPlan" action.
Request message for the "CreatePreparedSubstraitPlan" action on a Flight SQL enabled backend.
Request message for the "CreatePreparedSubstraitPlan" action on a Flight SQL enabled backend.
Request message for the "EndSavepoint" action.
Request message for the "EndSavepoint" action.
Protobuf enum
arrow.flight.protocol.sql.ActionEndSavepointRequest.EndSavepoint
Request message for the "EndTransaction" action.
Request message for the "EndTransaction" action.
Protobuf enum
arrow.flight.protocol.sql.ActionEndTransactionRequest.EndTransaction
Represents a request to retrieve the list of catalogs on a Flight SQL enabled backend.
Represents a request to retrieve the list of catalogs on a Flight SQL enabled backend.
Represents a request to retrieve a description of the foreign key columns in the given foreign key table that
reference the primary key or the columns representing a unique constraint of the parent table (could be the same
or a different table) on a Flight SQL enabled backend.
Represents a request to retrieve a description of the foreign key columns in the given foreign key table that
reference the primary key or the columns representing a unique constraint of the parent table (could be the same
or a different table) on a Flight SQL enabled backend.
Represents a request to retrieve the list of database schemas on a Flight SQL enabled backend.
Represents a request to retrieve the list of database schemas on a Flight SQL enabled backend.
Represents a request to retrieve a description of the foreign key columns that reference the given table's
primary key columns (the foreign keys exported by a table) of a table on a Flight SQL enabled backend.
Represents a request to retrieve a description of the foreign key columns that reference the given table's
primary key columns (the foreign keys exported by a table) of a table on a Flight SQL enabled backend.
Represents a request to retrieve the foreign keys of a table on a Flight SQL enabled backend.
Represents a request to retrieve the foreign keys of a table on a Flight SQL enabled backend.
Represents a request to retrieve the primary keys of a table on a Flight SQL enabled backend.
Represents a request to retrieve the primary keys of a table on a Flight SQL enabled backend.
Represents a metadata request.
Represents a metadata request.
Represents a request to retrieve the list of tables, and optionally their schemas, on a Flight SQL enabled backend.
Represents a request to retrieve the list of tables, and optionally their schemas, on a Flight SQL enabled backend.
Represents a request to retrieve the list of table types on a Flight SQL enabled backend.
Represents a request to retrieve the list of table types on a Flight SQL enabled backend.
Represents a request to retrieve information about data type supported on a Flight SQL enabled backend.
Represents a request to retrieve information about data type supported on a Flight SQL enabled backend.
Represents an instance of executing a prepared statement.
Represents an instance of executing a prepared statement.
Represents a SQL update query.
Represents a SQL update query.
Represents a bulk ingestion request.
Represents a bulk ingestion request.
Options for table definition behavior
Options for table definition behavior
The action to take if the target table already exists
The action to take if the target table does not exist
Represents a SQL query.
Represents a SQL query.
Represents a Substrait plan.
Represents a Substrait plan.
Represents a SQL update query.
Represents a SQL update query.
An *optional* response returned when `DoPut` is called with `CommandPreparedStatementQuery`.
An *optional* response returned when `DoPut` is called with `CommandPreparedStatementQuery`.
Returned from the RPC call DoPut when a CommandStatementUpdate,
CommandPreparedStatementUpdate, or CommandStatementIngest was
in the request, containing results from the update.
Returned from the RPC call DoPut when a CommandStatementUpdate,
CommandPreparedStatementUpdate, or CommandStatementIngest was
in the request, containing results from the update.
Protobuf enum
arrow.flight.protocol.sql.NullableProtobuf enum
arrow.flight.protocol.sql.Searchable
Options for CommandGetSqlInfo.
Protobuf enum
arrow.flight.protocol.sql.SqlNullOrderingProtobuf enum
arrow.flight.protocol.sql.SqlOuterJoinsSupportLevelProtobuf enum
arrow.flight.protocol.sql.SqlSupportedCaseSensitivityProtobuf enum
arrow.flight.protocol.sql.SqlSupportedElementActionsProtobuf enum
arrow.flight.protocol.sql.SqlSupportedGroupByProtobuf enum
arrow.flight.protocol.sql.SqlSupportedPositionedCommandsProtobuf enum
arrow.flight.protocol.sql.SqlSupportedResultSetConcurrencyProtobuf enum
arrow.flight.protocol.sql.SqlSupportedResultSetTypeProtobuf enum
arrow.flight.protocol.sql.SqlSupportedSubqueries
The level of support for Flight SQL transaction RPCs.
Protobuf enum
arrow.flight.protocol.sql.SqlSupportedTransactionsProtobuf enum
arrow.flight.protocol.sql.SqlSupportedUnionsProtobuf enum
arrow.flight.protocol.sql.SqlSupportsConvertProtobuf enum
arrow.flight.protocol.sql.SqlTransactionIsolationLevel
An embedded message describing a Substrait plan to execute.
An embedded message describing a Substrait plan to execute.
Protobuf enum
arrow.flight.protocol.sql.SupportedAnsi92SqlGrammarLevelProtobuf enum
arrow.flight.protocol.sql.SupportedSqlGrammar
Represents a ticket resulting from GetFlightInfo with a CommandStatementQuery.
Represents a ticket resulting from GetFlightInfo with a CommandStatementQuery.
Protobuf enum
arrow.flight.protocol.sql.UpdateDeleteRules
The JDBC/ODBC-defined type of any object.
Detailed subtype information for XDBC_TYPE_DATETIME and XDBC_TYPE_INTERVAL.
Flight client with Flight SQL semantics.
Class to encapsulate Flight SQL bulk ingest request options.
Helper class to encapsulate Flight SQL prepared statement logic.
A handle for an active savepoint.
A wrapper around a Substrait plan and a Substrait version.
A handle for an active transaction.
Flight SQL Client Demo CLI Application.
Metadata for a column in a Flight SQL query.
Builder of FlightSqlColumnMetadata, used on FlightSqlProducer implementations.
API to Implement an Arrow Flight SQL producer.
Default schema templates for the
FlightSqlProducer.Utilities to work with Flight SQL semantics.
A status code describing the result of a Flight call.
An adaptor between protobuf streams and flight data streams.
Provides a callback to cancel a process that is in progress.
Provides a interface to request more items from a stream producer.
Lifted from Apache Parquet MR project:
https://github.com/apache/parquet-mr/blob/e87b80308869b77f914fcfd04364686e11158950/parquet-column/src/main/java/org/apache/parquet/schema/Float16.java
Changes made:
Modify the data type input from Parquet-MR Binary (toFloat(Binary b)) to Arrow Java short
(toFloat(short b))
Expose NAN and POSITIVE_INFINITY variables
The class is a utility class to manipulate half-precision 16-bit IEEE 754 floating
point data types (also called fp16 or binary16).
Source code generated using FreeMarker template ValueHolders.java
Source code generated using FreeMarker template ComplexReaders.java
Source code generated using FreeMarker template ComplexReaders.java
Float2Vector implements a fixed width (2 bytes) vector of short values which could be null.
A binder for 32-bit floats.
Source code generated using FreeMarker template ValueHolders.java
Source code generated using FreeMarker template ComplexReaders.java
Source code generated using FreeMarker template ComplexReaders.java
Float4Vector implements a fixed width vector (4 bytes) of float values which could be null.
A binder for 64-bit floats.
Source code generated using FreeMarker template ValueHolders.java
Source code generated using FreeMarker template ComplexReaders.java
Source code generated using FreeMarker template ComplexReaders.java
Float8Vector implements a fixed width vector (8 bytes) of double values which could be null.
Consumer which consume float type values from
ResultSet.Precisions of primitive floating point numbers.
The interface for vectors with floating point values.
----------------------------------------------------------------------
Arrow File metadata
EXPERIMENTAL: a memory allocation that does not come from a BufferAllocator, but rather an
outside source (like JNI).
An out-of-place sorter for vectors of arbitrary type, with time complexity O(n*log(n)).
Generates and caches bearer tokens from user credentials.
Helper class to generate test data for Nullable fixed and variable width scalar vectors.
Enable access to ReadableBuffer directly to copy data from a BufferInputStream into a target
ByteBuffer/ByteBuf.
A request to get current session options.
A request to view the currently-set options for the current server session.
Typed StreamListener for getSessionOptions.
This class builds the dictionary based on a hash table.
Dictionary encoder based on hash table.
Method option for supplying headers to method calls.
Utility class that can be used to log activity within a class for later logging and debugging.
Sorter for the indices of a vector.
Basic interface for sorting a vector in-place.
A column binder for 32-bit integers.
Consumer which consume int type values from
ResultSet.Application for cross language integration testing.
Source code generated using FreeMarker template ValueHolders.java
Source code generated using FreeMarker template ComplexReaders.java
Source code generated using FreeMarker template ComplexReaders.java
IntervalDayVector implements a fixed width vector (8 bytes) of interval (days and milliseconds)
values which could be null.
Source code generated using FreeMarker template ValueHolders.java
Source code generated using FreeMarker template ComplexReaders.java
Source code generated using FreeMarker template ComplexReaders.java
IntervalMonthDayNanoVector implements a fixed width vector (16 bytes) of interval (month, days
and nanoseconds) values which could be null.
Resolutions for Interval Vectors.
Source code generated using FreeMarker template ValueHolders.java
Source code generated using FreeMarker template ComplexReaders.java
Source code generated using FreeMarker template ComplexReaders.java
IntervalYearVector implements a fixed width (4 bytes) vector of interval (years and months)
values which could be null.
Source code generated using FreeMarker template ValueHolders.java
Source code generated using FreeMarker template ComplexReaders.java
Source code generated using FreeMarker template ComplexReaders.java
IntVector implements a fixed width (4 bytes) vector of integer values which could be null.
Exception indicating a problem with an Arrow File
(https://arrow.apache.org/docs/format/IPC.html#file-format).
The extension metadata was malformed.
IPC options, now only use for write.
An abstraction that is used to consume values from
ResultSet.Exception while consuming JDBC data.
This class represents the information about a JDBC ResultSet Field that is needed to construct an
ArrowType.A binder binds JDBC prepared statement parameters to rows of Arrow data from a VectorSchemaRoot.
A builder for a
JdbcParameterBinder.Utility class to convert JDBC objects to columnar Arrow format objects.
This class configures the JDBC-to-Arrow conversion process.
Interface for a function that gets a JDBC consumer for the given values.
This class builds
JdbcToArrowConfigs.Class that does most of the work to convert JDBC ResultSet data into Arrow columnar format Vector
objects.
A reader for JSON files that translates them into vectors.
A writer that converts binary Vectors into an internal, unstable JSON format suitable
for integration testing.
Configuration POJO for writing JSON files.
Extension of
ArrayList that JsonStringArrayList.toString() method returns the serialized JSON
version of its members (or throws an exception if they can't be converted to JSON).Simple class that extends the regular java.util.HashMap but overrides the toString() method of
the HashMap class to produce a JSON string instead
----------------------------------------------------------------------
user defined key value pairs to add custom metadata to arrow
key namespacing is the responsibility of the user
Same as Binary, but with 64-bit offsets, allowing to represent
extremely large data values.
Same as List, but with 64-bit offsets, allowing to represent
extremely large data values.
A list vector contains lists of a specific type of elements.
Same as ListView, but with 64-bit offsets and sizes, allowing to represent
extremely large data values.
A large list view vector contains lists of a specific type of elements.
Contains utilities for dealing with a 64-bit address base.
Same as Utf8, but with 64-bit offsets, allowing to represent
extremely large data values.
Source code generated using FreeMarker template ValueHolders.java
Source code generated using FreeMarker template ComplexReaders.java
Source code generated using FreeMarker template ComplexReaders.java
LargeVarBinaryVector implements a large variable width vector of binary values which could be
NULL.
Source code generated using FreeMarker template ValueHolders.java
Source code generated using FreeMarker template ComplexReaders.java
Source code generated using FreeMarker template ComplexReaders.java
LargeVarCharVector implements a variable width vector of VARCHAR values which could be NULL.
Dictionary encoder based on linear search.
A column binder for list of primitive values.
Sub fields encoder/decoder for Dictionary encoded
BaseListVector.A list vector contains lists of a specific type of elements.
Represents the same logical types that List can, but contains offsets and
sizes allowing for writes in any order and sharing of child values among
list values.
A list view vector contains lists of a specific type of elements.
A URI where a Flight stream is available.
Constants representing well-known URI schemes for Flight services.
Highly specialized IdentityHashMap that implements only partial Map APIs.
Compression codec for the LZ4 algorithm.
A Map is a logical nested type that is represented as
List<entries: Struct<key: K, value: V>>
In this layout, the keys and values are each respectively contiguous.
A column binder for map of primitive values.
Consumer which consume map type values from
ResultSet.A MapVector is used to store entries of key/value pairs.
An implementation of a map that supports constant time look-up by a generic key or an ordinal.
An implementation of map that supports constant time look-up by a generic key or an ordinal.
Utilities for memory related operations.
Reads a sequence of messages using a ReadChannel.
----------------------------------------------------------------------
The root Message type
This union enables us to easily send different message types without
redundant storage, and in the future we can easily add new message types.
Class to hold resulting Message metadata and buffer containing the serialized Flatbuffer message
when reading messages from a ReadChannel.
Class to hold the Message metadata and body data when reading messages through a
MessageChannelReader.
Utility class for serializing Messages.
A mutable adapter between the gRPC Metadata object and the Flight headers interface.
Given a field, checks that no Union fields are present.
Metadata version for Arrow metadata.
An implementation of a multimap that supports constant time look-up by a generic key or an
ordinal.
Implementation of the Murmur hashing algorithm.
The default compression codec that does no compression.
The default factory that creates a
NoCompressionCodec.A struct vector that has no null values (and no validity buffer).
TransferPair for this this class.A
FlightProducer that throws on all operations.A
FlightSqlProducer that throws on all FlightSql-specific operations.A helper to facilitate easier anonymous subclass declaration.
A
FlightProducer.StreamListener that does nothing for all callbacks.These are stored in the flatbuffer in the Type union below
Source code generated using FreeMarker template ValueHolders.java
Source code generated using FreeMarker template ValueHolders.java
A ColumnBinder that checks for nullability before deferring to a type-specific binder.
Source code generated using FreeMarker template ValueHolders.java
Source code generated using FreeMarker template ValueHolders.java
Source code generated using FreeMarker template ValueHolders.java
Source code generated using FreeMarker template ValueHolders.java
Source code generated using FreeMarker template ValueHolders.java
Source code generated using FreeMarker template ValueHolders.java
Source code generated using FreeMarker template ValueHolders.java
Source code generated using FreeMarker template ValueHolders.java
Source code generated using FreeMarker template ValueHolders.java
Source code generated using FreeMarker template ValueHolders.java
Source code generated using FreeMarker template ValueHolders.java
Source code generated using FreeMarker template ValueHolders.java
Source code generated using FreeMarker template ValueHolders.java
Source code generated using FreeMarker template ValueHolders.java
Source code generated using FreeMarker template ValueHolders.java
Source code generated using FreeMarker template ValueHolders.java
An
FieldReader for reading nullable struct
vectors.A factory for
NullableStructWriter instances.Source code generated using FreeMarker template ValueHolders.java
Source code generated using FreeMarker template ValueHolders.java
Source code generated using FreeMarker template ValueHolders.java
Source code generated using FreeMarker template ValueHolders.java
Source code generated using FreeMarker template ValueHolders.java
Source code generated using FreeMarker template ValueHolders.java
Source code generated using FreeMarker template ValueHolders.java
Source code generated using FreeMarker template ValueHolders.java
Source code generated using FreeMarker template ValueHolders.java
Source code generated using FreeMarker template ValueHolders.java
Source code generated using FreeMarker template ValueHolders.java
Source code generated using FreeMarker template ValueHolders.java
Source code generated using FreeMarker template ValueHolders.java
Source code generated using FreeMarker template ValueHolders.java
Source code generated using FreeMarker template ValueHolders.java
Source code generated using FreeMarker template ValueHolders.java
Source code generated using FreeMarker template ValueHolders.java
Source code generated using FreeMarker template ValueHolders.java
Source code generated using FreeMarker template ValueHolders.java
Source code generated using FreeMarker template ValueHolders.java
Source code generated using FreeMarker template ValueHolders.java
Configuration class to determine if null checking should be enabled or disabled for the "get"
methods.
Consumer which consume null type values from ResultSet.
Source code generated using FreeMarker template NullReader.java
A null type vector.
A
ObjectMapper factory to read/write JSON.Opaque is a placeholder for a type from an external (usually non-Arrow) system that could not be
interpreted.
Opaque is a wrapper for (usually binary) data from an external (often non-Arrow) system that
could not be interpreted.
An interface for writing data to a peer, client or server.
Indicates memory could not be allocated for Arrow buffers.
Basic interface for sorting a vector out-of-place.
An exception that is used to signal that allocation request in bytes is greater than the maximum
allowed by
allocator.An
OwnershipTransferResult indicating no transfer needed.The result of transferring an
ArrowBuf between BufferAllocators.Search for a value in the vector by multiple threads.
Partial sum related utilities.
Combination of Period and Duration for representing this interval type as a POJO.
A POJO representation of the execution of a long-running query.
Get and set position in a particular data structure.
Static convenience methods that help a method or constructor check whether it was invoked
correctly (whether its preconditions have been met).
Implementation of MapWithOrdinal that allows for promotion to multimap when duplicate fields
exist.
Vector that can store multiple FieldType vectors as children.
This FieldWriter implementation delegates all FieldWriter API calls to an inner FieldWriter.
This FieldWriter implementation delegates all FieldWriter API calls to an inner FieldWriter.
A message from the server during a DoPut operation.
Wrapper for the parameters of comparing a range of values in two vectors.
Visitor to compare a range of values for vectors.
Adapter around
ReadableByteChannel that reads into ArrowBufs.A data header describing the shared memory layout of a "record" or "row"
batch.
ReferenceManager is the reference count for one or more allocations.
A request to extend the expiration time of a FlightEndpoint.
A
ValueVector mix-in that can be used in conjunction with RepeatedValueVector subtypes.ValueHolder for a nested ListVector.ValueHolder for a list of structs.An abstraction representing repeated value vectors.
A
ValueVector mix-in that can be used in conjunction with
variable RepeatedValueVector subtypes (e.g.Tracks variables about the current request.
Adapter for holding key value pairs.
Opaque result returned after executing an action.
A lightweight, automatically expanding container for holding byte data.
A wrapper around byte arrays for repeated writing.
A root allocator for using direct memory for Arrow Vectors/Arrays.
The policy for rounding the buffer size, to improve performance and avoid memory fragmentation.
Row is a positionable, immutable cursor backed by a
Table.Contains two child arrays, run_ends and values.
A run-end encoded vector contains only two child vectors: a run_end vector of type int and a
values vector of any type.
----------------------------------------------------------------------
A Schema describes the columns in a row batch
An Arrow Schema.
Callback for when the Schema for the Vector changes (generally happens when a vector is promoted
to a union type from a single value type).
Thrown when child vectors (e.g.
Opaque result returned after executing a getSchema request.
Schema utility class including serialization and deserialization.
Dictionary encoder based on searching.
This class builds the dictionary based on a binary search tree.
An
ReadChannel that supports seeking to a random position.The rounding policy that each buffer size must a multiple of the segment size.
Deprecated.
As of 14.0.0.
Interface for a server implementations to send back authentication messages back to the client.
GRPC Interceptor for performing authentication.
Contains utility methods for integrating authorization into a GRPC stream.
An interceptor for specifying the number of bytes that can be queued before a call with an output
stream gets blocked by backpressure.
Middleware that's used to validate credentials during the handshake and verify the bearer token
in subsequent requests.
Factory for accessing ServerAuthMiddleware.
Middleware that's used to extract and pass headers to the server during requests.
Factory for accessing ServerHeaderMiddleware.
An adapter between Flight middleware and a gRPC interceptor.
A combination of a middleware Key and factory.
Middleware for handling Flight SQL Sessions including session cookie handling.
Factory for managing and accessing ServerSessionMiddleware.
A thread-safe container for named SessionOptionValues.
A union-like container interface for supported session option value types.
Abstract factory for concrete SessionOptionValue instances.
A visitor interface to access SessionOptionValue's contained value.
A request to set option(s) in an existing or implicitly-created server session.
The result of attempting to set a set of session options.
Per-option extensible error response container.
Error status value for per-option errors.
Typed StreamListener for setSessionOptions.
A simple hasher that calculates the hash code of integers as is, and does not perform any
finalization.
An implementation of
AbstractFieldReader for lists vectors.FieldReader for a single NonNullableStructVector.Consumer which skip (throw away) data from the decoder.
Adapter function to skip (throw away) data from the decoder.
A column binder for 8-bit integers.
Consumer which consume smallInt type values from
ResultSet.Source code generated using FreeMarker template ValueHolders.java
Source code generated using FreeMarker template ComplexReaders.java
Source code generated using FreeMarker template ComplexReaders.java
SmallIntVector implements a fixed width (2 bytes) vector of short values which could be null.
Compressed Sparse format, that is matrix-specific.
----------------------------------------------------------------------
EXPERIMENTAL: Data structures for sparse tensors
Coordinate (COO) format of sparse tensor index.
Compressed Sparse Fiber (CSF) sparse tensor index.
Auxiliary class meant to facilitate the implementation of
FlightSqlProducer.getStreamSqlInfo(org.apache.arrow.flight.sql.impl.FlightSql.CommandGetSqlInfo, org.apache.arrow.flight.FlightProducer.CallContext, org.apache.arrow.flight.FlightProducer.ServerStreamListener).Utility class for
FlightSql.SqlInfo and FlightSqlClient.getSqlInfo(org.apache.arrow.flight.sql.impl.FlightSql.SqlInfo...) option parsing.Stable sorter.
Convenient way of obtaining and manipulating stack traces for debugging.
Utility methods for state machines based on enums.
Utilities to adapt gRPC and Flight status objects.
Converts an Arrow stream to an Arrow file.
A Struct_ in the flatbuffer metadata is the same as an Arrow Struct
(according to the physical memory layout).
Concrete implementation of
BaseWriter.StructOrListWriter.Sub fields encoder/decoder for Dictionary encoded
StructVector.A Struct vector consists of nullability/validity buffer and children vectors that make up the
struct's fields.
A listener for server-sent application metadata messages during a Flight DoPut.
Table is an immutable tabular data structure.
A helper class to reference a table to be passed to the flight sql client.
----------------------------------------------------------------------
Data structures for dense tensors
Shape data for a single axis in a tensor
A simplified byte wrapper similar to Hadoop's Text class without all the dependencies.
JSON serializer for
Text.Endpoint for a particular stream.
Time is either a 32-bit or 64-bit signed integer type representing an
elapsed time since midnight, stored in either of four units: seconds,
milliseconds, microseconds or nanoseconds.
A binder for 32-bit time types.
A binder for 64-bit time types.
Consumer which consume time type values from
ResultSet.Source code generated using FreeMarker template ValueHolders.java
Source code generated using FreeMarker template ComplexReaders.java
Source code generated using FreeMarker template ComplexReaders.java
TimeMicroVector implements a fixed width vector (8 bytes) of time (microsecond resolution) values
which could be null.
Source code generated using FreeMarker template ValueHolders.java
Source code generated using FreeMarker template ComplexReaders.java
Source code generated using FreeMarker template ComplexReaders.java
TimeMilliVector implements a fixed width (4 bytes) vector of time (millisecond resolution) values
which could be null.
Source code generated using FreeMarker template ValueHolders.java
Source code generated using FreeMarker template ComplexReaders.java
Source code generated using FreeMarker template ComplexReaders.java
TimeNanoVector implements a fixed width vector (8 bytes) of time (nanosecond resolution) values
which could be null.
Source code generated using FreeMarker template ValueHolders.java
Source code generated using FreeMarker template ComplexReaders.java
Source code generated using FreeMarker template ComplexReaders.java
TimeSecVector implements a fixed width (4 bytes) vector of time (seconds resolution) values which
could be null.
Timestamp is a 64-bit signed integer representing an elapsed time since a
fixed epoch, stored in either of four units: seconds, milliseconds,
microseconds or nanoseconds, and is optionally annotated with a timezone.
A column binder for timestamps.
Consumer which consume timestamp type values from
ResultSet.Source code generated using FreeMarker template ValueHolders.java
Source code generated using FreeMarker template ComplexReaders.java
Source code generated using FreeMarker template ComplexReaders.java
Source code generated using FreeMarker template ValueHolders.java
Source code generated using FreeMarker template ComplexReaders.java
Source code generated using FreeMarker template ComplexReaders.java
TimeStampMicroTZVector implements a fixed width vector (8 bytes) of timestamp (microsecond
resolution) values which could be null.
TimeStampMicroVector implements a fixed width vector (8 bytes) of timestamp (microsecond
resolution) values which could be null.
Source code generated using FreeMarker template ValueHolders.java
Source code generated using FreeMarker template ComplexReaders.java
Source code generated using FreeMarker template ComplexReaders.java
Source code generated using FreeMarker template ValueHolders.java
Source code generated using FreeMarker template ComplexReaders.java
Source code generated using FreeMarker template ComplexReaders.java
TimeStampMilliTZVector implements a fixed width vector (8 bytes) of timestamp (millisecond
resolution) values which could be null.
TimeStampMilliVector implements a fixed width vector (8 bytes) of timestamp (millisecond
resolution) values which could be null.
Source code generated using FreeMarker template ValueHolders.java
Source code generated using FreeMarker template ComplexReaders.java
Source code generated using FreeMarker template ComplexReaders.java
Source code generated using FreeMarker template ValueHolders.java
Source code generated using FreeMarker template ComplexReaders.java
Source code generated using FreeMarker template ComplexReaders.java
TimeStampNanoTZVector implements a fixed width vector (8 bytes) of timestamp (nanosecond
resolution) values which could be null.
TimeStampNanoVector implements a fixed width vector (8 bytes) of timestamp (nanosecond
resolution) values which could be null.
Source code generated using FreeMarker template ValueHolders.java
Source code generated using FreeMarker template ComplexReaders.java
Source code generated using FreeMarker template ComplexReaders.java
Source code generated using FreeMarker template ValueHolders.java
Source code generated using FreeMarker template ComplexReaders.java
Source code generated using FreeMarker template ComplexReaders.java
TimeStampSecTZVector implements a fixed width vector (8 bytes) of timestamp (seconds resolution)
values which could be null.
TimeStampSecVector implements a fixed width vector (8 bytes) of timestamp (seconds resolution)
values which could be null.
Consumer which consume timestamp (with time zone) type values from
ResultSet.TimeStampVector is an abstract interface for fixed width vector (8 bytes) of timestamp values
which could be null.
Resolutions that times can be stored with.
A column binder for 8-bit integers.
Consumer which consume tinyInt type values from
ResultSet.Source code generated using FreeMarker template ValueHolders.java
Source code generated using FreeMarker template ComplexReaders.java
Source code generated using FreeMarker template ComplexReaders.java
TinyIntVector implements a fixed width (1 bytes) vector of byte values which could be null.
Interface for copying values between a pair of two vectors of the same type.
----------------------------------------------------------------------
Top-level Type value, enabling extensible type-specific metadata.
Visitor to compare type equals for vectors.
The buffer layout of vectors for a given type.
An enumeration of all logical types supported by this library.
The actual enumeration of types.
Source code generated using FreeMarker template ValueHolders.java
Source code generated using FreeMarker template ComplexReaders.java
Source code generated using FreeMarker template ComplexReaders.java
UInt1Vector implements a fixed width (1 bytes) vector of integer values which could be null.
Source code generated using FreeMarker template ValueHolders.java
Source code generated using FreeMarker template ComplexReaders.java
Source code generated using FreeMarker template ComplexReaders.java
UInt2Vector implements a fixed width (2 bytes) vector of integer values which could be null.
Source code generated using FreeMarker template ValueHolders.java
Source code generated using FreeMarker template ComplexReaders.java
Source code generated using FreeMarker template ComplexReaders.java
UInt4Vector implements a fixed width (4 bytes) vector of integer values which could be null.
Source code generated using FreeMarker template ValueHolders.java
Source code generated using FreeMarker template ComplexReaders.java
Source code generated using FreeMarker template ComplexReaders.java
UInt8Vector implements a fixed width vector (8 bytes) of integer values which could be null.
A union is a complex type with children in Field
By default ids in the type vector refer to the offsets in the children
optionally typeIds provides an indirection between the child offset and the type id
for each child `typeIds[offset]` is the id used in the type vector
Reader for fixed size list vectors.
ValueHolder for Union Vectors.FieldReader for list of union types.FieldReader for largeListView of union types.FieldReader for list of union types.FieldReader for listview of union types.Reader for a MapVector.
Writer for MapVectors.
Different memory layouts for Union Vectors.
Source code generated using FreeMarker template UnionReader.java
Allocation manager based on unsafe API.
Unicode with UTF-8 encoding
Logically the same as Utf8, but the internal representation uses a view
struct that contains the string length and either the string's entire data
inline (for small strings) or an inlined prefix, an index of another buffer,
and an offset pointing to a slice in that buffer (for non-small strings).
Utilities for vector validation.
A exception that is thrown when the vector validation fails.
Visitor to validate vector buffers.
Utility for validating vector data.
Utility to validate vector type information.
Visitor to validate vector (without validating data).
Utility class for validating arrow data structures.
Vector value equalizers that regard values as equal if their difference is within a small
threshold (epsilon).
Difference function for float values.
Difference function for double values.
Difference function for floating point values.
Wrapper object for an individual value in Arrow.
An abstraction that is used to store a sequence of values in an individual column.
Utility methods for
ValueVector.Helper interface to generify a value to be included in the map where key is part of the value.
A binder for variable-width binary types.
Source code generated using FreeMarker template ValueHolders.java
Source code generated using FreeMarker template ComplexReaders.java
Source code generated using FreeMarker template ComplexReaders.java
VarBinaryVector implements a variable width vector of binary values which could be NULL.
A binder for variable-width string types.
Consumer which consume varchar type values from
ResultSet.Source code generated using FreeMarker template ValueHolders.java
Source code generated using FreeMarker template ComplexReaders.java
Source code generated using FreeMarker template ComplexReaders.java
VarCharVector implements a variable width vector of VARCHAR values which could be NULL.
A base interface for common functionalities in variable width vectors.
Default sorter for variable-width vectors.
Interface vectors that contain variable width members (e.g.
Utility to append two vectors together.
Utility to add vector values in batch.
Interface for setting a specific index values as defined/valid on a vector.
Visitor to compare vectors equal.
Loads buffers into vectors.
Search for the range of a particular element in the target vector.
Utility for calculating ranks of vector elements.
Remove adjacent equal elements from a vector.
Holder for a set of vectors to be loaded/unloaded.
Utility to append
VectorSchemaRoots with the same schema.Search for a particular element in the vector.
Helper class that handles converting a
VectorSchemaRoot to a ArrowRecordBatch.Compare two values at the given indices in the vectors.
A function to determine if two vectors are equal at specified positions.
Generic visitor to visit a
ValueVector.Tuple of a
ValueVector and an index into a data structure containing the ValueVector.Source code generated using FreeMarker template ValueHolders.java
Source code generated using FreeMarker template ComplexReaders.java
Source code generated using FreeMarker template ComplexReaders.java
ViewVarBinaryVector implements a variable width view vector of binary values which could be NULL.
Source code generated using FreeMarker template ValueHolders.java
Source code generated using FreeMarker template ComplexReaders.java
Source code generated using FreeMarker template ComplexReaders.java
ViewVarCharVector implements a view of a variable width vector of VARCHAR values which could be
NULL.
Annotation to indicate a class member or class is visible only for the purposes of testing and
otherwise should not be referenced by other classes.
Wrapper around a WritableByteChannel that maintains the position as well adding some common
serialization utilities.
A zero length vector of any type.
Compression codec for the ZSTD algorithm.
CancelStatus.