feat: adds parse options for SQL parser (#3193)

* feat: adds parse options for parser and timezone to scan request * chore: remove timezone in ScanRequest * feat: remove timezone in parse options and adds type checking to parititon columns * fix: comment * chore: apply suggestions Co-authored-by: Yingwen <realevenyag@gmail.com> * fix: format --------- Co-authored-by: Yingwen <realevenyag@gmail.com>
2026-05-29 19:30:37 +00:00 · 2024-01-19 17:16:36 +08:00
parent 632edd05e5
commit 5e89472b2e
49 changed files with 617 additions and 248 deletions
--- a/src/sql/src/parser.rs
+++ b/src/sql/src/parser.rs
@@ -25,6 +25,10 @@ use crate::parsers::tql_parser;
 use crate::statements::statement::Statement;
 use crate::statements::transform_statements;

+/// SQL Parser options.
+#[derive(Clone, Debug, Default)]
+pub struct ParseOptions {}
+
 /// GrepTime SQL parser context, a simple wrapper for Datafusion SQL parser.
 pub struct ParserContext<'a> {
    pub(crate) parser: Parser<'a>,
@@ -33,7 +37,11 @@ pub struct ParserContext<'a> {

 impl<'a> ParserContext<'a> {
    /// Parses SQL with given dialect
-    pub fn create_with_dialect(sql: &'a str, dialect: &dyn Dialect) -> Result<Vec<Statement>> {
+    pub fn create_with_dialect(
+        sql: &'a str,
+        dialect: &dyn Dialect,
+        _opts: ParseOptions,
+    ) -> Result<Vec<Statement>> {
        let mut stmts: Vec<Statement> = Vec::new();

        let parser = Parser::new(dialect)
@@ -207,10 +215,14 @@ mod tests {
    use crate::statements::sql_data_type_to_concrete_data_type;

    fn test_timestamp_precision(sql: &str, expected_type: ConcreteDataType) {
-        match ParserContext::create_with_dialect(sql, &GreptimeDbDialect {})
-            .unwrap()
-            .pop()
-            .unwrap()
+        match ParserContext::create_with_dialect(
+            sql,
+            &GreptimeDbDialect {},
+            ParseOptions::default(),
+        )
+        .unwrap()
+        .pop()
+        .unwrap()
        {
            Statement::CreateTable(CreateTable { columns, .. }) => {
                let ts_col = columns.first().unwrap();
--- a/src/sql/src/parsers/alter_parser.rs
+++ b/src/sql/src/parsers/alter_parser.rs
@@ -104,11 +104,14 @@ mod tests {

    use super::*;
    use crate::dialect::GreptimeDbDialect;
+    use crate::parser::ParseOptions;

    #[test]
    fn test_parse_alter_add_column() {
        let sql = "ALTER TABLE my_metric_1 ADD tagk_i STRING Null;";
-        let mut result = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}).unwrap();
+        let mut result =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default())
+                .unwrap();
        assert_eq!(1, result.len());

        let statement = result.remove(0);
@@ -142,7 +145,9 @@ mod tests {
    #[test]
    fn test_parse_alter_add_column_with_first() {
        let sql = "ALTER TABLE my_metric_1 ADD tagk_i STRING Null FIRST;";
-        let mut result = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}).unwrap();
+        let mut result =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default())
+                .unwrap();
        assert_eq!(1, result.len());

        let statement = result.remove(0);
@@ -176,7 +181,9 @@ mod tests {
    #[test]
    fn test_parse_alter_add_column_with_after() {
        let sql = "ALTER TABLE my_metric_1 ADD tagk_i STRING Null AFTER ts;";
-        let mut result = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}).unwrap();
+        let mut result =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default())
+                .unwrap();
        assert_eq!(1, result.len());

        let statement = result.remove(0);
@@ -215,12 +222,16 @@ mod tests {
    #[test]
    fn test_parse_alter_drop_column() {
        let sql = "ALTER TABLE my_metric_1 DROP a";
-        let result = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}).unwrap_err();
+        let result =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default())
+                .unwrap_err();
        let err = result.output_msg();
        assert!(err.contains("expect keyword COLUMN after ALTER TABLE DROP"));

        let sql = "ALTER TABLE my_metric_1 DROP COLUMN a";
-        let mut result = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}).unwrap();
+        let mut result =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default())
+                .unwrap();
        assert_eq!(1, result.len());

        let statement = result.remove(0);
@@ -245,12 +256,16 @@ mod tests {
    #[test]
    fn test_parse_alter_rename_table() {
        let sql = "ALTER TABLE test_table table_t";
-        let result = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}).unwrap_err();
+        let result =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default())
+                .unwrap_err();
        let err = result.output_msg();
        assert!(err.contains("expect keyword ADD or DROP or RENAME after ALTER TABLE"));

        let sql = "ALTER TABLE test_table RENAME table_t";
-        let mut result = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}).unwrap();
+        let mut result =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default())
+                .unwrap();
        assert_eq!(1, result.len());

        let statement = result.remove(0);
