chore: fix ci fail

Signed-off-by: Kould <[email protected]>

Author: KKould

src/common/exception/src/exception_into.rs

@@ -13,6 +13,7 @@
 // limitations under the License.
 
 use std::error::Error;
+use std::fmt;
 use std::fmt::Debug;
 use std::fmt::Display;
 use std::fmt::Formatter;
@@ -430,3 +431,9 @@ impl From<redis::RedisError> for ErrorCode {
         ErrorCode::DictionarySourceError(format!("Dictionary Redis Error, cause: {}", error))
     }
 }
+
+impl From<fmt::Error> for ErrorCode {
+    fn from(error: fmt::Error) -> Self {
+        ErrorCode::from_std_error(error)
+    }
+}

src/query/sql/src/planner/binder/bind_table_reference/bind_table.rs

@@ -12,6 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+use std::fmt::Write;
 use std::sync::Arc;
 
 use databend_common_ast::ast::Identifier;
@@ -402,12 +403,13 @@ impl Binder {
                 if index == 0 {
                     let is_created = true;
 
+                    let path = Self::convert_array_index(&virtual_field.name)?;
                     index = self.metadata.write().add_virtual_column(
                         &base_column,
                         column_id,
                         name.clone(),
                         table_data_type,
-                        Scalar::String(name.clone()),
+                        Scalar::String(path),
                         None,
                         is_created,
                     );
@@ -422,4 +424,90 @@ impl Binder {
 
         Ok(())
     }
+
+    fn convert_array_index(input: &str) -> Result<String> {
+        let mut chars = input.chars().peekable();
+        let mut path = "{".to_string();
+
+        while chars.peek().is_some() {
+            if chars.next() != Some('[') {
+                return Err(ErrorCode::InvalidArgument("Expected '['".to_string()));
+            }
+            if let Some('\'') = chars.peek() {
+                let _ = chars.next();
+                path.push('"');
+
+                let mut is_emtpy = true;
+                for c in chars.by_ref() {
+                    is_emtpy = false;
+                    if c == '\'' {
+                        break;
+                    }
+                    path.write_char(c)?;
+                }
+                if is_emtpy {
+                    let _ = path.pop();
+                } else {
+                    path.push('"')
+                }
+                if chars.next() != Some(']') {
+                    return Err(ErrorCode::InvalidArgument("Expected ']' after string"));
+                }
+            } else {
+                while let Some(&c) = chars.peek() {
+                    if c == ']' {
+                        break;
+                    }
+                    path.write_char(c)?;
+                    chars.next();
+                }
+                if chars.next() != Some(']') {
+                    return Err(ErrorCode::InvalidArgument(
+                        "Expected ']' after index".to_string(),
+                    ));
+                }
+            };
+
+            path.write_char(',')?;
+        }
+        if path.len() > 1 {
+            let _ = path.pop();
+        }
+        path.write_char('}')?;
+
+        if chars.next().is_some() {
+            return Err(ErrorCode::InvalidArgument("Unexpected trailing characters"));
+        }
+        Ok(path)
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use databend_common_exception::Result;
+
+    use crate::Binder;
+
+    #[test]
+    fn test_convert_array_index() -> Result<()> {
+        let success = vec![
+            ("['a']", "{\"a\"}"),
+            ("['a'][0]", "{\"a\",0}"),
+            ("['a']['b']", "{\"a\",\"b\"}"),
+            ("['a']['some_word']", "{\"a\",\"some_word\"}"),
+            ("['a'][42]['long_string']", "{\"a\",42,\"long_string\"}"),
+            ("['a'][0]['b']['c']", "{\"a\",0,\"b\",\"c\"}"),
+            ("['key']['value'][123]", "{\"key\",\"value\",123}"),
+            ("[0]", "{0}"),
+        ];
+        let failure = vec!["invalid", "['a'", "['a']extra"];
+        for (case, result) in success {
+            assert_eq!(result, Binder::convert_array_index(case)?);
+        }
+        for case in failure {
+            assert!(Binder::convert_array_index(case).is_err());
+        }
+
+        Ok(())
+    }
 }

src/query/sql/src/planner/semantic/type_check.rs

@@ -598,33 +598,10 @@ impl<'a> TypeChecker<'a> {
                 // as we cast JSON null to SQL NULL.
                 let target_type = if data_type.remove_nullable() == DataType::Variant {
                     let target_type = checked_expr.data_type().nest_wrap_nullable();
-                    if let ScalarExpr::BoundColumnRef(column) = &mut scalar {
-                        let mut guard = self.metadata.write();
-                        if let ColumnEntry::VirtualColumn(virtual_column) =
-                            guard.column(column.column.index).clone()
-                        {
-                            if let ColumnEntry::BaseTableColumn(source_column) =
-                                guard.column(virtual_column.source_column_index).clone()
-                            {
-                                if let Some(table_ty) = Option::<TableDataType>::from(&target_type)
-                                {
-                                    // Tips: column id from source virtual_column
-                                    column.column.index = guard.add_virtual_column(
-                                        &source_column,
-                                        virtual_column.column_id,
-                                        virtual_column.column_name,
-                                        table_ty,
-                                        virtual_column.key_paths,
-                                        Some(virtual_column.column_index),
-                                        virtual_column.is_created,
-                                    );
-                                    column.column.data_type = Box::new(target_type.clone());
-                                    return Ok(Box::new((scalar, target_type)));
-                                }
-                            }
-                        }
-                    }
 
+                    if self.try_rewrite_virtual_column_cast(&mut scalar, &target_type) {
+                        return Ok(Box::new((scalar, target_type)));
+                    }
                     target_type
                 // if the source type is nullable, cast target type should also be nullable.
                 } else if data_type.is_nullable_or_null() {
@@ -1199,6 +1176,44 @@ impl<'a> TypeChecker<'a> {
         Ok(Box::new((scalar, data_type)))
     }
 
+    fn try_rewrite_virtual_column_cast(
+        &mut self,
+        scalar: &mut ScalarExpr,
+        target_type: &DataType,
+    ) -> bool {
+        let ScalarExpr::BoundColumnRef(column) = scalar else {
+            return false;
+        };
+        let mut guard = self.metadata.write();
+        if column.column.table_index.is_none() {
+            return false;
+        }
+        let ColumnEntry::VirtualColumn(virtual_column) = guard.column(column.column.index).clone()
+        else {
+            return false;
+        };
+        let ColumnEntry::BaseTableColumn(source_column) =
+            guard.column(virtual_column.source_column_index).clone()
+        else {
+            return false;
+        };
+        if let Some(table_ty) = Option::<TableDataType>::from(target_type) {
+            // Tips: column id from source virtual_column
+            column.column.index = guard.add_virtual_column(
+                &source_column,
+                virtual_column.column_id,
+                virtual_column.column_name,
+                table_ty,
+                virtual_column.key_paths,
+                Some(virtual_column.column_index),
+                virtual_column.is_created,
+            );
+            column.column.data_type = Box::new(target_type.clone());
+            return true;
+        }
+        false
+    }
+
     // TODO: remove this function
     fn rewrite_substring(args: &mut [ScalarExpr]) {
         if let ScalarExpr::ConstantExpr(expr) = &args[1] {