Merge branch 'main' into chore-hnsw-quantization-simd

Author: b41sh

src/query/sql/src/planner/binder/default_expr.rs

@@ -168,7 +168,11 @@ impl DefaultExprBinder {
         Ok(ast)
     }
 
-    pub fn bind(&mut self, ast: &AExpr) -> Result<(ScalarExpr, DataType)> {
+    fn bind_impl(
+        &mut self,
+        ast: &AExpr,
+        skip_sequence_check: bool,
+    ) -> Result<(ScalarExpr, DataType)> {
         let mut type_checker = TypeChecker::try_create(
             &mut self.bind_context,
             self.ctx.clone(),
@@ -177,10 +181,17 @@ impl DefaultExprBinder {
             &[],
             true,
         )?;
+        if skip_sequence_check {
+            type_checker.set_skip_sequence_check(true);
+        }
         let (scalar_expr, data_type) = *type_checker.resolve(ast)?;
         Ok((scalar_expr, data_type))
     }
 
+    pub fn bind(&mut self, ast: &AExpr) -> Result<(ScalarExpr, DataType)> {
+        self.bind_impl(ast, false)
+    }
+
     pub fn parse_and_bind(&mut self, field: &DataField) -> Result<ScalarExpr> {
         if let Some(default_expr) = field.default_expr() {
             let ast = self.parse(default_expr).map_err(|e| {
@@ -192,7 +203,7 @@ impl DefaultExprBinder {
                     e
                 )
             })?;
-            let (scalar_expr, data_type) = self.bind(&ast)?;
+            let (scalar_expr, data_type) = self.bind_impl(&ast, true)?;
             let dest_type = field.data_type();
             if data_type != *dest_type {
                 Ok(wrap_cast(&scalar_expr, dest_type))

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

@@ -238,6 +238,9 @@ pub struct TypeChecker<'a> {
     // true if currently resolving a masking policy expression.
     // This prevents infinite recursion when a masking policy references the masked column itself.
     in_masking_policy: bool,
+
+    // Skip sequence existence checks when resolving `nextval`.
+    skip_sequence_check: bool,
 }
 
 impl<'a> TypeChecker<'a> {
@@ -263,9 +266,14 @@ impl<'a> TypeChecker<'a> {
             in_window_function: false,
             forbid_udf,
             in_masking_policy: false,
+            skip_sequence_check: false,
         })
     }
 
+    pub fn set_skip_sequence_check(&mut self, skip: bool) {
+        self.skip_sequence_check = skip;
+    }
+
     #[recursive::recursive]
     pub fn resolve(&mut self, expr: &Expr) -> Result<Box<(ScalarExpr, DataType)>> {
         let box (scalar, data_type): Box<(ScalarExpr, DataType)> = match expr {
@@ -5728,25 +5736,29 @@ impl<'a> TypeChecker<'a> {
             .set_span(span));
         };
 
-        let catalog = self.ctx.get_default_catalog()?;
-        let req = GetSequenceReq {
-            ident: SequenceIdent::new(self.ctx.get_tenant(), sequence_name.clone()),
-        };
+        if !self.skip_sequence_check {
+            let catalog = self.ctx.get_default_catalog()?;
+            let req = GetSequenceReq {
+                ident: SequenceIdent::new(self.ctx.get_tenant(), sequence_name.clone()),
+            };
 
-        let visibility_checker = if self
-            .ctx
-            .get_settings()
-            .get_enable_experimental_sequence_privilege_check()?
-        {
-            Some(databend_common_base::runtime::block_on(async move {
-                self.ctx
-                    .get_visibility_checker(false, Object::Sequence)
-                    .await
-            })?)
-        } else {
-            None
-        };
-        databend_common_base::runtime::block_on(catalog.get_sequence(req, &visibility_checker))?;
+            let visibility_checker = if self
+                .ctx
+                .get_settings()
+                .get_enable_experimental_sequence_privilege_check()?
+            {
+                Some(databend_common_base::runtime::block_on(async move {
+                    self.ctx
+                        .get_visibility_checker(false, Object::Sequence)
+                        .await
+                })?)
+            } else {
+                None
+            };
+            databend_common_base::runtime::block_on(
+                catalog.get_sequence(req, &visibility_checker),
+            )?;
+        }
 
         let return_type = DataType::Number(NumberDataType::UInt64);
         let func_arg = AsyncFunctionArgument::SequenceFunction(sequence_name);

tests/sqllogictests/suites/stage/sequence_as_default.test

@@ -26,3 +26,51 @@ select * from tmp order by seq;
 3 0 5
 4 1 6
 5 2 7
+
+statement ok
+create or replace sequence seq90;
+
+statement ok
+create or replace table sequence_demo (i integer default nextval(seq90), dummy smallint);
+
+statement ok
+drop table sequence_demo;
+
+statement ok
+drop sequence seq90;
+
+statement ok
+undrop table sequence_demo;
+
+query II
+select * from sequence_demo;
+----
+
+statement error 3101
+insert into sequence_demo(dummy) values(1);
+
+statement ok
+insert into sequence_demo values(100, 100);
+
+query II
+select * from sequence_demo order by dummy;
+----
+100 100
+
+statement ok
+alter table sequence_demo modify column i integer default 0;
+
+statement ok
+insert into sequence_demo(dummy) values(2);
+
+query II
+select * from sequence_demo order by dummy;
+----
+0 2
+100 100
+
+statement ok
+drop table if exists sequence_demo;
+
+statement ok
+drop sequence if exists seq90;