--- a/src/sql/src/parsers/copy_parser.rs
+++ b/src/sql/src/parsers/copy_parser.rs
@@ -185,14 +185,25 @@ mod tests {

    use super::*;
    use crate::dialect::GreptimeDbDialect;
+    use crate::parser::ParseOptions;
    use crate::statements::statement::Statement::Copy;

    #[test]
    fn test_parse_copy_table() {
        let sql0 = "COPY catalog0.schema0.tbl TO 'tbl_file.parquet'";
        let sql1 = "COPY catalog0.schema0.tbl TO 'tbl_file.parquet' WITH (FORMAT = 'parquet')";
-        let result0 = ParserContext::create_with_dialect(sql0, &GreptimeDbDialect {}).unwrap();
-        let result1 = ParserContext::create_with_dialect(sql1, &GreptimeDbDialect {}).unwrap();
+        let result0 = ParserContext::create_with_dialect(
+            sql0,
+            &GreptimeDbDialect {},
+            ParseOptions::default(),
+        )
+        .unwrap();
+        let result1 = ParserContext::create_with_dialect(
+            sql1,
+            &GreptimeDbDialect {},
+            ParseOptions::default(),
+        )
+        .unwrap();

        for mut result in [result0, result1] {
            assert_eq!(1, result.len());
@@ -238,7 +249,10 @@ mod tests {
            "COPY catalog0.schema0.tbl FROM 'tbl_file.parquet' WITH (FORMAT = 'parquet')",
        ]
        .iter()
-        .map(|sql| ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}).unwrap())
+        .map(|sql| {
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default())
+                .unwrap()
+        })
        .collect::<Vec<_>>();

        for mut result in results {
@@ -298,8 +312,12 @@ mod tests {
        ];

        for test in tests {
-            let mut result =
-                ParserContext::create_with_dialect(test.sql, &GreptimeDbDialect {}).unwrap();
+            let mut result = ParserContext::create_with_dialect(
+                test.sql,
+                &GreptimeDbDialect {},
+                ParseOptions::default(),
+            )
+            .unwrap();
            assert_eq!(1, result.len());

            let statement = result.remove(0);
@@ -344,8 +362,12 @@ mod tests {
        ];

        for test in tests {
-            let mut result =
-                ParserContext::create_with_dialect(test.sql, &GreptimeDbDialect {}).unwrap();
+            let mut result = ParserContext::create_with_dialect(
+                test.sql,
+                &GreptimeDbDialect {},
+                ParseOptions::default(),
+            )
+            .unwrap();
            assert_eq!(1, result.len());

            let statement = result.remove(0);
@@ -367,10 +389,11 @@ mod tests {
    #[test]
    fn test_copy_database_to() {
        let sql = "COPY DATABASE catalog0.schema0 TO 'tbl_file.parquet' WITH (FORMAT = 'parquet') CONNECTION (FOO='Bar', ONE='two')";
-        let stmt = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {})
-            .unwrap()
-            .pop()
-            .unwrap();
+        let stmt =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default())
+                .unwrap()
+                .pop()
+                .unwrap();

        let Copy(crate::statements::copy::Copy::CopyDatabase(stmt)) = stmt else {
            unreachable!()
--- a/src/sql/src/parsers/create_parser.rs
+++ b/src/sql/src/parsers/create_parser.rs
@@ -16,6 +16,7 @@ use std::cmp::Ordering;
 use std::collections::HashMap;

 use common_catalog::consts::default_engine;
+use datatypes::prelude::ConcreteDataType;
 use itertools::Itertools;
 use once_cell::sync::Lazy;
 use snafu::{ensure, OptionExt, ResultExt};
@@ -409,7 +410,7 @@ impl<'a> ParserContext<'a> {

        let name = parser.parse_identifier()?;
        if name.quote_style.is_none() &&
-            // "ALL_KEYWORDS" are sorted.
+        // "ALL_KEYWORDS" are sorted.
            ALL_KEYWORDS.binary_search(&name.value.to_uppercase().as_str()).is_ok()
        {
            return Err(ParserError::ParserError(format!(
@@ -726,6 +727,13 @@ fn ensure_value_lists_bounded_by_maxvalue(value_lists: Vec<&Vec<Value>>) -> Resu
    Ok(())
 }

+fn is_string_value(v: &SqlValue) -> bool {
+    matches!(
+        v,
+        SqlValue::DoubleQuotedString(_) | SqlValue::SingleQuotedString(_)
+    )
+}
+
 /// Ensure that value lists of partitions are strictly increasing.
 fn ensure_value_lists_strictly_increased<'a>(
    partitions: &'a Partitions,
@@ -753,6 +761,31 @@ fn ensure_value_lists_strictly_increased<'a>(
                (false, false) => {
                    let column_name = &column.name.value;
                    let cdt = sql_data_type_to_concrete_data_type(&column.data_type)?;
+
+                    if matches!(
+                        cdt,
+                        ConcreteDataType::Timestamp(_)
+                            | ConcreteDataType::Date(_)
+                            | ConcreteDataType::DateTime(_)
+                    ) {
+                        // Date/Timestamp/Datetime need to be aware of timezone information
+                        // when converting from a string to a specific type.
+                        // If x and y have only one value type as a string,
+                        // comparison is not allowed.
+                        match (is_string_value(x), is_string_value(y)) {
+                            (true, false) | (false, true) => {
+                                return error::InvalidSqlSnafu {
+                                    msg: format!(
+                                        "Can't compare {:?} with {:?} in partition rules",
+                                        x, y
+                                    ),
+                                }
+                                .fail();
+                            }
+                            _ => {}
+                        }
+                    }
+
                    let x = sql_value_to_value(column_name, &cdt, x)?;
                    let y = sql_value_to_value(column_name, &cdt, y)?;
                    match x.cmp(&y) {
@@ -847,6 +880,7 @@ mod tests {

    use super::*;
    use crate::dialect::GreptimeDbDialect;
+    use crate::parser::ParseOptions;

    #[test]
    fn test_validate_external_table_options() {
@@ -859,7 +893,8 @@ mod tests {
            PRIMARY KEY(ts, host)
        ) with(location='/var/data/city.csv',format='csv',foo='bar');";

-        let result = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {});
+        let result =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default());
        assert!(matches!(
            result,
            Err(error::Error::InvalidTableOption { .. })
@@ -900,8 +935,12 @@ mod tests {
        ];

        for test in tests {
-            let stmts =
-                ParserContext::create_with_dialect(test.sql, &GreptimeDbDialect {}).unwrap();
+            let stmts = ParserContext::create_with_dialect(
+                test.sql,
+                &GreptimeDbDialect {},
+                ParseOptions::default(),
+            )
+            .unwrap();
            assert_eq!(1, stmts.len());
            match &stmts[0] {
                Statement::CreateExternalTable(c) => {
@@ -931,7 +970,9 @@ mod tests {
            ("format".to_string(), "csv".to_string()),
        ]);

-        let stmts = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}).unwrap();
+        let stmts =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default())
+                .unwrap();
        assert_eq!(1, stmts.len());
        match &stmts[0] {
            Statement::CreateExternalTable(c) => {
@@ -967,14 +1008,17 @@ mod tests {
    #[test]
    fn test_parse_create_database() {
        let sql = "create database";
-        let result = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {});
+        let result =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default());
        assert!(result
            .unwrap_err()
            .to_string()
            .contains("Unexpected token while parsing SQL statement"));

        let sql = "create database prometheus";
-        let stmts = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}).unwrap();
+        let stmts =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default())
+                .unwrap();

        assert_eq!(1, stmts.len());
        match &stmts[0] {
@@ -986,7 +1030,9 @@ mod tests {
        }

        let sql = "create database if not exists prometheus";
-        let stmts = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}).unwrap();
+        let stmts =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default())
+                .unwrap();

        assert_eq!(1, stmts.len());
        match &stmts[0] {
@@ -1008,7 +1054,8 @@ PARTITION BY RANGE COLUMNS(b, a) (
  PARTITION r3 VALUES LESS THAN (MAXVALUE, MAXVALUE),
 )
 ENGINE=mito";
-        let result = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {});
+        let result =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default());
        let _ = result.unwrap();

        let sql = r"
@@ -1019,7 +1066,8 @@ PARTITION BY RANGE COLUMNS(b, x) (
  PARTITION r3 VALUES LESS THAN (MAXVALUE, MAXVALUE),
 )
 ENGINE=mito";
-        let result = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {});
+        let result =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default());
        assert!(result
            .unwrap_err()
            .to_string()
@@ -1034,7 +1082,8 @@ PARTITION BY RANGE COLUMNS(b, a) (
  PARTITION r1 VALUES LESS THAN (MAXVALUE, MAXVALUE),
 )
 ENGINE=mito";
-        let result = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {});
+        let result =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default());
        assert!(result
            .unwrap_err()
            .to_string()
@@ -1048,7 +1097,8 @@ PARTITION BY RANGE COLUMNS(b, a) (
  PARTITION r3 VALUES LESS THAN (MAXVALUE, MAXVALUE),
 )
 ENGINE=mito";
-        let result = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {});
+        let result =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default());
        assert!(result
            .unwrap_err()
            .to_string()
@@ -1089,7 +1139,11 @@ PARTITION BY RANGE COLUMNS(b, a) (
 ENGINE=mito",
        ];
        for sql in cases {
-            let result = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {});
+            let result = ParserContext::create_with_dialect(
+                sql,
+                &GreptimeDbDialect {},
+                ParseOptions::default(),
+            );
            assert!(result
                .unwrap_err()
                .to_string()
@@ -1104,7 +1158,8 @@ PARTITION BY RANGE COLUMNS(b, a) (
  PARTITION r3 VALUES LESS THAN (MAXVALUE, 9999),
 )
 ENGINE=mito";
-        let result = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {});
+        let result =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default());
        assert!(result
            .unwrap_err()
            .to_string()
@@ -1130,7 +1185,9 @@ PARTITION BY RANGE COLUMNS(idc, host_id) (
  PARTITION r3 VALUES LESS THAN (MAXVALUE, MAXVALUE),
 )
 ENGINE=mito";
-        let result = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}).unwrap();
+        let result =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default())
+                .unwrap();
        assert_eq!(result.len(), 1);
        match &result[0] {
            Statement::CreateTable(c) => {
@@ -1196,7 +1253,12 @@ CREATE TABLE monitor (
  PRIMARY KEY (host),
 )
 ENGINE=mito";
-        let result1 = ParserContext::create_with_dialect(sql1, &GreptimeDbDialect {}).unwrap();
+        let result1 = ParserContext::create_with_dialect(
+            sql1,
+            &GreptimeDbDialect {},
+            ParseOptions::default(),
+        )
+        .unwrap();

        if let Statement::CreateTable(c) = &result1[0] {
            assert_eq!(c.constraints.len(), 2);
@@ -1231,7 +1293,12 @@ CREATE TABLE monitor (
  PRIMARY KEY (host),
 )
 ENGINE=mito";
-        let result2 = ParserContext::create_with_dialect(sql2, &GreptimeDbDialect {}).unwrap();
+        let result2 = ParserContext::create_with_dialect(
+            sql2,
+            &GreptimeDbDialect {},
+            ParseOptions::default(),
+        )
+        .unwrap();

        assert_eq!(result1, result2);

@@ -1248,7 +1315,12 @@ CREATE TABLE monitor (
 )
 ENGINE=mito";

-        let result3 = ParserContext::create_with_dialect(sql3, &GreptimeDbDialect {}).unwrap();
+        let result3 = ParserContext::create_with_dialect(
+            sql3,
+            &GreptimeDbDialect {},
+            ParseOptions::default(),
+        )
+        .unwrap();

        assert_ne!(result1, result3);

@@ -1263,7 +1335,11 @@ CREATE TABLE monitor (
  PRIMARY KEY (host),
 )
 ENGINE=mito";
-        let result1 = ParserContext::create_with_dialect(sql1, &GreptimeDbDialect {});
+        let result1 = ParserContext::create_with_dialect(
+            sql1,
+            &GreptimeDbDialect {},
+            ParseOptions::default(),
+        );

        assert!(result1
            .unwrap_err()
@@ -1284,7 +1360,9 @@ CREATE TABLE monitor (
  PRIMARY KEY (host),
 )
 ENGINE=mito";
-        let result = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}).unwrap();
+        let result =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default())
+                .unwrap();

        assert_eq!(result.len(), 1);
        if let Statement::CreateTable(c) = &result[0] {
@@ -1307,7 +1385,12 @@ CREATE TABLE monitor (
 )
 ENGINE=mito";

-        let result1 = ParserContext::create_with_dialect(sql1, &GreptimeDbDialect {}).unwrap();
+        let result1 = ParserContext::create_with_dialect(
+            sql1,
+            &GreptimeDbDialect {},
+            ParseOptions::default(),
+        )
+        .unwrap();
        assert_eq!(result, result1);

        let sql2 = r"
@@ -1322,7 +1405,12 @@ CREATE TABLE monitor (
 )
 ENGINE=mito";

-        let result2 = ParserContext::create_with_dialect(sql2, &GreptimeDbDialect {}).unwrap();
+        let result2 = ParserContext::create_with_dialect(
+            sql2,
+            &GreptimeDbDialect {},
+            ParseOptions::default(),
+        )
+        .unwrap();
        assert_eq!(result, result2);

        let sql3 = r"
@@ -1337,7 +1425,11 @@ CREATE TABLE monitor (
 )
 ENGINE=mito";

-        let result3 = ParserContext::create_with_dialect(sql3, &GreptimeDbDialect {});
+        let result3 = ParserContext::create_with_dialect(
+            sql3,
+            &GreptimeDbDialect {},
+            ParseOptions::default(),
+        );
        assert!(result3.is_err());

        let sql4 = r"
@@ -1352,7 +1444,11 @@ CREATE TABLE monitor (
 )
 ENGINE=mito";

-        let result4 = ParserContext::create_with_dialect(sql4, &GreptimeDbDialect {});
+        let result4 = ParserContext::create_with_dialect(
+            sql4,
+            &GreptimeDbDialect {},
+            ParseOptions::default(),
+        );
        assert!(result4.is_err());

        let sql = r"
@@ -1367,7 +1463,9 @@ CREATE TABLE monitor (
 )
 ENGINE=mito";

-        let result = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}).unwrap();
+        let result =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default())
+                .unwrap();

        if let Statement::CreateTable(c) = &result[0] {
            let tc = c.constraints[0].clone();
@@ -1393,6 +1491,23 @@ ENGINE=mito";
        }
    }

