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 = "2a8c2dfb7447b7fe5f0b8f3df868f041600caec2" }
 humantime = "2.1"
 humantime-serde = "1.1"
 itertools = "0.10"
@@ -151,7 +151,7 @@ reqwest = { version = "0.12", default-features = false, features = [
     "stream",
     "multipart",
 ] }
-# SCRAM-SHA-512 requires https://github.com/dequbed/rsasl/pull/48, https://github.com/influxdata/rskafka/pull/247 
+# SCRAM-SHA-512 requires https://github.com/dequbed/rsasl/pull/48, https://github.com/influxdata/rskafka/pull/247
 rskafka = { git = "https://github.com/WenyXu/rskafka.git", rev = "940c6030012c5b746fad819fb72e3325b26e39de", features = [
     "transport-tls",
 ] }

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,11 +16,11 @@ 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};
+use datatypes::schema::{ChangeFulltextOptions, ColumnSchema, RawSchema};
 use snafu::{ensure, OptionExt, ResultExt};
 use table::metadata::TableId;
 use table::requests::{AddColumnRequest, AlterKind, AlterTableRequest, ChangeColumnTypeRequest};
@@ -92,6 +92,19 @@ 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,
+            enable,
+            analyzer,
+            case_sensitive,
+        }) => AlterKind::ChangeFulltext {
+            column_name,
+            options: ChangeFulltextOptions {
+                enable,
+                analyzer,
+                case_sensitive,
+            },
+        },
     };
 
     let request = AlterTableRequest {

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

@@ -121,6 +121,11 @@ pub enum Error {
     InvalidFulltextColumnType {
         column_name: String,
         column_type: ColumnDataType,
+    },
+
+    #[snafu(display("Invalid fulltext options"))]
+    InvalidFulltextOptions {
+        source: datatypes::error::Error,
         #[snafu(implicit)]
         location: Location,
     },
@@ -145,9 +150,9 @@ impl ErrorExt for Error {
                 StatusCode::InvalidArguments
             }
 
-            Error::UnknownColumnDataType { .. } | Error::InvalidFulltextColumnType { .. } => {
-                StatusCode::InvalidArguments
-            }
+            Error::UnknownColumnDataType { .. }
+            | Error::InvalidFulltextOptions { .. }
+            | Error::InvalidFulltextColumnType { .. } => StatusCode::InvalidArguments,
         }
     }
 

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/Cargo.toml

@@ -30,3 +30,5 @@ paste = "1.0"
 serde.workspace = true
 serde_json.workspace = true
 snafu.workspace = true
+sqlparser.workspace = true
+sqlparser_derive = "0.1"

src/datatypes/src/error.rs

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

src/datatypes/src/schema.rs

@@ -26,12 +26,15 @@ use snafu::{ensure, ResultExt};
 
 use crate::error::{self, DuplicateColumnSnafu, Error, ProjectArrowSchemaSnafu, Result};
 pub use crate::schema::column_schema::{
-    ColumnSchema, FulltextAnalyzer, FulltextOptions, Metadata, COMMENT_KEY, FULLTEXT_KEY,
-    TIME_INDEX_KEY,
+    ChangeFulltextOptions, ColumnSchema, FulltextAnalyzer, FulltextOptions, Metadata, COMMENT_KEY,
+    FULLTEXT_KEY, TIME_INDEX_KEY,
 };
 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";
 

src/datatypes/src/schema/column_schema.rs

@@ -18,7 +18,9 @@ use std::fmt;
 use arrow::datatypes::Field;
 use serde::{Deserialize, Serialize};
 use snafu::{ensure, ResultExt};
+use sqlparser_derive::{Visit, VisitMut};
 
+use super::{COLUMN_FULLTEXT_OPT_KEY_ANALYZER, COLUMN_FULLTEXT_OPT_KEY_CASE_SENSITIVE};
 use crate::data_type::{ConcreteDataType, DataType};
 use crate::error::{self, Error, Result};
 use crate::schema::constraint::ColumnDefaultConstraint;
@@ -255,12 +257,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(())
     }
 }
 
@@ -340,6 +355,121 @@ pub enum FulltextAnalyzer {
     Chinese,
 }
 
+impl TryFrom<i32> for FulltextAnalyzer {
+    type Error = Error;
+
+    fn try_from(value: i32) -> Result<Self> {
+        match value {
+            0 => Ok(FulltextAnalyzer::English),
+            1 => Ok(FulltextAnalyzer::Chinese),
+            _ => Err(error::InvalidFulltextOptionsSnafu {
+                key: "analyzer".to_string(),
+                value: value.to_string(),
+            }
+            .build()),
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Visit, VisitMut, Default)]
+pub struct ChangeFulltextOptions {
+    pub enable: Option<bool>,
+    pub analyzer: Option<i32>,
+    pub case_sensitive: Option<bool>,
+}
+
+impl fmt::Display for ChangeFulltextOptions {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "fulltext options: ")?;
+
+        if let Some(enable) = self.enable {
+            write!(f, "enable={}", enable)?;
+        } else {
+            write!(f, "enable=None")?;
+        }
+
+        if let Some(analyzer) = self.analyzer {
+            if analyzer == 0 {
+                write!(f, ", analyzer=English")?;
+            } else {
+                write!(f, ", analyzer=Chinese")?;
+            }
+        } else {
+            write!(f, ", analyzer=None")?;
+        }
+
+        if let Some(case_sensitive) = self.case_sensitive {
+            write!(f, ", case_sensitive={}", case_sensitive)?;
+        } else {
+            write!(f, ", case_sensitive=None")?;
+        }
+
+        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 `ChangeFulltextOptions`
+/// object is returned. If the options are invalid or missing, the function returns error.
+impl TryFrom<HashMap<String, String>> for ChangeFulltextOptions {
+    type Error = Error;
+
+    fn try_from(options: HashMap<String, String>) -> Result<Self> {
+        let mut fulltext = ChangeFulltextOptions::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 = Some(true);
+                    fulltext.analyzer = Some(0);
+                }
+                "chinese" => {
+                    fulltext.enable = Some(true);
+                    fulltext.analyzer = Some(1);
+                }
+                _ => {
+                    // If the analyzer is invalid, return None to indicate failure
+                    return error::InvalidFulltextOptionsSnafu {
+                        key: COLUMN_FULLTEXT_OPT_KEY_ANALYZER.to_string(),
+                        value: analyzer.to_string(),
+                    }
+                    .fail();
+                }
+            }
+        }
+
+        // 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 = Some(true);
+                    fulltext.case_sensitive = Some(true);
+                }
+                "false" => {
+                    fulltext.enable = Some(true);
+                    fulltext.case_sensitive = Some(false);
+                }
+                _ => {
+                    // If case sensitivity is invalid, return None
+                    return error::InvalidFulltextOptionsSnafu {
+                        key: COLUMN_FULLTEXT_OPT_KEY_CASE_SENSITIVE.to_string(),
+                        value: case_sensitive.to_string(),
+                    }
+                    .fail();
+                }
+            }
+        }
+
+        Ok(fulltext)
+    }
+}
+
 impl fmt::Display for FulltextAnalyzer {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {

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,