All Classes and Interfaces
Class
Description
Abstract class for catalogs.
The AbstractCatalogStore class is an abstract base class for implementing a catalog store.
Highest abstraction that describes the data type of a value in the table ecosystem.
Heap vector that nullable shared structure.
Contains the shared structure for
ColumnVectors, including NULL information and
dictionary.Helper context that deals with adapted arguments.
Resolved and validated expression for calling an aggregate function.
Base class for a user-defined aggregate function.
Deprecated.
Non-legacy functions can simply omit this wrapper for declarations.
Deprecated.
This exception is considered internal and has been erroneously placed in the *.api
package.
Exception for finding more than one
TableFactory for the given properties.Strategy for inferring and validating an argument using a conjunction of multiple
ArgumentTypeStrategys into one like f(NUMERIC && LITERAL)Strategy for an argument that can be of any type.
Defines the count of accepted arguments (including open intervals) that a function can take.
A hint that provides additional information about an argument.
Type strategy that returns the n-th input argument, mapping it with the provided function.
Declares traits for
ArgumentHint.Strategy for inferring and validating a single input argument type of a function call.
Type strategy that returns a
DataTypes.ARRAY(DataType) with element type equal to the
type of the first argument if it's not nullable or element to add is not nullable, otherwise it
returns DataTypes.ARRAY(DataType) with type equal to the type of the element to add to
array.Array column vector.
An
ArgumentTypeStrategy that checks if the input argument is an ARRAY type and check
whether its' elements are comparable.Base interface of an internal data structure representing data of
ArrayType.Accessor for getting the elements of an array during runtime.
Returns the element of an
LogicalTypeFamily.COLLECTION type.Strategy for an argument that must be an array of strings.
Logical type of an array of elements with same subtype.
A wrapper class of
AsyncTableFunction for asynchronously lookup rows matching the lookup
keys from external system.A provider for creating
AsyncLookupFunction.Base class for a user-defined scalar function which returns results asynchronously.
Base class for a user-defined asynchronous table function.
Deprecated.
Please use
AsyncLookupFunctionProvider to implement asynchronous lookup
table.A data type that does not contain further data types (e.g.
Logical type of an 8-byte signed integer with values from -9,223,372,036,854,775,808 to
9,223,372,036,854,775,807.
A binary implementation of
ArrayData which is backed by MemorySegments.Binary format spanning
MemorySegments.[4 byte(keyArray size in bytes)] + [Key BinaryArray] + [Value BinaryArray].
A lazily binary implementation of
RawValueData which is backed by MemorySegments
and generic Object.An implementation of
RowData which is backed by MemorySegment instead of Object.A basic implementation of
BinaryFormat which describe a section of memory.Utilities for binary data segments which heavily uses
MemorySegment.Logical type of a fixed-length binary string (=a sequence of bytes).
Boolean column vector.
Logical type of a boolean with a (possibly) three-valued logic of
TRUE, FALSE, UNKNOWN.Definition of a built-in function.
Builder for fluent definition of built-in functions.
Dictionary of function definitions for all built-in functions.
The list of the built-in aggregate functions which can be mixed with the Python UDAF.
Byte column vector.
Bytes column vector to get
BytesColumnVector.Bytes, it include original data and offset and length.Bytes data.
Customized trigger for reloading lookup table entries.
Context of
CacheReloadTrigger for getting information about times and triggering
reload.Provides details about a function call during
TypeInference.Resolved and validated call expression for calling a function.
Interface to model a function that performs the casting of a value from one type to another.
This interface is responsible for reading and writing metadata such as database/table/views/UDFs
from a registered catalog.
A common parent that describes the unresolved metadata of a table or view in a catalog.
The kind of
CatalogBaseTable.CatalogChange represents the modification of the catalog.A catalog change to modify the comment.
A catalog change to modify the catalog configuration.
Column statistics of a table or partition.
Column statistics value base class.
Column statistics value of binary type.
Column statistics value of boolean type.
Column statistics value of date type.
Column statistics value of double type.
Column statistics value of long type.
Column statistics value of string type.
Interface of a database in a catalog.
Describes a
Catalog with the catalog name and configuration.A catalog-related, runtime exception.
A factory to create configured catalog instances based on string-based properties.
Context provided when a catalog is created.
Interface for a function in a catalog.
Represents the unresolved metadata of a materialized table in a
Catalog.Builder for configuring and creating instances of
CatalogMaterializedTable.The logical refresh mode of materialized table.
The physical refresh mode of materialized table.
Background refresh pipeline status of materialized table.
Interface for a model in a catalog.
Exception for an operation on a nonexistent catalog.
Represents a partition object in catalog.
Represents a partition spec object in catalog.
Utilities for de/serializing
Catalog objects into a map of string properties.Represents the storage where persists all
Catalogs.A factory to create configured catalog store instances based on string-based properties.
Context provided when a catalog store is created.
A holder for a
CatalogStore instance and the necessary information for creating and
initializing Catalog instances, including a CatalogStoreFactory, a ReadableConfig instance, and a ClassLoader instance.Builder for a fluent definition of a
CatalogStoreHolder.Represents the unresolved metadata of a table in a
Catalog.Builder for configuring and creating instances of
CatalogTable.Statistics for a non-partitioned table or a partition of a partitioned table.
Represents the unresolved metadata of a view in a
Catalog.The set of changes contained in a changelog.
Builder for configuring and creating instances of
ChangelogMode.Logical type of a fixed-length character string.
Class-based data type extractor that supports extraction of clearly identifiable data types for
input and output conversion.
A data type that contains an element type (e.g.
Type strategy that returns a
DataTypes.MULTISET(DataType) with element type equal to the
type of the first argument.Representation of a column in a
ResolvedSchema.Representation of a computed column.
Representation of a metadata column.
Representation of a physical column.
Columnar array to support access to vector column data.
Columnar map to support access to vector column data.
Columnar row to support access to vector column data.
Column statistics.
ColumnStats builder.
Nullable column vector.
Argument type strategy that checks and casts for a common, least restrictive type of all
arguments.
An
InputTypeStrategy that expects that all arguments have a common array type.A collection of
ConfigOption which are consistently used in multiple catalogs.An
InputTypeStrategy that expects that all arguments have a common type.An
InputTypeStrategy that expects that all arguments have a common type.An
InputTypeStrategy that expects that all arguments have a common map type.A collection of
ConfigOption which are consistently used in multiple modules.Type strategy that returns a common, least restrictive type of selected arguments.
An
InputTypeStrategy that checks if all input arguments can be compared with each other
with the minimal provided comparison.Strategy that checks that the argument has a composite type.
Deprecated.
Helper class for
ArgumentCount with constant boundaries.Integrity constraints, generally referred to simply as constraints, define the valid states of
SQL-data by constraining the values in the base tables.
Deprecated.
See
ResolvedSchema and Constraint.Type of the constraint.
Type of the constraint.
Strategy for an argument that must fulfill a given constraint.
Embedded continuous refresh handler of Flink streaming job for materialized table.
Serializer for
ContinuousRefreshHandler.Module of default core metadata in Flink.
Factory for
CoreModule.CreateRefreshWorkflow provides the related information to create periodic refresh
workflow of CatalogMaterializedTable.CreateRefreshWorkflow provides the related information to create refresh workflow of
CatalogMaterializedTable.Exception for trying to create a database that already exists.
Exception for trying to drop on a database that is not empty.
Exception for trying to operate on a database that doesn't exist.
Describes the data type of a value in the table ecosystem.
This type transformation transforms the specified data types to a new one with the expected
conversion class.
Implementation of
DataTypeVisitor that redirects all calls to DataTypeDefaultVisitor.defaultMethod(DataType).Factory for creating fully resolved data types that can be used for planning.
A hint that influences the reflection-based extraction of a
DataType.Indicates that a
DataType can be retrieved from a class that implements this interfaces.A
DataType can be used to declare input and/or output types of operations.Common helper class for resolved and unresolved fields of a row or structured type.
Helper class for defining the field of a row or structured type.
Helper class for defining the resolution of an interval.
Helper class for defining the unresolved field of a row or structured type.
Utilities for handling
DataTypes.The visitor definition of
DataType.A
DataView is a collection type that can be used in the accumulator of an ImperativeAggregateFunction.Class representing a date value in statistics.
Utility functions for datetime types: date, time, timestamp.
Enumeration of time units used to construct an interval.
A range of time units.
Logical type of a date consisting of
year-month-day with values ranging from
0000-01-01 to 9999-12-31.Logical type for a group of day-time interval types.
Supported resolutions of this type.
Decimal column vector.
An internal data structure representing data of
DecimalType.Logical type of a decimal number with fixed precision and scale.
A
Format for a DynamicTableSource for reading rows.Default implementation of a
CatalogMaterializedTable.A catalog model implementation.
Default implementation of a
CatalogTable.Default implementation of
LookupCache.Builder for
DefaultLookupCache.A validated
CatalogModel that is backed by the original metadata coming from the Catalog but resolved by the framework.Deprecated.
This interface will not be supported in the new source design around
DynamicTableSource.Deprecated.
This interface will not be supported in the new source design around
DynamicTableSource.Deprecated.
This interface will not be supported in the new source design around
DynamicTableSource.DeleteRefreshWorkflow provides the related information to delete refresh workflow of
CatalogMaterializedTable.Deprecated.
Descriptor was primarily used for the legacy connector stack and have been
deprecated.Deprecated.
This utility will be dropped soon.
Deprecated.
See
Descriptor for details.Factory for creating a
DecodingFormat for DeserializationSchema.The interface for dictionary in AbstractColumnVector to decode dictionary encoded values.
Logical type of a user-defined distinct type.
A builder for a
DistinctType.Double column vector.
Logical type of an 8-byte double precision floating point number.
Data for dynamic filtering.
A source event to transport the
DynamicFilteringData for dynamic filtering purpose.Base interface for configuring a dynamic table connector for an external storage system from
catalog and session information.
Provides catalog and session information describing the dynamic table to be accessed.
Sink of a dynamic table to an external storage system.
Context for creating runtime implementation via a
DynamicTableSink.SinkRuntimeProvider.Converter for mapping between Flink's internal data structures and objects specified by the
given
DataType that can be passed into a runtime implementation.Provides actual runtime implementation for writing the data.
Creates a
DynamicTableSink instance from a CatalogTable and additional context
information.Source of a dynamic table from an external storage system.
Base context for creating runtime implementation via a
ScanTableSource.ScanRuntimeProvider and LookupTableSource.LookupRuntimeProvider.Converter for mapping between objects and Flink's internal data structures during runtime.
Creates a
DynamicTableSource instance from a CatalogTable and additional context
information.A
Format for a DynamicTableSink for writing rows.Base interface for configuring an
EncodingFormat for a DynamicTableSink.General utilities for string-encoding.
Strategy for an argument that corresponds to an explicitly defined type.
Type strategy that returns a fixed
DataType.General interface for all kinds of expressions.
Implementation of
ExpressionVisitor that redirects all calls to ExpressionDefaultVisitor.defaultMethod(Expression).Deprecated.
This exception is considered internal and has been erroneously placed in the *.api
package.
Exception for all errors occurring during expression parsing.
Utility methods for working with
Expressions.The visitor definition of
Expression.Utilities for performing reflection tasks.
Result of the extraction in
ExtractionUtils.extractAssigningConstructor(Class, List).Checks the relation between primitive and boxed types.
Logical version that describes the expected behavior of the reflection-based data type
extraction.
Base interface for all kind of factories that create object instances from a list of key-value
pairs in Flink's Table & SQL API.
Utility for working with
Factorys.Helper utility for validating all options for a
CatalogFactory.Helper utility for validating all options for a
CatalogStoreFactory.Default implementation of
CatalogFactory.Context.Default implementation of
CatalogStoreFactory.Context.Default implementation of
DynamicTableFactory.Context.Default implementation of
ModuleFactory.Context.Base helper utility for validating all options for a
Factory.Helper utility for validating all options for a
ModuleFactory.Helper utility for discovering formats and validating all options for a
DynamicTableFactory.Strategy for an argument that corresponds to a given
LogicalTypeFamily and nullability.Deprecated.
This interface will not be supported in the new source design around
DynamicTableSource.A reference to a field in an input.
A data type that contains field data types (i.e. row and structured type).
Extension of input format which is able to report estimated statistics for file based connector.
Deprecated.
The legacy CSV connector has been replaced by
FileSource / FileSink.Deprecated.
This interface will not be supported in the new source design around
DynamicTableSource.Type strategy that returns the first type that could be inferred.
Float column vector.
Logical type of a 4-byte single precision floating point number.
Forces a given type strategy to be nullable.
Base interface for connector formats.
Base interface for
DecodingFormatFactory and EncodingFormatFactory.A
LookupFunctionProvider that never lookup in external system on cache miss and provides
a cache for holding all entries in the external system.Exception for trying to create a function that already exists.
A
FunctionContext allows to obtain global runtime information about the context in which
the user-defined function is executed.Definition of a function.
A factory to create
FunctionDefinition.Context provided when a function definition is created.
A hint that influences the reflection-based extraction of arguments, accumulator, and output for
constructing the
TypeInference logic of a UserDefinedFunction.Helper annotation for repeatable
FunctionHints.Identifies a system function with function name or a catalog function with a fully qualified
identifier.
Categorizes the semantics of a
FunctionDefinition.Categorizes the language semantics of a
CatalogFunction.Exception for trying to operate on a function that doesn't exist.
Characteristics that a
FunctionDefinition requires.An internal data structure representing data of
ArrayType.An internal data structure representing data of
MapType or MultisetType.An internal data structure representing data of
RowType and other (possibly nested)
structured types such as StructuredType.This class represents a nullable heap array column vector.
This class represents a nullable heap boolean column vector.
This class supports string and binary data by value reference -- i.e. each field is explicitly
present, as opposed to provided by a dictionary reference.
This class represents a nullable byte column vector.
This class represents a nullable double precision floating point column vector.
This class represents a nullable double precision floating point column vector.
This class represents a nullable int column vector.
This class represents a nullable long column vector.
This class represents a nullable heap map column vector.
This class represents a nullable heap row column vector.
This class represents a nullable short column vector.
This class represents a nullable byte column vector.
Three-valued flag for representing
TRUE, FALSE, and UNKNOWN.Type strategy that returns the result type of a decimal addition, used internally for
implementing native SUM/AVG aggregations on a Decimal type.
Base class for user-defined
AggregateFunction and TableAggregateFunction.An
ArgumentTypeStrategy that expects a LogicalTypeFamily.INTEGER_NUMERIC starting
from 0.Provider of an
InputFormat instance as a runtime implementation for ScanTableSource.A list of commonly used pre-defined groups of similar types for accepting more than just one data
type as an input argument in
DataTypeHints.Strategies for inferring and validating input arguments in a function call.
Strategy for inferring and validating input arguments in a function call.
Int column vector.
The
IntervalFreshness represents freshness definition of CatalogMaterializedTable.An enumeration of time unit representing the unit of interval freshness.
Utilities to
IntervalFreshness.Logical type of a 4-byte signed integer with values from -2,147,483,648 to 2,147,483,647.
An
ArgumentTypeStrategy that expects:An output type strategy for
BuiltInFunctionDefinitions.AT.Behavior in case of errors for
BuiltInFunctionDefinitions.JSON_EXISTS.Behavior for entries with a null value for
BuiltInFunctionDefinitions.JSON_OBJECT and
BuiltInFunctionDefinitions.JSON_ARRAY.Behavior of
BuiltInFunctionDefinitions.JSON_QUERY in case a path expression is empty or
raises an error.Argument strategy for
BuiltInFunctionDefinitions.JSON_QUERY to check the `ON EMPTY`
and/or `ON ERROR` behaviour in combination with the return type.Defines whether and when to wrap the result of
BuiltInFunctionDefinitions.JSON_QUERY into
an array.Supported JSON types for
BuiltInFunctionDefinitions.IS_JSON.Behavior for
BuiltInFunctionDefinitions.JSON_VALUE.A data type that contains a key and value data type (e.g.
An abstract implementation fo
BinaryFormat which is lazily serialized into binary or
lazily deserialized into Java object.Type strategy for
BuiltInFunctionDefinitions.LAG and { @link
BuiltInFunctionDefinitions#LEAD}.This type transformation transforms the LEGACY('RAW', ...) type to the RAW(..., ?)
Transformation that applies
TypeInfoDataTypeConverter on LegacyTypeInformationType.Deprecated.
Use
DataTypeFactory.createDataType(TypeInformation) instead.This type is a temporary solution to fully support the old type system stack through the new
stack.
Deprecated.
Deprecated.
This interface will not be supported in the new source design around
DynamicTableSource.A
DataView that provides List-like functionality in the accumulator of an AggregateFunction or TableAggregateFunction when large amounts of data are expected.Deprecated.
Deprecated.
Deprecated.
Strategy that checks if an argument is a literal.
Logical type of a timestamp WITH LOCAL time zone consisting of
year-month-day
hour:minute:second[.fractional] zone with up to nanosecond precision and values ranging from
0000-01-01 00:00:00.000000000 +14:59 to 9999-12-31 23:59:59.999999999 -14:59.A logical type that describes the data type of a value.
Utilities for casting
LogicalType.Utilities for checking
LogicalType and avoiding a lot of type casting and repetitive
work.A converter between
LogicalType and DataType.Implementation of
LogicalTypeVisitor that redirects all calls to LogicalTypeDefaultVisitor.defaultMethod(LogicalType).Returns a deep copy of a
LogicalType.An enumeration of logical type families for clustering
LogicalTypeRoots into categories.Utilities for merging multiple
LogicalType.Parser for creating instances of
LogicalType from a serialized string created with LogicalType.asSerializableString().An enumeration of logical type roots containing static information about logical data types.
Utilities for handling
LogicalTypes.The visitor definition of
LogicalType.Long column vector.
Deprecated.
This interface will not be supported in the new source design around
DynamicTableSource.A semi-persistent mapping from keys to values for storing entries of lookup table.
A wrapper class of
TableFunction for synchronously lookup rows matching the lookup keys
from external system.A provider for creating
LookupFunction.Predefined options for lookup table.
Types of the lookup cache.
Defines which
CacheReloadTrigger to use.A
DynamicTableSource that looks up rows of an external storage system by one or more keys
during runtime.Context for creating runtime implementation via a
LookupTableSource.LookupRuntimeProvider.Provides actual runtime implementation for reading the data.
Map column vector.
Base interface of an internal data structure representing data of
MapType or MultisetType.Type strategy that maps an
InputTypeStrategy to a TypeStrategy if the input
strategy infers compatible types.Logical type of an associative array that maps keys (including
NULL) to values (including
NULL).A
DataView that provides Map-like functionality in the accumulator of an AggregateFunction or TableAggregateFunction when large amounts of data are expected.Deprecated.
Deprecated.
Deprecated.
Type strategy that returns the given argument if it is of the same logical type family.
Placeholder for a missing type strategy.
Exception for trying to create a model that already exists.
Exception for trying to operate on a model that doesn't exist.
ModifyRefreshWorkflow provides the related information to modify refresh workflow of
CatalogMaterializedTable.Modules define a set of metadata, including functions, user defined types, operators, rules, etc.
Exception related to modules.
A factory to create configured module instances based on string-based properties.
Context provided when a module is created.
Logical type of a multiset (=bag).
A reference to a nested field in an input.
Deprecated.
This interface will not be supported in the new source design around
DynamicTableSource.Its memory storage structure is exactly the same with
BinaryRowData.Deprecated.
This exception is considered internal and has been erroneously placed in the *.api
package.
Exception for not finding a
TableFactory for the given properties.A type strategy that can be used to make a result type nullable if any or all of the selected
input arguments are nullable.
Provides null related getters.
Deprecated.
Deprecated.
A serializer for null.
Serializer configuration snapshot for compatibility and format evolution.
Logical type for representing untyped
NULL values.Identifies an object in a catalog.
A database name and object (table/view/function) name combo in a catalog.
Strategy for inferring and validating an argument using a disjunction of multiple
ArgumentTypeStrategys into one like f(NUMERIC || STRING).Strategy for inferring and validating the input using a disjunction of multiple
InputTypeStrategys into one like f(NUMERIC) || f(STRING).Strategy for inferring an unknown argument type from the function's output
DataType if
available.Provider of an
OutputFormat instance as a runtime implementation for DynamicTableSink.Specific
InputTypeStrategy for BuiltInFunctionDefinitions.OVER.Range specification for
BuiltInFunctionDefinitions.OVER window.Deprecated.
This interface will not be supported in the new sink design around
DynamicTableSink.Parallelism provider for other connector providers.
Provider for creating
AsyncLookupFunction and LookupCache for storing lookup
entries.Provider for creating
LookupFunction and LookupCache for storing lookup entries.Deprecated.
This interface will not be supported in the new sink design around
DynamicTableSink.Deprecated.
This interface will not be supported in the new source design around
DynamicTableSource.Exception for trying to create a partition that already exists.
Exception for operation on a partition that doesn't exist.
Utils for file system.
Exception for invalid PartitionSpec compared with partition key list of a partitioned Table.
An
ArgumentTypeStrategy that expects a percentage value between [0.0, 1.0].An
ArgumentTypeStrategy that expects an array of percentages with each element between
[0.0, 1.0].A trigger that reloads cache entries periodically with specified interval and
PeriodicCacheReloadTrigger.ScheduleMode.Defines the mode how to schedule cache reloads.
A strategy which indicates the watermarks should be preserved from the underlying datastream.
A
PrintStyle defines style and formatting to print a collection of RowData.Base interface representing a stored procedure that can be executed by Flink.
Definition of a procedure.
A hint that influences the reflection-based extraction of arguments and output for constructing
the
TypeInference logic of a Procedure.Helper annotation for repeatable
ProcedureHints.Exception for trying to operate on a procedure that doesn't exist.
Base class for a user-defined process table function.
Context that can be added as a first argument to the eval() method for additional information
about the input tables and other services provided by the framework.
Extension of
DecodingFormat which is able to produce projected rows.Deprecated.
This interface will not be supported in the new source design around
DynamicTableSource.Projection represents a list of (possibly nested) indexes that can be used to project
data types.The wrapper of user defined python aggregate function.
PythonAggregateFunctionInfo contains the execution information of a Python aggregate function,
such as: the actual Python aggregation function, the input arguments, the filter arg, the
distinct flag, etc.
Python execution environments.
The Execution type specifies how to execute the Python function.
The base interface of a wrapper of a Python function.
PythonFunctionInfo contains the execution information of a Python function, such as: the actual
Python function, the input arguments, etc.
Categorizes the Python functions.
Utilities for creating PythonFunction from the fully qualified name of a Python function.
The wrapper of user defined python scalar function.
The wrapper of user defined python table aggregate function.
The wrapper of user defined python table function.
Print only the result content as raw form. column delimiter is ",", row delimiter is "\n".
Logical type of an arbitrary serialized type.
An internal data structure representing data of
RawType.This interface represents the meta information of current materialized table background refresh
pipeline.
This interface is used to serialize and deserialize the
RefreshHandler.RefreshWorkflow is the basic interface that provide the related information to operate
the refresh workflow of CatalogMaterializedTable, the operation of refresh workflow
include create, modify, drop, etc.InputTypeStrategy specific for BuiltInFunctionDefinitions.REINTERPRET_CAST.InputTypeStrategy composed of an arbitrarily often repeating list of ArgumentTypeStrategys.A common parent that describes the resolved metadata of a table or view in a catalog.
A validated
CatalogMaterializedTable that is backed by the original metadata coming from
the Catalog but resolved by the framework.A validated
CatalogModel that is backed by the original metadata coming from the Catalog but resolved by the framework.A validated
CatalogTable that is backed by the original metadata coming from the Catalog but resolved by the framework.A validated
CatalogView that is backed by the original metadata coming from the Catalog but resolved by the framework.Expression that has been fully resolved and validated.
A reference to a field in an input which has been resolved.
Schema of a table or view consisting of columns, constraints, and watermark specifications.
An enum that represents the type of resource.
Description of resource information.
ModifyRefreshWorkflow provides the related information to resume refresh workflow of
CatalogMaterializedTable.Strategy for an argument that corresponds to a given
LogicalTypeRoot and nullability.Row column vector.
Base interface for an internal data structure representing data of
RowType and other
(possibly nested) structured types such as StructuredType in the table ecosystem.Accessor for getting the field of a row during runtime.
The context is intended to provide the relevant table scan information needed by the sink to
perform row-level update/delete.
Deprecated.
This class was used for legacy connectors using
Descriptor.Deprecated.
This interface will not be supported in the new source design around
DynamicTableSource.Type strategy for
BuiltInFunctionDefinitions.ROWTIME which mirrors the type of the passed
rowtime column, but returns LogicalTypeRoot.TIMESTAMP_WITHOUT_TIME_ZONE for a
BATCH mode.Logical type of a sequence of fields.
Describes a field of a
RowType.Base interface for converting data during runtime.
Context for conversions during runtime.
Base class for a user-defined scalar function.
Deprecated.
Non-legacy functions can simply omit this wrapper for declarations.
A
DynamicTableSource that scans all rows from an external storage system during runtime.Context for creating runtime implementation via a
ScanTableSource.ScanRuntimeProvider.Provides actual runtime implementation for reading the data.
Schema of a table or view.
Deprecated.
This class was used for legacy connectors using
Descriptor.A builder for constructing an immutable but still unresolved
Schema.Super class for all kinds of columns in an unresolved schema.
Declaration of a computed column that will be resolved to
Column.ComputedColumn during
schema resolution.Super class for all kinds of constraints in an unresolved schema.
Declaration of a metadata column that will be resolved to
Column.MetadataColumn during
schema resolution.Declaration of a physical column that will be resolved to
Column.PhysicalColumn during
schema resolution.Declaration of a primary key that will be resolved to
UniqueConstraint during schema
resolution.Declaration of a watermark strategy that will be resolved to
WatermarkSpec during
schema resolution.Resolves a
Schema to a validated ResolvedSchema.Strategy for inferring and validating a function signature like
f(STRING, NUMERIC) or
f(s STRING, n NUMERIC) using a sequence of ArgumentTypeStrategys.Factory for creating a
EncodingFormat for SerializationSchema.Short column vector.
Describes the signature of a function.
Representation of a single argument in a signature.
Implementation of
SupportsStaging.StagingContext.Provider of a
Sink instance as a runtime implementation for DynamicTableSink.Logical type of a 2-byte signed integer with values from -32,768 to 32,767.
Provider of a
Source instance as a runtime implementation for ScanTableSource.A
FunctionDefinition that can provide a runtime implementation (i.e. the function's body)
that is specialized for the given call and session.Serializable factory that can be passed into a
UserDefinedFunction for evaluating
previously defined expression during runtime.Helper interface for creating
SpecializedFunction.ExpressionEvaluators.Provides call and session information for the specialized function.
Entry point for specific input type strategies not covered in
InputTypeStrategies.Entry point for specific type strategies not covered in
TypeStrategies.A call to a SQL expression.
Provides a format for unparsing
BuiltInFunctionDefinitions into a SQL string.The
StagedTable is designed to implement Flink's atomic semantic for CTAS(CREATE TABLE AS
SELECT) and RTAS([CREATE OR] REPLACE TABLE AS SELECT) statement using a two-phase commit
protocol.A hint that declares an intermediate result (i.e. state entry) that is managed by the framework
(i.e.
Strategy for inferring a function call's intermediate result data type (i.e. state entry).
Describes an argument in a static signature that is not overloaded and does not support varargs.
Declares traits for
StaticArgument.An internal data structure representing data of
CharType and VarCharType.Logical type of a user-defined object structured type.
A builder for a
StructuredType.Defines an attribute of a
StructuredType.Defines equality properties for scalar evaluation.
An
InputTypeStrategy that lets you apply other strategies for subsequences of the actual
arguments.A Builder for
SubsequenceInputTypeStrategy.Enables to push down the local aggregates into a
ScanTableSource.Enables to write bucketed data into a
DynamicTableSink.Enables to push down filters decomposed from the
WHERE clause in delete statement to
DynamicTableSink.Pushes dynamic filter into
ScanTableSource, the table source can filter the partitions
even the input data in runtime to reduce scan I/O.Enables to push down filters into a
ScanTableSource.Result of a filter push down.
Enables to push down a limit (the expected maximum number of produced records) into a
ScanTableSource.This interface is designed to allow connectors to provide a custom partitioning strategy for the
data that is fed into the
LookupTableSource.This interface is responsible for providing custom partitioning logic for the RowData
records.
Enables to overwrite existing data in a
DynamicTableSink.Enables to write partitioned data in a
DynamicTableSink.Enables to pass available partitions to the planner and push down partitions into a
ScanTableSource.Enables to push down a (possibly nested) projection into a
ScanTableSource.Interface for
ScanTableSources that support reading metadata columns.Interface for
DynamicTableSinks that support delete existing data according to row-level
changes.The information that guides the planner on how to rewrite the delete statement.
Type of delete modes that the sink expects for delete purpose.
Interface for
ScanTableSources that support the row-level modification.Type of the row-level modification for table.
Interface for
DynamicTableSinks that support update existing data according to row-level
changes.The information that guides the planner on how to rewrite the update statement.
Type of update modes that the sink expects for update purpose.
Enables to fully rely on the watermark strategy provided by the
ScanTableSource itself.Interface for
DynamicTableSinks that support atomic semantic for CTAS(CREATE TABLE AS
SELECT) or RTAS([CREATE OR] REPLACE TABLE AS SELECT) statement using a two-phase commit protocol.The context is intended to tell DynamicTableSink the type of this operation.
The type of operation the staging sink is for.
Enables to report the estimated statistics provided by the
DynamicTableSource.Enables to delete all existing data in a
DynamicTableSink table using TRUNCATE
TABLE statement.Enables to push down a watermark strategy into a
ScanTableSource.Interface for
DynamicTableSinks that support writing metadata columns.ModifyRefreshWorkflow provides the related information to suspend refresh workflow of
CatalogMaterializedTable.Strategy for a symbol argument of a specific
TableSymbol enum.Logical type for representing symbol values.
Extends the
TypeInference function-aware by additional system columns and validation.Base class for a user-defined table aggregate function.
Collects a record and forwards it.
Deprecated.
Non-legacy functions can simply omit this wrapper for declarations.
Exception for trying to create a table (or view) that already exists.
Print the result and content as tableau form.
TableChange represents the modification of the CatalogBaseTable.A table change to add a column.
A table change to add a distribution.
A table change to add a unique constraint.
A table change to add a watermark.
Column position AFTER means the specified column should be put after the given `column`.
TableChange.CatalogTableChange represents the modification of the CatalogTable.The position of the modified or added column.
A table change to drop the column.
A table change to drop the constraints.
A table change to drop a table's distribution.
A table change to drop the watermark.
Column position FIRST means the specified column should be the first column.
TableChange.MaterializedTableChange represents the modification of the materialized table.A base schema change to modify a column.
A table change to modify the column comment.
A table change to modify the column name.
A table change to modify the column position.
A table change to modify the definition query.
A table change to modify a distribution.
A table change that modify the physical column data type.
A table change to modify materialized table refresh handler.
A table change to modify materialized table refresh status.
A table change to modify a unique constraint.
A table change to modify the watermark.
A table change to reset the table option.
A table change to set the table option.
Deprecated.
See
ResolvedSchema and Column.Representation of a computed column.
Representation of a metadata column.
Representation of a physical column.
Utilities for table sources and sinks.
Defines whether the given table is distributed across buckets using a specified algorithm and
given columns.
Distribution kind.
General Exception for all errors during table handling.
Deprecated.
This interface has been replaced by
Factory.Deprecated.
Base class for a user-defined table function.
Deprecated.
Non-legacy functions can simply omit this wrapper for declarations.
Deprecated.
Please use
LookupFunctionProvider to implement synchronous lookup table.Exception for an operation on a nonexistent table.
Exception for trying to operate on a table (or view) that doesn't exist.
Exception for trying to operate partition on a non-partitioned table.
Exception for trying to operate non-partitioned on a partitioned table.
Exception for errors occurring in the runtime.
Deprecated.
This class has been deprecated as part of FLIP-164.
Builder for creating a
TableSchema.Utilities to
TableSchema.Provides call information about the table that has been passed to a table argument.
Deprecated.
This interface has been replaced by
DynamicTableSink.Deprecated.
This class is implementing the deprecated
TableSink interface.Deprecated.
This interface has been replaced by
DynamicTableSinkFactory.Context of table sink creation.
Deprecated.
Deprecated.
This interface has been replaced by
DynamicTableSource.Deprecated.
This interface has been replaced by
DynamicTableSourceFactory.Context of table source creation.
Deprecated.
Logic to validate
TableSource types.Table statistics.
The base interface for all table symbols.
Class representing temporal table function over some history table.
This interface is for a
Catalog to listen on temporary object operations.Provides a thread local cache with a maximum cache size per thread.
A trigger that reloads at a specific time and repeats for the given interval in days.
Deprecated.
This class will be removed in future versions as it is used for the old type system.
Deprecated.
This class will be removed in future versions as it is used for the old type system.
Units for working with time intervals.
Units for working with points in time.
Timestamp column vector.
An internal data structure representing data of
TimestampType and LocalZonedTimestampType.Deprecated.
This interface will not be supported in the new source design around
DynamicTableSource.Utility methods for dealing with
TimestampExtractor.Internal timestamp kind for attaching time attribute metadata to timestamps with or without a
time zone.
Logical type of a timestamp WITHOUT time zone consisting of
year-month-day
hour:minute:second[.fractional] with up to nanosecond precision and values ranging from
0000-01-01 00:00:00.000000000 to 9999-12-31 23:59:59.999999999.Logical type of a time WITHOUT time zone consisting of
hour:minute:second[.fractional]
with up to nanosecond precision and values ranging from 00:00:00.000000000 to
23:59:59.999999999.Logical type of a 1-byte signed integer with values from -128 to 127.
Type strategy of
TO_TIMESTAMP_LTZ.Provide type specialized setters to reduce if/else and eliminate box and unbox.
Provides logic for the type inference of function calls.
Builder for configuring and creating instances of
TypeInference.Reflection-based utility for extracting a
TypeInference from a supported subclass of
UserDefinedFunction.Utility for performing type inference.
The result of a type inference run.
Information what the outer world (i.e. an outer wrapping call) expects from the current
function call.
Converter from
TypeInformation to DataType.Deprecated.
Use
RawType instead.Strategy that checks if an argument is a type literal.
Expression that wraps
DataType as a literal.Utility methods for dealing with field types in
TableSource and TableSink.Deprecated.
This class will be removed in future versions as it uses the old type system.
Strategies for inferring an output or accumulator data type of a function call.
Strategy for inferring a function call's result data type.
Deprecated.
This utility is based on
TypeInformation.Transforms one data type to another.
Transformations for transforming one data type to another.
A unique key constraint.
Deprecated.
See
ResolvedSchema and UniqueConstraint.A
CallContext with unknown data types.Partially resolved data type that requires a lookup in a catalog or configuration before creating
the corresponding
LogicalType.Identifier of an object, such as table, view, function or type in a catalog.
Placeholder type of an unresolved user-defined type that is identified by an
UnresolvedIdentifier.Base class for all user-defined functions.
Utility for dealing with subclasses of
UserDefinedFunction.Logical type of a user-defined representation for one or more built-in types.
Exception for all errors occurring during validation phase.
Value-based data type extractor that supports extraction of clearly identifiable data types for
input conversion.
Expression for constant literal values.
Logical type of a variable-length binary string (=a sequence of bytes).
Logical type of a variable-length character string.
Strategy for inferring and validating a varying function signature like
f(INT, STRING,
NUMERIC...) or f(i INT, str STRING, num NUMERIC...) using a sequence of ArgumentTypeStrategys.A type strategy that ensures that the result type is either
LogicalTypeRoot.VARCHAR or
LogicalTypeRoot.VARBINARY from their corresponding non-varying roots.A VectorizedColumnBatch is a set of rows, organized with each column as a vector.
The strategy for emitting watermark.
Pojo class for watermark configs from table options or 'OPTIONS' hint.
Builder of WatermarkHintParams.
Representation of a watermark specification in a
ResolvedSchema.Deprecated.
See
ResolvedSchema and WatermarkSpec.Provides a strategy to generate watermarks for a rowtime attribute.
Strategy that does not perform any modification or validation of the input.
A workflow-related operation exception to materialized table, including create, suspend, resume,
drop workflow operation, etc.
This interface is used to interact with specific workflow scheduler services that support
creating, modifying, and deleting refreshed workflow of Materialized Table.
A factory to create a
WorkflowScheduler instance.Context provided when a workflow scheduler is created.
Utility for working with
WorkflowScheduler.Default implementation of
WorkflowSchedulerFactory.Context.Helper utility for validating all options for a
WorkflowSchedulerFactory.Writable
BooleanColumnVector.Writable
BytesColumnVector.Writable
ByteColumnVector.Writable
ColumnVector.Writable
DoubleColumnVector.Writable
FloatColumnVector.Writable
IntColumnVector.Writable
LongColumnVector.Writable
ShortColumnVector.Writable
TimestampColumnVector.Logical type for a group of year-month interval types.
Supported resolutions of this type.
Logical type of a timestamp WITH time zone consisting of
year-month-day
hour:minute:second[.fractional] zone with up to nanosecond precision and values ranging from
0000-01-01 00:00:00.000000000 +14:59 to 9999-12-31 23:59:59.999999999 -14:59.