+    #[test]
+    fn test_parse_partitions_with_invalid_comparison() {
+        let sql = r"
+CREATE TABLE rcx ( a INT, b STRING, c INT, ts timestamp time index)
+PARTITION BY RANGE COLUMNS(ts) (
+  PARTITION r0 VALUES LESS THAN (1000),
+  PARTITION r1 VALUES LESS THAN ('2024-01-19 00:00:00'),
+  PARTITION r3 VALUES LESS THAN (MAXVALUE),
+)
+ENGINE=mito";
+        let result =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default());
+
+        let err_msg = result.unwrap_err().output_msg();
+        assert!(err_msg.contains("Invalid SQL, error: Can't compare"));
+    }
+
    #[test]
    fn test_parse_partitions_with_error_syntax() {
        let sql = r"
@@ -1403,7 +1518,8 @@ PARTITION RANGE COLUMNS(b, a) (
  PARTITION r3 VALUES LESS THAN (MAXVALUE, MAXVALUE),
 )
 ENGINE=mito";
-        let result = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {});
+        let result =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default());
        assert!(result
            .unwrap_err()
            .output_msg()
@@ -1417,7 +1533,8 @@ PARTITION BY RANGE COLUMNS(b, a) (
  PARTITION r3 VALUES LESS THAN (MAXVALUE, MAXVALUE),
 )
 ENGINE=mito";
-        let result = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {});
+        let result =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default());
        assert!(result
            .unwrap_err()
            .output_msg()
@@ -1431,7 +1548,8 @@ PARTITION BY RANGE COLUMNS(b, a) (
  PARTITION r3 VALUES LESS THAN (MAXVALUE, MAXVALU),
 )
 ENGINE=mito";
-        let result = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {});
+        let result =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default());
        assert!(result
            .unwrap_err()
            .output_msg()
@@ -1454,7 +1572,9 @@ ENGINE=mito";
                             PRIMARY KEY(ts, host)) engine=mito
                             with(regions=1);
         ";
