org.apache.flink.table.factories.TableFactory Java Examples

@Test
public void testGenericTable() throws Exception {
	TableSchema schema = TableSchema.builder()
		.field("name", DataTypes.STRING())
		.field("age", DataTypes.INT())
		.build();

	Map<String, String> properties = new HashMap<>();
	properties.put(CatalogConfig.IS_GENERIC, String.valueOf(true));
	properties.put("connector", "COLLECTION");

	catalog.createDatabase("mydb", new CatalogDatabaseImpl(new HashMap<>(), ""), true);
	ObjectPath path = new ObjectPath("mydb", "mytable");
	CatalogTable table = new CatalogTableImpl(schema, properties, "csv table");
	catalog.createTable(path, table, true);
	Optional<TableFactory> opt = catalog.getTableFactory();
	assertTrue(opt.isPresent());
	HiveTableFactory tableFactory = (HiveTableFactory) opt.get();
	TableSource tableSource = tableFactory.createTableSource(path, table);
	assertTrue(tableSource instanceof StreamTableSource);
	TableSink tableSink = tableFactory.createTableSink(path, table);
	assertTrue(tableSink instanceof StreamTableSink);
}
 

@Test
public void testHiveTable() throws Exception {
	TableSchema schema = TableSchema.builder()
		.field("name", DataTypes.STRING())
		.field("age", DataTypes.INT())
		.build();

	Map<String, String> properties = new HashMap<>();

	catalog.createDatabase("mydb", new CatalogDatabaseImpl(new HashMap<>(), ""), true);
	ObjectPath path = new ObjectPath("mydb", "mytable");
	CatalogTable table = new CatalogTableImpl(schema, properties, "hive table");
	catalog.createTable(path, table, true);
	Optional<TableFactory> opt = catalog.getTableFactory();
	assertTrue(opt.isPresent());
	HiveTableFactory tableFactory = (HiveTableFactory) opt.get();
	TableSink tableSink = tableFactory.createTableSink(path, table);
	assertTrue(tableSink instanceof HiveTableSink);
	TableSource tableSource = tableFactory.createTableSource(path, table);
	assertTrue(tableSource instanceof HiveTableSource);
}
 

private Table convertTable(ObjectIdentifier identifier, TableLookupResult lookupResult, @Nullable TableFactory tableFactory) {
	CatalogBaseTable table = lookupResult.getTable();
	TableSchema resolvedSchema = lookupResult.getResolvedSchema();
	if (table instanceof QueryOperationCatalogView) {
		return QueryOperationCatalogViewTable.createCalciteTable(
			((QueryOperationCatalogView) table),
			resolvedSchema);
	} else if (table instanceof ConnectorCatalogTable) {
		return convertConnectorTable((ConnectorCatalogTable<?, ?>) table, resolvedSchema);
	} else {
		if (table instanceof CatalogTable) {
			return convertCatalogTable(
				identifier,
				(CatalogTable) table,
				resolvedSchema,
				tableFactory);
		} else if (table instanceof CatalogView) {
			return convertCatalogView(
				identifier.getObjectName(),
				(CatalogView) table,
				resolvedSchema);
		} else {
			throw new TableException("Unsupported table type: " + table);
		}
	}
}
 

@Override
public Table getTable(String tableName) {
	ObjectIdentifier identifier = ObjectIdentifier.of(catalogName, databaseName, tableName);
	return catalogManager.getTable(identifier)
		.map(result -> {
			final TableFactory tableFactory;
			if (result.isTemporary()) {
				tableFactory = null;
			} else {
				tableFactory = catalogManager.getCatalog(catalogName)
					.flatMap(Catalog::getTableFactory)
					.orElse(null);
			}
			return convertTable(identifier, result, tableFactory);
		})
		.orElse(null);
}
 

private Table convertCatalogTable(ObjectPath tablePath, CatalogTable table) {
	TableSource<?> tableSource;
	Optional<TableFactory> tableFactory = catalog.getTableFactory();
	if (tableFactory.isPresent()) {
		TableFactory tf = tableFactory.get();
		if (tf instanceof TableSourceFactory) {
			tableSource = ((TableSourceFactory) tf).createTableSource(tablePath, table);
		} else {
			throw new TableException(String.format("Cannot query a sink-only table. TableFactory provided by catalog %s must implement TableSourceFactory",
				catalog.getClass()));
		}
	} else {
		tableSource = TableFactoryUtil.findAndCreateTableSource(table);
	}

	if (!(tableSource instanceof StreamTableSource)) {
		throw new TableException("Catalog tables support only StreamTableSource and InputFormatTableSource");
	}

	return new TableSourceTable<>(
		tableSource,
		!((StreamTableSource<?>) tableSource).isBounded(),
		FlinkStatistic.UNKNOWN()
	);
}
 

