Revert "feat(query): Support Computed columns (databendlabs#11391)"

This reverts commit f530b1e.

src/common/io/Cargo.toml

@@ -28,5 +28,5 @@ ordered-float = { workspace = true }
 serde = { workspace = true }
 
 [dev-dependencies]
-aho-corasick = { version = "1.0.1" }
+aho-corasick = { version = "0.7.20" }
 rand = "0.8.5"

src/common/io/tests/it/cursor_ext/fast_read_text_ext.rs

@@ -31,7 +31,7 @@ fn test_positions() -> Result<()> {
     ];
 
     let patterns = &["'", "\\"];
-    let ac = AhoCorasick::new(patterns).unwrap();
+    let ac = AhoCorasick::new(patterns);
     for (data, expect) in cases {
         let mut positions = VecDeque::new();
         for mat in ac.find_iter(&data) {
@@ -47,7 +47,7 @@ fn test_positions() -> Result<()> {
 fn test_fast_read_text() -> Result<()> {
     let data = r#"'abc','d\'ef','g\\\'hi'"#.to_string();
     let patterns = &["'", "\\"];
-    let ac = AhoCorasick::new(patterns).unwrap();
+    let ac = AhoCorasick::new(patterns);
     let mut positions = VecDeque::new();
     for mat in ac.find_iter(&data) {
         let pos = mat.start();

src/meta/proto-conv/src/schema_from_to_protobuf_impl.rs

@@ -71,84 +71,30 @@ impl FromToProto for ex::TableField {
     fn from_pb(p: pb::DataField) -> Result<Self, Incompatible> {
         reader_check_msg(p.ver, p.min_reader_ver)?;
 
-        let computed_expr = match p.computed_expr {
-            Some(computed_expr) => Some(ex::ComputedExpr::from_pb(computed_expr)?),
-            None => None,
-        };
-
         let v = ex::TableField::new_from_column_id(
             &p.name,
             ex::TableDataType::from_pb(p.data_type.ok_or_else(|| Incompatible {
                 reason: "DataField.data_type can not be None".to_string(),
             })?)?,
             p.column_id,
         )
-        .with_default_expr(p.default_expr)
-        .with_computed_expr(computed_expr);
+        .with_default_expr(p.default_expr);
         Ok(v)
     }
 
     fn to_pb(&self) -> Result<pb::DataField, Incompatible> {
-        let computed_expr = match self.computed_expr() {
-            Some(computed_expr) => Some(computed_expr.to_pb()?),
-            None => None,
-        };
         let p = pb::DataField {
             ver: VER,
             min_reader_ver: MIN_READER_VER,
             name: self.name().clone(),
             default_expr: self.default_expr().cloned(),
             data_type: Some(self.data_type().to_pb()?),
             column_id: self.column_id(),
-            computed_expr,
         };
         Ok(p)
     }
 }
 
-impl FromToProto for ex::ComputedExpr {
-    type PB = pb::ComputedExpr;
-
-    fn get_pb_ver(p: &Self::PB) -> u64 {
-        p.ver
-    }
-
-    fn from_pb(p: pb::ComputedExpr) -> Result<Self, Incompatible> {
-        reader_check_msg(p.ver, p.min_reader_ver)?;
-
-        let computed_expr = match p.computed_expr {
-            None => {
-                return Err(Incompatible {
-                    reason: "Invalid ComputedExpr: .computed_expr can not be None".to_string(),
-                });
-            }
-            Some(x) => x,
-        };
-
-        let x = match computed_expr {
-            pb::computed_expr::ComputedExpr::Virtual(expr) => Self::Virtual(expr),
-            pb::computed_expr::ComputedExpr::Stored(expr) => Self::Stored(expr),
-        };
-        Ok(x)
-    }
-
-    fn to_pb(&self) -> Result<pb::ComputedExpr, Incompatible> {
-        let x = match self {
-            ex::ComputedExpr::Virtual(expr) => {
-                pb::computed_expr::ComputedExpr::Virtual(expr.clone())
-            }
-            ex::ComputedExpr::Stored(expr) => pb::computed_expr::ComputedExpr::Stored(expr.clone()),
-        };
-
-        Ok(pb::ComputedExpr {
-            ver: VER,
-            min_reader_ver: MIN_READER_VER,
-
-            computed_expr: Some(x),
-        })
-    }
-}
-
 impl FromToProto for ex::TableDataType {
     type PB = pb::DataType;
     fn get_pb_ver(p: &Self::PB) -> u64 {

src/meta/proto-conv/tests/it/main.rs

@@ -42,5 +42,4 @@ mod v032_file_format_params;
 mod v033_table_meta;
 mod v034_schema;
 mod v035_user_stage;
-mod v036_table_meta;
 mod v037_index_meta;

src/meta/protos/proto/metadata.proto

@@ -32,16 +32,6 @@ message DataSchema {
   uint32 next_column_id = 3;
 }
 
-message ComputedExpr {
-  uint64 ver = 100;
-  uint64 min_reader_ver = 101;
-
-  oneof computed_expr {
-    string virtual  = 1;
-    string stored   = 2;
-  }
-}
-
 // One field, AKA column
 message DataField {
   uint64 ver = 100;
@@ -58,6 +48,4 @@ message DataField {
   DataType data_type = 3;
 
   uint32 column_id = 4;
-
-  optional ComputedExpr computed_expr = 5;
 }

src/query/ast/src/ast/statements/table.rs

@@ -578,35 +578,11 @@ impl Display for OptimizeTableAction {
     }
 }
 
-#[derive(Debug, Clone, PartialEq)]
-pub enum ColumnExpr {
-    Default(Box<Expr>),
-    Virtual(Box<Expr>),
-    Stored(Box<Expr>),
-}
-
-impl Display for ColumnExpr {
-    fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
-        match self {
-            ColumnExpr::Default(expr) => {
-                write!(f, " DEFAULT {expr}")?;
-            }
-            ColumnExpr::Virtual(expr) => {
-                write!(f, " AS ({expr}) VIRTUAL")?;
-            }
-            ColumnExpr::Stored(expr) => {
-                write!(f, " AS ({expr}) STORED")?;
-            }
-        }
-        Ok(())
-    }
-}
-
 #[derive(Debug, Clone, PartialEq)]
 pub struct ColumnDefinition {
     pub name: Identifier,
     pub data_type: TypeName,
-    pub expr: Option<ColumnExpr>,
+    pub default_expr: Option<Box<Expr>>,
     pub comment: Option<String>,
 }
 
@@ -618,8 +594,8 @@ impl Display for ColumnDefinition {
             write!(f, " NOT NULL")?;
         }
 
-        if let Some(expr) = &self.expr {
-            write!(f, "{expr}")?;
+        if let Some(default_expr) = &self.default_expr {
+            write!(f, " DEFAULT {default_expr}")?;
         }
         if let Some(comment) = &self.comment {
             write!(f, " COMMENT '{comment}'")?;