chore: rename change to modify (#5000)

* chore: rename change to modify * chore: proto rev
2025-12-23 06:30:05 +00:00 · 2024-11-15 14:58:26 +08:00
parent cdba7b442f
commit a2852affeb
13 changed files with 103 additions and 103 deletions
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4595,7 +4595,7 @@ dependencies = [
 [[package]]
 name = "greptime-proto"
 version = "0.1.0"
-source = "git+https://github.com/GreptimeTeam/greptime-proto.git?rev=e1070ad3e7ad3d89f8dd1e20756b0c0cc26f3365#e1070ad3e7ad3d89f8dd1e20756b0c0cc26f3365"
+source = "git+https://github.com/GreptimeTeam/greptime-proto.git?rev=fb4e2146b1ea8816148304f1f258e7a73736a905#fb4e2146b1ea8816148304f1f258e7a73736a905"
 dependencies = [
 "prost 0.12.6",
 "serde",
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -122,7 +122,7 @@ etcd-client = "0.13"
 fst = "0.4.7"
 futures = "0.3"
 futures-util = "0.3"
-greptime-proto = { git = "https://github.com/GreptimeTeam/greptime-proto.git", rev = "e1070ad3e7ad3d89f8dd1e20756b0c0cc26f3365" }
+greptime-proto = { git = "https://github.com/GreptimeTeam/greptime-proto.git", rev = "fb4e2146b1ea8816148304f1f258e7a73736a905" }
 hex = "0.4"
 humantime = "2.1"
 humantime-serde = "1.1"
--- a/src/common/grpc-expr/src/alter.rs
+++ b/src/common/grpc-expr/src/alter.rs
@@ -17,15 +17,15 @@ use api::v1::add_column_location::LocationType;
 use api::v1::alter_expr::Kind;
 use api::v1::column_def::as_fulltext_option;
 use api::v1::{
-    column_def, AddColumnLocation as Location, AlterExpr, Analyzer, ChangeColumnTypes,
-    CreateTableExpr, DropColumns, RenameTable, SemanticType,
+    column_def, AddColumnLocation as Location, AlterExpr, Analyzer, CreateTableExpr, DropColumns,
+    ModifyColumnTypes, RenameTable, SemanticType,
 };
 use common_query::AddColumnLocation;
 use datatypes::schema::{ColumnSchema, FulltextOptions, RawSchema};
 use snafu::{ensure, OptionExt, ResultExt};
 use store_api::region_request::ChangeOption;
 use table::metadata::TableId;
-use table::requests::{AddColumnRequest, AlterKind, AlterTableRequest, ChangeColumnTypeRequest};
+use table::requests::{AddColumnRequest, AlterKind, AlterTableRequest, ModifyColumnTypeRequest};

 use crate::error::{
    InvalidChangeFulltextOptionRequestSnafu, InvalidChangeTableOptionRequestSnafu,
@@ -68,25 +68,25 @@ pub fn alter_expr_to_request(table_id: TableId, expr: AlterExpr) -> Result<Alter
                columns: add_column_requests,
            }
        }
-        Kind::ChangeColumnTypes(ChangeColumnTypes {
-            change_column_types,
+        Kind::ModifyColumnTypes(ModifyColumnTypes {
+            modify_column_types,
        }) => {
-            let change_column_type_requests = change_column_types
+            let modify_column_type_requests = modify_column_types
                .into_iter()
                .map(|cct| {
                    let target_type =
                        ColumnDataTypeWrapper::new(cct.target_type(), cct.target_type_extension)
                            .into();

-                    Ok(ChangeColumnTypeRequest {
+                    Ok(ModifyColumnTypeRequest {
                        column_name: cct.column_name,
                        target_type,
                    })
                })
                .collect::<Result<Vec<_>>>()?;

-            AlterKind::ChangeColumnTypes {
-                columns: change_column_type_requests,
+            AlterKind::ModifyColumnTypes {
+                columns: modify_column_type_requests,
            }
        }
        Kind::DropColumns(DropColumns { drop_columns }) => AlterKind::DropColumns {
@@ -183,7 +183,7 @@ fn parse_location(location: Option<Location>) -> Result<Option<AddColumnLocation
 #[cfg(test)]
 mod tests {
    use api::v1::{
-        AddColumn, AddColumns, ChangeColumnType, ColumnDataType, ColumnDef, DropColumn,
+        AddColumn, AddColumns, ColumnDataType, ColumnDef, DropColumn, ModifyColumnType,
        SemanticType,
    };
    use datatypes::prelude::ConcreteDataType;
@@ -309,14 +309,14 @@ mod tests {
    }

    #[test]
-    fn test_change_column_type_expr() {
+    fn test_modify_column_type_expr() {
        let expr = AlterExpr {
            catalog_name: "test_catalog".to_string(),
            schema_name: "test_schema".to_string(),
            table_name: "monitor".to_string(),

-            kind: Some(Kind::ChangeColumnTypes(ChangeColumnTypes {
-                change_column_types: vec![ChangeColumnType {
+            kind: Some(Kind::ModifyColumnTypes(ModifyColumnTypes {
+                modify_column_types: vec![ModifyColumnType {
                    column_name: "mem_usage".to_string(),
                    target_type: ColumnDataType::String as i32,
                    target_type_extension: None,
@@ -329,16 +329,16 @@ mod tests {
        assert_eq!(alter_request.schema_name, "test_schema");
        assert_eq!("monitor".to_string(), alter_request.table_name);

-        let mut change_column_types = match alter_request.alter_kind {
-            AlterKind::ChangeColumnTypes { columns } => columns,
+        let mut modify_column_types = match alter_request.alter_kind {
+            AlterKind::ModifyColumnTypes { columns } => columns,
            _ => unreachable!(),
        };

-        let change_column_type = change_column_types.pop().unwrap();
-        assert_eq!("mem_usage", change_column_type.column_name);
+        let modify_column_type = modify_column_types.pop().unwrap();
+        assert_eq!("mem_usage", modify_column_type.column_name);
        assert_eq!(
            ConcreteDataType::string_datatype(),
-            change_column_type.target_type
+            modify_column_type.target_type
        );
    }

--- a/src/common/meta/src/ddl/alter_table/region_request.rs
+++ b/src/common/meta/src/ddl/alter_table/region_request.rs
@@ -91,7 +91,7 @@ fn create_proto_alter_kind(
                add_columns,
            })))
        }
-        Kind::ChangeColumnTypes(x) => Ok(Some(alter_request::Kind::ChangeColumnTypes(x.clone()))),
+        Kind::ModifyColumnTypes(x) => Ok(Some(alter_request::Kind::ModifyColumnTypes(x.clone()))),
        Kind::DropColumns(x) => {
            let drop_columns = x
                .drop_columns
@@ -123,8 +123,8 @@ mod tests {
    use api::v1::region::region_request::Body;
    use api::v1::region::RegionColumnDef;
    use api::v1::{
-        region, AddColumn, AddColumnLocation, AddColumns, AlterExpr, ChangeColumnType,
-        ChangeColumnTypes, ColumnDataType, ColumnDef as PbColumnDef, SemanticType,
+        region, AddColumn, AddColumnLocation, AddColumns, AlterExpr, ColumnDataType,
+        ColumnDef as PbColumnDef, ModifyColumnType, ModifyColumnTypes, SemanticType,
    };
    use common_catalog::consts::{DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME};
    use store_api::storage::{RegionId, TableId};
@@ -284,8 +284,8 @@ mod tests {
                catalog_name: DEFAULT_CATALOG_NAME.to_string(),
                schema_name: DEFAULT_SCHEMA_NAME.to_string(),
                table_name,
-                kind: Some(Kind::ChangeColumnTypes(ChangeColumnTypes {
-                    change_column_types: vec![ChangeColumnType {
+                kind: Some(Kind::ModifyColumnTypes(ModifyColumnTypes {
+                    modify_column_types: vec![ModifyColumnType {
                        column_name: "cpu".to_string(),
                        target_type: ColumnDataType::String as i32,
                        target_type_extension: None,
@@ -306,9 +306,9 @@ mod tests {
        assert_eq!(alter_region_request.schema_version, 1);
        assert_eq!(
            alter_region_request.kind,
-            Some(region::alter_request::Kind::ChangeColumnTypes(
-                ChangeColumnTypes {
-                    change_column_types: vec![ChangeColumnType {
+            Some(region::alter_request::Kind::ModifyColumnTypes(
+                ModifyColumnTypes {
+                    modify_column_types: vec![ModifyColumnType {
                        column_name: "cpu".to_string(),
                        target_type: ColumnDataType::String as i32,
                        target_type_extension: None,
--- a/src/common/meta/src/ddl/alter_table/update_metadata.rs
+++ b/src/common/meta/src/ddl/alter_table/update_metadata.rs
@@ -52,7 +52,7 @@ impl AlterTableProcedure {
                new_info.name = new_table_name.to_string();
            }
            AlterKind::DropColumns { .. }
-            | AlterKind::ChangeColumnTypes { .. }
+            | AlterKind::ModifyColumnTypes { .. }
            | AlterKind::ChangeTableOptions { .. }
            | AlterKind::ChangeColumnFulltext { .. } => {}
        }
--- a/src/operator/src/expr_factory.rs
+++ b/src/operator/src/expr_factory.rs
@@ -18,9 +18,9 @@ use api::helper::ColumnDataTypeWrapper;
 use api::v1::alter_expr::Kind;
 use api::v1::column_def::options_from_column_schema;
 use api::v1::{
-    AddColumn, AddColumns, AlterExpr, Analyzer, ChangeColumnFulltext, ChangeColumnType,
-    ChangeColumnTypes, ChangeTableOptions, ColumnDataType, ColumnDataTypeExtension, CreateFlowExpr,
-    CreateTableExpr, CreateViewExpr, DropColumn, DropColumns, ExpireAfter, RenameTable,
+    AddColumn, AddColumns, AlterExpr, Analyzer, ChangeColumnFulltext, ChangeTableOptions,
+    ColumnDataType, ColumnDataTypeExtension, CreateFlowExpr, CreateTableExpr, CreateViewExpr,
+    DropColumn, DropColumns, ExpireAfter, ModifyColumnType, ModifyColumnTypes, RenameTable,
    SemanticType, TableName,
 };
 use common_error::ext::BoxedError;
@@ -501,7 +501,7 @@ pub(crate) fn to_alter_expr(
                location: location.as_ref().map(From::from),
            }],
        }),
-        AlterTableOperation::ChangeColumnType {
+        AlterTableOperation::ModifyColumnType {
            column_name,
            target_type,
        } => {
@@ -510,8 +510,8 @@ pub(crate) fn to_alter_expr(
            let (target_type, target_type_extension) = ColumnDataTypeWrapper::try_from(target_type)
                .map(|w| w.to_parts())
                .context(ColumnDataTypeSnafu)?;
-            Kind::ChangeColumnTypes(ChangeColumnTypes {
-                change_column_types: vec![ChangeColumnType {
+            Kind::ModifyColumnTypes(ModifyColumnTypes {
+                modify_column_types: vec![ModifyColumnType {
                    column_name: column_name.value,
                    target_type: target_type as i32,
                    target_type_extension,
@@ -803,7 +803,7 @@ mod tests {
    }

    #[test]
-    fn test_to_alter_change_column_type_expr() {
+    fn test_to_alter_modify_column_type_expr() {
        let sql = "ALTER TABLE monitor MODIFY COLUMN mem_usage STRING;";
        let stmt =
            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default())
@@ -819,22 +819,22 @@ mod tests {
        let expr = to_alter_expr(alter_table.clone(), &QueryContext::arc()).unwrap();
        let kind = expr.kind.unwrap();

-        let Kind::ChangeColumnTypes(ChangeColumnTypes {
-            change_column_types,
+        let Kind::ModifyColumnTypes(ModifyColumnTypes {
+            modify_column_types,
        }) = kind
        else {
            unreachable!()
        };

-        assert_eq!(1, change_column_types.len());
-        let change_column_type = &change_column_types[0];
+        assert_eq!(1, modify_column_types.len());
+        let modify_column_type = &modify_column_types[0];

-        assert_eq!("mem_usage", change_column_type.column_name);
+        assert_eq!("mem_usage", modify_column_type.column_name);
        assert_eq!(
            ColumnDataType::String as i32,
-            change_column_type.target_type
+            modify_column_type.target_type
        );
-        assert!(change_column_type.target_type_extension.is_none());
+        assert!(modify_column_type.target_type_extension.is_none());
    }

    fn new_test_table_names() -> Vec<TableName> {
--- a/src/sql/src/parsers/alter_parser.rs
+++ b/src/sql/src/parsers/alter_parser.rs
@@ -170,7 +170,7 @@ impl ParserContext<'_> {
                    self.parse_alter_column_fulltext(column_name)
                } else {
                    let data_type = self.parser.parse_data_type().context(error::SyntaxSnafu)?;
-                    Ok(AlterTableOperation::ChangeColumnType {
+                    Ok(AlterTableOperation::ModifyColumnType {
                        column_name,
                        target_type: data_type,
                    })
@@ -399,7 +399,7 @@ mod tests {
    }

    #[test]
-    fn test_parse_alter_change_column_type() {
+    fn test_parse_alter_modify_column_type() {
        let sql_1 = "ALTER TABLE my_metric_1 MODIFY COLUMN a STRING";
        let result_1 = ParserContext::create_with_dialect(
            sql_1,
@@ -427,10 +427,10 @@ mod tests {
                let alter_operation = alter_table.alter_operation();
                assert_matches!(
                    alter_operation,
-                    AlterTableOperation::ChangeColumnType { .. }
+                    AlterTableOperation::ModifyColumnType { .. }
                );
                match alter_operation {
-                    AlterTableOperation::ChangeColumnType {
+                    AlterTableOperation::ModifyColumnType {
                        column_name,
                        target_type,
                    } => {
@@ -461,10 +461,10 @@ mod tests {
                let alter_operation = alter_table.alter_operation();
                assert_matches!(
                    alter_operation,
-                    AlterTableOperation::ChangeColumnType { .. }
+                    AlterTableOperation::ModifyColumnType { .. }
                );
                match alter_operation {
-                    AlterTableOperation::ChangeColumnType {
+                    AlterTableOperation::ModifyColumnType {
                        column_name,
                        target_type,
                    } => {
@@ -492,10 +492,10 @@ mod tests {
                let alter_operation = alter_table.alter_operation();
                assert_matches!(
                    alter_operation,
-                    AlterTableOperation::ChangeColumnType { .. }
+                    AlterTableOperation::ModifyColumnType { .. }
                );
                match alter_operation {
-                    AlterTableOperation::ChangeColumnType {
+                    AlterTableOperation::ModifyColumnType {
                        column_name,
                        target_type,
                    } => {
--- a/src/sql/src/statements/alter.rs
+++ b/src/sql/src/statements/alter.rs
@@ -66,7 +66,7 @@ pub enum AlterTableOperation {
        location: Option<AddColumnLocation>,
    },
    /// `MODIFY <column_name> [target_type]`
-    ChangeColumnType {
+    ModifyColumnType {
        column_name: Ident,
        target_type: DataType,
    },
@@ -101,7 +101,7 @@ impl Display for AlterTableOperation {
            AlterTableOperation::RenameTable { new_table_name } => {
                write!(f, r#"RENAME {new_table_name}"#)
            }
-            AlterTableOperation::ChangeColumnType {
+            AlterTableOperation::ModifyColumnType {
                column_name,
                target_type,
            } => {
--- a/src/sql/src/statements/transform/type_alias.rs
+++ b/src/sql/src/statements/transform/type_alias.rs
@@ -53,7 +53,7 @@ impl TransformRule for TypeAliasTransformRule {
                    .for_each(|column| replace_type_alias(column.mut_data_type()));
            }
            Statement::Alter(alter_table) => {
-                if let AlterTableOperation::ChangeColumnType { target_type, .. } =
+                if let AlterTableOperation::ModifyColumnType { target_type, .. } =
                    alter_table.alter_operation_mut()
                {
                    replace_type_alias(target_type)
--- a/src/store-api/src/metadata.rs
+++ b/src/store-api/src/metadata.rs
@@ -33,7 +33,7 @@ use serde::de::Error;
 use serde::{Deserialize, Deserializer, Serialize};
 use snafu::{ensure, Location, OptionExt, ResultExt, Snafu};

-use crate::region_request::{AddColumn, AddColumnLocation, AlterKind, ChangeColumnType};
+use crate::region_request::{AddColumn, AddColumnLocation, AlterKind, ModifyColumnType};
 use crate::storage::consts::is_internal_column;
 use crate::storage::{ColumnId, RegionId};

@@ -552,7 +552,7 @@ impl RegionMetadataBuilder {
        match kind {
            AlterKind::AddColumns { columns } => self.add_columns(columns)?,
            AlterKind::DropColumns { names } => self.drop_columns(&names),
-            AlterKind::ChangeColumnTypes { columns } => self.change_column_types(columns),
+            AlterKind::ModifyColumnTypes { columns } => self.modify_column_types(columns),
            AlterKind::ChangeColumnFulltext {
                column_name,
                options,
@@ -642,11 +642,11 @@ impl RegionMetadataBuilder {
    }

    /// Changes columns type to the metadata if exist.
-    fn change_column_types(&mut self, columns: Vec<ChangeColumnType>) {
+    fn modify_column_types(&mut self, columns: Vec<ModifyColumnType>) {
        let mut change_type_map: HashMap<_, _> = columns
            .into_iter()
            .map(
-                |ChangeColumnType {
+                |ModifyColumnType {
                     column_name,
                     target_type,
                 }| (column_name, target_type),
@@ -1265,8 +1265,8 @@ mod test {

        let mut builder = RegionMetadataBuilder::from_existing(metadata);
        builder
-            .alter(AlterKind::ChangeColumnTypes {
-                columns: vec![ChangeColumnType {
+            .alter(AlterKind::ModifyColumnTypes {
+                columns: vec![ModifyColumnType {
                    column_name: "b".to_string(),
                    target_type: ConcreteDataType::string_datatype(),
                }],
--- a/src/store-api/src/region_request.rs
+++ b/src/store-api/src/region_request.rs
@@ -408,9 +408,9 @@ pub enum AlterKind {
        names: Vec<String>,
    },
    /// Change columns datatype form the region, only fields are allowed to change.
-    ChangeColumnTypes {
+    ModifyColumnTypes {
        /// Columns to change.
-        columns: Vec<ChangeColumnType>,
+        columns: Vec<ModifyColumnType>,
    },
    /// Change region options.
    ChangeRegionOptions { options: Vec<ChangeOption> },
@@ -437,7 +437,7 @@ impl AlterKind {
                    Self::validate_column_to_drop(name, metadata)?;
                }
            }
-            AlterKind::ChangeColumnTypes { columns } => {
+            AlterKind::ModifyColumnTypes { columns } => {
                for col_to_change in columns {
                    col_to_change.validate(metadata)?;
                }
@@ -460,7 +460,7 @@ impl AlterKind {
            AlterKind::DropColumns { names } => names
                .iter()
                .any(|name| metadata.column_by_name(name).is_some()),
-            AlterKind::ChangeColumnTypes { columns } => columns
+            AlterKind::ModifyColumnTypes { columns } => columns
                .iter()
                .any(|col_to_change| col_to_change.need_alter(metadata)),
            AlterKind::ChangeRegionOptions { .. } => {
@@ -529,13 +529,13 @@ impl TryFrom<alter_request::Kind> for AlterKind {
                    .collect::<Result<Vec<_>>>()?;
                AlterKind::AddColumns { columns }
            }
-            alter_request::Kind::ChangeColumnTypes(x) => {
+            alter_request::Kind::ModifyColumnTypes(x) => {
                let columns = x
-                    .change_column_types
+                    .modify_column_types
                    .into_iter()
                    .map(|x| x.into())
                    .collect::<Vec<_>>();
-                AlterKind::ChangeColumnTypes { columns }
+                AlterKind::ModifyColumnTypes { columns }
            }
            alter_request::Kind::DropColumns(x) => {
                let names = x.drop_columns.into_iter().map(|x| x.name).collect();
@@ -663,14 +663,14 @@ impl TryFrom<v1::AddColumnLocation> for AddColumnLocation {

 /// Change a column's datatype.
 #[derive(Debug, PartialEq, Eq, Clone)]
-pub struct ChangeColumnType {
+pub struct ModifyColumnType {
    /// Schema of the column to modify.
    pub column_name: String,
    /// Column will be changed to this type.
    pub target_type: ConcreteDataType,
 }

-impl ChangeColumnType {
+impl ModifyColumnType {
    /// Returns an error if the column's datatype to change is invalid.
    pub fn validate(&self, metadata: &RegionMetadata) -> Result<()> {
        let column_meta = metadata
@@ -711,16 +711,16 @@ impl ChangeColumnType {
    }
 }

-impl From<v1::ChangeColumnType> for ChangeColumnType {
-    fn from(change_column_type: v1::ChangeColumnType) -> Self {
+impl From<v1::ModifyColumnType> for ModifyColumnType {
+    fn from(modify_column_type: v1::ModifyColumnType) -> Self {
        let target_type = ColumnDataTypeWrapper::new(
-            change_column_type.target_type(),
-            change_column_type.target_type_extension,
+            modify_column_type.target_type(),
+            modify_column_type.target_type_extension,
        )
        .into();

-        ChangeColumnType {
-            column_name: change_column_type.column_name,
+        ModifyColumnType {
+            column_name: modify_column_type.column_name,
            target_type,
        }
    }
@@ -1072,10 +1072,10 @@ mod tests {
    }

    #[test]
-    fn test_validate_change_column_type() {
+    fn test_validate_modify_column_type() {
        let metadata = new_metadata();
-        AlterKind::ChangeColumnTypes {
-            columns: vec![ChangeColumnType {
+        AlterKind::ModifyColumnTypes {
+            columns: vec![ModifyColumnType {
                column_name: "xxxx".to_string(),
                target_type: ConcreteDataType::string_datatype(),
            }],
@@ -1083,8 +1083,8 @@ mod tests {
        .validate(&metadata)
        .unwrap_err();

-        AlterKind::ChangeColumnTypes {
-            columns: vec![ChangeColumnType {
+        AlterKind::ModifyColumnTypes {
+            columns: vec![ModifyColumnType {
                column_name: "field_1".to_string(),
                target_type: ConcreteDataType::date_datatype(),
            }],
@@ -1092,8 +1092,8 @@ mod tests {
        .validate(&metadata)
        .unwrap_err();

-        AlterKind::ChangeColumnTypes {
-            columns: vec![ChangeColumnType {
+        AlterKind::ModifyColumnTypes {
+            columns: vec![ModifyColumnType {
                column_name: "ts".to_string(),
                target_type: ConcreteDataType::date_datatype(),
            }],
@@ -1101,8 +1101,8 @@ mod tests {
        .validate(&metadata)
        .unwrap_err();

-        AlterKind::ChangeColumnTypes {
-            columns: vec![ChangeColumnType {
+        AlterKind::ModifyColumnTypes {
+            columns: vec![ModifyColumnType {
                column_name: "tag_0".to_string(),
                target_type: ConcreteDataType::date_datatype(),
            }],
@@ -1110,8 +1110,8 @@ mod tests {
        .validate(&metadata)
        .unwrap_err();

-        let kind = AlterKind::ChangeColumnTypes {
-            columns: vec![ChangeColumnType {
+        let kind = AlterKind::ModifyColumnTypes {
+            columns: vec![ModifyColumnType {
                column_name: "field_0".to_string(),
                target_type: ConcreteDataType::int32_datatype(),
            }],
--- a/src/table/src/metadata.rs
+++ b/src/table/src/metadata.rs
@@ -32,7 +32,7 @@ use store_api::region_request::ChangeOption;
 use store_api::storage::{ColumnDescriptor, ColumnDescriptorBuilder, ColumnId, RegionId};

 use crate::error::{self, Result};
-use crate::requests::{AddColumnRequest, AlterKind, ChangeColumnTypeRequest, TableOptions};
+use crate::requests::{AddColumnRequest, AlterKind, ModifyColumnTypeRequest, TableOptions};

 pub type TableId = u32;
 pub type TableVersion = u64;
@@ -201,8 +201,8 @@ impl TableMeta {
                self.add_columns(table_name, columns, add_if_not_exists)
            }
            AlterKind::DropColumns { names } => self.remove_columns(table_name, names),
-            AlterKind::ChangeColumnTypes { columns } => {
-                self.change_column_types(table_name, columns)
+            AlterKind::ModifyColumnTypes { columns } => {
+                self.modify_column_types(table_name, columns)
            }
            // No need to rebuild table meta when renaming tables.
            AlterKind::RenameTable { .. } => Ok(self.new_meta_builder()),
@@ -579,15 +579,15 @@ impl TableMeta {
        Ok(meta_builder)
    }

-    fn change_column_types(
+    fn modify_column_types(
        &self,
        table_name: &str,
-        requests: &[ChangeColumnTypeRequest],
+        requests: &[ModifyColumnTypeRequest],
    ) -> Result<TableMetaBuilder> {
        let table_schema = &self.schema;
        let mut meta_builder = self.new_meta_builder();

-        let mut change_column_types = HashMap::with_capacity(requests.len());
+        let mut modify_column_types = HashMap::with_capacity(requests.len());
        let timestamp_index = table_schema.timestamp_index();

        for col_to_change in requests {
@@ -628,7 +628,7 @@ impl TableMeta {
            }

            ensure!(
-                change_column_types
+                modify_column_types
                    .insert(&col_to_change.column_name, col_to_change)
                    .is_none(),
                error::InvalidAlterRequestSnafu {
@@ -670,7 +670,7 @@ impl TableMeta {
            .iter()
            .cloned()
            .map(|mut column| {
-                if let Some(change_column) = change_column_types.get(&column.name) {
+                if let Some(change_column) = modify_column_types.get(&column.name) {
                    column.data_type = change_column.target_type.clone();
                }
                column
@@ -1298,8 +1298,8 @@ mod tests {
            .build()
            .unwrap();

-        let alter_kind = AlterKind::ChangeColumnTypes {
-            columns: vec![ChangeColumnTypeRequest {
+        let alter_kind = AlterKind::ModifyColumnTypes {
+            columns: vec![ModifyColumnTypeRequest {
                column_name: "unknown".to_string(),
                target_type: ConcreteDataType::string_datatype(),
            }],
@@ -1358,8 +1358,8 @@ mod tests {
            .unwrap();

        // Remove column in primary key.
-        let alter_kind = AlterKind::ChangeColumnTypes {
-            columns: vec![ChangeColumnTypeRequest {
+        let alter_kind = AlterKind::ModifyColumnTypes {
+            columns: vec![ModifyColumnTypeRequest {
                column_name: "col1".to_string(),
                target_type: ConcreteDataType::string_datatype(),
            }],
@@ -1372,8 +1372,8 @@ mod tests {
        assert_eq!(StatusCode::InvalidArguments, err.status_code());

        // Remove timestamp column.
-        let alter_kind = AlterKind::ChangeColumnTypes {
-            columns: vec![ChangeColumnTypeRequest {
+        let alter_kind = AlterKind::ModifyColumnTypes {
+            columns: vec![ModifyColumnTypeRequest {
                column_name: "ts".to_string(),
                target_type: ConcreteDataType::string_datatype(),
            }],
--- a/src/table/src/requests.rs
+++ b/src/table/src/requests.rs
@@ -194,7 +194,7 @@ pub struct AddColumnRequest {

 /// Change column datatype request
 #[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct ChangeColumnTypeRequest {
+pub struct ModifyColumnTypeRequest {
    pub column_name: String,
    pub target_type: ConcreteDataType,
 }
@@ -207,8 +207,8 @@ pub enum AlterKind {
    DropColumns {
        names: Vec<String>,
    },
-    ChangeColumnTypes {
-        columns: Vec<ChangeColumnTypeRequest>,
+    ModifyColumnTypes {
+        columns: Vec<ModifyColumnTypeRequest>,
    },
    RenameTable {
        new_table_name: String,