public AmbiguousTableFactoryException(
		List<? extends TableFactory> matchingFactories,
		Class<? extends TableFactory> factoryClass,
		List<TableFactory> factories,
		Map<String, String> properties) {

	this(matchingFactories, factoryClass, factories, properties, null);
}
 

public NoMatchingTableFactoryException(
	String message,
	@Nullable String matchCandidatesMessage,
	Class<?> factoryClass,
	List<TableFactory> factories,
	Map<String, String> properties,
	Throwable cause) {

	super(cause);
	this.message = message;
	this.matchCandidatesMessage = matchCandidatesMessage;
	this.factoryClass = factoryClass;
	this.factories = factories;
	this.properties = properties;
}
 

private Table convertCatalogTable(
		ObjectIdentifier identifier,
		CatalogTable table,
		TableSchema resolvedSchema,
		@Nullable TableFactory tableFactory) {
	final TableSource<?> tableSource;
	final TableSourceFactory.Context context = new TableSourceFactoryContextImpl(
			identifier, table, tableConfig.getConfiguration());
	if (tableFactory != null) {
		if (tableFactory instanceof TableSourceFactory) {
			tableSource = ((TableSourceFactory<?>) tableFactory).createTableSource(context);
		} else {
			throw new TableException(
				"Cannot query a sink-only table. TableFactory provided by catalog must implement TableSourceFactory");
		}
	} else {
		tableSource = TableFactoryUtil.findAndCreateTableSource(context);
	}

	if (!(tableSource instanceof StreamTableSource)) {
		throw new TableException("Catalog tables support only StreamTableSource and InputFormatTableSource");
	}

	return new TableSourceTable<>(
		resolvedSchema,
		tableSource,
		// this means the TableSource extends from StreamTableSource, this is needed for the
		// legacy Planner. Blink Planner should use the information that comes from the TableSource
		// itself to determine if it is a streaming or batch source.
		isStreamingMode,
		FlinkStatistic.UNKNOWN()
	);
}
 

@Test
public void testHiveTable() throws Exception {
	TableSchema schema = TableSchema.builder()
		.field("name", DataTypes.STRING())
		.field("age", DataTypes.INT())
		.build();

	Map<String, String> properties = new HashMap<>();
	properties.put(CatalogConfig.IS_GENERIC, String.valueOf(false));

	catalog.createDatabase("mydb", new CatalogDatabaseImpl(new HashMap<>(), ""), true);
	ObjectPath path = new ObjectPath("mydb", "mytable");
	CatalogTable table = new CatalogTableImpl(schema, properties, "hive table");
	catalog.createTable(path, table, true);
	Optional<TableFactory> opt = catalog.getTableFactory();
	assertTrue(opt.isPresent());
	HiveTableFactory tableFactory = (HiveTableFactory) opt.get();
	TableSink tableSink = tableFactory.createTableSink(new TableSinkFactoryContextImpl(
			ObjectIdentifier.of("mycatalog", "mydb", "mytable"),
			table,
			new Configuration(),
			true));
	assertTrue(tableSink instanceof HiveTableSink);
	TableSource tableSource = tableFactory.createTableSource(new TableSourceFactoryContextImpl(
			ObjectIdentifier.of("mycatalog", "mydb", "mytable"), table, new Configuration()));
	assertTrue(tableSource instanceof HiveTableSource);
}
 

@Test
public void testGenericTable() throws Exception {
	TableSchema schema = TableSchema.builder()
		.field("name", DataTypes.STRING())
		.field("age", DataTypes.INT())
		.build();

	Map<String, String> properties = new HashMap<>();
	properties.put(CatalogConfig.IS_GENERIC, String.valueOf(true));
	properties.put("connector", "COLLECTION");

	catalog.createDatabase("mydb", new CatalogDatabaseImpl(new HashMap<>(), ""), true);
	ObjectPath path = new ObjectPath("mydb", "mytable");
	CatalogTable table = new CatalogTableImpl(schema, properties, "csv table");
	catalog.createTable(path, table, true);
	Optional<TableFactory> opt = catalog.getTableFactory();
	assertTrue(opt.isPresent());
	HiveTableFactory tableFactory = (HiveTableFactory) opt.get();
	TableSource tableSource = tableFactory.createTableSource(new TableSourceFactoryContextImpl(
			ObjectIdentifier.of("mycatalog", "mydb", "mytable"), table, new Configuration()));
	assertTrue(tableSource instanceof StreamTableSource);
	TableSink tableSink = tableFactory.createTableSink(new TableSinkFactoryContextImpl(
			ObjectIdentifier.of("mycatalog", "mydb", "mytable"),
			table,
			new Configuration(),
			true));
	assertTrue(tableSink instanceof StreamTableSink);
}
 

