Support multiple table engines

[WenyXu]

What problem does the new feature solve?

Allow user to specify the table engine type, e.g.,

CREATE EXTERNAL TABLE external_monitor (
  host_id    INT,
  idc        STRING,
  ts         TIMESTAMP TIME INDEX,
  cpu        DOUBLE DEFAULT 0,
  memory     DOUBLE,
  PRIMARY KEY (host),
)
ENGINE=file
...

CREATE TABLE my_metric (
  host_id    INT,
  idc        STRING,
  ts         TIMESTAMP TIME INDEX,
  cpu        DOUBLE DEFAULT 0,
  memory     DOUBLE,
  PRIMARY KEY (host),
)
ENGINE=metric

What does the feature do?

By default, If we run the following SQL, the database will create a table using a default mito engine.

CREATE TABLE monitor (
  host_id    INT,
  idc        STRING,
  ts         TIMESTAMP TIME INDEX,
  cpu        DOUBLE DEFAULT 0,
  memory     DOUBLE,
  PRIMARY KEY (host),
)

Which equals the following:

CREATE TABLE monitor (
  host_id    INT,
  idc        STRING,
  ts         TIMESTAMP TIME INDEX,
  cpu        DOUBLE DEFAULT 0,
  memory     DOUBLE,
  PRIMARY KEY (host),
)
ENGINE=mito

Now, we will support multiple table engines, e.g., file table engine, metric engine, etc.

Some places need to be modified to adapt to this feature.

Registers table engine type to catalog, and removes hard code:

greptimedb/src/catalog/src/tables.rs

Lines 82 to 90 in 0943079

	async fn scan(
	&self,
	_projection: Option<&Vec<usize>>,
	_filters: &[Expr],
	_limit: Option<usize>,
	) -> table::error::Result<PhysicalPlanRef> {
	let catalogs = self.catalogs.clone();
	let schema_ref = self.schema.clone();
	let engine_name = self.engine_name.clone();

Distinguishes between different table engines via catalog and recovers them:

greptimedb/src/catalog/src/local/manager.rs

Lines 235 to 261 in 0943079

	async fn open_and_register_table(&self, t: &TableEntry) -> Result<()> {
	let catalog = self
	.catalogs
	.catalog(&t.catalog_name)?
	.context(CatalogNotFoundSnafu {
	catalog_name: &t.catalog_name,
	})?;
	let schema = catalog
	.schema(&t.schema_name)?
	.context(SchemaNotFoundSnafu {
	catalog: &t.catalog_name,
	schema: &t.schema_name,
	})?;
	let context = EngineContext {};
	let request = OpenTableRequest {
	catalog_name: t.catalog_name.clone(),
	schema_name: t.schema_name.clone(),
	table_name: t.table_name.clone(),
	table_id: t.table_id,
	};
	let option = self
	.engine
	.open_table(&context, request)
	.await
	.with_context(|_| OpenTableSnafu {

Implementation challenges

compatibility