-        let result = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}).unwrap();
+        let result =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default())
+                .unwrap();
        assert_eq!(1, result.len());
        match &result[0] {
            Statement::CreateTable(c) => {
@@ -1503,7 +1623,8 @@ ENGINE=mito";
                             PRIMARY KEY(ts, host)) engine=mito
                             with(regions=1);
         ";
-        let result = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {});
+        let result =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default());
        assert!(result.is_err());
        assert_matches!(result, Err(crate::error::Error::InvalidTimeIndex { .. }));
    }
@@ -1520,7 +1641,8 @@ ENGINE=mito";
                             PRIMARY KEY(ts, host)) engine=mito
                             with(regions=1);
         ";
-        let result = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {});
+        let result =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default());
        assert!(result.is_err());
        assert_matches!(result, Err(crate::error::Error::InvalidTimeIndex { .. }));

@@ -1534,7 +1656,8 @@ ENGINE=mito";
                             PRIMARY KEY(ts, host)) engine=mito
                             with(regions=1);
         ";
-        let result = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {});
+        let result =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default());
        assert!(result.is_err());
        assert_matches!(result, Err(crate::error::Error::InvalidTimeIndex { .. }));
    }
@@ -1542,7 +1665,8 @@ ENGINE=mito";
    #[test]
    fn test_invalid_column_name() {
        let sql = "create table foo(user string, i timestamp time index)";
-        let result = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {});
+        let result =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default());
        let err = result.unwrap_err().output_msg();
        assert!(err.contains("Cannot use keyword 'user' as column name"));

@@ -1550,7 +1674,8 @@ ENGINE=mito";
        let sql = r#"
            create table foo("user" string, i timestamp time index)
        "#;
-        let result = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {});
+        let result =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default());
        let _ = result.unwrap();
    }
 }
--- a/src/sql/src/parsers/delete_parser.rs
+++ b/src/sql/src/parsers/delete_parser.rs
@@ -45,11 +45,14 @@ mod tests {

    use super::*;
    use crate::dialect::GreptimeDbDialect;
+    use crate::parser::ParseOptions;

    #[test]
    pub fn test_parse_insert() {
        let sql = r"delete from my_table where k1 = xxx and k2 = xxx and timestamp = xxx;";
-        let result = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}).unwrap();
+        let result =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default())
+                .unwrap();
        assert_eq!(1, result.len());
        assert_matches!(result[0], Statement::Delete { .. })
    }
@@ -57,7 +60,8 @@ mod tests {
    #[test]
    pub fn test_parse_invalid_insert() {
        let sql = r"delete my_table where "; // intentionally a bad sql
-        let result = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {});
+        let result =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default());
        assert!(result.is_err(), "result is: {result:?}");
    }
 }
--- a/src/sql/src/parsers/describe_parser.rs
+++ b/src/sql/src/parsers/describe_parser.rs
@@ -55,6 +55,7 @@ mod tests {

    use super::*;
    use crate::dialect::GreptimeDbDialect;
+    use crate::parser::ParseOptions;

    #[test]
    fn test_parse_function() {
@@ -64,10 +65,11 @@ mod tests {
    }

    fn assert_describe_table(sql: &str) {
-        let stmt = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {})
-            .unwrap()
-            .pop()
-            .unwrap();
+        let stmt =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default())
+                .unwrap()
+                .pop()
+                .unwrap();
        assert!(matches!(stmt, Statement::DescribeTable(_)))
    }

--- a/src/sql/src/parsers/drop_parser.rs
+++ b/src/sql/src/parsers/drop_parser.rs
@@ -56,11 +56,13 @@ mod tests {

    use super::*;
    use crate::dialect::GreptimeDbDialect;
+    use crate::parser::ParseOptions;

    #[test]
    pub fn test_drop_table() {
        let sql = "DROP TABLE foo";
-        let result = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {});
+        let result =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default());
        let mut stmts = result.unwrap();
        assert_eq!(
            stmts.pop().unwrap(),
@@ -68,7 +70,8 @@ mod tests {
        );

        let sql = "DROP TABLE IF EXISTS foo";
-        let result = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {});
+        let result =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default());
        let mut stmts = result.unwrap();
        assert_eq!(
            stmts.pop().unwrap(),
@@ -76,7 +79,8 @@ mod tests {
        );

        let sql = "DROP TABLE my_schema.foo";
-        let result = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {});
+        let result =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default());
        let mut stmts = result.unwrap();
        assert_eq!(
            stmts.pop().unwrap(),
@@ -87,7 +91,8 @@ mod tests {
        );

        let sql = "DROP TABLE my_catalog.my_schema.foo";
-        let result = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {});
+        let result =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default());
        let mut stmts = result.unwrap();
        assert_eq!(
            stmts.pop().unwrap(),
--- a/src/sql/src/parsers/explain_parser.rs
+++ b/src/sql/src/parsers/explain_parser.rs
@@ -43,11 +43,13 @@ mod tests {

    use super::*;
    use crate::dialect::GreptimeDbDialect;
+    use crate::parser::ParseOptions;

    #[test]
    pub fn test_explain() {
        let sql = "EXPLAIN select * from foo";
-        let result = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {});
+        let result =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default());
        let stmts = result.unwrap();
        assert_eq!(1, stmts.len());

--- a/src/sql/src/parsers/insert_parser.rs
+++ b/src/sql/src/parsers/insert_parser.rs
@@ -45,6 +45,7 @@ mod tests {

    use super::*;
    use crate::dialect::GreptimeDbDialect;
+    use crate::parser::ParseOptions;

    #[test]
    pub fn test_parse_insert() {
@@ -52,7 +53,9 @@ mod tests {
            'test1',1,'true',
            'test2',2,'false')
         ";
-        let result = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}).unwrap();
+        let result =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default())
+                .unwrap();
        assert_eq!(1, result.len());
        assert_matches!(result[0], Statement::Insert { .. })
    }
