feat: Alter column fulltext option

Cargo.toml

@@ -119,7 +119,7 @@ etcd-client = { version = "0.13" }
 fst = "0.4.7"
 futures = "0.3"
 futures-util = "0.3"
-greptime-proto = { git = "https://github.com/GreptimeTeam/greptime-proto.git", rev = "c437b55725b7f5224fe9d46db21072b4a682ee4b" }
+greptime-proto = { git = "https://github.com/irenjj/greptime-proto.git", rev = "6df0c7ba6d0c9acfcf155483d19889ffed3ef99d" }
 humantime = "2.1"
 humantime-serde = "1.1"
 itertools = "0.10"

src/api/src/v1/column_def.rs

@@ -148,7 +148,7 @@ mod tests {
         assert!(options.is_none());
 
         let schema = ColumnSchema::new("test", ConcreteDataType::string_datatype(), true)
-            .with_fulltext_options(FulltextOptions {
+            .with_fulltext_options(&FulltextOptions {
                 enable: true,
                 analyzer: FulltextAnalyzer::English,
                 case_sensitive: false,

src/common/grpc-expr/src/alter.rs

@@ -16,8 +16,8 @@ use api::helper::ColumnDataTypeWrapper;
 use api::v1::add_column_location::LocationType;
 use api::v1::alter_expr::Kind;
 use api::v1::{
-    column_def, AddColumnLocation as Location, AlterExpr, ChangeColumnTypes, CreateTableExpr,
-    DropColumns, RenameTable, SemanticType,
+    column_def, AddColumnLocation as Location, AlterExpr, ChangeColumnTypes, ChangeFulltext,
+    CreateTableExpr, DropColumns, RenameTable, SemanticType,
 };
 use common_query::AddColumnLocation;
 use datatypes::schema::{ColumnSchema, RawSchema};
@@ -92,6 +92,13 @@ pub fn alter_expr_to_request(table_id: TableId, expr: AlterExpr) -> Result<Alter
         Kind::RenameTable(RenameTable { new_table_name }) => {
             AlterKind::RenameTable { new_table_name }
         }
+        Kind::ChangeFulltext(ChangeFulltext {
+            column_name,
+            options,
+        }) => AlterKind::ChangeFulltext {
+            column_name,
+            options,
+        },
     };
 
     let request = AlterTableRequest {

src/common/meta/src/ddl/alter_table/region_request.rs

@@ -106,6 +106,7 @@ fn create_proto_alter_kind(
             })))
         }
         Kind::RenameTable(_) => Ok(None),
+        Kind::ChangeFulltext(x) => Ok(Some(alter_request::Kind::ChangeFulltext(x.clone()))),
     }
 }
 

src/common/meta/src/ddl/alter_table/update_metadata.rs

@@ -52,6 +52,7 @@ impl AlterTableProcedure {
                 new_info.name = new_table_name.to_string();
             }
             AlterKind::DropColumns { .. } | AlterKind::ChangeColumnTypes { .. } => {}
+            AlterKind::ChangeFulltext { .. } => {}
         }
 
         Ok(new_info)

src/datatypes/src/error.rs

@@ -205,6 +205,13 @@ pub enum Error {
         #[snafu(implicit)]
         location: Location,
     },
