tessl/maven-org-apache-flink--flink-table-runtime-blink-2-11
Runtime classes required by a task manager for execution of table programs in Apache Flink's Blink planner
type-system.mddocs/
Type System
Comprehensive type conversion, serialization, and type information system supporting all Flink data types with optimized serializers for runtime performance and seamless integration with external type systems.
Capabilities
Type Conversion
Core type conversion utilities for transforming between different type representations including class types, logical types, and type information.
/**
* Key converter between classes and data types
* Enables conversion between Java classes and Flink's internal type system
*/
class ClassDataTypeConverter {
/** Extract data type from Java class */
static Optional<DataType> extractDataType(Class<?> clazz);
/** Extract Java class from data type */
static Optional<Class<?>> extractClass(DataType dataType);
/** Extract data type with generic information */
static Optional<DataType> extractDataType(Class<?> clazz, TypeHint<?> typeHint);
/** Check if class can be converted to data type */
static boolean canBeConverted(Class<?> clazz);
}
/** Converter for logical types */
class LogicalTypeDataTypeConverter {
/** Convert logical type to data type */
static DataType toDataType(LogicalType logicalType);
/** Convert data type to logical type */
static LogicalType toLogicalType(DataType dataType);
/** Convert with nullable information */
static DataType toDataType(LogicalType logicalType, boolean nullable);
}
/** Converter for type information */
class TypeInfoDataTypeConverter {
/** Convert type information to data type */
static DataType toDataType(TypeInformation<?> typeInfo);
/** Convert data type to type information */
static TypeInformation<?> toTypeInformation(DataType dataType);
/** Convert with legacy type information */
static DataType toLegacyDataType(TypeInformation<?> typeInfo);
}
/**
* Utility class for planner type operations
* Provides type-related utilities for query planning and optimization
*/
class PlannerTypeUtils {
/** Check if type is primitive */
static boolean isPrimitive(LogicalType type);
/** Get default value for type */
static Object getDefaultValue(LogicalType type);
/** Check if types are compatible */
static boolean isCompatible(LogicalType source, LogicalType target);
/** Get common type for multiple types */
static Optional<LogicalType> getCommonType(LogicalType... types);
/** Convert type to internal type */
static LogicalType toInternalType(LogicalType type);
}Row Data Serializers
Primary serializers for row data, providing efficient serialization and deserialization of tabular data with support for different row formats.
/**
* Primary serializer for row data
* Handles serialization of tabular data with schema information
*/
class RowDataSerializer extends TypeSerializer<RowData> {
/** Create serializer with field types */
RowDataSerializer(LogicalType... types);
/** Create serializer with type information */
RowDataSerializer(TypeInformation<RowData> typeInfo);
/** Serialize row data to output view */
void serialize(RowData record, DataOutputView target) throws IOException;
/** Deserialize row data from input view */
RowData deserialize(DataInputView source) throws IOException;
/** Deserialize into reuse object */
RowData deserialize(RowData reuse, DataInputView source) throws IOException;
/** Copy row data */
RowData copy(RowData from);
/** Copy into reuse object */
RowData copy(RowData from, RowData reuse);
/** Get serialized length */
int getLength();
/** Check if length is fixed */
boolean isImmutableType();
/** Create serializer snapshot */
TypeSerializerSnapshot<RowData> snapshotConfiguration();
}
/** Serializer for binary row data */
class BinaryRowDataSerializer extends TypeSerializer<BinaryRowData> {
BinaryRowDataSerializer(int arity);
/** Serialize binary row data */
void serialize(BinaryRowData record, DataOutputView target) throws IOException;
/** Deserialize binary row data */
BinaryRowData deserialize(DataInputView source) throws IOException;
/** Copy binary row data */
BinaryRowData copy(BinaryRowData from);
/** Get number of fields */
int getArity();
}Collection Serializers
Serializers for collection data types including arrays, maps, and other complex data structures.
/** Serializer for array data */
class ArrayDataSerializer extends TypeSerializer<ArrayData> {
ArrayDataSerializer(LogicalType elementType);
/** Serialize array data */
void serialize(ArrayData record, DataOutputView target) throws IOException;
/** Deserialize array data */
ArrayData deserialize(DataInputView source) throws IOException;
/** Copy array data */
ArrayData copy(ArrayData from);
/** Get element type */
LogicalType getElementType();
}
/** Serializer for map data */
class MapDataSerializer extends TypeSerializer<MapData> {
MapDataSerializer(LogicalType keyType, LogicalType valueType);
/** Serialize map data */
void serialize(MapData record, DataOutputView target) throws IOException;
/** Deserialize map data */
MapData deserialize(DataInputView source) throws IOException;
/** Copy map data */
MapData copy(MapData from);
/** Get key type */
LogicalType getKeyType();
/** Get value type */
LogicalType getValueType();
}Temporal Data Serializers
Specialized serializers for temporal data types including timestamps, dates, and time values.
/** Serializer for timestamp data */
class TimestampDataSerializer extends TypeSerializer<TimestampData> {
TimestampDataSerializer(int precision);
/** Serialize timestamp data */
void serialize(TimestampData record, DataOutputView target) throws IOException;
/** Deserialize timestamp data */
TimestampData deserialize(DataInputView source) throws IOException;
/** Copy timestamp data */
TimestampData copy(TimestampData from);
/** Get timestamp precision */
int getPrecision();
}
/** Serializer for decimal data */
class DecimalDataSerializer extends TypeSerializer<DecimalData> {
DecimalDataSerializer(int precision, int scale);
/** Serialize decimal data */
void serialize(DecimalData record, DataOutputView target) throws IOException;
/** Deserialize decimal data */
DecimalData deserialize(DataInputView source) throws IOException;
/** Copy decimal data */
DecimalData copy(DecimalData from);
/** Get decimal precision */
int getPrecision();
/** Get decimal scale */
int getScale();
}Type Information Classes
Type information classes providing runtime type metadata for various data types, enabling type-safe operations and serialization.
/** Type info for timestamp data */
class TimestampDataTypeInfo extends TypeInformation<TimestampData> {
TimestampDataTypeInfo(int precision);
/** Get timestamp precision */
int getPrecision();
/** Create serializer */
TypeSerializer<TimestampData> createSerializer(ExecutionConfig config);
/** Check if basic type */
boolean isBasicType();
/** Check if tuple type */
boolean isTupleType();
}
/** Type info for decimal data */
class DecimalDataTypeInfo extends TypeInformation<DecimalData> {
DecimalDataTypeInfo(int precision, int scale);
/** Get decimal precision */
int getPrecision();
/** Get decimal scale */
int getScale();
/** Create serializer */
TypeSerializer<DecimalData> createSerializer(ExecutionConfig config);
}
/** Type info for string data */
class StringDataTypeInfo extends TypeInformation<StringData> {
StringDataTypeInfo();
/** Create serializer */
TypeSerializer<StringData> createSerializer(ExecutionConfig config);
/** Check equality */
boolean equals(Object obj);
/** Get hash code */
int hashCode();
}
/** Type info for BigDecimal */
class BigDecimalTypeInfo extends TypeInformation<BigDecimal> {
BigDecimalTypeInfo(int precision, int scale);
/** Get precision */
int getPrecision();
/** Get scale */
int getScale();
/** Create serializer */
TypeSerializer<BigDecimal> createSerializer(ExecutionConfig config);
}Raw Data Serializers
Serializers for raw data types and binary data, providing efficient serialization for opaque data objects.
/** Serializer for raw value data */
class RawValueDataSerializer<T> extends TypeSerializer<RawValueData<T>> {
RawValueDataSerializer(TypeSerializer<T> innerSerializer);
/** Serialize raw value data */
void serialize(RawValueData<T> record, DataOutputView target) throws IOException;
/** Deserialize raw value data */
RawValueData<T> deserialize(DataInputView source) throws IOException;
/** Copy raw value data */
RawValueData<T> copy(RawValueData<T> from);
/** Get inner serializer */
TypeSerializer<T> getInnerSerializer();
}
/** Serializer for binary string data */
class BinaryStringDataSerializer extends TypeSerializer<BinaryStringData> {
BinaryStringDataSerializer();
/** Serialize binary string data */
void serialize(BinaryStringData record, DataOutputView target) throws IOException;
/** Deserialize binary string data */
BinaryStringData deserialize(DataInputView source) throws IOException;
/** Copy binary string data */
BinaryStringData copy(BinaryStringData from);
}Specialized Type Utilities
Utility classes for working with specific data types and providing type-specific operations.
/** Utilities for internal type operations */
class InternalTypeUtils {
/** Create internal serializer for type */
static TypeSerializer<?> createInternalSerializer(LogicalType type);
/** Create external serializer for type */
static TypeSerializer<?> createExternalSerializer(LogicalType type);
/** Check if type needs internal conversion */
static boolean needsInternalConversion(LogicalType type);
/** Convert to internal type */
static LogicalType toInternalType(LogicalType type);
}
/** Type utilities for runtime operations */
class TypeUtils {
/** Check if type is nullable */
static boolean isNullable(LogicalType type);
/** Cast object to specific type */
static <T> T cast(Object obj, Class<T> clazz);
/** Get type class */
static Class<?> getTypeClass(LogicalType type);
/** Create type information from logical type */
static TypeInformation<?> toTypeInformation(LogicalType type);
}
/** Utilities for schema operations */
class SchemaUtils {
/** Convert table schema to row type */
static RowType toRowType(TableSchema schema);
/** Convert row type to table schema */
static TableSchema toTableSchema(RowType rowType);
/** Project schema with field indices */
static TableSchema projectSchema(TableSchema schema, int[] fieldIndices);
/** Rename schema fields */
static TableSchema renameSchema(TableSchema schema, List<String> newFieldNames);
}Type Compatibility and Conversion
Classes and utilities for handling type compatibility checks and automatic type conversions.
/** Type compatibility checker */
class TypeCompatibilityChecker {
/** Check if types are compatible */
static boolean isCompatible(LogicalType source, LogicalType target);
/** Check if conversion is possible */
static boolean canConvert(LogicalType source, LogicalType target);
/** Get conversion cost */
static int getConversionCost(LogicalType source, LogicalType target);
/** Find common super type */
static Optional<LogicalType> getCommonSuperType(LogicalType... types);
}
/** Automatic type converter */
class TypeConverter {
/** Convert value between types */
static Object convert(Object value, LogicalType sourceType, LogicalType targetType);
/** Create conversion function */
static Function<Object, Object> createConverter(LogicalType sourceType, LogicalType targetType);
/** Check if conversion is lossless */
static boolean isLosslessConversion(LogicalType sourceType, LogicalType targetType);
}Type Factory and Builders
Factory classes and builders for creating type instances and complex type structures.
/** Factory for creating type serializers */
class TypeSerializerFactory {
/** Create serializer for logical type */
static TypeSerializer<?> createSerializer(LogicalType type);
/** Create serializer for data type */
static TypeSerializer<?> createSerializer(DataType dataType);
/** Create serializer with execution config */
static TypeSerializer<?> createSerializer(LogicalType type, ExecutionConfig config);
}
/** Builder for row types */
class RowTypeBuilder {
/** Add field to row type */
RowTypeBuilder field(String name, LogicalType type);
/** Add nullable field */
RowTypeBuilder nullableField(String name, LogicalType type);
/** Build the row type */
RowType build();
}Usage Examples
// Convert between class and data type
Optional<DataType> dataType = ClassDataTypeConverter.extractDataType(String.class);
Optional<Class<?>> clazz = ClassDataTypeConverter.extractClass(DataTypes.STRING());
// Create row data serializer
LogicalType[] fieldTypes = {
DataTypes.INT().getLogicalType(),
DataTypes.STRING().getLogicalType(),
DataTypes.TIMESTAMP(3).getLogicalType()
};
RowDataSerializer serializer = new RowDataSerializer(fieldTypes);
// Serialize and deserialize row data
ByteArrayOutputStream baos = new ByteArrayOutputStream();
DataOutputViewStreamWrapper outputView = new DataOutputViewStreamWrapper(baos);
serializer.serialize(rowData, outputView);
ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
DataInputViewStreamWrapper inputView = new DataInputViewStreamWrapper(bais);
RowData deserializedRow = serializer.deserialize(inputView);
// Create type information
TimestampDataTypeInfo timestampTypeInfo = new TimestampDataTypeInfo(3);
DecimalDataTypeInfo decimalTypeInfo = new DecimalDataTypeInfo(10, 2);
// Type conversion utilities
boolean compatible = PlannerTypeUtils.isCompatible(sourceType, targetType);
Optional<LogicalType> commonType = PlannerTypeUtils.getCommonType(type1, type2, type3);
// Build complex row type
RowType rowType = new RowTypeBuilder()
.field("id", DataTypes.INT().getLogicalType())
.field("name", DataTypes.STRING().getLogicalType())
.nullableField("email", DataTypes.STRING().getLogicalType())
.build();
// Create array and map serializers
ArrayDataSerializer arraySerializer = new ArrayDataSerializer(DataTypes.STRING().getLogicalType());
MapDataSerializer mapSerializer = new MapDataSerializer(
DataTypes.STRING().getLogicalType(),
DataTypes.INT().getLogicalType()
);Install with Tessl CLI
npx tessl i tessl/maven-org-apache-flink--flink-table-runtime-blink-2-11