Java Code Examples for org.apache.flink.table.types.utils.TypeConversions#fromLegacyInfoToDataType()

@Test
public void testCheckPhysicalLogicalTypeCompatible() {
	TableSchema tableSchema = TableSchema.builder()
							.field("a", DataTypes.VARCHAR(2))
							.field("b", DataTypes.DECIMAL(20, 2))
							.build();
	TableSink tableSink = new TestTableSink(tableSchema);
	LegacyTypeInformationType legacyDataType = (LegacyTypeInformationType) tableSink.getConsumedDataType()
													.getLogicalType();
	TypeInformation legacyTypeInfo = ((TupleTypeInfo) legacyDataType.getTypeInformation()).getTypeAt(1);
	DataType physicalType = TypeConversions.fromLegacyInfoToDataType(legacyTypeInfo);
	TableSchema physicSchema = DataTypeUtils.expandCompositeTypeToSchema(physicalType);
	DataType[] logicalDataTypes = tableSchema.getFieldDataTypes();
	DataType[] physicalDataTypes = physicSchema.getFieldDataTypes();
	for (int i = 0; i < logicalDataTypes.length; i++) {
		TypeMappingUtils.checkPhysicalLogicalTypeCompatible(
				physicalDataTypes[i].getLogicalType(),
				logicalDataTypes[i].getLogicalType(),
				"physicalField",
				"logicalField",
				false);
	}
}
 

@Override
public <T> DataStream<T> toAppendStream(Table table, TypeInformation<T> typeInfo) {
	OutputConversionModifyOperation modifyOperation = new OutputConversionModifyOperation(
		table.getQueryOperation(),
		TypeConversions.fromLegacyInfoToDataType(typeInfo),
		OutputConversionModifyOperation.UpdateMode.APPEND);
	return toDataStream(table, modifyOperation);
}
 

@Override
public <T> DataStream<T> toAppendStream(Table table, TypeInformation<T> typeInfo) {
	OutputConversionModifyOperation modifyOperation = new OutputConversionModifyOperation(
		table.getQueryOperation(),
		TypeConversions.fromLegacyInfoToDataType(typeInfo),
		OutputConversionModifyOperation.UpdateMode.APPEND);
	return toDataStream(table, modifyOperation);
}
 

@Override
public PlannerTypeInferenceUtil getPlannerTypeInferenceUtil() {
	return (unresolvedCall, resolvedArgs) -> {
		FunctionDefinition functionDefinition = unresolvedCall.getFunctionDefinition();
		List<DataType> argumentTypes = resolvedArgs.stream()
			.map(ResolvedExpression::getOutputDataType)
			.collect(Collectors.toList());
		if (functionDefinition.equals(BuiltInFunctionDefinitions.EQUALS)) {
			return new TypeInferenceUtil.Result(
				argumentTypes,
				null,
				DataTypes.BOOLEAN()
			);
		} else if (functionDefinition.equals(BuiltInFunctionDefinitions.IS_NULL)) {
			return new TypeInferenceUtil.Result(
				argumentTypes,
				null,
				DataTypes.BOOLEAN()
			);
		} else if (functionDefinition instanceof ScalarFunctionDefinition) {
			return new TypeInferenceUtil.Result(
				argumentTypes,
				null,
				// We do not support a full legacy type inference here. We support only a static result
				// type
				TypeConversions.fromLegacyInfoToDataType(((ScalarFunctionDefinition) functionDefinition)
					.getScalarFunction()
					.getResultType(null)));
		}

		throw new IllegalArgumentException(
			"Unsupported builtin function in the test: " + unresolvedCall);
	};
}
 

@Test
public void testIsCompositeTypeLegacySimpleType() {
	DataType dataType = TypeConversions.fromLegacyInfoToDataType(Types.STRING);
	boolean isCompositeType = LogicalTypeChecks.isCompositeType(dataType.getLogicalType());

	assertThat(isCompositeType, is(false));
}
 

@Test
public void testIsCompositeTypeLegacyCompositeType() {
	DataType dataType = TypeConversions.fromLegacyInfoToDataType(new RowTypeInfo(Types.STRING, Types.INT));
	boolean isCompositeType = LogicalTypeChecks.isCompositeType(dataType.getLogicalType());

	assertThat(isCompositeType, is(true));
}
 