public NoMatchingTableFactoryException(
	String message,
	Class<?> factoryClass,
	List<TableFactory> factories,
	Map<String, String> properties) {
	this(message, null, factoryClass, factories, properties, null);
}
 

public NoMatchingTableFactoryException(
	String message,
	@Nullable String matchCandidatesMessage,
	Class<?> factoryClass,
	List<TableFactory> factories,
	Map<String, String> properties) {
	this(message, matchCandidatesMessage, factoryClass, factories, properties, null);
}
 

public AmbiguousTableFactoryException(
		List<? extends TableFactory> matchingFactories,
		Class<? extends TableFactory> factoryClass,
		List<TableFactory> factories,
		Map<String, String> properties,
		Throwable cause) {

	super(cause);
	this.matchingFactories = matchingFactories;
	this.factoryClass = factoryClass;
	this.factories = factories;
	this.properties = properties;
}
 

public NoMatchingTableFactoryException(
	String message,
	Class<?> factoryClass,
	List<TableFactory> factories,
	Map<String, String> properties) {

	this(message, factoryClass, factories, properties, null);
}
 

public NoMatchingTableFactoryException(
	String message,
	Class<?> factoryClass,
	List<TableFactory> factories,
	Map<String, String> properties,
	Throwable cause) {

	super(cause);
	this.message = message;
	this.factoryClass = factoryClass;
	this.factories = factories;
	this.properties = properties;
}
 

public AmbiguousTableFactoryException(
		List<? extends TableFactory> matchingFactories,
		Class<? extends TableFactory> factoryClass,
		List<TableFactory> factories,
		Map<String, String> properties,
		Throwable cause) {

	super(cause);
	this.matchingFactories = matchingFactories;
	this.factoryClass = factoryClass;
	this.factories = factories;
	this.properties = properties;
}
 

private Table convertCatalogTable(ObjectPath tablePath, CatalogTable table) {
	TableSource<?> tableSource;
	Optional<TableFactory> tableFactory = catalog.getTableFactory();
	if (tableFactory.isPresent()) {
		TableFactory tf = tableFactory.get();
		if (tf instanceof TableSourceFactory) {
			tableSource = ((TableSourceFactory) tf).createTableSource(tablePath, table);
		} else {
			throw new TableException(String.format("Cannot query a sink-only table. TableFactory provided by catalog %s must implement TableSourceFactory",
				catalog.getClass()));
		}
	} else {
		tableSource = TableFactoryUtil.findAndCreateTableSource(table);
	}

	if (!(tableSource instanceof StreamTableSource)) {
		throw new TableException("Catalog tables support only StreamTableSource and InputFormatTableSource");
	}

	return new TableSourceTable<>(
		tableSource,
		// this means the TableSource extends from StreamTableSource, this is needed for the
		// legacy Planner. Blink Planner should use the information that comes from the TableSource
		// itself to determine if it is a streaming or batch source.
		isStreamingMode,
		FlinkStatistic.UNKNOWN()
	);
}
 

public AmbiguousTableFactoryException(
		List<? extends TableFactory> matchingFactories,
		Class<? extends TableFactory> factoryClass,
		List<TableFactory> factories,
		Map<String, String> properties) {

	this(matchingFactories, factoryClass, factories, properties, null);
}
 

@Override
public Optional<TableFactory> getTableFactory() {
	return Optional.of(new HiveTableFactory(hiveConf));
}
 

@Override
public Optional<TableFactory> getTableFactory() {
    Properties props = new Properties();
    props.putAll(properties);
    return Optional.of(new PulsarTableSourceSinkFactory(props));
}
 

public Optional<TableFactory> getTableFactory() {
    return Optional.of(getKuduTableFactory());
}
 

@Override
public Optional<TableFactory> getTableFactory() {
	return Optional.of(new HiveTableFactory(hiveConf));
}
 

/**
 * Get an optional {@link TableFactory} instance that's responsible for generating table-related
 * instances stored in this catalog, instances such as source/sink.
 *
 * @return an optional TableFactory instance
 * @deprecated Use {@link #getFactory()} for the new factory stack. The new factory stack uses the
 *             new table sources and sinks defined in FLIP-95 and a slightly different discovery mechanism.
 */
@Deprecated
default Optional<TableFactory> getTableFactory() {
	return Optional.empty();
}
 

/**
 * Get an optional {@link TableFactory} instance that's responsible for generating table-related
 * instances stored in this catalog, instances such as source/sink and function definitions.
 *
 * @return an optional TableFactory instance
 */
default Optional<TableFactory> getTableFactory() {
	return Optional.empty();
}