refactor(sql): share optimizer replay support and add lite harness (#19542)

* refactor(sql-test-support): extract parse_raw_expr

* refactor(sql-test-support): share optimizer replay support

* test(sql): add lite replay optimizer harness

Author: forsaken628

Cargo.lock

@@ -104,6 +104,7 @@ databend-common-protos = { path = "src/meta/protos" }
 databend-common-script = { path = "src/query/script" }
 databend-common-settings = { path = "src/query/settings" }
 databend-common-sql = { path = "src/query/sql" }
+databend-common-sql-test-support = { path = "src/query/sql/test-support" }
 databend-common-sqlsmith = { path = "src/tests/sqlsmith" }
 databend-common-statistics = { path = "src/common/statistics" }
 databend-common-storage = { path = "src/common/storage" }
@@ -318,7 +319,7 @@ jiff = { version = "0.2.16", features = ["serde", "tzdb-bundle-always"] }
 jsonb = "0.5.5"
 jwt-simple = { version = "0.12.12", default-features = false, features = ["pure-rust"] }
 lance-core = "1.0.4"
-lance-encoding = "1.0.4"
+lance-encoding = { version = "1.0.4", features = ["protoc"] }
 lance-file = "1.0.4"
 lance-io = { version = "1.0.4", default-features = false }
 lance-table = "1.0.4"

Cargo.toml

@@ -13,7 +13,6 @@ borsh = { workspace = true }
 bstr = { workspace = true }
 bumpalo = { workspace = true }
 ctor = { workspace = true }
-databend-common-ast = { workspace = true }
 databend-common-base = { workspace = true }
 databend-common-column = { workspace = true }
 databend-common-exception = { workspace = true }
@@ -39,7 +38,6 @@ jaq-std = { workspace = true }
 jiff = { workspace = true }
 jsonb = { workspace = true }
 libm = { workspace = true }
-log = { workspace = true }
 match-template = { workspace = true }
 md-5 = { workspace = true }
 naive-cityhash = { workspace = true }
@@ -63,6 +61,7 @@ uuid = { workspace = true }
 anyhow = { workspace = true }
 comfy-table = { workspace = true }
 databend-common-ast = { workspace = true }
+databend-common-sql-test-support = { workspace = true }
 divan = { workspace = true }
 goldenfile = { workspace = true }
 

src/query/functions/Cargo.toml

@@ -34,20 +34,20 @@ mod dummy {
     use databend_common_expression::FunctionContext;
     use databend_common_expression::type_check;
     use databend_common_functions::BUILTIN_FUNCTIONS;
-    use databend_common_functions::test_utils as parser;
+    use databend_common_sql_test_support as parser;
 
     #[divan::bench(args = [10240, 102400])]
     fn parse(bencher: divan::Bencher, n: usize) {
         let text = "[".to_string() + &"true,".repeat(n) + "]";
         bencher.bench(|| {
-            let _ = divan::black_box(parser::parse_raw_expr(&text, &[]));
+            let _ = divan::black_box(parser::parse_raw_expr(&text, &[], &BUILTIN_FUNCTIONS));
         });
     }
 
     #[divan::bench(args = [10240, 102400])]
     fn check(bencher: divan::Bencher, n: usize) {
         let text = "[".to_string() + &"true,".repeat(n) + "]";
-        let raw_expr = parser::parse_raw_expr(&text, &[]);
+        let raw_expr = parser::parse_raw_expr(&text, &[], &BUILTIN_FUNCTIONS);
 
         bencher.bench(|| {
             let _ = divan::black_box(type_check::check(&raw_expr, &BUILTIN_FUNCTIONS));
@@ -57,7 +57,7 @@ mod dummy {
     #[divan::bench(args = [10240, 102400])]
     fn eval(bencher: divan::Bencher, n: usize) {
         let text = "[".to_string() + &"true,".repeat(n) + "]";
-        let raw_expr = parser::parse_raw_expr(&text, &[]);
+        let raw_expr = parser::parse_raw_expr(&text, &[], &BUILTIN_FUNCTIONS);
         let func_ctx = FunctionContext::default();
         let expr = type_check::check(&raw_expr, &BUILTIN_FUNCTIONS).unwrap();
         let block = DataBlock::new(vec![], 1);
@@ -250,7 +250,7 @@ mod datetime_fast_path {
     use databend_common_expression::types::timestamp::microseconds_to_days;
     use databend_common_expression::types::timestamp::timestamp_to_string;
     use databend_common_functions::BUILTIN_FUNCTIONS;
-    use databend_common_functions::test_utils as parser;
+    use databend_common_sql_test_support as parser;
     use jiff::civil::date;
     use jiff::tz::TimeZone;
     use rand::Rng;
@@ -457,7 +457,7 @@ mod datetime_fast_path {
     }
 
     fn build_expr(sql: &str, columns: &[(&str, DataType)]) -> Expr {
-        let raw_expr = parser::parse_raw_expr(sql, columns);
+        let raw_expr = parser::parse_raw_expr(sql, columns, &BUILTIN_FUNCTIONS);
         type_check::check(&raw_expr, &BUILTIN_FUNCTIONS).unwrap()
     }
 

src/query/functions/benches/bench.rs

@@ -27,7 +27,6 @@ pub mod aggregates;
 mod cast_rules;
 pub mod scalars;
 pub mod srfs;
-pub mod test_utils;
 
 pub fn is_builtin_function(name: &str) -> bool {
     let name = Ascii::new(name);

src/query/functions/src/lib.rs

@@ -70,6 +70,7 @@ pub fn run_agg_ast(
             .iter()
             .map(|(name, entry)| (*name, entry.data_type()))
             .collect::<Vec<_>>(),
+        &BUILTIN_FUNCTIONS,
     );
 
     let num_rows = entries

src/query/functions/tests/it/aggregates/mod.rs

@@ -60,7 +60,7 @@ mod tuple;
 mod variant;
 mod vector;
 
-pub use databend_common_functions::test_utils as parser;
+pub use databend_common_sql_test_support as parser;
 
 #[derive(Clone)]
 pub struct TestContext<'a> {
@@ -129,6 +129,7 @@ pub fn run_ast_with_context(file: &mut impl Write, text: impl AsRef<str>, mut ct
                 .iter()
                 .map(|(name, entry)| (*name, entry.data_type()))
                 .collect::<Vec<_>>(),
+            &BUILTIN_FUNCTIONS,
         );
 
         let expr = type_check::check(&raw_expr, &BUILTIN_FUNCTIONS)?;
@@ -366,10 +367,14 @@ fn test_if_function() -> anyhow::Result<()> {
     use databend_common_expression::FromData;
     use databend_common_expression::Scalar;
     use databend_common_expression::types::*;
-    let raw_expr = parser::parse_raw_expr("if(eq(n,1), sum_sid + 1,100)", &[
-        ("n", UInt8Type::data_type()),
-        ("sum_sid", Int32Type::data_type().wrap_nullable()),
-    ]);
+    let raw_expr = parser::parse_raw_expr(
+        "if(eq(n,1), sum_sid + 1,100)",
+        &[
+            ("n", UInt8Type::data_type()),
+            ("sum_sid", Int32Type::data_type().wrap_nullable()),
+        ],
+        &BUILTIN_FUNCTIONS,
+    );
     let expr = type_check::check(&raw_expr, &BUILTIN_FUNCTIONS)?;
     let block = DataBlock::new(
         vec![

src/query/functions/tests/it/scalars/mod.rs

@@ -21,7 +21,7 @@ use databend_common_expression::type_check;
 use databend_common_expression::types::timestamp_tz::TimestampTzType;
 use databend_common_expression::types::*;
 use databend_common_functions::BUILTIN_FUNCTIONS;
-use databend_common_functions::test_utils;
+use databend_common_sql_test_support::parse_raw_expr;
 use goldenfile::Mint;
 use jsonb::OwnedJsonb;
 
@@ -235,7 +235,7 @@ fn test_find_leveled_eq_filters() {
     ];
 
     for (text, expected_catalog, expected_database, expected_table) in cases {
-        let raw_expr = test_utils::parse_raw_expr(text, &cols);
+        let raw_expr = parse_raw_expr(text, &cols, &BUILTIN_FUNCTIONS);
 
         let expr = type_check::check(&raw_expr, &BUILTIN_FUNCTIONS).unwrap();
         let expr = type_check::rewrite_function_to_cast(expr);

src/query/functions/tests/it/type_check.rs

@@ -177,6 +177,7 @@ zip = { workspace = true }
 
 [dev-dependencies]
 arrow-cast = { workspace = true }
+databend-common-sql-test-support = { workspace = true }
 databend-storages-common-pruner = { workspace = true }
 geo = { workspace = true }
 goldenfile = { workspace = true }