/**
 * A {@link InputFormatTableSource} and {@link LookupableTableSource} for simple CSV files with
 * a (logically) unlimited number of fields.
 *
 * @param path            The path to the CSV file.
 * @param fieldNames      The names of the table fields.
 * @param fieldTypes      The types of the table fields.
 * @param selectedFields  The fields which will be read and returned by the table source. If
 *                        None, all fields are returned.
 * @param fieldDelim      The field delimiter, "," by default.
 * @param lineDelim       The row delimiter, "\n" by default.
 * @param quoteCharacter  An optional quote character for String values, null by default.
 * @param ignoreFirstLine Flag to ignore the first line, false by default.
 * @param ignoreComments  An optional prefix to indicate comments, null by default.
 * @param lenient         Flag to skip records with parse error instead to fail, false by
 *                        default.
 */
public CsvTableSource(
		String path,
		String[] fieldNames,
		TypeInformation<?>[] fieldTypes,
		int[] selectedFields,
		String fieldDelim,
		String lineDelim,
		Character quoteCharacter,
		boolean ignoreFirstLine,
		String ignoreComments,
		boolean lenient) {
	this(new CsvInputFormatConfig(
			path, fieldNames, TypeConversions.fromLegacyInfoToDataType(fieldTypes), selectedFields,
			fieldDelim, lineDelim, quoteCharacter, ignoreFirstLine,
			ignoreComments, lenient, false));
}
 

@Override
public DataType getProducedDataType() {
	return TypeConversions.fromLegacyInfoToDataType(rowTypeInfo);
}
 

private <T> DataType wrapWithChangeFlag(TypeInformation<T> outputType) {
	TupleTypeInfo tupleTypeInfo = new TupleTypeInfo<Tuple2<Boolean, T>>(Types.BOOLEAN(), outputType);
	return TypeConversions.fromLegacyInfoToDataType(tupleTypeInfo);
}
 

private static DataType createLegacyRaw() {
	return TypeConversions.fromLegacyInfoToDataType(Types.GENERIC(TypeTransformationsTest.class));
}
 

private static DataType createLegacyDecimal() {
	return TypeConversions.fromLegacyInfoToDataType(Types.BIG_DEC);
}
 

/**
 * It will lose some information. (Like {@link PojoTypeInfo} will converted to {@link RowType})
 * It and {@link TypeInfoLogicalTypeConverter#fromLogicalTypeToTypeInfo} not allows back-and-forth conversion.
 */
public static LogicalType fromTypeInfoToLogicalType(TypeInformation typeInfo) {
	DataType dataType = TypeConversions.fromLegacyInfoToDataType(typeInfo);
	return LogicalTypeDataTypeConverter.fromDataTypeToLogicalType(dataType);
}
 

@Override
public DataType getProducedDataType() {
	return TypeConversions.fromLegacyInfoToDataType(rowTypeInfo);
}
 

/**
 * Sets row key information in the table schema.
 * @param rowKeyName the row key field name
 * @param clazz the data type of the row key
 */
public void setRowKey(String rowKeyName, Class<?> clazz) {
	Preconditions.checkNotNull(clazz, "row key class type");
	DataType type = TypeConversions.fromLegacyInfoToDataType(TypeExtractor.getForClass(clazz));
	setRowKey(rowKeyName, type);
}
 

private <T> DataType wrapWithChangeFlag(TypeInformation<T> outputType) {
	TupleTypeInfo tupleTypeInfo = new TupleTypeInfo<Tuple2<Boolean, T>>(Types.BOOLEAN(), outputType);
	return TypeConversions.fromLegacyInfoToDataType(tupleTypeInfo);
}
 

/**
 * It will lose some information. (Like {@link PojoTypeInfo} will converted to {@link RowType})
 * It and {@link TypeInfoLogicalTypeConverter#fromLogicalTypeToTypeInfo} not allows back-and-forth conversion.
 */
public static LogicalType fromTypeInfoToLogicalType(TypeInformation typeInfo) {
	DataType dataType = TypeConversions.fromLegacyInfoToDataType(typeInfo);
	return LogicalTypeDataTypeConverter.fromDataTypeToLogicalType(dataType);
}
 

/**
 * Adds a column defined by family, qualifier, and type to the table schema.
 *
 * @param family    the family name
 * @param qualifier the qualifier name
 * @param clazz     the data type of the qualifier
 */
public void addColumn(String family, String qualifier, Class<?> clazz) {
	Preconditions.checkNotNull(clazz, "class type");
	DataType type = TypeConversions.fromLegacyInfoToDataType(TypeExtractor.getForClass(clazz));
	addColumn(family, qualifier, type);
}