rust/greptimedb
1
0
Fork 0
mirror of https://github.com/GreptimeTeam/greptimedb.git synced 2026-05-23 16:30:39 +00:00
Code Issues Packages Projects Releases Wiki Activity

feat: distributed alter table in region server (#2311)

Browse Source 
* feat: distributed alter table in region server

* rebase
This commit is contained in:
LFC
2023-09-05 14:07:50 +08:00
committed by Ruihang Xia
parent 922e342b63
commit 711e27d9fa
33 changed files with 902 additions and 381 deletions
Download Patch File Download Diff File Expand all files Collapse all files

30
src/common/grpc-expr/src/alter.rs
View File

@@ -12,10 +12,12 @@
// See the License for the specific language governing permissions and
// limitations under the License.
use api::v1::add_column::location::LocationType;
use api::v1::add_column::Location;
use api::v1::add_column_location::LocationType;
use api::v1::alter_expr::Kind;
use api::v1::{column_def, AlterExpr, CreateTableExpr, DropColumns, RenameTable};
use api::v1::{
column_def, AddColumnLocation as Location, AlterExpr, CreateTableExpr, DropColumns,
RenameTable, SemanticType,
};
use common_catalog::consts::{DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME};
use common_query::AddColumnLocation;
use datatypes::schema::{ColumnSchema, RawSchema};
@@ -55,7 +57,7 @@ pub fn alter_expr_to_request(table_id: TableId, expr: AlterExpr) -> Result<Alter
)?;
Ok(AddColumnRequest {
column_schema: schema,
is_key: ac.is_key,
is_key: column_def.semantic_type == SemanticType::Tag as i32,
location: parse_location(ac.location)?,
})
})
@@ -79,7 +81,7 @@ pub fn alter_expr_to_request(table_id: TableId, expr: AlterExpr) -> Result<Alter
table_name: expr.table_name,
table_id,
alter_kind,
table_version: Some(expr.table_version),
table_version: None,
};
Ok(request)
}
@@ -197,8 +199,7 @@ fn parse_location(location: Option<Location>) -> Result<Option<AddColumnLocation
#[cfg(test)]
mod tests {
use api::v1::add_column::location::LocationType;
use api::v1::{AddColumn, AddColumns, ColumnDataType, ColumnDef, DropColumn};
use api::v1::{AddColumn, AddColumns, ColumnDataType, ColumnDef, DropColumn, SemanticType};
use datatypes::prelude::ConcreteDataType;
use super::*;
@@ -214,15 +215,14 @@ mod tests {
add_columns: vec![AddColumn {
column_def: Some(ColumnDef {
name: "mem_usage".to_string(),
datatype: ColumnDataType::Float64 as i32,
data_type: ColumnDataType::Float64 as i32,
is_nullable: false,
default_constraint: vec![],
semantic_type: SemanticType::Field as i32,
}),
is_key: false,
location: None,
}],
})),
..Default::default()
};
let alter_request = alter_expr_to_request(1, expr).unwrap();
@@ -255,11 +255,11 @@ mod tests {
AddColumn {
column_def: Some(ColumnDef {
name: "mem_usage".to_string(),
datatype: ColumnDataType::Float64 as i32,
data_type: ColumnDataType::Float64 as i32,
is_nullable: false,
default_constraint: vec![],
semantic_type: SemanticType::Field as i32,
}),
is_key: false,
location: Some(Location {
location_type: LocationType::First.into(),
after_column_name: "".to_string(),
@@ -268,11 +268,11 @@ mod tests {
AddColumn {
column_def: Some(ColumnDef {
name: "cpu_usage".to_string(),
datatype: ColumnDataType::Float64 as i32,
data_type: ColumnDataType::Float64 as i32,
is_nullable: false,
default_constraint: vec![],
semantic_type: SemanticType::Field as i32,
}),
is_key: false,
location: Some(Location {
location_type: LocationType::After.into(),
after_column_name: "ts".to_string(),
@@ -280,7 +280,6 @@ mod tests {
},
],
})),
..Default::default()
};
let alter_request = alter_expr_to_request(1, expr).unwrap();
@@ -329,7 +328,6 @@ mod tests {
name: "mem_usage".to_string(),
}],
})),
..Default::default()
};
let alter_request = alter_expr_to_request(1, expr).unwrap();