@@ -60,7 +63,8 @@ mod tests {
    #[test]
    pub fn test_parse_invalid_insert() {
        let sql = r"INSERT INTO table_1 VALUES ("; // intentionally a bad sql
-        let result = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {});
+        let result =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default());
        assert!(result.is_err(), "result is: {result:?}");
    }
 }
--- a/src/sql/src/parsers/query_parser.rs
+++ b/src/sql/src/parsers/query_parser.rs
@@ -33,7 +33,7 @@ mod tests {
    use common_error::ext::ErrorExt;

    use crate::dialect::GreptimeDbDialect;
-    use crate::parser::ParserContext;
+    use crate::parser::{ParseOptions, ParserContext};

    #[test]
    pub fn test_parse_query() {
@@ -42,13 +42,16 @@ mod tests {
           WHERE a > b AND b < 100 \
           ORDER BY a DESC, b";

-        let _ = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}).unwrap();
+        let _ =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default())
+                .unwrap();
    }

    #[test]
    pub fn test_parse_invalid_query() {
        let sql = "SELECT * FROM table_1 WHERE";
-        let result = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {});
+        let result =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default());
        assert!(result.is_err());
        assert!(result
            .unwrap_err()
--- a/src/sql/src/parsers/set_var_parser.rs
+++ b/src/sql/src/parsers/set_var_parser.rs
@@ -49,12 +49,14 @@ mod tests {

    use super::*;
    use crate::dialect::GreptimeDbDialect;
+    use crate::parser::ParseOptions;

    #[test]
    pub fn test_set_timezone() {
        // mysql style
        let sql = "SET time_zone = 'UTC'";
-        let result = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {});
+        let result =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default());
        let mut stmts = result.unwrap();
        assert_eq!(
            stmts.pop().unwrap(),
@@ -65,7 +67,8 @@ mod tests {
        );
        // postgresql style
        let sql = "SET TIMEZONE TO 'UTC'";
-        let result = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {});
+        let result =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default());
        let mut stmts = result.unwrap();
        assert_eq!(
            stmts.pop().unwrap(),
--- a/src/sql/src/parsers/show_parser.rs
+++ b/src/sql/src/parsers/show_parser.rs
@@ -194,12 +194,14 @@ mod tests {

    use super::*;
    use crate::dialect::GreptimeDbDialect;
+    use crate::parser::ParseOptions;
    use crate::statements::show::ShowDatabases;

    #[test]
    pub fn test_show_database_all() {
        let sql = "SHOW DATABASES";
-        let result = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {});
+        let result =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default());
        let stmts = result.unwrap();
        assert_eq!(1, stmts.len());

@@ -214,7 +216,8 @@ mod tests {
    #[test]
    pub fn test_show_database_like() {
        let sql = "SHOW DATABASES LIKE test_database";
-        let result = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {});
+        let result =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default());
        let stmts = result.unwrap();
        assert_eq!(1, stmts.len());

@@ -232,7 +235,8 @@ mod tests {
    #[test]
    pub fn test_show_database_where() {
        let sql = "SHOW DATABASES WHERE Database LIKE '%whatever1%' OR Database LIKE '%whatever2%'";
-        let result = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {});
+        let result =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default());
        let stmts = result.unwrap();
        assert_eq!(1, stmts.len());

@@ -251,7 +255,8 @@ mod tests {
    #[test]
    pub fn test_show_tables_all() {
        let sql = "SHOW TABLES";
-        let result = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {});
+        let result =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default());
        let stmts = result.unwrap();
        assert_eq!(1, stmts.len());

@@ -268,7 +273,8 @@ mod tests {
    #[test]
    pub fn test_show_tables_like() {
        let sql = "SHOW TABLES LIKE test_table";
-        let result = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {});
+        let result =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default());
        let stmts = result.unwrap();
        assert_eq!(1, stmts.len());

@@ -285,7 +291,8 @@ mod tests {
        );

        let sql = "SHOW TABLES in test_db LIKE test_table";
-        let result = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {});
+        let result =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default());
        let stmts = result.unwrap();
        assert_eq!(1, stmts.len());

@@ -305,7 +312,8 @@ mod tests {
    #[test]
    pub fn test_show_tables_where() {
        let sql = "SHOW TABLES where name like test_table";
-        let result = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {});
+        let result =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default());
        let stmts = result.unwrap();
        assert_eq!(1, stmts.len());

@@ -319,7 +327,8 @@ mod tests {
        );

        let sql = "SHOW TABLES in test_db where name LIKE test_table";
-        let result = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {});
+        let result =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default());
        let stmts = result.unwrap();
        assert_eq!(1, stmts.len());

@@ -336,7 +345,9 @@ mod tests {
    #[test]
    pub fn test_show_full_tables() {
        let sql = "SHOW FULL TABLES";
-        let stmts = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}).unwrap();
+        let stmts =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default())
+                .unwrap();
        assert_eq!(1, stmts.len());
        assert_matches!(&stmts[0], Statement::ShowTables { .. });
        match &stmts[0] {
@@ -352,7 +363,9 @@ mod tests {
    #[test]
    pub fn test_show_full_tables_where() {
        let sql = "SHOW FULL TABLES IN test_db WHERE Tables LIKE test_table";
-        let stmts = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}).unwrap();
+        let stmts =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default())
+                .unwrap();
        assert_eq!(1, stmts.len());

        assert_matches!(
@@ -368,7 +381,8 @@ mod tests {
    #[test]
    pub fn test_show_full_tables_like() {
        let sql = "SHOW FULL TABLES LIKE test_table";
-        let result = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {});
+        let result =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default());
        let stmts = result.unwrap();
        assert_eq!(1, stmts.len());

@@ -385,7 +399,8 @@ mod tests {
        );

        let sql = "SHOW FULL TABLES in test_db LIKE test_table";
-        let result = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {});
+        let result =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default());
        let stmts = result.unwrap();
        assert_eq!(1, stmts.len());