+
+    #[snafu(display("Invalid data type {} for fulltext", data_type))]
+    InvalidFulltextDataType {
+        data_type: String,
+        #[snafu(implicit)]
+        location: Location,
+    },
 }
 
 impl ErrorExt for Error {
@@ -222,7 +229,8 @@ impl ErrorExt for Error {
             | DefaultValueType { .. }
             | DuplicateMeta { .. }
             | InvalidTimestampPrecision { .. }
-            | InvalidPrecisionOrScale { .. } => StatusCode::InvalidArguments,
+            | InvalidPrecisionOrScale { .. }
+            | InvalidFulltextDataType { .. } => StatusCode::InvalidArguments,
 
             ValueExceedsPrecision { .. }
             | CastType { .. }

src/datatypes/src/schema.rs

@@ -32,6 +32,9 @@ pub use crate::schema::column_schema::{
 pub use crate::schema::constraint::ColumnDefaultConstraint;
 pub use crate::schema::raw::RawSchema;
 
+const COLUMN_FULLTEXT_OPT_KEY_ANALYZER: &str = "analyzer";
+const COLUMN_FULLTEXT_OPT_KEY_CASE_SENSITIVE: &str = "case_sensitive";
+
 /// Key used to store version number of the schema in metadata.
 pub const VERSION_KEY: &str = "greptime:version";
 
@@ -300,6 +303,69 @@ fn validate_timestamp_index(column_schemas: &[ColumnSchema], timestamp_index: us
     Ok(())
 }
 
+/// Parses the provided options to configure full-text search behavior.
+///
+/// This function checks for specific keys in the provided `HashMap`:
+/// - `COLUMN_FULLTEXT_OPT_KEY_ANALYZER`: Defines the analyzer to use (e.g., "english", "chinese").
+/// - `COLUMN_FULLTEXT_OPT_KEY_CASE_SENSITIVE`: Defines whether the full-text search should be case-sensitive ("true" or "false").
+///
+/// If the provided options contain valid values for the full-text keys, a configured `FulltextOptions`
+/// object is returned. If the options are invalid or missing, the function returns `None`.
+///
+/// # Parameters:
+/// - `options`: A reference to a `HashMap<String, String>` containing the full-text options.
+///
+/// # Returns:
+/// - `Some(FulltextOptions)` if valid options are provided.
+/// - `None` if the options are invalid or do not contain full-text related keys.
+pub fn parse_fulltext_options(options: &HashMap<String, String>) -> Option<FulltextOptions> {
+    let mut fulltext = FulltextOptions::default();
+
+    // Check and parse the "analyzer" option
+    if let Some(analyzer) = options.get(COLUMN_FULLTEXT_OPT_KEY_ANALYZER) {
+        match analyzer.to_ascii_lowercase().as_str() {
+            "english" => {
+                fulltext.enable = true;
+                fulltext.analyzer = FulltextAnalyzer::English;
+            }
+            "chinese" => {
+                fulltext.enable = true;
+                fulltext.analyzer = FulltextAnalyzer::Chinese;
+            }
+            _ => {
+                // If the analyzer is invalid, return None to indicate failure
+                return None;
+            }
+        }
+    }
+
+    // Check and parse the "case_sensitive" option
+    if let Some(case_sensitive) = options.get(COLUMN_FULLTEXT_OPT_KEY_CASE_SENSITIVE) {
+        match case_sensitive.to_ascii_lowercase().as_str() {
+            "true" => {
+                fulltext.enable = true;
+                fulltext.case_sensitive = true;
+            }
+            "false" => {
+                fulltext.enable = true;
+                fulltext.case_sensitive = false;
+            }
+            _ => {
+                // If case sensitivity is invalid, return None
+                return None;
+            }
+        }
+    }
+
+    // If any fulltext-related key exists, return the constructed FulltextOptions
+    if fulltext.enable {
+        Some(fulltext)
+    } else {
+        // Return None if no valid fulltext keys are found
+        None
+    }
+}
+
 pub type SchemaRef = Arc<Schema>;
 
 impl TryFrom<Arc<ArrowSchema>> for Schema {
@@ -484,4 +550,13 @@ mod tests {
             .build()
             .is_err());
     }
+
+    #[test]
+    fn test_validate_fulltext_options() {
+        let options = HashMap::from([(String::from("analyzer"), String::from("English"))]);
+        assert!(parse_fulltext_options(&options).is_some());
+
+        let options = HashMap::from([(String::from("analyzer"), String::from("Chinglish"))]);
+        assert!(parse_fulltext_options(&options).is_some());
+    }
 }

src/datatypes/src/schema/column_schema.rs

@@ -255,12 +255,25 @@ impl ColumnSchema {
         }
     }
 
-    pub fn with_fulltext_options(mut self, options: FulltextOptions) -> Result<Self> {
+    pub fn with_fulltext_options(mut self, options: &FulltextOptions) -> Result<Self> {
+        self.set_fulltext_options(options)?;
+        Ok(self)
+    }
+
+    pub fn set_fulltext_options(&mut self, options: &FulltextOptions) -> Result<()> {
+        if self.data_type != ConcreteDataType::string_datatype() {
+            return error::InvalidFulltextDataTypeSnafu {
+                data_type: self.data_type.to_string(),
+            }
+            .fail();
+        }
+
         self.metadata.insert(
             FULLTEXT_KEY.to_string(),
-            serde_json::to_string(&options).context(error::SerializeSnafu)?,
+            serde_json::to_string(options).context(error::SerializeSnafu)?,
         );
-        Ok(self)
+
+        Ok(())
     }
 }
 

src/mito2/src/sst/index.rs

@@ -349,7 +349,7 @@ mod tests {
         if with_fulltext {
             let column_schema =
                 ColumnSchema::new("text", ConcreteDataType::string_datatype(), true)
-                    .with_fulltext_options(FulltextOptions {
+                    .with_fulltext_options(&FulltextOptions {
                         enable: true,
                         ..Default::default()
                     })

src/mito2/src/sst/index/fulltext_index/creator.rs

@@ -329,7 +329,7 @@ mod tests {
                     ConcreteDataType::string_datatype(),
                     true,
                 )
-                .with_fulltext_options(FulltextOptions {
+                .with_fulltext_options(&FulltextOptions {
                     enable: true,
                     analyzer: FulltextAnalyzer::English,
                     case_sensitive: true,
@@ -344,7 +344,7 @@ mod tests {
                     ConcreteDataType::string_datatype(),
                     true,
                 )
-                .with_fulltext_options(FulltextOptions {
+                .with_fulltext_options(&FulltextOptions {
                     enable: true,
                     analyzer: FulltextAnalyzer::English,
                     case_sensitive: false,
@@ -359,7 +359,7 @@ mod tests {
                     ConcreteDataType::string_datatype(),
                     true,
                 )
-                .with_fulltext_options(FulltextOptions {
+                .with_fulltext_options(&FulltextOptions {
                     enable: true,
                     analyzer: FulltextAnalyzer::Chinese,
                     case_sensitive: false,

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, ChangeColumnType, ChangeColumnTypes, ColumnDataType,
-    ColumnDataTypeExtension, CreateFlowExpr, CreateTableExpr, CreateViewExpr, DropColumn,
-    DropColumns, ExpireAfter, RenameTable, SemanticType, TableName,
+    AddColumn, AddColumns, AlterExpr, ChangeColumnType, ChangeColumnTypes, ChangeFulltext,
+    ColumnDataType, ColumnDataTypeExtension, CreateFlowExpr, CreateTableExpr, CreateViewExpr,
+    DropColumn, DropColumns, ExpireAfter, RenameTable, SemanticType, TableName,
 };
 use common_error::ext::BoxedError;
 use common_grpc_expr::util::ColumnExpr;
@@ -483,6 +483,13 @@ pub(crate) fn to_alter_expr(
         AlterTableOperation::RenameTable { new_table_name } => Kind::RenameTable(RenameTable {
             new_table_name: new_table_name.to_string(),
         }),
+        AlterTableOperation::AlterColumnFulltext {
+            column_name,
+            options,
+        } => Kind::ChangeFulltext(ChangeFulltext {
+            column_name: column_name.value.to_string(),
+            options: options.clone().into_map(),
+        }),
     };
 
     Ok(AlterExpr {

src/query/src/sql/show_create_table.rs

@@ -222,7 +222,7 @@ mod tests {
             ColumnSchema::new("cpu", ConcreteDataType::float64_datatype(), true),
             ColumnSchema::new("disk", ConcreteDataType::float32_datatype(), true),
             ColumnSchema::new("msg", ConcreteDataType::string_datatype(), true)
-                .with_fulltext_options(FulltextOptions {
+                .with_fulltext_options(&FulltextOptions {
                     enable: true,
                     ..Default::default()
                 })

src/sql/src/parsers/alter_parser.rs

@@ -1,5 +1,3 @@
-// Copyright 2023 Greptime Team
-//
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
@@ -12,6 +10,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+use std::collections::HashMap;
+
 use common_query::AddColumnLocation;
 use snafu::ResultExt;
 use sqlparser::keywords::Keyword;
@@ -22,6 +22,7 @@ use crate::error::{self, Result};
 use crate::parser::ParserContext;
 use crate::statements::alter::{AlterTable, AlterTableOperation};
 use crate::statements::statement::Statement;
+use crate::util::parse_option_string;
 
 impl<'a> ParserContext<'a> {
     pub(crate) fn parse_alter(&mut self) -> Result<Statement> {
@@ -74,13 +75,36 @@ impl<'a> ParserContext<'a> {
                 )));
             }
         } else if self.consume_token("MODIFY") {
-            let _ = self.parser.parse_keyword(Keyword::COLUMN);
+            if !self.parser.parse_keyword(Keyword::COLUMN) {
+                return Err(ParserError::ParserError(format!(
+                    "expect keyword COLUMN after ALTER TABLE MODIFY, found {}",
+                    self.parser.peek_token()
+                )));
+            }
             let column_name = Self::canonicalize_identifier(self.parser.parse_identifier(false)?);
-            let target_type = self.parser.parse_data_type()?;
 
-            AlterTableOperation::ChangeColumnType {
-                column_name,
-                target_type,
+            if self.parser.parse_keyword(Keyword::SET) {
+                let _ = self.parser.parse_keyword(Keyword::FULLTEXT);
+
+                let options = self
+                    .parser
+                    .parse_options(Keyword::WITH)?
+                    .into_iter()
+                    .map(parse_option_string)
+                    .collect::<Result<HashMap<String, String>>>()
+                    .unwrap();
+
+                AlterTableOperation::AlterColumnFulltext {
+                    column_name,
+                    options: options.into(),
+                }
+            } else {
+                let target_type = self.parser.parse_data_type()?;
+
+                AlterTableOperation::ChangeColumnType {
+                    column_name,
+                    target_type,
+                }
             }
         } else if self.parser.parse_keyword(Keyword::RENAME) {
             let new_table_name_obj_raw = self.parse_object_name()?;
@@ -96,7 +120,7 @@ impl<'a> ParserContext<'a> {
             AlterTableOperation::RenameTable { new_table_name }
         } else {
             return Err(ParserError::ParserError(format!(
-                "expect keyword ADD or DROP or MODIFY or RENAME after ALTER TABLE, found {}",
+                "expect keyword ADD or DROP or MODIFY or RENAME or SET after ALTER TABLE, found {}",
                 self.parser.peek_token()
             )));
         };
@@ -406,4 +430,38 @@ mod tests {
             _ => unreachable!(),
         }
     }
+
+    #[test]
+    fn test_parse_alter_change_fulltext() {
+        let sql = "ALTER TABLE test MODIFY COLUMN message SET FULLTEXT WITH(analyzer = 'Chinese', case_sensitive = 'true');";
+        let mut result =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default())
+                .unwrap();
+        assert_eq!(1, result.len());
+
+        let statement = result.remove(0);
+        assert_matches!(statement, Statement::Alter { .. });
+        match statement {
+            Statement::Alter(alter_table) => {
+                assert_eq!("test", alter_table.table_name().0[0].value);
+
+                let alter_operation = alter_table.alter_operation();
+                assert_matches!(
+                    alter_operation,
+                    AlterTableOperation::AlterColumnFulltext { .. }
+                );
+                match alter_operation {
+                    AlterTableOperation::AlterColumnFulltext {
+                        column_name,
+                        options,
+                    } => {
+                        assert_eq!(column_name.value, r#"message"#);
+                        assert_eq!(options.get("analyzer").unwrap(), "Chinese");
+                    }
+                    _ => unreachable!(),
+                }
+            }
+            _ => unreachable!(),
+        }
+    }
 }