32
src/common/grpc-expr/src/insert.rs
View File

@@ -219,7 +219,7 @@ mod tests {
.iter()
.find(|c| c.name == "host")
.unwrap()
.datatype
.data_type
)
.unwrap()
)
@@ -233,7 +233,7 @@ mod tests {
.iter()
.find(|c| c.name == "cpu")
.unwrap()
.datatype
.data_type
)
.unwrap()
)
@@ -247,7 +247,7 @@ mod tests {
.iter()
.find(|c| c.name == "memory")
.unwrap()
.datatype
.data_type
)
.unwrap()
)
@@ -261,7 +261,7 @@ mod tests {
.iter()
.find(|c| c.name == "time")
.unwrap()
.datatype
.data_type
)
.unwrap()
)
@@ -275,7 +275,7 @@ mod tests {
.iter()
.find(|c| c.name == "interval")
.unwrap()
.datatype
.data_type
)
.unwrap()
)
@@ -289,7 +289,7 @@ mod tests {
.iter()
.find(|c| c.name == "ts")
.unwrap()
.datatype
.data_type
)
.unwrap()
)
@@ -316,46 +316,40 @@ mod tests {
assert_eq!(4, add_columns.add_columns.len());
let host_column = &add_columns.add_columns[0];
assert!(host_column.is_key);
assert_eq!(
ConcreteDataType::string_datatype(),
ConcreteDataType::from(
ColumnDataTypeWrapper::try_new(host_column.column_def.as_ref().unwrap().datatype)
ColumnDataTypeWrapper::try_new(host_column.column_def.as_ref().unwrap().data_type)
.unwrap()
)
);
let memory_column = &add_columns.add_columns[1];
assert!(!memory_column.is_key);
assert_eq!(
ConcreteDataType::float64_datatype(),
ConcreteDataType::from(
ColumnDataTypeWrapper::try_new(memory_column.column_def.as_ref().unwrap().datatype)
.unwrap()
ColumnDataTypeWrapper::try_new(
memory_column.column_def.as_ref().unwrap().data_type
)
.unwrap()
)
);
let time_column = &add_columns.add_columns[2];
assert!(!time_column.is_key);
assert_eq!(
ConcreteDataType::time_datatype(TimeUnit::Millisecond),
ConcreteDataType::from(
ColumnDataTypeWrapper::try_new(time_column.column_def.as_ref().unwrap().datatype)
ColumnDataTypeWrapper::try_new(time_column.column_def.as_ref().unwrap().data_type)
.unwrap()
)
);
let interval_column = &add_columns.add_columns[3];
assert!(!interval_column.is_key);
assert_eq!(
ConcreteDataType::interval_datatype(IntervalUnit::MonthDayNano),
ConcreteDataType::from(
ColumnDataTypeWrapper::try_new(
interval_column.column_def.as_ref().unwrap().datatype
interval_column.column_def.as_ref().unwrap().data_type
)
.unwrap()
)

8
src/common/grpc-expr/src/util.rs
View File

@@ -116,9 +116,10 @@ pub fn build_create_table_expr(
let column_def = ColumnDef {
name: column_name.to_string(),
datatype,
data_type: datatype,
is_nullable,
default_constraint: vec![],
semantic_type,
};
column_defs.push(column_def);
}
@@ -154,16 +155,15 @@ pub fn extract_new_columns(
.into_iter()
.filter(|expr| schema.column_schema_by_name(expr.column_name).is_none())
.map(|expr| {
let is_key = expr.semantic_type == SemanticType::Tag as i32;
let column_def = Some(ColumnDef {
name: expr.column_name.to_string(),
datatype: expr.datatype,
data_type: expr.datatype,
is_nullable: true,
default_constraint: vec![],
semantic_type: expr.semantic_type,
});
AddColumn {
column_def,
is_key,
location: None,
}
})

2
src/common/meta/Cargo.toml
View File

@@ -10,7 +10,7 @@ async-stream.workspace = true
async-trait.workspace = true
common-catalog = { workspace = true }
common-error = { workspace = true }
common-grpc-expr = { workspace = true }
common-grpc-expr.workspace = true
common-procedure = { workspace = true }
common-runtime = { workspace = true }
common-telemetry = { workspace = true }

246
src/common/meta/src/ddl/alter_table.rs
View File

@@ -14,51 +14,60 @@
use std::vec;
use api::v1::alter_expr::Kind;
use api::v1::region::{
alter_request, region_request, AddColumn, AddColumns, AlterRequest, DropColumn, DropColumns,
RegionColumnDef, RegionRequest,
};
use api::v1::{AlterExpr, RenameTable};
use async_trait::async_trait;
use common_grpc_expr::alter_expr_to_request;
use common_procedure::error::{FromJsonSnafu, Result as ProcedureResult, ToJsonSnafu};
use common_procedure::{
Context as ProcedureContext, Error as ProcedureError, LockKey, Procedure, Status,
};
use common_telemetry::{debug, info};
use futures::future;
use serde::{Deserialize, Serialize};
use snafu::{ensure, OptionExt, ResultExt};
use store_api::storage::RegionId;
use strum::AsRefStr;
use table::engine::TableReference;
use table::metadata::{RawTableInfo, TableId, TableInfo};
use table::requests::{AlterKind, AlterTableRequest};
use table::requests::AlterKind;
use crate::cache_invalidator::Context;
use crate::ddl::utils::handle_operate_region_error;
use crate::ddl::DdlContext;
use crate::error::{self, Result};
use crate::error::{
self, ConvertAlterTableRequestSnafu, InvalidProtoMsgSnafu, Result, TableRouteNotFoundSnafu,
};
use crate::ident::TableIdent;
use crate::key::table_info::TableInfoValue;
use crate::key::table_name::TableNameKey;
use crate::key::table_route::TableRouteValue;
use crate::metrics;
use crate::rpc::ddl::AlterTableTask;
use crate::rpc::router::RegionRoute;
use crate::rpc::router::{find_leader_regions, find_leaders};
use crate::table_name::TableName;
// TODO(weny): removes in following PRs.
#[allow(dead_code)]
pub struct AlterTableProcedure {
context: DdlContext,
data: AlterTableData,
}
// TODO(weny): removes in following PRs.
#[allow(dead_code)]
impl AlterTableProcedure {
pub const TYPE_NAME: &'static str = "metasrv-procedure::AlterTable";
pub fn new(
cluster_id: u64,
task: AlterTableTask,
alter_table_request: AlterTableRequest,
table_info_value: TableInfoValue,
context: DdlContext,
) -> Self {
Self {
context,
data: AlterTableData::new(task, alter_table_request, table_info_value, cluster_id),
data: AlterTableData::new(task, table_info_value, cluster_id),
}
}
@@ -70,45 +79,36 @@ impl AlterTableProcedure {
// Checks whether the table exists.
async fn on_prepare(&mut self) -> Result<Status> {
let request = &self.data.alter_table_request;
let alter_expr = &self.alter_expr();
let catalog = &alter_expr.catalog_name;
let schema = &alter_expr.schema_name;
let manager = &self.context.table_metadata_manager;
if let AlterKind::RenameTable { new_table_name } = &request.alter_kind {
if let Kind::RenameTable(RenameTable { new_table_name }) = self.alter_kind()? {
let new_table_name_key = TableNameKey::new(catalog, schema, new_table_name);
let exist = manager
.table_name_manager()
.exists(TableNameKey::new(
&request.catalog_name,
&request.schema_name,
new_table_name,
))
.exists(new_table_name_key)
.await?;
ensure!(
!exist,
error::TableAlreadyExistsSnafu {
table_name: common_catalog::format_full_table_name(
&request.catalog_name,
&request.schema_name,
new_table_name,
),
table_name: TableName::from(new_table_name_key).to_string(),
}
)
}
let exist = manager
.table_name_manager()
.exists(TableNameKey::new(
&request.catalog_name,
&request.schema_name,
&request.table_name,
))
.await?;
let table_name_key = TableNameKey::new(catalog, schema, &alter_expr.table_name);
let exist = manager.table_name_manager().exists(table_name_key).await?;
ensure!(
exist,
error::TableNotFoundSnafu {
table_name: request.table_ref().to_string()
table_name: TableName::from(table_name_key).to_string()
}
);
@@ -117,6 +117,124 @@ impl AlterTableProcedure {
Ok(Status::executing(true))
}
fn alter_expr(&self) -> &AlterExpr {
&self.data.task.alter_table
}
fn alter_kind(&self) -> Result<&Kind> {
self.alter_expr()
.kind
.as_ref()
.context(InvalidProtoMsgSnafu {
err_msg: "'kind' is absent",
})
}
pub fn create_alter_region_request(&self, region_id: RegionId) -> Result<AlterRequest> {
let table_info = self.data.table_info();
let kind =
match self.alter_kind()? {
Kind::AddColumns(x) => {
let mut next_column_id = table_info.meta.next_column_id;
let add_columns =
x.add_columns
.iter()
.map(|add_column| {
let column_def = add_column.column_def.as_ref().context(
InvalidProtoMsgSnafu {
err_msg: "'column_def' is absent",
},
)?;
let column_id = next_column_id;
next_column_id += 1;
let column_def = RegionColumnDef {
column_def: Some(column_def.clone()),
column_id,
};
Ok(AddColumn {
column_def: Some(column_def),
location: add_column.location.clone(),
})
})
.collect::<Result<Vec<_>>>()?;
alter_request::Kind::AddColumns(AddColumns { add_columns })
}
Kind::DropColumns(x) => {
let drop_columns = x
.drop_columns
.iter()
.map(|x| DropColumn {
name: x.name.clone(),
})
.collect::<Vec<_>>();
alter_request::Kind::DropColumns(DropColumns { drop_columns })
}
Kind::RenameTable(_) => unreachable!(),
};
Ok(AlterRequest {
region_id: region_id.as_u64(),
schema_version: table_info.ident.version,
kind: Some(kind),
})
}
pub async fn submit_alter_region_requests(&self) -> Result<Status> {
let table_id = self.data.table_id();
let table_ref = self.data.table_ref();
let TableRouteValue { region_routes, .. } = self
.context
.table_metadata_manager
.table_route_manager()
.get(table_id)
.await?
.with_context(|| TableRouteNotFoundSnafu {
table_name: table_ref.to_string(),
})?;
let leaders = find_leaders(&region_routes);
let mut alter_region_tasks = Vec::with_capacity(leaders.len());
for datanode in leaders {
let datanode_manager = self.context.datanode_manager.clone();
let regions = find_leader_regions(&region_routes, &datanode);
alter_region_tasks.push(async move {
for region in regions {
let region_id = RegionId::new(table_id, region);
let request = self.create_alter_region_request(region_id)?;
let request = RegionRequest {
header: None,
body: Some(region_request::Body::Alter(request)),
};
debug!("Submitting {request:?} to {datanode}");
let requester = datanode_manager.datanode(&datanode).await;
if let Err(e) = requester.handle(request).await {
return Err(handle_operate_region_error(datanode)(e));
}
}
Ok(())
});
}
future::join_all(alter_region_tasks)
.await
.into_iter()
.collect::<Result<Vec<_>>>()?;
Ok(Status::Done)
}
/// Update table metadata for rename table operation.
async fn on_update_metadata_for_rename(&self, new_table_name: String) -> Result<()> {
let table_metadata_manager = &self.context.table_metadata_manager;
@@ -148,7 +266,8 @@ impl AlterTableProcedure {
let table_ref = self.data.table_ref();
let request = &self.data.alter_table_request;
let request = alter_expr_to_request(self.data.table_id(), self.alter_expr().clone())
.context(ConvertAlterTableRequestSnafu)?;
let new_meta = table_info
.meta
@@ -172,11 +291,9 @@ impl AlterTableProcedure {
/// Update table metadata.
async fn on_update_metadata(&mut self) -> Result<Status> {
let request = &self.data.alter_table_request;
let table_id = self.data.table_id();
let table_ref = self.data.table_ref();
let new_info = self.build_new_table_info()?;
let table_metadata_manager = &self.context.table_metadata_manager;
debug!(
"starting update table: {} metadata, new table info {:?}",
@@ -184,7 +301,7 @@ impl AlterTableProcedure {
new_info
);
if let AlterKind::RenameTable { new_table_name } = &request.alter_kind {
if let Kind::RenameTable(RenameTable { new_table_name }) = self.alter_kind()? {
self.on_update_metadata_for_rename(new_table_name.to_string())
.await?;
} else {
@@ -193,27 +310,18 @@ impl AlterTableProcedure {
info!("Updated table metadata for table {table_id}");
let TableRouteValue { region_routes, .. } = table_metadata_manager
.table_route_manager()
.get(table_id)
.await?
.with_context(|| error::TableRouteNotFoundSnafu {
table_name: table_ref.to_string(),
})?;
self.data.region_routes = Some(region_routes);
self.data.state = AlterTableState::InvalidateTableCache;
Ok(Status::executing(true))
}
/// Broadcasts the invalidating table cache instructions.
async fn on_broadcast(&mut self) -> Result<Status> {
let table_name = self.data.table_name();
let table_ref = self.data.table_ref();
let table_ident = TableIdent {
catalog: table_name.catalog_name,
schema: table_name.schema_name,
table: table_name.table_name,
catalog: table_ref.catalog.to_string(),
schema: table_ref.schema.to_string(),
table: table_ref.table.to_string(),
table_id: self.data.table_id(),
engine: self.data.table_info().meta.engine.to_string(),
};
@@ -228,8 +336,14 @@ impl AlterTableProcedure {
)
.await?;
self.data.state = AlterTableState::DatanodeAlterTable;
Ok(Status::executing(true))
let alter_kind = self.alter_kind()?;
if matches!(alter_kind, Kind::RenameTable { .. }) {
Ok(Status::Done)
} else {
self.data.state = AlterTableState::SubmitAlterRegionRequests;
Ok(Status::executing(true))
}
}
fn lock_key_inner(&self) -> Vec<String> {
@@ -241,8 +355,7 @@ impl AlterTableProcedure {
);
let mut lock_key = vec![table_key];
if let AlterKind::RenameTable { new_table_name } = &self.data.alter_table_request.alter_kind
{
if let Ok(Kind::RenameTable(RenameTable { new_table_name })) = self.alter_kind() {
lock_key.push(common_catalog::format_full_table_name(
table_ref.catalog,
table_ref.schema,
@@ -269,11 +382,18 @@ impl Procedure for AlterTableProcedure {
}
};
match self.data.state {
let state = &self.data.state;
let _timer = common_telemetry::timer!(
metrics::METRIC_META_PROCEDURE_ALTER_TABLE,
&[("step", state.as_ref().to_string())]
);
match state {
AlterTableState::Prepare => self.on_prepare().await,
AlterTableState::UpdateMetadata => self.on_update_metadata().await,
AlterTableState::InvalidateTableCache => self.on_broadcast().await,
AlterTableState::DatanodeAlterTable => todo!(),
AlterTableState::SubmitAlterRegionRequests => self.submit_alter_region_requests().await,
}
.map_err(error_handler)
}
@@ -289,7 +409,7 @@ impl Procedure for AlterTableProcedure {
}
}
#[derive(Debug, Serialize, Deserialize)]
#[derive(Debug, Serialize, Deserialize, AsRefStr)]
enum AlterTableState {
/// Prepares to alter the table
Prepare,
@@ -297,32 +417,22 @@ enum AlterTableState {
UpdateMetadata,
/// Broadcasts the invalidating table cache instruction.
InvalidateTableCache,
/// Datanode alters the table.
DatanodeAlterTable,
SubmitAlterRegionRequests,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct AlterTableData {
state: AlterTableState,
task: AlterTableTask,
alter_table_request: AlterTableRequest,
region_routes: Option<Vec<RegionRoute>>,
table_info_value: TableInfoValue,
cluster_id: u64,
}
impl AlterTableData {
pub fn new(
task: AlterTableTask,
alter_table_request: AlterTableRequest,
table_info_value: TableInfoValue,
cluster_id: u64,
) -> Self {
pub fn new(task: AlterTableTask, table_info_value: TableInfoValue, cluster_id: u64) -> Self {
Self {
state: AlterTableState::Prepare,
task,
alter_table_request,
region_routes: None,
table_info_value,
cluster_id,
}
@@ -332,10 +442,6 @@ impl AlterTableData {
self.task.table_ref()
}
fn table_name(&self) -> TableName {
self.task.table_name()
}
fn table_id(&self) -> TableId {
self.table_info().ident.table_id
}

31
src/common/meta/src/ddl/create_table.rs
View File

@@ -14,9 +14,9 @@
use api::v1::region::region_request::Body as PbRegionRequest;
use api::v1::region::{
ColumnDef, CreateRequest as PbCreateRegionRequest, RegionRequest, RegionRequestHeader,
CreateRequest as PbCreateRegionRequest, RegionColumnDef, RegionRequest, RegionRequestHeader,
};
use api::v1::SemanticType;
use api::v1::{ColumnDef, SemanticType};
use async_trait::async_trait;
use common_procedure::error::{FromJsonSnafu, Result as ProcedureResult, ToJsonSnafu};
use common_procedure::{Context as ProcedureContext, LockKey, Procedure, Status};
@@ -42,7 +42,6 @@ pub struct CreateTableProcedure {
pub creator: TableCreator,
}
#[allow(dead_code)]
impl CreateTableProcedure {
pub const TYPE_NAME: &'static str = "metasrv-procedure::CreateTable";
@@ -124,13 +123,15 @@ impl CreateTableProcedure {
SemanticType::Field
};
ColumnDef {
name: c.name.clone(),
RegionColumnDef {
column_def: Some(ColumnDef {
name: c.name.clone(),
data_type: c.data_type,
is_nullable: c.is_nullable,
default_constraint: c.default_constraint.clone(),
semantic_type: semantic_type as i32,
}),
column_id: i as u32,
datatype: c.datatype,
is_nullable: c.is_nullable,
default_constraint: c.default_constraint.clone(),
semantic_type: semantic_type as i32,
}
})
.collect::<Vec<_>>();
@@ -142,11 +143,13 @@ impl CreateTableProcedure {
column_defs
.iter()
.find_map(|c| {
if &c.name == key {
Some(c.column_id)
} else {
None
}
c.column_def.as_ref().and_then(|x| {
if &x.name == key {
Some(c.column_id)
} else {
None
}
})
})
.context(error::PrimaryKeyNotFoundSnafu { key })
})

59
src/common/meta/src/ddl_manager.rs
View File

@@ -14,11 +14,9 @@
use std::sync::Arc;
use common_grpc_expr::alter_expr_to_request;
use common_procedure::{watcher, ProcedureId, ProcedureManagerRef, ProcedureWithId};
use common_telemetry::{error, info};
use snafu::{OptionExt, ResultExt};
use table::requests::AlterTableRequest;
use crate::cache_invalidator::CacheInvalidatorRef;
use crate::datanode_manager::DatanodeManagerRef;
@@ -27,10 +25,11 @@ use crate::ddl::create_table::CreateTableProcedure;
use crate::ddl::drop_table::DropTableProcedure;
use crate::ddl::{DdlContext, DdlExecutor, ExecutorContext, TableCreatorContext, TableCreatorRef};
use crate::error::{
self, RegisterProcedureLoaderSnafu, Result, SubmitProcedureSnafu, UnsupportedSnafu,
WaitProcedureSnafu,
self, RegisterProcedureLoaderSnafu, Result, SubmitProcedureSnafu, TableNotFoundSnafu,
UnsupportedSnafu, WaitProcedureSnafu,
};
use crate::key::table_info::TableInfoValue;
use crate::key::table_name::TableNameKey;
use crate::key::table_route::TableRouteValue;
use crate::key::TableMetadataManagerRef;
use crate::rpc::ddl::DdlTask::{AlterTable, CreateTable, DropTable, TruncateTable};
@@ -127,18 +126,12 @@ impl DdlManager {
&self,
cluster_id: u64,
alter_table_task: AlterTableTask,
alter_table_request: AlterTableRequest,
table_info_value: TableInfoValue,
) -> Result<ProcedureId> {
let context = self.create_context();
let procedure = AlterTableProcedure::new(
cluster_id,
alter_table_task,
alter_table_request,
table_info_value,
context,
);
let procedure =
AlterTableProcedure::new(cluster_id, alter_table_task, table_info_value, context);
let procedure_with_id = ProcedureWithId::with_random_id(Box::new(procedure));
@@ -255,23 +248,24 @@ async fn handle_truncate_table_task(
async fn handle_alter_table_task(
ddl_manager: &DdlManager,
cluster_id: u64,
mut alter_table_task: AlterTableTask,
alter_table_task: AlterTableTask,
) -> Result<SubmitDdlTaskResponse> {
let table_id = alter_table_task
.alter_table
.table_id
.as_ref()
.context(error::UnexpectedSnafu {
err_msg: "expected table id ",
})?
.id;
let mut alter_table_request =
alter_expr_to_request(table_id, alter_table_task.alter_table.clone())
.context(error::ConvertGrpcExprSnafu)?;
let table_ref = alter_table_task.table_ref();
let table_id = ddl_manager
.table_metadata_manager
.table_name_manager()
.get(TableNameKey::new(
table_ref.catalog,
table_ref.schema,
table_ref.table,
))
.await?
.with_context(|| TableNotFoundSnafu {
table_name: table_ref.to_string(),
})?
.table_id();
let table_info_value = ddl_manager
.table_metadata_manager()
.table_info_manager()
@@ -281,19 +275,8 @@ async fn handle_alter_table_task(
table_name: table_ref.to_string(),
})?;
let table_info = &table_info_value.table_info;
// Sets alter_table's table_version
alter_table_task.alter_table.table_version = table_info.ident.version;
alter_table_request.table_version = Some(table_info.ident.version);
let id = ddl_manager
.submit_alter_table_task(
cluster_id,
alter_table_task,
alter_table_request,
table_info_value,
)
.submit_alter_table_task(cluster_id, alter_table_task, table_info_value)
.await?;
info!("Table: {table_id} is altered via procedure_id {id:?}");

16
src/common/meta/src/error.rs
View File

@@ -26,12 +26,6 @@ use crate::peer::Peer;
#[derive(Debug, Snafu)]
#[snafu(visibility(pub))]
pub enum Error {
#[snafu(display("Failed to convert grpc expr, source: {}", source))]
ConvertGrpcExpr {
location: Location,
source: common_grpc_expr::error::Error,
},
#[snafu(display("Table info not found: {}", table_name))]
TableInfoNotFound {
table_name: String,
@@ -146,7 +140,13 @@ pub enum Error {
location: Location,
},
#[snafu(display("Invalid protobuf message, err: {}", err_msg))]
#[snafu(display("Failed to convert alter table request, source: {source}, at {location}"))]
ConvertAlterTableRequest {
source: common_grpc_expr::error::Error,
location: Location,
},
#[snafu(display("Invalid protobuf message: {err_msg}, at {location}"))]
InvalidProtoMsg { err_msg: String, location: Location },
#[snafu(display("Unexpected: {err_msg}"))]
@@ -265,7 +265,6 @@ impl ErrorExt for Error {
| MoveRegion { .. }
| Unexpected { .. }
| External { .. }
| ConvertGrpcExpr { .. }
| TableInfoNotFound { .. }
| InvalidHeartbeatResponse { .. } => StatusCode::Unexpected,
@@ -300,6 +299,7 @@ impl ErrorExt for Error {
ExecuteDdl { source, .. } => source.status_code(),
MetaSrv { source, .. } => source.status_code(),
InvalidCatalogValue { source, .. } => source.status_code(),
ConvertAlterTableRequest { source, .. } => source.status_code(),
}
}

1
src/common/meta/src/metrics.rs
View File

@@ -16,3 +16,4 @@ pub const METRIC_META_TXN_REQUEST: &str = "meta.txn_request";
pub(crate) const METRIC_META_PROCEDURE_CREATE_TABLE: &str = "meta.procedure.create_table";
pub(crate) const METRIC_META_PROCEDURE_DROP_TABLE: &str = "meta.procedure.drop_table";
pub(crate) const METRIC_META_PROCEDURE_ALTER_TABLE: &str = "meta.procedure.alter_table";

4
src/common/query/src/lib.rs
View File

@@ -14,8 +14,8 @@
use std::fmt::{Debug, Formatter};
use api::greptime_proto::v1::add_column::location::LocationType;
use api::greptime_proto::v1::add_column::Location;
use api::greptime_proto::v1::add_column_location::LocationType;
use api::greptime_proto::v1::AddColumnLocation as Location;
use common_recordbatch::{RecordBatches, SendableRecordBatchStream};
use serde::{Deserialize, Serialize};