@@ -405,7 +420,8 @@ mod tests {
    #[test]
    pub fn test_show_variables() {
        let sql = "SHOW VARIABLES system_time_zone";
-        let result = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {});
+        let result =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default());
        let stmts = result.unwrap();
        assert_eq!(1, stmts.len());
        assert_eq!(
--- a/src/sql/src/parsers/tql_parser.rs
+++ b/src/sql/src/parsers/tql_parser.rs
@@ -168,11 +168,14 @@ mod tests {

    use super::*;
    use crate::dialect::GreptimeDbDialect;
+    use crate::parser::ParseOptions;
    #[test]
    fn test_parse_tql_eval() {
        let sql = "TQL EVAL (1676887657, 1676887659, '1m') http_requests_total{environment=~'staging|testing|development',method!='GET'} @ 1609746000 offset 5m";

-        let mut result = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}).unwrap();
+        let mut result =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default())
+                .unwrap();
        assert_eq!(1, result.len());

        let statement = result.remove(0);
@@ -188,7 +191,9 @@ mod tests {

        let sql = "TQL EVAL (1676887657.1, 1676887659.5, 30.3) http_requests_total{environment=~'staging|testing|development',method!='GET'} @ 1609746000 offset 5m";

-        let mut result = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}).unwrap();
+        let mut result =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default())
+                .unwrap();
        assert_eq!(1, result.len());

        let statement = result.remove(0);
@@ -204,7 +209,9 @@ mod tests {

        let sql = "TQL EVALUATE (1676887657.1, 1676887659.5, 30.3) http_requests_total{environment=~'staging|testing|development',method!='GET'} @ 1609746000 offset 5m";

-        let mut result = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}).unwrap();
+        let mut result =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default())
+                .unwrap();
        assert_eq!(1, result.len());

        let statement2 = result.remove(0);
@@ -212,7 +219,9 @@ mod tests {

        let sql = "tql eval ('2015-07-01T20:10:30.781Z', '2015-07-01T20:11:00.781Z', '30s') http_requests_total{environment=~'staging|testing|development',method!='GET'} @ 1609746000 offset 5m";

-        let mut result = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}).unwrap();
+        let mut result =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default())
+                .unwrap();
        assert_eq!(1, result.len());

        let statement = result.remove(0);
@@ -231,7 +240,9 @@ mod tests {
    fn test_parse_tql_explain() {
        let sql = "TQL EXPLAIN http_requests_total{environment=~'staging|testing|development',method!='GET'} @ 1609746000 offset 5m";

-        let mut result = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}).unwrap();
+        let mut result =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default())
+                .unwrap();
        assert_eq!(1, result.len());

        let statement = result.remove(0);
@@ -247,7 +258,9 @@ mod tests {

        let sql = "TQL EXPLAIN (20,100,10) http_requests_total{environment=~'staging|testing|development',method!='GET'} @ 1609746000 offset 5m";

-        let mut result = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}).unwrap();
+        let mut result =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default())
+                .unwrap();
        assert_eq!(1, result.len());

        let statement = result.remove(0);
@@ -265,7 +278,9 @@ mod tests {
    #[test]
    fn test_parse_tql_analyze() {
        let sql = "TQL ANALYZE (1676887657.1, 1676887659.5, 30.3) http_requests_total{environment=~'staging|testing|development',method!='GET'} @ 1609746000 offset 5m";
-        let mut result = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}).unwrap();
+        let mut result =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default())
+                .unwrap();
        assert_eq!(1, result.len());
        let statement = result.remove(0);
        match statement {
@@ -283,12 +298,16 @@ mod tests {
    fn test_parse_tql_error() {
        // Invalid duration
        let sql = "TQL EVAL (1676887657, 1676887659, 1m) http_requests_total{environment=~'staging|testing|development',method!='GET'} @ 1609746000 offset 5m";
-        let result = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}).unwrap_err();
+        let result =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default())
+                .unwrap_err();
        assert!(result.output_msg().contains("Expected ), found: m"));

        // missing end
        let sql = "TQL EVAL (1676887657, '1m') http_requests_total{environment=~'staging|testing|development',method!='GET'} @ 1609746000 offset 5m";
-        let result = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}).unwrap_err();
+        let result =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default())
+                .unwrap_err();
        assert!(result.output_msg().contains("Expected ,, found: )"));
    }
 }
--- a/src/sql/src/parsers/truncate_parser.rs
+++ b/src/sql/src/parsers/truncate_parser.rs
@@ -53,25 +53,32 @@ mod tests {

    use super::*;
    use crate::dialect::GreptimeDbDialect;
+    use crate::parser::ParseOptions;

    #[test]
    pub fn test_parse_truncate() {
        let sql = "TRUNCATE foo";
-        let mut stmts = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}).unwrap();
+        let mut stmts =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default())
+                .unwrap();
        assert_eq!(
            stmts.pop().unwrap(),
            Statement::TruncateTable(TruncateTable::new(ObjectName(vec![Ident::new("foo")])))
        );

        let sql = "TRUNCATE TABLE foo";
-        let mut stmts = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}).unwrap();
+        let mut stmts =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default())
+                .unwrap();
        assert_eq!(
            stmts.pop().unwrap(),
            Statement::TruncateTable(TruncateTable::new(ObjectName(vec![Ident::new("foo")])))
        );

        let sql = "TRUNCATE TABLE my_schema.foo";
