diff --git a/Cargo.lock b/Cargo.lock
index 345399bc15ab..e2536a58315e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2956,6 +2956,7 @@ dependencies = [
  "bincode 2.0.0-rc.3",
  "codespan-reporting",
  "databend-common-arrow",
+ "geos",
  "geozero",
  "http",
  "opendal",
@@ -2998,6 +2999,7 @@ dependencies = [
  "ethnum 1.5.0 (git+https://github.com/ariesdevil/ethnum-rs?rev=4cb05f1)",
  "futures",
  "geo",
+ "geos",
  "geozero",
  "goldenfile",
  "hex",
@@ -3041,6 +3043,7 @@ dependencies = [
  "databend-common-settings",
  "databend-storages-common-blocks",
  "databend-storages-common-table-meta",
+ "geos",
  "geozero",
  "hex",
  "jsonb 0.3.0 (git+https://github.com/datafuselabs/jsonb?rev=a7325f4)",
@@ -3174,6 +3177,7 @@ dependencies = [
  "databend-common-exception",
  "ethnum 1.5.0 (git+https://github.com/ariesdevil/ethnum-rs?rev=4cb05f1)",
  "geo",
+ "geos",
  "geozero",
  "lexical-core",
  "micromarshal 0.5.0",
@@ -3640,6 +3644,7 @@ dependencies = [
  "derive-visitor",
  "goldenfile",
  "minitrace",
+ "tokio",
  "unindent",
 ]
 
@@ -4595,6 +4600,7 @@ dependencies = [
  "databend-common-pipeline-sinks",
  "databend-common-pipeline-sources",
  "databend-common-pipeline-transforms",
+ "databend-common-script",
  "databend-common-settings",
  "databend-common-sharing",
  "databend-common-sql",
diff --git a/src/common/exception/Cargo.toml b/src/common/exception/Cargo.toml
index 2e5cc3be9a10..44fbcbc42f21 100644
--- a/src/common/exception/Cargo.toml
+++ b/src/common/exception/Cargo.toml
@@ -23,6 +23,7 @@ arrow-schema = { workspace = true }
 backtrace = { git = "https://github.com/rust-lang/backtrace-rs.git", rev = "6145fe6bac65c38375f1216a565a6cc7deb89a2d" }
 #backtrace = "0.3.69"
 bincode = { workspace = true }
+geos = { workspace = true }
 geozero = { workspace = true }
 http = "0.2"
 opendal = { workspace = true }
@@ -34,3 +35,6 @@ serde_json = { workspace = true }
 tantivy = "0.21.1"
 thiserror = { workspace = true }
 tonic = { workspace = true }
+
+[package.metadata.cargo-machete]
+ignored = ["geos"]
diff --git a/src/common/exception/src/lib.rs b/src/common/exception/src/lib.rs
index 2f3190f296a1..537f2fd433fd 100644
--- a/src/common/exception/src/lib.rs
+++ b/src/common/exception/src/lib.rs
@@ -25,6 +25,8 @@ pub use exception::ErrorCode;
 pub use exception::Result;
 pub use exception::ToErrorCode;
 pub use exception_into::SerializedError;
+pub use span::merge_span;
+pub use span::offset_span;
 pub use span::pretty_print_error;
 pub use span::Range;
 pub use span::Span;
diff --git a/src/common/exception/src/span.rs b/src/common/exception/src/span.rs
index cce450ed02f1..e874176ef897 100644
--- a/src/common/exception/src/span.rs
+++ b/src/common/exception/src/span.rs
@@ -16,6 +16,8 @@ use std::fmt::Debug;
 use std::fmt::Display;
 use std::fmt::Formatter;
 
+pub type Span = Option<Range>;
+
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, serde::Serialize, serde::Deserialize)]
 pub struct Range {
     pub start: u32,
@@ -26,13 +28,12 @@ impl Range {
     pub fn start(&self) -> usize {
         self.start as usize
     }
+
     pub fn end(&self) -> usize {
         self.end as usize
     }
 }
 
-pub type Span = Option<Range>;
-
 impl Debug for Range {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         write!(f, "{}..{}", self.start, self.end)
@@ -60,6 +61,25 @@ impl From<std::ops::Range<usize>> for Range {
     }
 }
 
+pub fn offset_span(span: Span, offset: usize) -> Span {
+    span.map(|range| Range {
+        start: range.start + offset as u32,
+        end: range.end + offset as u32,
+    })
+}
+
+pub fn merge_span(lhs: Span, rhs: Span) -> Span {
+    match (lhs, rhs) {
+        (Some(lhs), Some(rhs)) => Some(Range {
+            start: lhs.start.min(rhs.start),
+            end: lhs.end.max(rhs.end),
+        }),
+        (Some(lhs), None) => Some(lhs),
+        (None, Some(rhs)) => Some(rhs),
+        (None, None) => None,
+    }
+}
+
 pub fn pretty_print_error(source: &str, labels: Vec<(Range, String)>) -> String {
     use codespan_reporting::diagnostic::Diagnostic;
     use codespan_reporting::diagnostic::Label;
diff --git a/src/common/io/Cargo.toml b/src/common/io/Cargo.toml
index bacef2a7e0df..a0768fb18239 100644
--- a/src/common/io/Cargo.toml
+++ b/src/common/io/Cargo.toml
@@ -24,6 +24,7 @@ chrono = { workspace = true }
 chrono-tz = { workspace = true }
 ethnum = { workspace = true }
 geo = { workspace = true }
+geos = { workspace = true }
 geozero = { workspace = true }
 lexical-core = "0.8.5"
 micromarshal = "0.5.0"
@@ -36,3 +37,6 @@ wkt = "0.10.3"
 aho-corasick = { version = "1.0.1" }
 rand = { workspace = true }
 rmp-serde = "1.1.1"
+
+[package.metadata.cargo-machete]
+ignored = ["geos"]
diff --git a/src/query/ast/Cargo.toml b/src/query/ast/Cargo.toml
index 568367a3ca03..62cce6727716 100644
--- a/src/query/ast/Cargo.toml
+++ b/src/query/ast/Cargo.toml
@@ -34,6 +34,7 @@ serde_json = { workspace = true }
 strsim = "0.10"
 strum = "0.24"
 strum_macros = "0.24"
+unindent = "0.2.3"
 url = "2.3.1"
 
 [dev-dependencies]
@@ -42,7 +43,6 @@ databend-common-base = { path = "../../common/base" }
 goldenfile = "1.4"
 pretty_assertions = "1.3.0"
 regex = { workspace = true }
-unindent = "0.2.3"
 
 [[bench]]
 name = "bench"
diff --git a/src/query/ast/src/ast/expr.rs b/src/query/ast/src/ast/expr.rs
index 0a0f1d1f2f11..a221dbcc3d0e 100644
--- a/src/query/ast/src/ast/expr.rs
+++ b/src/query/ast/src/ast/expr.rs
@@ -15,6 +15,7 @@
 use std::fmt::Display;
 use std::fmt::Formatter;
 
+use databend_common_exception::merge_span;
 use databend_common_exception::ErrorCode;
 use databend_common_exception::Result;
 use databend_common_exception::Span;
@@ -305,6 +306,139 @@ impl Expr {
         }
     }
 
+    pub fn whole_span(&self) -> Span {
+        match self {
+            Expr::ColumnRef { span, .. } => *span,
+            Expr::IsNull { span, expr, .. } => merge_span(*span, expr.whole_span()),
+            Expr::IsDistinctFrom {
+                span, left, right, ..
+            } => merge_span(merge_span(*span, left.whole_span()), right.whole_span()),
+            Expr::InList {
+                span, expr, list, ..
+            } => {
+                let mut span = merge_span(*span, expr.whole_span());
+                for item in list {
+                    span = merge_span(span, item.whole_span());
+                }
+                span
+            }
+            Expr::InSubquery {
+                span,
+                expr,
+                subquery,
+                ..
+            } => merge_span(merge_span(*span, expr.whole_span()), subquery.span),
+            Expr::Between {
+                span,
+                expr,
+                low,
+                high,
+                ..
+            } => merge_span(
+                merge_span(*span, expr.whole_span()),
+                merge_span(low.whole_span(), high.whole_span()),
+            ),
+            Expr::BinaryOp {
+                span, left, right, ..
+            } => merge_span(merge_span(*span, left.whole_span()), right.whole_span()),
+            Expr::JsonOp {
+                span, left, right, ..
+            } => merge_span(merge_span(*span, left.whole_span()), right.whole_span()),
+            Expr::UnaryOp { span, expr, .. } => merge_span(*span, expr.whole_span()),
+            Expr::Cast { span, expr, .. } => merge_span(*span, expr.whole_span()),
+            Expr::TryCast { span, expr, .. } => merge_span(*span, expr.whole_span()),
+            Expr::Extract { span, expr, .. } => merge_span(*span, expr.whole_span()),
+            Expr::DatePart { span, expr, .. } => merge_span(*span, expr.whole_span()),
+            Expr::Position {
+                span,
+                substr_expr,
+                str_expr,
+                ..
+            } => merge_span(
+                merge_span(*span, substr_expr.whole_span()),
+                str_expr.whole_span(),
+            ),
+            Expr::Substring {
+                span,
+                expr,
+                substring_from,
+                substring_for,
+                ..
+            } => {
+                let mut span = merge_span(
+                    merge_span(*span, expr.whole_span()),
+                    substring_from.whole_span(),
+                );
+                if let Some(substring_for) = substring_for {
+                    span = merge_span(span, substring_for.whole_span());
+                }
+                span
+            }
+            Expr::Trim { span, expr, .. } => merge_span(*span, expr.whole_span()),
+            Expr::Literal { span, .. } => *span,
+            Expr::CountAll { span, .. } => *span,
+            Expr::Tuple { span, exprs } => {
+                let mut span = *span;
+                for expr in exprs {
+                    span = merge_span(span, expr.whole_span());
+                }
+                span
+            }
+            Expr::FunctionCall { span, .. } => *span,
+            Expr::Case {
+                span,
+                operand,
+                conditions,
+                results,
+                else_result,
+            } => {
+                let mut span = *span;
+                if let Some(operand) = operand {
+                    span = merge_span(span, operand.whole_span());
+                }
+                for (cond, res) in conditions.iter().zip(results) {
+                    span = merge_span(merge_span(span, cond.whole_span()), res.whole_span());
+                }
+                if let Some(else_result) = else_result {
+                    span = merge_span(span, else_result.whole_span());
+                }
+                span
+            }
+            Expr::Exists { span, subquery, .. } => merge_span(*span, subquery.span),
+            Expr::Subquery { span, subquery, .. } => merge_span(*span, subquery.span),
+            Expr::MapAccess { span, expr, .. } => merge_span(*span, expr.whole_span()),
+            Expr::Array { span, exprs } => {
+                let mut span = *span;
+                for expr in exprs {
+                    span = merge_span(span, expr.whole_span());
+                }
+                span
+            }
+            Expr::Map { span, kvs } => {
+                let mut span = *span;
+                for (_, v) in kvs {
+                    span = merge_span(span, v.whole_span());
+                }
+                span
+            }
+            Expr::Interval { span, expr, .. } => merge_span(*span, expr.whole_span()),
+            Expr::DateAdd {
+                span,
+                interval,
+                date,
+                ..
+            } => merge_span(merge_span(*span, interval.whole_span()), date.whole_span()),
+            Expr::DateSub {
+                span,
+                interval,
+                date,
+                ..
+            } => merge_span(merge_span(*span, interval.whole_span()), date.whole_span()),
+            Expr::DateTrunc { span, date, .. } => merge_span(*span, date.whole_span()),
+            Expr::Hole { span, .. } => *span,
+        }
+    }
+
     pub fn all_function_like_syntaxes() -> &'static [&'static str] {
         &[
             "CAST",
diff --git a/src/query/ast/src/ast/statements/mod.rs b/src/query/ast/src/ast/statements/mod.rs
index d478a8865905..09b9227ca2b7 100644
--- a/src/query/ast/src/ast/statements/mod.rs
+++ b/src/query/ast/src/ast/statements/mod.rs
@@ -33,6 +33,7 @@ mod notification;
 mod password_policy;
 mod pipe;
 mod presign;
+mod procedure;
 mod replace;
 mod script;
 mod share;
@@ -70,6 +71,7 @@ pub use notification::*;
 pub use password_policy::*;
 pub use pipe::*;
 pub use presign::*;
+pub use procedure::*;
 pub use replace::*;
 pub use script::*;
 pub use share::*;
diff --git a/src/query/ast/src/ast/statements/procedure.rs b/src/query/ast/src/ast/statements/procedure.rs
new file mode 100644
index 000000000000..ef4c8fd135a0
--- /dev/null
+++ b/src/query/ast/src/ast/statements/procedure.rs
@@ -0,0 +1,32 @@
+// Copyright 2021 Datafuse Labs
+//
+// 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
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use std::fmt::Display;
+use std::fmt::Formatter;
+
+use derive_visitor::Drive;
+use derive_visitor::DriveMut;
+
+#[derive(Debug, Clone, PartialEq, Eq, Drive, DriveMut)]
+pub struct ExecuteImmediateStmt {
+    #[drive(skip)]
+    pub script: String,
+}
+
+impl Display for ExecuteImmediateStmt {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "EXECUTE IMMEDIATE $$\n{}\n$$", self.script)?;
+        Ok(())
+    }
+}
diff --git a/src/query/ast/src/ast/statements/script.rs b/src/query/ast/src/ast/statements/script.rs
index b6684e3821e6..1317f2b0daa1 100644
--- a/src/query/ast/src/ast/statements/script.rs
+++ b/src/query/ast/src/ast/statements/script.rs
@@ -20,70 +20,107 @@ use databend_common_exception::Span;
 use crate::ast::Expr;
 use crate::ast::Identifier;
 use crate::ast::Statement;
-use crate::ast::TypeName;
 
 const INDENT_DEPTH: usize = 4;
 
 #[derive(Debug, Clone, PartialEq)]
-pub struct CreateStoredProceduer {
-    pub or_replace: bool,
-    pub name: Identifier,
-    pub returns: TypeName,
-    pub body: ScriptBody,
+pub struct ScriptBlock {
+    pub span: Span,
+    pub declares: Vec<DeclareItem>,
+    pub body: Vec<ScriptStatement>,
+}
+
+impl Display for ScriptBlock {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        writeln!(f, "DECLARE")?;
+        for declare in &self.declares {
+            writeln!(
+                f,
+                "{}",
+                indent::indent_all_by(INDENT_DEPTH, format!("{};", declare))
+            )?;
+        }
+        writeln!(f, "BEGIN")?;
+        for stmt in &self.body {
+            writeln!(
+                f,
+                "{}",
+                indent::indent_all_by(INDENT_DEPTH, format!("{};", stmt))
+            )?;
+        }
+        writeln!(f, "END;")?;
+        Ok(())
+    }
 }
 
 #[derive(Debug, Clone, PartialEq)]
-pub struct ScriptBody {
-    declare: Vec<VariableDeclare>,
-    body: Vec<ScriptStatement>,
-    exception_body: Option<ScriptStatement>,
+pub enum DeclareItem {
+    Var(DeclareVar),
+    Set(DeclareSet),
+}
+
+impl Display for DeclareItem {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        match self {
+            DeclareItem::Var(declare) => write!(f, "{declare}"),
+            DeclareItem::Set(declare) => write!(f, "{declare}"),
+        }
+    }
 }
 
 #[derive(Debug, Clone, PartialEq)]
-pub struct VariableDeclare {
+pub struct DeclareVar {
+    pub span: Span,
     pub name: Identifier,
-    pub data_type: Option<TypeName>,
     pub default: Expr,
 }
 
-impl Display for VariableDeclare {
+impl Display for DeclareVar {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        let VariableDeclare {
-            name,
-            data_type,
-            default,
-        } = self;
-        if let Some(data_type) = data_type {
-            write!(f, "{name} {data_type} := {default}")?;
-        } else {
-            write!(f, "{name} := {default}")?;
-        }
+        let DeclareVar { name, default, .. } = self;
+        write!(f, "{name} := {default}")?;
         Ok(())
     }
 }
 
 #[derive(Debug, Clone, PartialEq)]
-pub struct StatementDeclare {
+pub struct DeclareSet {
+    pub span: Span,
     pub name: Identifier,
     pub stmt: Statement,
 }
 
-impl Display for StatementDeclare {
+impl Display for DeclareSet {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        let StatementDeclare { name, stmt } = self;
+        let DeclareSet { name, stmt, .. } = self;
         write!(f, "{name} RESULTSET := {stmt}")
     }
 }
 
+#[derive(Debug, Clone, PartialEq)]
+pub enum ReturnItem {
+    Var(Expr),
+    Set(Identifier),
+    Statement(Statement),
+}
+
+impl Display for ReturnItem {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        match self {
+            ReturnItem::Var(expr) => write!(f, "{expr}"),
+            ReturnItem::Set(name) => write!(f, "TABLE({name})"),
+            ReturnItem::Statement(stmt) => write!(f, "TABLE({stmt})"),
+        }
+    }
+}
+
 #[derive(Debug, Clone, PartialEq)]
 pub enum ScriptStatement {
     LetVar {
-        span: Span,
-        declare: VariableDeclare,
+        declare: DeclareVar,
     },
     LetStatement {
-        span: Span,
-        declare: StatementDeclare,
+        declare: DeclareSet,
     },
     RunStatement {
         span: Span,
@@ -96,7 +133,7 @@ pub enum ScriptStatement {
     },
     Return {
         span: Span,
-        value: Option<Expr>,
+        value: Option<ReturnItem>,
     },
     ForLoop {
         span: Span,
@@ -107,13 +144,20 @@ pub enum ScriptStatement {
         body: Vec<ScriptStatement>,
         label: Option<Identifier>,
     },
-    ForIn {
+    ForInSet {
         span: Span,
         variable: Identifier,
         resultset: Identifier,
         body: Vec<ScriptStatement>,
         label: Option<Identifier>,
     },
+    ForInStatement {
+        span: Span,
+        variable: Identifier,
+        stmt: Statement,
+        body: Vec<ScriptStatement>,
+        label: Option<Identifier>,
+    },
     WhileLoop {
         span: Span,
         condition: Expr,
@@ -195,7 +239,7 @@ impl Display for ScriptStatement {
                 }
                 Ok(())
             }
-            ScriptStatement::ForIn {
+            ScriptStatement::ForInSet {
                 variable,
                 resultset,
                 body,
@@ -216,6 +260,33 @@ impl Display for ScriptStatement {
                 }
                 Ok(())
             }
+            ScriptStatement::ForInStatement {
+                variable,
+                stmt,
+                body,
+                label,
+                ..
+            } => {
+                writeln!(f, "FOR {variable} IN")?;
+                writeln!(
+                    f,
+                    "{}",
+                    indent::indent_all_by(INDENT_DEPTH, format!("{stmt}"))
+                )?;
+                writeln!(f, "DO")?;
+                for stmt in body {
+                    writeln!(
+                        f,
+                        "{}",
+                        indent::indent_all_by(INDENT_DEPTH, format!("{stmt};"))
+                    )?;
+                }
+                write!(f, "END FOR")?;
+                if let Some(label) = label {
+                    write!(f, " {label}")?;
+                }
+                Ok(())
+            }
             ScriptStatement::WhileLoop {
                 condition,
                 body,
diff --git a/src/query/ast/src/ast/statements/statement.rs b/src/query/ast/src/ast/statements/statement.rs
index 968d668e6212..81fe7081ad7f 100644
--- a/src/query/ast/src/ast/statements/statement.rs
+++ b/src/query/ast/src/ast/statements/statement.rs
@@ -325,6 +325,9 @@ pub enum Statement {
     AlterNotification(AlterNotificationStmt),
     DropNotification(DropNotificationStmt),
     DescribeNotification(DescribeNotificationStmt),
+
+    // Stored procedures
+    ExecuteImmediate(ExecuteImmediateStmt),
 }
 
 #[derive(Debug, Clone, PartialEq)]
@@ -716,6 +719,8 @@ impl Display for Statement {
             Statement::AlterNotification(stmt) => write!(f, "{stmt}")?,
             Statement::DropNotification(stmt) => write!(f, "{stmt}")?,
             Statement::DescribeNotification(stmt) => write!(f, "{stmt}")?,
+
+            Statement::ExecuteImmediate(stmt) => write!(f, "{stmt}")?,
         }
         Ok(())
     }
diff --git a/src/query/ast/src/ast/statements/udf.rs b/src/query/ast/src/ast/statements/udf.rs
index 656cb8fb337e..6a1206718341 100644
--- a/src/query/ast/src/ast/statements/udf.rs
+++ b/src/query/ast/src/ast/statements/udf.rs
@@ -92,7 +92,7 @@ impl Display for UDFDefinition {
                 write_comma_separated_list(f, arg_types)?;
                 write!(
                     f,
-                    ") RETURNS {return_type} LANGUAGE {language} HANDLER = '{handler}' AS $${code}$$"
+                    ") RETURNS {return_type} LANGUAGE {language} HANDLER = '{handler}' AS $$\n{code}\n$$"
                 )?;
             }
         }
diff --git a/src/query/ast/src/ast/visitors/walk.rs b/src/query/ast/src/ast/visitors/walk.rs
index 260465609251..c7ce6c2b2af0 100644
--- a/src/query/ast/src/ast/visitors/walk.rs
+++ b/src/query/ast/src/ast/visitors/walk.rs
@@ -585,5 +585,6 @@ pub fn walk_statement<'a, V: Visitor<'a>>(visitor: &mut V, statement: &'a Statem
         Statement::Commit => {}
         Statement::Abort => {}
         Statement::InsertMultiTable(_) => {}
+        Statement::ExecuteImmediate(_) => {}
     }
 }
diff --git a/src/query/ast/src/ast/visitors/walk_mut.rs b/src/query/ast/src/ast/visitors/walk_mut.rs
index 342fa478df60..937632de9ab4 100644
--- a/src/query/ast/src/ast/visitors/walk_mut.rs
+++ b/src/query/ast/src/ast/visitors/walk_mut.rs
@@ -583,5 +583,6 @@ pub fn walk_statement_mut<V: VisitorMut>(visitor: &mut V, statement: &mut Statem
         Statement::DropNotification(stmt) => visitor.visit_drop_notification(stmt),
         Statement::DescribeNotification(stmt) => visitor.visit_describe_notification(stmt),
         Statement::InsertMultiTable(_) => {}
+        Statement::ExecuteImmediate(_) => {}
     }
 }
diff --git a/src/query/ast/src/parser/error.rs b/src/query/ast/src/parser/error.rs
index fea4fcba8358..afbbd46ab2f0 100644
--- a/src/query/ast/src/parser/error.rs
+++ b/src/query/ast/src/parser/error.rs
@@ -223,7 +223,7 @@ pub fn display_parser_error(error: Error, source: &str) -> String {
         });
 
         let mut msg = if span_text.is_empty() {
-            "unexpected end of line".to_string()
+            "unexpected end of input".to_string()
         } else {
             format!("unexpected `{span_text}`")
         };
diff --git a/src/query/ast/src/parser/expr.rs b/src/query/ast/src/parser/expr.rs
index 462f762399b4..66190a3fe1de 100644
--- a/src/query/ast/src/parser/expr.rs
+++ b/src/query/ast/src/parser/expr.rs
@@ -1516,8 +1516,9 @@ pub fn at_string(i: Input) -> IResult<String> {
 
 pub fn code_string(i: Input) -> IResult<String> {
     map_res(rule! { CodeString }, |token| {
-        let path = &token.text()[2..token.text().len() - 2];
-        Ok(path.to_string())
+        let content = &token.text()[2..token.text().len() - 2];
+        let trimmed = unindent::unindent(content).trim().to_string();
+        Ok(trimmed)
     })(i)
 }
 
diff --git a/src/query/ast/src/parser/script.rs b/src/query/ast/src/parser/script.rs
index 611cbb477aca..c360257b4a86 100644
--- a/src/query/ast/src/parser/script.rs
+++ b/src/query/ast/src/parser/script.rs
@@ -23,32 +23,78 @@ use crate::parser::statement::*;
 use crate::parser::token::*;
 use crate::rule;
 
-pub fn script_stmts(i: Input) -> IResult<Vec<ScriptStatement>> {
-    semicolon_terminated_list1(script_stmt)(i)
+pub fn script_block(i: Input) -> IResult<ScriptBlock> {
+    map(
+        consumed(rule! {
+            ( DECLARE ~ #semicolon_terminated_list1(declare_item) )?
+            ~ BEGIN
+            ~ #semicolon_terminated_list1(script_stmt)
+            ~ END
+            ~ ";"
+        }),
+        |(span, (declares, _, body, _, _))| {
+            let declares = declares.map(|(_, declare)| declare).unwrap_or_default();
+            ScriptBlock {
+                span: transform_span(span.tokens),
+                declares,
+                body,
+            }
+        },
+    )(i)
 }
 
-pub fn script_stmt(i: Input) -> IResult<ScriptStatement> {
-    let let_stmt_stmt = map(
+pub fn declare_item(i: Input) -> IResult<DeclareItem> {
+    let declare_var = map(declare_var, DeclareItem::Var);
+    let declare_set = map(declare_set, DeclareItem::Set);
+
+    rule!(
+        #declare_var
+        | #declare_set
+    )(i)
+}
+
+pub fn declare_var(i: Input) -> IResult<DeclareVar> {
+    map(
         consumed(rule! {
-            LET ~^#ident ~ RESULTSET ~ ^":=" ~ ^#statement_body
+            #ident ~ ":=" ~ ^#expr
         }),
-        |(span, (_, name, _, _, stmt))| ScriptStatement::LetStatement {
+        |(span, (name, _, default))| DeclareVar {
             span: transform_span(span.tokens),
-            declare: StatementDeclare { name, stmt },
+            name,
+            default,
         },
-    );
-    let let_var_stmt = map(
+    )(i)
+}
+
+pub fn declare_set(i: Input) -> IResult<DeclareSet> {
+    map(
         consumed(rule! {
-            LET ~^#ident ~ #type_name? ~ ^":=" ~ ^#expr
+            #ident ~ RESULTSET ~ ^":=" ~ ^#statement_body
         }),
-        |(span, (_, name, data_type, _, default))| ScriptStatement::LetVar {
+        |(span, (name, _, _, stmt))| DeclareSet {
             span: transform_span(span.tokens),
-            declare: VariableDeclare {
-                name,
-                data_type,
-                default,
-            },
+            name,
+            stmt,
+        },
+    )(i)
+}
+
+pub fn script_stmts(i: Input) -> IResult<Vec<ScriptStatement>> {
+    semicolon_terminated_list1(script_stmt)(i)
+}
+
+pub fn script_stmt(i: Input) -> IResult<ScriptStatement> {
+    let let_var_stmt = map(
+        rule! {
+            LET ~ #declare_var
+        },
+        |(_, declare)| ScriptStatement::LetVar { declare },
+    );
+    let let_stmt_stmt = map(
+        rule! {
+            LET ~ #declare_set
         },
+        |(_, declare)| ScriptStatement::LetStatement { declare },
     );
     let run_stmt = map(
         consumed(rule! {
@@ -69,13 +115,40 @@ pub fn script_stmt(i: Input) -> IResult<ScriptStatement> {
             value,
         },
     );
+    let return_set_stmt = map(
+        consumed(rule! {
+            RETURN ~ TABLE ~ "(" ~ #ident ~ ^")"
+        }),
+        |(span, (_, _, _, name, _))| ScriptStatement::Return {
+            span: transform_span(span.tokens),
+            value: Some(ReturnItem::Set(name)),
+        },
+    );
+    let return_stmt_stmt = map(
+        consumed(rule! {
+            RETURN ~ TABLE ~ "(" ~ #statement_body ~ ^")"
+        }),
+        |(span, (_, _, _, stmt, _))| ScriptStatement::Return {
+            span: transform_span(span.tokens),
+            value: Some(ReturnItem::Statement(stmt)),
+        },
+    );
+    let return_var_stmt = map(
+        consumed(rule! {
+            RETURN ~ #expr
+        }),
+        |(span, (_, expr))| ScriptStatement::Return {
+            span: transform_span(span.tokens),
+            value: Some(ReturnItem::Var(expr)),
+        },
+    );
     let return_stmt = map(
         consumed(rule! {
-            RETURN ~ #expr?
+            RETURN
         }),
-        |(span, (_, value))| ScriptStatement::Return {
+        |(span, _)| ScriptStatement::Return {
             span: transform_span(span.tokens),
-            value,
+            value: None,
         },
     );
     let for_loop_stmt = map(
@@ -98,13 +171,13 @@ pub fn script_stmt(i: Input) -> IResult<ScriptStatement> {
             label,
         },
     );
-    let for_in_stmt = map(
+    let for_in_set_stmt = map(
         consumed(rule! {
             FOR ~ ^#ident ~ ^IN ~ #ident ~ ^DO
             ~ ^#semicolon_terminated_list1(script_stmt)
             ~ ^END ~ ^FOR ~ #ident?
         }),
-        |(span, (_, variable, _, resultset, _, body, _, _, label))| ScriptStatement::ForIn {
+        |(span, (_, variable, _, resultset, _, body, _, _, label))| ScriptStatement::ForInSet {
             span: transform_span(span.tokens),
             variable,
             resultset,
@@ -112,6 +185,20 @@ pub fn script_stmt(i: Input) -> IResult<ScriptStatement> {
             label,
         },
     );
+    let for_in_stmt_stmt = map(
+        consumed(rule! {
+            FOR ~ ^#ident ~ ^IN ~ ^#statement_body ~ ^DO
+            ~ ^#semicolon_terminated_list1(script_stmt)
+            ~ ^END ~ ^FOR ~ #ident?
+        }),
+        |(span, (_, variable, _, stmt, _, body, _, _, label))| ScriptStatement::ForInStatement {
+            span: transform_span(span.tokens),
+            variable,
+            stmt,
+            body,
+            label,
+        },
+    );
     let while_loop_stmt = map(
         consumed(rule! {
             WHILE ~ ^#expr ~ ^DO
@@ -217,9 +304,13 @@ pub fn script_stmt(i: Input) -> IResult<ScriptStatement> {
         | #let_var_stmt
         | #run_stmt
         | #assign_stmt
+        | #return_set_stmt
+        | #return_stmt_stmt
+        | #return_var_stmt
         | #return_stmt
         | #for_loop_stmt
-        | #for_in_stmt
+        | #for_in_set_stmt
+        | #for_in_stmt_stmt
         | #while_loop_stmt
         | #repeat_loop_stmt
         | #loop_stmt
diff --git a/src/query/ast/src/parser/statement.rs b/src/query/ast/src/parser/statement.rs
index 28e294b06e30..5c64e939b143 100644
--- a/src/query/ast/src/parser/statement.rs
+++ b/src/query/ast/src/parser/statement.rs
@@ -2025,6 +2025,13 @@ pub fn statement_body(i: Input) -> IResult<Statement> {
     let commit = value(Statement::Commit, rule! { COMMIT });
     let abort = value(Statement::Abort, rule! { ABORT | ROLLBACK });
 
+    let execute_immediate = map(
+        rule! {
+            EXECUTE ~ IMMEDIATE ~ #code_string
+        },
+        |(_, _, script)| Statement::ExecuteImmediate(ExecuteImmediateStmt { script }),
+    );
+
     alt((
         // query, explain,show
         rule!(
@@ -2149,24 +2156,16 @@ pub fn statement_body(i: Input) -> IResult<Statement> {
             | #list_stage: "`LIST @<stage_name> [pattern = '<pattern>']`"
             | #remove_stage: "`REMOVE @<stage_name> [pattern = '<pattern>']`"
             | #drop_stage: "`DROP STAGE <stage_name>`"
-        ),
-        rule!(
-            #create_file_format: "`CREATE FILE FORMAT [ IF NOT EXISTS ] <format_name> formatTypeOptions`"
+            | #create_file_format: "`CREATE FILE FORMAT [ IF NOT EXISTS ] <format_name> formatTypeOptions`"
             | #show_file_formats: "`SHOW FILE FORMATS`"
             | #drop_file_format: "`DROP FILE FORMAT  [ IF EXISTS ] <format_name>`"
-        ),
-        rule!( #copy_into ),
-        rule!(
-            #call: "`CALL <procedure_name>(<parameter>, ...)`"
-        ),
-        rule!(
-            #grant : "`GRANT { ROLE <role_name> | schemaObjectPrivileges | ALL [ PRIVILEGES ] ON <privileges_level> } TO { [ROLE <role_name>] | [USER] <user> }`"
+            | #copy_into
+            | #call: "`CALL <procedure_name>(<parameter>, ...)`"
+            | #grant : "`GRANT { ROLE <role_name> | schemaObjectPrivileges | ALL [ PRIVILEGES ] ON <privileges_level> } TO { [ROLE <role_name>] | [USER] <user> }`"
             | #show_grants : "`SHOW GRANTS {FOR  { ROLE <role_name> | USER <user> }] | ON {DATABASE <db_name> | TABLE <db_name>.<table_name>} }`"
             | #revoke : "`REVOKE { ROLE <role_name> | schemaObjectPrivileges | ALL [ PRIVILEGES ] ON <privileges_level> } FROM { [ROLE <role_name>] | [USER] <user> }`"
             | #grant_ownership : "GRANT OWNERSHIP ON <privileges_level> TO ROLE <role_name>"
-        ),
-        rule!(
-            #presign: "`PRESIGN [{DOWNLOAD | UPLOAD}] <location> [EXPIRE = 3600]`"
+            | #presign: "`PRESIGN [{DOWNLOAD | UPLOAD}] <location> [EXPIRE = 3600]`"
         ),
         // data mask
         rule!(
@@ -2231,9 +2230,10 @@ AS
         ),
         rule!(
             #create_connection: "`CREATE [OR REPLACE] CONNECTION [IF NOT EXISTS] <connection_name> STORAGE_TYPE = <type> <storage_configs>`"
-        | #drop_connection: "`DROP CONNECTION [IF EXISTS] <connection_name>`"
-        | #desc_connection: "`DESC | DESCRIBE CONNECTION  <connection_name>`"
-        | #show_connections: "`SHOW CONNECTIONS`"
+            | #drop_connection: "`DROP CONNECTION [IF EXISTS] <connection_name>`"
+            | #desc_connection: "`DESC | DESCRIBE CONNECTION  <connection_name>`"
+            | #show_connections: "`SHOW CONNECTIONS`"
+            | #execute_immediate : "`EXECUTE IMMEDIATE $$ <script> $$`"
         ),
     ))(i)
 }
diff --git a/src/query/ast/src/parser/token.rs b/src/query/ast/src/parser/token.rs
index ad3952dcb7ca..21ae906ef8c9 100644
--- a/src/query/ast/src/parser/token.rs
+++ b/src/query/ast/src/parser/token.rs
@@ -486,6 +486,8 @@ pub enum TokenKind {
     DECADE,
     #[token("DECIMAL", ignore(ascii_case))]
     DECIMAL,
+    #[token("DECLARE", ignore(ascii_case))]
+    DECLARE,
     #[token("DEFAULT", ignore(ascii_case))]
     DEFAULT,
     #[token("DEFLATE", ignore(ascii_case))]
@@ -674,6 +676,8 @@ pub enum TokenKind {
     INTO,
     #[token("INVERTED", ignore(ascii_case))]
     INVERTED,
+    #[token("IMMEDIATE", ignore(ascii_case))]
+    IMMEDIATE,
     #[token("IS", ignore(ascii_case))]
     IS,
     #[token("ISODOW", ignore(ascii_case))]
@@ -1512,7 +1516,7 @@ impl TokenKind {
             // | TokenKind::DEFERRABLE
             | TokenKind::DESC
             | TokenKind::DISTINCT
-            // | TokenKind::DO
+            | TokenKind::DO
             | TokenKind::ELSE
             | TokenKind::END
             | TokenKind::FALSE
@@ -1538,7 +1542,6 @@ impl TokenKind {
             | TokenKind::NULL
             // | TokenKind::ONLY
             | TokenKind::OR
-            // | TokenKind::OUTER
             // | TokenKind::PLACING
             // | TokenKind::PRIMARY
             // | TokenKind::REFERENCES
@@ -1551,7 +1554,6 @@ impl TokenKind {
             | TokenKind::SOME
             | TokenKind::SEMI
             // | TokenKind::SYMMETRIC
-            // | TokenKind::TABLE
             // | TokenKind::TABLESAMPLE
             | TokenKind::THEN
             | TokenKind::TRAILING
@@ -1571,7 +1573,7 @@ impl TokenKind {
             | TokenKind::EXCEPT
             // | TokenKind::FETCH
             | TokenKind::FROM
-            // | TokenKind::GRANT
+            | TokenKind::GRANT
             | TokenKind::GROUP
             | TokenKind::HAVING
             | TokenKind::INTERSECT
diff --git a/src/query/ast/tests/it/parser.rs b/src/query/ast/tests/it/parser.rs
index b9e56ff860f3..4e1af3a3defb 100644
--- a/src/query/ast/tests/it/parser.rs
+++ b/src/query/ast/tests/it/parser.rs
@@ -22,6 +22,7 @@ use databend_common_ast::parser::parse_sql;
 use databend_common_ast::parser::query::*;
 use databend_common_ast::parser::quote::quote_ident;
 use databend_common_ast::parser::quote::unquote_ident;
+use databend_common_ast::parser::script::script_block;
 use databend_common_ast::parser::script::script_stmt;
 use databend_common_ast::parser::statement::insert_stmt;
 use databend_common_ast::parser::token::*;
@@ -131,9 +132,11 @@ fn test_statement() {
         r#"create table a.b like c.d;"#,
         r#"create table t like t2 engine = memory;"#,
         r#"create table if not exists a.b (a int) 's3://testbucket/admin/data/' connection=(aws_key_id='minioadmin' aws_secret_key='minioadmin' endpoint_url='http://127.0.0.1:9900');"#,
-        r#"create table if not exists a.b (a int) 's3://testbucket/admin/data/'
-             connection=(aws_key_id='minioadmin' aws_secret_key='minioadmin' endpoint_url='http://127.0.0.1:9900')
-             location_prefix = 'db';"#,
+        r#"
+            create table if not exists a.b (a int) 's3://testbucket/admin/data/'
+                connection=(aws_key_id='minioadmin' aws_secret_key='minioadmin' endpoint_url='http://127.0.0.1:9900')
+                location_prefix = 'db';
+        "#,
         r#"truncate table a;"#,
         r#"truncate table "a".b;"#,
         r#"drop table a;"#,
@@ -312,10 +315,13 @@ fn test_statement() {
         r#"SET ROLE 'test-user';"#,
         r#"SET ROLE ROLE1;"#,
         r#"REVOKE ALL ON tb1 FROM 'u1';"#,
-        r#"COPY INTO mytable
+        r#"
+            COPY INTO mytable
                 FROM '@~/mybucket/my data.csv'
-                size_limit=10;"#,
-        r#"COPY INTO mytable
+                size_limit=10;
+        "#,
+        r#"
+            COPY INTO mytable
                 FROM @~/mybucket/data.csv
                 FILE_FORMAT = (
                     type = CSV
@@ -323,8 +329,10 @@ fn test_statement() {
                     record_delimiter = '\n'
                     skip_header = 1
                 )
-                size_limit=10;"#,
-        r#"COPY INTO mytable
+                size_limit=10;
+        "#,
+        r#"
+            COPY INTO mytable
                 FROM 's3://mybucket/data.csv'
                 FILE_FORMAT = (
                     type = CSV
@@ -333,8 +341,10 @@ fn test_statement() {
                     skip_header = 1
                 )
                 size_limit=10
-                max_files=10;"#,
-        r#"COPY INTO mytable
+                max_files=10;
+        "#,
+        r#"
+            COPY INTO mytable
                 FROM 's3://mybucket/data.csv'
                 FILE_FORMAT = (
                     type = CSV
@@ -343,8 +353,10 @@ fn test_statement() {
                     skip_header = 1
                 )
                 size_limit=10
-                max_files=3000;"#,
-        r#"COPY INTO mytable
+                max_files=3000;
+        "#,
+        r#"
+            COPY INTO mytable
                 FROM 's3://mybucket/data.csv'
                 CONNECTION = (
                     ENDPOINT_URL = 'http://127.0.0.1:9900'
@@ -355,8 +367,10 @@ fn test_statement() {
                     record_delimiter = '\n'
                     skip_header = 1
                 )
-                size_limit=10;"#,
-        r#"COPY INTO mytable
+                size_limit=10;
+        "#,
+        r#"
+            COPY INTO mytable
                 FROM 's3://mybucket/data.csv'
                 CONNECTION = (
                     ENDPOINT_URL = 'http://127.0.0.1:9900'
@@ -367,12 +381,18 @@ fn test_statement() {
                     field_delimiter = ','
                     record_delimiter = '\n'
                     skip_header = 1
-                );"#,
-        r#"COPY INTO mytable
-                FROM 'https://127.0.0.1:9900';"#,
-        r#"COPY INTO mytable
-                FROM 'https://127.0.0.1:';"#,
-        r#"COPY INTO mytable
+                );
+        "#,
+        r#"
+            COPY INTO mytable
+                FROM 'https://127.0.0.1:9900';
+        "#,
+        r#"
+            COPY INTO mytable
+                FROM 'https://127.0.0.1:';
+        "#,
+        r#"
+            COPY INTO mytable
                 FROM @my_stage
                 FILE_FORMAT = (
                     type = CSV,
@@ -381,26 +401,34 @@ fn test_statement() {
                     skip_header = 1,
                     error_on_column_count_mismatch = FALSE
                 )
-                size_limit=10;"#,
-        r#"COPY INTO 's3://mybucket/data.csv'
+                size_limit=10;
+        "#,
+        r#"
+            COPY INTO 's3://mybucket/data.csv'
                 FROM mytable
                 FILE_FORMAT = (
                     type = CSV
                     field_delimiter = ','
                     record_delimiter = '\n'
                     skip_header = 1
-                )"#,
-        r#"COPY INTO '@my_stage/my data'
-                FROM mytable;"#,
-        r#"COPY INTO @my_stage
+                )
+        "#,
+        r#"
+            COPY INTO '@my_stage/my data'
+                FROM mytable;
+        "#,
+        r#"
+            COPY INTO @my_stage
                 FROM mytable
                 FILE_FORMAT = (
                     type = CSV
                     field_delimiter = ','
                     record_delimiter = '\n'
                     skip_header = 1
-                );"#,
-        r#"COPY INTO mytable
+                );
+        "#,
+        r#"
+            COPY INTO mytable
                 FROM 's3://mybucket/data.csv'
                 CREDENTIALS = (
                     AWS_KEY_ID = 'access_key'
@@ -412,8 +440,10 @@ fn test_statement() {
                     record_delimiter = '\n'
                     skip_header = 1
                 )
-                size_limit=10;"#,
-        r#"COPY INTO mytable
+                size_limit=10;
+        "#,
+        r#"
+            COPY INTO mytable
                 FROM @external_stage/path/to/file.csv
                 FILE_FORMAT = (
                     type = CSV
@@ -421,8 +451,10 @@ fn test_statement() {
                     record_delimiter = '\n'
                     skip_header = 1
                 )
-                size_limit=10;"#,
-        r#"COPY INTO mytable
+                size_limit=10;
+        "#,
+        r#"
+            COPY INTO mytable
                 FROM @external_stage/path/to/dir/
                 FILE_FORMAT = (
                     type = CSV
@@ -430,8 +462,10 @@ fn test_statement() {
                     record_delimiter = '\n'
                     skip_header = 1
                 )
-                size_limit=10;"#,
-        r#"COPY INTO mytable
+                size_limit=10;
+        "#,
+        r#"
+            COPY INTO mytable
                 FROM @external_stage/path/to/file.csv
                 FILE_FORMAT = (
                     type = CSV
@@ -439,8 +473,10 @@ fn test_statement() {
                     record_delimiter = '\n'
                     skip_header = 1
                 )
-                force=true;"#,
-        r#"COPY INTO mytable
+                force=true;
+        "#,
+        r#"
+            COPY INTO mytable
                 FROM 'fs:///path/to/data.csv'
                 FILE_FORMAT = (
                     type = CSV
@@ -449,17 +485,21 @@ fn test_statement() {
                     skip_header = 1
                 )
                 size_limit=10
-                disable_variant_check=true;"#,
-        r#"COPY INTO books FROM 's3://databend/books.csv'
+                disable_variant_check=true;
+        "#,
+        r#"
+            COPY INTO books FROM 's3://databend/books.csv'
                 CONNECTION = (
                     ENDPOINT_URL = 'http://localhost:9000/',
                     ACCESS_KEY_ID = 'ROOTUSER',
                     SECRET_ACCESS_KEY = 'CHANGEME123',
                     region = 'us-west-2'
                 )
-                FILE_FORMAT = (type = CSV);"#,
+                FILE_FORMAT = (type = CSV);
+        "#,
         // We used to support COPY FROM a quoted at string
-        // r#"COPY INTO mytable
+        // r#"
+        //     COPY INTO mytable
         //         FROM '@external_stage/path/to/file.csv'
         //         FILE_FORMAT = (
         //             type = 'CSV'
@@ -467,7 +507,8 @@ fn test_statement() {
         //             record_delimiter = '\n'
         //             skip_header = 1
         //         )
-        //         size_limit=10;"#,
+        //         size_limit=10;
+        // "#,
         r#"CALL system$test(a)"#,
         r#"CALL system$test('a')"#,
         r#"show settings like 'enable%' limit 1"#,
@@ -526,16 +567,24 @@ fn test_statement() {
         r#"UNSET max_threads;"#,
         r#"UNSET (max_threads, sql_dialect);"#,
         r#"select $1 FROM '@my_stage/my data/'"#,
-        r#"SELECT t.c1 FROM @stage1/dir/file
-        ( file_format => 'PARQUET', FILES => ('file1', 'file2')) t;"#,
-        r#"select table0.c1, table1.c2 from
-            @stage1/dir/file ( FILE_FORMAT => 'parquet', FILES => ('file1', 'file2')) table0
-            left join table1;"#,
+        r#"
+            SELECT t.c1 FROM @stage1/dir/file
+                ( file_format => 'PARQUET', FILES => ('file1', 'file2')) t;
+        "#,
+        r#"
+            select table0.c1, table1.c2 from
+                @stage1/dir/file ( FILE_FORMAT => 'parquet', FILES => ('file1', 'file2')) table0
+                left join table1;
+        "#,
         r#"SELECT c1 FROM 's3://test/bucket' (PATTERN => '*.parquet', connection => (ENDPOINT_URL = 'xxx')) t;"#,
-        r#"CREATE FILE FORMAT my_csv
-            type = CSV field_delimiter = ',' record_delimiter = '\n' skip_header = 1;"#,
-        r#"CREATE OR REPLACE FILE FORMAT my_csv
-            type = CSV field_delimiter = ',' record_delimiter = '\n' skip_header = 1;"#,
+        r#"
+            CREATE FILE FORMAT my_csv
+                type = CSV field_delimiter = ',' record_delimiter = '\n' skip_header = 1;
+        "#,
+        r#"
+            CREATE OR REPLACE FILE FORMAT my_csv
+                type = CSV field_delimiter = ',' record_delimiter = '\n' skip_header = 1;
+        "#,
         r#"SHOW FILE FORMATS"#,
         r#"DROP FILE FORMAT my_csv"#,
         r#"SELECT * FROM t GROUP BY GROUPING SETS (a, b, c, d)"#,
@@ -565,34 +614,38 @@ fn test_statement() {
         r#"CREATE TASK IF NOT EXISTS MyTask1 SCHEDULE = USING CRON '0 13 * * *' AS COPY INTO @my_internal_stage FROM canadian_city_population FILE_FORMAT = (TYPE = PARQUET)"#,
         r#"CREATE TASK IF NOT EXISTS MyTask1 AFTER 'task2', 'task3' WHEN SYSTEM$GET_PREDECESSOR_RETURN_VALUE('task_name') != 'VALIDATION' AS VACUUM TABLE t"#,
         r#"CREATE TASK IF NOT EXISTS MyTask1 DATABASE = 'target', TIMEZONE = 'America/Los Angeles'  AS VACUUM TABLE t"#,
-        r#"CREATE TASK IF NOT EXISTS MyTask1 DATABASE = 'target', TIMEZONE = 'America/Los Angeles'  as
-            BEGIN
-              begin;
-              insert into t values('a;');
-              delete from t where c = ';';
-              vacuum table t;
-              merge into t using s on t.id = s.id when matched then update *;
-              commit;
+        r#"
+            CREATE TASK IF NOT EXISTS MyTask1 DATABASE = 'target', TIMEZONE = 'America/Los Angeles' as
+                BEGIN
+                begin;
+                insert into t values('a;');
+                delete from t where c = ';';
+                vacuum table t;
+                merge into t using s on t.id = s.id when matched then update *;
+                commit;
+                END
+        "#,
+        r#"
+            CREATE TASK IF NOT EXISTS merge_task WAREHOUSE = 'test-parser' SCHEDULE = 1 SECOND
+            AS BEGIN
+            MERGE INTO t USING s ON t.c = s.c
+                WHEN MATCHED THEN
+                UPDATE
+                    *
+                    WHEN NOT MATCHED THEN
+                INSERT
+                    *;
             END"#,
         r#"CREATE TASK IF NOT EXISTS merge_task WAREHOUSE = 'test-parser' SCHEDULE = 1 SECOND
-        AS BEGIN
-          MERGE INTO t USING s ON t.c = s.c
-            WHEN MATCHED THEN
-            UPDATE
-                *
-                WHEN NOT MATCHED THEN
-            INSERT
-                *;
-        END"#,
-        r#"CREATE TASK IF NOT EXISTS merge_task WAREHOUSE = 'test-parser' SCHEDULE = 1 SECOND
-        AS BEGIN
-          MERGE INTO t USING s ON t.c = s.c
-            WHEN MATCHED THEN
-            UPDATE
-                *
-                WHEN NOT MATCHED THEN
-            INSERT values('a;', 1, "str");
-        END"#,
+            AS BEGIN
+            MERGE INTO t USING s ON t.c = s.c
+                WHEN MATCHED THEN
+                UPDATE
+                    *
+                    WHEN NOT MATCHED THEN
+                INSERT values('a;', 1, "str");
+            END
+        "#,
         r#"ALTER TASK MyTask1 RESUME"#,
         r#"ALTER TASK MyTask1 SUSPEND"#,
         r#"ALTER TASK MyTask1 ADD AFTER 'task2', 'task3'"#,
@@ -603,7 +656,8 @@ fn test_statement() {
         r#"ALTER TASK MyTask1 SET DATABASE='newDB', TIMEZONE='America/Los_Angeles'"#,
         r#"ALTER TASK MyTask1 SET ERROR_INTEGRATION = 'candidate_notifictaion'"#,
         r#"ALTER TASK MyTask2 MODIFY AS SELECT CURRENT_VERSION()"#,
-        r#"ALTER TASK MyTask2 MODIFY AS
+        r#"
+            ALTER TASK MyTask2 MODIFY AS
             BEGIN
               begin;
               insert into t values('a;');
@@ -611,7 +665,8 @@ fn test_statement() {
               vacuum table t;
               merge into t using s on t.id = s.id when matched then update *;
               commit;
-            END"#,
+            END
+        "#,
         r#"ALTER TASK MyTask1 MODIFY WHEN SYSTEM$GET_PREDECESSOR_RETURN_VALUE('task_name') != 'VALIDATION'"#,
         r#"DROP TASK MyTask1"#,
         r#"SHOW TASKS"#,
@@ -657,24 +712,38 @@ fn test_statement() {
         r#"CREATE FUNCTION binary_reverse (BINARY) RETURNS BINARY LANGUAGE python HANDLER = 'binary_reverse' ADDRESS = 'http://0.0.0.0:8815';"#,
         r#"CREATE OR REPLACE FUNCTION binary_reverse (BINARY) RETURNS BINARY LANGUAGE python HANDLER = 'binary_reverse' ADDRESS = 'http://0.0.0.0:8815';"#,
         r#"CREATE STAGE s file_format=(record_delimiter='\n' escape='\\');"#,
-        r#"create or replace function addone(int)
-returns int
-language python
-handler = 'addone_py'
-as
-$$
-def addone_py(i):
-  return i+1
-$$;"#,
+        r#"
+            create or replace function addone(int)
+            returns int
+            language python
+            handler = 'addone_py'
+            as
+            $$
+            def addone_py(i):
+            return i+1
+            $$;
+        "#,
         r#"DROP FUNCTION binary_reverse;"#,
         r#"DROP FUNCTION isnotempty;"#,
+        r#"
+            EXECUTE IMMEDIATE 
+            $$
+            BEGIN
+                LOOP
+                    RETURN 1;
+                END LOOP;
+            END;
+            $$
+        "#,
     ];
 
     for case in cases {
-        let tokens = tokenize_sql(case).unwrap();
+        let src = unindent::unindent(case);
+        let src = src.trim();
+        let tokens = tokenize_sql(src).unwrap();
         let (stmt, fmt) = parse_sql(&tokens, Dialect::PostgreSQL).unwrap();
         writeln!(file, "---------- Input ----------").unwrap();
-        writeln!(file, "{}", case).unwrap();
+        writeln!(file, "{}", src).unwrap();
         writeln!(file, "---------- Output ---------").unwrap();
         writeln!(file, "{}", stmt).unwrap();
         writeln!(file, "---------- AST ------------").unwrap();
@@ -853,6 +922,7 @@ fn test_query() {
         r#"VALUES(1,'a'),(2,'b'),(null,'c') order by col0 limit 2"#,
         r#"select * from t left join lateral(select 1) on true, lateral(select 2)"#,
         r#"select * from t, lateral flatten(input => u.col) f"#,
+        r#"select * from flatten(input => parse_json('{"a":1, "b":[77,88]}'), outer => true)"#,
     ];
 
     for case in cases {
@@ -1055,11 +1125,13 @@ fn test_script() {
     let file = &mut mint.new_goldenfile("script.txt").unwrap();
 
     let cases = &[
-        r#"LET cost DECIMAL(38, 2) := 100.0"#,
+        r#"LET cost := 100.0"#,
         r#"LET t1 RESULTSET := SELECT * FROM numbers(100)"#,
         r#"profit := revenue - cost"#,
-        r#"RETURN profit"#,
         r#"RETURN"#,
+        r#"RETURN profit"#,
+        r#"RETURN TABLE(t1)"#,
+        r#"RETURN TABLE(select count(*) from t1)"#,
         r#"
             FOR i IN REVERSE 1 TO maximum_count DO
                 counter := counter + 1;
@@ -1070,6 +1142,11 @@ fn test_script() {
                 CONTINUE;
             END FOR label1
         "#,
+        r#"
+            FOR rec IN SELECT * FROM numbers(100) DO
+                CONTINUE;
+            END FOR label1
+        "#,
         r#"
             WHILE counter < maximum_count DO
                 CONTINUE label1;
@@ -1134,6 +1211,35 @@ fn test_script() {
             case,
         );
     }
+
+    let cases = vec![
+        r#"
+            BEGIN
+                LOOP
+                    CONTINUE;
+                END LOOP;
+            END;
+        "#,
+        r#"
+            DECLARE
+                x := 1;
+            BEGIN
+                FOR y in x TO 10 DO
+                    CONTINUE;
+                END FOR;
+            END;
+        "#,
+    ];
+
+    for case in cases {
+        run_parser_with_dialect(
+            file,
+            script_block,
+            Dialect::PostgreSQL,
+            ParseMode::Template,
+            case,
+        );
+    }
 }
 
 #[test]
diff --git a/src/query/ast/tests/it/testdata/query-error.txt b/src/query/ast/tests/it/testdata/query-error.txt
index 9f42ab5b7c40..669d79e77a22 100644
--- a/src/query/ast/tests/it/testdata/query-error.txt
+++ b/src/query/ast/tests/it/testdata/query-error.txt
@@ -79,7 +79,7 @@ error:
   --> SQL:1:15
   |
 1 | select * order
-  | ------        ^ unexpected end of line, expecting `BY`
+  | ------        ^ unexpected end of input, expecting `BY`
   | |             
   | while parsing `SELECT ...`
 
diff --git a/src/query/ast/tests/it/testdata/query.txt b/src/query/ast/tests/it/testdata/query.txt
index 2f65b3dd3a9a..d74e9cc78a17 100644
--- a/src/query/ast/tests/it/testdata/query.txt
+++ b/src/query/ast/tests/it/testdata/query.txt
@@ -6875,3 +6875,123 @@ Query {
 }
 
 
+---------- Input ----------
+select * from flatten(input => parse_json('{"a":1, "b":[77,88]}'), outer => true)
+---------- Output ---------
+SELECT * FROM flatten(input=>parse_json('{"a":1, "b":[77,88]}'),outer=>TRUE)
+---------- AST ------------
+Query {
+    span: Some(
+        0..81,
+    ),
+    with: None,
+    body: Select(
+        SelectStmt {
+            span: Some(
+                0..81,
+            ),
+            hints: None,
+            distinct: false,
+            select_list: [
+                StarColumns {
+                    qualified: [
+                        Star(
+                            Some(
+                                7..8,
+                            ),
+                        ),
+                    ],
+                    column_filter: None,
+                },
+            ],
+            from: [
+                TableFunction {
+                    span: Some(
+                        14..81,
+                    ),
+                    lateral: false,
+                    name: Identifier {
+                        span: Some(
+                            14..21,
+                        ),
+                        name: "flatten",
+                        quote: None,
+                        is_hole: false,
+                    },
+                    params: [],
+                    named_params: [
+                        (
+                            Identifier {
+                                span: Some(
+                                    22..27,
+                                ),
+                                name: "input",
+                                quote: None,
+                                is_hole: false,
+                            },
+                            FunctionCall {
+                                span: Some(
+                                    31..65,
+                                ),
+                                func: FunctionCall {
+                                    distinct: false,
+                                    name: Identifier {
+                                        span: Some(
+                                            31..41,
+                                        ),
+                                        name: "parse_json",
+                                        quote: None,
+                                        is_hole: false,
+                                    },
+                                    args: [
+                                        Literal {
+                                            span: Some(
+                                                42..64,
+                                            ),
+                                            value: String(
+                                                "{\"a\":1, \"b\":[77,88]}",
+                                            ),
+                                        },
+                                    ],
+                                    params: [],
+                                    window: None,
+                                    lambda: None,
+                                },
+                            },
+                        ),
+                        (
+                            Identifier {
+                                span: Some(
+                                    67..72,
+                                ),
+                                name: "outer",
+                                quote: None,
+                                is_hole: false,
+                            },
+                            Literal {
+                                span: Some(
+                                    76..80,
+                                ),
+                                value: Boolean(
+                                    true,
+                                ),
+                            },
+                        ),
+                    ],
+                    alias: None,
+                },
+            ],
+            selection: None,
+            group_by: None,
+            having: None,
+            window_list: None,
+            qualify: None,
+        },
+    ),
+    order_by: [],
+    limit: [],
+    offset: None,
+    ignore_result: false,
+}
+
+
diff --git a/src/query/ast/tests/it/testdata/script.txt b/src/query/ast/tests/it/testdata/script.txt
index 7e36bb75c8e6..086623f4df4e 100644
--- a/src/query/ast/tests/it/testdata/script.txt
+++ b/src/query/ast/tests/it/testdata/script.txt
@@ -1,13 +1,13 @@
 ---------- Input ----------
-LET cost DECIMAL(38, 2) := 100.0
+LET cost := 100.0
 ---------- Output ---------
-LET cost Decimal(38, 2) := 100.0
+LET cost := 100.0
 ---------- AST ------------
 LetVar {
-    span: Some(
-        0..32,
-    ),
-    declare: VariableDeclare {
+    declare: DeclareVar {
+        span: Some(
+            4..17,
+        ),
         name: Identifier {
             span: Some(
                 4..8,
@@ -16,15 +16,9 @@ LetVar {
             quote: None,
             is_hole: false,
         },
-        data_type: Some(
-            Decimal {
-                precision: 38,
-                scale: 2,
-            },
-        ),
         default: Literal {
             span: Some(
-                27..32,
+                12..17,
             ),
             value: Decimal256 {
                 value: 1000,
@@ -42,10 +36,10 @@ LET t1 RESULTSET := SELECT * FROM numbers(100)
 LET t1 RESULTSET := SELECT * FROM numbers(100)
 ---------- AST ------------
 LetStatement {
-    span: Some(
-        0..46,
-    ),
-    declare: StatementDeclare {
+    declare: DeclareSet {
+        span: Some(
+            4..46,
+        ),
         name: Identifier {
             span: Some(
                 4..6,
@@ -188,6 +182,19 @@ Assign {
 }
 
 
+---------- Input ----------
+RETURN
+---------- Output ---------
+RETURN
+---------- AST ------------
+Return {
+    span: Some(
+        0..6,
+    ),
+    value: None,
+}
+
+
 ---------- Input ----------
 RETURN profit
 ---------- Output ---------
@@ -198,39 +205,126 @@ Return {
         0..13,
     ),
     value: Some(
-        ColumnRef {
-            span: Some(
-                7..13,
-            ),
-            column: ColumnRef {
-                database: None,
-                table: None,
-                column: Name(
-                    Identifier {
-                        span: Some(
-                            7..13,
-                        ),
-                        name: "profit",
-                        quote: None,
-                        is_hole: false,
-                    },
+        Var(
+            ColumnRef {
+                span: Some(
+                    7..13,
                 ),
+                column: ColumnRef {
+                    database: None,
+                    table: None,
+                    column: Name(
+                        Identifier {
+                            span: Some(
+                                7..13,
+                            ),
+                            name: "profit",
+                            quote: None,
+                            is_hole: false,
+                        },
+                    ),
+                },
             },
-        },
+        ),
     ),
 }
 
 
 ---------- Input ----------
-RETURN
+RETURN TABLE(t1)
 ---------- Output ---------
-RETURN
+RETURN TABLE(t1)
 ---------- AST ------------
 Return {
     span: Some(
-        0..6,
+        0..16,
+    ),
+    value: Some(
+        Set(
+            Identifier {
+                span: Some(
+                    13..15,
+                ),
+                name: "t1",
+                quote: None,
+                is_hole: false,
+            },
+        ),
+    ),
+}
+
+
+---------- Input ----------
+RETURN TABLE(select count(*) from t1)
+---------- Output ---------
+RETURN TABLE(SELECT COUNT(*) FROM t1)
+---------- AST ------------
+Return {
+    span: Some(
+        0..37,
+    ),
+    value: Some(
+        Statement(
+            Query(
+                Query {
+                    span: Some(
+                        13..36,
+                    ),
+                    with: None,
+                    body: Select(
+                        SelectStmt {
+                            span: Some(
+                                13..36,
+                            ),
+                            hints: None,
+                            distinct: false,
+                            select_list: [
+                                AliasedExpr {
+                                    expr: CountAll {
+                                        span: Some(
+                                            20..28,
+                                        ),
+                                        window: None,
+                                    },
+                                    alias: None,
+                                },
+                            ],
+                            from: [
+                                Table {
+                                    span: Some(
+                                        34..36,
+                                    ),
+                                    catalog: None,
+                                    database: None,
+                                    table: Identifier {
+                                        span: Some(
+                                            34..36,
+                                        ),
+                                        name: "t1",
+                                        quote: None,
+                                        is_hole: false,
+                                    },
+                                    alias: None,
+                                    temporal: None,
+                                    pivot: None,
+                                    unpivot: None,
+                                },
+                            ],
+                            selection: None,
+                            group_by: None,
+                            having: None,
+                            window_list: None,
+                            qualify: None,
+                        },
+                    ),
+                    order_by: [],
+                    limit: [],
+                    offset: None,
+                    ignore_result: false,
+                },
+            ),
+        ),
     ),
-    value: None,
 }
 
 
@@ -353,7 +447,7 @@ FOR rec IN resultset DO
     CONTINUE;
 END FOR label1
 ---------- AST ------------
-ForIn {
+ForInSet {
     span: Some(
         0..52,
     ),
@@ -394,6 +488,116 @@ ForIn {
 }
 
 
+---------- Input ----------
+FOR rec IN SELECT * FROM numbers(100) DO
+    CONTINUE;
+END FOR label1
+---------- Output ---------
+FOR rec IN
+    SELECT * FROM numbers(100)
+DO
+    CONTINUE;
+END FOR label1
+---------- AST ------------
+ForInStatement {
+    span: Some(
+        0..69,
+    ),
+    variable: Identifier {
+        span: Some(
+            4..7,
+        ),
+        name: "rec",
+        quote: None,
+        is_hole: false,
+    },
+    stmt: Query(
+        Query {
+            span: Some(
+                11..37,
+            ),
+            with: None,
+            body: Select(
+                SelectStmt {
+                    span: Some(
+                        11..37,
+                    ),
+                    hints: None,
+                    distinct: false,
+                    select_list: [
+                        StarColumns {
+                            qualified: [
+                                Star(
+                                    Some(
+                                        18..19,
+                                    ),
+                                ),
+                            ],
+                            column_filter: None,
+                        },
+                    ],
+                    from: [
+                        TableFunction {
+                            span: Some(
+                                25..37,
+                            ),
+                            lateral: false,
+                            name: Identifier {
+                                span: Some(
+                                    25..32,
+                                ),
+                                name: "numbers",
+                                quote: None,
+                                is_hole: false,
+                            },
+                            params: [
+                                Literal {
+                                    span: Some(
+                                        33..36,
+                                    ),
+                                    value: UInt64(
+                                        100,
+                                    ),
+                                },
+                            ],
+                            named_params: [],
+                            alias: None,
+                        },
+                    ],
+                    selection: None,
+                    group_by: None,
+                    having: None,
+                    window_list: None,
+                    qualify: None,
+                },
+            ),
+            order_by: [],
+            limit: [],
+            offset: None,
+            ignore_result: false,
+        },
+    ),
+    body: [
+        Continue {
+            span: Some(
+                45..53,
+            ),
+            label: None,
+        },
+    ],
+    label: Some(
+        Identifier {
+            span: Some(
+                63..69,
+            ),
+            name: "label1",
+            quote: None,
+            is_hole: false,
+        },
+    ),
+}
+
+
 ---------- Input ----------
 WHILE counter < maximum_count DO
     CONTINUE label1;
@@ -1692,3 +1896,144 @@ RunStatement {
 }
 
 
+---------- Input ----------
+BEGIN
+    LOOP
+        CONTINUE;
+    END LOOP;
+END;
+---------- Output ---------
+DECLARE
+BEGIN
+    LOOP
+        CONTINUE;
+    END LOOP;
+END;
+
+---------- AST ------------
+ScriptBlock {
+    span: Some(
+        0..51,
+    ),
+    declares: [],
+    body: [
+        Loop {
+            span: Some(
+                10..45,
+            ),
+            body: [
+                Continue {
+                    span: Some(
+                        23..31,
+                    ),
+                    label: None,
+                },
+            ],
+            label: None,
+        },
+    ],
+}
+
+
+---------- Input ----------
+DECLARE
+    x := 1;
+BEGIN
+    FOR y in x TO 10 DO
+        CONTINUE;
+    END FOR;
+END;
+---------- Output ---------
+DECLARE
+    x := 1;
+BEGIN
+    FOR y IN x TO 10 DO
+        CONTINUE;
+    END FOR;
+END;
+
+---------- AST ------------
+ScriptBlock {
+    span: Some(
+        0..85,
+    ),
+    declares: [
+        Var(
+            DeclareVar {
+                span: Some(
+                    12..18,
+                ),
+                name: Identifier {
+                    span: Some(
+                        12..13,
+                    ),
+                    name: "x",
+                    quote: None,
+                    is_hole: false,
+                },
+                default: Literal {
+                    span: Some(
+                        17..18,
+                    ),
+                    value: UInt64(
+                        1,
+                    ),
+                },
+            },
+        ),
+    ],
+    body: [
+        ForLoop {
+            span: Some(
+                30..79,
+            ),
+            variable: Identifier {
+                span: Some(
+                    34..35,
+                ),
+                name: "y",
+                quote: None,
+                is_hole: false,
+            },
+            is_reverse: false,
+            lower_bound: ColumnRef {
+                span: Some(
+                    39..40,
+                ),
+                column: ColumnRef {
+                    database: None,
+                    table: None,
+                    column: Name(
+                        Identifier {
+                            span: Some(
+                                39..40,
+                            ),
+                            name: "x",
+                            quote: None,
+                            is_hole: false,
+                        },
+                    ),
+                },
+            },
+            upper_bound: Literal {
+                span: Some(
+                    44..46,
+                ),
+                value: UInt64(
+                    10,
+                ),
+            },
+            body: [
+                Continue {
+                    span: Some(
+                        58..66,
+                    ),
+                    label: None,
+                },
+            ],
+            label: None,
+        },
+    ],
+}
+
+
diff --git a/src/query/ast/tests/it/testdata/statement-error.txt b/src/query/ast/tests/it/testdata/statement-error.txt
index 9c548023d802..a2c5f63cb433 100644
--- a/src/query/ast/tests/it/testdata/statement-error.txt
+++ b/src/query/ast/tests/it/testdata/statement-error.txt
@@ -169,7 +169,7 @@ error:
   --> SQL:1:19
   |
 1 | show tables format
-  |                   ^ unexpected end of line, expecting <Ident>, <QuotedString>, or `IDENTIFIER`
+  |                   ^ unexpected end of input, expecting <Ident>, <QuotedString>, or `IDENTIFIER`
 
 
 ---------- Input ----------
@@ -353,7 +353,7 @@ error:
   --> SQL:1:17
   |
 1 | CALL system$test
-  | ----            ^ unexpected end of line, expecting `(`
+  | ----            ^ unexpected end of input, expecting `(`
   | |               
   | while parsing `CALL <procedure_name>(<parameter>, ...)`
 
@@ -365,7 +365,7 @@ error:
   --> SQL:1:19
   |
 1 | CALL system$test(a
-  | ----              ^ unexpected end of line, expecting `)` or `,`
+  | ----              ^ unexpected end of input, expecting `)` or `,`
   | |                 
   | while parsing `CALL <procedure_name>(<parameter>, ...)`
 
@@ -752,7 +752,7 @@ error:
   --> SQL:1:40
   |
 1 | CREATE CONNECTION IF NOT EXISTS my_conn
-  | ------                                 ^ unexpected end of line, expecting `STORAGE_TYPE`
+  | ------                                 ^ unexpected end of input, expecting `STORAGE_TYPE`
   | |                                      
   | while parsing `CREATE [OR REPLACE] CONNECTION [IF NOT EXISTS] <connection_name> STORAGE_TYPE = <type> <storage_configs>`
 
@@ -845,7 +845,7 @@ error:
   --> SQL:1:65
   |
 1 | CREATE FUNCTION IF NOT EXISTS isnotempty AS(p) -> not(is_null(p)
-  | ------                                   --       ----          ^ unexpected end of line, expecting `)`, `OVER`, `(`, `IS`, `NOT`, `IN`, `EXISTS`, `BETWEEN`, `+`, `-`, `*`, `/`, `//`, `DIV`, `%`, `||`, `<->`, `>`, `<`, `>=`, `<=`, `=`, `<>`, `!=`, `^`, `AND`, `OR`, `XOR`, `LIKE`, `REGEXP`, `RLIKE`, `SOUNDS`, <BitWiseOr>, <BitWiseAnd>, <BitWiseXor>, <ShiftLeft>, <ShiftRight>, `->`, `->>`, `#>`, `#>>`, `?`, `?|`, `?&`, `@>`, `<@`, `@?`, `@@`, `#-`, <Factorial>, <SquareRoot>, <BitWiseNot>, <CubeRoot>, <Abs>, `CAST`, `TRY_CAST`, `DATE_ADD`, `DATE_SUB`, `DATE_TRUNC`, `DATE`, or 32 more ...
+  | ------                                   --       ----          ^ unexpected end of input, expecting `)`, `OVER`, `(`, `IS`, `NOT`, `IN`, `EXISTS`, `BETWEEN`, `+`, `-`, `*`, `/`, `//`, `DIV`, `%`, `||`, `<->`, `>`, `<`, `>=`, `<=`, `=`, `<>`, `!=`, `^`, `AND`, `OR`, `XOR`, `LIKE`, `REGEXP`, `RLIKE`, `SOUNDS`, <BitWiseOr>, <BitWiseAnd>, <BitWiseXor>, <ShiftLeft>, <ShiftRight>, `->`, `->>`, `#>`, `#>>`, `?`, `?|`, `?&`, `@>`, `<@`, `@?`, `@@`, `#-`, <Factorial>, <SquareRoot>, <BitWiseNot>, <CubeRoot>, <Abs>, `CAST`, `TRY_CAST`, `DATE_ADD`, `DATE_SUB`, `DATE_TRUNC`, `DATE`, or 32 more ...
   | |                                        |        |  |          
   | |                                        |        |  while parsing `(<expr> [, ...])`
   | |                                        |        while parsing expression
diff --git a/src/query/ast/tests/it/testdata/statement.txt b/src/query/ast/tests/it/testdata/statement.txt
index f3d2db5f908a..b83d72f4e0e2 100644
--- a/src/query/ast/tests/it/testdata/statement.txt
+++ b/src/query/ast/tests/it/testdata/statement.txt
@@ -2228,8 +2228,8 @@ CreateTable(
 
 ---------- Input ----------
 create table if not exists a.b (a int) 's3://testbucket/admin/data/'
-             connection=(aws_key_id='minioadmin' aws_secret_key='minioadmin' endpoint_url='http://127.0.0.1:9900')
-             location_prefix = 'db';
+    connection=(aws_key_id='minioadmin' aws_secret_key='minioadmin' endpoint_url='http://127.0.0.1:9900')
+    location_prefix = 'db';
 ---------- Output ---------
 CREATE TABLE IF NOT EXISTS a.b (a Int32) 's3://testbucket/admin/data/' CONNECTION = ( aws_key_id = 'minioadmin', aws_secret_key = 'minioadmin', endpoint_url = 'http://127.0.0.1:9900' ) LOCATION_PREFIX = 'db'
 ---------- AST ------------
@@ -11966,8 +11966,8 @@ Revoke(
 
 ---------- Input ----------
 COPY INTO mytable
-                FROM '@~/mybucket/my data.csv'
-                size_limit=10;
+    FROM '@~/mybucket/my data.csv'
+    size_limit=10;
 ---------- Output ---------
 COPY INTO mytable FROM '@~/mybucket/my data.csv' SIZE_LIMIT = 10 PURGE = false FORCE = false DISABLE_VARIANT_CHECK = false ON_ERROR = abort
 ---------- AST ------------
@@ -12012,14 +12012,14 @@ CopyIntoTable(
 
 ---------- Input ----------
 COPY INTO mytable
-                FROM @~/mybucket/data.csv
-                FILE_FORMAT = (
-                    type = CSV
-                    field_delimiter = ','
-                    record_delimiter = '\n'
-                    skip_header = 1
-                )
-                size_limit=10;
+    FROM @~/mybucket/data.csv
+    FILE_FORMAT = (
+        type = CSV
+        field_delimiter = ','
+        record_delimiter = '\n'
+        skip_header = 1
+    )
+    size_limit=10;
 ---------- Output ---------
 COPY INTO mytable FROM '@~/mybucket/data.csv' FILE_FORMAT = (field_delimiter = ',', record_delimiter = '\n', skip_header = 1, type = CSV) SIZE_LIMIT = 10 PURGE = false FORCE = false DISABLE_VARIANT_CHECK = false ON_ERROR = abort
 ---------- AST ------------
@@ -12077,15 +12077,15 @@ CopyIntoTable(
 
 ---------- Input ----------
 COPY INTO mytable
-                FROM 's3://mybucket/data.csv'
-                FILE_FORMAT = (
-                    type = CSV
-                    field_delimiter = ','
-                    record_delimiter = '\n'
-                    skip_header = 1
-                )
-                size_limit=10
-                max_files=10;
+    FROM 's3://mybucket/data.csv'
+    FILE_FORMAT = (
+        type = CSV
+        field_delimiter = ','
+        record_delimiter = '\n'
+        skip_header = 1
+    )
+    size_limit=10
+    max_files=10;
 ---------- Output ---------
 COPY INTO mytable FROM 's3://mybucket/data.csv' FILE_FORMAT = (field_delimiter = ',', record_delimiter = '\n', skip_header = 1, type = CSV) SIZE_LIMIT = 10 MAX_FILES = 10 PURGE = false FORCE = false DISABLE_VARIANT_CHECK = false ON_ERROR = abort
 ---------- AST ------------
@@ -12152,15 +12152,15 @@ CopyIntoTable(
 
 ---------- Input ----------
 COPY INTO mytable
-                FROM 's3://mybucket/data.csv'
-                FILE_FORMAT = (
-                    type = CSV
-                    field_delimiter = ','
-                    record_delimiter = '\n'
-                    skip_header = 1
-                )
-                size_limit=10
-                max_files=3000;
+    FROM 's3://mybucket/data.csv'
+    FILE_FORMAT = (
+        type = CSV
+        field_delimiter = ','
+        record_delimiter = '\n'
+        skip_header = 1
+    )
+    size_limit=10
+    max_files=3000;
 ---------- Output ---------
 COPY INTO mytable FROM 's3://mybucket/data.csv' FILE_FORMAT = (field_delimiter = ',', record_delimiter = '\n', skip_header = 1, type = CSV) SIZE_LIMIT = 10 MAX_FILES = 3000 PURGE = false FORCE = false DISABLE_VARIANT_CHECK = false ON_ERROR = abort
 ---------- AST ------------
@@ -12227,17 +12227,17 @@ CopyIntoTable(
 
 ---------- Input ----------
 COPY INTO mytable
-                FROM 's3://mybucket/data.csv'
-                CONNECTION = (
-                    ENDPOINT_URL = 'http://127.0.0.1:9900'
-                )
-                FILE_FORMAT = (
-                    type = CSV
-                    field_delimiter = ','
-                    record_delimiter = '\n'
-                    skip_header = 1
-                )
-                size_limit=10;
+    FROM 's3://mybucket/data.csv'
+    CONNECTION = (
+        ENDPOINT_URL = 'http://127.0.0.1:9900'
+    )
+    FILE_FORMAT = (
+        type = CSV
+        field_delimiter = ','
+        record_delimiter = '\n'
+        skip_header = 1
+    )
+    size_limit=10;
 ---------- Output ---------
 COPY INTO mytable FROM 's3://mybucket/data.csv' CONNECTION = ( endpoint_url = 'http://127.0.0.1:9900' ) FILE_FORMAT = (field_delimiter = ',', record_delimiter = '\n', skip_header = 1, type = CSV) SIZE_LIMIT = 10 PURGE = false FORCE = false DISABLE_VARIANT_CHECK = false ON_ERROR = abort
 ---------- AST ------------
@@ -12306,17 +12306,17 @@ CopyIntoTable(
 
 ---------- Input ----------
 COPY INTO mytable
-                FROM 's3://mybucket/data.csv'
-                CONNECTION = (
-                    ENDPOINT_URL = 'http://127.0.0.1:9900'
-                )
-                size_limit=10
-                FILE_FORMAT = (
-                    type = CSV
-                    field_delimiter = ','
-                    record_delimiter = '\n'
-                    skip_header = 1
-                );
+    FROM 's3://mybucket/data.csv'
+    CONNECTION = (
+        ENDPOINT_URL = 'http://127.0.0.1:9900'
+    )
+    size_limit=10
+    FILE_FORMAT = (
+        type = CSV
+        field_delimiter = ','
+        record_delimiter = '\n'
+        skip_header = 1
+    );
 ---------- Output ---------
 COPY INTO mytable FROM 's3://mybucket/data.csv' CONNECTION = ( endpoint_url = 'http://127.0.0.1:9900' ) FILE_FORMAT = (field_delimiter = ',', record_delimiter = '\n', skip_header = 1, type = CSV) SIZE_LIMIT = 10 PURGE = false FORCE = false DISABLE_VARIANT_CHECK = false ON_ERROR = abort
 ---------- AST ------------
@@ -12385,7 +12385,7 @@ CopyIntoTable(
 
 ---------- Input ----------
 COPY INTO mytable
-                FROM 'https://127.0.0.1:9900';
+    FROM 'https://127.0.0.1:9900';
 ---------- Output ---------
 COPY INTO mytable FROM 'https://127.0.0.1:9900/' PURGE = false FORCE = false DISABLE_VARIANT_CHECK = false ON_ERROR = abort
 ---------- AST ------------
@@ -12439,7 +12439,7 @@ CopyIntoTable(
 
 ---------- Input ----------
 COPY INTO mytable
-                FROM 'https://127.0.0.1:';
+    FROM 'https://127.0.0.1:';
 ---------- Output ---------
 COPY INTO mytable FROM 'https://127.0.0.1/' PURGE = false FORCE = false DISABLE_VARIANT_CHECK = false ON_ERROR = abort
 ---------- AST ------------
@@ -12493,15 +12493,15 @@ CopyIntoTable(
 
 ---------- Input ----------
 COPY INTO mytable
-                FROM @my_stage
-                FILE_FORMAT = (
-                    type = CSV,
-                    field_delimiter = ',',
-                    record_delimiter = '\n',
-                    skip_header = 1,
-                    error_on_column_count_mismatch = FALSE
-                )
-                size_limit=10;
+    FROM @my_stage
+    FILE_FORMAT = (
+        type = CSV,
+        field_delimiter = ',',
+        record_delimiter = '\n',
+        skip_header = 1,
+        error_on_column_count_mismatch = FALSE
+    )
+    size_limit=10;
 ---------- Output ---------
 COPY INTO mytable FROM '@my_stage' FILE_FORMAT = (error_on_column_count_mismatch = false, field_delimiter = ',', record_delimiter = '\n', skip_header = 1, type = CSV) SIZE_LIMIT = 10 PURGE = false FORCE = false DISABLE_VARIANT_CHECK = false ON_ERROR = abort
 ---------- AST ------------
@@ -12562,13 +12562,13 @@ CopyIntoTable(
 
 ---------- Input ----------
 COPY INTO 's3://mybucket/data.csv'
-                FROM mytable
-                FILE_FORMAT = (
-                    type = CSV
-                    field_delimiter = ','
-                    record_delimiter = '\n'
-                    skip_header = 1
-                )
+    FROM mytable
+    FILE_FORMAT = (
+        type = CSV
+        field_delimiter = ','
+        record_delimiter = '\n'
+        skip_header = 1
+    )
 ---------- Output ---------
 COPY INTO 's3://mybucket/data.csv' FROM mytable FILE_FORMAT = (field_delimiter = ',', record_delimiter = '\n', skip_header = 1, type = CSV) SINGLE = false MAX_FILE_SIZE = 0 DETAILED_OUTPUT = false
 ---------- AST ------------
@@ -12581,7 +12581,7 @@ CopyIntoLocation(
                 database: None,
                 table: Identifier {
                     span: Some(
-                        56..63,
+                        44..51,
                     ),
                     name: "mytable",
                     quote: None,
@@ -12626,7 +12626,7 @@ CopyIntoLocation(
 
 ---------- Input ----------
 COPY INTO '@my_stage/my data'
-                FROM mytable;
+    FROM mytable;
 ---------- Output ---------
 COPY INTO '@my_stage/my data' FROM mytable SINGLE = false MAX_FILE_SIZE = 0 DETAILED_OUTPUT = false
 ---------- AST ------------
@@ -12639,7 +12639,7 @@ CopyIntoLocation(
                 database: None,
                 table: Identifier {
                     span: Some(
-                        51..58,
+                        39..46,
                     ),
                     name: "mytable",
                     quote: None,
@@ -12662,13 +12662,13 @@ CopyIntoLocation(
 
 ---------- Input ----------
 COPY INTO @my_stage
-                FROM mytable
-                FILE_FORMAT = (
-                    type = CSV
-                    field_delimiter = ','
-                    record_delimiter = '\n'
-                    skip_header = 1
-                );
+    FROM mytable
+    FILE_FORMAT = (
+        type = CSV
+        field_delimiter = ','
+        record_delimiter = '\n'
+        skip_header = 1
+    );
 ---------- Output ---------
 COPY INTO '@my_stage' FROM mytable FILE_FORMAT = (field_delimiter = ',', record_delimiter = '\n', skip_header = 1, type = CSV) SINGLE = false MAX_FILE_SIZE = 0 DETAILED_OUTPUT = false
 ---------- AST ------------
@@ -12681,7 +12681,7 @@ CopyIntoLocation(
                 database: None,
                 table: Identifier {
                     span: Some(
-                        41..48,
+                        29..36,
                     ),
                     name: "mytable",
                     quote: None,
@@ -12717,18 +12717,18 @@ CopyIntoLocation(
 
 ---------- Input ----------
 COPY INTO mytable
-                FROM 's3://mybucket/data.csv'
-                CREDENTIALS = (
-                    AWS_KEY_ID = 'access_key'
-                    AWS_SECRET_KEY = 'secret_key'
-                )
-                FILE_FORMAT = (
-                    type = CSV
-                    field_delimiter = ','
-                    record_delimiter = '\n'
-                    skip_header = 1
-                )
-                size_limit=10;
+    FROM 's3://mybucket/data.csv'
+    CREDENTIALS = (
+        AWS_KEY_ID = 'access_key'
+        AWS_SECRET_KEY = 'secret_key'
+    )
+    FILE_FORMAT = (
+        type = CSV
+        field_delimiter = ','
+        record_delimiter = '\n'
+        skip_header = 1
+    )
+    size_limit=10;
 ---------- Output ---------
 COPY INTO mytable FROM 's3://mybucket/data.csv' CONNECTION = ( aws_key_id = 'access_key', aws_secret_key = 'secret_key' ) FILE_FORMAT = (field_delimiter = ',', record_delimiter = '\n', skip_header = 1, type = CSV) SIZE_LIMIT = 10 PURGE = false FORCE = false DISABLE_VARIANT_CHECK = false ON_ERROR = abort
 ---------- AST ------------
@@ -12798,14 +12798,14 @@ CopyIntoTable(
 
 ---------- Input ----------
 COPY INTO mytable
-                FROM @external_stage/path/to/file.csv
-                FILE_FORMAT = (
-                    type = CSV
-                    field_delimiter = ','
-                    record_delimiter = '\n'
-                    skip_header = 1
-                )
-                size_limit=10;
+    FROM @external_stage/path/to/file.csv
+    FILE_FORMAT = (
+        type = CSV
+        field_delimiter = ','
+        record_delimiter = '\n'
+        skip_header = 1
+    )
+    size_limit=10;
 ---------- Output ---------
 COPY INTO mytable FROM '@external_stage/path/to/file.csv' FILE_FORMAT = (field_delimiter = ',', record_delimiter = '\n', skip_header = 1, type = CSV) SIZE_LIMIT = 10 PURGE = false FORCE = false DISABLE_VARIANT_CHECK = false ON_ERROR = abort
 ---------- AST ------------
@@ -12863,14 +12863,14 @@ CopyIntoTable(
 
 ---------- Input ----------
 COPY INTO mytable
-                FROM @external_stage/path/to/dir/
-                FILE_FORMAT = (
-                    type = CSV
-                    field_delimiter = ','
-                    record_delimiter = '\n'
-                    skip_header = 1
-                )
-                size_limit=10;
+    FROM @external_stage/path/to/dir/
+    FILE_FORMAT = (
+        type = CSV
+        field_delimiter = ','
+        record_delimiter = '\n'
+        skip_header = 1
+    )
+    size_limit=10;
 ---------- Output ---------
 COPY INTO mytable FROM '@external_stage/path/to/dir/' FILE_FORMAT = (field_delimiter = ',', record_delimiter = '\n', skip_header = 1, type = CSV) SIZE_LIMIT = 10 PURGE = false FORCE = false DISABLE_VARIANT_CHECK = false ON_ERROR = abort
 ---------- AST ------------
@@ -12928,14 +12928,14 @@ CopyIntoTable(
 
 ---------- Input ----------
 COPY INTO mytable
-                FROM @external_stage/path/to/file.csv
-                FILE_FORMAT = (
-                    type = CSV
-                    field_delimiter = ','
-                    record_delimiter = '\n'
-                    skip_header = 1
-                )
-                force=true;
+    FROM @external_stage/path/to/file.csv
+    FILE_FORMAT = (
+        type = CSV
+        field_delimiter = ','
+        record_delimiter = '\n'
+        skip_header = 1
+    )
+    force=true;
 ---------- Output ---------
 COPY INTO mytable FROM '@external_stage/path/to/file.csv' FILE_FORMAT = (field_delimiter = ',', record_delimiter = '\n', skip_header = 1, type = CSV) PURGE = false FORCE = true DISABLE_VARIANT_CHECK = false ON_ERROR = abort
 ---------- AST ------------
@@ -12993,15 +12993,15 @@ CopyIntoTable(
 
 ---------- Input ----------
 COPY INTO mytable
-                FROM 'fs:///path/to/data.csv'
-                FILE_FORMAT = (
-                    type = CSV
-                    field_delimiter = ','
-                    record_delimiter = '\n'
-                    skip_header = 1
-                )
-                size_limit=10
-                disable_variant_check=true;
+    FROM 'fs:///path/to/data.csv'
+    FILE_FORMAT = (
+        type = CSV
+        field_delimiter = ','
+        record_delimiter = '\n'
+        skip_header = 1
+    )
+    size_limit=10
+    disable_variant_check=true;
 ---------- Output ---------
 COPY INTO mytable FROM 'fs:///path/to/data.csv' FILE_FORMAT = (field_delimiter = ',', record_delimiter = '\n', skip_header = 1, type = CSV) SIZE_LIMIT = 10 PURGE = false FORCE = false DISABLE_VARIANT_CHECK = true ON_ERROR = abort
 ---------- AST ------------
@@ -13068,13 +13068,13 @@ CopyIntoTable(
 
 ---------- Input ----------
 COPY INTO books FROM 's3://databend/books.csv'
-                CONNECTION = (
-                    ENDPOINT_URL = 'http://localhost:9000/',
-                    ACCESS_KEY_ID = 'ROOTUSER',
-                    SECRET_ACCESS_KEY = 'CHANGEME123',
-                    region = 'us-west-2'
-                )
-                FILE_FORMAT = (type = CSV);
+    CONNECTION = (
+        ENDPOINT_URL = 'http://localhost:9000/',
+        ACCESS_KEY_ID = 'ROOTUSER',
+        SECRET_ACCESS_KEY = 'CHANGEME123',
+        region = 'us-west-2'
+    )
+    FILE_FORMAT = (type = CSV);
 ---------- Output ---------
 COPY INTO books FROM 's3://databend/books.csv' CONNECTION = ( access_key_id = 'ROOTUSER', endpoint_url = 'http://localhost:9000/', region = 'us-west-2', secret_access_key = 'CHANGEME123' ) FILE_FORMAT = (type = CSV) PURGE = false FORCE = false DISABLE_VARIANT_CHECK = false ON_ERROR = abort
 ---------- AST ------------
@@ -14802,20 +14802,20 @@ Query(
 
 ---------- Input ----------
 SELECT t.c1 FROM @stage1/dir/file
-        ( file_format => 'PARQUET', FILES => ('file1', 'file2')) t;
+    ( file_format => 'PARQUET', FILES => ('file1', 'file2')) t;
 ---------- Output ---------
 SELECT t.c1 FROM '@stage1/dir/file' ( FILES => ('file1', 'file2'), FILE_FORMAT => 'PARQUET', ) AS t
 ---------- AST ------------
 Query(
     Query {
         span: Some(
-            0..100,
+            0..96,
         ),
         with: None,
         body: Select(
             SelectStmt {
                 span: Some(
-                    0..100,
+                    0..96,
                 ),
                 hints: None,
                 distinct: false,
@@ -14855,7 +14855,7 @@ Query(
                 from: [
                     Location {
                         span: Some(
-                            17..100,
+                            17..96,
                         ),
                         location: Stage(
                             "stage1/dir/file",
@@ -14877,7 +14877,7 @@ Query(
                             TableAlias {
                                 name: Identifier {
                                     span: Some(
-                                        99..100,
+                                        95..96,
                                     ),
                                     name: "t",
                                     quote: None,
@@ -14905,21 +14905,21 @@ Query(
 
 ---------- Input ----------
 select table0.c1, table1.c2 from
-            @stage1/dir/file ( FILE_FORMAT => 'parquet', FILES => ('file1', 'file2')) table0
-            left join table1;
+    @stage1/dir/file ( FILE_FORMAT => 'parquet', FILES => ('file1', 'file2')) table0
+    left join table1;
 ---------- Output ---------
 SELECT table0.c1, table1.c2 FROM '@stage1/dir/file' ( FILES => ('file1', 'file2'), FILE_FORMAT => 'parquet', ) AS table0 LEFT OUTER JOIN table1
 ---------- AST ------------
 Query(
     Query {
         span: Some(
-            0..154,
+            0..138,
         ),
         with: None,
         body: Select(
             SelectStmt {
                 span: Some(
-                    0..154,
+                    0..138,
                 ),
                 hints: None,
                 distinct: false,
@@ -14990,14 +14990,14 @@ Query(
                 from: [
                     Join {
                         span: Some(
-                            138..147,
+                            122..131,
                         ),
                         join: Join {
                             op: LeftOuter,
                             condition: None,
                             left: Location {
                                 span: Some(
-                                    45..125,
+                                    37..117,
                                 ),
                                 location: Stage(
                                     "stage1/dir/file",
@@ -15019,7 +15019,7 @@ Query(
                                     TableAlias {
                                         name: Identifier {
                                             span: Some(
-                                                119..125,
+                                                111..117,
                                             ),
                                             name: "table0",
                                             quote: None,
@@ -15031,13 +15031,13 @@ Query(
                             },
                             right: Table {
                                 span: Some(
-                                    148..154,
+                                    132..138,
                                 ),
                                 catalog: None,
                                 database: None,
                                 table: Identifier {
                                     span: Some(
-                                        148..154,
+                                        132..138,
                                     ),
                                     name: "table1",
                                     quote: None,
@@ -15167,7 +15167,7 @@ Query(
 
 ---------- Input ----------
 CREATE FILE FORMAT my_csv
-            type = CSV field_delimiter = ',' record_delimiter = '\n' skip_header = 1;
+    type = CSV field_delimiter = ',' record_delimiter = '\n' skip_header = 1;
 ---------- Output ---------
 CREATE FILE FORMAT my_csv field_delimiter = ',', record_delimiter = '\n', skip_header = 1, type = CSV
 ---------- AST ------------
@@ -15195,7 +15195,7 @@ CreateFileFormat {
 
 ---------- Input ----------
 CREATE OR REPLACE FILE FORMAT my_csv
-            type = CSV field_delimiter = ',' record_delimiter = '\n' skip_header = 1;
+    type = CSV field_delimiter = ',' record_delimiter = '\n' skip_header = 1;
 ---------- Output ---------
 CREATE OR REPLACE FILE FORMAT my_csv field_delimiter = ',', record_delimiter = '\n', skip_header = 1, type = CSV
 ---------- AST ------------
@@ -17150,15 +17150,15 @@ CreateTask(
 
 
 ---------- Input ----------
-CREATE TASK IF NOT EXISTS MyTask1 DATABASE = 'target', TIMEZONE = 'America/Los Angeles'  as
-            BEGIN
-              begin;
-              insert into t values('a;');
-              delete from t where c = ';';
-              vacuum table t;
-              merge into t using s on t.id = s.id when matched then update *;
-              commit;
-            END
+CREATE TASK IF NOT EXISTS MyTask1 DATABASE = 'target', TIMEZONE = 'America/Los Angeles' as
+    BEGIN
+    begin;
+    insert into t values('a;');
+    delete from t where c = ';';
+    vacuum table t;
+    merge into t using s on t.id = s.id when matched then update *;
+    commit;
+    END
 ---------- Output ---------
 CREATE TASK IF NOT EXISTS MyTask1 database = 'target', timezone = 'America/Los Angeles' AS BEGIN
 BEGIN;
@@ -17202,15 +17202,15 @@ CreateTask(
 
 ---------- Input ----------
 CREATE TASK IF NOT EXISTS merge_task WAREHOUSE = 'test-parser' SCHEDULE = 1 SECOND
-        AS BEGIN
-          MERGE INTO t USING s ON t.c = s.c
-            WHEN MATCHED THEN
-            UPDATE
-                *
-                WHEN NOT MATCHED THEN
-            INSERT
-                *;
-        END
+AS BEGIN
+MERGE INTO t USING s ON t.c = s.c
+    WHEN MATCHED THEN
+    UPDATE
+        *
+        WHEN NOT MATCHED THEN
+    INSERT
+        *;
+END
 ---------- Output ---------
 CREATE TASK IF NOT EXISTS merge_task WAREHOUSE = 'test-parser' SCHEDULE = 1 SECOND AS BEGIN
 MERGE INTO t USING s ON t.c = s.c WHEN MATCHED THEN UPDATE * WHEN NOT MATCHED THEN INSERT *;
@@ -17247,14 +17247,14 @@ CreateTask(
 
 ---------- Input ----------
 CREATE TASK IF NOT EXISTS merge_task WAREHOUSE = 'test-parser' SCHEDULE = 1 SECOND
-        AS BEGIN
-          MERGE INTO t USING s ON t.c = s.c
-            WHEN MATCHED THEN
-            UPDATE
-                *
-                WHEN NOT MATCHED THEN
-            INSERT values('a;', 1, "str");
-        END
+AS BEGIN
+MERGE INTO t USING s ON t.c = s.c
+    WHEN MATCHED THEN
+    UPDATE
+        *
+        WHEN NOT MATCHED THEN
+    INSERT values('a;', 1, "str");
+END
 ---------- Output ---------
 CREATE TASK IF NOT EXISTS merge_task WAREHOUSE = 'test-parser' SCHEDULE = 1 SECOND AS BEGIN
 MERGE INTO t USING s ON t.c = s.c WHEN MATCHED THEN UPDATE * WHEN NOT MATCHED THEN INSERT VALUES('a;', 1, "str");
@@ -17517,14 +17517,14 @@ AlterTask(
 
 ---------- Input ----------
 ALTER TASK MyTask2 MODIFY AS
-            BEGIN
-              begin;
-              insert into t values('a;');
-              delete from t where c = ';';
-              vacuum table t;
-              merge into t using s on t.id = s.id when matched then update *;
-              commit;
-            END
+BEGIN
+  begin;
+  insert into t values('a;');
+  delete from t where c = ';';
+  vacuum table t;
+  merge into t using s on t.id = s.id when matched then update *;
+  commit;
+END
 ---------- Output ---------
 ALTER TASK MyTask2 MODIFY AS BEGIN
 BEGIN;
@@ -18163,20 +18163,20 @@ DescribeNotification(
 
 ---------- Input ----------
 --各环节转各环节转各环节转各环节转各
-  select 34343
+select 34343
 ---------- Output ---------
 SELECT 34343
 ---------- AST ------------
 Query(
     Query {
         span: Some(
-            56..68,
+            54..66,
         ),
         with: None,
         body: Select(
             SelectStmt {
                 span: Some(
-                    56..68,
+                    54..66,
                 ),
                 hints: None,
                 distinct: false,
@@ -18184,7 +18184,7 @@ Query(
                     AliasedExpr {
                         expr: Literal {
                             span: Some(
-                                63..68,
+                                61..66,
                             ),
                             value: UInt64(
                                 34343,
@@ -18259,20 +18259,20 @@ Query(
 
 ---------- Input ----------
 -- xxxxx
-  select 34343;
+select 34343;
 ---------- Output ---------
 SELECT 34343
 ---------- AST ------------
 Query(
     Query {
         span: Some(
-            11..23,
+            9..21,
         ),
         with: None,
         body: Select(
             SelectStmt {
                 span: Some(
-                    11..23,
+                    9..21,
                 ),
                 hints: None,
                 distinct: false,
@@ -18280,7 +18280,7 @@ Query(
                     AliasedExpr {
                         expr: Literal {
                             span: Some(
-                                18..23,
+                                16..21,
                             ),
                             value: UInt64(
                                 34343,
@@ -19001,12 +19001,12 @@ handler = 'addone_py'
 as
 $$
 def addone_py(i):
-  return i+1
+return i+1
 $$;
 ---------- Output ---------
 CREATE OR REPLACE FUNCTION addone (Int32 NULL) RETURNS Int32 NULL LANGUAGE python HANDLER = 'addone_py' AS $$
 def addone_py(i):
-  return i+1
+return i+1
 $$
 ---------- AST ------------
 CreateUDF(
@@ -19030,7 +19030,7 @@ CreateUDF(
             return_type: Nullable(
                 Int32,
             ),
-            code: "\ndef addone_py(i):\n  return i+1\n",
+            code: "def addone_py(i):\nreturn i+1",
             handler: "addone_py",
             language: "python",
             runtime_version: "",
@@ -19075,3 +19075,28 @@ DropUDF {
 }
 
 
+---------- Input ----------
+EXECUTE IMMEDIATE 
+$$
+BEGIN
+    LOOP
+        RETURN 1;
+    END LOOP;
+END;
+$$
+---------- Output ---------
+EXECUTE IMMEDIATE $$
+BEGIN
+    LOOP
+        RETURN 1;
+    END LOOP;
+END;
+$$
+---------- AST ------------
+ExecuteImmediate(
+    ExecuteImmediateStmt {
+        script: "BEGIN\n    LOOP\n        RETURN 1;\n    END LOOP;\nEND;",
+    },
+)
+
+
diff --git a/src/query/expression/Cargo.toml b/src/query/expression/Cargo.toml
index ee5d12239c8b..ba18b0b30064 100644
--- a/src/query/expression/Cargo.toml
+++ b/src/query/expression/Cargo.toml
@@ -38,6 +38,7 @@ enum-as-inner = "0.5"
 ethnum = { workspace = true, features = ["serde", "macros", "borsh"] }
 futures = { workspace = true }
 geo = { workspace = true }
+geos = { workspace = true }
 geozero = { workspace = true }
 hex = "0.4.3"
 itertools = { workspace = true }
@@ -67,3 +68,6 @@ goldenfile = "1.4"
 pretty_assertions = "1.3.0"
 rand = { workspace = true }
 rmp-serde = "1.1.1"
+
+[package.metadata.cargo-machete]
+ignored = ["geos"]
diff --git a/src/query/formats/Cargo.toml b/src/query/formats/Cargo.toml
index 06166c08ed0f..36250aa21feb 100644
--- a/src/query/formats/Cargo.toml
+++ b/src/query/formats/Cargo.toml
@@ -16,6 +16,7 @@ async-trait = { workspace = true }
 base64 = "0.21.0"
 bstr = "1.0.1"
 chrono-tz = { workspace = true }
+geos = { workspace = true }
 geozero = { workspace = true }
 hex = "0.4.3"
 lexical-core = "0.8.5"
@@ -40,9 +41,8 @@ jsonb = { workspace = true }
 
 [dev-dependencies]
 databend-common-arrow = { path = "../../common/arrow" }
-tokio = { workspace = true }
-
 pretty_assertions = "1.3.0"
+tokio = { workspace = true }
 
 [package.metadata.cargo-machete]
-ignored = ["match-template"]
+ignored = ["geos", "match-template"]
diff --git a/src/query/script/Cargo.toml b/src/query/script/Cargo.toml
index 17c49ea57592..7d2aa9a888eb 100644
--- a/src/query/script/Cargo.toml
+++ b/src/query/script/Cargo.toml
@@ -20,4 +20,5 @@ minitrace = { workspace = true }
 
 [dev-dependencies]
 goldenfile = "1.4"
+tokio = { workspace = true, features = ["macros", "rt", "rt-multi-thread", "sync"] }
 unindent = "0.2.3"
diff --git a/src/query/script/src/compiler.rs b/src/query/script/src/compiler.rs
index 2ec39b4f91dc..c2c9f94cae5d 100644
--- a/src/query/script/src/compiler.rs
+++ b/src/query/script/src/compiler.rs
@@ -26,6 +26,7 @@ use databend_common_ast::ast::Identifier;
 use databend_common_ast::ast::Indirection;
 use databend_common_ast::ast::Literal;
 use databend_common_ast::ast::Query;
+use databend_common_ast::ast::ReturnItem;
 use databend_common_ast::ast::ScriptStatement;
 use databend_common_ast::ast::SelectStmt;
 use databend_common_ast::ast::SelectTarget;
@@ -42,7 +43,7 @@ use derive_visitor::VisitorMut;
 use crate::ir::ColumnAccess;
 use crate::ir::IterRef;
 use crate::ir::LabelRef;
-use crate::ir::RefAllocator;
+use crate::ir::Ref;
 use crate::ir::ScriptIR;
 use crate::ir::SetRef;
 use crate::ir::StatementTemplate;
@@ -81,15 +82,30 @@ impl Compiler {
         for line in code {
             match line {
                 ScriptStatement::LetVar { declare, .. } => {
-                    let to_var = self.declare_var(&declare.name)?;
-                    output.append(&mut self.compile_expr(&declare.default, to_var)?);
+                    let to_var = VarRef::new(
+                        declare.name.span,
+                        &declare.name.name,
+                        &mut self.ref_allocator,
+                    );
+                    output.append(&mut self.compile_expr(&declare.default, to_var.clone())?);
+                    self.declare_ref(&declare.name, RefItem::Var(to_var))?;
                 }
-                ScriptStatement::LetStatement { span, declare } => {
-                    let to_set = self.declare_set(&declare.name)?;
-                    output.append(&mut self.compile_sql_statement(*span, &declare.stmt, to_set)?);
+                ScriptStatement::LetStatement { declare } => {
+                    let to_set = SetRef::new(
+                        declare.name.span,
+                        &declare.name.name,
+                        &mut self.ref_allocator,
+                    );
+                    output.append(&mut self.compile_sql_statement(
+                        declare.span,
+                        &declare.stmt,
+                        to_set.clone(),
+                    )?);
+                    self.declare_ref(&declare.name, RefItem::Set(to_set))?;
                 }
                 ScriptStatement::RunStatement { span, stmt } => {
-                    let to_set = self.declare_anonymous_set(*span, "unused_result")?;
+                    let to_set =
+                        SetRef::new_internal(*span, "unused_result", &mut self.ref_allocator);
                     output.append(&mut self.compile_sql_statement(*span, stmt, to_set)?);
                 }
                 ScriptStatement::Assign { name, value, .. } => {
@@ -100,13 +116,29 @@ impl Compiler {
                     output.push(ScriptIR::Return);
                 }
                 ScriptStatement::Return {
-                    value: Some(value), ..
+                    value: Some(ReturnItem::Var(expr)),
+                    ..
                 } => {
-                    // TODO(andylokandy): support returning table
-                    let to_var = self.declare_anonymous_var(value.span(), "return_val")?;
-                    output.append(&mut self.compile_expr(value, to_var.clone())?);
+                    let to_var =
+                        VarRef::new_internal(expr.span(), "return_val", &mut self.ref_allocator);
+                    output.append(&mut self.compile_expr(expr, to_var.clone())?);
                     output.push(ScriptIR::ReturnVar { var: to_var });
                 }
+                ScriptStatement::Return {
+                    value: Some(ReturnItem::Set(name)),
+                    ..
+                } => {
+                    let set = self.lookup_set(name)?;
+                    output.push(ScriptIR::ReturnSet { set });
+                }
+                ScriptStatement::Return {
+                    span,
+                    value: Some(ReturnItem::Statement(stmt)),
+                } => {
+                    let to_set = SetRef::new_internal(*span, "return_set", &mut self.ref_allocator);
+                    output.append(&mut self.compile_sql_statement(*span, stmt, to_set.clone())?);
+                    output.push(ScriptIR::ReturnSet { set: to_set });
+                }
                 ScriptStatement::ForLoop {
                     span,
                     variable,
@@ -126,15 +158,26 @@ impl Compiler {
                         label,
                     )?);
                 }
-                ScriptStatement::ForIn {
+                ScriptStatement::ForInSet {
                     span,
                     variable,
                     resultset,
                     body,
                     label,
                 } => {
-                    output
-                        .append(&mut self.compile_for_in(*span, variable, resultset, body, label)?);
+                    let set = self.lookup_set(resultset)?;
+                    output.append(&mut self.compile_for_in(*span, variable, set, body, label)?);
+                }
+                ScriptStatement::ForInStatement {
+                    span,
+                    variable,
+                    stmt,
+                    body,
+                    label,
+                } => {
+                    let to_set = SetRef::new_internal(*span, "for_in_set", &mut self.ref_allocator);
+                    output.append(&mut self.compile_sql_statement(*span, stmt, to_set.clone())?);
+                    output.append(&mut self.compile_for_in(*span, variable, to_set, body, label)?);
                 }
                 ScriptStatement::WhileLoop {
                     span,
@@ -163,29 +206,29 @@ impl Compiler {
                 ScriptStatement::Break {
                     label: Some(label), ..
                 } => {
-                    let (_, break_label) = self.lookup_loop(label)?;
+                    let loop_item = self.lookup_loop(label)?;
                     output.push(ScriptIR::Goto {
-                        to_label: break_label,
+                        to_label: loop_item.break_label,
                     });
                 }
                 ScriptStatement::Break { span, label: None } => {
-                    let (_, break_label) = self.current_loop(*span)?;
+                    let loop_item = self.current_loop(*span)?;
                     output.push(ScriptIR::Goto {
-                        to_label: break_label,
+                        to_label: loop_item.break_label,
                     });
                 }
                 ScriptStatement::Continue {
                     label: Some(label), ..
                 } => {
-                    let (continue_label, _) = self.lookup_loop(label)?;
+                    let loop_item = self.lookup_loop(label)?;
                     output.push(ScriptIR::Goto {
-                        to_label: continue_label,
+                        to_label: loop_item.continue_label,
                     });
                 }
                 ScriptStatement::Continue { span, label: None } => {
-                    let (continue_label, _) = self.current_loop(*span)?;
+                    let loop_item = self.current_loop(*span)?;
                     output.push(ScriptIR::Goto {
-                        to_label: continue_label,
+                        to_label: loop_item.continue_label,
                     });
                 }
                 ScriptStatement::If {
@@ -256,15 +299,16 @@ impl Compiler {
             offset: None,
             ignore_result: false,
         }));
-        let stmt = StatementTemplate::new(expr.span(), select_stmt);
-        let set_ref = self.declare_anonymous_set(expr.span(), "expr_result")?;
+        let stmt = StatementTemplate::new(expr.whole_span(), select_stmt);
+        let set_ref = SetRef::new_internal(expr.span(), "expr_result", &mut self.ref_allocator);
         output.push(ScriptIR::Query {
             stmt,
             to_set: set_ref.clone(),
         });
 
         // ITER expr_result, expr_result_iter
-        let iter_ref = self.declare_anonymous_iter(expr.span(), "expr_result_iter")?;
+        let iter_ref =
+            IterRef::new_internal(expr.span(), "expr_result_iter", &mut self.ref_allocator);
         output.push(ScriptIR::Iter {
             set: set_ref,
             to_iter: iter_ref.clone(),
@@ -294,7 +338,7 @@ impl Compiler {
 
         self.push_scope();
 
-        let (continue_label, break_label) = match label {
+        let loop_item = match label {
             Some(label) => self.declare_loop(label)?,
             None => self.declare_anonymous_loop(span)?,
         };
@@ -347,14 +391,14 @@ impl Compiler {
             ignore_result: false,
         }));
         let stmt = StatementTemplate::new(variable.span, select_stmt);
-        let to_set = self.declare_anonymous_set(variable.span, "for_index_set")?;
+        let to_set = SetRef::new_internal(variable.span, "for_index_set", &mut self.ref_allocator);
         output.push(ScriptIR::Query {
             stmt,
             to_set: to_set.clone(),
         });
 
         // ITER for_index_set, for_index_iter
-        let iter = self.declare_anonymous_iter(variable.span, "for_index_iter")?;
+        let iter = IterRef::new_internal(variable.span, "for_index_iter", &mut self.ref_allocator);
         output.push(ScriptIR::Iter {
             set: to_set,
             to_iter: iter.clone(),
@@ -362,21 +406,22 @@ impl Compiler {
 
         // Label LOOP
         output.push(ScriptIR::Label {
-            label: continue_label.clone(),
+            label: loop_item.continue_label.clone(),
         });
 
         // JUMP_IF_ENDED for_index_iter, LOOP_END
         output.push(ScriptIR::JumpIfEnded {
             iter: iter.clone(),
-            to_label: break_label.clone(),
+            to_label: loop_item.break_label.clone(),
         });
 
-        // READ for_index_iter, $0, variable
-        let variable = self.declare_var(variable)?;
+        // READ for_index_iter, $0, to_var
+        let to_var = VarRef::new(variable.span, &variable.name, &mut self.ref_allocator);
+        self.declare_ref(variable, RefItem::Var(to_var.clone()))?;
         output.push(ScriptIR::Read {
             iter: iter.clone(),
             column: ColumnAccess::Position(0),
-            to_var: variable.clone(),
+            to_var,
         });
 
         // <body>
@@ -387,11 +432,13 @@ impl Compiler {
 
         // GOTO LOOP
         output.push(ScriptIR::Goto {
-            to_label: continue_label.clone(),
+            to_label: loop_item.continue_label.clone(),
         });
 
         // Label LOOP_END
-        output.push(ScriptIR::Label { label: break_label });
+        output.push(ScriptIR::Label {
+            label: loop_item.break_label,
+        });
 
         self.pop_scope();
 
@@ -402,7 +449,7 @@ impl Compiler {
         &mut self,
         span: Span,
         variable: &Identifier,
-        resultset: &Identifier,
+        set: SetRef,
         body: &[ScriptStatement],
         label: &Option<Identifier>,
     ) -> Result<Vec<ScriptIR>> {
@@ -410,14 +457,14 @@ impl Compiler {
 
         self.push_scope();
 
-        let (continue_label, break_label) = match label {
+        let loop_item = match label {
             Some(label) => self.declare_loop(label)?,
             None => self.declare_anonymous_loop(span)?,
         };
 
-        // ITER resultset, for_iter
-        let set = self.lookup_set(resultset)?;
-        let iter = self.declare_iter(variable.span, variable)?;
+        // ITER resultset, iter
+        let iter = IterRef::new(variable.span, &variable.name, &mut self.ref_allocator);
+        self.declare_ref(variable, RefItem::Iter(iter.clone()))?;
         output.push(ScriptIR::Iter {
             set,
             to_iter: iter.clone(),
@@ -425,28 +472,30 @@ impl Compiler {
 
         // Label LOOP
         output.push(ScriptIR::Label {
-            label: continue_label.clone(),
+            label: loop_item.continue_label.clone(),
         });
 
-        // JUMP_IF_ENDED for_iter, LOOP_END
+        // JUMP_IF_ENDED iter, LOOP_END
         output.push(ScriptIR::JumpIfEnded {
             iter: iter.clone(),
-            to_label: break_label.clone(),
+            to_label: loop_item.break_label.clone(),
         });
 
         // <body>
         output.append(&mut self.compile(body)?);
 
-        // NEXT for_iter
+        // NEXT iter
         output.push(ScriptIR::Next { iter: iter.clone() });
 
         // GOTO LOOP
         output.push(ScriptIR::Goto {
-            to_label: continue_label.clone(),
+            to_label: loop_item.continue_label.clone(),
         });
 
         // Label LOOP_END
-        output.push(ScriptIR::Label { label: break_label });
+        output.push(ScriptIR::Label {
+            label: loop_item.break_label,
+        });
 
         self.pop_scope();
 
@@ -464,25 +513,28 @@ impl Compiler {
 
         self.push_scope();
 
-        let (continue_label, break_label) = match label {
+        let loop_item = match label {
             Some(label) => self.declare_loop(label)?,
             None => self.declare_anonymous_loop(span)?,
         };
 
         // Label LOOP
         output.push(ScriptIR::Label {
-            label: continue_label.clone(),
+            label: loop_item.continue_label.clone(),
         });
 
         // <let break_condition := NOT is_true(<condition>)>
         // JUMP_IF_TRUE break_condition, LOOP_END
         let break_condition = wrap_not(wrap_is_true(condition.clone()));
-        let break_condition_var =
-            self.declare_anonymous_var(break_condition.span(), "break_condition")?;
+        let break_condition_var = VarRef::new_internal(
+            break_condition.span(),
+            "break_condition",
+            &mut self.ref_allocator,
+        );
         output.append(&mut self.compile_expr(&break_condition, break_condition_var.clone())?);
         output.push(ScriptIR::JumpIfTrue {
             condition: break_condition_var,
-            to_label: break_label.clone(),
+            to_label: loop_item.break_label.clone(),
         });
 
         // <body>
@@ -490,11 +542,13 @@ impl Compiler {
 
         // GOTO LOOP
         output.push(ScriptIR::Goto {
-            to_label: continue_label.clone(),
+            to_label: loop_item.continue_label.clone(),
         });
 
         // Label LOOP_END
-        output.push(ScriptIR::Label { label: break_label });
+        output.push(ScriptIR::Label {
+            label: loop_item.break_label,
+        });
 
         self.pop_scope();
 
@@ -512,14 +566,14 @@ impl Compiler {
 
         self.push_scope();
 
-        let (continue_label, break_label) = match label {
+        let loop_item = match label {
             Some(label) => self.declare_loop(label)?,
             None => self.declare_anonymous_loop(span)?,
         };
 
         // Label LOOP
         output.push(ScriptIR::Label {
-            label: continue_label.clone(),
+            label: loop_item.continue_label.clone(),
         });
 
         // <body>
@@ -528,21 +582,26 @@ impl Compiler {
         // <let break_condition := is_true(until_condition)>
         // JUMP_IF_TRUE break_condition, LOOP_END
         let break_condition = wrap_is_true(until_condition.clone());
-        let break_condition_var =
-            self.declare_anonymous_var(break_condition.span(), "break_condition")?;
+        let break_condition_var = VarRef::new_internal(
+            break_condition.span(),
+            "break_condition",
+            &mut self.ref_allocator,
+        );
         output.append(&mut self.compile_expr(&break_condition, break_condition_var.clone())?);
         output.push(ScriptIR::JumpIfTrue {
             condition: break_condition_var,
-            to_label: break_label.clone(),
+            to_label: loop_item.break_label.clone(),
         });
 
         // GOTO LOOP
         output.push(ScriptIR::Goto {
-            to_label: continue_label.clone(),
+            to_label: loop_item.continue_label.clone(),
         });
 
         // Label LOOP_END
-        output.push(ScriptIR::Label { label: break_label });
+        output.push(ScriptIR::Label {
+            label: loop_item.break_label,
+        });
 
         self.pop_scope();
 
@@ -559,14 +618,14 @@ impl Compiler {
 
         self.push_scope();
 
-        let (continue_label, break_label) = match label {
+        let loop_item = match label {
             Some(label) => self.declare_loop(label)?,
             None => self.declare_anonymous_loop(span)?,
         };
 
         // Label LOOP
         output.push(ScriptIR::Label {
-            label: continue_label.clone(),
+            label: loop_item.continue_label.clone(),
         });
 
         // <body>
@@ -574,11 +633,13 @@ impl Compiler {
 
         // GOTO LOOP
         output.push(ScriptIR::Goto {
-            to_label: continue_label.clone(),
+            to_label: loop_item.continue_label.clone(),
         });
 
         // Label LOOP_END
-        output.push(ScriptIR::Label { label: break_label });
+        output.push(ScriptIR::Label {
+            label: loop_item.break_label,
+        });
 
         self.pop_scope();
 
@@ -608,7 +669,8 @@ impl Compiler {
             // <let condition := is_true(condition)>
             // JUMP_IF_TRUE condition, IF_THEN
             let condition = wrap_is_true(condition.clone());
-            let condition_var = self.declare_anonymous_var(condition.span(), "condition")?;
+            let condition_var =
+                VarRef::new_internal(condition.span(), "condition", &mut self.ref_allocator);
             output.append(&mut self.compile_expr(&condition, condition_var.clone())?);
             output.push(ScriptIR::JumpIfTrue {
                 condition: condition_var,
@@ -677,7 +739,7 @@ impl Compiler {
         to_set: SetRef,
     ) -> Result<Vec<ScriptIR>> {
         #[derive(VisitorMut)]
-        #[visitor(Expr(enter), Identifier(enter))]
+        #[visitor(Expr(enter), Identifier(enter), Statement(enter))]
         struct QuoteVisitor<'a> {
             compiler: &'a Compiler,
             error: Option<ErrorCode>,
@@ -717,6 +779,33 @@ impl Compiler {
                     }
                 }
             }
+
+            // TODO(andylokandy: handle these statement)
+            fn enter_statement(&mut self, stmt: &mut Statement) {
+                match stmt {
+                    Statement::Begin => {
+                        self.error = Some(ErrorCode::Unimplemented(
+                            "BEGIN in script is not supported yet".to_string(),
+                        ));
+                    }
+                    Statement::Commit => {
+                        self.error = Some(ErrorCode::Unimplemented(
+                            "COMMIT in script is not supported yet".to_string(),
+                        ));
+                    }
+                    Statement::Abort => {
+                        self.error = Some(ErrorCode::Unimplemented(
+                            "ABORT in script is not supported yet".to_string(),
+                        ));
+                    }
+                    Statement::Call { .. } => {
+                        self.error = Some(ErrorCode::Unimplemented(
+                            "CALL in script is not supported yet".to_string(),
+                        ));
+                    }
+                    _ => (),
+                }
+            }
         }
 
         let mut stmt = stmt.clone();
@@ -752,66 +841,11 @@ impl Compiler {
 
     fn declare_ref(&mut self, ident: &Identifier, item: RefItem) -> Result<()> {
         let name = self.normalize_ident(ident);
-        for scope in self.scopes.iter().rev() {
-            if let Some(shadowed) = scope.items.get(&name) {
-                if !shadowed.is_same_kind(&item) {
-                    return Err(ErrorCode::ScriptSemanticError(format!(
-                        "`{name}` is already defined as a different kind of variable"
-                    ))
-                    .set_span(ident.span));
-                }
-                break;
-            }
-        }
         self.scopes.last_mut().unwrap().items.insert(name, item);
         Ok(())
     }
 
-    fn declare_anonymous_ref(&mut self, item: RefItem) -> Result<()> {
-        self.scopes.last_mut().unwrap().anonymous_items.push(item);
-        Ok(())
-    }
-
-    fn declare_var(&mut self, ident: &Identifier) -> Result<VarRef> {
-        let name = self.normalize_ident(ident);
-        let var = VarRef::new(ident.span, &name.0, &mut self.ref_allocator);
-        self.declare_ref(ident, RefItem::Var(var.clone()))?;
-        Ok(var)
-    }
-
-    fn declare_anonymous_var(&mut self, span: Span, hint: &str) -> Result<VarRef> {
-        let var = VarRef::new_internal(span, hint, &mut self.ref_allocator);
-        self.declare_anonymous_ref(RefItem::Var(var.clone()))?;
-        Ok(var)
-    }
-
-    fn declare_set(&mut self, ident: &Identifier) -> Result<SetRef> {
-        let name = self.normalize_ident(ident);
-        let set = SetRef::new(ident.span, &name.0, &mut self.ref_allocator);
-        self.declare_ref(ident, RefItem::Set(set.clone()))?;
-        Ok(set)
-    }
-
-    fn declare_anonymous_set(&mut self, span: Span, hint: &str) -> Result<SetRef> {
-        let set = SetRef::new_internal(span, hint, &mut self.ref_allocator);
-        self.declare_anonymous_ref(RefItem::Set(set.clone()))?;
-        Ok(set)
-    }
-
-    fn declare_iter(&mut self, span: Span, ident: &Identifier) -> Result<IterRef> {
-        let name = self.normalize_ident(ident);
-        let iter = IterRef::new(span, &name.0, &mut self.ref_allocator);
-        self.declare_ref(ident, RefItem::Iter(iter.clone()))?;
-        Ok(iter)
-    }
-
-    fn declare_anonymous_iter(&mut self, span: Span, hint: &str) -> Result<IterRef> {
-        let iter = IterRef::new_internal(span, hint, &mut self.ref_allocator);
-        self.declare_anonymous_ref(RefItem::Iter(iter.clone()))?;
-        Ok(iter)
-    }
-
-    fn declare_loop(&mut self, ident: &Identifier) -> Result<(LabelRef, LabelRef)> {
+    fn declare_loop(&mut self, ident: &Identifier) -> Result<LoopItem> {
         let name = self.normalize_ident(ident);
         let continue_label = LabelRef::new(
             ident.span,
@@ -823,21 +857,25 @@ impl Compiler {
             &format!("{}_LOOP_END", &name.0),
             &mut self.ref_allocator,
         );
-        self.declare_ref(ident, RefItem::Loop {
+        let loop_item = LoopItem {
+            name: Some(name.clone()),
             continue_label: continue_label.clone(),
             break_label: break_label.clone(),
-        })?;
-        Ok((continue_label, break_label))
+        };
+        self.scopes.last_mut().unwrap().loop_item = Some(loop_item.clone());
+        Ok(loop_item)
     }
 
-    fn declare_anonymous_loop(&mut self, span: Span) -> Result<(LabelRef, LabelRef)> {
+    fn declare_anonymous_loop(&mut self, span: Span) -> Result<LoopItem> {
         let continue_label = LabelRef::new_internal(span, "LOOP", &mut self.ref_allocator);
         let break_label = LabelRef::new_internal(span, "LOOP_END", &mut self.ref_allocator);
-        self.declare_anonymous_ref(RefItem::Loop {
+        let loop_item = LoopItem {
+            name: None,
             continue_label: continue_label.clone(),
             break_label: break_label.clone(),
-        })?;
-        Ok((continue_label, break_label))
+        };
+        self.scopes.last_mut().unwrap().loop_item = Some(loop_item.clone());
+        Ok(loop_item)
     }
 
     fn lookup_ref(&self, ident: &Identifier) -> Result<RefItem> {
@@ -883,31 +921,22 @@ impl Compiler {
         Ok(iter)
     }
 
-    fn lookup_loop(&self, ident: &Identifier) -> Result<(LabelRef, LabelRef)> {
-        let RefItem::Loop {
-            continue_label,
-            break_label,
-        } = self.lookup_ref(ident)?
-        else {
-            let name = self.normalize_ident(ident);
-            return Err(
-                ErrorCode::ScriptSemanticError(format!("`{name}` is not a loop"))
-                    .set_span(ident.span),
-            );
-        };
-        Ok((continue_label, break_label))
+    fn lookup_loop(&self, ident: &Identifier) -> Result<LoopItem> {
+        let name = self.normalize_ident(ident);
+        for scope in self.scopes.iter().rev() {
+            if let Some(item) = &scope.loop_item
+                && item.name.as_ref() == Some(&name)
+            {
+                return Ok(item.clone());
+            }
+        }
+        Err(ErrorCode::ScriptSemanticError(format!("`{name}` is not defined")).set_span(ident.span))
     }
 
-    fn current_loop(&self, span: Span) -> Result<(LabelRef, LabelRef)> {
+    fn current_loop(&self, span: Span) -> Result<LoopItem> {
         for scope in self.scopes.iter().rev() {
-            for item in scope.anonymous_items.iter().chain(scope.items.values()) {
-                if let RefItem::Loop {
-                    continue_label,
-                    break_label,
-                } = item
-                {
-                    return Ok((continue_label.clone(), break_label.clone()));
-                }
+            if let Some(loop_item) = &scope.loop_item {
+                return Ok(loop_item.clone());
             }
         }
         Err(ErrorCode::ScriptSemanticError("not in a loop".to_string()).set_span(span))
@@ -925,6 +954,7 @@ impl Compiler {
         impl QuoteVisitor<'_> {
             fn enter_expr(&mut self, expr: &mut Expr) {
                 match expr {
+                    // Transform `variable` to `:index`.
                     Expr::ColumnRef {
                         span,
                         column:
@@ -947,6 +977,8 @@ impl Compiler {
                             }
                         }
                     }
+                    // Transform `iter.column` to `READ <iter>, <column>, to_var`, and replace the
+                    // expression with `:to_var_index`.
                     Expr::ColumnRef {
                         span,
                         column:
@@ -958,9 +990,11 @@ impl Compiler {
                     } => {
                         let res = try {
                             // READ <iter>, <column>, to_var
-                            let to_var = self
-                                .compiler
-                                .declare_anonymous_var(column.span, &format!("{iter}.{column}"))?;
+                            let to_var = VarRef::new_internal(
+                                column.span,
+                                &format!("{iter}.{column}"),
+                                &mut self.compiler.ref_allocator,
+                            );
                             let iter = self.compiler.lookup_iter(iter)?;
                             let column =
                                 ColumnAccess::Name(self.compiler.normalize_ident(column).0);
@@ -1025,7 +1059,7 @@ impl Compiler {
 #[derive(Debug, Default)]
 struct Scope {
     items: HashMap<RefName, RefItem>,
-    anonymous_items: Vec<RefItem>,
+    loop_item: Option<LoopItem>,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -1042,21 +1076,46 @@ enum RefItem {
     Var(VarRef),
     Set(SetRef),
     Iter(IterRef),
-    Loop {
-        continue_label: LabelRef,
-        break_label: LabelRef,
-    },
 }
 
-impl RefItem {
-    pub fn is_same_kind(&self, other: &RefItem) -> bool {
-        #[allow(clippy::match_like_matches_macro)]
-        match (self, other) {
-            (RefItem::Var(_), RefItem::Var(_)) => true,
-            (RefItem::Set(_), RefItem::Set(_)) => true,
-            (RefItem::Iter(_), RefItem::Iter(_)) => true,
-            (RefItem::Loop { .. }, RefItem::Loop { .. }) => true,
-            _ => false,
+#[derive(Debug, Clone)]
+struct LoopItem {
+    name: Option<RefName>,
+    continue_label: LabelRef,
+    break_label: LabelRef,
+}
+
+#[derive(Default)]
+pub struct RefAllocator {
+    next_index: usize,
+}
+
+impl<const REFKIND: usize> Ref<REFKIND> {
+    pub fn new(span: Span, name: &str, allocator: &mut RefAllocator) -> Self {
+        let index = allocator.next_index;
+        allocator.next_index += 1;
+        Ref {
+            span,
+            index,
+            display_name: name.to_string(),
+        }
+    }
+
+    pub fn new_internal(span: Span, hint: &str, allocator: &mut RefAllocator) -> Self {
+        let index = allocator.next_index;
+        allocator.next_index += 1;
+        Ref {
+            span,
+            index,
+            display_name: format!("__{hint}{index}"),
+        }
+    }
+
+    pub fn placeholder(index: usize) -> Self {
+        Ref {
+            span: None,
+            index,
+            display_name: format!(":{}", index),
         }
     }
 }
diff --git a/src/query/script/src/executor.rs b/src/query/script/src/executor.rs
index 09c8de7c2917..dd67932dd071 100644
--- a/src/query/script/src/executor.rs
+++ b/src/query/script/src/executor.rs
@@ -14,9 +14,10 @@
 
 use std::collections::HashMap;
 
-use databend_common_ast::ast::Literal;
+use databend_common_ast::ast::Expr;
 use databend_common_exception::ErrorCode;
 use databend_common_exception::Result;
+use databend_common_exception::Span;
 
 use crate::ir::ColumnAccess;
 use crate::ir::IterRef;
@@ -26,25 +27,22 @@ use crate::ir::SetRef;
 use crate::ir::VarRef;
 
 pub trait Client {
-    type Scalar: Clone;
-    type DataBlock: Clone;
-
-    fn query(&self, query: &str) -> Result<Self::DataBlock>;
-    fn scalar_to_literal(&self, scalar: &Self::Scalar) -> Literal;
-    fn read_from_block(
-        &self,
-        block: &Self::DataBlock,
-        row: usize,
-        col: &ColumnAccess,
-    ) -> Self::Scalar;
-    fn block_len(&self, block: &Self::DataBlock) -> usize;
-    fn is_true(&self, scalar: &Self::Scalar) -> bool;
+    type Var: Clone;
+    type Set: Clone;
+
+    #[allow(async_fn_in_trait)]
+    async fn query(&self, query: &str) -> Result<Self::Set>;
+    fn var_to_ast(&self, scalar: &Self::Var) -> Result<Expr>;
+    fn read_from_set(&self, block: &Self::Set, row: usize, col: &ColumnAccess)
+    -> Result<Self::Var>;
+    fn set_len(&self, block: &Self::Set) -> usize;
+    fn is_true(&self, scalar: &Self::Var) -> Result<bool>;
 }
 
 #[derive(Debug, Clone)]
 pub enum ReturnValue<C: Client> {
-    Var(C::Scalar),
-    Set(C::DataBlock),
+    Var(C::Var),
+    Set(C::Set),
 }
 
 #[derive(Debug)]
@@ -56,11 +54,11 @@ struct Cursor {
 
 #[derive(Debug)]
 pub struct Executor<C: Client> {
+    span: Span,
     client: C,
     code: Vec<ScriptIR>,
-    max_steps: usize,
-    vars: HashMap<VarRef, C::Scalar>,
-    sets: HashMap<SetRef, C::DataBlock>,
+    vars: HashMap<VarRef, C::Var>,
+    sets: HashMap<SetRef, C::Set>,
     iters: HashMap<IterRef, Cursor>,
     label_to_pc: HashMap<LabelRef, usize>,
     return_value: Option<ReturnValue<C>>,
@@ -68,7 +66,7 @@ pub struct Executor<C: Client> {
 }
 
 impl<C: Client> Executor<C> {
-    pub fn load(client: C, code: Vec<ScriptIR>, max_steps: usize) -> Self {
+    pub fn load(span: Span, client: C, code: Vec<ScriptIR>) -> Self {
         assert!(!code.is_empty());
 
         let mut label_to_pc = HashMap::new();
@@ -79,9 +77,9 @@ impl<C: Client> Executor<C> {
         }
 
         Executor {
+            span,
             client,
             code,
-            max_steps,
             vars: HashMap::new(),
             sets: HashMap::new(),
             iters: HashMap::new(),
@@ -91,23 +89,25 @@ impl<C: Client> Executor<C> {
         }
     }
 
-    pub fn run(&mut self) -> Result<Option<ReturnValue<C>>> {
-        for _ in 0..self.max_steps {
+    pub async fn run(&mut self, max_steps: usize) -> Result<Option<ReturnValue<C>>> {
+        for _ in 0..max_steps {
             if self.pc >= self.code.len() {
                 return Ok(self.return_value.take());
             }
-            self.step()?;
+            self.step().await?;
         }
 
         Err(ErrorCode::ScriptExecutionError(format!(
             "Execution of script has exceeded the limit of {} steps, \
              which usually means you may have an infinite loop. Otherwise, \
-             You can increase the limit with `set script_max_steps = 10000;`.",
-            self.max_steps
-        )))
+             You can increase the limit with `set script_max_steps = {};`.",
+            max_steps,
+            max_steps * 10
+        ))
+        .set_span(self.span))
     }
 
-    fn step(&mut self) -> Result<()> {
+    async fn step(&mut self) -> Result<()> {
         let line = self
             .code
             .get(self.pc)
@@ -118,11 +118,12 @@ impl<C: Client> Executor<C> {
         match &line {
             ScriptIR::Query { stmt, to_set } => {
                 let sql = stmt
-                    .subst(|var| Ok(self.client.scalar_to_literal(self.get_var(&var)?)))?
+                    .subst(|var| self.client.var_to_ast(self.get_var(&var)?))?
                     .to_string();
                 let block = self
                     .client
                     .query(&sql)
+                    .await
                     .map_err(|err| err.set_span(stmt.span))?;
                 self.sets.insert(to_set.clone(), block);
             }
@@ -131,7 +132,7 @@ impl<C: Client> Executor<C> {
                 let cursor = Cursor {
                     set: set.clone(),
                     row: 0,
-                    len: self.client.block_len(block),
+                    len: self.client.set_len(block),
                 };
                 self.iters.insert(to_iter.clone(), cursor);
             }
@@ -142,7 +143,7 @@ impl<C: Client> Executor<C> {
             } => {
                 let cursor = self.get_iter(iter)?;
                 let block = self.get_set(&cursor.set)?;
-                let scalar = self.client.read_from_block(block, cursor.row, column);
+                let scalar = self.client.read_from_set(block, cursor.row, column)?;
                 self.vars.insert(to_var.clone(), scalar);
             }
             ScriptIR::Next { iter } => {
@@ -162,7 +163,7 @@ impl<C: Client> Executor<C> {
                 to_label,
             } => {
                 let scalar = self.get_var(condition)?;
-                if self.client.is_true(scalar) {
+                if self.client.is_true(scalar)? {
                     self.goto(to_label)?;
                 }
             }
@@ -187,13 +188,13 @@ impl<C: Client> Executor<C> {
         Ok(())
     }
 
-    fn get_var(&self, var: &VarRef) -> Result<&C::Scalar> {
+    fn get_var(&self, var: &VarRef) -> Result<&C::Var> {
         self.vars
             .get(var)
             .ok_or_else(|| ErrorCode::ScriptExecutionError(format!("unknown var: {var}")))
     }
 
-    fn get_set(&self, set: &SetRef) -> Result<&C::DataBlock> {
+    fn get_set(&self, set: &SetRef) -> Result<&C::Set> {
         self.sets
             .get(set)
             .ok_or_else(|| ErrorCode::ScriptExecutionError(format!("unknown set: {set}")))
diff --git a/src/query/script/src/ir.rs b/src/query/script/src/ir.rs
index e4013367dac3..dfd718a18eef 100644
--- a/src/query/script/src/ir.rs
+++ b/src/query/script/src/ir.rs
@@ -58,41 +58,6 @@ impl<const REFKIND: usize> Display for Ref<REFKIND> {
     }
 }
 
-#[derive(Default)]
-pub struct RefAllocator {
-    next_index: usize,
-}
-
-impl<const REFKIND: usize> Ref<REFKIND> {
-    pub fn new(span: Span, name: &str, allocator: &mut RefAllocator) -> Self {
-        let index = allocator.next_index;
-        allocator.next_index += 1;
-        Ref {
-            span,
-            index,
-            display_name: name.to_string(),
-        }
-    }
-
-    pub fn new_internal(span: Span, hint: &str, allocator: &mut RefAllocator) -> Self {
-        let index = allocator.next_index;
-        allocator.next_index += 1;
-        Ref {
-            span,
-            index,
-            display_name: format!("__{hint}{index}"),
-        }
-    }
-
-    pub fn placeholder(index: usize) -> Self {
-        Ref {
-            span: None,
-            index,
-            display_name: format!(":{}", index),
-        }
-    }
-}
-
 #[derive(Debug, Clone)]
 pub enum ScriptIR {
     /// Executes a SQL query and stores the result in a named result set.
@@ -194,11 +159,11 @@ impl StatementTemplate {
         StatementTemplate { span, stmt }
     }
 
-    pub fn subst(&self, lookup_var: impl Fn(VarRef) -> Result<Literal>) -> Result<Statement> {
+    pub fn subst(&self, lookup_var: impl Fn(VarRef) -> Result<Expr>) -> Result<Statement> {
         #[derive(VisitorMut)]
         #[visitor(Expr(enter), Identifier(enter))]
         struct SubstVisitor<'a> {
-            lookup_var: &'a dyn Fn(VarRef) -> Result<Literal>,
+            lookup_var: &'a dyn Fn(VarRef) -> Result<Expr>,
             error: Option<ErrorCode>,
         }
 
@@ -209,7 +174,7 @@ impl StatementTemplate {
                     let value = (self.lookup_var)(VarRef::placeholder(index));
                     match value {
                         Ok(value) => {
-                            *expr = Expr::Literal { span: *span, value };
+                            *expr = value;
                         }
                         Err(e) => {
                             self.error = Some(e.set_span(*span));
@@ -223,7 +188,10 @@ impl StatementTemplate {
                     let index = ident.name.parse::<usize>().unwrap();
                     let value = (self.lookup_var)(VarRef::placeholder(index));
                     match value {
-                        Ok(Literal::String(name)) => {
+                        Ok(Expr::Literal {
+                            value: Literal::String(name),
+                            ..
+                        }) => {
                             *ident = Identifier::from_name(ident.span, name);
                         }
                         Ok(value) => {
diff --git a/src/query/script/src/lib.rs b/src/query/script/src/lib.rs
index 281417981b1f..f20b63c47390 100644
--- a/src/query/script/src/lib.rs
+++ b/src/query/script/src/lib.rs
@@ -13,6 +13,7 @@
 // limitations under the License.
 
 #![feature(try_blocks)]
+#![feature(let_chains)]
 
 pub mod ir;
 
diff --git a/src/query/script/tests/it/main.rs b/src/query/script/tests/it/main.rs
index 8070300fed69..e81cf6c5e880 100644
--- a/src/query/script/tests/it/main.rs
+++ b/src/query/script/tests/it/main.rs
@@ -22,18 +22,22 @@ use std::io::Write;
 use std::sync::Arc;
 use std::sync::Mutex;
 
+use databend_common_ast::ast::Expr;
 use databend_common_ast::ast::Literal;
 use databend_common_ast::parser::run_parser;
 use databend_common_ast::parser::script::script_stmts;
 use databend_common_ast::parser::tokenize_sql;
 use databend_common_ast::parser::Dialect;
 use databend_common_ast::parser::ParseMode;
+use databend_common_exception::ErrorCode;
+use databend_common_exception::Range;
 use databend_common_exception::Result;
 use databend_common_script::compile;
 use databend_common_script::ir::ColumnAccess;
 use databend_common_script::Client;
 use databend_common_script::Executor;
 use goldenfile::Mint;
+use tokio::runtime::Runtime;
 
 fn run_script(file: &mut dyn Write, src: &str) {
     let src = unindent::unindent(src);
@@ -51,8 +55,9 @@ fn run_script(file: &mut dyn Write, src: &str) {
         let ir = compile(&ast)?;
         let client = mock_client();
         let query_log = client.query_log.clone();
-        let mut executor = Executor::load(client, ir.clone(), 1000);
-        let result = executor.run()?;
+        let mut executor = Executor::load(None, client, ir.clone());
+        let rt = Runtime::new().unwrap();
+        let result = rt.block_on(executor.run(1000))?;
 
         (ir, query_log, result)
     };
@@ -93,17 +98,40 @@ fn test_script() {
     run_script(
         file,
         r#"
-            CREATE TABLE t1 (a INT, b INT, c INT);
+            CREATE OR REPLACE TABLE t1 (a INT, b INT, c INT);
             INSERT INTO t1 VALUES (1, 2, 3);
-            DROP TABLE t1;
+            RETURN TABLE(SELECT a FROM t1);
         "#,
     );
     run_script(
         file,
         r#"
             LET x := 1;
-            LET y := x + 1;
-            LET z RESULTSET := SELECT :y + 1;
+            LET x := x + 1;
+            LET x RESULTSET := SELECT :x + 1;
+            RETURN TABLE(x);
+        "#,
+    );
+    run_script(
+        file,
+        r#"
+            LET x := 1;
+            RETURN TABLE(SELECT :x + 1);
+        "#,
+    );
+    run_script(
+        file,
+        r#"
+            LET x RESULTSET := SELECT 1;
+            LET x := 1;
+            RETURN x;
+        "#,
+    );
+    run_script(
+        file,
+        r#"
+            LET table := 1;
+            RETURN table;
         "#,
     );
     run_script(
@@ -144,6 +172,28 @@ fn test_script() {
             RETURN sum;
         "#,
     );
+    run_script(
+        file,
+        r#"
+            LET sum := 0;
+            FOR row IN SELECT * FROM numbers(3) DO
+                sum := sum + row.number;
+            END FOR;
+            RETURN sum;
+        "#,
+    );
+    run_script(
+        file,
+        r#"
+            LET x RESULTSET := SELECT * FROM numbers(3);
+            LET sum := 0;
+            FOR x IN x DO
+                LET x := x.number;
+                sum := sum + x;
+            END FOR x;
+            RETURN sum;
+        "#,
+    );
     run_script(
         file,
         r#"
@@ -165,6 +215,18 @@ fn test_script() {
             RETURN x;
         "#,
     );
+    run_script(
+        file,
+        r#"
+            LET x := 1;
+            REPEAT
+                x := x + 1;
+                LET y := 3;
+            UNTIL x = y
+            END REPEAT;
+            RETURN x;
+        "#,
+    );
     run_script(
         file,
         r#"
@@ -275,22 +337,29 @@ fn test_script_error() {
     run_script(
         file,
         r#"
-            LET x := 1;
             LET x RESULTSET := SELECT 1;
+            LET y := x;
+        "#,
+    );
+    run_script(
+        file,
+        r#"
+            RETURN TABLE(x);
         "#,
     );
     run_script(
         file,
         r#"
-            LET x RESULTSET := SELECT 1;
             LET x := 1;
+            RETURN TABLE(x);
         "#,
     );
     run_script(
         file,
         r#"
+            LET x := 1;
             LET x RESULTSET := SELECT 1;
-            LET y := x;
+            RETURN x;
         "#,
     );
     run_script(
@@ -359,27 +428,66 @@ fn test_script_error() {
             END LOOP;
         "#,
     );
+    run_script(
+        file,
+        r#"
+            LET zero := 0;
+            LET y := 1 + zero / 0;
+        "#,
+    );
+    run_script(
+        file,
+        r#"
+            LET zero := 0;
+            SELECT 1 + :zero / 0;
+        "#,
+    );
+    run_script(
+        file,
+        r#"
+            LET zero := 0;
+            RETURN 1 + zero / 0;
+        "#,
+    );
+    run_script(
+        file,
+        r#"
+            LET zero := 0;
+            RETURN TABLE(SELECT 1 + :zero / 0);
+        "#,
+    );
+    run_script(
+        file,
+        r#"
+            FOR x IN REVERSE 3 TO 1 DO
+                RETURN;
+            END FOR;
+        "#,
+    );
 }
 
 fn mock_client() -> MockClient {
     MockClient::new()
         .response_when(
             "SELECT * FROM numbers(3)",
-            MockBlock::named(vec!["number"], vec![
+            MockSet::named(vec!["number"], vec![
                 vec![Literal::UInt64(0)],
                 vec![Literal::UInt64(1)],
                 vec![Literal::UInt64(2)],
             ]),
         )
         .response_when(
-            "CREATE TABLE t1 (a Int32, b Int32, c Int32)",
-            MockBlock::empty(),
+            "CREATE OR REPLACE TABLE t1 (a Int32, b Int32, c Int32)",
+            MockSet::empty(),
+        )
+        .response_when("INSERT INTO t1 VALUES (1, 2, 3)", MockSet::empty())
+        .response_when(
+            "SELECT a FROM t1",
+            MockSet::named(vec!["a"], vec![vec![Literal::UInt64(1)]]),
         )
-        .response_when("INSERT INTO t1 VALUES (1, 2, 3)", MockBlock::empty())
-        .response_when("DROP TABLE t1", MockBlock::empty())
         .response_when(
             "SELECT * FROM generate_series(1, 1 + 2, 1)",
-            MockBlock::unnamed(vec![
+            MockSet::unnamed(vec![
                 vec![Literal::UInt64(1)],
                 vec![Literal::UInt64(2)],
                 vec![Literal::UInt64(3)],
@@ -387,7 +495,7 @@ fn mock_client() -> MockClient {
         )
         .response_when(
             "SELECT * FROM generate_series(1, - 1, -1)",
-            MockBlock::unnamed(vec![
+            MockSet::unnamed(vec![
                 vec![Literal::UInt64(1)],
                 vec![Literal::UInt64(0)],
                 vec![Literal::Decimal256 {
@@ -397,209 +505,215 @@ fn mock_client() -> MockClient {
                 }],
             ]),
         )
-        .response_when(
-            "SELECT 0",
-            MockBlock::unnamed(vec![vec![Literal::UInt64(0)]]),
-        )
-        .response_when(
-            "SELECT 1",
-            MockBlock::unnamed(vec![vec![Literal::UInt64(1)]]),
-        )
-        .response_when(
-            "SELECT 2",
-            MockBlock::unnamed(vec![vec![Literal::UInt64(2)]]),
-        )
-        .response_when(
-            "SELECT 3",
-            MockBlock::unnamed(vec![vec![Literal::UInt64(3)]]),
-        )
-        .response_when(
-            "SELECT 6",
-            MockBlock::unnamed(vec![vec![Literal::UInt64(6)]]),
-        )
+        .response_when("SELECT 0", MockSet::unnamed(vec![vec![Literal::UInt64(0)]]))
+        .response_when("SELECT 1", MockSet::unnamed(vec![vec![Literal::UInt64(1)]]))
+        .response_when("SELECT 2", MockSet::unnamed(vec![vec![Literal::UInt64(2)]]))
+        .response_when("SELECT 3", MockSet::unnamed(vec![vec![Literal::UInt64(3)]]))
+        .response_when("SELECT 6", MockSet::unnamed(vec![vec![Literal::UInt64(6)]]))
         .response_when(
             "SELECT 'ONE'",
-            MockBlock::unnamed(vec![vec![Literal::String("ONE".to_string())]]),
+            MockSet::unnamed(vec![vec![Literal::String("ONE".to_string())]]),
         )
         .response_when(
             "SELECT 'TWO'",
-            MockBlock::unnamed(vec![vec![Literal::String("TWO".to_string())]]),
+            MockSet::unnamed(vec![vec![Literal::String("TWO".to_string())]]),
         )
         .response_when(
             "SELECT 'OTHER'",
-            MockBlock::unnamed(vec![vec![Literal::String("OTHER".to_string())]]),
+            MockSet::unnamed(vec![vec![Literal::String("OTHER".to_string())]]),
         )
         .response_when(
             "SELECT 0 + 0",
-            MockBlock::unnamed(vec![vec![Literal::UInt64(0)]]),
+            MockSet::unnamed(vec![vec![Literal::UInt64(0)]]),
         )
         .response_when(
             "SELECT 0 + 1",
-            MockBlock::unnamed(vec![vec![Literal::UInt64(1)]]),
+            MockSet::unnamed(vec![vec![Literal::UInt64(1)]]),
         )
         .response_when(
             "SELECT 1 + 0",
-            MockBlock::unnamed(vec![vec![Literal::UInt64(1)]]),
+            MockSet::unnamed(vec![vec![Literal::UInt64(1)]]),
         )
         .response_when(
             "SELECT 1 + -1",
-            MockBlock::unnamed(vec![vec![Literal::UInt64(0)]]),
+            MockSet::unnamed(vec![vec![Literal::UInt64(0)]]),
         )
         .response_when(
             "SELECT 1 + 1",
-            MockBlock::unnamed(vec![vec![Literal::UInt64(2)]]),
+            MockSet::unnamed(vec![vec![Literal::UInt64(2)]]),
         )
         .response_when(
             "SELECT 1 + 2",
-            MockBlock::unnamed(vec![vec![Literal::UInt64(3)]]),
+            MockSet::unnamed(vec![vec![Literal::UInt64(3)]]),
         )
         .response_when(
             "SELECT 2 + 1",
-            MockBlock::unnamed(vec![vec![Literal::UInt64(3)]]),
+            MockSet::unnamed(vec![vec![Literal::UInt64(3)]]),
         )
         .response_when(
             "SELECT 3 + 3",
-            MockBlock::unnamed(vec![vec![Literal::UInt64(6)]]),
+            MockSet::unnamed(vec![vec![Literal::UInt64(6)]]),
         )
         .response_when(
             "SELECT 3 * 3",
-            MockBlock::unnamed(vec![vec![Literal::UInt64(9)]]),
+            MockSet::unnamed(vec![vec![Literal::UInt64(9)]]),
         )
         .response_when(
             "SELECT is_true(0 < 2)",
-            MockBlock::unnamed(vec![vec![Literal::Boolean(true)]]),
+            MockSet::unnamed(vec![vec![Literal::Boolean(true)]]),
         )
         .response_when(
             "SELECT is_true(1 < 2)",
-            MockBlock::unnamed(vec![vec![Literal::Boolean(true)]]),
+            MockSet::unnamed(vec![vec![Literal::Boolean(true)]]),
         )
         .response_when(
             "SELECT is_true(2 < 2)",
-            MockBlock::unnamed(vec![vec![Literal::Boolean(false)]]),
+            MockSet::unnamed(vec![vec![Literal::Boolean(false)]]),
         )
         .response_when(
             "SELECT is_true(1 = 1)",
-            MockBlock::unnamed(vec![vec![Literal::Boolean(true)]]),
+            MockSet::unnamed(vec![vec![Literal::Boolean(true)]]),
         )
         .response_when(
             "SELECT is_true(2 = 1)",
-            MockBlock::unnamed(vec![vec![Literal::Boolean(false)]]),
+            MockSet::unnamed(vec![vec![Literal::Boolean(false)]]),
         )
         .response_when(
             "SELECT is_true(2 = 2)",
-            MockBlock::unnamed(vec![vec![Literal::Boolean(true)]]),
+            MockSet::unnamed(vec![vec![Literal::Boolean(true)]]),
         )
         .response_when(
             "SELECT is_true(2 = 3)",
-            MockBlock::unnamed(vec![vec![Literal::Boolean(false)]]),
+            MockSet::unnamed(vec![vec![Literal::Boolean(false)]]),
         )
         .response_when(
             "SELECT is_true(3 = 1)",
-            MockBlock::unnamed(vec![vec![Literal::Boolean(false)]]),
+            MockSet::unnamed(vec![vec![Literal::Boolean(false)]]),
         )
         .response_when(
             "SELECT is_true(3 = 2)",
-            MockBlock::unnamed(vec![vec![Literal::Boolean(false)]]),
+            MockSet::unnamed(vec![vec![Literal::Boolean(false)]]),
         )
         .response_when(
             "SELECT is_true(3 = 3)",
-            MockBlock::unnamed(vec![vec![Literal::Boolean(true)]]),
+            MockSet::unnamed(vec![vec![Literal::Boolean(true)]]),
         )
         .response_when(
             "SELECT NOT is_true(1 < 3)",
-            MockBlock::unnamed(vec![vec![Literal::Boolean(false)]]),
+            MockSet::unnamed(vec![vec![Literal::Boolean(false)]]),
         )
         .response_when(
             "SELECT NOT is_true(2 < 3)",
-            MockBlock::unnamed(vec![vec![Literal::Boolean(false)]]),
+            MockSet::unnamed(vec![vec![Literal::Boolean(false)]]),
         )
         .response_when(
             "SELECT NOT is_true(3 < 3)",
-            MockBlock::unnamed(vec![vec![Literal::Boolean(true)]]),
+            MockSet::unnamed(vec![vec![Literal::Boolean(true)]]),
+        )
+        .throw_error_when(
+            "SELECT 1 + 0 / 0",
+            ErrorCode::BadArguments("division by zero".to_string())
+                .set_span(Some(Range { start: 13, end: 14 })),
+        )
+        .throw_error_when(
+            "SELECT * FROM generate_series(1, 3, -1)",
+            ErrorCode::BadArguments(
+                "start must be greater than or equal to end when step is negative".to_string(),
+            )
+            .set_span(Some(Range { start: 14, end: 39 })),
         )
 }
 
 #[derive(Debug, Clone)]
 struct MockClient {
-    responses: HashMap<String, MockBlock>,
-    query_log: Arc<Mutex<Vec<(String, MockBlock)>>>,
+    responses: HashMap<String, MockSet>,
+    throw_errors: HashMap<String, ErrorCode>,
+    query_log: Arc<Mutex<Vec<(String, MockSet)>>>,
 }
 
 impl MockClient {
     pub fn new() -> Self {
         MockClient {
             responses: HashMap::new(),
+            throw_errors: HashMap::new(),
             query_log: Arc::new(Mutex::new(vec![])),
         }
     }
 
-    pub fn response_when(mut self, query: &str, block: MockBlock) -> Self {
+    pub fn response_when(mut self, query: &str, block: MockSet) -> Self {
         self.responses.insert(query.to_string(), block);
         self
     }
+
+    pub fn throw_error_when(mut self, query: &str, err: ErrorCode) -> Self {
+        self.throw_errors.insert(query.to_string(), err);
+        self
+    }
 }
 
 impl Client for MockClient {
-    type Scalar = Literal;
-    type DataBlock = MockBlock;
+    type Var = Literal;
+    type Set = MockSet;
 
-    fn query(&self, query: &str) -> Result<Self::DataBlock> {
-        match self.responses.get(query) {
-            Some(block) => {
-                self.query_log
-                    .lock()
-                    .unwrap()
-                    .push((query.to_string(), block.clone()));
-                Ok(block.clone())
-            }
-            None => panic!("response to query is not defined: {query}"),
+    async fn query(&self, query: &str) -> Result<Self::Set> {
+        if let Some(block) = self.responses.get(query) {
+            self.query_log
+                .lock()
+                .unwrap()
+                .push((query.to_string(), block.clone()));
+            return Ok(block.clone());
+        }
+
+        if let Some(err) = self.throw_errors.get(query) {
+            return Err(err.clone());
         }
+
+        panic!("response to query is not defined: {query}")
     }
 
-    fn scalar_to_literal(&self, scalar: &Self::Scalar) -> Literal {
-        scalar.clone()
+    fn var_to_ast(&self, scalar: &Self::Var) -> Result<Expr> {
+        Ok(Expr::Literal {
+            span: None,
+            value: scalar.clone(),
+        })
     }
 
-    fn read_from_block(
-        &self,
-        block: &Self::DataBlock,
-        row: usize,
-        col: &ColumnAccess,
-    ) -> Self::Scalar {
-        match col {
-            ColumnAccess::Position(col) => block.data[row][*col].clone(),
+    fn read_from_set(&self, set: &Self::Set, row: usize, col: &ColumnAccess) -> Result<Self::Var> {
+        let var = match col {
+            ColumnAccess::Position(col) => set.data[row][*col].clone(),
             ColumnAccess::Name(name) => {
-                let col = block.column_names.iter().position(|x| x == name).unwrap();
-                block.data[row][col].clone()
+                let col = set.column_names.iter().position(|x| x == name).unwrap();
+                set.data[row][col].clone()
             }
-        }
+        };
+        Ok(var)
     }
 
-    fn block_len(&self, block: &Self::DataBlock) -> usize {
-        block.data.len()
+    fn set_len(&self, set: &Self::Set) -> usize {
+        set.data.len()
     }
 
-    fn is_true(&self, scalar: &Self::Scalar) -> bool {
-        *scalar == Literal::Boolean(true)
+    fn is_true(&self, scalar: &Self::Var) -> Result<bool> {
+        Ok(*scalar == Literal::Boolean(true))
     }
 }
 
 #[derive(Debug, Clone)]
-struct MockBlock {
+struct MockSet {
     column_names: Vec<String>,
     data: Vec<Vec<Literal>>,
 }
 
-impl MockBlock {
+impl MockSet {
     pub fn empty() -> Self {
-        MockBlock {
+        MockSet {
             column_names: vec![],
             data: vec![],
         }
     }
 
     pub fn unnamed(data: Vec<Vec<Literal>>) -> Self {
-        MockBlock {
+        MockSet {
             column_names: (0..data[0].len()).map(|x| format!("${x}")).collect(),
             data,
         }
@@ -609,14 +723,14 @@ impl MockBlock {
         column_names: impl IntoIterator<Item = &'static str>,
         data: Vec<Vec<Literal>>,
     ) -> Self {
-        MockBlock {
+        MockSet {
             column_names: column_names.into_iter().map(|x| x.to_string()).collect(),
             data,
         }
     }
 }
 
-impl Display for MockBlock {
+impl Display for MockSet {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         write!(f, "(")?;
         for (i, name) in self.column_names.iter().enumerate() {
diff --git a/src/query/script/tests/it/testdata/script-error.txt b/src/query/script/tests/it/testdata/script-error.txt
index 0afd0cf1e6ee..3e0c653e4cf9 100644
--- a/src/query/script/tests/it/testdata/script-error.txt
+++ b/src/query/script/tests/it/testdata/script-error.txt
@@ -9,39 +9,51 @@ error:
 
 
 ---------- Input ----------
-LET x := 1;
 LET x RESULTSET := SELECT 1;
+LET y := x;
 ---------- Output ----------
 error: 
-  --> SQL:2:5
+  --> SQL:2:10
   |
-1 | LET x := 1;
-2 | LET x RESULTSET := SELECT 1;
-  |     ^ `x` is already defined as a different kind of variable
+1 | LET x RESULTSET := SELECT 1;
+2 | LET y := x;
+  |          ^ `x` is not a scalar variable
+
+
+---------- Input ----------
+RETURN TABLE(x);
+---------- Output ----------
+error: 
+  --> SQL:1:14
+  |
+1 | RETURN TABLE(x);
+  |              ^ `x` is not defined
 
 
 ---------- Input ----------
-LET x RESULTSET := SELECT 1;
 LET x := 1;
+RETURN TABLE(x);
 ---------- Output ----------
 error: 
-  --> SQL:2:5
+  --> SQL:2:14
   |
-1 | LET x RESULTSET := SELECT 1;
-2 | LET x := 1;
-  |     ^ `x` is already defined as a different kind of variable
+1 | LET x := 1;
+2 | RETURN TABLE(x);
+  |              ^ `x` is not a set
 
 
 ---------- Input ----------
+LET x := 1;
 LET x RESULTSET := SELECT 1;
-LET y := x;
+RETURN x;
 ---------- Output ----------
 error: 
-  --> SQL:2:10
+  --> SQL:3:8
   |
-1 | LET x RESULTSET := SELECT 1;
-2 | LET y := x;
-  |          ^ `x` is not a scalar variable
+1 | LET x := 1;
+2 | LET x RESULTSET := SELECT 1;
+3 | RETURN x;
+  |        ^ `x` is not a scalar variable
 
 
 ---------- Input ----------
@@ -148,3 +160,63 @@ END LOOP;
 Execution of script has exceeded the limit of 1000 steps, which usually means you may have an infinite loop. Otherwise, You can increase the limit with `set script_max_steps = 10000;`.
 
 
+---------- Input ----------
+LET zero := 0;
+LET y := 1 + zero / 0;
+---------- Output ----------
+error: 
+  --> SQL:2:10
+  |
+1 | LET zero := 0;
+2 | LET y := 1 + zero / 0;
+  |          ^^^^^^^^^^^^ division by zero
+
+
+---------- Input ----------
+LET zero := 0;
+SELECT 1 + :zero / 0;
+---------- Output ----------
+error: 
+  --> SQL:2:1
+  |
+1 | LET zero := 0;
+2 | SELECT 1 + :zero / 0;
+  | ^^^^^^^^^^^^^^^^^^^^ division by zero
+
+
+---------- Input ----------
+LET zero := 0;
+RETURN 1 + zero / 0;
+---------- Output ----------
+error: 
+  --> SQL:2:8
+  |
+1 | LET zero := 0;
+2 | RETURN 1 + zero / 0;
+  |        ^^^^^^^^^^^^ division by zero
+
+
+---------- Input ----------
+LET zero := 0;
+RETURN TABLE(SELECT 1 + :zero / 0);
+---------- Output ----------
+error: 
+  --> SQL:2:1
+  |
+1 | LET zero := 0;
+2 | RETURN TABLE(SELECT 1 + :zero / 0);
+  | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ division by zero
+
+
+---------- Input ----------
+FOR x IN REVERSE 3 TO 1 DO
+    RETURN;
+END FOR;
+---------- Output ----------
+error: 
+  --> SQL:1:5
+  |
+1 | FOR x IN REVERSE 3 TO 1 DO
+  |     ^ start must be greater than or equal to end when step is negative
+
+
diff --git a/src/query/script/tests/it/testdata/script.txt b/src/query/script/tests/it/testdata/script.txt
index d93a46dcc172..018a88d879e7 100644
--- a/src/query/script/tests/it/testdata/script.txt
+++ b/src/query/script/tests/it/testdata/script.txt
@@ -1,34 +1,37 @@
 ---------- Input ----------
-CREATE TABLE t1 (a INT, b INT, c INT);
+CREATE OR REPLACE TABLE t1 (a INT, b INT, c INT);
 INSERT INTO t1 VALUES (1, 2, 3);
-DROP TABLE t1;
+RETURN TABLE(SELECT a FROM t1);
 ---------- IR -------------
-QUERY CREATE TABLE t1 (a Int32, b Int32, c Int32), __unused_result0(0)
+QUERY CREATE OR REPLACE TABLE t1 (a Int32, b Int32, c Int32), __unused_result0(0)
 QUERY INSERT INTO t1 VALUES (1, 2, 3), __unused_result1(1)
-QUERY DROP TABLE t1, __unused_result2(2)
+QUERY SELECT a FROM t1, __return_set2(2)
+RETURN __return_set2(2)
 ---------- QUERY ---------
-QUERY: CREATE TABLE t1 (a Int32, b Int32, c Int32)
+QUERY: CREATE OR REPLACE TABLE t1 (a Int32, b Int32, c Int32)
 BLOCK: (): 
 QUERY: INSERT INTO t1 VALUES (1, 2, 3)
 BLOCK: (): 
-QUERY: DROP TABLE t1
-BLOCK: (): 
+QUERY: SELECT a FROM t1
+BLOCK: (a): (1)
 ---------- Output ---------
-None
+Some(Set(MockSet { column_names: ["a"], data: [[UInt64(1)]] }))
 
 
 ---------- Input ----------
 LET x := 1;
-LET y := x + 1;
-LET z RESULTSET := SELECT :y + 1;
+LET x := x + 1;
+LET x RESULTSET := SELECT :x + 1;
+RETURN TABLE(x);
 ---------- IR -------------
 QUERY SELECT 1, __expr_result1(1)
 ITER __expr_result1(1), __expr_result_iter2(2)
 READ __expr_result_iter2(2), $0, x(0)
 QUERY SELECT :0 + 1, __expr_result4(4)
 ITER __expr_result4(4), __expr_result_iter5(5)
-READ __expr_result_iter5(5), $0, y(3)
-QUERY SELECT :3 + 1, z(6)
+READ __expr_result_iter5(5), $0, x(3)
+QUERY SELECT :3 + 1, x(6)
+RETURN x(6)
 ---------- QUERY ---------
 QUERY: SELECT 1
 BLOCK: ($0): (1)
@@ -37,7 +40,69 @@ BLOCK: ($0): (2)
 QUERY: SELECT 2 + 1
 BLOCK: ($0): (3)
 ---------- Output ---------
-None
+Some(Set(MockSet { column_names: ["$0"], data: [[UInt64(3)]] }))
+
+
+---------- Input ----------
+LET x := 1;
+RETURN TABLE(SELECT :x + 1);
+---------- IR -------------
+QUERY SELECT 1, __expr_result1(1)
+ITER __expr_result1(1), __expr_result_iter2(2)
+READ __expr_result_iter2(2), $0, x(0)
+QUERY SELECT :0 + 1, __return_set3(3)
+RETURN __return_set3(3)
+---------- QUERY ---------
+QUERY: SELECT 1
+BLOCK: ($0): (1)
+QUERY: SELECT 1 + 1
+BLOCK: ($0): (2)
+---------- Output ---------
+Some(Set(MockSet { column_names: ["$0"], data: [[UInt64(2)]] }))
+
+
+---------- Input ----------
+LET x RESULTSET := SELECT 1;
+LET x := 1;
+RETURN x;
+---------- IR -------------
+QUERY SELECT 1, x(0)
+QUERY SELECT 1, __expr_result2(2)
+ITER __expr_result2(2), __expr_result_iter3(3)
+READ __expr_result_iter3(3), $0, x(1)
+QUERY SELECT :1, __expr_result5(5)
+ITER __expr_result5(5), __expr_result_iter6(6)
+READ __expr_result_iter6(6), $0, __return_val4(4)
+RETURN __return_val4(4)
+---------- QUERY ---------
+QUERY: SELECT 1
+BLOCK: ($0): (1)
+QUERY: SELECT 1
+BLOCK: ($0): (1)
+QUERY: SELECT 1
+BLOCK: ($0): (1)
+---------- Output ---------
+Some(Var(UInt64(1)))
+
+
+---------- Input ----------
+LET table := 1;
+RETURN table;
+---------- IR -------------
+QUERY SELECT 1, __expr_result1(1)
+ITER __expr_result1(1), __expr_result_iter2(2)
+READ __expr_result_iter2(2), $0, table(0)
+QUERY SELECT :0, __expr_result4(4)
+ITER __expr_result4(4), __expr_result_iter5(5)
+READ __expr_result_iter5(5), $0, __return_val3(3)
+RETURN __return_val3(3)
+---------- QUERY ---------
+QUERY: SELECT 1
+BLOCK: ($0): (1)
+QUERY: SELECT 1
+BLOCK: ($0): (1)
+---------- Output ---------
+Some(Var(UInt64(1)))
 
 
 ---------- Input ----------
@@ -182,6 +247,101 @@ BLOCK: ($0): (3)
 Some(Var(UInt64(3)))
 
 
+---------- Input ----------
+LET sum := 0;
+FOR row IN SELECT * FROM numbers(3) DO
+    sum := sum + row.number;
+END FOR;
+RETURN sum;
+---------- IR -------------
+QUERY SELECT 0, __expr_result1(1)
+ITER __expr_result1(1), __expr_result_iter2(2)
+READ __expr_result_iter2(2), $0, sum(0)
+QUERY SELECT * FROM numbers(3), __for_in_set3(3)
+ITER __for_in_set3(3), row(6)
+__LOOP4(4):
+JUMP_IF_ENDED row(6), __LOOP_END5(5)
+READ row(6), "number", __row.number7(7)
+QUERY SELECT :0 + :7, __expr_result8(8)
+ITER __expr_result8(8), __expr_result_iter9(9)
+READ __expr_result_iter9(9), $0, sum(0)
+NEXT row(6)
+GOTO __LOOP4(4)
+__LOOP_END5(5):
+QUERY SELECT :0, __expr_result11(11)
+ITER __expr_result11(11), __expr_result_iter12(12)
+READ __expr_result_iter12(12), $0, __return_val10(10)
+RETURN __return_val10(10)
+---------- QUERY ---------
+QUERY: SELECT 0
+BLOCK: ($0): (0)
+QUERY: SELECT * FROM numbers(3)
+BLOCK: (number): (0), (1), (2)
+QUERY: SELECT 0 + 0
+BLOCK: ($0): (0)
+QUERY: SELECT 0 + 1
+BLOCK: ($0): (1)
+QUERY: SELECT 1 + 2
+BLOCK: ($0): (3)
+QUERY: SELECT 3
+BLOCK: ($0): (3)
+---------- Output ---------
+Some(Var(UInt64(3)))
+
+
+---------- Input ----------
+LET x RESULTSET := SELECT * FROM numbers(3);
+LET sum := 0;
+FOR x IN x DO
+    LET x := x.number;
+    sum := sum + x;
+END FOR x;
+RETURN sum;
+---------- IR -------------
+QUERY SELECT * FROM numbers(3), x(0)
+QUERY SELECT 0, __expr_result2(2)
+ITER __expr_result2(2), __expr_result_iter3(3)
+READ __expr_result_iter3(3), $0, sum(1)
+ITER x(0), x(6)
+x_LOOP(4):
+JUMP_IF_ENDED x(6), x_LOOP_END(5)
+READ x(6), "number", __x.number8(8)
+QUERY SELECT :8, __expr_result9(9)
+ITER __expr_result9(9), __expr_result_iter10(10)
+READ __expr_result_iter10(10), $0, x(7)
+QUERY SELECT :1 + :7, __expr_result11(11)
+ITER __expr_result11(11), __expr_result_iter12(12)
+READ __expr_result_iter12(12), $0, sum(1)
+NEXT x(6)
+GOTO x_LOOP(4)
+x_LOOP_END(5):
+QUERY SELECT :1, __expr_result14(14)
+ITER __expr_result14(14), __expr_result_iter15(15)
+READ __expr_result_iter15(15), $0, __return_val13(13)
+RETURN __return_val13(13)
+---------- QUERY ---------
+QUERY: SELECT * FROM numbers(3)
+BLOCK: (number): (0), (1), (2)
+QUERY: SELECT 0
+BLOCK: ($0): (0)
+QUERY: SELECT 0
+BLOCK: ($0): (0)
+QUERY: SELECT 0 + 0
+BLOCK: ($0): (0)
+QUERY: SELECT 1
+BLOCK: ($0): (1)
+QUERY: SELECT 0 + 1
+BLOCK: ($0): (1)
+QUERY: SELECT 2
+BLOCK: ($0): (2)
+QUERY: SELECT 1 + 2
+BLOCK: ($0): (3)
+QUERY: SELECT 3
+BLOCK: ($0): (3)
+---------- Output ---------
+Some(Var(UInt64(3)))
+
+
 ---------- Input ----------
 LET x := 1;
 WHILE x < 3 DO
@@ -267,6 +427,56 @@ BLOCK: ($0): (3)
 Some(Var(UInt64(3)))
 
 
+---------- Input ----------
+LET x := 1;
+REPEAT
+    x := x + 1;
+    LET y := 3;
+UNTIL x = y
+END REPEAT;
+RETURN x;
+---------- IR -------------
+QUERY SELECT 1, __expr_result1(1)
+ITER __expr_result1(1), __expr_result_iter2(2)
+READ __expr_result_iter2(2), $0, x(0)
+__LOOP3(3):
+QUERY SELECT :0 + 1, __expr_result5(5)
+ITER __expr_result5(5), __expr_result_iter6(6)
+READ __expr_result_iter6(6), $0, x(0)
+QUERY SELECT 3, __expr_result8(8)
+ITER __expr_result8(8), __expr_result_iter9(9)
+READ __expr_result_iter9(9), $0, y(7)
+QUERY SELECT is_true(:0 = :7), __expr_result11(11)
+ITER __expr_result11(11), __expr_result_iter12(12)
+READ __expr_result_iter12(12), $0, __break_condition10(10)
+JUMP_IF_TRUE __break_condition10(10), __LOOP_END4(4)
+GOTO __LOOP3(3)
+__LOOP_END4(4):
+QUERY SELECT :0, __expr_result14(14)
+ITER __expr_result14(14), __expr_result_iter15(15)
+READ __expr_result_iter15(15), $0, __return_val13(13)
+RETURN __return_val13(13)
+---------- QUERY ---------
+QUERY: SELECT 1
+BLOCK: ($0): (1)
+QUERY: SELECT 1 + 1
+BLOCK: ($0): (2)
+QUERY: SELECT 3
+BLOCK: ($0): (3)
+QUERY: SELECT is_true(2 = 3)
+BLOCK: ($0): (FALSE)
+QUERY: SELECT 2 + 1
+BLOCK: ($0): (3)
+QUERY: SELECT 3
+BLOCK: ($0): (3)
+QUERY: SELECT is_true(3 = 3)
+BLOCK: ($0): (TRUE)
+QUERY: SELECT 3
+BLOCK: ($0): (3)
+---------- Output ---------
+Some(Var(UInt64(3)))
+
+
 ---------- Input ----------
 LOOP
     LET x := 0;
diff --git a/src/query/service/Cargo.toml b/src/query/service/Cargo.toml
index c2a0fb73c02c..273971cf9101 100644
--- a/src/query/service/Cargo.toml
+++ b/src/query/service/Cargo.toml
@@ -50,6 +50,7 @@ databend-common-io = { path = "../../common/io" }
 databend-common-management = { path = "../management" }
 databend-common-meta-api = { path = "../../meta/api" }
 databend-common-meta-app = { path = "../../meta/app" }
+databend-common-script = { path = "../script" }
 
 databend-common-cloud-control = { path = "../../common/cloud_control" }
 databend-common-license = { path = "../../common/license" }
diff --git a/src/query/service/src/interpreters/access/privilege_access.rs b/src/query/service/src/interpreters/access/privilege_access.rs
index e5dfa3f79252..0e0ffcf18bf2 100644
--- a/src/query/service/src/interpreters/access/privilege_access.rs
+++ b/src/query/service/src/interpreters/access/privilege_access.rs
@@ -1076,6 +1076,7 @@ impl AccessChecker for PrivilegeAccess {
             Plan::Begin => {}
             Plan::Commit => {}
             Plan::Abort => {}
+            Plan::ExecuteImmediate(_) => {}
         }
 
         Ok(())
diff --git a/src/query/service/src/interpreters/interpreter_execute_immediate.rs b/src/query/service/src/interpreters/interpreter_execute_immediate.rs
new file mode 100644
index 000000000000..a25ba27c2d11
--- /dev/null
+++ b/src/query/service/src/interpreters/interpreter_execute_immediate.rs
@@ -0,0 +1,425 @@
+// Copyright 2021 Datafuse Labs
+//
+// 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
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use std::sync::Arc;
+
+use databend_common_ast::ast::DeclareItem;
+use databend_common_ast::ast::Expr;
+use databend_common_ast::ast::FunctionCall;
+use databend_common_ast::ast::Identifier;
+use databend_common_ast::ast::Literal;
+use databend_common_ast::ast::ScriptStatement;
+use databend_common_ast::ast::TypeName;
+use databend_common_ast::parser::run_parser;
+use databend_common_ast::parser::script::script_block;
+use databend_common_ast::parser::tokenize_sql;
+use databend_common_ast::parser::ParseMode;
+use databend_common_exception::ErrorCode;
+use databend_common_exception::Result;
+use databend_common_expression::block_debug::box_render;
+use databend_common_expression::types::decimal::DecimalScalar;
+use databend_common_expression::types::decimal::MAX_DECIMAL256_PRECISION;
+use databend_common_expression::types::NumberScalar;
+use databend_common_expression::types::StringType;
+use databend_common_expression::with_integer_mapped_type;
+use databend_common_expression::DataBlock;
+use databend_common_expression::DataSchemaRef;
+use databend_common_expression::FromData;
+use databend_common_expression::Scalar;
+use databend_common_script::compile;
+use databend_common_script::ir::ColumnAccess;
+use databend_common_script::Client;
+use databend_common_script::Executor;
+use databend_common_script::ReturnValue;
+use databend_common_sql::plans::ExecuteImmediatePlan;
+use databend_common_sql::Planner;
+use databend_common_storages_fuse::TableContext;
+use futures::TryStreamExt;
+use itertools::Itertools;
+use serde_json::Value as JsonValue;
+
+use crate::interpreters::Interpreter;
+use crate::interpreters::InterpreterFactory;
+use crate::pipelines::PipelineBuildResult;
+use crate::sessions::QueryContext;
+
+#[derive(Debug)]
+pub struct ExecuteImmediateInterpreter {
+    ctx: Arc<QueryContext>,
+    plan: ExecuteImmediatePlan,
+}
+
+impl ExecuteImmediateInterpreter {
+    pub fn try_create(ctx: Arc<QueryContext>, plan: ExecuteImmediatePlan) -> Result<Self> {
+        Ok(ExecuteImmediateInterpreter { ctx, plan })
+    }
+}
+
+#[async_trait::async_trait]
+impl Interpreter for ExecuteImmediateInterpreter {
+    fn name(&self) -> &str {
+        "ExecuteImmediateInterpreter"
+    }
+
+    fn is_ddl(&self) -> bool {
+        false
+    }
+
+    #[minitrace::trace]
+    #[async_backtrace::framed]
+    async fn execute2(&self) -> Result<PipelineBuildResult> {
+        let res: Result<_> = try {
+            let dialect = self.ctx.get_settings().get_sql_dialect()?;
+            let tokens = tokenize_sql(&self.plan.script)?;
+            let mut ast = run_parser(&tokens, dialect, ParseMode::Template, false, script_block)?;
+
+            let mut src = vec![];
+            for declare in ast.declares {
+                match declare {
+                    DeclareItem::Var(declare) => src.push(ScriptStatement::LetVar { declare }),
+                    DeclareItem::Set(declare) => {
+                        src.push(ScriptStatement::LetStatement { declare })
+                    }
+                }
+            }
+            src.append(&mut ast.body);
+            let compiled = compile(&src)?;
+
+            let client = ScriptClient {
+                ctx: self.ctx.clone(),
+            };
+            let mut executor = Executor::load(ast.span, client, compiled);
+            let result = executor.run(/* TODO(andylokandy) */ 1000).await?;
+
+            match result {
+                Some(ReturnValue::Var(scalar)) => {
+                    PipelineBuildResult::from_blocks(vec![DataBlock::new_from_columns(vec![
+                        StringType::from_data(vec![scalar.to_string()]),
+                    ])])?
+                }
+                Some(ReturnValue::Set(set)) => {
+                    let rendered_table = box_render(
+                        &set.schema,
+                        &[set.block.clone()],
+                        usize::MAX,
+                        usize::MAX,
+                        usize::MAX,
+                        true,
+                    )?;
+                    let lines = rendered_table.lines().map(|x| x.to_string()).collect();
+                    PipelineBuildResult::from_blocks(vec![DataBlock::new_from_columns(vec![
+                        StringType::from_data(lines),
+                    ])])?
+                }
+                None => PipelineBuildResult::from_blocks(vec![DataBlock::new_from_columns(vec![
+                    StringType::from_data(Vec::<String>::new()),
+                ])])?,
+            }
+        };
+
+        res.map_err(|err| err.display_with_sql(&self.plan.script))
+    }
+}
+
+#[derive(Debug, Clone)]
+struct QueryResult {
+    schema: DataSchemaRef,
+    block: DataBlock,
+}
+
+struct ScriptClient {
+    ctx: Arc<QueryContext>,
+}
+
+impl Client for ScriptClient {
+    type Var = Scalar;
+    type Set = QueryResult;
+
+    async fn query(&self, query: &str) -> Result<Self::Set> {
+        let ctx = self
+            .ctx
+            .get_current_session()
+            .create_query_context()
+            .await?;
+
+        let mut planner = Planner::new(ctx.clone());
+        let (plan, _) = planner.plan_sql(query).await?;
+        let interpreter = InterpreterFactory::get(ctx.clone(), &plan).await?;
+        let stream = interpreter.execute(ctx.clone()).await?;
+        let blocks = stream.try_collect::<Vec<_>>().await?;
+        let schema = plan.schema();
+
+        let block = match blocks.len() {
+            0 => DataBlock::empty_with_schema(schema.clone()),
+            1 => blocks[0].clone(),
+            _ => DataBlock::concat(&blocks)?,
+        };
+
+        Ok(QueryResult { schema, block })
+    }
+
+    fn var_to_ast(&self, scalar: &Self::Var) -> Result<Expr> {
+        let ast = match scalar {
+            Scalar::Number(v) => with_integer_mapped_type!(|NUM_TYPE| match v {
+                NumberScalar::NUM_TYPE(v) => Expr::Literal {
+                    span: None,
+                    value: Literal::Decimal256 {
+                        value: (*v).into(),
+                        precision: MAX_DECIMAL256_PRECISION,
+                        scale: 0,
+                    },
+                },
+                NumberScalar::Float32(v) => Expr::Literal {
+                    span: None,
+                    value: Literal::Float64(v.into_inner() as f64),
+                },
+                NumberScalar::Float64(v) => Expr::Literal {
+                    span: None,
+                    value: Literal::Float64(v.into_inner()),
+                },
+            }),
+            Scalar::Boolean(v) => Expr::Literal {
+                span: None,
+                value: Literal::Boolean(*v),
+            },
+            Scalar::String(v) => Expr::Literal {
+                span: None,
+                value: Literal::String(v.clone()),
+            },
+            Scalar::Tuple(v) => Expr::FunctionCall {
+                span: None,
+                func: FunctionCall {
+                    distinct: false,
+                    name: Identifier::from_name(None, "tuple"),
+                    args: v
+                        .iter()
+                        .map(|x| self.var_to_ast(&x.to_owned()))
+                        .collect::<Result<Vec<_>>>()?,
+                    params: vec![],
+                    window: None,
+                    lambda: None,
+                },
+            },
+            Scalar::Array(v) => Expr::FunctionCall {
+                span: None,
+                func: FunctionCall {
+                    distinct: false,
+                    name: Identifier::from_name(None, "array"),
+                    args: v
+                        .iter()
+                        .map(|x| self.var_to_ast(&x.to_owned()))
+                        .collect::<Result<Vec<_>>>()?,
+                    params: vec![],
+                    window: None,
+                    lambda: None,
+                },
+            },
+            Scalar::Decimal(DecimalScalar::Decimal128(v, size)) => Expr::Literal {
+                span: None,
+                value: Literal::Decimal256 {
+                    value: (*v).into(),
+                    precision: size.precision,
+                    scale: size.scale,
+                },
+            },
+            Scalar::Decimal(DecimalScalar::Decimal256(v, size)) => Expr::Literal {
+                span: None,
+                value: Literal::Decimal256 {
+                    value: *v,
+                    precision: size.precision,
+                    scale: size.scale,
+                },
+            },
+            Scalar::Map(v) => {
+                let col = v.as_tuple().unwrap();
+                let keys = col[0]
+                    .iter()
+                    .map(|x| self.var_to_ast(&x.to_owned()))
+                    .collect::<Result<Vec<_>>>()?;
+                let vals = col[1]
+                    .iter()
+                    .map(|x| self.var_to_ast(&x.to_owned()))
+                    .collect::<Result<Vec<_>>>()?;
+                Expr::FunctionCall {
+                    span: None,
+                    func: FunctionCall {
+                        distinct: false,
+                        name: Identifier::from_name(None, "map"),
+                        args: vec![
+                            Expr::FunctionCall {
+                                span: None,
+                                func: FunctionCall {
+                                    distinct: false,
+                                    name: Identifier::from_name(None, "array"),
+                                    args: keys,
+                                    params: vec![],
+                                    window: None,
+                                    lambda: None,
+                                },
+                            },
+                            Expr::FunctionCall {
+                                span: None,
+                                func: FunctionCall {
+                                    distinct: false,
+                                    name: Identifier::from_name(None, "array"),
+                                    args: vals,
+                                    params: vec![],
+                                    window: None,
+                                    lambda: None,
+                                },
+                            },
+                        ],
+                        params: vec![],
+                        window: None,
+                        lambda: None,
+                    },
+                }
+            }
+            Scalar::Variant(v) => {
+                let value = jsonb::from_slice(v).unwrap();
+                let json = JsonValue::from(value).to_string();
+                Expr::FunctionCall {
+                    span: None,
+                    func: FunctionCall {
+                        distinct: false,
+                        name: Identifier::from_name(None, "parse_json"),
+                        args: vec![Expr::Literal {
+                            span: None,
+                            value: Literal::String(json),
+                        }],
+                        params: vec![],
+                        window: None,
+                        lambda: None,
+                    },
+                }
+            }
+            Scalar::EmptyArray => Expr::FunctionCall {
+                span: None,
+                func: FunctionCall {
+                    distinct: false,
+                    name: Identifier::from_name(None, "array"),
+                    args: vec![],
+                    params: vec![],
+                    window: None,
+                    lambda: None,
+                },
+            },
+            Scalar::EmptyMap => Expr::FunctionCall {
+                span: None,
+                func: FunctionCall {
+                    distinct: false,
+                    name: Identifier::from_name(None, "map"),
+                    args: vec![],
+                    params: vec![],
+                    window: None,
+                    lambda: None,
+                },
+            },
+            Scalar::Date(v) => Expr::Cast {
+                span: None,
+                expr: Box::new(Expr::Literal {
+                    span: None,
+                    value: Literal::Decimal256 {
+                        value: (*v).into(),
+                        precision: MAX_DECIMAL256_PRECISION,
+                        scale: 0,
+                    },
+                }),
+                target_type: TypeName::Date,
+                pg_style: false,
+            },
+            Scalar::Timestamp(v) => Expr::Cast {
+                span: None,
+                expr: Box::new(Expr::Literal {
+                    span: None,
+                    value: Literal::Decimal256 {
+                        value: (*v).into(),
+                        precision: MAX_DECIMAL256_PRECISION,
+                        scale: 0,
+                    },
+                }),
+                target_type: TypeName::Timestamp,
+                pg_style: false,
+            },
+            Scalar::Null => Expr::Literal {
+                span: None,
+                value: Literal::Null,
+            },
+            Scalar::Bitmap(_) | Scalar::Binary(_) | Scalar::Geometry(_) => {
+                return Err(ErrorCode::Unimplemented(format!(
+                    "variable of type {} is not supported yet",
+                    scalar.as_ref().infer_data_type()
+                )));
+            }
+        };
+
+        Ok(ast)
+    }
+
+    fn read_from_set(&self, set: &Self::Set, row: usize, col: &ColumnAccess) -> Result<Self::Var> {
+        let offset = match col {
+            ColumnAccess::Position(offset) => *offset,
+            // TODO(andylokandy): name resolution
+            ColumnAccess::Name(name) => set
+                .schema
+                .fields()
+                .iter()
+                .position(|f| f.name() == name)
+                .ok_or_else(|| {
+                ErrorCode::ScriptExecutionError(format!(
+                    "cannot find column with name {} in block, available columns: {}",
+                    name,
+                    set.schema
+                        .fields()
+                        .iter()
+                        .map(|f| format!("'{}'", f.name()))
+                        .join(", ")
+                ))
+            })?,
+        };
+        let col = set.block.columns().get(offset).ok_or_else(|| {
+            ErrorCode::ScriptExecutionError(format!(
+                "cannot read column at offset {} from block with {} columns",
+                offset,
+                set.block.num_columns()
+            ))
+        })?;
+        let cell = col
+            .value
+            .index(row)
+            .ok_or_else(|| {
+                ErrorCode::ScriptExecutionError(format!(
+                    "cannot read value at row {} from column with {} rows",
+                    row,
+                    set.block.num_rows(),
+                ))
+            })?
+            .to_owned();
+
+        Ok(cell)
+    }
+
+    fn set_len(&self, set: &Self::Set) -> usize {
+        set.block.num_rows()
+    }
+
+    fn is_true(&self, scalar: &Self::Var) -> Result<bool> {
+        match scalar {
+            Scalar::Boolean(v) => Ok(*v),
+            _ => Err(ErrorCode::ScriptExecutionError(format!(
+                "`is_true` called on non-boolean value {scalar}",
+            ))),
+        }
+    }
+}
diff --git a/src/query/service/src/interpreters/interpreter_factory.rs b/src/query/service/src/interpreters/interpreter_factory.rs
index 7aec3fee1f83..d3f0bbfe0f8a 100644
--- a/src/query/service/src/interpreters/interpreter_factory.rs
+++ b/src/query/service/src/interpreters/interpreter_factory.rs
@@ -577,6 +577,10 @@ impl InterpreterFactory {
             Plan::InsertMultiTable(p) => {
                 Ok(InsertMultiTableInterpreter::try_create(ctx, *p.clone())?)
             }
+            Plan::ExecuteImmediate(p) => Ok(Arc::new(ExecuteImmediateInterpreter::try_create(
+                ctx,
+                *p.clone(),
+            )?)),
         }
     }
 }
diff --git a/src/query/service/src/interpreters/mod.rs b/src/query/service/src/interpreters/mod.rs
index 83438e5b4bfc..a7499cd365c9 100644
--- a/src/query/service/src/interpreters/mod.rs
+++ b/src/query/service/src/interpreters/mod.rs
@@ -37,6 +37,7 @@ mod interpreter_database_rename;
 mod interpreter_database_show_create;
 mod interpreter_database_undrop;
 mod interpreter_delete;
+mod interpreter_execute_immediate;
 mod interpreter_explain;
 mod interpreter_factory;
 mod interpreter_file_format_create;
@@ -163,6 +164,7 @@ pub use interpreter_database_rename::RenameDatabaseInterpreter;
 pub use interpreter_database_show_create::ShowCreateDatabaseInterpreter;
 pub use interpreter_database_undrop::UndropDatabaseInterpreter;
 pub use interpreter_delete::DeleteInterpreter;
+pub use interpreter_execute_immediate::ExecuteImmediateInterpreter;
 pub use interpreter_explain::ExplainInterpreter;
 pub use interpreter_factory::InterpreterFactory;
 pub use interpreter_index_refresh::RefreshIndexInterpreter;
diff --git a/src/query/service/src/table_functions/srf/range.rs b/src/query/service/src/table_functions/srf/range.rs
index f84094cbd6d1..3568b667bb25 100644
--- a/src/query/service/src/table_functions/srf/range.rs
+++ b/src/query/service/src/table_functions/srf/range.rs
@@ -268,10 +268,15 @@ impl<const INCLUSIVE: bool> RangeSource<INCLUSIVE> {
             }
         }
 
-        if (step == 0) || ((step > 0) ^ (start < end)) {
+        if step == 0 {
+            return Err(ErrorCode::BadArguments("step must not be zero".to_string()));
+        } else if step > 0 && start > end {
             return Err(ErrorCode::BadArguments(
-                "start must be less than or equal to end when step is positive vice versa"
-                    .to_string(),
+                "start must be less than or equal to end when step is positive".to_string(),
+            ));
+        } else if step < 0 && start < end {
+            return Err(ErrorCode::BadArguments(
+                "start must be greater than or equal to end when step is negative".to_string(),
             ));
         }
 
diff --git a/src/query/sql/src/planner/binder/binder.rs b/src/query/sql/src/planner/binder/binder.rs
index 5671ff151af9..8d594ae683b4 100644
--- a/src/query/sql/src/planner/binder/binder.rs
+++ b/src/query/sql/src/planner/binder/binder.rs
@@ -641,6 +641,7 @@ impl<'a> Binder {
             Statement::Begin => Plan::Begin,
             Statement::Commit => Plan::Commit,
             Statement::Abort => Plan::Abort,
+            Statement::ExecuteImmediate(stmt) => self.bind_execute_immediate(stmt).await?
         };
         Ok(plan)
     }
diff --git a/src/query/sql/src/planner/binder/ddl/mod.rs b/src/query/sql/src/planner/binder/ddl/mod.rs
index f28d93791688..481c209c1bda 100644
--- a/src/query/sql/src/planner/binder/ddl/mod.rs
+++ b/src/query/sql/src/planner/binder/ddl/mod.rs
@@ -22,6 +22,7 @@ mod index;
 mod network_policy;
 mod notification;
 mod password_policy;
+mod procedure;
 mod role;
 mod share;
 mod stage;
diff --git a/src/query/sql/src/planner/binder/ddl/procedure.rs b/src/query/sql/src/planner/binder/ddl/procedure.rs
new file mode 100644
index 000000000000..5bc5bdf680ad
--- /dev/null
+++ b/src/query/sql/src/planner/binder/ddl/procedure.rs
@@ -0,0 +1,33 @@
+// Copyright 2021 Datafuse Labs
+//
+// 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
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use databend_common_ast::ast::ExecuteImmediateStmt;
+use databend_common_exception::Result;
+
+use crate::plans::ExecuteImmediatePlan;
+use crate::plans::Plan;
+use crate::Binder;
+
+impl Binder {
+    #[async_backtrace::framed]
+    pub(in crate::planner::binder) async fn bind_execute_immediate(
+        &mut self,
+        stmt: &ExecuteImmediateStmt,
+    ) -> Result<Plan> {
+        let ExecuteImmediateStmt { script } = stmt;
+        Ok(Plan::ExecuteImmediate(Box::new(ExecuteImmediatePlan {
+            script: script.clone(),
+        })))
+    }
+}
diff --git a/src/query/sql/src/planner/format/display_plan.rs b/src/query/sql/src/planner/format/display_plan.rs
index 758143262358..b6270c4e904c 100644
--- a/src/query/sql/src/planner/format/display_plan.rs
+++ b/src/query/sql/src/planner/format/display_plan.rs
@@ -214,6 +214,9 @@ impl Plan {
             Plan::DropNotification(_) => Ok("DropNotification".to_string()),
             Plan::DescNotification(_) => Ok("DescNotification".to_string()),
             Plan::AlterNotification(_) => Ok("AlterNotification".to_string()),
+
+            // Stored procedures
+            Plan::ExecuteImmediate(_) => Ok("ExecuteImmediate".to_string()),
         }
     }
 }
diff --git a/src/query/sql/src/planner/plans/ddl/mod.rs b/src/query/sql/src/planner/plans/ddl/mod.rs
index 407db9be34af..56c06ab56bea 100644
--- a/src/query/sql/src/planner/plans/ddl/mod.rs
+++ b/src/query/sql/src/planner/plans/ddl/mod.rs
@@ -19,6 +19,7 @@ mod database;
 mod file_format;
 mod index;
 mod notification;
+mod procedure;
 mod stage;
 mod stream;
 mod table;
@@ -34,6 +35,7 @@ pub use database::*;
 pub use file_format::*;
 pub use index::*;
 pub use notification::*;
+pub use procedure::*;
 pub use stage::*;
 pub use stream::*;
 pub use table::*;
diff --git a/src/query/sql/src/planner/plans/ddl/procedure.rs b/src/query/sql/src/planner/plans/ddl/procedure.rs
new file mode 100644
index 000000000000..8b26fd7c3e06
--- /dev/null
+++ b/src/query/sql/src/planner/plans/ddl/procedure.rs
@@ -0,0 +1,29 @@
+// Copyright 2021 Datafuse Labs
+//
+// 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
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use databend_common_expression::types::DataType;
+use databend_common_expression::DataField;
+use databend_common_expression::DataSchemaRef;
+use databend_common_expression::DataSchemaRefExt;
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct ExecuteImmediatePlan {
+    pub script: String,
+}
+
+impl ExecuteImmediatePlan {
+    pub fn schema(&self) -> DataSchemaRef {
+        DataSchemaRefExt::create(vec![DataField::new("Result", DataType::String)])
+    }
+}
diff --git a/src/query/sql/src/planner/plans/plan.rs b/src/query/sql/src/planner/plans/plan.rs
index 653c9790826d..7c0ded656b4f 100644
--- a/src/query/sql/src/planner/plans/plan.rs
+++ b/src/query/sql/src/planner/plans/plan.rs
@@ -24,7 +24,6 @@ use databend_common_expression::DataSchema;
 use databend_common_expression::DataSchemaRef;
 use databend_common_expression::DataSchemaRefExt;
 
-use super::SetSecondaryRolesPlan;
 use crate::binder::ExplainConfig;
 use crate::optimizer::SExpr;
 use crate::plans::copy_into_location::CopyIntoLocationPlan;
@@ -96,6 +95,7 @@ use crate::plans::DropUDFPlan;
 use crate::plans::DropUserPlan;
 use crate::plans::DropViewPlan;
 use crate::plans::DropVirtualColumnPlan;
+use crate::plans::ExecuteImmediatePlan;
 use crate::plans::ExecuteTaskPlan;
 use crate::plans::ExistsTablePlan;
 use crate::plans::GrantPrivilegePlan;
@@ -123,6 +123,7 @@ use crate::plans::RevokeRolePlan;
 use crate::plans::RevokeShareObjectPlan;
 use crate::plans::SetOptionsPlan;
 use crate::plans::SetRolePlan;
+use crate::plans::SetSecondaryRolesPlan;
 use crate::plans::SettingPlan;
 use crate::plans::ShowConnectionsPlan;
 use crate::plans::ShowCreateCatalogPlan;
@@ -348,6 +349,9 @@ pub enum Plan {
     AlterNotification(Box<AlterNotificationPlan>),
     DropNotification(Box<DropNotificationPlan>),
     DescNotification(Box<DescNotificationPlan>),
+
+    // Stored procedures
+    ExecuteImmediate(Box<ExecuteImmediatePlan>),
 }
 
 #[derive(Clone, Debug)]
@@ -439,10 +443,8 @@ impl Plan {
             Plan::ShowRoles(plan) => plan.schema(),
             Plan::ShowGrants(plan) => plan.schema(),
             Plan::ShowFileFormats(plan) => plan.schema(),
-
             Plan::Insert(plan) => plan.schema(),
             Plan::Replace(plan) => plan.schema(),
-
             Plan::Presign(plan) => plan.schema(),
             Plan::ShowShareEndpoint(plan) => plan.schema(),
             Plan::DescShare(plan) => plan.schema(),
@@ -464,6 +466,7 @@ impl Plan {
             Plan::DescNotification(plan) => plan.schema(),
             Plan::DescConnection(plan) => plan.schema(),
             Plan::ShowConnections(plan) => plan.schema(),
+            Plan::ExecuteImmediate(plan) => plan.schema(),
             Plan::InsertMultiTable(plan) => plan.schema(),
 
             other => {
@@ -507,6 +510,7 @@ impl Plan {
                 | Plan::DescConnection(_)
                 | Plan::ShowConnections(_)
                 | Plan::MergeInto(_)
+                | Plan::ExecuteImmediate(_)
                 | Plan::InsertMultiTable(_)
         )
     }
diff --git a/src/query/storages/information_schema/src/columns_table.rs b/src/query/storages/information_schema/src/columns_table.rs
index b531365c22d8..33a8afcda616 100644
--- a/src/query/storages/information_schema/src/columns_table.rs
+++ b/src/query/storages/information_schema/src/columns_table.rs
@@ -29,7 +29,7 @@ impl ColumnsTable {
         let query = "SELECT
             database AS table_catalog,
             database AS table_schema,
-            table AS table_name,
+            \"table\" AS table_name,
             name AS column_name,
             1 AS ordinal_position,
             NULL AS column_default,
diff --git a/src/tests/sqlsmith/src/runner.rs b/src/tests/sqlsmith/src/runner.rs
index f42eb11bd7b6..dcb50c145fa6 100644
--- a/src/tests/sqlsmith/src/runner.rs
+++ b/src/tests/sqlsmith/src/runner.rs
@@ -38,7 +38,7 @@ use crate::reducer::try_reduce_query;
 use crate::sql_gen::SqlGenerator;
 use crate::sql_gen::Table;
 
-const KNOWN_ERRORS: [&str; 31] = [
+const KNOWN_ERRORS: &[&str] = &[
     // Errors caused by illegal parameters
     "Overflow on date YMD",
     "timestamp is out of range",
@@ -68,7 +68,9 @@ const KNOWN_ERRORS: [&str; 31] = [
     "The arguments of AggregateRetention should be an expression which returns a Boolean result",
     "AggregateWindowFunnelFunction does not support type",
     "nth_value should count from 1",
-    "start must be less than or equal to end when step is positive vice versa",
+    "step must not be zero",
+    "start must be less than or equal to end when step is positive",
+    "start must be greater than or equal to end when step is negative",
     "Expected Number, Date or Timestamp type, but got",
     "Unsupported data type for generate_series",
     "Having clause can't contain window functions",
diff --git a/tests/sqllogictests/suites/base/05_ddl/05_0033_ddl_connection.test b/tests/sqllogictests/suites/base/05_ddl/05_0033_ddl_connection.test
index 0976ddf294f0..99f2736a3ba7 100644
--- a/tests/sqllogictests/suites/base/05_ddl/05_0033_ddl_connection.test
+++ b/tests/sqllogictests/suites/base/05_ddl/05_0033_ddl_connection.test
@@ -4,7 +4,7 @@ DROP CONNECTION IF EXISTS test_conn
 statement error 2510.*Connection 'test_conn' does not exist.
 DROP CONNECTION test_conn
 
-statement error (?s)1005.*unexpected end of line
+statement error (?s)1005.*unexpected end of input
 CREATE CONNECTION test_conn
 
 statement error 1005
diff --git a/tests/sqllogictests/suites/base/15_procedure/15_0001_execute_immediate.test b/tests/sqllogictests/suites/base/15_procedure/15_0001_execute_immediate.test
new file mode 100644
index 000000000000..64e161536d9d
--- /dev/null
+++ b/tests/sqllogictests/suites/base/15_procedure/15_0001_execute_immediate.test
@@ -0,0 +1,133 @@
+statement ok
+create or replace database test_procedure;
+
+statement ok
+use test_procedure;
+
+query I
+EXECUTE IMMEDIATE $$
+BEGIN
+    RETURN;
+END;
+$$;
+----
+
+query I
+EXECUTE IMMEDIATE $$
+BEGIN
+    LET x := -1;
+    LET sum := 0;
+    FOR x IN x TO x + 3 DO
+        sum := sum + x;
+    END FOR;
+    RETURN sum;
+END;
+$$;
+----
+2
+
+
+query I
+EXECUTE IMMEDIATE $$
+BEGIN
+    LET sum := 0;
+    FOR x IN SELECT * FROM numbers(100) DO
+        sum := sum + x.number;
+    END FOR;
+    RETURN sum;
+END;
+$$;
+----
+4950
+
+query I
+EXECUTE IMMEDIATE $$
+BEGIN
+    LET x RESULTSET := SELECT * FROM numbers(100);
+    LET sum := 0;
+    FOR x IN x DO
+        sum := sum + x.number;
+    END FOR;
+    RETURN sum;
+END;
+$$;
+----
+4950
+
+query error start must be less than or equal to end when step is positive
+EXECUTE IMMEDIATE $$
+BEGIN
+    FOR x IN 1 TO -1 DO
+        RETURN x;
+    END FOR;
+END;
+$$;
+
+query I
+EXECUTE IMMEDIATE $$
+BEGIN
+    CREATE OR REPLACE TABLE t1 (a INT, b FLOAT, c STRING);
+    INSERT INTO t1 VALUES (1, 2.0, '3');
+    RETURN TABLE(select * from t1);
+END;
+$$;
+----
+┌─────────────────────────────────────────┐
+│      a     │       b      │      c      │
+│ Int32 NULL │ Float32 NULL │ String NULL │
+├────────────┼──────────────┼─────────────┤
+│ 1          │ 2            │ '3'         │
+└─────────────────────────────────────────┘
+
+query I
+EXECUTE IMMEDIATE $$
+BEGIN
+    LET x := 1;
+    LET y := x + 1;
+    LET z RESULTSET := SELECT :y + 1;
+    RETURN TABLE(z);
+END;
+$$;
+----
+┌───────┐
+│ 2 + 1 │
+│ UInt8 │
+├───────┤
+│     3 │
+└───────┘
+
+query I
+EXECUTE IMMEDIATE $$
+BEGIN
+    LET x := 1;
+    RETURN TABLE(SELECT :x + 1);
+END;
+$$;
+----
+┌───────┐
+│ 1 + 1 │
+│ UInt8 │
+├───────┤
+│     2 │
+└───────┘
+
+query error divided by zero
+EXECUTE IMMEDIATE $$
+BEGIN
+    SELECT 0 / 0;
+END;
+$$;
+----
+
+
+query error divided by zero
+EXECUTE IMMEDIATE $$
+BEGIN
+    RETURN 0 / 0;
+END;
+$$;
+----
+
+
+statement ok
+drop database test_procedure;