-        let mut stmts = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}).unwrap();
+        let mut stmts =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default())
+                .unwrap();
        assert_eq!(
            stmts.pop().unwrap(),
            Statement::TruncateTable(TruncateTable::new(ObjectName(vec![
@@ -81,7 +88,9 @@ mod tests {
        );

        let sql = "TRUNCATE my_schema.foo";
-        let mut stmts = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}).unwrap();
+        let mut stmts =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default())
+                .unwrap();
        assert_eq!(
            stmts.pop().unwrap(),
            Statement::TruncateTable(TruncateTable::new(ObjectName(vec![
@@ -91,7 +100,9 @@ mod tests {
        );

        let sql = "TRUNCATE TABLE my_catalog.my_schema.foo";
-        let mut stmts = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}).unwrap();
+        let mut stmts =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default())
+                .unwrap();
        assert_eq!(
            stmts.pop().unwrap(),
            Statement::TruncateTable(TruncateTable::new(ObjectName(vec![
@@ -102,14 +113,18 @@ mod tests {
        );

        let sql = "TRUNCATE drop";
-        let mut stmts = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}).unwrap();
+        let mut stmts =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default())
+                .unwrap();
        assert_eq!(
            stmts.pop().unwrap(),
            Statement::TruncateTable(TruncateTable::new(ObjectName(vec![Ident::new("drop")])))
        );

        let sql = "TRUNCATE `drop`";
-        let mut stmts = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}).unwrap();
+        let mut stmts =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default())
+                .unwrap();
        assert_eq!(
            stmts.pop().unwrap(),
            Statement::TruncateTable(TruncateTable::new(ObjectName(vec![Ident::with_quote(
@@ -118,7 +133,9 @@ mod tests {
        );

        let sql = "TRUNCATE \"drop\"";
-        let mut stmts = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}).unwrap();
+        let mut stmts =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default())
+                .unwrap();
        assert_eq!(
            stmts.pop().unwrap(),
            Statement::TruncateTable(TruncateTable::new(ObjectName(vec![Ident::with_quote(
@@ -130,11 +147,13 @@ mod tests {
    #[test]
    pub fn test_parse_invalid_truncate() {
        let sql = "TRUNCATE SCHEMA foo";
-        let result = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {});
+        let result =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default());
        assert!(result.is_err(), "result is: {result:?}");

        let sql = "TRUNCATE";
-        let result = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {});
+        let result =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default());
        assert!(result.is_err(), "result is: {result:?}");
    }
 }
--- a/src/sql/src/statements/create.rs
+++ b/src/sql/src/statements/create.rs
@@ -222,7 +222,7 @@ pub struct CreateExternalTable {
 mod tests {
    use crate::dialect::GreptimeDbDialect;
    use crate::error::Error::InvalidTableOption;
-    use crate::parser::ParserContext;
+    use crate::parser::{ParseOptions, ParserContext};
    use crate::statements::statement::Statement;

    #[test]
@@ -243,7 +243,9 @@ mod tests {
                       engine=mito
                       with(regions=1, ttl='7d', storage='File');
         ";
-        let result = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}).unwrap();
+        let result =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default())
+                .unwrap();
        assert_eq!(1, result.len());

        match &result[0] {
@@ -273,8 +275,12 @@ WITH(
                    &new_sql
                );

-                let new_result =
-                    ParserContext::create_with_dialect(&new_sql, &GreptimeDbDialect {}).unwrap();
+                let new_result = ParserContext::create_with_dialect(
+                    &new_sql,
+                    &GreptimeDbDialect {},
+                    ParseOptions::default(),
+                )
+                .unwrap();
                assert_eq!(result, new_result);
            }
            _ => unreachable!(),
@@ -292,7 +298,9 @@ WITH(
            PRIMARY KEY(ts, host)
            );
        ";
-        let result = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}).unwrap();
+        let result =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default())
+                .unwrap();
        assert_eq!(1, result.len());

        match &result[0] {
@@ -313,8 +321,12 @@ ENGINE=mito
                    &new_sql
                );

-                let new_result =
-                    ParserContext::create_with_dialect(&new_sql, &GreptimeDbDialect {}).unwrap();
+                let new_result = ParserContext::create_with_dialect(
+                    &new_sql,
+                    &GreptimeDbDialect {},
+                    ParseOptions::default(),
+                )
+                .unwrap();
                assert_eq!(result, new_result);
            }
            _ => unreachable!(),
@@ -339,7 +351,8 @@ ENGINE=mito
      engine=mito
      with(regions=1, ttl='7d', hello='world');
 ";
-        let result = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {});
+        let result =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default());
        assert!(matches!(result, Err(InvalidTableOption { .. })))
    }
 }
--- a/src/sql/src/statements/describe.rs
+++ b/src/sql/src/statements/describe.rs
@@ -37,7 +37,7 @@ mod tests {
    use std::assert_matches::assert_matches;

    use crate::dialect::GreptimeDbDialect;
-    use crate::parser::ParserContext;
+    use crate::parser::{ParseOptions, ParserContext};
    use crate::statements::statement::Statement;
    use crate::util::format_raw_object_name;

@@ -45,7 +45,8 @@ mod tests {
    pub fn test_describe_table() {
        let sql = "DESCRIBE TABLE test";
        let stmts: Vec<Statement> =
-            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}).unwrap();
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default())
+                .unwrap();
        assert_eq!(1, stmts.len());
        assert_matches!(&stmts[0], Statement::DescribeTable { .. });
        match &stmts[0] {
@@ -62,7 +63,8 @@ mod tests {
    pub fn test_describe_schema_table() {
        let sql = "DESCRIBE TABLE test_schema.test";
        let stmts: Vec<Statement> =
-            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}).unwrap();
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default())
+                .unwrap();
        assert_eq!(1, stmts.len());
        assert_matches!(&stmts[0], Statement::DescribeTable { .. });
        match &stmts[0] {
@@ -79,7 +81,8 @@ mod tests {
    pub fn test_describe_catalog_schema_table() {
        let sql = "DESCRIBE TABLE test_catalog.test_schema.test";
        let stmts: Vec<Statement> =
-            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}).unwrap();
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default())
+                .unwrap();
        assert_eq!(1, stmts.len());
        assert_matches!(&stmts[0], Statement::DescribeTable { .. });
        match &stmts[0] {
@@ -98,6 +101,11 @@ mod tests {
    #[test]
    pub fn test_describe_missing_table_name() {
        let sql = "DESCRIBE TABLE";
-        assert!(ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}).is_err());
+        assert!(ParserContext::create_with_dialect(
+            sql,
+            &GreptimeDbDialect {},
+            ParseOptions::default()
+        )
+        .is_err());
    }
 }
--- a/src/sql/src/statements/insert.rs
+++ b/src/sql/src/statements/insert.rs
@@ -171,16 +171,17 @@ impl TryFrom<Statement> for Insert {
 mod tests {
    use super::*;
    use crate::dialect::GreptimeDbDialect;
-    use crate::parser::ParserContext;
+    use crate::parser::{ParseOptions, ParserContext};
    use crate::statements::statement::Statement;

    #[test]
    fn test_insert_value_with_unary_op() {
        // insert "-1"
        let sql = "INSERT INTO my_table VALUES(-1)";
-        let stmt = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {})
-            .unwrap()
-            .remove(0);
+        let stmt =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default())
+                .unwrap()
+                .remove(0);
        match stmt {
            Statement::Insert(insert) => {
                let values = insert.values_body().unwrap();
@@ -191,9 +192,10 @@ mod tests {

        // insert "+1"
        let sql = "INSERT INTO my_table VALUES(+1)";
-        let stmt = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {})
-            .unwrap()
-            .remove(0);
+        let stmt =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default())
+                .unwrap()
+                .remove(0);
        match stmt {
            Statement::Insert(insert) => {
                let values = insert.values_body().unwrap();
@@ -207,9 +209,10 @@ mod tests {
    fn test_insert_value_with_default() {
        // insert "default"
        let sql = "INSERT INTO my_table VALUES(default)";
-        let stmt = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {})
-            .unwrap()
-            .remove(0);
+        let stmt =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default())
+                .unwrap()
+                .remove(0);
        match stmt {
            Statement::Insert(insert) => {
                let values = insert.values_body().unwrap();
@@ -223,9 +226,10 @@ mod tests {
    fn test_insert_value_with_default_uppercase() {
        // insert "DEFAULT"
        let sql = "INSERT INTO my_table VALUES(DEFAULT)";
-        let stmt = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {})
-            .unwrap()
-            .remove(0);
+        let stmt =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default())
+                .unwrap()
+                .remove(0);
        match stmt {
            Statement::Insert(insert) => {
                let values = insert.values_body().unwrap();
@@ -239,9 +243,10 @@ mod tests {
    fn test_insert_value_with_quoted_string() {
        // insert 'default'
        let sql = "INSERT INTO my_table VALUES('default')";
-        let stmt = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {})
-            .unwrap()
-            .remove(0);
+        let stmt =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default())
+                .unwrap()
+                .remove(0);
        match stmt {
            Statement::Insert(insert) => {
                let values = insert.values_body().unwrap();
@@ -255,9 +260,10 @@ mod tests {

        // insert "default". Treating double-quoted identifiers as strings.
        let sql = "INSERT INTO my_table VALUES(\"default\")";
-        let stmt = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {})
-            .unwrap()
-            .remove(0);
+        let stmt =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default())
+                .unwrap()
+                .remove(0);
        match stmt {
            Statement::Insert(insert) => {
                let values = insert.values_body().unwrap();
@@ -270,9 +276,10 @@ mod tests {
        }

        let sql = "INSERT INTO my_table VALUES(`default`)";
-        let stmt = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {})
-            .unwrap()
-            .remove(0);
+        let stmt =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default())
+                .unwrap()
+                .remove(0);
        match stmt {
            Statement::Insert(insert) => {
                assert!(insert.values_body().is_err());
@@ -284,9 +291,10 @@ mod tests {
    #[test]
    fn test_insert_select() {
        let sql = "INSERT INTO my_table select * from other_table";
-        let stmt = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {})
-            .unwrap()
-            .remove(0);
+        let stmt =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default())
+                .unwrap()
+                .remove(0);
        match stmt {
            Statement::Insert(insert) => {
                let q = insert.query_body().unwrap().unwrap();
--- a/src/sql/src/statements/query.rs
+++ b/src/sql/src/statements/query.rs
@@ -54,13 +54,17 @@ mod test {

    use super::Query;
    use crate::dialect::GreptimeDbDialect;
-    use crate::parser::ParserContext;
+    use crate::parser::{ParseOptions, ParserContext};
    use crate::statements::statement::Statement;

    fn create_query(sql: &str) -> Option<Box<Query>> {
-        match ParserContext::create_with_dialect(sql, &GreptimeDbDialect {})
-            .unwrap()
-            .remove(0)
+        match ParserContext::create_with_dialect(
+            sql,
+            &GreptimeDbDialect {},
+            ParseOptions::default(),
+        )
+        .unwrap()
+        .remove(0)
        {
            Statement::Query(query) => Some(query),
            _ => None,
--- a/src/sql/src/statements/show.rs
+++ b/src/sql/src/statements/show.rs
@@ -77,7 +77,7 @@ mod tests {

    use super::*;
    use crate::dialect::GreptimeDbDialect;
-    use crate::parser::ParserContext;
+    use crate::parser::{ParseOptions, ParserContext};
    use crate::statements::statement::Statement;

    #[test]
@@ -111,7 +111,9 @@ mod tests {
    #[test]
    pub fn test_show_database() {
        let sql = "SHOW DATABASES";
-        let stmts = ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}).unwrap();
+        let stmts =
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default())
+                .unwrap();
        assert_eq!(1, stmts.len());
        assert_matches!(&stmts[0], Statement::ShowDatabases { .. });
        match &stmts[0] {
@@ -128,7 +130,8 @@ mod tests {
    pub fn test_show_create_table() {
        let sql = "SHOW CREATE TABLE test";
        let stmts: Vec<Statement> =
-            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}).unwrap();
+            ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}, ParseOptions::default())
+                .unwrap();
        assert_eq!(1, stmts.len());
        assert_matches!(&stmts[0], Statement::ShowCreateTable { .. });
        match &stmts[0] {
@@ -144,6 +147,11 @@ mod tests {
    #[test]
    pub fn test_show_create_missing_table_name() {
        let sql = "SHOW CREATE TABLE";
-        assert!(ParserContext::create_with_dialect(sql, &GreptimeDbDialect {}).is_err());
+        assert!(ParserContext::create_with_dialect(
+            sql,
+            &GreptimeDbDialect {},
+            ParseOptions::default()
+        )
+        .is_err());
    }
 }
--- a/src/sql/src/statements/transform/type_alias.rs
+++ b/src/sql/src/statements/transform/type_alias.rs
@@ -167,7 +167,7 @@ mod tests {
    use sqlparser::dialect::GenericDialect;

    use super::*;
-    use crate::parser::ParserContext;
+    use crate::parser::{ParseOptions, ParserContext};
    use crate::statements::transform_statements;

    #[test]
@@ -265,7 +265,9 @@ mod tests {

    fn test_timestamp_alias(alias: &str, expected: &str) {
        let sql = format!("SELECT TIMESTAMP '2020-01-01 01:23:45.12345678'::{alias}");
-        let mut stmts = ParserContext::create_with_dialect(&sql, &GenericDialect {}).unwrap();
+        let mut stmts =
+            ParserContext::create_with_dialect(&sql, &GenericDialect {}, ParseOptions::default())
+                .unwrap();
        transform_statements(&mut stmts).unwrap();

        match &stmts[0] {
@@ -318,7 +320,9 @@ CREATE TABLE data_types (
  ts9 TimestampNanosecond DEFAULT CURRENT_TIMESTAMP TIME INDEX,
  PRIMARY KEY(s));"#;

-        let mut stmts = ParserContext::create_with_dialect(sql, &GenericDialect {}).unwrap();
+        let mut stmts =
+            ParserContext::create_with_dialect(sql, &GenericDialect {}, ParseOptions::default())
+                .unwrap();
        transform_statements(&mut stmts).unwrap();

        match &stmts[0] {