From d73c26cd135b1c0f94a84dafd7b7741b266414f6 Mon Sep 17 00:00:00 2001 From: "Alex Chi Z." <4198311+skyzh@users.noreply.github.com> Date: Sat, 26 Oct 2024 17:41:22 -0400 Subject: [PATCH] refactor(sqlplannertest): further split test cases, support specify rules enabled (#190) * Split TPC-H test cases * Add the test case that causes cycles Signed-off-by: Alex Chi --- datafusion-optd-cli/src/main.rs | 6 +- datafusion-optd-cli/tests/cli_integration.rs | 2 +- .../tpch-sf0_01/simple_manual_test.sql | 4 +- optd-core/src/cascades/optimizer.rs | 13 +- optd-datafusion-repr/src/lib.rs | 1 + optd-sqlplannertest/README.md | 1 + optd-sqlplannertest/src/lib.rs | 124 +- .../join_enumerate.planner.sql | 0 .../tests/{basic => joins}/join_enumerate.yml | 0 .../pushdowns/fliter_transpose.planner.sql | 35 + .../tests/pushdowns/fliter_transpose.yml | 15 + .../subqueries/subquery_unnesting.planner.sql | 25 + .../tests/tpch/tpch-01-05.planner.sql | 654 +++++ optd-sqlplannertest/tests/tpch/tpch-01-05.yml | 213 ++ .../tests/tpch/tpch-06-10.planner.sql | 862 +++++++ optd-sqlplannertest/tests/tpch/tpch-06-10.yml | 293 +++ .../tests/tpch/tpch-11-15.planner.sql | 631 +++++ optd-sqlplannertest/tests/tpch/tpch-11-15.yml | 197 ++ .../tests/tpch/tpch-16-20.planner.sql | 396 +++ optd-sqlplannertest/tests/tpch/tpch-16-20.yml | 144 ++ .../tests/tpch/tpch.planner.sql | 2273 ----------------- optd-sqlplannertest/tests/tpch/tpch.yml | 583 ----- 22 files changed, 3583 insertions(+), 2889 deletions(-) rename optd-sqlplannertest/tests/{basic => joins}/join_enumerate.planner.sql (100%) rename optd-sqlplannertest/tests/{basic => joins}/join_enumerate.yml (100%) create mode 100644 optd-sqlplannertest/tests/pushdowns/fliter_transpose.planner.sql create mode 100644 optd-sqlplannertest/tests/pushdowns/fliter_transpose.yml create mode 100644 optd-sqlplannertest/tests/tpch/tpch-01-05.planner.sql create mode 100644 optd-sqlplannertest/tests/tpch/tpch-01-05.yml create mode 100644 optd-sqlplannertest/tests/tpch/tpch-06-10.planner.sql create mode 100644 optd-sqlplannertest/tests/tpch/tpch-06-10.yml create mode 100644 optd-sqlplannertest/tests/tpch/tpch-11-15.planner.sql create mode 100644 optd-sqlplannertest/tests/tpch/tpch-11-15.yml create mode 100644 optd-sqlplannertest/tests/tpch/tpch-16-20.planner.sql create mode 100644 optd-sqlplannertest/tests/tpch/tpch-16-20.yml delete mode 100644 optd-sqlplannertest/tests/tpch/tpch.planner.sql delete mode 100644 optd-sqlplannertest/tests/tpch/tpch.yml diff --git a/datafusion-optd-cli/src/main.rs b/datafusion-optd-cli/src/main.rs index f9d46526..b4c6f4b2 100644 --- a/datafusion-optd-cli/src/main.rs +++ b/datafusion-optd-cli/src/main.rs @@ -137,7 +137,7 @@ struct Args { maxrows: MaxRows, #[clap(long, help = "Turn on datafusion logical optimizer before optd")] - enable_logical: bool, + enable_df_logical: bool, #[clap(long, help = "Turn on adaptive optimization")] enable_adaptive: bool, @@ -164,7 +164,7 @@ pub async fn main() -> Result<()> { let mut session_config = SessionConfig::from_env()?.with_information_schema(true); - if !args.enable_logical { + if !args.enable_df_logical { session_config.options_mut().optimizer.max_passes = 0; } @@ -198,7 +198,7 @@ pub async fn main() -> Result<()> { let mut ctx = { let mut state = SessionState::new_with_config_rt(session_config.clone(), Arc::new(runtime_env)); - if !args.enable_logical { + if !args.enable_df_logical { // clean up optimizer rules so that we can plug in our own optimizer state = state.with_optimizer_rules(vec![]); state = state.with_physical_optimizer_rules(vec![]); diff --git a/datafusion-optd-cli/tests/cli_integration.rs b/datafusion-optd-cli/tests/cli_integration.rs index 1d77b8e9..27145df7 100644 --- a/datafusion-optd-cli/tests/cli_integration.rs +++ b/datafusion-optd-cli/tests/cli_integration.rs @@ -56,7 +56,7 @@ fn cli_test_tpch() { let mut cmd = Command::cargo_bin("datafusion-optd-cli").unwrap(); cmd.current_dir(".."); // all paths in `test.sql` assume we're in the base dir of the repo cmd.args([ - "--enable-logical", + "--enable-df-logical", "--file", "datafusion-optd-cli/tpch-sf0_01/test.sql", ]); diff --git a/datafusion-optd-cli/tpch-sf0_01/simple_manual_test.sql b/datafusion-optd-cli/tpch-sf0_01/simple_manual_test.sql index 27dac2e1..3303820a 100644 --- a/datafusion-optd-cli/tpch-sf0_01/simple_manual_test.sql +++ b/datafusion-optd-cli/tpch-sf0_01/simple_manual_test.sql @@ -1,5 +1,5 @@ -- This is just used if you want to run really simple manual tests on the CLI. Feel free to delete the whole thing and write your own manual tests --- Command: `cargo run --bin datafusion-optd-cli -- --enable-logical -f datafusion-optd-cli/tpch-sf0_01/simple_manual_test.sql` +-- Command: `cargo run --bin datafusion-optd-cli -- --enable-df-logical -f datafusion-optd-cli/tpch-sf0_01/simple_manual_test.sql` CREATE TABLE NATION ( N_NATIONKEY INT NOT NULL, N_NAME CHAR(25) NOT NULL, @@ -10,4 +10,4 @@ CREATE TABLE NATION ( CREATE EXTERNAL TABLE nation_tbl STORED AS CSV DELIMITER '|' LOCATION 'datafusion-optd-cli/tpch-sf0_01/nation.tbl'; insert into nation select column_1, column_2, column_3, column_4 from nation_tbl; -SELECT * FROM nation where nation.n_nationkey = 1 OR nation.n_nationkey = 2 OR nation.n_nationkey = 5; \ No newline at end of file +SELECT * FROM nation where nation.n_nationkey = 1 OR nation.n_nationkey = 2 OR nation.n_nationkey = 5; diff --git a/optd-core/src/cascades/optimizer.rs b/optd-core/src/cascades/optimizer.rs index c312075f..92c70cfc 100644 --- a/optd-core/src/cascades/optimizer.rs +++ b/optd-core/src/cascades/optimizer.rs @@ -31,6 +31,7 @@ pub struct OptimizerContext { #[derive(Default, Clone, Debug)] pub struct OptimizerProperties { + pub partial_explore_temporarily_disabled: bool, /// If the number of rules applied exceeds this number, we stop applying logical rules. pub partial_explore_iter: Option, /// Plan space can be expanded by this number of times before we stop applying logical rules. @@ -86,6 +87,14 @@ impl CascadesOptimizer { Self::new_with_prop(rules, cost, property_builders, Default::default()) } + pub fn disable_explore_limit(&mut self) { + self.prop.partial_explore_temporarily_disabled = true; + } + + pub fn enable_explore_limit(&mut self) { + self.prop.partial_explore_temporarily_disabled = false; + } + pub fn new_with_prop( rules: Vec>>, cost: Box>, @@ -113,7 +122,7 @@ impl CascadesOptimizer { self.cost.clone() } - pub(super) fn rules(&self) -> Arc<[Arc>]> { + pub fn rules(&self) -> Arc<[Arc>]> { self.rules.clone() } @@ -229,7 +238,7 @@ impl CascadesOptimizer { let new_tasks = task.execute(self)?; self.tasks.extend(new_tasks); iter += 1; - if !self.ctx.budget_used { + if !self.ctx.budget_used && !self.prop.partial_explore_temporarily_disabled { let plan_space = self.memo.compute_plan_space(); if let Some(partial_explore_space) = self.prop.partial_explore_space { if plan_space - plan_space_begin > partial_explore_space { diff --git a/optd-datafusion-repr/src/lib.rs b/optd-datafusion-repr/src/lib.rs index 966a4629..b164649f 100644 --- a/optd-datafusion-repr/src/lib.rs +++ b/optd-datafusion-repr/src/lib.rs @@ -162,6 +162,7 @@ impl DatafusionOptimizer { Box::new(ColumnRefPropertyBuilder::new(catalog.clone())), ], OptimizerProperties { + partial_explore_temporarily_disabled: false, partial_explore_iter: Some(1 << 20), partial_explore_space: Some(1 << 10), }, diff --git a/optd-sqlplannertest/README.md b/optd-sqlplannertest/README.md index 590cfd23..522e3966 100644 --- a/optd-sqlplannertest/README.md +++ b/optd-sqlplannertest/README.md @@ -36,6 +36,7 @@ The `explain` and `execute` task will be run with datafusion's logical optimizer | -------------- | --------------------------------------- | | use_df_logical | Enable Datafusion's logical optimizer | | verbose | Display estimated cost in physical plan | +| logical_rules | Only enable these logical rules | Currently we have the following options for the explain task: diff --git a/optd-sqlplannertest/src/lib.rs b/optd-sqlplannertest/src/lib.rs index 76e55a44..261001fd 100644 --- a/optd-sqlplannertest/src/lib.rs +++ b/optd-sqlplannertest/src/lib.rs @@ -13,12 +13,13 @@ use optd_datafusion_bridge::{DatafusionCatalog, OptdQueryPlanner}; use optd_datafusion_repr::cost::BaseTableStats; use optd_datafusion_repr::DatafusionOptimizer; use regex::Regex; +use std::collections::HashSet; use std::sync::Arc; #[global_allocator] static GLOBAL: MiMalloc = MiMalloc; -use anyhow::{Context, Result}; +use anyhow::{bail, Result}; use async_trait::async_trait; #[derive(Default)] @@ -26,16 +27,19 @@ pub struct DatafusionDBMS { ctx: SessionContext, /// Context enabling datafusion's logical optimizer. use_df_logical_ctx: SessionContext, + /// Shared optd optimizer (for tweaking config) + optd_optimizer: Option>, } impl DatafusionDBMS { pub async fn new() -> Result { - let ctx = DatafusionDBMS::new_session_ctx(false, None).await?; - let use_df_logical_ctx = + let (ctx, optd_optimizer) = DatafusionDBMS::new_session_ctx(false, None).await?; + let (use_df_logical_ctx, _) = DatafusionDBMS::new_session_ctx(true, Some(ctx.state().catalog_list().clone())).await?; Ok(Self { ctx, use_df_logical_ctx, + optd_optimizer: Some(optd_optimizer), }) } @@ -43,7 +47,7 @@ impl DatafusionDBMS { async fn new_session_ctx( use_df_logical: bool, catalog: Option>, - ) -> Result { + ) -> Result<(SessionContext, Arc)> { let mut session_config = SessionConfig::from_env()?.with_information_schema(true); if !use_df_logical { session_config.options_mut().optimizer.max_passes = 0; @@ -51,6 +55,7 @@ impl DatafusionDBMS { let rn_config = RuntimeConfig::new(); let runtime_env = RuntimeEnv::new(rn_config.clone())?; + let optd_optimizer; let ctx = { let mut state = if let Some(catalog) = catalog { @@ -73,20 +78,63 @@ impl DatafusionDBMS { } state = state.with_physical_optimizer_rules(vec![]); // use optd-bridge query planner - state = state.with_query_planner(Arc::new(OptdQueryPlanner::new(optimizer))); + optd_optimizer = Arc::new(OptdQueryPlanner::new(optimizer)); + state = state.with_query_planner(optd_optimizer.clone()); SessionContext::new_with_state(state) }; ctx.refresh_catalogs().await?; - Ok(ctx) + Ok((ctx, optd_optimizer)) } - pub async fn execute(&self, sql: &str, use_df_logical: bool) -> Result>> { + pub(crate) async fn execute(&self, sql: &str, flags: &TestFlags) -> Result>> { + { + let mut guard = self + .optd_optimizer + .as_ref() + .unwrap() + .optimizer + .lock() + .unwrap(); + let optimizer = guard.as_mut().unwrap().optd_optimizer_mut(); + if flags.disable_explore_limit { + optimizer.disable_explore_limit(); + } else { + optimizer.enable_explore_limit(); + } + let rules = optimizer.rules(); + if flags.enable_logical_rules.is_empty() { + for r in 0..rules.len() { + optimizer.enable_rule(r); + } + } else { + for (rule_id, rule) in rules.as_ref().iter().enumerate() { + if rule.rule.is_impl_rule() { + optimizer.enable_rule(rule_id); + } else { + optimizer.disable_rule(rule_id); + } + } + let mut rules_to_enable = flags + .enable_logical_rules + .iter() + .map(|x| x.as_str()) + .collect::>(); + for (rule_id, rule) in rules.as_ref().iter().enumerate() { + if rules_to_enable.remove(rule.rule.name()) { + optimizer.enable_rule(rule_id); + } + } + if !rules_to_enable.is_empty() { + bail!("Unknown logical rule: {:?}", rules_to_enable); + } + } + } let sql = unescape_input(sql)?; let dialect = Box::new(GenericDialect); let statements = DFParser::parse_sql_with_dialect(&sql, dialect.as_ref())?; let mut result = Vec::new(); for statement in statements { - let df = if use_df_logical { + let df = if flags.enable_df_logical { let plan = self .use_df_logical_ctx .state() @@ -95,6 +143,7 @@ impl DatafusionDBMS { self.use_df_logical_ctx.execute_logical_plan(plan).await? } else { let plan = self.ctx.state().statement_to_plan(statement).await?; + self.ctx.execute_logical_plan(plan).await? }; @@ -123,10 +172,12 @@ impl DatafusionDBMS { } /// Executes the `execute` task. - async fn task_execute(&mut self, r: &mut String, sql: &str, flags: &[String]) -> Result<()> { + async fn task_execute(&mut self, r: &mut String, sql: &str, flags: &TestFlags) -> Result<()> { use std::fmt::Write; - let use_df_logical = flags.contains(&"use_df_logical".to_string()); - let result = self.execute(sql, use_df_logical).await?; + if flags.verbose { + bail!("Verbose flag is not supported for execute task"); + } + let result = self.execute(sql, flags).await?; writeln!(r, "{}", result.into_iter().map(|x| x.join(" ")).join("\n"))?; writeln!(r)?; Ok(()) @@ -138,19 +189,18 @@ impl DatafusionDBMS { r: &mut String, sql: &str, task: &str, - flags: &[String], + flags: &TestFlags, ) -> Result<()> { use std::fmt::Write; - let use_df_logical = flags.contains(&"use_df_logical".to_string()); - let verbose = flags.contains(&"verbose".to_string()); + let verbose = flags.verbose; let explain_sql = if verbose { format!("explain verbose {}", &sql) } else { format!("explain {}", &sql) }; - let result = self.execute(&explain_sql, use_df_logical).await?; - let subtask_start_pos = task.find(':').unwrap() + 1; + let result = self.execute(&explain_sql, flags).await?; + let subtask_start_pos = task.rfind(':').unwrap() + 1; for subtask in task[subtask_start_pos..].split(',') { let subtask = subtask.trim(); if subtask == "logical_datafusion" { @@ -163,7 +213,7 @@ impl DatafusionDBMS { .map(|x| &x[1]) .unwrap() )?; - } else if subtask == "logical_optd_heuristic" { + } else if subtask == "logical_optd_heuristic" || subtask == "optimized_logical_optd" { writeln!( r, "{}", @@ -225,6 +275,8 @@ impl DatafusionDBMS { .map(|x| &x[1]) .unwrap() )?; + } else { + bail!("Unknown subtask: {}", subtask); } } @@ -235,10 +287,8 @@ impl DatafusionDBMS { #[async_trait] impl sqlplannertest::PlannerTestRunner for DatafusionDBMS { async fn run(&mut self, test_case: &sqlplannertest::ParsedTestCase) -> Result { - for before in &test_case.before_sql { - self.execute(before, true) - .await - .context("before execution error")?; + if !test_case.before_sql.is_empty() { + panic!("before is not supported in optd-sqlplannertest, always specify the task type to run"); } let mut result = String::new(); @@ -259,18 +309,42 @@ lazy_static! { static ref FLAGS_REGEX: Regex = Regex::new(r"\[(.*)\]").unwrap(); } +#[derive(Default, Debug)] +struct TestFlags { + verbose: bool, + enable_df_logical: bool, + enable_logical_rules: Vec, + disable_explore_limit: bool, +} + /// Extract the flags from a task. The flags are specified in square brackets. /// For example, the flags for the task `explain[use_df_logical, verbose]` are `["use_df_logical", "verbose"]`. -fn extract_flags(task: &str) -> Result> { +fn extract_flags(task: &str) -> Result { if let Some(captures) = FLAGS_REGEX.captures(task) { - Ok(captures + let flags = captures .get(1) .unwrap() .as_str() .split(',') .map(|x| x.trim().to_string()) - .collect()) + .collect_vec(); + let mut options = TestFlags::default(); + for flag in flags { + if flag == "verbose" { + options.verbose = true; + } else if flag == "use_df_logical" { + options.enable_df_logical = true; + } else if flag.starts_with("logical_rules") { + options.enable_logical_rules = + flag.split('+').skip(1).map(|x| x.to_string()).collect(); + } else if flag == "disable_explore_limit" { + options.disable_explore_limit = true; + } else { + bail!("Unknown flag: {}", flag); + } + } + Ok(options) } else { - Ok(vec![]) + Ok(TestFlags::default()) } } diff --git a/optd-sqlplannertest/tests/basic/join_enumerate.planner.sql b/optd-sqlplannertest/tests/joins/join_enumerate.planner.sql similarity index 100% rename from optd-sqlplannertest/tests/basic/join_enumerate.planner.sql rename to optd-sqlplannertest/tests/joins/join_enumerate.planner.sql diff --git a/optd-sqlplannertest/tests/basic/join_enumerate.yml b/optd-sqlplannertest/tests/joins/join_enumerate.yml similarity index 100% rename from optd-sqlplannertest/tests/basic/join_enumerate.yml rename to optd-sqlplannertest/tests/joins/join_enumerate.yml diff --git a/optd-sqlplannertest/tests/pushdowns/fliter_transpose.planner.sql b/optd-sqlplannertest/tests/pushdowns/fliter_transpose.planner.sql new file mode 100644 index 00000000..727c1168 --- /dev/null +++ b/optd-sqlplannertest/tests/pushdowns/fliter_transpose.planner.sql @@ -0,0 +1,35 @@ +-- (no id or description) +create table t1(t1v1 int, t1v2 int); +create table t2(t2v1 int, t2v3 int); +insert into t1 values (0, 0), (1, 1), (2, 2); +insert into t2 values (0, 200), (1, 201), (2, 202); + +/* +3 +3 +*/ + +-- Test whether we can transpose filter and projection +SELECT t1.t1v1, t1.t1v2, t2.t2v3 + FROM t1, t2 + WHERE t1.t1v1 = t2.t2v1; + +/* +LogicalProjection { exprs: [ #0, #1, #3 ] } +└── LogicalFilter + ├── cond:Eq + │ ├── #0 + │ └── #2 + └── LogicalJoin { join_type: Cross, cond: true } + ├── LogicalScan { table: t1 } + └── LogicalScan { table: t2 } +PhysicalProjection { exprs: [ #0, #1, #3 ] } +└── PhysicalFilter + ├── cond:Eq + │ ├── #0 + │ └── #2 + └── PhysicalNestedLoopJoin { join_type: Cross, cond: true } + ├── PhysicalScan { table: t1 } + └── PhysicalScan { table: t2 } +*/ + diff --git a/optd-sqlplannertest/tests/pushdowns/fliter_transpose.yml b/optd-sqlplannertest/tests/pushdowns/fliter_transpose.yml new file mode 100644 index 00000000..ebdf91ff --- /dev/null +++ b/optd-sqlplannertest/tests/pushdowns/fliter_transpose.yml @@ -0,0 +1,15 @@ +- sql: | + create table t1(t1v1 int, t1v2 int); + create table t2(t2v1 int, t2v3 int); + insert into t1 values (0, 0), (1, 1), (2, 2); + insert into t2 values (0, 200), (1, 201), (2, 202); + tasks: + - execute[use_df_logical] +- sql: | + SELECT t1.t1v1, t1.t1v2, t2.t2v3 + FROM t1, t2 + WHERE t1.t1v1 = t2.t2v1; + desc: Test whether we can transpose filter and projection + tasks: + # - explain[logical_rules:filter_project_transpose_rule+project_filter_transpose_rule,disable_explore_limit]:logical_optd,physical_optd + - explain[logical_rules:filter_project_transpose_rule+project_filter_transpose_rule]:logical_optd,physical_optd diff --git a/optd-sqlplannertest/tests/subqueries/subquery_unnesting.planner.sql b/optd-sqlplannertest/tests/subqueries/subquery_unnesting.planner.sql index 6679a17f..043c7c84 100644 --- a/optd-sqlplannertest/tests/subqueries/subquery_unnesting.planner.sql +++ b/optd-sqlplannertest/tests/subqueries/subquery_unnesting.planner.sql @@ -28,6 +28,31 @@ LogicalProjection { exprs: [ #0, #1 ] } │ ├── #0 │ └── Extern(#0) └── LogicalScan { table: t2 } +LogicalProjection { exprs: [ #0, #1 ] } +└── LogicalFilter + ├── cond:Gt + │ ├── #2 + │ └── 100(i64) + └── LogicalProjection { exprs: [ #0, #1, #3 ] } + └── LogicalJoin + ├── join_type: Inner + ├── cond:Eq + │ ├── #0 + │ └── #2 + ├── LogicalScan { table: t1 } + └── LogicalProjection { exprs: [ #0, #1 ] } + └── LogicalAgg + ├── exprs:Agg(Sum) + │ └── [ Cast { cast_to: Int64, expr: #2 } ] + ├── groups: [ #1 ] + └── LogicalFilter + ├── cond:Eq + │ ├── #1 + │ └── #0 + └── LogicalJoin { join_type: Inner, cond: true } + ├── LogicalAgg { exprs: [], groups: [ #0 ] } + │ └── LogicalScan { table: t1 } + └── LogicalScan { table: t2 } PhysicalProjection { exprs: [ #0, #1 ] } └── PhysicalProjection { exprs: [ #0, #1, #3 ] } └── PhysicalProjection { exprs: [ #2, #3, #0, #1 ] } diff --git a/optd-sqlplannertest/tests/tpch/tpch-01-05.planner.sql b/optd-sqlplannertest/tests/tpch/tpch-01-05.planner.sql new file mode 100644 index 00000000..e6383264 --- /dev/null +++ b/optd-sqlplannertest/tests/tpch/tpch-01-05.planner.sql @@ -0,0 +1,654 @@ +-- TPC-H schema +CREATE TABLE NATION ( + N_NATIONKEY INT NOT NULL, + N_NAME CHAR(25) NOT NULL, + N_REGIONKEY INT NOT NULL, + N_COMMENT VARCHAR(152) +); + +CREATE TABLE REGION ( + R_REGIONKEY INT NOT NULL, + R_NAME CHAR(25) NOT NULL, + R_COMMENT VARCHAR(152) +); + +CREATE TABLE PART ( + P_PARTKEY INT NOT NULL, + P_NAME VARCHAR(55) NOT NULL, + P_MFGR CHAR(25) NOT NULL, + P_BRAND CHAR(10) NOT NULL, + P_TYPE VARCHAR(25) NOT NULL, + P_SIZE INT NOT NULL, + P_CONTAINER CHAR(10) NOT NULL, + P_RETAILPRICE DECIMAL(15,2) NOT NULL, + P_COMMENT VARCHAR(23) NOT NULL +); + +CREATE TABLE SUPPLIER ( + S_SUPPKEY INT NOT NULL, + S_NAME CHAR(25) NOT NULL, + S_ADDRESS VARCHAR(40) NOT NULL, + S_NATIONKEY INT NOT NULL, + S_PHONE CHAR(15) NOT NULL, + S_ACCTBAL DECIMAL(15,2) NOT NULL, + S_COMMENT VARCHAR(101) NOT NULL +); + +CREATE TABLE PARTSUPP ( + PS_PARTKEY INT NOT NULL, + PS_SUPPKEY INT NOT NULL, + PS_AVAILQTY INT NOT NULL, + PS_SUPPLYCOST DECIMAL(15,2) NOT NULL, + PS_COMMENT VARCHAR(199) NOT NULL +); + +CREATE TABLE CUSTOMER ( + C_CUSTKEY INT NOT NULL, + C_NAME VARCHAR(25) NOT NULL, + C_ADDRESS VARCHAR(40) NOT NULL, + C_NATIONKEY INT NOT NULL, + C_PHONE CHAR(15) NOT NULL, + C_ACCTBAL DECIMAL(15,2) NOT NULL, + C_MKTSEGMENT CHAR(10) NOT NULL, + C_COMMENT VARCHAR(117) NOT NULL +); + +CREATE TABLE ORDERS ( + O_ORDERKEY INT NOT NULL, + O_CUSTKEY INT NOT NULL, + O_ORDERSTATUS CHAR(1) NOT NULL, + O_TOTALPRICE DECIMAL(15,2) NOT NULL, + O_ORDERDATE DATE NOT NULL, + O_ORDERPRIORITY CHAR(15) NOT NULL, + O_CLERK CHAR(15) NOT NULL, + O_SHIPPRIORITY INT NOT NULL, + O_COMMENT VARCHAR(79) NOT NULL +); + +CREATE TABLE LINEITEM ( + L_ORDERKEY INT NOT NULL, + L_PARTKEY INT NOT NULL, + L_SUPPKEY INT NOT NULL, + L_LINENUMBER INT NOT NULL, + L_QUANTITY DECIMAL(15,2) NOT NULL, + L_EXTENDEDPRICE DECIMAL(15,2) NOT NULL, + L_DISCOUNT DECIMAL(15,2) NOT NULL, + L_TAX DECIMAL(15,2) NOT NULL, + L_RETURNFLAG CHAR(1) NOT NULL, + L_LINESTATUS CHAR(1) NOT NULL, + L_SHIPDATE DATE NOT NULL, + L_COMMITDATE DATE NOT NULL, + L_RECEIPTDATE DATE NOT NULL, + L_SHIPINSTRUCT CHAR(25) NOT NULL, + L_SHIPMODE CHAR(10) NOT NULL, + L_COMMENT VARCHAR(44) NOT NULL +); + +/* + +*/ + +-- TPC-H Q1 +SELECT + l_returnflag, + l_linestatus, + sum(l_quantity) as sum_qty, + sum(l_extendedprice) as sum_base_price, + sum(l_extendedprice * (1 - l_discount)) as sum_disc_price, + sum(l_extendedprice * (1 - l_discount) * (1 + l_tax)) as sum_charge, + avg(l_quantity) as avg_qty, + avg(l_extendedprice) as avg_price, + avg(l_discount) as avg_disc, + count(*) as count_order +FROM + lineitem +WHERE + l_shipdate <= date '1998-12-01' - interval '90' day +GROUP BY + l_returnflag, l_linestatus +ORDER BY + l_returnflag, l_linestatus; + +/* +LogicalSort +├── exprs: +│ ┌── SortOrder { order: Asc } +│ │ └── #0 +│ └── SortOrder { order: Asc } +│ └── #1 +└── LogicalProjection { exprs: [ #0, #1, #2, #3, #4, #5, #6, #7, #8, #9 ] } + └── LogicalAgg + ├── exprs: + │ ┌── Agg(Sum) + │ │ └── [ #4 ] + │ ├── Agg(Sum) + │ │ └── [ #5 ] + │ ├── Agg(Sum) + │ │ └── Mul + │ │ ├── #5 + │ │ └── Sub + │ │ ├── Cast { cast_to: Decimal128(20, 0), expr: 1(i64) } + │ │ └── #6 + │ ├── Agg(Sum) + │ │ └── Mul + │ │ ├── Mul + │ │ │ ├── #5 + │ │ │ └── Sub + │ │ │ ├── Cast { cast_to: Decimal128(20, 0), expr: 1(i64) } + │ │ │ └── #6 + │ │ └── Add + │ │ ├── Cast { cast_to: Decimal128(20, 0), expr: 1(i64) } + │ │ └── #7 + │ ├── Agg(Avg) + │ │ └── [ #4 ] + │ ├── Agg(Avg) + │ │ └── [ #5 ] + │ ├── Agg(Avg) + │ │ └── [ #6 ] + │ └── Agg(Count) + │ └── [ 1(u8) ] + ├── groups: [ #8, #9 ] + └── LogicalFilter + ├── cond:Leq + │ ├── #10 + │ └── Sub + │ ├── Cast { cast_to: Date32, expr: "1998-12-01" } + │ └── INTERVAL_MONTH_DAY_NANO (0, 90, 0) + └── LogicalScan { table: lineitem } +PhysicalSort +├── exprs: +│ ┌── SortOrder { order: Asc } +│ │ └── #0 +│ └── SortOrder { order: Asc } +│ └── #1 +└── PhysicalProjection { exprs: [ #0, #1, #2, #3, #4, #5, #6, #7, #8, #9 ] } + └── PhysicalAgg + ├── aggrs: + │ ┌── Agg(Sum) + │ │ └── [ #4 ] + │ ├── Agg(Sum) + │ │ └── [ #5 ] + │ ├── Agg(Sum) + │ │ └── Mul + │ │ ├── #5 + │ │ └── Sub + │ │ ├── Cast { cast_to: Decimal128(20, 0), expr: 1(i64) } + │ │ └── #6 + │ ├── Agg(Sum) + │ │ └── Mul + │ │ ├── Mul + │ │ │ ├── #5 + │ │ │ └── Sub + │ │ │ ├── Cast { cast_to: Decimal128(20, 0), expr: 1(i64) } + │ │ │ └── #6 + │ │ └── Add + │ │ ├── Cast { cast_to: Decimal128(20, 0), expr: 1(i64) } + │ │ └── #7 + │ ├── Agg(Avg) + │ │ └── [ #4 ] + │ ├── Agg(Avg) + │ │ └── [ #5 ] + │ ├── Agg(Avg) + │ │ └── [ #6 ] + │ └── Agg(Count) + │ └── [ 1(u8) ] + ├── groups: [ #8, #9 ] + └── PhysicalFilter + ├── cond:Leq + │ ├── #10 + │ └── Sub + │ ├── Cast { cast_to: Date32, expr: "1998-12-01" } + │ └── INTERVAL_MONTH_DAY_NANO (0, 90, 0) + └── PhysicalScan { table: lineitem } +*/ + +-- TPC-H Q2 +select + s_acctbal, + s_name, + n_name, + p_partkey, + p_mfgr, + s_address, + s_phone, + s_comment +from + part, + supplier, + partsupp, + nation, + region +where + p_partkey = ps_partkey + and s_suppkey = ps_suppkey +and p_size = 4 +and p_type like '%TIN' + and s_nationkey = n_nationkey + and n_regionkey = r_regionkey + and r_name = 'AFRICA' + and ps_supplycost = ( + select + min(ps_supplycost) + from + partsupp, + supplier, + nation, + region + where + p_partkey = ps_partkey + and s_suppkey = ps_suppkey + and s_nationkey = n_nationkey + and n_regionkey = r_regionkey + and r_name = 'AFRICA' + ) +order by + s_acctbal desc, + n_name, + s_name, + p_partkey +limit 100; + +/* +LogicalLimit { skip: 0(u64), fetch: 100(u64) } +└── LogicalSort + ├── exprs: + │ ┌── SortOrder { order: Desc } + │ │ └── #0 + │ ├── SortOrder { order: Asc } + │ │ └── #2 + │ ├── SortOrder { order: Asc } + │ │ └── #1 + │ └── SortOrder { order: Asc } + │ └── #3 + └── LogicalProjection { exprs: [ #5, #2, #8, #0, #1, #3, #4, #6 ] } + └── LogicalJoin + ├── join_type: Inner + ├── cond:And + │ ├── Eq + │ │ ├── #0 + │ │ └── #10 + │ └── Eq + │ ├── #7 + │ └── #9 + ├── LogicalProjection { exprs: [ #0, #1, #2, #3, #4, #5, #6, #7, #8 ] } + │ └── LogicalJoin + │ ├── join_type: Inner + │ ├── cond:Eq + │ │ ├── #9 + │ │ └── #10 + │ ├── LogicalProjection { exprs: [ #0, #1, #2, #3, #5, #6, #7, #8, #10, #11 ] } + │ │ └── LogicalJoin + │ │ ├── join_type: Inner + │ │ ├── cond:Eq + │ │ │ ├── #4 + │ │ │ └── #9 + │ │ ├── LogicalProjection { exprs: [ #0, #1, #5, #6, #7, #8, #9, #10, #3 ] } + │ │ │ └── LogicalJoin + │ │ │ ├── join_type: Inner + │ │ │ ├── cond:Eq + │ │ │ │ ├── #2 + │ │ │ │ └── #4 + │ │ │ ├── LogicalProjection { exprs: [ #0, #1, #3, #4 ] } + │ │ │ │ └── LogicalJoin + │ │ │ │ ├── join_type: Inner + │ │ │ │ ├── cond:Eq + │ │ │ │ │ ├── #0 + │ │ │ │ │ └── #2 + │ │ │ │ ├── LogicalProjection { exprs: [ #0, #1 ] } + │ │ │ │ │ └── LogicalFilter + │ │ │ │ │ ├── cond:And + │ │ │ │ │ │ ├── Eq + │ │ │ │ │ │ │ ├── #3 + │ │ │ │ │ │ │ └── 4(i32) + │ │ │ │ │ │ └── Like { expr: #2, pattern: "%TIN", negated: false, case_insensitive: false } + │ │ │ │ │ └── LogicalProjection { exprs: [ #0, #2, #4, #5 ] } + │ │ │ │ │ └── LogicalScan { table: part } + │ │ │ │ └── LogicalProjection { exprs: [ #0, #1, #3 ] } + │ │ │ │ └── LogicalScan { table: partsupp } + │ │ │ └── LogicalProjection { exprs: [ #0, #1, #2, #3, #4, #5, #6 ] } + │ │ │ └── LogicalScan { table: supplier } + │ │ └── LogicalProjection { exprs: [ #0, #1, #2 ] } + │ │ └── LogicalScan { table: nation } + │ └── LogicalProjection { exprs: [ #0 ] } + │ └── LogicalFilter + │ ├── cond:Eq + │ │ ├── #1 + │ │ └── "AFRICA" + │ └── LogicalProjection { exprs: [ #0, #1 ] } + │ └── LogicalScan { table: region } + └── LogicalProjection { exprs: [ #1, #0 ] } + └── LogicalAgg + ├── exprs:Agg(Min) + │ └── [ #1 ] + ├── groups: [ #0 ] + └── LogicalProjection { exprs: [ #0, #1 ] } + └── LogicalJoin + ├── join_type: Inner + ├── cond:Eq + │ ├── #2 + │ └── #3 + ├── LogicalProjection { exprs: [ #0, #1, #4 ] } + │ └── LogicalJoin + │ ├── join_type: Inner + │ ├── cond:Eq + │ │ ├── #2 + │ │ └── #3 + │ ├── LogicalProjection { exprs: [ #0, #2, #4 ] } + │ │ └── LogicalJoin + │ │ ├── join_type: Inner + │ │ ├── cond:Eq + │ │ │ ├── #1 + │ │ │ └── #3 + │ │ ├── LogicalProjection { exprs: [ #0, #1, #3 ] } + │ │ │ └── LogicalScan { table: partsupp } + │ │ └── LogicalProjection { exprs: [ #0, #3 ] } + │ │ └── LogicalScan { table: supplier } + │ └── LogicalProjection { exprs: [ #0, #2 ] } + │ └── LogicalScan { table: nation } + └── LogicalProjection { exprs: [ #0 ] } + └── LogicalFilter + ├── cond:Eq + │ ├── #1 + │ └── "AFRICA" + └── LogicalProjection { exprs: [ #0, #1 ] } + └── LogicalScan { table: region } +PhysicalLimit { skip: 0(u64), fetch: 100(u64) } +└── PhysicalSort + ├── exprs: + │ ┌── SortOrder { order: Desc } + │ │ └── #0 + │ ├── SortOrder { order: Asc } + │ │ └── #2 + │ ├── SortOrder { order: Asc } + │ │ └── #1 + │ └── SortOrder { order: Asc } + │ └── #3 + └── PhysicalProjection { exprs: [ #5, #2, #8, #0, #1, #3, #4, #6 ] } + └── PhysicalHashJoin { join_type: Inner, left_keys: [ #0, #7 ], right_keys: [ #1, #0 ] } + ├── PhysicalProjection { exprs: [ #0, #1, #2, #3, #4, #5, #6, #7, #8 ] } + │ └── PhysicalHashJoin { join_type: Inner, left_keys: [ #9 ], right_keys: [ #0 ] } + │ ├── PhysicalProjection { exprs: [ #0, #1, #2, #3, #5, #6, #7, #8, #10, #11 ] } + │ │ └── PhysicalHashJoin { join_type: Inner, left_keys: [ #4 ], right_keys: [ #0 ] } + │ │ ├── PhysicalProjection { exprs: [ #0, #1, #5, #6, #7, #8, #9, #10, #3 ] } + │ │ │ └── PhysicalHashJoin { join_type: Inner, left_keys: [ #2 ], right_keys: [ #0 ] } + │ │ │ ├── PhysicalProjection { exprs: [ #0, #1, #3, #4 ] } + │ │ │ │ └── PhysicalHashJoin { join_type: Inner, left_keys: [ #0 ], right_keys: [ #0 ] } + │ │ │ │ ├── PhysicalProjection { exprs: [ #0, #1 ] } + │ │ │ │ │ └── PhysicalProjection { exprs: [ #0, #2, #4, #5 ] } + │ │ │ │ │ └── PhysicalFilter + │ │ │ │ │ ├── cond:And + │ │ │ │ │ │ ├── Eq + │ │ │ │ │ │ │ ├── #5 + │ │ │ │ │ │ │ └── 4(i32) + │ │ │ │ │ │ └── Like { expr: #4, pattern: "%TIN", negated: false, case_insensitive: false } + │ │ │ │ │ └── PhysicalScan { table: part } + │ │ │ │ └── PhysicalProjection { exprs: [ #0, #1, #3 ] } + │ │ │ │ └── PhysicalScan { table: partsupp } + │ │ │ └── PhysicalProjection { exprs: [ #0, #1, #2, #3, #4, #5, #6 ] } + │ │ │ └── PhysicalScan { table: supplier } + │ │ └── PhysicalProjection { exprs: [ #0, #1, #2 ] } + │ │ └── PhysicalScan { table: nation } + │ └── PhysicalProjection { exprs: [ #0 ] } + │ └── PhysicalProjection { exprs: [ #0, #1 ] } + │ └── PhysicalFilter + │ ├── cond:Eq + │ │ ├── #1 + │ │ └── "AFRICA" + │ └── PhysicalScan { table: region } + └── PhysicalProjection { exprs: [ #1, #0 ] } + └── PhysicalAgg + ├── aggrs:Agg(Min) + │ └── [ #1 ] + ├── groups: [ #0 ] + └── PhysicalProjection { exprs: [ #0, #1 ] } + └── PhysicalHashJoin { join_type: Inner, left_keys: [ #2 ], right_keys: [ #0 ] } + ├── PhysicalProjection { exprs: [ #0, #1, #4 ] } + │ └── PhysicalHashJoin { join_type: Inner, left_keys: [ #2 ], right_keys: [ #0 ] } + │ ├── PhysicalProjection { exprs: [ #0, #2, #4 ] } + │ │ └── PhysicalHashJoin { join_type: Inner, left_keys: [ #1 ], right_keys: [ #0 ] } + │ │ ├── PhysicalProjection { exprs: [ #0, #1, #3 ] } + │ │ │ └── PhysicalScan { table: partsupp } + │ │ └── PhysicalProjection { exprs: [ #0, #3 ] } + │ │ └── PhysicalScan { table: supplier } + │ └── PhysicalProjection { exprs: [ #0, #2 ] } + │ └── PhysicalScan { table: nation } + └── PhysicalProjection { exprs: [ #0 ] } + └── PhysicalProjection { exprs: [ #0, #1 ] } + └── PhysicalFilter + ├── cond:Eq + │ ├── #1 + │ └── "AFRICA" + └── PhysicalScan { table: region } +*/ + +-- TPC-H Q3 +SELECT + l_orderkey, + SUM(l_extendedprice * (1 - l_discount)) AS revenue, + o_orderdate, + o_shippriority +FROM + customer, + orders, + lineitem +WHERE + c_mktsegment = 'FURNITURE' + AND c_custkey = o_custkey + AND l_orderkey = o_orderkey + AND o_orderdate < DATE '1995-03-29' + AND l_shipdate > DATE '1995-03-29' +GROUP BY + l_orderkey, + o_orderdate, + o_shippriority +ORDER BY + revenue DESC, + o_orderdate LIMIT 10; + +/* +LogicalLimit { skip: 0(u64), fetch: 10(u64) } +└── LogicalSort + ├── exprs: + │ ┌── SortOrder { order: Desc } + │ │ └── #1 + │ └── SortOrder { order: Asc } + │ └── #2 + └── LogicalProjection { exprs: [ #0, #3, #1, #2 ] } + └── LogicalAgg + ├── exprs:Agg(Sum) + │ └── Mul + │ ├── #3 + │ └── Sub + │ ├── 1(float) + │ └── #4 + ├── groups: [ #2, #0, #1 ] + └── LogicalProjection { exprs: [ #1, #2, #3, #4, #5 ] } + └── LogicalJoin + ├── join_type: Inner + ├── cond:Eq + │ ├── #0 + │ └── #3 + ├── LogicalProjection { exprs: [ #1, #3, #4 ] } + │ └── LogicalJoin + │ ├── join_type: Inner + │ ├── cond:Eq + │ │ ├── #0 + │ │ └── #2 + │ ├── LogicalProjection { exprs: [ #0 ] } + │ │ └── LogicalFilter + │ │ ├── cond:Eq + │ │ │ ├── #1 + │ │ │ └── "FURNITURE" + │ │ └── LogicalProjection { exprs: [ #0, #6 ] } + │ │ └── LogicalScan { table: customer } + │ └── LogicalFilter + │ ├── cond:Lt + │ │ ├── #2 + │ │ └── 9218(i64) + │ └── LogicalProjection { exprs: [ #0, #1, #4, #7 ] } + │ └── LogicalScan { table: orders } + └── LogicalProjection { exprs: [ #0, #1, #2 ] } + └── LogicalFilter + ├── cond:Gt + │ ├── #3 + │ └── 9218(i64) + └── LogicalProjection { exprs: [ #0, #5, #6, #10 ] } + └── LogicalScan { table: lineitem } +PhysicalLimit { skip: 0(u64), fetch: 10(u64) } +└── PhysicalSort + ├── exprs: + │ ┌── SortOrder { order: Desc } + │ │ └── #1 + │ └── SortOrder { order: Asc } + │ └── #2 + └── PhysicalProjection { exprs: [ #0, #3, #1, #2 ] } + └── PhysicalAgg + ├── aggrs:Agg(Sum) + │ └── Mul + │ ├── #3 + │ └── Sub + │ ├── 1(float) + │ └── #4 + ├── groups: [ #2, #0, #1 ] + └── PhysicalProjection { exprs: [ #1, #2, #3, #4, #5 ] } + └── PhysicalHashJoin { join_type: Inner, left_keys: [ #0 ], right_keys: [ #0 ] } + ├── PhysicalProjection { exprs: [ #1, #3, #4 ] } + │ └── PhysicalHashJoin { join_type: Inner, left_keys: [ #0 ], right_keys: [ #1 ] } + │ ├── PhysicalProjection { exprs: [ #0 ] } + │ │ └── PhysicalProjection { exprs: [ #0, #6 ] } + │ │ └── PhysicalFilter + │ │ ├── cond:Eq + │ │ │ ├── #6 + │ │ │ └── "FURNITURE" + │ │ └── PhysicalScan { table: customer } + │ └── PhysicalProjection { exprs: [ #0, #1, #4, #7 ] } + │ └── PhysicalFilter + │ ├── cond:Lt + │ │ ├── #4 + │ │ └── 9218(i64) + │ └── PhysicalScan { table: orders } + └── PhysicalProjection { exprs: [ #0, #1, #2 ] } + └── PhysicalProjection { exprs: [ #0, #5, #6, #10 ] } + └── PhysicalFilter + ├── cond:Gt + │ ├── #10 + │ └── 9218(i64) + └── PhysicalScan { table: lineitem } +*/ + +-- TPC-H Q5 +SELECT + n_name AS nation, + SUM(l_extendedprice * (1 - l_discount)) AS revenue +FROM + customer, + orders, + lineitem, + supplier, + nation, + region +WHERE + c_custkey = o_custkey + AND l_orderkey = o_orderkey + AND l_suppkey = s_suppkey + AND c_nationkey = s_nationkey + AND s_nationkey = n_nationkey + AND n_regionkey = r_regionkey + AND r_name = 'Asia' -- Specified region + AND o_orderdate >= DATE '2023-01-01' + AND o_orderdate < DATE '2024-01-01' +GROUP BY + n_name +ORDER BY + revenue DESC; + +/* +LogicalSort +├── exprs:SortOrder { order: Desc } +│ └── #1 +└── LogicalProjection { exprs: [ #0, #1 ] } + └── LogicalAgg + ├── exprs:Agg(Sum) + │ └── Mul + │ ├── #22 + │ └── Sub + │ ├── Cast { cast_to: Decimal128(20, 0), expr: 1(i64) } + │ └── #23 + ├── groups: [ #41 ] + └── LogicalFilter + ├── cond:And + │ ├── Eq + │ │ ├── #0 + │ │ └── #9 + │ ├── Eq + │ │ ├── #17 + │ │ └── #8 + │ ├── Eq + │ │ ├── #19 + │ │ └── #33 + │ ├── Eq + │ │ ├── #3 + │ │ └── #36 + │ ├── Eq + │ │ ├── #36 + │ │ └── #40 + │ ├── Eq + │ │ ├── #42 + │ │ └── #44 + │ ├── Eq + │ │ ├── #45 + │ │ └── "Asia" + │ ├── Geq + │ │ ├── #12 + │ │ └── Cast { cast_to: Date32, expr: "2023-01-01" } + │ └── Lt + │ ├── #12 + │ └── Cast { cast_to: Date32, expr: "2024-01-01" } + └── LogicalJoin { join_type: Cross, cond: true } + ├── LogicalJoin { join_type: Cross, cond: true } + │ ├── LogicalJoin { join_type: Cross, cond: true } + │ │ ├── LogicalJoin { join_type: Cross, cond: true } + │ │ │ ├── LogicalJoin { join_type: Cross, cond: true } + │ │ │ │ ├── LogicalScan { table: customer } + │ │ │ │ └── LogicalScan { table: orders } + │ │ │ └── LogicalScan { table: lineitem } + │ │ └── LogicalScan { table: supplier } + │ └── LogicalScan { table: nation } + └── LogicalScan { table: region } +PhysicalSort +├── exprs:SortOrder { order: Desc } +│ └── #1 +└── PhysicalProjection { exprs: [ #0, #1 ] } + └── PhysicalAgg + ├── aggrs:Agg(Sum) + │ └── Mul + │ ├── #22 + │ └── Sub + │ ├── Cast { cast_to: Decimal128(20, 0), expr: 1(i64) } + │ └── #23 + ├── groups: [ #41 ] + └── PhysicalHashJoin { join_type: Inner, left_keys: [ #19, #3 ], right_keys: [ #0, #3 ] } + ├── PhysicalHashJoin { join_type: Inner, left_keys: [ #0 ], right_keys: [ #1 ] } + │ ├── PhysicalScan { table: customer } + │ └── PhysicalHashJoin { join_type: Inner, left_keys: [ #0 ], right_keys: [ #0 ] } + │ ├── PhysicalFilter + │ │ ├── cond:And + │ │ │ ├── Geq + │ │ │ │ ├── #4 + │ │ │ │ └── Cast { cast_to: Date32, expr: "2023-01-01" } + │ │ │ └── Lt + │ │ │ ├── #4 + │ │ │ └── Cast { cast_to: Date32, expr: "2024-01-01" } + │ │ └── PhysicalScan { table: orders } + │ └── PhysicalScan { table: lineitem } + └── PhysicalHashJoin { join_type: Inner, left_keys: [ #9 ], right_keys: [ #0 ] } + ├── PhysicalHashJoin { join_type: Inner, left_keys: [ #3 ], right_keys: [ #0 ] } + │ ├── PhysicalScan { table: supplier } + │ └── PhysicalScan { table: nation } + └── PhysicalFilter + ├── cond:Eq + │ ├── #1 + │ └── "Asia" + └── PhysicalScan { table: region } +*/ + diff --git a/optd-sqlplannertest/tests/tpch/tpch-01-05.yml b/optd-sqlplannertest/tests/tpch/tpch-01-05.yml new file mode 100644 index 00000000..9b4099c9 --- /dev/null +++ b/optd-sqlplannertest/tests/tpch/tpch-01-05.yml @@ -0,0 +1,213 @@ +- sql: | + CREATE TABLE NATION ( + N_NATIONKEY INT NOT NULL, + N_NAME CHAR(25) NOT NULL, + N_REGIONKEY INT NOT NULL, + N_COMMENT VARCHAR(152) + ); + + CREATE TABLE REGION ( + R_REGIONKEY INT NOT NULL, + R_NAME CHAR(25) NOT NULL, + R_COMMENT VARCHAR(152) + ); + + CREATE TABLE PART ( + P_PARTKEY INT NOT NULL, + P_NAME VARCHAR(55) NOT NULL, + P_MFGR CHAR(25) NOT NULL, + P_BRAND CHAR(10) NOT NULL, + P_TYPE VARCHAR(25) NOT NULL, + P_SIZE INT NOT NULL, + P_CONTAINER CHAR(10) NOT NULL, + P_RETAILPRICE DECIMAL(15,2) NOT NULL, + P_COMMENT VARCHAR(23) NOT NULL + ); + + CREATE TABLE SUPPLIER ( + S_SUPPKEY INT NOT NULL, + S_NAME CHAR(25) NOT NULL, + S_ADDRESS VARCHAR(40) NOT NULL, + S_NATIONKEY INT NOT NULL, + S_PHONE CHAR(15) NOT NULL, + S_ACCTBAL DECIMAL(15,2) NOT NULL, + S_COMMENT VARCHAR(101) NOT NULL + ); + + CREATE TABLE PARTSUPP ( + PS_PARTKEY INT NOT NULL, + PS_SUPPKEY INT NOT NULL, + PS_AVAILQTY INT NOT NULL, + PS_SUPPLYCOST DECIMAL(15,2) NOT NULL, + PS_COMMENT VARCHAR(199) NOT NULL + ); + + CREATE TABLE CUSTOMER ( + C_CUSTKEY INT NOT NULL, + C_NAME VARCHAR(25) NOT NULL, + C_ADDRESS VARCHAR(40) NOT NULL, + C_NATIONKEY INT NOT NULL, + C_PHONE CHAR(15) NOT NULL, + C_ACCTBAL DECIMAL(15,2) NOT NULL, + C_MKTSEGMENT CHAR(10) NOT NULL, + C_COMMENT VARCHAR(117) NOT NULL + ); + + CREATE TABLE ORDERS ( + O_ORDERKEY INT NOT NULL, + O_CUSTKEY INT NOT NULL, + O_ORDERSTATUS CHAR(1) NOT NULL, + O_TOTALPRICE DECIMAL(15,2) NOT NULL, + O_ORDERDATE DATE NOT NULL, + O_ORDERPRIORITY CHAR(15) NOT NULL, + O_CLERK CHAR(15) NOT NULL, + O_SHIPPRIORITY INT NOT NULL, + O_COMMENT VARCHAR(79) NOT NULL + ); + + CREATE TABLE LINEITEM ( + L_ORDERKEY INT NOT NULL, + L_PARTKEY INT NOT NULL, + L_SUPPKEY INT NOT NULL, + L_LINENUMBER INT NOT NULL, + L_QUANTITY DECIMAL(15,2) NOT NULL, + L_EXTENDEDPRICE DECIMAL(15,2) NOT NULL, + L_DISCOUNT DECIMAL(15,2) NOT NULL, + L_TAX DECIMAL(15,2) NOT NULL, + L_RETURNFLAG CHAR(1) NOT NULL, + L_LINESTATUS CHAR(1) NOT NULL, + L_SHIPDATE DATE NOT NULL, + L_COMMITDATE DATE NOT NULL, + L_RECEIPTDATE DATE NOT NULL, + L_SHIPINSTRUCT CHAR(25) NOT NULL, + L_SHIPMODE CHAR(10) NOT NULL, + L_COMMENT VARCHAR(44) NOT NULL + ); + desc: TPC-H schema + tasks: + - execute +- sql: | + SELECT + l_returnflag, + l_linestatus, + sum(l_quantity) as sum_qty, + sum(l_extendedprice) as sum_base_price, + sum(l_extendedprice * (1 - l_discount)) as sum_disc_price, + sum(l_extendedprice * (1 - l_discount) * (1 + l_tax)) as sum_charge, + avg(l_quantity) as avg_qty, + avg(l_extendedprice) as avg_price, + avg(l_discount) as avg_disc, + count(*) as count_order + FROM + lineitem + WHERE + l_shipdate <= date '1998-12-01' - interval '90' day + GROUP BY + l_returnflag, l_linestatus + ORDER BY + l_returnflag, l_linestatus; + desc: TPC-H Q1 + tasks: + - explain:logical_optd,physical_optd +- sql: | + select + s_acctbal, + s_name, + n_name, + p_partkey, + p_mfgr, + s_address, + s_phone, + s_comment + from + part, + supplier, + partsupp, + nation, + region + where + p_partkey = ps_partkey + and s_suppkey = ps_suppkey + and p_size = 4 + and p_type like '%TIN' + and s_nationkey = n_nationkey + and n_regionkey = r_regionkey + and r_name = 'AFRICA' + and ps_supplycost = ( + select + min(ps_supplycost) + from + partsupp, + supplier, + nation, + region + where + p_partkey = ps_partkey + and s_suppkey = ps_suppkey + and s_nationkey = n_nationkey + and n_regionkey = r_regionkey + and r_name = 'AFRICA' + ) + order by + s_acctbal desc, + n_name, + s_name, + p_partkey + limit 100; + desc: TPC-H Q2 + tasks: + - explain[use_df_logical]:logical_optd,physical_optd +- sql: | + SELECT + l_orderkey, + SUM(l_extendedprice * (1 - l_discount)) AS revenue, + o_orderdate, + o_shippriority + FROM + customer, + orders, + lineitem + WHERE + c_mktsegment = 'FURNITURE' + AND c_custkey = o_custkey + AND l_orderkey = o_orderkey + AND o_orderdate < DATE '1995-03-29' + AND l_shipdate > DATE '1995-03-29' + GROUP BY + l_orderkey, + o_orderdate, + o_shippriority + ORDER BY + revenue DESC, + o_orderdate LIMIT 10; + desc: TPC-H Q3 + tasks: + - explain[use_df_logical]:logical_optd,physical_optd +- sql: | + SELECT + n_name AS nation, + SUM(l_extendedprice * (1 - l_discount)) AS revenue + FROM + customer, + orders, + lineitem, + supplier, + nation, + region + WHERE + c_custkey = o_custkey + AND l_orderkey = o_orderkey + AND l_suppkey = s_suppkey + AND c_nationkey = s_nationkey + AND s_nationkey = n_nationkey + AND n_regionkey = r_regionkey + AND r_name = 'Asia' -- Specified region + AND o_orderdate >= DATE '2023-01-01' + AND o_orderdate < DATE '2024-01-01' + GROUP BY + n_name + ORDER BY + revenue DESC; + desc: TPC-H Q5 + tasks: + - explain:logical_optd,physical_optd diff --git a/optd-sqlplannertest/tests/tpch/tpch-06-10.planner.sql b/optd-sqlplannertest/tests/tpch/tpch-06-10.planner.sql new file mode 100644 index 00000000..692389f4 --- /dev/null +++ b/optd-sqlplannertest/tests/tpch/tpch-06-10.planner.sql @@ -0,0 +1,862 @@ +-- TPC-H schema +CREATE TABLE NATION ( + N_NATIONKEY INT NOT NULL, + N_NAME CHAR(25) NOT NULL, + N_REGIONKEY INT NOT NULL, + N_COMMENT VARCHAR(152) +); + +CREATE TABLE REGION ( + R_REGIONKEY INT NOT NULL, + R_NAME CHAR(25) NOT NULL, + R_COMMENT VARCHAR(152) +); + +CREATE TABLE PART ( + P_PARTKEY INT NOT NULL, + P_NAME VARCHAR(55) NOT NULL, + P_MFGR CHAR(25) NOT NULL, + P_BRAND CHAR(10) NOT NULL, + P_TYPE VARCHAR(25) NOT NULL, + P_SIZE INT NOT NULL, + P_CONTAINER CHAR(10) NOT NULL, + P_RETAILPRICE DECIMAL(15,2) NOT NULL, + P_COMMENT VARCHAR(23) NOT NULL +); + +CREATE TABLE SUPPLIER ( + S_SUPPKEY INT NOT NULL, + S_NAME CHAR(25) NOT NULL, + S_ADDRESS VARCHAR(40) NOT NULL, + S_NATIONKEY INT NOT NULL, + S_PHONE CHAR(15) NOT NULL, + S_ACCTBAL DECIMAL(15,2) NOT NULL, + S_COMMENT VARCHAR(101) NOT NULL +); + +CREATE TABLE PARTSUPP ( + PS_PARTKEY INT NOT NULL, + PS_SUPPKEY INT NOT NULL, + PS_AVAILQTY INT NOT NULL, + PS_SUPPLYCOST DECIMAL(15,2) NOT NULL, + PS_COMMENT VARCHAR(199) NOT NULL +); + +CREATE TABLE CUSTOMER ( + C_CUSTKEY INT NOT NULL, + C_NAME VARCHAR(25) NOT NULL, + C_ADDRESS VARCHAR(40) NOT NULL, + C_NATIONKEY INT NOT NULL, + C_PHONE CHAR(15) NOT NULL, + C_ACCTBAL DECIMAL(15,2) NOT NULL, + C_MKTSEGMENT CHAR(10) NOT NULL, + C_COMMENT VARCHAR(117) NOT NULL +); + +CREATE TABLE ORDERS ( + O_ORDERKEY INT NOT NULL, + O_CUSTKEY INT NOT NULL, + O_ORDERSTATUS CHAR(1) NOT NULL, + O_TOTALPRICE DECIMAL(15,2) NOT NULL, + O_ORDERDATE DATE NOT NULL, + O_ORDERPRIORITY CHAR(15) NOT NULL, + O_CLERK CHAR(15) NOT NULL, + O_SHIPPRIORITY INT NOT NULL, + O_COMMENT VARCHAR(79) NOT NULL +); + +CREATE TABLE LINEITEM ( + L_ORDERKEY INT NOT NULL, + L_PARTKEY INT NOT NULL, + L_SUPPKEY INT NOT NULL, + L_LINENUMBER INT NOT NULL, + L_QUANTITY DECIMAL(15,2) NOT NULL, + L_EXTENDEDPRICE DECIMAL(15,2) NOT NULL, + L_DISCOUNT DECIMAL(15,2) NOT NULL, + L_TAX DECIMAL(15,2) NOT NULL, + L_RETURNFLAG CHAR(1) NOT NULL, + L_LINESTATUS CHAR(1) NOT NULL, + L_SHIPDATE DATE NOT NULL, + L_COMMITDATE DATE NOT NULL, + L_RECEIPTDATE DATE NOT NULL, + L_SHIPINSTRUCT CHAR(25) NOT NULL, + L_SHIPMODE CHAR(10) NOT NULL, + L_COMMENT VARCHAR(44) NOT NULL +); + +/* + +*/ + +-- TPC-H Q6 +SELECT + SUM(l_extendedprice * l_discount) AS revenue_loss +FROM + lineitem +WHERE + l_shipdate >= DATE '2023-01-01' + AND l_shipdate < DATE '2024-01-01' + AND l_discount BETWEEN 0.05 AND 0.07 + AND l_quantity < 24; + +/* +LogicalProjection { exprs: [ #0 ] } +└── LogicalAgg + ├── exprs:Agg(Sum) + │ └── Mul + │ ├── #5 + │ └── #6 + ├── groups: [] + └── LogicalFilter + ├── cond:And + │ ├── Geq + │ │ ├── #10 + │ │ └── Cast { cast_to: Date32, expr: "2023-01-01" } + │ ├── Lt + │ │ ├── #10 + │ │ └── Cast { cast_to: Date32, expr: "2024-01-01" } + │ ├── Between { expr: Cast { cast_to: Decimal128(30, 15), expr: #6 }, lower: Cast { cast_to: Decimal128(30, 15), expr: 0.05(float) }, upper: Cast { cast_to: Decimal128(30, 15), expr: 0.07(float) } } + │ └── Lt + │ ├── Cast { cast_to: Decimal128(22, 2), expr: #4 } + │ └── Cast { cast_to: Decimal128(22, 2), expr: 24(i64) } + └── LogicalScan { table: lineitem } +PhysicalProjection { exprs: [ #0 ] } +└── PhysicalAgg + ├── aggrs:Agg(Sum) + │ └── Mul + │ ├── #5 + │ └── #6 + ├── groups: [] + └── PhysicalFilter + ├── cond:And + │ ├── Geq + │ │ ├── #10 + │ │ └── Cast { cast_to: Date32, expr: "2023-01-01" } + │ ├── Lt + │ │ ├── #10 + │ │ └── Cast { cast_to: Date32, expr: "2024-01-01" } + │ ├── Between { expr: Cast { cast_to: Decimal128(30, 15), expr: #6 }, lower: Cast { cast_to: Decimal128(30, 15), expr: 0.05(float) }, upper: Cast { cast_to: Decimal128(30, 15), expr: 0.07(float) } } + │ └── Lt + │ ├── Cast { cast_to: Decimal128(22, 2), expr: #4 } + │ └── Cast { cast_to: Decimal128(22, 2), expr: 24(i64) } + └── PhysicalScan { table: lineitem } +*/ + +-- TPC-H Q7 +SELECT + supp_nation, + cust_nation, + l_year, + SUM(volume) AS revenue +FROM + ( + SELECT + n1.n_name AS supp_nation, + n2.n_name AS cust_nation, + EXTRACT(YEAR FROM l_shipdate) AS l_year, + l_extendedprice * (1 - l_discount) AS volume + FROM + supplier, + lineitem, + orders, + customer, + nation n1, + nation n2 + WHERE + s_suppkey = l_suppkey + AND o_orderkey = l_orderkey + AND c_custkey = o_custkey + AND s_nationkey = n1.n_nationkey + AND c_nationkey = n2.n_nationkey + AND ( + (n1.n_name = 'FRANCE' AND n2.n_name = 'GERMANY') + OR (n1.n_name = 'GERMANY' AND n2.n_name = 'FRANCE') + ) + AND l_shipdate BETWEEN DATE '1995-01-01' AND DATE '1996-12-31' + ) AS shipping +GROUP BY + supp_nation, + cust_nation, + l_year +ORDER BY + supp_nation, + cust_nation, + l_year; + +/* +LogicalSort +├── exprs: +│ ┌── SortOrder { order: Asc } +│ │ └── #0 +│ ├── SortOrder { order: Asc } +│ │ └── #1 +│ └── SortOrder { order: Asc } +│ └── #2 +└── LogicalProjection { exprs: [ #0, #1, #2, #3 ] } + └── LogicalAgg + ├── exprs:Agg(Sum) + │ └── [ #3 ] + ├── groups: [ #0, #1, #2 ] + └── LogicalProjection + ├── exprs: + │ ┌── #41 + │ ├── #45 + │ ├── Scalar(DatePart) + │ │ └── [ "YEAR", #17 ] + │ └── Mul + │ ├── #12 + │ └── Sub + │ ├── Cast { cast_to: Decimal128(20, 0), expr: 1(i64) } + │ └── #13 + └── LogicalFilter + ├── cond:And + │ ├── Eq + │ │ ├── #0 + │ │ └── #9 + │ ├── Eq + │ │ ├── #23 + │ │ └── #7 + │ ├── Eq + │ │ ├── #32 + │ │ └── #24 + │ ├── Eq + │ │ ├── #3 + │ │ └── #40 + │ ├── Eq + │ │ ├── #35 + │ │ └── #44 + │ ├── Or + │ │ ├── And + │ │ │ ├── Eq + │ │ │ │ ├── #41 + │ │ │ │ └── "FRANCE" + │ │ │ └── Eq + │ │ │ ├── #45 + │ │ │ └── "GERMANY" + │ │ └── And + │ │ ├── Eq + │ │ │ ├── #41 + │ │ │ └── "GERMANY" + │ │ └── Eq + │ │ ├── #45 + │ │ └── "FRANCE" + │ └── Between { expr: #17, lower: Cast { cast_to: Date32, expr: "1995-01-01" }, upper: Cast { cast_to: Date32, expr: "1996-12-31" } } + └── LogicalJoin { join_type: Cross, cond: true } + ├── LogicalJoin { join_type: Cross, cond: true } + │ ├── LogicalJoin { join_type: Cross, cond: true } + │ │ ├── LogicalJoin { join_type: Cross, cond: true } + │ │ │ ├── LogicalJoin { join_type: Cross, cond: true } + │ │ │ │ ├── LogicalScan { table: supplier } + │ │ │ │ └── LogicalScan { table: lineitem } + │ │ │ └── LogicalScan { table: orders } + │ │ └── LogicalScan { table: customer } + │ └── LogicalScan { table: nation } + └── LogicalScan { table: nation } +PhysicalSort +├── exprs: +│ ┌── SortOrder { order: Asc } +│ │ └── #0 +│ ├── SortOrder { order: Asc } +│ │ └── #1 +│ └── SortOrder { order: Asc } +│ └── #2 +└── PhysicalProjection { exprs: [ #0, #1, #2, #3 ] } + └── PhysicalAgg + ├── aggrs:Agg(Sum) + │ └── [ #3 ] + ├── groups: [ #0, #1, #2 ] + └── PhysicalProjection + ├── exprs: + │ ┌── #41 + │ ├── #45 + │ ├── Scalar(DatePart) + │ │ └── [ "YEAR", #17 ] + │ └── Mul + │ ├── #12 + │ └── Sub + │ ├── Cast { cast_to: Decimal128(20, 0), expr: 1(i64) } + │ └── #13 + └── PhysicalNestedLoopJoin + ├── join_type: Inner + ├── cond:And + │ ├── Eq + │ │ ├── #35 + │ │ └── #44 + │ └── Or + │ ├── And + │ │ ├── Eq + │ │ │ ├── #41 + │ │ │ └── "FRANCE" + │ │ └── Eq + │ │ ├── #45 + │ │ └── "GERMANY" + │ └── And + │ ├── Eq + │ │ ├── #41 + │ │ └── "GERMANY" + │ └── Eq + │ ├── #45 + │ └── "FRANCE" + ├── PhysicalHashJoin { join_type: Inner, left_keys: [ #3 ], right_keys: [ #0 ] } + │ ├── PhysicalHashJoin { join_type: Inner, left_keys: [ #0 ], right_keys: [ #2 ] } + │ │ ├── PhysicalScan { table: supplier } + │ │ └── PhysicalHashJoin { join_type: Inner, left_keys: [ #17 ], right_keys: [ #0 ] } + │ │ ├── PhysicalHashJoin { join_type: Inner, left_keys: [ #0 ], right_keys: [ #0 ] } + │ │ │ ├── PhysicalFilter { cond: Between { expr: #10, lower: Cast { cast_to: Date32, expr: "1995-01-01" }, upper: Cast { cast_to: Date32, expr: "1996-12-31" } } } + │ │ │ │ └── PhysicalScan { table: lineitem } + │ │ │ └── PhysicalScan { table: orders } + │ │ └── PhysicalScan { table: customer } + │ └── PhysicalScan { table: nation } + └── PhysicalScan { table: nation } +*/ + +-- TPC-H Q8 without top-most limit node +select + o_year, + sum(case + when nation = 'IRAQ' then volume + else 0 + end) / sum(volume) as mkt_share +from + ( + select + extract(year from o_orderdate) as o_year, + l_extendedprice * (1 - l_discount) as volume, + n2.n_name as nation + from + part, + supplier, + lineitem, + orders, + customer, + nation n1, + nation n2, + region + where + p_partkey = l_partkey + and s_suppkey = l_suppkey + and l_orderkey = o_orderkey + and o_custkey = c_custkey + and c_nationkey = n1.n_nationkey + and n1.n_regionkey = r_regionkey + and r_name = 'AMERICA' + and s_nationkey = n2.n_nationkey + and o_orderdate between date '1995-01-01' and date '1996-12-31' + and p_type = 'ECONOMY ANODIZED STEEL' + ) as all_nations +group by + o_year +order by + o_year; + +/* +LogicalSort +├── exprs:SortOrder { order: Asc } +│ └── #0 +└── LogicalProjection + ├── exprs: + │ ┌── #0 + │ └── Div + │ ├── #1 + │ └── #2 + └── LogicalAgg + ├── exprs: + │ ┌── Agg(Sum) + │ │ └── Case + │ │ └── + │ │ ┌── Eq + │ │ │ ├── #2 + │ │ │ └── "IRAQ" + │ │ ├── #1 + │ │ └── Cast { cast_to: Decimal128(38, 4), expr: 0(i64) } + │ └── Agg(Sum) + │ └── [ #1 ] + ├── groups: [ #0 ] + └── LogicalProjection + ├── exprs: + │ ┌── Scalar(DatePart) + │ │ └── [ "YEAR", #36 ] + │ ├── Mul + │ │ ├── #21 + │ │ └── Sub + │ │ ├── Cast { cast_to: Decimal128(20, 0), expr: 1(i64) } + │ │ └── #22 + │ └── #54 + └── LogicalFilter + ├── cond:And + │ ├── Eq + │ │ ├── #0 + │ │ └── #17 + │ ├── Eq + │ │ ├── #9 + │ │ └── #18 + │ ├── Eq + │ │ ├── #16 + │ │ └── #32 + │ ├── Eq + │ │ ├── #33 + │ │ └── #41 + │ ├── Eq + │ │ ├── #44 + │ │ └── #49 + │ ├── Eq + │ │ ├── #51 + │ │ └── #57 + │ ├── Eq + │ │ ├── #58 + │ │ └── "AMERICA" + │ ├── Eq + │ │ ├── #12 + │ │ └── #53 + │ ├── Between { expr: #36, lower: Cast { cast_to: Date32, expr: "1995-01-01" }, upper: Cast { cast_to: Date32, expr: "1996-12-31" } } + │ └── Eq + │ ├── #4 + │ └── "ECONOMY ANODIZED STEEL" + └── LogicalJoin { join_type: Cross, cond: true } + ├── LogicalJoin { join_type: Cross, cond: true } + │ ├── LogicalJoin { join_type: Cross, cond: true } + │ │ ├── LogicalJoin { join_type: Cross, cond: true } + │ │ │ ├── LogicalJoin { join_type: Cross, cond: true } + │ │ │ │ ├── LogicalJoin { join_type: Cross, cond: true } + │ │ │ │ │ ├── LogicalJoin { join_type: Cross, cond: true } + │ │ │ │ │ │ ├── LogicalScan { table: part } + │ │ │ │ │ │ └── LogicalScan { table: supplier } + │ │ │ │ │ └── LogicalScan { table: lineitem } + │ │ │ │ └── LogicalScan { table: orders } + │ │ │ └── LogicalScan { table: customer } + │ │ └── LogicalScan { table: nation } + │ └── LogicalScan { table: nation } + └── LogicalScan { table: region } +PhysicalSort +├── exprs:SortOrder { order: Asc } +│ └── #0 +└── PhysicalProjection + ├── exprs: + │ ┌── #0 + │ └── Div + │ ├── #1 + │ └── #2 + └── PhysicalAgg + ├── aggrs: + │ ┌── Agg(Sum) + │ │ └── Case + │ │ └── + │ │ ┌── Eq + │ │ │ ├── #2 + │ │ │ └── "IRAQ" + │ │ ├── #1 + │ │ └── Cast { cast_to: Decimal128(38, 4), expr: 0(i64) } + │ └── Agg(Sum) + │ └── [ #1 ] + ├── groups: [ #0 ] + └── PhysicalProjection + ├── exprs: + │ ┌── Scalar(DatePart) + │ │ └── [ "YEAR", #36 ] + │ ├── Mul + │ │ ├── #21 + │ │ └── Sub + │ │ ├── Cast { cast_to: Decimal128(20, 0), expr: 1(i64) } + │ │ └── #22 + │ └── #54 + └── PhysicalHashJoin { join_type: Inner, left_keys: [ #51 ], right_keys: [ #0 ] } + ├── PhysicalHashJoin { join_type: Inner, left_keys: [ #12 ], right_keys: [ #0 ] } + │ ├── PhysicalHashJoin { join_type: Inner, left_keys: [ #0, #9 ], right_keys: [ #1, #2 ] } + │ │ ├── PhysicalNestedLoopJoin { join_type: Cross, cond: true } + │ │ │ ├── PhysicalFilter + │ │ │ │ ├── cond:Eq + │ │ │ │ │ ├── #4 + │ │ │ │ │ └── "ECONOMY ANODIZED STEEL" + │ │ │ │ └── PhysicalScan { table: part } + │ │ │ └── PhysicalScan { table: supplier } + │ │ └── PhysicalHashJoin { join_type: Inner, left_keys: [ #17 ], right_keys: [ #0 ] } + │ │ ├── PhysicalHashJoin { join_type: Inner, left_keys: [ #0 ], right_keys: [ #0 ] } + │ │ │ ├── PhysicalScan { table: lineitem } + │ │ │ └── PhysicalFilter { cond: Between { expr: #4, lower: Cast { cast_to: Date32, expr: "1995-01-01" }, upper: Cast { cast_to: Date32, expr: "1996-12-31" } } } + │ │ │ └── PhysicalScan { table: orders } + │ │ └── PhysicalHashJoin { join_type: Inner, left_keys: [ #3 ], right_keys: [ #0 ] } + │ │ ├── PhysicalScan { table: customer } + │ │ └── PhysicalScan { table: nation } + │ └── PhysicalScan { table: nation } + └── PhysicalFilter + ├── cond:Eq + │ ├── #1 + │ └── "AMERICA" + └── PhysicalScan { table: region } +*/ + +-- TPC-H Q9 +SELECT + nation, + o_year, + SUM(amount) AS sum_profit +FROM + ( + SELECT + n_name AS nation, + EXTRACT(YEAR FROM o_orderdate) AS o_year, + l_extendedprice * (1 - l_discount) - ps_supplycost * l_quantity AS amount + FROM + part, + supplier, + lineitem, + partsupp, + orders, + nation + WHERE + s_suppkey = l_suppkey + AND ps_suppkey = l_suppkey + AND ps_partkey = l_partkey + AND p_partkey = l_partkey + AND o_orderkey = l_orderkey + AND s_nationkey = n_nationkey + AND p_name LIKE '%green%' + ) AS profit +GROUP BY + nation, + o_year +ORDER BY + nation, + o_year DESC; + +/* +LogicalSort +├── exprs: +│ ┌── SortOrder { order: Asc } +│ │ └── #0 +│ └── SortOrder { order: Desc } +│ └── #1 +└── LogicalProjection { exprs: [ #0, #1, #2 ] } + └── LogicalAgg + ├── exprs:Agg(Sum) + │ └── [ #2 ] + ├── groups: [ #0, #1 ] + └── LogicalProjection + ├── exprs: + │ ┌── #47 + │ ├── Scalar(DatePart) + │ │ └── [ "YEAR", #41 ] + │ └── Sub + │ ├── Mul + │ │ ├── #21 + │ │ └── Sub + │ │ ├── Cast { cast_to: Decimal128(20, 0), expr: 1(i64) } + │ │ └── #22 + │ └── Mul + │ ├── #35 + │ └── #20 + └── LogicalFilter + ├── cond:And + │ ├── Eq + │ │ ├── #9 + │ │ └── #18 + │ ├── Eq + │ │ ├── #33 + │ │ └── #18 + │ ├── Eq + │ │ ├── #32 + │ │ └── #17 + │ ├── Eq + │ │ ├── #0 + │ │ └── #17 + │ ├── Eq + │ │ ├── #37 + │ │ └── #16 + │ ├── Eq + │ │ ├── #12 + │ │ └── #46 + │ └── Like { expr: #1, pattern: "%green%", negated: false, case_insensitive: false } + └── LogicalJoin { join_type: Cross, cond: true } + ├── LogicalJoin { join_type: Cross, cond: true } + │ ├── LogicalJoin { join_type: Cross, cond: true } + │ │ ├── LogicalJoin { join_type: Cross, cond: true } + │ │ │ ├── LogicalJoin { join_type: Cross, cond: true } + │ │ │ │ ├── LogicalScan { table: part } + │ │ │ │ └── LogicalScan { table: supplier } + │ │ │ └── LogicalScan { table: lineitem } + │ │ └── LogicalScan { table: partsupp } + │ └── LogicalScan { table: orders } + └── LogicalScan { table: nation } +PhysicalSort +├── exprs: +│ ┌── SortOrder { order: Asc } +│ │ └── #0 +│ └── SortOrder { order: Desc } +│ └── #1 +└── PhysicalProjection { exprs: [ #0, #1, #2 ] } + └── PhysicalAgg + ├── aggrs:Agg(Sum) + │ └── [ #2 ] + ├── groups: [ #0, #1 ] + └── PhysicalProjection + ├── exprs: + │ ┌── #47 + │ ├── Scalar(DatePart) + │ │ └── [ "YEAR", #41 ] + │ └── Sub + │ ├── Mul + │ │ ├── #21 + │ │ └── Sub + │ │ ├── Cast { cast_to: Decimal128(20, 0), expr: 1(i64) } + │ │ └── #22 + │ └── Mul + │ ├── #35 + │ └── #20 + └── PhysicalHashJoin { join_type: Inner, left_keys: [ #12 ], right_keys: [ #0 ] } + ├── PhysicalHashJoin { join_type: Inner, left_keys: [ #9, #0 ], right_keys: [ #2, #1 ] } + │ ├── PhysicalNestedLoopJoin { join_type: Cross, cond: true } + │ │ ├── PhysicalFilter { cond: Like { expr: #1, pattern: "%green%", negated: false, case_insensitive: false } } + │ │ │ └── PhysicalScan { table: part } + │ │ └── PhysicalScan { table: supplier } + │ └── PhysicalHashJoin { join_type: Inner, left_keys: [ #0 ], right_keys: [ #0 ] } + │ ├── PhysicalHashJoin { join_type: Inner, left_keys: [ #2, #1 ], right_keys: [ #1, #0 ] } + │ │ ├── PhysicalScan { table: lineitem } + │ │ └── PhysicalScan { table: partsupp } + │ └── PhysicalScan { table: orders } + └── PhysicalScan { table: nation } +*/ + +-- TPC-H Q9 +SELECT + nation, + o_year, + SUM(amount) AS sum_profit +FROM + ( + SELECT + n_name AS nation, + EXTRACT(YEAR FROM o_orderdate) AS o_year, + l_extendedprice * (1 - l_discount) - ps_supplycost * l_quantity AS amount + FROM + part, + supplier, + lineitem, + partsupp, + orders, + nation + WHERE + s_suppkey = l_suppkey + AND ps_suppkey = l_suppkey + AND ps_partkey = l_partkey + AND p_partkey = l_partkey + AND o_orderkey = l_orderkey + AND s_nationkey = n_nationkey + AND p_name LIKE '%green%' + ) AS profit +GROUP BY + nation, + o_year +ORDER BY + nation, + o_year DESC; + +/* +LogicalSort +├── exprs: +│ ┌── SortOrder { order: Asc } +│ │ └── #0 +│ └── SortOrder { order: Desc } +│ └── #1 +└── LogicalProjection { exprs: [ #0, #1, #2 ] } + └── LogicalAgg + ├── exprs:Agg(Sum) + │ └── [ #2 ] + ├── groups: [ #0, #1 ] + └── LogicalProjection + ├── exprs: + │ ┌── #47 + │ ├── Scalar(DatePart) + │ │ └── [ "YEAR", #41 ] + │ └── Sub + │ ├── Mul + │ │ ├── #21 + │ │ └── Sub + │ │ ├── Cast { cast_to: Decimal128(20, 0), expr: 1(i64) } + │ │ └── #22 + │ └── Mul + │ ├── #35 + │ └── #20 + └── LogicalFilter + ├── cond:And + │ ├── Eq + │ │ ├── #9 + │ │ └── #18 + │ ├── Eq + │ │ ├── #33 + │ │ └── #18 + │ ├── Eq + │ │ ├── #32 + │ │ └── #17 + │ ├── Eq + │ │ ├── #0 + │ │ └── #17 + │ ├── Eq + │ │ ├── #37 + │ │ └── #16 + │ ├── Eq + │ │ ├── #12 + │ │ └── #46 + │ └── Like { expr: #1, pattern: "%green%", negated: false, case_insensitive: false } + └── LogicalJoin { join_type: Cross, cond: true } + ├── LogicalJoin { join_type: Cross, cond: true } + │ ├── LogicalJoin { join_type: Cross, cond: true } + │ │ ├── LogicalJoin { join_type: Cross, cond: true } + │ │ │ ├── LogicalJoin { join_type: Cross, cond: true } + │ │ │ │ ├── LogicalScan { table: part } + │ │ │ │ └── LogicalScan { table: supplier } + │ │ │ └── LogicalScan { table: lineitem } + │ │ └── LogicalScan { table: partsupp } + │ └── LogicalScan { table: orders } + └── LogicalScan { table: nation } +PhysicalSort +├── exprs: +│ ┌── SortOrder { order: Asc } +│ │ └── #0 +│ └── SortOrder { order: Desc } +│ └── #1 +└── PhysicalProjection { exprs: [ #0, #1, #2 ] } + └── PhysicalAgg + ├── aggrs:Agg(Sum) + │ └── [ #2 ] + ├── groups: [ #0, #1 ] + └── PhysicalProjection + ├── exprs: + │ ┌── #47 + │ ├── Scalar(DatePart) + │ │ └── [ "YEAR", #41 ] + │ └── Sub + │ ├── Mul + │ │ ├── #21 + │ │ └── Sub + │ │ ├── Cast { cast_to: Decimal128(20, 0), expr: 1(i64) } + │ │ └── #22 + │ └── Mul + │ ├── #35 + │ └── #20 + └── PhysicalHashJoin { join_type: Inner, left_keys: [ #12 ], right_keys: [ #0 ] } + ├── PhysicalHashJoin { join_type: Inner, left_keys: [ #9, #0 ], right_keys: [ #2, #1 ] } + │ ├── PhysicalNestedLoopJoin { join_type: Cross, cond: true } + │ │ ├── PhysicalFilter { cond: Like { expr: #1, pattern: "%green%", negated: false, case_insensitive: false } } + │ │ │ └── PhysicalScan { table: part } + │ │ └── PhysicalScan { table: supplier } + │ └── PhysicalHashJoin { join_type: Inner, left_keys: [ #0 ], right_keys: [ #0 ] } + │ ├── PhysicalHashJoin { join_type: Inner, left_keys: [ #2, #1 ], right_keys: [ #1, #0 ] } + │ │ ├── PhysicalScan { table: lineitem } + │ │ └── PhysicalScan { table: partsupp } + │ └── PhysicalScan { table: orders } + └── PhysicalScan { table: nation } +*/ + +-- TPC-H Q10 +SELECT + c_custkey, + c_name, + sum(l_extendedprice * (1 - l_discount)) as revenue, + c_acctbal, + n_name, + c_address, + c_phone, + c_comment +FROM + customer, + orders, + lineitem, + nation +WHERE + c_custkey = o_custkey + AND l_orderkey = o_orderkey + AND o_orderdate >= DATE '1993-07-01' + AND o_orderdate < DATE '1993-07-01' + INTERVAL '3' MONTH + AND l_returnflag = 'R' + AND c_nationkey = n_nationkey +GROUP BY + c_custkey, + c_name, + c_acctbal, + c_phone, + n_name, + c_address, + c_comment +ORDER BY + revenue DESC +LIMIT 20; + +/* +LogicalLimit { skip: 0(u64), fetch: 20(u64) } +└── LogicalSort + ├── exprs:SortOrder { order: Desc } + │ └── #2 + └── LogicalProjection { exprs: [ #0, #1, #7, #2, #4, #5, #3, #6 ] } + └── LogicalAgg + ├── exprs:Agg(Sum) + │ └── Mul + │ ├── #22 + │ └── Sub + │ ├── Cast { cast_to: Decimal128(20, 0), expr: 1(i64) } + │ └── #23 + ├── groups: [ #0, #1, #5, #4, #34, #2, #7 ] + └── LogicalFilter + ├── cond:And + │ ├── Eq + │ │ ├── #0 + │ │ └── #9 + │ ├── Eq + │ │ ├── #17 + │ │ └── #8 + │ ├── Geq + │ │ ├── #12 + │ │ └── Cast { cast_to: Date32, expr: "1993-07-01" } + │ ├── Lt + │ │ ├── #12 + │ │ └── Add + │ │ ├── Cast { cast_to: Date32, expr: "1993-07-01" } + │ │ └── INTERVAL_MONTH_DAY_NANO (3, 0, 0) + │ ├── Eq + │ │ ├── #25 + │ │ └── "R" + │ └── Eq + │ ├── #3 + │ └── #33 + └── LogicalJoin { join_type: Cross, cond: true } + ├── LogicalJoin { join_type: Cross, cond: true } + │ ├── LogicalJoin { join_type: Cross, cond: true } + │ │ ├── LogicalScan { table: customer } + │ │ └── LogicalScan { table: orders } + │ └── LogicalScan { table: lineitem } + └── LogicalScan { table: nation } +PhysicalLimit { skip: 0(u64), fetch: 20(u64) } +└── PhysicalSort + ├── exprs:SortOrder { order: Desc } + │ └── #2 + └── PhysicalProjection { exprs: [ #0, #1, #7, #2, #4, #5, #3, #6 ] } + └── PhysicalAgg + ├── aggrs:Agg(Sum) + │ └── Mul + │ ├── #22 + │ └── Sub + │ ├── Cast { cast_to: Decimal128(20, 0), expr: 1(i64) } + │ └── #23 + ├── groups: [ #0, #1, #5, #4, #34, #2, #7 ] + └── PhysicalHashJoin { join_type: Inner, left_keys: [ #3 ], right_keys: [ #0 ] } + ├── PhysicalHashJoin { join_type: Inner, left_keys: [ #0 ], right_keys: [ #1 ] } + │ ├── PhysicalScan { table: customer } + │ └── PhysicalHashJoin { join_type: Inner, left_keys: [ #0 ], right_keys: [ #0 ] } + │ ├── PhysicalFilter + │ │ ├── cond:And + │ │ │ ├── Geq + │ │ │ │ ├── #4 + │ │ │ │ └── Cast { cast_to: Date32, expr: "1993-07-01" } + │ │ │ └── Lt + │ │ │ ├── #4 + │ │ │ └── Add + │ │ │ ├── Cast { cast_to: Date32, expr: "1993-07-01" } + │ │ │ └── INTERVAL_MONTH_DAY_NANO (3, 0, 0) + │ │ └── PhysicalScan { table: orders } + │ └── PhysicalFilter + │ ├── cond:Eq + │ │ ├── #8 + │ │ └── "R" + │ └── PhysicalScan { table: lineitem } + └── PhysicalScan { table: nation } +*/ + diff --git a/optd-sqlplannertest/tests/tpch/tpch-06-10.yml b/optd-sqlplannertest/tests/tpch/tpch-06-10.yml new file mode 100644 index 00000000..d6ba7170 --- /dev/null +++ b/optd-sqlplannertest/tests/tpch/tpch-06-10.yml @@ -0,0 +1,293 @@ +- sql: | + CREATE TABLE NATION ( + N_NATIONKEY INT NOT NULL, + N_NAME CHAR(25) NOT NULL, + N_REGIONKEY INT NOT NULL, + N_COMMENT VARCHAR(152) + ); + + CREATE TABLE REGION ( + R_REGIONKEY INT NOT NULL, + R_NAME CHAR(25) NOT NULL, + R_COMMENT VARCHAR(152) + ); + + CREATE TABLE PART ( + P_PARTKEY INT NOT NULL, + P_NAME VARCHAR(55) NOT NULL, + P_MFGR CHAR(25) NOT NULL, + P_BRAND CHAR(10) NOT NULL, + P_TYPE VARCHAR(25) NOT NULL, + P_SIZE INT NOT NULL, + P_CONTAINER CHAR(10) NOT NULL, + P_RETAILPRICE DECIMAL(15,2) NOT NULL, + P_COMMENT VARCHAR(23) NOT NULL + ); + + CREATE TABLE SUPPLIER ( + S_SUPPKEY INT NOT NULL, + S_NAME CHAR(25) NOT NULL, + S_ADDRESS VARCHAR(40) NOT NULL, + S_NATIONKEY INT NOT NULL, + S_PHONE CHAR(15) NOT NULL, + S_ACCTBAL DECIMAL(15,2) NOT NULL, + S_COMMENT VARCHAR(101) NOT NULL + ); + + CREATE TABLE PARTSUPP ( + PS_PARTKEY INT NOT NULL, + PS_SUPPKEY INT NOT NULL, + PS_AVAILQTY INT NOT NULL, + PS_SUPPLYCOST DECIMAL(15,2) NOT NULL, + PS_COMMENT VARCHAR(199) NOT NULL + ); + + CREATE TABLE CUSTOMER ( + C_CUSTKEY INT NOT NULL, + C_NAME VARCHAR(25) NOT NULL, + C_ADDRESS VARCHAR(40) NOT NULL, + C_NATIONKEY INT NOT NULL, + C_PHONE CHAR(15) NOT NULL, + C_ACCTBAL DECIMAL(15,2) NOT NULL, + C_MKTSEGMENT CHAR(10) NOT NULL, + C_COMMENT VARCHAR(117) NOT NULL + ); + + CREATE TABLE ORDERS ( + O_ORDERKEY INT NOT NULL, + O_CUSTKEY INT NOT NULL, + O_ORDERSTATUS CHAR(1) NOT NULL, + O_TOTALPRICE DECIMAL(15,2) NOT NULL, + O_ORDERDATE DATE NOT NULL, + O_ORDERPRIORITY CHAR(15) NOT NULL, + O_CLERK CHAR(15) NOT NULL, + O_SHIPPRIORITY INT NOT NULL, + O_COMMENT VARCHAR(79) NOT NULL + ); + + CREATE TABLE LINEITEM ( + L_ORDERKEY INT NOT NULL, + L_PARTKEY INT NOT NULL, + L_SUPPKEY INT NOT NULL, + L_LINENUMBER INT NOT NULL, + L_QUANTITY DECIMAL(15,2) NOT NULL, + L_EXTENDEDPRICE DECIMAL(15,2) NOT NULL, + L_DISCOUNT DECIMAL(15,2) NOT NULL, + L_TAX DECIMAL(15,2) NOT NULL, + L_RETURNFLAG CHAR(1) NOT NULL, + L_LINESTATUS CHAR(1) NOT NULL, + L_SHIPDATE DATE NOT NULL, + L_COMMITDATE DATE NOT NULL, + L_RECEIPTDATE DATE NOT NULL, + L_SHIPINSTRUCT CHAR(25) NOT NULL, + L_SHIPMODE CHAR(10) NOT NULL, + L_COMMENT VARCHAR(44) NOT NULL + ); + desc: TPC-H schema + tasks: + - execute +- sql: | + SELECT + SUM(l_extendedprice * l_discount) AS revenue_loss + FROM + lineitem + WHERE + l_shipdate >= DATE '2023-01-01' + AND l_shipdate < DATE '2024-01-01' + AND l_discount BETWEEN 0.05 AND 0.07 + AND l_quantity < 24; + desc: TPC-H Q6 + tasks: + - explain:logical_optd,physical_optd +- sql: | + SELECT + supp_nation, + cust_nation, + l_year, + SUM(volume) AS revenue + FROM + ( + SELECT + n1.n_name AS supp_nation, + n2.n_name AS cust_nation, + EXTRACT(YEAR FROM l_shipdate) AS l_year, + l_extendedprice * (1 - l_discount) AS volume + FROM + supplier, + lineitem, + orders, + customer, + nation n1, + nation n2 + WHERE + s_suppkey = l_suppkey + AND o_orderkey = l_orderkey + AND c_custkey = o_custkey + AND s_nationkey = n1.n_nationkey + AND c_nationkey = n2.n_nationkey + AND ( + (n1.n_name = 'FRANCE' AND n2.n_name = 'GERMANY') + OR (n1.n_name = 'GERMANY' AND n2.n_name = 'FRANCE') + ) + AND l_shipdate BETWEEN DATE '1995-01-01' AND DATE '1996-12-31' + ) AS shipping + GROUP BY + supp_nation, + cust_nation, + l_year + ORDER BY + supp_nation, + cust_nation, + l_year; + desc: TPC-H Q7 + tasks: + - explain:logical_optd,physical_optd +- sql: | + select + o_year, + sum(case + when nation = 'IRAQ' then volume + else 0 + end) / sum(volume) as mkt_share + from + ( + select + extract(year from o_orderdate) as o_year, + l_extendedprice * (1 - l_discount) as volume, + n2.n_name as nation + from + part, + supplier, + lineitem, + orders, + customer, + nation n1, + nation n2, + region + where + p_partkey = l_partkey + and s_suppkey = l_suppkey + and l_orderkey = o_orderkey + and o_custkey = c_custkey + and c_nationkey = n1.n_nationkey + and n1.n_regionkey = r_regionkey + and r_name = 'AMERICA' + and s_nationkey = n2.n_nationkey + and o_orderdate between date '1995-01-01' and date '1996-12-31' + and p_type = 'ECONOMY ANODIZED STEEL' + ) as all_nations + group by + o_year + order by + o_year; + desc: TPC-H Q8 without top-most limit node + tasks: + - explain:logical_optd,physical_optd +- sql: | + SELECT + nation, + o_year, + SUM(amount) AS sum_profit + FROM + ( + SELECT + n_name AS nation, + EXTRACT(YEAR FROM o_orderdate) AS o_year, + l_extendedprice * (1 - l_discount) - ps_supplycost * l_quantity AS amount + FROM + part, + supplier, + lineitem, + partsupp, + orders, + nation + WHERE + s_suppkey = l_suppkey + AND ps_suppkey = l_suppkey + AND ps_partkey = l_partkey + AND p_partkey = l_partkey + AND o_orderkey = l_orderkey + AND s_nationkey = n_nationkey + AND p_name LIKE '%green%' + ) AS profit + GROUP BY + nation, + o_year + ORDER BY + nation, + o_year DESC; + desc: TPC-H Q9 + tasks: + - explain:logical_optd,physical_optd +- sql: | + SELECT + nation, + o_year, + SUM(amount) AS sum_profit + FROM + ( + SELECT + n_name AS nation, + EXTRACT(YEAR FROM o_orderdate) AS o_year, + l_extendedprice * (1 - l_discount) - ps_supplycost * l_quantity AS amount + FROM + part, + supplier, + lineitem, + partsupp, + orders, + nation + WHERE + s_suppkey = l_suppkey + AND ps_suppkey = l_suppkey + AND ps_partkey = l_partkey + AND p_partkey = l_partkey + AND o_orderkey = l_orderkey + AND s_nationkey = n_nationkey + AND p_name LIKE '%green%' + ) AS profit + GROUP BY + nation, + o_year + ORDER BY + nation, + o_year DESC; + desc: TPC-H Q9 + tasks: + - explain:logical_optd,physical_optd +- sql: | + SELECT + c_custkey, + c_name, + sum(l_extendedprice * (1 - l_discount)) as revenue, + c_acctbal, + n_name, + c_address, + c_phone, + c_comment + FROM + customer, + orders, + lineitem, + nation + WHERE + c_custkey = o_custkey + AND l_orderkey = o_orderkey + AND o_orderdate >= DATE '1993-07-01' + AND o_orderdate < DATE '1993-07-01' + INTERVAL '3' MONTH + AND l_returnflag = 'R' + AND c_nationkey = n_nationkey + GROUP BY + c_custkey, + c_name, + c_acctbal, + c_phone, + n_name, + c_address, + c_comment + ORDER BY + revenue DESC + LIMIT 20; + desc: TPC-H Q10 + tasks: + - explain:logical_optd,physical_optd diff --git a/optd-sqlplannertest/tests/tpch/tpch-11-15.planner.sql b/optd-sqlplannertest/tests/tpch/tpch-11-15.planner.sql new file mode 100644 index 00000000..52efaef5 --- /dev/null +++ b/optd-sqlplannertest/tests/tpch/tpch-11-15.planner.sql @@ -0,0 +1,631 @@ +-- TPC-H schema +CREATE TABLE NATION ( + N_NATIONKEY INT NOT NULL, + N_NAME CHAR(25) NOT NULL, + N_REGIONKEY INT NOT NULL, + N_COMMENT VARCHAR(152) +); + +CREATE TABLE REGION ( + R_REGIONKEY INT NOT NULL, + R_NAME CHAR(25) NOT NULL, + R_COMMENT VARCHAR(152) +); + +CREATE TABLE PART ( + P_PARTKEY INT NOT NULL, + P_NAME VARCHAR(55) NOT NULL, + P_MFGR CHAR(25) NOT NULL, + P_BRAND CHAR(10) NOT NULL, + P_TYPE VARCHAR(25) NOT NULL, + P_SIZE INT NOT NULL, + P_CONTAINER CHAR(10) NOT NULL, + P_RETAILPRICE DECIMAL(15,2) NOT NULL, + P_COMMENT VARCHAR(23) NOT NULL +); + +CREATE TABLE SUPPLIER ( + S_SUPPKEY INT NOT NULL, + S_NAME CHAR(25) NOT NULL, + S_ADDRESS VARCHAR(40) NOT NULL, + S_NATIONKEY INT NOT NULL, + S_PHONE CHAR(15) NOT NULL, + S_ACCTBAL DECIMAL(15,2) NOT NULL, + S_COMMENT VARCHAR(101) NOT NULL +); + +CREATE TABLE PARTSUPP ( + PS_PARTKEY INT NOT NULL, + PS_SUPPKEY INT NOT NULL, + PS_AVAILQTY INT NOT NULL, + PS_SUPPLYCOST DECIMAL(15,2) NOT NULL, + PS_COMMENT VARCHAR(199) NOT NULL +); + +CREATE TABLE CUSTOMER ( + C_CUSTKEY INT NOT NULL, + C_NAME VARCHAR(25) NOT NULL, + C_ADDRESS VARCHAR(40) NOT NULL, + C_NATIONKEY INT NOT NULL, + C_PHONE CHAR(15) NOT NULL, + C_ACCTBAL DECIMAL(15,2) NOT NULL, + C_MKTSEGMENT CHAR(10) NOT NULL, + C_COMMENT VARCHAR(117) NOT NULL +); + +CREATE TABLE ORDERS ( + O_ORDERKEY INT NOT NULL, + O_CUSTKEY INT NOT NULL, + O_ORDERSTATUS CHAR(1) NOT NULL, + O_TOTALPRICE DECIMAL(15,2) NOT NULL, + O_ORDERDATE DATE NOT NULL, + O_ORDERPRIORITY CHAR(15) NOT NULL, + O_CLERK CHAR(15) NOT NULL, + O_SHIPPRIORITY INT NOT NULL, + O_COMMENT VARCHAR(79) NOT NULL +); + +CREATE TABLE LINEITEM ( + L_ORDERKEY INT NOT NULL, + L_PARTKEY INT NOT NULL, + L_SUPPKEY INT NOT NULL, + L_LINENUMBER INT NOT NULL, + L_QUANTITY DECIMAL(15,2) NOT NULL, + L_EXTENDEDPRICE DECIMAL(15,2) NOT NULL, + L_DISCOUNT DECIMAL(15,2) NOT NULL, + L_TAX DECIMAL(15,2) NOT NULL, + L_RETURNFLAG CHAR(1) NOT NULL, + L_LINESTATUS CHAR(1) NOT NULL, + L_SHIPDATE DATE NOT NULL, + L_COMMITDATE DATE NOT NULL, + L_RECEIPTDATE DATE NOT NULL, + L_SHIPINSTRUCT CHAR(25) NOT NULL, + L_SHIPMODE CHAR(10) NOT NULL, + L_COMMENT VARCHAR(44) NOT NULL +); + +/* + +*/ + +-- TPC-H Q11 +select + ps_partkey, + sum(ps_supplycost * ps_availqty) as value +from + partsupp, + supplier, + nation +where + ps_suppkey = s_suppkey + and s_nationkey = n_nationkey + and n_name = 'CHINA' +group by + ps_partkey having + sum(ps_supplycost * ps_availqty) > ( + select + sum(ps_supplycost * ps_availqty) * 0.0001000000 + from + partsupp, + supplier, + nation + where + ps_suppkey = s_suppkey + and s_nationkey = n_nationkey + and n_name = 'CHINA' + ) +order by + value desc; + +/* +LogicalSort +├── exprs:SortOrder { order: Desc } +│ └── #1 +└── LogicalProjection { exprs: [ #0, #1 ] } + └── LogicalJoin + ├── join_type: Inner + ├── cond:Gt + │ ├── Cast { cast_to: Decimal128(38, 15), expr: #1 } + │ └── #2 + ├── LogicalAgg + │ ├── exprs:Agg(Sum) + │ │ └── Mul + │ │ ├── #2 + │ │ └── Cast { cast_to: Decimal128(10, 0), expr: #1 } + │ ├── groups: [ #0 ] + │ └── LogicalProjection { exprs: [ #0, #1, #2 ] } + │ └── LogicalJoin + │ ├── join_type: Inner + │ ├── cond:Eq + │ │ ├── #3 + │ │ └── #4 + │ ├── LogicalProjection { exprs: [ #0, #2, #3, #5 ] } + │ │ └── LogicalJoin + │ │ ├── join_type: Inner + │ │ ├── cond:Eq + │ │ │ ├── #1 + │ │ │ └── #4 + │ │ ├── LogicalProjection { exprs: [ #0, #1, #2, #3 ] } + │ │ │ └── LogicalScan { table: partsupp } + │ │ └── LogicalProjection { exprs: [ #0, #3 ] } + │ │ └── LogicalScan { table: supplier } + │ └── LogicalProjection { exprs: [ #0 ] } + │ └── LogicalFilter + │ ├── cond:Eq + │ │ ├── #1 + │ │ └── "CHINA" + │ └── LogicalProjection { exprs: [ #0, #1 ] } + │ └── LogicalScan { table: nation } + └── LogicalProjection + ├── exprs:Cast + │ ├── cast_to: Decimal128(38, 15) + │ ├── expr:Mul + │ │ ├── Cast { cast_to: Float64, expr: #0 } + │ │ └── 0.0001(float) + + └── LogicalAgg + ├── exprs:Agg(Sum) + │ └── Mul + │ ├── #1 + │ └── Cast { cast_to: Decimal128(10, 0), expr: #0 } + ├── groups: [] + └── LogicalProjection { exprs: [ #0, #1 ] } + └── LogicalJoin + ├── join_type: Inner + ├── cond:Eq + │ ├── #2 + │ └── #3 + ├── LogicalProjection { exprs: [ #1, #2, #4 ] } + │ └── LogicalJoin + │ ├── join_type: Inner + │ ├── cond:Eq + │ │ ├── #0 + │ │ └── #3 + │ ├── LogicalProjection { exprs: [ #1, #2, #3 ] } + │ │ └── LogicalScan { table: partsupp } + │ └── LogicalProjection { exprs: [ #0, #3 ] } + │ └── LogicalScan { table: supplier } + └── LogicalProjection { exprs: [ #0 ] } + └── LogicalFilter + ├── cond:Eq + │ ├── #1 + │ └── "CHINA" + └── LogicalProjection { exprs: [ #0, #1 ] } + └── LogicalScan { table: nation } +PhysicalSort +├── exprs:SortOrder { order: Desc } +│ └── #1 +└── PhysicalProjection { exprs: [ #0, #1 ] } + └── PhysicalProjection { exprs: [ #0, #1 ] } + └── PhysicalNestedLoopJoin + ├── join_type: Inner + ├── cond:Gt + │ ├── Cast { cast_to: Decimal128(38, 15), expr: #1 } + │ └── #0 + ├── PhysicalProjection + │ ├── exprs:Cast + │ │ ├── cast_to: Decimal128(38, 15) + │ │ ├── expr:Mul + │ │ │ ├── Cast { cast_to: Float64, expr: #0 } + │ │ │ └── 0.0001(float) + + │ └── PhysicalAgg + │ ├── aggrs:Agg(Sum) + │ │ └── Mul + │ │ ├── #1 + │ │ └── Cast { cast_to: Decimal128(10, 0), expr: #0 } + │ ├── groups: [] + │ └── PhysicalProjection { exprs: [ #0, #1 ] } + │ └── PhysicalHashJoin { join_type: Inner, left_keys: [ #2 ], right_keys: [ #0 ] } + │ ├── PhysicalProjection { exprs: [ #1, #2, #4 ] } + │ │ └── PhysicalHashJoin { join_type: Inner, left_keys: [ #0 ], right_keys: [ #0 ] } + │ │ ├── PhysicalProjection { exprs: [ #1, #2, #3 ] } + │ │ │ └── PhysicalScan { table: partsupp } + │ │ └── PhysicalProjection { exprs: [ #0, #3 ] } + │ │ └── PhysicalScan { table: supplier } + │ └── PhysicalProjection { exprs: [ #0 ] } + │ └── PhysicalProjection { exprs: [ #0, #1 ] } + │ └── PhysicalFilter + │ ├── cond:Eq + │ │ ├── #1 + │ │ └── "CHINA" + │ └── PhysicalScan { table: nation } + └── PhysicalAgg + ├── aggrs:Agg(Sum) + │ └── Mul + │ ├── #2 + │ └── Cast { cast_to: Decimal128(10, 0), expr: #1 } + ├── groups: [ #0 ] + └── PhysicalProjection { exprs: [ #0, #1, #2 ] } + └── PhysicalHashJoin { join_type: Inner, left_keys: [ #3 ], right_keys: [ #0 ] } + ├── PhysicalProjection { exprs: [ #0, #2, #3, #5 ] } + │ └── PhysicalHashJoin { join_type: Inner, left_keys: [ #1 ], right_keys: [ #0 ] } + │ ├── PhysicalProjection { exprs: [ #0, #1, #2, #3 ] } + │ │ └── PhysicalScan { table: partsupp } + │ └── PhysicalProjection { exprs: [ #0, #3 ] } + │ └── PhysicalScan { table: supplier } + └── PhysicalProjection { exprs: [ #0 ] } + └── PhysicalProjection { exprs: [ #0, #1 ] } + └── PhysicalFilter + ├── cond:Eq + │ ├── #1 + │ └── "CHINA" + └── PhysicalScan { table: nation } +*/ + +-- TPC-H Q12 +SELECT + l_shipmode, + sum(case when o_orderpriority = '1-URGENT' + or o_orderpriority = '2-HIGH' + then 1 else 0 end) as high_priority_orders, + sum(case when o_orderpriority <> '1-URGENT' + and o_orderpriority <> '2-HIGH' + then 1 else 0 end) as low_priority_orders +FROM + orders, + lineitem +WHERE + o_orderkey = l_orderkey + AND l_shipmode in ('MAIL', 'SHIP') + AND l_commitdate < l_receiptdate + AND l_shipdate < l_commitdate + AND l_receiptdate >= DATE '1994-01-01' + AND l_receiptdate < DATE '1995-01-01' +GROUP BY + l_shipmode +ORDER BY + l_shipmode; + +/* +LogicalSort +├── exprs:SortOrder { order: Asc } +│ └── #0 +└── LogicalProjection { exprs: [ #0, #1, #2 ] } + └── LogicalAgg + ├── exprs: + │ ┌── Agg(Sum) + │ │ └── Case + │ │ └── + │ │ ┌── Or + │ │ │ ├── Eq + │ │ │ │ ├── #5 + │ │ │ │ └── "1-URGENT" + │ │ │ └── Eq + │ │ │ ├── #5 + │ │ │ └── "2-HIGH" + │ │ ├── 1(i64) + │ │ └── 0(i64) + │ └── Agg(Sum) + │ └── Case + │ └── + │ ┌── And + │ │ ├── Neq + │ │ │ ├── #5 + │ │ │ └── "1-URGENT" + │ │ └── Neq + │ │ ├── #5 + │ │ └── "2-HIGH" + │ ├── 1(i64) + │ └── 0(i64) + ├── groups: [ #23 ] + └── LogicalFilter + ├── cond:And + │ ├── Eq + │ │ ├── #0 + │ │ └── #9 + │ ├── InList { expr: #23, list: [ "MAIL", "SHIP" ], negated: false } + │ ├── Lt + │ │ ├── #20 + │ │ └── #21 + │ ├── Lt + │ │ ├── #19 + │ │ └── #20 + │ ├── Geq + │ │ ├── #21 + │ │ └── Cast { cast_to: Date32, expr: "1994-01-01" } + │ └── Lt + │ ├── #21 + │ └── Cast { cast_to: Date32, expr: "1995-01-01" } + └── LogicalJoin { join_type: Cross, cond: true } + ├── LogicalScan { table: orders } + └── LogicalScan { table: lineitem } +PhysicalSort +├── exprs:SortOrder { order: Asc } +│ └── #0 +└── PhysicalProjection { exprs: [ #0, #1, #2 ] } + └── PhysicalAgg + ├── aggrs: + │ ┌── Agg(Sum) + │ │ └── Case + │ │ └── + │ │ ┌── Or + │ │ │ ├── Eq + │ │ │ │ ├── #5 + │ │ │ │ └── "1-URGENT" + │ │ │ └── Eq + │ │ │ ├── #5 + │ │ │ └── "2-HIGH" + │ │ ├── 1(i64) + │ │ └── 0(i64) + │ └── Agg(Sum) + │ └── Case + │ └── + │ ┌── And + │ │ ├── Neq + │ │ │ ├── #5 + │ │ │ └── "1-URGENT" + │ │ └── Neq + │ │ ├── #5 + │ │ └── "2-HIGH" + │ ├── 1(i64) + │ └── 0(i64) + ├── groups: [ #23 ] + └── PhysicalHashJoin { join_type: Inner, left_keys: [ #0 ], right_keys: [ #0 ] } + ├── PhysicalScan { table: orders } + └── PhysicalFilter + ├── cond:And + │ ├── InList { expr: #14, list: [ "MAIL", "SHIP" ], negated: false } + │ ├── Lt + │ │ ├── #11 + │ │ └── #12 + │ ├── Lt + │ │ ├── #10 + │ │ └── #11 + │ ├── Geq + │ │ ├── #12 + │ │ └── Cast { cast_to: Date32, expr: "1994-01-01" } + │ └── Lt + │ ├── #12 + │ └── Cast { cast_to: Date32, expr: "1995-01-01" } + └── PhysicalScan { table: lineitem } +*/ + +-- TPC-H Q14 +SELECT + 100.00 * sum(case when p_type like 'PROMO%' + then l_extendedprice * (1 - l_discount) + else 0 end) / sum(l_extendedprice * (1 - l_discount)) as promo_revenue +FROM + lineitem, + part +WHERE + l_partkey = p_partkey + AND l_shipdate >= DATE '1995-09-01' + AND l_shipdate < DATE '1995-09-01' + INTERVAL '1' MONTH; + +/* +LogicalProjection +├── exprs:Div +│ ├── Mul +│ │ ├── 100(float) +│ │ └── Cast { cast_to: Float64, expr: #0 } +│ └── Cast { cast_to: Float64, expr: #1 } +└── LogicalAgg + ├── exprs: + │ ┌── Agg(Sum) + │ │ └── Case + │ │ └── + │ │ ┌── Like { expr: #20, pattern: "PROMO%", negated: false, case_insensitive: false } + │ │ ├── Mul + │ │ │ ├── #5 + │ │ │ └── Sub + │ │ │ ├── Cast { cast_to: Decimal128(20, 0), expr: 1(i64) } + │ │ │ └── #6 + │ │ └── Cast { cast_to: Decimal128(38, 4), expr: 0(i64) } + │ └── Agg(Sum) + │ └── Mul + │ ├── #5 + │ └── Sub + │ ├── Cast { cast_to: Decimal128(20, 0), expr: 1(i64) } + │ └── #6 + ├── groups: [] + └── LogicalFilter + ├── cond:And + │ ├── Eq + │ │ ├── #1 + │ │ └── #16 + │ ├── Geq + │ │ ├── #10 + │ │ └── Cast { cast_to: Date32, expr: "1995-09-01" } + │ └── Lt + │ ├── #10 + │ └── Add + │ ├── Cast { cast_to: Date32, expr: "1995-09-01" } + │ └── INTERVAL_MONTH_DAY_NANO (1, 0, 0) + └── LogicalJoin { join_type: Cross, cond: true } + ├── LogicalScan { table: lineitem } + └── LogicalScan { table: part } +PhysicalProjection +├── exprs:Div +│ ├── Mul +│ │ ├── 100(float) +│ │ └── Cast { cast_to: Float64, expr: #0 } +│ └── Cast { cast_to: Float64, expr: #1 } +└── PhysicalAgg + ├── aggrs: + │ ┌── Agg(Sum) + │ │ └── Case + │ │ └── + │ │ ┌── Like { expr: #20, pattern: "PROMO%", negated: false, case_insensitive: false } + │ │ ├── Mul + │ │ │ ├── #5 + │ │ │ └── Sub + │ │ │ ├── Cast { cast_to: Decimal128(20, 0), expr: 1(i64) } + │ │ │ └── #6 + │ │ └── Cast { cast_to: Decimal128(38, 4), expr: 0(i64) } + │ └── Agg(Sum) + │ └── Mul + │ ├── #5 + │ └── Sub + │ ├── Cast { cast_to: Decimal128(20, 0), expr: 1(i64) } + │ └── #6 + ├── groups: [] + └── PhysicalHashJoin { join_type: Inner, left_keys: [ #1 ], right_keys: [ #0 ] } + ├── PhysicalFilter + │ ├── cond:And + │ │ ├── Geq + │ │ │ ├── #10 + │ │ │ └── Cast { cast_to: Date32, expr: "1995-09-01" } + │ │ └── Lt + │ │ ├── #10 + │ │ └── Add + │ │ ├── Cast { cast_to: Date32, expr: "1995-09-01" } + │ │ └── INTERVAL_MONTH_DAY_NANO (1, 0, 0) + │ └── PhysicalScan { table: lineitem } + └── PhysicalScan { table: part } +*/ + +-- TPC-H Q15 +WITH revenue0 (supplier_no, total_revenue) AS +( + SELECT + l_suppkey, + SUM(l_extendedprice * (1 - l_discount)) + FROM + lineitem + WHERE + l_shipdate >= DATE '1993-01-01' + AND l_shipdate < DATE '1993-01-01' + INTERVAL '3' MONTH + GROUP BY + l_suppkey +) +SELECT + s_suppkey, + s_name, + s_address, + s_phone, + total_revenue +FROM + supplier, + revenue0 +WHERE + s_suppkey = supplier_no + AND total_revenue = + ( + SELECT + MAX(total_revenue) + FROM + revenue0 + ) +ORDER BY + s_suppkey; + +/* +LogicalSort +├── exprs:SortOrder { order: Asc } +│ └── #0 +└── LogicalProjection { exprs: [ #0, #1, #2, #3, #4 ] } + └── LogicalJoin + ├── join_type: Inner + ├── cond:Eq + │ ├── #4 + │ └── #5 + ├── LogicalProjection { exprs: [ #0, #1, #2, #3, #5 ] } + │ └── LogicalJoin + │ ├── join_type: Inner + │ ├── cond:Eq + │ │ ├── #0 + │ │ └── #4 + │ ├── LogicalProjection { exprs: [ #0, #1, #2, #4 ] } + │ │ └── LogicalScan { table: supplier } + │ └── LogicalProjection { exprs: [ #0, #1 ] } + │ └── LogicalAgg + │ ├── exprs:Agg(Sum) + │ │ └── Mul + │ │ ├── #1 + │ │ └── Sub + │ │ ├── 1(float) + │ │ └── #2 + │ ├── groups: [ #0 ] + │ └── LogicalProjection { exprs: [ #0, #1, #2 ] } + │ └── LogicalFilter + │ ├── cond:And + │ │ ├── Geq + │ │ │ ├── #3 + │ │ │ └── 8401(i64) + │ │ └── Lt + │ │ ├── #3 + │ │ └── 8491(i64) + │ └── LogicalProjection { exprs: [ #2, #5, #6, #10 ] } + │ └── LogicalScan { table: lineitem } + └── LogicalAgg + ├── exprs:Agg(Max) + │ └── [ #0 ] + ├── groups: [] + └── LogicalProjection { exprs: [ #1 ] } + └── LogicalAgg + ├── exprs:Agg(Sum) + │ └── Mul + │ ├── #1 + │ └── Sub + │ ├── 1(float) + │ └── #2 + ├── groups: [ #0 ] + └── LogicalProjection { exprs: [ #0, #1, #2 ] } + └── LogicalFilter + ├── cond:And + │ ├── Geq + │ │ ├── #3 + │ │ └── 8401(i64) + │ └── Lt + │ ├── #3 + │ └── 8491(i64) + └── LogicalProjection { exprs: [ #2, #5, #6, #10 ] } + └── LogicalScan { table: lineitem } +PhysicalSort +├── exprs:SortOrder { order: Asc } +│ └── #0 +└── PhysicalProjection { exprs: [ #0, #1, #2, #3, #4 ] } + └── PhysicalProjection { exprs: [ #0, #1, #2, #3, #5, #6 ] } + └── PhysicalHashJoin { join_type: Inner, left_keys: [ #0 ], right_keys: [ #0 ] } + ├── PhysicalProjection { exprs: [ #0, #1, #2, #4 ] } + │ └── PhysicalScan { table: supplier } + └── PhysicalProjection { exprs: [ #0, #1, #2 ] } + └── PhysicalProjection { exprs: [ #1, #2, #0 ] } + └── PhysicalHashJoin { join_type: Inner, left_keys: [ #0 ], right_keys: [ #1 ] } + ├── PhysicalAgg + │ ├── aggrs:Agg(Max) + │ │ └── [ #0 ] + │ ├── groups: [] + │ └── PhysicalProjection { exprs: [ #1 ] } + │ └── PhysicalAgg + │ ├── aggrs:Agg(Sum) + │ │ └── Mul + │ │ ├── #1 + │ │ └── Sub + │ │ ├── 1(float) + │ │ └── #2 + │ ├── groups: [ #0 ] + │ └── PhysicalProjection { exprs: [ #0, #1, #2 ] } + │ └── PhysicalProjection { exprs: [ #2, #5, #6, #10 ] } + │ └── PhysicalFilter + │ ├── cond:And + │ │ ├── Geq + │ │ │ ├── #10 + │ │ │ └── 8401(i64) + │ │ └── Lt + │ │ ├── #10 + │ │ └── 8491(i64) + │ └── PhysicalScan { table: lineitem } + └── PhysicalAgg + ├── aggrs:Agg(Sum) + │ └── Mul + │ ├── #1 + │ └── Sub + │ ├── 1(float) + │ └── #2 + ├── groups: [ #0 ] + └── PhysicalProjection { exprs: [ #0, #1, #2 ] } + └── PhysicalProjection { exprs: [ #2, #5, #6, #10 ] } + └── PhysicalFilter + ├── cond:And + │ ├── Geq + │ │ ├── #10 + │ │ └── 8401(i64) + │ └── Lt + │ ├── #10 + │ └── 8491(i64) + └── PhysicalScan { table: lineitem } +*/ + diff --git a/optd-sqlplannertest/tests/tpch/tpch-11-15.yml b/optd-sqlplannertest/tests/tpch/tpch-11-15.yml new file mode 100644 index 00000000..988f8123 --- /dev/null +++ b/optd-sqlplannertest/tests/tpch/tpch-11-15.yml @@ -0,0 +1,197 @@ +- sql: | + CREATE TABLE NATION ( + N_NATIONKEY INT NOT NULL, + N_NAME CHAR(25) NOT NULL, + N_REGIONKEY INT NOT NULL, + N_COMMENT VARCHAR(152) + ); + + CREATE TABLE REGION ( + R_REGIONKEY INT NOT NULL, + R_NAME CHAR(25) NOT NULL, + R_COMMENT VARCHAR(152) + ); + + CREATE TABLE PART ( + P_PARTKEY INT NOT NULL, + P_NAME VARCHAR(55) NOT NULL, + P_MFGR CHAR(25) NOT NULL, + P_BRAND CHAR(10) NOT NULL, + P_TYPE VARCHAR(25) NOT NULL, + P_SIZE INT NOT NULL, + P_CONTAINER CHAR(10) NOT NULL, + P_RETAILPRICE DECIMAL(15,2) NOT NULL, + P_COMMENT VARCHAR(23) NOT NULL + ); + + CREATE TABLE SUPPLIER ( + S_SUPPKEY INT NOT NULL, + S_NAME CHAR(25) NOT NULL, + S_ADDRESS VARCHAR(40) NOT NULL, + S_NATIONKEY INT NOT NULL, + S_PHONE CHAR(15) NOT NULL, + S_ACCTBAL DECIMAL(15,2) NOT NULL, + S_COMMENT VARCHAR(101) NOT NULL + ); + + CREATE TABLE PARTSUPP ( + PS_PARTKEY INT NOT NULL, + PS_SUPPKEY INT NOT NULL, + PS_AVAILQTY INT NOT NULL, + PS_SUPPLYCOST DECIMAL(15,2) NOT NULL, + PS_COMMENT VARCHAR(199) NOT NULL + ); + + CREATE TABLE CUSTOMER ( + C_CUSTKEY INT NOT NULL, + C_NAME VARCHAR(25) NOT NULL, + C_ADDRESS VARCHAR(40) NOT NULL, + C_NATIONKEY INT NOT NULL, + C_PHONE CHAR(15) NOT NULL, + C_ACCTBAL DECIMAL(15,2) NOT NULL, + C_MKTSEGMENT CHAR(10) NOT NULL, + C_COMMENT VARCHAR(117) NOT NULL + ); + + CREATE TABLE ORDERS ( + O_ORDERKEY INT NOT NULL, + O_CUSTKEY INT NOT NULL, + O_ORDERSTATUS CHAR(1) NOT NULL, + O_TOTALPRICE DECIMAL(15,2) NOT NULL, + O_ORDERDATE DATE NOT NULL, + O_ORDERPRIORITY CHAR(15) NOT NULL, + O_CLERK CHAR(15) NOT NULL, + O_SHIPPRIORITY INT NOT NULL, + O_COMMENT VARCHAR(79) NOT NULL + ); + + CREATE TABLE LINEITEM ( + L_ORDERKEY INT NOT NULL, + L_PARTKEY INT NOT NULL, + L_SUPPKEY INT NOT NULL, + L_LINENUMBER INT NOT NULL, + L_QUANTITY DECIMAL(15,2) NOT NULL, + L_EXTENDEDPRICE DECIMAL(15,2) NOT NULL, + L_DISCOUNT DECIMAL(15,2) NOT NULL, + L_TAX DECIMAL(15,2) NOT NULL, + L_RETURNFLAG CHAR(1) NOT NULL, + L_LINESTATUS CHAR(1) NOT NULL, + L_SHIPDATE DATE NOT NULL, + L_COMMITDATE DATE NOT NULL, + L_RECEIPTDATE DATE NOT NULL, + L_SHIPINSTRUCT CHAR(25) NOT NULL, + L_SHIPMODE CHAR(10) NOT NULL, + L_COMMENT VARCHAR(44) NOT NULL + ); + desc: TPC-H schema + tasks: + - execute +- sql: | + select + ps_partkey, + sum(ps_supplycost * ps_availqty) as value + from + partsupp, + supplier, + nation + where + ps_suppkey = s_suppkey + and s_nationkey = n_nationkey + and n_name = 'CHINA' + group by + ps_partkey having + sum(ps_supplycost * ps_availqty) > ( + select + sum(ps_supplycost * ps_availqty) * 0.0001000000 + from + partsupp, + supplier, + nation + where + ps_suppkey = s_suppkey + and s_nationkey = n_nationkey + and n_name = 'CHINA' + ) + order by + value desc; + desc: TPC-H Q11 + tasks: + - explain[use_df_logical]:logical_optd,physical_optd +- sql: | + SELECT + l_shipmode, + sum(case when o_orderpriority = '1-URGENT' + or o_orderpriority = '2-HIGH' + then 1 else 0 end) as high_priority_orders, + sum(case when o_orderpriority <> '1-URGENT' + and o_orderpriority <> '2-HIGH' + then 1 else 0 end) as low_priority_orders + FROM + orders, + lineitem + WHERE + o_orderkey = l_orderkey + AND l_shipmode in ('MAIL', 'SHIP') + AND l_commitdate < l_receiptdate + AND l_shipdate < l_commitdate + AND l_receiptdate >= DATE '1994-01-01' + AND l_receiptdate < DATE '1995-01-01' + GROUP BY + l_shipmode + ORDER BY + l_shipmode; + desc: TPC-H Q12 + tasks: + - explain:logical_optd,physical_optd +- sql: | + SELECT + 100.00 * sum(case when p_type like 'PROMO%' + then l_extendedprice * (1 - l_discount) + else 0 end) / sum(l_extendedprice * (1 - l_discount)) as promo_revenue + FROM + lineitem, + part + WHERE + l_partkey = p_partkey + AND l_shipdate >= DATE '1995-09-01' + AND l_shipdate < DATE '1995-09-01' + INTERVAL '1' MONTH; + desc: TPC-H Q14 + tasks: + - explain:logical_optd,physical_optd +- sql: | + WITH revenue0 (supplier_no, total_revenue) AS + ( + SELECT + l_suppkey, + SUM(l_extendedprice * (1 - l_discount)) + FROM + lineitem + WHERE + l_shipdate >= DATE '1993-01-01' + AND l_shipdate < DATE '1993-01-01' + INTERVAL '3' MONTH + GROUP BY + l_suppkey + ) + SELECT + s_suppkey, + s_name, + s_address, + s_phone, + total_revenue + FROM + supplier, + revenue0 + WHERE + s_suppkey = supplier_no + AND total_revenue = + ( + SELECT + MAX(total_revenue) + FROM + revenue0 + ) + ORDER BY + s_suppkey; + desc: TPC-H Q15 + tasks: + - explain[use_df_logical]:logical_optd,physical_optd diff --git a/optd-sqlplannertest/tests/tpch/tpch-16-20.planner.sql b/optd-sqlplannertest/tests/tpch/tpch-16-20.planner.sql new file mode 100644 index 00000000..0bc642fe --- /dev/null +++ b/optd-sqlplannertest/tests/tpch/tpch-16-20.planner.sql @@ -0,0 +1,396 @@ +-- TPC-H schema +CREATE TABLE NATION ( + N_NATIONKEY INT NOT NULL, + N_NAME CHAR(25) NOT NULL, + N_REGIONKEY INT NOT NULL, + N_COMMENT VARCHAR(152) +); + +CREATE TABLE REGION ( + R_REGIONKEY INT NOT NULL, + R_NAME CHAR(25) NOT NULL, + R_COMMENT VARCHAR(152) +); + +CREATE TABLE PART ( + P_PARTKEY INT NOT NULL, + P_NAME VARCHAR(55) NOT NULL, + P_MFGR CHAR(25) NOT NULL, + P_BRAND CHAR(10) NOT NULL, + P_TYPE VARCHAR(25) NOT NULL, + P_SIZE INT NOT NULL, + P_CONTAINER CHAR(10) NOT NULL, + P_RETAILPRICE DECIMAL(15,2) NOT NULL, + P_COMMENT VARCHAR(23) NOT NULL +); + +CREATE TABLE SUPPLIER ( + S_SUPPKEY INT NOT NULL, + S_NAME CHAR(25) NOT NULL, + S_ADDRESS VARCHAR(40) NOT NULL, + S_NATIONKEY INT NOT NULL, + S_PHONE CHAR(15) NOT NULL, + S_ACCTBAL DECIMAL(15,2) NOT NULL, + S_COMMENT VARCHAR(101) NOT NULL +); + +CREATE TABLE PARTSUPP ( + PS_PARTKEY INT NOT NULL, + PS_SUPPKEY INT NOT NULL, + PS_AVAILQTY INT NOT NULL, + PS_SUPPLYCOST DECIMAL(15,2) NOT NULL, + PS_COMMENT VARCHAR(199) NOT NULL +); + +CREATE TABLE CUSTOMER ( + C_CUSTKEY INT NOT NULL, + C_NAME VARCHAR(25) NOT NULL, + C_ADDRESS VARCHAR(40) NOT NULL, + C_NATIONKEY INT NOT NULL, + C_PHONE CHAR(15) NOT NULL, + C_ACCTBAL DECIMAL(15,2) NOT NULL, + C_MKTSEGMENT CHAR(10) NOT NULL, + C_COMMENT VARCHAR(117) NOT NULL +); + +CREATE TABLE ORDERS ( + O_ORDERKEY INT NOT NULL, + O_CUSTKEY INT NOT NULL, + O_ORDERSTATUS CHAR(1) NOT NULL, + O_TOTALPRICE DECIMAL(15,2) NOT NULL, + O_ORDERDATE DATE NOT NULL, + O_ORDERPRIORITY CHAR(15) NOT NULL, + O_CLERK CHAR(15) NOT NULL, + O_SHIPPRIORITY INT NOT NULL, + O_COMMENT VARCHAR(79) NOT NULL +); + +CREATE TABLE LINEITEM ( + L_ORDERKEY INT NOT NULL, + L_PARTKEY INT NOT NULL, + L_SUPPKEY INT NOT NULL, + L_LINENUMBER INT NOT NULL, + L_QUANTITY DECIMAL(15,2) NOT NULL, + L_EXTENDEDPRICE DECIMAL(15,2) NOT NULL, + L_DISCOUNT DECIMAL(15,2) NOT NULL, + L_TAX DECIMAL(15,2) NOT NULL, + L_RETURNFLAG CHAR(1) NOT NULL, + L_LINESTATUS CHAR(1) NOT NULL, + L_SHIPDATE DATE NOT NULL, + L_COMMITDATE DATE NOT NULL, + L_RECEIPTDATE DATE NOT NULL, + L_SHIPINSTRUCT CHAR(25) NOT NULL, + L_SHIPMODE CHAR(10) NOT NULL, + L_COMMENT VARCHAR(44) NOT NULL +); + +/* + +*/ + +-- TPC-H Q17 +SELECT + ROUND(SUM(l_extendedprice) / 7.0, 16) AS avg_yearly +FROM + lineitem, + part +WHERE + p_partkey = l_partkey + AND p_brand = 'Brand#13' + AND p_container = 'JUMBO PKG' + AND l_quantity < ( + SELECT + 0.2 * AVG(l_quantity) + FROM + lineitem + WHERE + l_partkey = p_partkey + ); + +/* +LogicalProjection +├── exprs:Scalar(Round) +│ └── +│ ┌── Div +│ │ ├── Cast { cast_to: Float64, expr: #0 } +│ │ └── 7(float) +│ └── 16(i64) +└── LogicalAgg + ├── exprs:Agg(Sum) + │ └── [ #0 ] + ├── groups: [] + └── LogicalProjection { exprs: [ #1 ] } + └── LogicalJoin + ├── join_type: Inner + ├── cond:And + │ ├── Eq + │ │ ├── #2 + │ │ └── #4 + │ └── Lt + │ ├── Cast { cast_to: Decimal128(30, 15), expr: #0 } + │ └── #3 + ├── LogicalProjection { exprs: [ #1, #2, #3 ] } + │ └── LogicalJoin + │ ├── join_type: Inner + │ ├── cond:Eq + │ │ ├── #0 + │ │ └── #3 + │ ├── LogicalProjection { exprs: [ #1, #4, #5 ] } + │ │ └── LogicalScan { table: lineitem } + │ └── LogicalProjection { exprs: [ #0 ] } + │ └── LogicalFilter + │ ├── cond:And + │ │ ├── Eq + │ │ │ ├── #1 + │ │ │ └── "Brand#13" + │ │ └── Eq + │ │ ├── #2 + │ │ └── "JUMBO PKG" + │ └── LogicalProjection { exprs: [ #0, #3, #6 ] } + │ └── LogicalScan { table: part } + └── LogicalProjection + ├── exprs: + │ ┌── Cast + │ │ ├── cast_to: Decimal128(30, 15) + │ │ ├── expr:Mul + │ │ │ ├── 0.2(float) + │ │ │ └── Cast { cast_to: Float64, expr: #1 } + + │ └── #0 + └── LogicalAgg + ├── exprs:Agg(Avg) + │ └── [ #1 ] + ├── groups: [ #0 ] + └── LogicalProjection { exprs: [ #1, #4 ] } + └── LogicalScan { table: lineitem } +PhysicalProjection +├── exprs:Scalar(Round) +│ └── +│ ┌── Div +│ │ ├── Cast { cast_to: Float64, expr: #0 } +│ │ └── 7(float) +│ └── 16(i64) +└── PhysicalAgg + ├── aggrs:Agg(Sum) + │ └── [ #0 ] + ├── groups: [] + └── PhysicalProjection { exprs: [ #1 ] } + └── PhysicalNestedLoopJoin + ├── join_type: Inner + ├── cond:And + │ ├── Eq + │ │ ├── #2 + │ │ └── #0 + │ └── Lt + │ ├── Cast { cast_to: Decimal128(30, 15), expr: #0 } + │ └── #3 + ├── PhysicalProjection { exprs: [ #1, #2, #3 ] } + │ └── PhysicalHashJoin { join_type: Inner, left_keys: [ #0 ], right_keys: [ #0 ] } + │ ├── PhysicalProjection { exprs: [ #1, #4, #5 ] } + │ │ └── PhysicalScan { table: lineitem } + │ └── PhysicalProjection { exprs: [ #0 ] } + │ └── PhysicalProjection { exprs: [ #0, #3, #6 ] } + │ └── PhysicalFilter + │ ├── cond:And + │ │ ├── Eq + │ │ │ ├── #3 + │ │ │ └── "Brand#13" + │ │ └── Eq + │ │ ├── #6 + │ │ └── "JUMBO PKG" + │ └── PhysicalScan { table: part } + └── PhysicalProjection + ├── exprs: + │ ┌── Cast + │ │ ├── cast_to: Decimal128(30, 15) + │ │ ├── expr:Mul + │ │ │ ├── 0.2(float) + │ │ │ └── Cast { cast_to: Float64, expr: #1 } + + │ └── #0 + └── PhysicalAgg + ├── aggrs:Agg(Avg) + │ └── [ #1 ] + ├── groups: [ #0 ] + └── PhysicalProjection { exprs: [ #1, #4 ] } + └── PhysicalScan { table: lineitem } +*/ + +-- TPC-H Q19 +SELECT + sum(l_extendedprice* (1 - l_discount)) as revenue +FROM + lineitem, + part +WHERE + ( + p_partkey = l_partkey + AND p_brand = 'Brand#12' + AND p_container IN ('SM CASE', 'SM BOX', 'SM PACK', 'SM PKG') + AND l_quantity >= 1 AND l_quantity <= 11 + AND p_size BETWEEN 1 AND 5 + AND l_shipmode IN ('AIR', 'AIR REG') + AND l_shipinstruct = 'DELIVER IN PERSON' + ) OR ( + p_partkey = l_partkey + AND p_brand = 'Brand#23' + AND p_container IN ('MED BAG', 'MED BOX', 'MED PKG', 'MED PACK') + AND l_quantity >= 10 AND l_quantity <= 20 + AND p_size BETWEEN 1 AND 10 + AND l_shipmode IN ('AIR', 'AIR REG') + AND l_shipinstruct = 'DELIVER IN PERSON' + ) OR ( + p_partkey = l_partkey + AND p_brand = 'Brand#34' + AND p_container IN ('LG CASE', 'LG BOX', 'LG PACK', 'LG PKG') + AND l_quantity >= 20 AND l_quantity <= 30 + AND p_size BETWEEN 1 AND 15 + AND l_shipmode IN ('AIR', 'AIR REG') + AND l_shipinstruct = 'DELIVER IN PERSON' + ) + +/* +LogicalProjection { exprs: [ #0 ] } +└── LogicalAgg + ├── exprs:Agg(Sum) + │ └── Mul + │ ├── #5 + │ └── Sub + │ ├── Cast { cast_to: Decimal128(20, 0), expr: 1(i64) } + │ └── #6 + ├── groups: [] + └── LogicalFilter + ├── cond:Or + │ ├── And + │ │ ├── Eq + │ │ │ ├── #16 + │ │ │ └── #1 + │ │ ├── Eq + │ │ │ ├── #19 + │ │ │ └── "Brand#12" + │ │ ├── InList { expr: #22, list: [ "SM CASE", "SM BOX", "SM PACK", "SM PKG" ], negated: false } + │ │ ├── Geq + │ │ │ ├── Cast { cast_to: Decimal128(22, 2), expr: #4 } + │ │ │ └── Cast { cast_to: Decimal128(22, 2), expr: 1(i64) } + │ │ ├── Leq + │ │ │ ├── Cast { cast_to: Decimal128(22, 2), expr: #4 } + │ │ │ └── Cast { cast_to: Decimal128(22, 2), expr: 11(i64) } + │ │ ├── Between { expr: Cast { cast_to: Int64, expr: #21 }, lower: 1(i64), upper: 5(i64) } + │ │ ├── InList { expr: #14, list: [ "AIR", "AIR REG" ], negated: false } + │ │ └── Eq + │ │ ├── #13 + │ │ └── "DELIVER IN PERSON" + │ ├── And + │ │ ├── Eq + │ │ │ ├── #16 + │ │ │ └── #1 + │ │ ├── Eq + │ │ │ ├── #19 + │ │ │ └── "Brand#23" + │ │ ├── InList { expr: #22, list: [ "MED BAG", "MED BOX", "MED PKG", "MED PACK" ], negated: false } + │ │ ├── Geq + │ │ │ ├── Cast { cast_to: Decimal128(22, 2), expr: #4 } + │ │ │ └── Cast { cast_to: Decimal128(22, 2), expr: 10(i64) } + │ │ ├── Leq + │ │ │ ├── Cast { cast_to: Decimal128(22, 2), expr: #4 } + │ │ │ └── Cast { cast_to: Decimal128(22, 2), expr: 20(i64) } + │ │ ├── Between { expr: Cast { cast_to: Int64, expr: #21 }, lower: 1(i64), upper: 10(i64) } + │ │ ├── InList { expr: #14, list: [ "AIR", "AIR REG" ], negated: false } + │ │ └── Eq + │ │ ├── #13 + │ │ └── "DELIVER IN PERSON" + │ └── And + │ ├── Eq + │ │ ├── #16 + │ │ └── #1 + │ ├── Eq + │ │ ├── #19 + │ │ └── "Brand#34" + │ ├── InList { expr: #22, list: [ "LG CASE", "LG BOX", "LG PACK", "LG PKG" ], negated: false } + │ ├── Geq + │ │ ├── Cast { cast_to: Decimal128(22, 2), expr: #4 } + │ │ └── Cast { cast_to: Decimal128(22, 2), expr: 20(i64) } + │ ├── Leq + │ │ ├── Cast { cast_to: Decimal128(22, 2), expr: #4 } + │ │ └── Cast { cast_to: Decimal128(22, 2), expr: 30(i64) } + │ ├── Between { expr: Cast { cast_to: Int64, expr: #21 }, lower: 1(i64), upper: 15(i64) } + │ ├── InList { expr: #14, list: [ "AIR", "AIR REG" ], negated: false } + │ └── Eq + │ ├── #13 + │ └── "DELIVER IN PERSON" + └── LogicalJoin { join_type: Cross, cond: true } + ├── LogicalScan { table: lineitem } + └── LogicalScan { table: part } +PhysicalProjection { exprs: [ #0 ] } +└── PhysicalAgg + ├── aggrs:Agg(Sum) + │ └── Mul + │ ├── #5 + │ └── Sub + │ ├── Cast { cast_to: Decimal128(20, 0), expr: 1(i64) } + │ └── #6 + ├── groups: [] + └── PhysicalNestedLoopJoin + ├── join_type: Inner + ├── cond:Or + │ ├── And + │ │ ├── Eq + │ │ │ ├── #16 + │ │ │ └── #1 + │ │ ├── Eq + │ │ │ ├── #19 + │ │ │ └── "Brand#12" + │ │ ├── InList { expr: #22, list: [ "SM CASE", "SM BOX", "SM PACK", "SM PKG" ], negated: false } + │ │ ├── Geq + │ │ │ ├── Cast { cast_to: Decimal128(22, 2), expr: #4 } + │ │ │ └── Cast { cast_to: Decimal128(22, 2), expr: 1(i64) } + │ │ ├── Leq + │ │ │ ├── Cast { cast_to: Decimal128(22, 2), expr: #4 } + │ │ │ └── Cast { cast_to: Decimal128(22, 2), expr: 11(i64) } + │ │ ├── Between { expr: Cast { cast_to: Int64, expr: #21 }, lower: 1(i64), upper: 5(i64) } + │ │ ├── InList { expr: #14, list: [ "AIR", "AIR REG" ], negated: false } + │ │ └── Eq + │ │ ├── #13 + │ │ └── "DELIVER IN PERSON" + │ ├── And + │ │ ├── Eq + │ │ │ ├── #16 + │ │ │ └── #1 + │ │ ├── Eq + │ │ │ ├── #19 + │ │ │ └── "Brand#23" + │ │ ├── InList { expr: #22, list: [ "MED BAG", "MED BOX", "MED PKG", "MED PACK" ], negated: false } + │ │ ├── Geq + │ │ │ ├── Cast { cast_to: Decimal128(22, 2), expr: #4 } + │ │ │ └── Cast { cast_to: Decimal128(22, 2), expr: 10(i64) } + │ │ ├── Leq + │ │ │ ├── Cast { cast_to: Decimal128(22, 2), expr: #4 } + │ │ │ └── Cast { cast_to: Decimal128(22, 2), expr: 20(i64) } + │ │ ├── Between { expr: Cast { cast_to: Int64, expr: #21 }, lower: 1(i64), upper: 10(i64) } + │ │ ├── InList { expr: #14, list: [ "AIR", "AIR REG" ], negated: false } + │ │ └── Eq + │ │ ├── #13 + │ │ └── "DELIVER IN PERSON" + │ └── And + │ ├── Eq + │ │ ├── #16 + │ │ └── #1 + │ ├── Eq + │ │ ├── #19 + │ │ └── "Brand#34" + │ ├── InList { expr: #22, list: [ "LG CASE", "LG BOX", "LG PACK", "LG PKG" ], negated: false } + │ ├── Geq + │ │ ├── Cast { cast_to: Decimal128(22, 2), expr: #4 } + │ │ └── Cast { cast_to: Decimal128(22, 2), expr: 20(i64) } + │ ├── Leq + │ │ ├── Cast { cast_to: Decimal128(22, 2), expr: #4 } + │ │ └── Cast { cast_to: Decimal128(22, 2), expr: 30(i64) } + │ ├── Between { expr: Cast { cast_to: Int64, expr: #21 }, lower: 1(i64), upper: 15(i64) } + │ ├── InList { expr: #14, list: [ "AIR", "AIR REG" ], negated: false } + │ └── Eq + │ ├── #13 + │ └── "DELIVER IN PERSON" + ├── PhysicalScan { table: lineitem } + └── PhysicalScan { table: part } +*/ + diff --git a/optd-sqlplannertest/tests/tpch/tpch-16-20.yml b/optd-sqlplannertest/tests/tpch/tpch-16-20.yml new file mode 100644 index 00000000..3a7279ad --- /dev/null +++ b/optd-sqlplannertest/tests/tpch/tpch-16-20.yml @@ -0,0 +1,144 @@ +- sql: | + CREATE TABLE NATION ( + N_NATIONKEY INT NOT NULL, + N_NAME CHAR(25) NOT NULL, + N_REGIONKEY INT NOT NULL, + N_COMMENT VARCHAR(152) + ); + + CREATE TABLE REGION ( + R_REGIONKEY INT NOT NULL, + R_NAME CHAR(25) NOT NULL, + R_COMMENT VARCHAR(152) + ); + + CREATE TABLE PART ( + P_PARTKEY INT NOT NULL, + P_NAME VARCHAR(55) NOT NULL, + P_MFGR CHAR(25) NOT NULL, + P_BRAND CHAR(10) NOT NULL, + P_TYPE VARCHAR(25) NOT NULL, + P_SIZE INT NOT NULL, + P_CONTAINER CHAR(10) NOT NULL, + P_RETAILPRICE DECIMAL(15,2) NOT NULL, + P_COMMENT VARCHAR(23) NOT NULL + ); + + CREATE TABLE SUPPLIER ( + S_SUPPKEY INT NOT NULL, + S_NAME CHAR(25) NOT NULL, + S_ADDRESS VARCHAR(40) NOT NULL, + S_NATIONKEY INT NOT NULL, + S_PHONE CHAR(15) NOT NULL, + S_ACCTBAL DECIMAL(15,2) NOT NULL, + S_COMMENT VARCHAR(101) NOT NULL + ); + + CREATE TABLE PARTSUPP ( + PS_PARTKEY INT NOT NULL, + PS_SUPPKEY INT NOT NULL, + PS_AVAILQTY INT NOT NULL, + PS_SUPPLYCOST DECIMAL(15,2) NOT NULL, + PS_COMMENT VARCHAR(199) NOT NULL + ); + + CREATE TABLE CUSTOMER ( + C_CUSTKEY INT NOT NULL, + C_NAME VARCHAR(25) NOT NULL, + C_ADDRESS VARCHAR(40) NOT NULL, + C_NATIONKEY INT NOT NULL, + C_PHONE CHAR(15) NOT NULL, + C_ACCTBAL DECIMAL(15,2) NOT NULL, + C_MKTSEGMENT CHAR(10) NOT NULL, + C_COMMENT VARCHAR(117) NOT NULL + ); + + CREATE TABLE ORDERS ( + O_ORDERKEY INT NOT NULL, + O_CUSTKEY INT NOT NULL, + O_ORDERSTATUS CHAR(1) NOT NULL, + O_TOTALPRICE DECIMAL(15,2) NOT NULL, + O_ORDERDATE DATE NOT NULL, + O_ORDERPRIORITY CHAR(15) NOT NULL, + O_CLERK CHAR(15) NOT NULL, + O_SHIPPRIORITY INT NOT NULL, + O_COMMENT VARCHAR(79) NOT NULL + ); + + CREATE TABLE LINEITEM ( + L_ORDERKEY INT NOT NULL, + L_PARTKEY INT NOT NULL, + L_SUPPKEY INT NOT NULL, + L_LINENUMBER INT NOT NULL, + L_QUANTITY DECIMAL(15,2) NOT NULL, + L_EXTENDEDPRICE DECIMAL(15,2) NOT NULL, + L_DISCOUNT DECIMAL(15,2) NOT NULL, + L_TAX DECIMAL(15,2) NOT NULL, + L_RETURNFLAG CHAR(1) NOT NULL, + L_LINESTATUS CHAR(1) NOT NULL, + L_SHIPDATE DATE NOT NULL, + L_COMMITDATE DATE NOT NULL, + L_RECEIPTDATE DATE NOT NULL, + L_SHIPINSTRUCT CHAR(25) NOT NULL, + L_SHIPMODE CHAR(10) NOT NULL, + L_COMMENT VARCHAR(44) NOT NULL + ); + desc: TPC-H schema + tasks: + - execute +- sql: | + SELECT + ROUND(SUM(l_extendedprice) / 7.0, 16) AS avg_yearly + FROM + lineitem, + part + WHERE + p_partkey = l_partkey + AND p_brand = 'Brand#13' + AND p_container = 'JUMBO PKG' + AND l_quantity < ( + SELECT + 0.2 * AVG(l_quantity) + FROM + lineitem + WHERE + l_partkey = p_partkey + ); + desc: TPC-H Q17 + tasks: + - explain[use_df_logical]:logical_optd,physical_optd +- sql: | + SELECT + sum(l_extendedprice* (1 - l_discount)) as revenue + FROM + lineitem, + part + WHERE + ( + p_partkey = l_partkey + AND p_brand = 'Brand#12' + AND p_container IN ('SM CASE', 'SM BOX', 'SM PACK', 'SM PKG') + AND l_quantity >= 1 AND l_quantity <= 11 + AND p_size BETWEEN 1 AND 5 + AND l_shipmode IN ('AIR', 'AIR REG') + AND l_shipinstruct = 'DELIVER IN PERSON' + ) OR ( + p_partkey = l_partkey + AND p_brand = 'Brand#23' + AND p_container IN ('MED BAG', 'MED BOX', 'MED PKG', 'MED PACK') + AND l_quantity >= 10 AND l_quantity <= 20 + AND p_size BETWEEN 1 AND 10 + AND l_shipmode IN ('AIR', 'AIR REG') + AND l_shipinstruct = 'DELIVER IN PERSON' + ) OR ( + p_partkey = l_partkey + AND p_brand = 'Brand#34' + AND p_container IN ('LG CASE', 'LG BOX', 'LG PACK', 'LG PKG') + AND l_quantity >= 20 AND l_quantity <= 30 + AND p_size BETWEEN 1 AND 15 + AND l_shipmode IN ('AIR', 'AIR REG') + AND l_shipinstruct = 'DELIVER IN PERSON' + ) + desc: TPC-H Q19 + tasks: + - explain:logical_optd,physical_optd diff --git a/optd-sqlplannertest/tests/tpch/tpch.planner.sql b/optd-sqlplannertest/tests/tpch/tpch.planner.sql deleted file mode 100644 index 8bf88051..00000000 --- a/optd-sqlplannertest/tests/tpch/tpch.planner.sql +++ /dev/null @@ -1,2273 +0,0 @@ --- TPC-H schema -CREATE TABLE NATION ( - N_NATIONKEY INT NOT NULL, - N_NAME CHAR(25) NOT NULL, - N_REGIONKEY INT NOT NULL, - N_COMMENT VARCHAR(152) -); - -CREATE TABLE REGION ( - R_REGIONKEY INT NOT NULL, - R_NAME CHAR(25) NOT NULL, - R_COMMENT VARCHAR(152) -); - -CREATE TABLE PART ( - P_PARTKEY INT NOT NULL, - P_NAME VARCHAR(55) NOT NULL, - P_MFGR CHAR(25) NOT NULL, - P_BRAND CHAR(10) NOT NULL, - P_TYPE VARCHAR(25) NOT NULL, - P_SIZE INT NOT NULL, - P_CONTAINER CHAR(10) NOT NULL, - P_RETAILPRICE DECIMAL(15,2) NOT NULL, - P_COMMENT VARCHAR(23) NOT NULL -); - -CREATE TABLE SUPPLIER ( - S_SUPPKEY INT NOT NULL, - S_NAME CHAR(25) NOT NULL, - S_ADDRESS VARCHAR(40) NOT NULL, - S_NATIONKEY INT NOT NULL, - S_PHONE CHAR(15) NOT NULL, - S_ACCTBAL DECIMAL(15,2) NOT NULL, - S_COMMENT VARCHAR(101) NOT NULL -); - -CREATE TABLE PARTSUPP ( - PS_PARTKEY INT NOT NULL, - PS_SUPPKEY INT NOT NULL, - PS_AVAILQTY INT NOT NULL, - PS_SUPPLYCOST DECIMAL(15,2) NOT NULL, - PS_COMMENT VARCHAR(199) NOT NULL -); - -CREATE TABLE CUSTOMER ( - C_CUSTKEY INT NOT NULL, - C_NAME VARCHAR(25) NOT NULL, - C_ADDRESS VARCHAR(40) NOT NULL, - C_NATIONKEY INT NOT NULL, - C_PHONE CHAR(15) NOT NULL, - C_ACCTBAL DECIMAL(15,2) NOT NULL, - C_MKTSEGMENT CHAR(10) NOT NULL, - C_COMMENT VARCHAR(117) NOT NULL -); - -CREATE TABLE ORDERS ( - O_ORDERKEY INT NOT NULL, - O_CUSTKEY INT NOT NULL, - O_ORDERSTATUS CHAR(1) NOT NULL, - O_TOTALPRICE DECIMAL(15,2) NOT NULL, - O_ORDERDATE DATE NOT NULL, - O_ORDERPRIORITY CHAR(15) NOT NULL, - O_CLERK CHAR(15) NOT NULL, - O_SHIPPRIORITY INT NOT NULL, - O_COMMENT VARCHAR(79) NOT NULL -); - -CREATE TABLE LINEITEM ( - L_ORDERKEY INT NOT NULL, - L_PARTKEY INT NOT NULL, - L_SUPPKEY INT NOT NULL, - L_LINENUMBER INT NOT NULL, - L_QUANTITY DECIMAL(15,2) NOT NULL, - L_EXTENDEDPRICE DECIMAL(15,2) NOT NULL, - L_DISCOUNT DECIMAL(15,2) NOT NULL, - L_TAX DECIMAL(15,2) NOT NULL, - L_RETURNFLAG CHAR(1) NOT NULL, - L_LINESTATUS CHAR(1) NOT NULL, - L_SHIPDATE DATE NOT NULL, - L_COMMITDATE DATE NOT NULL, - L_RECEIPTDATE DATE NOT NULL, - L_SHIPINSTRUCT CHAR(25) NOT NULL, - L_SHIPMODE CHAR(10) NOT NULL, - L_COMMENT VARCHAR(44) NOT NULL -); - -/* - -*/ - --- TPC-H Q1 -SELECT - l_returnflag, - l_linestatus, - sum(l_quantity) as sum_qty, - sum(l_extendedprice) as sum_base_price, - sum(l_extendedprice * (1 - l_discount)) as sum_disc_price, - sum(l_extendedprice * (1 - l_discount) * (1 + l_tax)) as sum_charge, - avg(l_quantity) as avg_qty, - avg(l_extendedprice) as avg_price, - avg(l_discount) as avg_disc, - count(*) as count_order -FROM - lineitem -WHERE - l_shipdate <= date '1998-12-01' - interval '90' day -GROUP BY - l_returnflag, l_linestatus -ORDER BY - l_returnflag, l_linestatus; - -/* -LogicalSort -├── exprs: -│ ┌── SortOrder { order: Asc } -│ │ └── #0 -│ └── SortOrder { order: Asc } -│ └── #1 -└── LogicalProjection { exprs: [ #0, #1, #2, #3, #4, #5, #6, #7, #8, #9 ] } - └── LogicalAgg - ├── exprs: - │ ┌── Agg(Sum) - │ │ └── [ #4 ] - │ ├── Agg(Sum) - │ │ └── [ #5 ] - │ ├── Agg(Sum) - │ │ └── Mul - │ │ ├── #5 - │ │ └── Sub - │ │ ├── Cast { cast_to: Decimal128(20, 0), expr: 1(i64) } - │ │ └── #6 - │ ├── Agg(Sum) - │ │ └── Mul - │ │ ├── Mul - │ │ │ ├── #5 - │ │ │ └── Sub - │ │ │ ├── Cast { cast_to: Decimal128(20, 0), expr: 1(i64) } - │ │ │ └── #6 - │ │ └── Add - │ │ ├── Cast { cast_to: Decimal128(20, 0), expr: 1(i64) } - │ │ └── #7 - │ ├── Agg(Avg) - │ │ └── [ #4 ] - │ ├── Agg(Avg) - │ │ └── [ #5 ] - │ ├── Agg(Avg) - │ │ └── [ #6 ] - │ └── Agg(Count) - │ └── [ 1(u8) ] - ├── groups: [ #8, #9 ] - └── LogicalFilter - ├── cond:Leq - │ ├── #10 - │ └── Sub - │ ├── Cast { cast_to: Date32, expr: "1998-12-01" } - │ └── INTERVAL_MONTH_DAY_NANO (0, 90, 0) - └── LogicalScan { table: lineitem } -PhysicalSort -├── exprs: -│ ┌── SortOrder { order: Asc } -│ │ └── #0 -│ └── SortOrder { order: Asc } -│ └── #1 -└── PhysicalProjection { exprs: [ #0, #1, #2, #3, #4, #5, #6, #7, #8, #9 ] } - └── PhysicalAgg - ├── aggrs: - │ ┌── Agg(Sum) - │ │ └── [ #4 ] - │ ├── Agg(Sum) - │ │ └── [ #5 ] - │ ├── Agg(Sum) - │ │ └── Mul - │ │ ├── #5 - │ │ └── Sub - │ │ ├── Cast { cast_to: Decimal128(20, 0), expr: 1(i64) } - │ │ └── #6 - │ ├── Agg(Sum) - │ │ └── Mul - │ │ ├── Mul - │ │ │ ├── #5 - │ │ │ └── Sub - │ │ │ ├── Cast { cast_to: Decimal128(20, 0), expr: 1(i64) } - │ │ │ └── #6 - │ │ └── Add - │ │ ├── Cast { cast_to: Decimal128(20, 0), expr: 1(i64) } - │ │ └── #7 - │ ├── Agg(Avg) - │ │ └── [ #4 ] - │ ├── Agg(Avg) - │ │ └── [ #5 ] - │ ├── Agg(Avg) - │ │ └── [ #6 ] - │ └── Agg(Count) - │ └── [ 1(u8) ] - ├── groups: [ #8, #9 ] - └── PhysicalFilter - ├── cond:Leq - │ ├── #10 - │ └── Sub - │ ├── Cast { cast_to: Date32, expr: "1998-12-01" } - │ └── INTERVAL_MONTH_DAY_NANO (0, 90, 0) - └── PhysicalScan { table: lineitem } -*/ - --- TPC-H Q2 -select - s_acctbal, - s_name, - n_name, - p_partkey, - p_mfgr, - s_address, - s_phone, - s_comment -from - part, - supplier, - partsupp, - nation, - region -where - p_partkey = ps_partkey - and s_suppkey = ps_suppkey -and p_size = 4 -and p_type like '%TIN' - and s_nationkey = n_nationkey - and n_regionkey = r_regionkey - and r_name = 'AFRICA' - and ps_supplycost = ( - select - min(ps_supplycost) - from - partsupp, - supplier, - nation, - region - where - p_partkey = ps_partkey - and s_suppkey = ps_suppkey - and s_nationkey = n_nationkey - and n_regionkey = r_regionkey - and r_name = 'AFRICA' - ) -order by - s_acctbal desc, - n_name, - s_name, - p_partkey -limit 100; - -/* -LogicalLimit { skip: 0(u64), fetch: 100(u64) } -└── LogicalSort - ├── exprs: - │ ┌── SortOrder { order: Desc } - │ │ └── #0 - │ ├── SortOrder { order: Asc } - │ │ └── #2 - │ ├── SortOrder { order: Asc } - │ │ └── #1 - │ └── SortOrder { order: Asc } - │ └── #3 - └── LogicalProjection { exprs: [ #5, #2, #8, #0, #1, #3, #4, #6 ] } - └── LogicalJoin - ├── join_type: Inner - ├── cond:And - │ ├── Eq - │ │ ├── #0 - │ │ └── #10 - │ └── Eq - │ ├── #7 - │ └── #9 - ├── LogicalProjection { exprs: [ #0, #1, #2, #3, #4, #5, #6, #7, #8 ] } - │ └── LogicalJoin - │ ├── join_type: Inner - │ ├── cond:Eq - │ │ ├── #9 - │ │ └── #10 - │ ├── LogicalProjection { exprs: [ #0, #1, #2, #3, #5, #6, #7, #8, #10, #11 ] } - │ │ └── LogicalJoin - │ │ ├── join_type: Inner - │ │ ├── cond:Eq - │ │ │ ├── #4 - │ │ │ └── #9 - │ │ ├── LogicalProjection { exprs: [ #0, #1, #5, #6, #7, #8, #9, #10, #3 ] } - │ │ │ └── LogicalJoin - │ │ │ ├── join_type: Inner - │ │ │ ├── cond:Eq - │ │ │ │ ├── #2 - │ │ │ │ └── #4 - │ │ │ ├── LogicalProjection { exprs: [ #0, #1, #3, #4 ] } - │ │ │ │ └── LogicalJoin - │ │ │ │ ├── join_type: Inner - │ │ │ │ ├── cond:Eq - │ │ │ │ │ ├── #0 - │ │ │ │ │ └── #2 - │ │ │ │ ├── LogicalProjection { exprs: [ #0, #1 ] } - │ │ │ │ │ └── LogicalFilter - │ │ │ │ │ ├── cond:And - │ │ │ │ │ │ ├── Eq - │ │ │ │ │ │ │ ├── #3 - │ │ │ │ │ │ │ └── 4(i32) - │ │ │ │ │ │ └── Like { expr: #2, pattern: "%TIN", negated: false, case_insensitive: false } - │ │ │ │ │ └── LogicalProjection { exprs: [ #0, #2, #4, #5 ] } - │ │ │ │ │ └── LogicalScan { table: part } - │ │ │ │ └── LogicalProjection { exprs: [ #0, #1, #3 ] } - │ │ │ │ └── LogicalScan { table: partsupp } - │ │ │ └── LogicalProjection { exprs: [ #0, #1, #2, #3, #4, #5, #6 ] } - │ │ │ └── LogicalScan { table: supplier } - │ │ └── LogicalProjection { exprs: [ #0, #1, #2 ] } - │ │ └── LogicalScan { table: nation } - │ └── LogicalProjection { exprs: [ #0 ] } - │ └── LogicalFilter - │ ├── cond:Eq - │ │ ├── #1 - │ │ └── "AFRICA" - │ └── LogicalProjection { exprs: [ #0, #1 ] } - │ └── LogicalScan { table: region } - └── LogicalProjection { exprs: [ #1, #0 ] } - └── LogicalAgg - ├── exprs:Agg(Min) - │ └── [ #1 ] - ├── groups: [ #0 ] - └── LogicalProjection { exprs: [ #0, #1 ] } - └── LogicalJoin - ├── join_type: Inner - ├── cond:Eq - │ ├── #2 - │ └── #3 - ├── LogicalProjection { exprs: [ #0, #1, #4 ] } - │ └── LogicalJoin - │ ├── join_type: Inner - │ ├── cond:Eq - │ │ ├── #2 - │ │ └── #3 - │ ├── LogicalProjection { exprs: [ #0, #2, #4 ] } - │ │ └── LogicalJoin - │ │ ├── join_type: Inner - │ │ ├── cond:Eq - │ │ │ ├── #1 - │ │ │ └── #3 - │ │ ├── LogicalProjection { exprs: [ #0, #1, #3 ] } - │ │ │ └── LogicalScan { table: partsupp } - │ │ └── LogicalProjection { exprs: [ #0, #3 ] } - │ │ └── LogicalScan { table: supplier } - │ └── LogicalProjection { exprs: [ #0, #2 ] } - │ └── LogicalScan { table: nation } - └── LogicalProjection { exprs: [ #0 ] } - └── LogicalFilter - ├── cond:Eq - │ ├── #1 - │ └── "AFRICA" - └── LogicalProjection { exprs: [ #0, #1 ] } - └── LogicalScan { table: region } -PhysicalLimit { skip: 0(u64), fetch: 100(u64) } -└── PhysicalSort - ├── exprs: - │ ┌── SortOrder { order: Desc } - │ │ └── #0 - │ ├── SortOrder { order: Asc } - │ │ └── #2 - │ ├── SortOrder { order: Asc } - │ │ └── #1 - │ └── SortOrder { order: Asc } - │ └── #3 - └── PhysicalProjection { exprs: [ #5, #2, #8, #0, #1, #3, #4, #6 ] } - └── PhysicalHashJoin { join_type: Inner, left_keys: [ #0, #7 ], right_keys: [ #1, #0 ] } - ├── PhysicalProjection { exprs: [ #0, #1, #2, #3, #4, #5, #6, #7, #8 ] } - │ └── PhysicalHashJoin { join_type: Inner, left_keys: [ #9 ], right_keys: [ #0 ] } - │ ├── PhysicalProjection { exprs: [ #0, #1, #2, #3, #5, #6, #7, #8, #10, #11 ] } - │ │ └── PhysicalHashJoin { join_type: Inner, left_keys: [ #4 ], right_keys: [ #0 ] } - │ │ ├── PhysicalProjection { exprs: [ #0, #1, #5, #6, #7, #8, #9, #10, #3 ] } - │ │ │ └── PhysicalHashJoin { join_type: Inner, left_keys: [ #2 ], right_keys: [ #0 ] } - │ │ │ ├── PhysicalProjection { exprs: [ #0, #1, #3, #4 ] } - │ │ │ │ └── PhysicalHashJoin { join_type: Inner, left_keys: [ #0 ], right_keys: [ #0 ] } - │ │ │ │ ├── PhysicalProjection { exprs: [ #0, #1 ] } - │ │ │ │ │ └── PhysicalProjection { exprs: [ #0, #2, #4, #5 ] } - │ │ │ │ │ └── PhysicalFilter - │ │ │ │ │ ├── cond:And - │ │ │ │ │ │ ├── Eq - │ │ │ │ │ │ │ ├── #5 - │ │ │ │ │ │ │ └── 4(i32) - │ │ │ │ │ │ └── Like { expr: #4, pattern: "%TIN", negated: false, case_insensitive: false } - │ │ │ │ │ └── PhysicalScan { table: part } - │ │ │ │ └── PhysicalProjection { exprs: [ #0, #1, #3 ] } - │ │ │ │ └── PhysicalScan { table: partsupp } - │ │ │ └── PhysicalProjection { exprs: [ #0, #1, #2, #3, #4, #5, #6 ] } - │ │ │ └── PhysicalScan { table: supplier } - │ │ └── PhysicalProjection { exprs: [ #0, #1, #2 ] } - │ │ └── PhysicalScan { table: nation } - │ └── PhysicalProjection { exprs: [ #0 ] } - │ └── PhysicalProjection { exprs: [ #0, #1 ] } - │ └── PhysicalFilter - │ ├── cond:Eq - │ │ ├── #1 - │ │ └── "AFRICA" - │ └── PhysicalScan { table: region } - └── PhysicalProjection { exprs: [ #1, #0 ] } - └── PhysicalAgg - ├── aggrs:Agg(Min) - │ └── [ #1 ] - ├── groups: [ #0 ] - └── PhysicalProjection { exprs: [ #0, #1 ] } - └── PhysicalHashJoin { join_type: Inner, left_keys: [ #2 ], right_keys: [ #0 ] } - ├── PhysicalProjection { exprs: [ #0, #1, #4 ] } - │ └── PhysicalHashJoin { join_type: Inner, left_keys: [ #2 ], right_keys: [ #0 ] } - │ ├── PhysicalProjection { exprs: [ #0, #2, #4 ] } - │ │ └── PhysicalHashJoin { join_type: Inner, left_keys: [ #1 ], right_keys: [ #0 ] } - │ │ ├── PhysicalProjection { exprs: [ #0, #1, #3 ] } - │ │ │ └── PhysicalScan { table: partsupp } - │ │ └── PhysicalProjection { exprs: [ #0, #3 ] } - │ │ └── PhysicalScan { table: supplier } - │ └── PhysicalProjection { exprs: [ #0, #2 ] } - │ └── PhysicalScan { table: nation } - └── PhysicalProjection { exprs: [ #0 ] } - └── PhysicalProjection { exprs: [ #0, #1 ] } - └── PhysicalFilter - ├── cond:Eq - │ ├── #1 - │ └── "AFRICA" - └── PhysicalScan { table: region } -*/ - --- TPC-H Q3 -SELECT - l_orderkey, - SUM(l_extendedprice * (1 - l_discount)) AS revenue, - o_orderdate, - o_shippriority -FROM - customer, - orders, - lineitem -WHERE - c_mktsegment = 'FURNITURE' - AND c_custkey = o_custkey - AND l_orderkey = o_orderkey - AND o_orderdate < DATE '1995-03-29' - AND l_shipdate > DATE '1995-03-29' -GROUP BY - l_orderkey, - o_orderdate, - o_shippriority -ORDER BY - revenue DESC, - o_orderdate LIMIT 10; - -/* -LogicalLimit { skip: 0(u64), fetch: 10(u64) } -└── LogicalSort - ├── exprs: - │ ┌── SortOrder { order: Desc } - │ │ └── #1 - │ └── SortOrder { order: Asc } - │ └── #2 - └── LogicalProjection { exprs: [ #0, #3, #1, #2 ] } - └── LogicalAgg - ├── exprs:Agg(Sum) - │ └── Mul - │ ├── #3 - │ └── Sub - │ ├── 1(float) - │ └── #4 - ├── groups: [ #2, #0, #1 ] - └── LogicalProjection { exprs: [ #1, #2, #3, #4, #5 ] } - └── LogicalJoin - ├── join_type: Inner - ├── cond:Eq - │ ├── #0 - │ └── #3 - ├── LogicalProjection { exprs: [ #1, #3, #4 ] } - │ └── LogicalJoin - │ ├── join_type: Inner - │ ├── cond:Eq - │ │ ├── #0 - │ │ └── #2 - │ ├── LogicalProjection { exprs: [ #0 ] } - │ │ └── LogicalFilter - │ │ ├── cond:Eq - │ │ │ ├── #1 - │ │ │ └── "FURNITURE" - │ │ └── LogicalProjection { exprs: [ #0, #6 ] } - │ │ └── LogicalScan { table: customer } - │ └── LogicalFilter - │ ├── cond:Lt - │ │ ├── #2 - │ │ └── 9218(i64) - │ └── LogicalProjection { exprs: [ #0, #1, #4, #7 ] } - │ └── LogicalScan { table: orders } - └── LogicalProjection { exprs: [ #0, #1, #2 ] } - └── LogicalFilter - ├── cond:Gt - │ ├── #3 - │ └── 9218(i64) - └── LogicalProjection { exprs: [ #0, #5, #6, #10 ] } - └── LogicalScan { table: lineitem } -PhysicalLimit { skip: 0(u64), fetch: 10(u64) } -└── PhysicalSort - ├── exprs: - │ ┌── SortOrder { order: Desc } - │ │ └── #1 - │ └── SortOrder { order: Asc } - │ └── #2 - └── PhysicalProjection { exprs: [ #0, #3, #1, #2 ] } - └── PhysicalAgg - ├── aggrs:Agg(Sum) - │ └── Mul - │ ├── #3 - │ └── Sub - │ ├── 1(float) - │ └── #4 - ├── groups: [ #2, #0, #1 ] - └── PhysicalProjection { exprs: [ #1, #2, #3, #4, #5 ] } - └── PhysicalHashJoin { join_type: Inner, left_keys: [ #0 ], right_keys: [ #0 ] } - ├── PhysicalProjection { exprs: [ #1, #3, #4 ] } - │ └── PhysicalHashJoin { join_type: Inner, left_keys: [ #0 ], right_keys: [ #1 ] } - │ ├── PhysicalProjection { exprs: [ #0 ] } - │ │ └── PhysicalProjection { exprs: [ #0, #6 ] } - │ │ └── PhysicalFilter - │ │ ├── cond:Eq - │ │ │ ├── #6 - │ │ │ └── "FURNITURE" - │ │ └── PhysicalScan { table: customer } - │ └── PhysicalProjection { exprs: [ #0, #1, #4, #7 ] } - │ └── PhysicalFilter - │ ├── cond:Lt - │ │ ├── #4 - │ │ └── 9218(i64) - │ └── PhysicalScan { table: orders } - └── PhysicalProjection { exprs: [ #0, #1, #2 ] } - └── PhysicalProjection { exprs: [ #0, #5, #6, #10 ] } - └── PhysicalFilter - ├── cond:Gt - │ ├── #10 - │ └── 9218(i64) - └── PhysicalScan { table: lineitem } -*/ - --- TPC-H Q5 -SELECT - n_name AS nation, - SUM(l_extendedprice * (1 - l_discount)) AS revenue -FROM - customer, - orders, - lineitem, - supplier, - nation, - region -WHERE - c_custkey = o_custkey - AND l_orderkey = o_orderkey - AND l_suppkey = s_suppkey - AND c_nationkey = s_nationkey - AND s_nationkey = n_nationkey - AND n_regionkey = r_regionkey - AND r_name = 'Asia' -- Specified region - AND o_orderdate >= DATE '2023-01-01' - AND o_orderdate < DATE '2024-01-01' -GROUP BY - n_name -ORDER BY - revenue DESC; - -/* -LogicalSort -├── exprs:SortOrder { order: Desc } -│ └── #1 -└── LogicalProjection { exprs: [ #0, #1 ] } - └── LogicalAgg - ├── exprs:Agg(Sum) - │ └── Mul - │ ├── #22 - │ └── Sub - │ ├── Cast { cast_to: Decimal128(20, 0), expr: 1(i64) } - │ └── #23 - ├── groups: [ #41 ] - └── LogicalFilter - ├── cond:And - │ ├── Eq - │ │ ├── #0 - │ │ └── #9 - │ ├── Eq - │ │ ├── #17 - │ │ └── #8 - │ ├── Eq - │ │ ├── #19 - │ │ └── #33 - │ ├── Eq - │ │ ├── #3 - │ │ └── #36 - │ ├── Eq - │ │ ├── #36 - │ │ └── #40 - │ ├── Eq - │ │ ├── #42 - │ │ └── #44 - │ ├── Eq - │ │ ├── #45 - │ │ └── "Asia" - │ ├── Geq - │ │ ├── #12 - │ │ └── Cast { cast_to: Date32, expr: "2023-01-01" } - │ └── Lt - │ ├── #12 - │ └── Cast { cast_to: Date32, expr: "2024-01-01" } - └── LogicalJoin { join_type: Cross, cond: true } - ├── LogicalJoin { join_type: Cross, cond: true } - │ ├── LogicalJoin { join_type: Cross, cond: true } - │ │ ├── LogicalJoin { join_type: Cross, cond: true } - │ │ │ ├── LogicalJoin { join_type: Cross, cond: true } - │ │ │ │ ├── LogicalScan { table: customer } - │ │ │ │ └── LogicalScan { table: orders } - │ │ │ └── LogicalScan { table: lineitem } - │ │ └── LogicalScan { table: supplier } - │ └── LogicalScan { table: nation } - └── LogicalScan { table: region } -PhysicalSort -├── exprs:SortOrder { order: Desc } -│ └── #1 -└── PhysicalProjection { exprs: [ #0, #1 ] } - └── PhysicalAgg - ├── aggrs:Agg(Sum) - │ └── Mul - │ ├── #22 - │ └── Sub - │ ├── Cast { cast_to: Decimal128(20, 0), expr: 1(i64) } - │ └── #23 - ├── groups: [ #41 ] - └── PhysicalHashJoin { join_type: Inner, left_keys: [ #19, #3 ], right_keys: [ #0, #3 ] } - ├── PhysicalHashJoin { join_type: Inner, left_keys: [ #0 ], right_keys: [ #1 ] } - │ ├── PhysicalScan { table: customer } - │ └── PhysicalHashJoin { join_type: Inner, left_keys: [ #0 ], right_keys: [ #0 ] } - │ ├── PhysicalFilter - │ │ ├── cond:And - │ │ │ ├── Geq - │ │ │ │ ├── #4 - │ │ │ │ └── Cast { cast_to: Date32, expr: "2023-01-01" } - │ │ │ └── Lt - │ │ │ ├── #4 - │ │ │ └── Cast { cast_to: Date32, expr: "2024-01-01" } - │ │ └── PhysicalScan { table: orders } - │ └── PhysicalScan { table: lineitem } - └── PhysicalHashJoin { join_type: Inner, left_keys: [ #9 ], right_keys: [ #0 ] } - ├── PhysicalHashJoin { join_type: Inner, left_keys: [ #3 ], right_keys: [ #0 ] } - │ ├── PhysicalScan { table: supplier } - │ └── PhysicalScan { table: nation } - └── PhysicalFilter - ├── cond:Eq - │ ├── #1 - │ └── "Asia" - └── PhysicalScan { table: region } -*/ - --- TPC-H Q6 -SELECT - SUM(l_extendedprice * l_discount) AS revenue_loss -FROM - lineitem -WHERE - l_shipdate >= DATE '2023-01-01' - AND l_shipdate < DATE '2024-01-01' - AND l_discount BETWEEN 0.05 AND 0.07 - AND l_quantity < 24; - -/* -LogicalProjection { exprs: [ #0 ] } -└── LogicalAgg - ├── exprs:Agg(Sum) - │ └── Mul - │ ├── #5 - │ └── #6 - ├── groups: [] - └── LogicalFilter - ├── cond:And - │ ├── Geq - │ │ ├── #10 - │ │ └── Cast { cast_to: Date32, expr: "2023-01-01" } - │ ├── Lt - │ │ ├── #10 - │ │ └── Cast { cast_to: Date32, expr: "2024-01-01" } - │ ├── Between { expr: Cast { cast_to: Decimal128(30, 15), expr: #6 }, lower: Cast { cast_to: Decimal128(30, 15), expr: 0.05(float) }, upper: Cast { cast_to: Decimal128(30, 15), expr: 0.07(float) } } - │ └── Lt - │ ├── Cast { cast_to: Decimal128(22, 2), expr: #4 } - │ └── Cast { cast_to: Decimal128(22, 2), expr: 24(i64) } - └── LogicalScan { table: lineitem } -PhysicalProjection { exprs: [ #0 ] } -└── PhysicalAgg - ├── aggrs:Agg(Sum) - │ └── Mul - │ ├── #5 - │ └── #6 - ├── groups: [] - └── PhysicalFilter - ├── cond:And - │ ├── Geq - │ │ ├── #10 - │ │ └── Cast { cast_to: Date32, expr: "2023-01-01" } - │ ├── Lt - │ │ ├── #10 - │ │ └── Cast { cast_to: Date32, expr: "2024-01-01" } - │ ├── Between { expr: Cast { cast_to: Decimal128(30, 15), expr: #6 }, lower: Cast { cast_to: Decimal128(30, 15), expr: 0.05(float) }, upper: Cast { cast_to: Decimal128(30, 15), expr: 0.07(float) } } - │ └── Lt - │ ├── Cast { cast_to: Decimal128(22, 2), expr: #4 } - │ └── Cast { cast_to: Decimal128(22, 2), expr: 24(i64) } - └── PhysicalScan { table: lineitem } -*/ - --- TPC-H Q7 -SELECT - supp_nation, - cust_nation, - l_year, - SUM(volume) AS revenue -FROM - ( - SELECT - n1.n_name AS supp_nation, - n2.n_name AS cust_nation, - EXTRACT(YEAR FROM l_shipdate) AS l_year, - l_extendedprice * (1 - l_discount) AS volume - FROM - supplier, - lineitem, - orders, - customer, - nation n1, - nation n2 - WHERE - s_suppkey = l_suppkey - AND o_orderkey = l_orderkey - AND c_custkey = o_custkey - AND s_nationkey = n1.n_nationkey - AND c_nationkey = n2.n_nationkey - AND ( - (n1.n_name = 'FRANCE' AND n2.n_name = 'GERMANY') - OR (n1.n_name = 'GERMANY' AND n2.n_name = 'FRANCE') - ) - AND l_shipdate BETWEEN DATE '1995-01-01' AND DATE '1996-12-31' - ) AS shipping -GROUP BY - supp_nation, - cust_nation, - l_year -ORDER BY - supp_nation, - cust_nation, - l_year; - -/* -LogicalSort -├── exprs: -│ ┌── SortOrder { order: Asc } -│ │ └── #0 -│ ├── SortOrder { order: Asc } -│ │ └── #1 -│ └── SortOrder { order: Asc } -│ └── #2 -└── LogicalProjection { exprs: [ #0, #1, #2, #3 ] } - └── LogicalAgg - ├── exprs:Agg(Sum) - │ └── [ #3 ] - ├── groups: [ #0, #1, #2 ] - └── LogicalProjection - ├── exprs: - │ ┌── #41 - │ ├── #45 - │ ├── Scalar(DatePart) - │ │ └── [ "YEAR", #17 ] - │ └── Mul - │ ├── #12 - │ └── Sub - │ ├── Cast { cast_to: Decimal128(20, 0), expr: 1(i64) } - │ └── #13 - └── LogicalFilter - ├── cond:And - │ ├── Eq - │ │ ├── #0 - │ │ └── #9 - │ ├── Eq - │ │ ├── #23 - │ │ └── #7 - │ ├── Eq - │ │ ├── #32 - │ │ └── #24 - │ ├── Eq - │ │ ├── #3 - │ │ └── #40 - │ ├── Eq - │ │ ├── #35 - │ │ └── #44 - │ ├── Or - │ │ ├── And - │ │ │ ├── Eq - │ │ │ │ ├── #41 - │ │ │ │ └── "FRANCE" - │ │ │ └── Eq - │ │ │ ├── #45 - │ │ │ └── "GERMANY" - │ │ └── And - │ │ ├── Eq - │ │ │ ├── #41 - │ │ │ └── "GERMANY" - │ │ └── Eq - │ │ ├── #45 - │ │ └── "FRANCE" - │ └── Between { expr: #17, lower: Cast { cast_to: Date32, expr: "1995-01-01" }, upper: Cast { cast_to: Date32, expr: "1996-12-31" } } - └── LogicalJoin { join_type: Cross, cond: true } - ├── LogicalJoin { join_type: Cross, cond: true } - │ ├── LogicalJoin { join_type: Cross, cond: true } - │ │ ├── LogicalJoin { join_type: Cross, cond: true } - │ │ │ ├── LogicalJoin { join_type: Cross, cond: true } - │ │ │ │ ├── LogicalScan { table: supplier } - │ │ │ │ └── LogicalScan { table: lineitem } - │ │ │ └── LogicalScan { table: orders } - │ │ └── LogicalScan { table: customer } - │ └── LogicalScan { table: nation } - └── LogicalScan { table: nation } -PhysicalSort -├── exprs: -│ ┌── SortOrder { order: Asc } -│ │ └── #0 -│ ├── SortOrder { order: Asc } -│ │ └── #1 -│ └── SortOrder { order: Asc } -│ └── #2 -└── PhysicalProjection { exprs: [ #0, #1, #2, #3 ] } - └── PhysicalAgg - ├── aggrs:Agg(Sum) - │ └── [ #3 ] - ├── groups: [ #0, #1, #2 ] - └── PhysicalProjection - ├── exprs: - │ ┌── #41 - │ ├── #45 - │ ├── Scalar(DatePart) - │ │ └── [ "YEAR", #17 ] - │ └── Mul - │ ├── #12 - │ └── Sub - │ ├── Cast { cast_to: Decimal128(20, 0), expr: 1(i64) } - │ └── #13 - └── PhysicalNestedLoopJoin - ├── join_type: Inner - ├── cond:And - │ ├── Eq - │ │ ├── #35 - │ │ └── #44 - │ └── Or - │ ├── And - │ │ ├── Eq - │ │ │ ├── #41 - │ │ │ └── "FRANCE" - │ │ └── Eq - │ │ ├── #45 - │ │ └── "GERMANY" - │ └── And - │ ├── Eq - │ │ ├── #41 - │ │ └── "GERMANY" - │ └── Eq - │ ├── #45 - │ └── "FRANCE" - ├── PhysicalHashJoin { join_type: Inner, left_keys: [ #3 ], right_keys: [ #0 ] } - │ ├── PhysicalHashJoin { join_type: Inner, left_keys: [ #0 ], right_keys: [ #2 ] } - │ │ ├── PhysicalScan { table: supplier } - │ │ └── PhysicalHashJoin { join_type: Inner, left_keys: [ #17 ], right_keys: [ #0 ] } - │ │ ├── PhysicalHashJoin { join_type: Inner, left_keys: [ #0 ], right_keys: [ #0 ] } - │ │ │ ├── PhysicalFilter { cond: Between { expr: #10, lower: Cast { cast_to: Date32, expr: "1995-01-01" }, upper: Cast { cast_to: Date32, expr: "1996-12-31" } } } - │ │ │ │ └── PhysicalScan { table: lineitem } - │ │ │ └── PhysicalScan { table: orders } - │ │ └── PhysicalScan { table: customer } - │ └── PhysicalScan { table: nation } - └── PhysicalScan { table: nation } -*/ - --- TPC-H Q8 without top-most limit node -select - o_year, - sum(case - when nation = 'IRAQ' then volume - else 0 - end) / sum(volume) as mkt_share -from - ( - select - extract(year from o_orderdate) as o_year, - l_extendedprice * (1 - l_discount) as volume, - n2.n_name as nation - from - part, - supplier, - lineitem, - orders, - customer, - nation n1, - nation n2, - region - where - p_partkey = l_partkey - and s_suppkey = l_suppkey - and l_orderkey = o_orderkey - and o_custkey = c_custkey - and c_nationkey = n1.n_nationkey - and n1.n_regionkey = r_regionkey - and r_name = 'AMERICA' - and s_nationkey = n2.n_nationkey - and o_orderdate between date '1995-01-01' and date '1996-12-31' - and p_type = 'ECONOMY ANODIZED STEEL' - ) as all_nations -group by - o_year -order by - o_year; - -/* -LogicalSort -├── exprs:SortOrder { order: Asc } -│ └── #0 -└── LogicalProjection - ├── exprs: - │ ┌── #0 - │ └── Div - │ ├── #1 - │ └── #2 - └── LogicalAgg - ├── exprs: - │ ┌── Agg(Sum) - │ │ └── Case - │ │ └── - │ │ ┌── Eq - │ │ │ ├── #2 - │ │ │ └── "IRAQ" - │ │ ├── #1 - │ │ └── Cast { cast_to: Decimal128(38, 4), expr: 0(i64) } - │ └── Agg(Sum) - │ └── [ #1 ] - ├── groups: [ #0 ] - └── LogicalProjection - ├── exprs: - │ ┌── Scalar(DatePart) - │ │ └── [ "YEAR", #36 ] - │ ├── Mul - │ │ ├── #21 - │ │ └── Sub - │ │ ├── Cast { cast_to: Decimal128(20, 0), expr: 1(i64) } - │ │ └── #22 - │ └── #54 - └── LogicalFilter - ├── cond:And - │ ├── Eq - │ │ ├── #0 - │ │ └── #17 - │ ├── Eq - │ │ ├── #9 - │ │ └── #18 - │ ├── Eq - │ │ ├── #16 - │ │ └── #32 - │ ├── Eq - │ │ ├── #33 - │ │ └── #41 - │ ├── Eq - │ │ ├── #44 - │ │ └── #49 - │ ├── Eq - │ │ ├── #51 - │ │ └── #57 - │ ├── Eq - │ │ ├── #58 - │ │ └── "AMERICA" - │ ├── Eq - │ │ ├── #12 - │ │ └── #53 - │ ├── Between { expr: #36, lower: Cast { cast_to: Date32, expr: "1995-01-01" }, upper: Cast { cast_to: Date32, expr: "1996-12-31" } } - │ └── Eq - │ ├── #4 - │ └── "ECONOMY ANODIZED STEEL" - └── LogicalJoin { join_type: Cross, cond: true } - ├── LogicalJoin { join_type: Cross, cond: true } - │ ├── LogicalJoin { join_type: Cross, cond: true } - │ │ ├── LogicalJoin { join_type: Cross, cond: true } - │ │ │ ├── LogicalJoin { join_type: Cross, cond: true } - │ │ │ │ ├── LogicalJoin { join_type: Cross, cond: true } - │ │ │ │ │ ├── LogicalJoin { join_type: Cross, cond: true } - │ │ │ │ │ │ ├── LogicalScan { table: part } - │ │ │ │ │ │ └── LogicalScan { table: supplier } - │ │ │ │ │ └── LogicalScan { table: lineitem } - │ │ │ │ └── LogicalScan { table: orders } - │ │ │ └── LogicalScan { table: customer } - │ │ └── LogicalScan { table: nation } - │ └── LogicalScan { table: nation } - └── LogicalScan { table: region } -PhysicalSort -├── exprs:SortOrder { order: Asc } -│ └── #0 -└── PhysicalProjection - ├── exprs: - │ ┌── #0 - │ └── Div - │ ├── #1 - │ └── #2 - └── PhysicalAgg - ├── aggrs: - │ ┌── Agg(Sum) - │ │ └── Case - │ │ └── - │ │ ┌── Eq - │ │ │ ├── #2 - │ │ │ └── "IRAQ" - │ │ ├── #1 - │ │ └── Cast { cast_to: Decimal128(38, 4), expr: 0(i64) } - │ └── Agg(Sum) - │ └── [ #1 ] - ├── groups: [ #0 ] - └── PhysicalProjection - ├── exprs: - │ ┌── Scalar(DatePart) - │ │ └── [ "YEAR", #36 ] - │ ├── Mul - │ │ ├── #21 - │ │ └── Sub - │ │ ├── Cast { cast_to: Decimal128(20, 0), expr: 1(i64) } - │ │ └── #22 - │ └── #54 - └── PhysicalHashJoin { join_type: Inner, left_keys: [ #51 ], right_keys: [ #0 ] } - ├── PhysicalHashJoin { join_type: Inner, left_keys: [ #12 ], right_keys: [ #0 ] } - │ ├── PhysicalHashJoin { join_type: Inner, left_keys: [ #0, #9 ], right_keys: [ #1, #2 ] } - │ │ ├── PhysicalNestedLoopJoin { join_type: Cross, cond: true } - │ │ │ ├── PhysicalFilter - │ │ │ │ ├── cond:Eq - │ │ │ │ │ ├── #4 - │ │ │ │ │ └── "ECONOMY ANODIZED STEEL" - │ │ │ │ └── PhysicalScan { table: part } - │ │ │ └── PhysicalScan { table: supplier } - │ │ └── PhysicalHashJoin { join_type: Inner, left_keys: [ #17 ], right_keys: [ #0 ] } - │ │ ├── PhysicalHashJoin { join_type: Inner, left_keys: [ #0 ], right_keys: [ #0 ] } - │ │ │ ├── PhysicalScan { table: lineitem } - │ │ │ └── PhysicalFilter { cond: Between { expr: #4, lower: Cast { cast_to: Date32, expr: "1995-01-01" }, upper: Cast { cast_to: Date32, expr: "1996-12-31" } } } - │ │ │ └── PhysicalScan { table: orders } - │ │ └── PhysicalHashJoin { join_type: Inner, left_keys: [ #3 ], right_keys: [ #0 ] } - │ │ ├── PhysicalScan { table: customer } - │ │ └── PhysicalScan { table: nation } - │ └── PhysicalScan { table: nation } - └── PhysicalFilter - ├── cond:Eq - │ ├── #1 - │ └── "AMERICA" - └── PhysicalScan { table: region } -*/ - --- TPC-H Q9 -SELECT - nation, - o_year, - SUM(amount) AS sum_profit -FROM - ( - SELECT - n_name AS nation, - EXTRACT(YEAR FROM o_orderdate) AS o_year, - l_extendedprice * (1 - l_discount) - ps_supplycost * l_quantity AS amount - FROM - part, - supplier, - lineitem, - partsupp, - orders, - nation - WHERE - s_suppkey = l_suppkey - AND ps_suppkey = l_suppkey - AND ps_partkey = l_partkey - AND p_partkey = l_partkey - AND o_orderkey = l_orderkey - AND s_nationkey = n_nationkey - AND p_name LIKE '%green%' - ) AS profit -GROUP BY - nation, - o_year -ORDER BY - nation, - o_year DESC; - -/* -LogicalSort -├── exprs: -│ ┌── SortOrder { order: Asc } -│ │ └── #0 -│ └── SortOrder { order: Desc } -│ └── #1 -└── LogicalProjection { exprs: [ #0, #1, #2 ] } - └── LogicalAgg - ├── exprs:Agg(Sum) - │ └── [ #2 ] - ├── groups: [ #0, #1 ] - └── LogicalProjection - ├── exprs: - │ ┌── #47 - │ ├── Scalar(DatePart) - │ │ └── [ "YEAR", #41 ] - │ └── Sub - │ ├── Mul - │ │ ├── #21 - │ │ └── Sub - │ │ ├── Cast { cast_to: Decimal128(20, 0), expr: 1(i64) } - │ │ └── #22 - │ └── Mul - │ ├── #35 - │ └── #20 - └── LogicalFilter - ├── cond:And - │ ├── Eq - │ │ ├── #9 - │ │ └── #18 - │ ├── Eq - │ │ ├── #33 - │ │ └── #18 - │ ├── Eq - │ │ ├── #32 - │ │ └── #17 - │ ├── Eq - │ │ ├── #0 - │ │ └── #17 - │ ├── Eq - │ │ ├── #37 - │ │ └── #16 - │ ├── Eq - │ │ ├── #12 - │ │ └── #46 - │ └── Like { expr: #1, pattern: "%green%", negated: false, case_insensitive: false } - └── LogicalJoin { join_type: Cross, cond: true } - ├── LogicalJoin { join_type: Cross, cond: true } - │ ├── LogicalJoin { join_type: Cross, cond: true } - │ │ ├── LogicalJoin { join_type: Cross, cond: true } - │ │ │ ├── LogicalJoin { join_type: Cross, cond: true } - │ │ │ │ ├── LogicalScan { table: part } - │ │ │ │ └── LogicalScan { table: supplier } - │ │ │ └── LogicalScan { table: lineitem } - │ │ └── LogicalScan { table: partsupp } - │ └── LogicalScan { table: orders } - └── LogicalScan { table: nation } -PhysicalSort -├── exprs: -│ ┌── SortOrder { order: Asc } -│ │ └── #0 -│ └── SortOrder { order: Desc } -│ └── #1 -└── PhysicalProjection { exprs: [ #0, #1, #2 ] } - └── PhysicalAgg - ├── aggrs:Agg(Sum) - │ └── [ #2 ] - ├── groups: [ #0, #1 ] - └── PhysicalProjection - ├── exprs: - │ ┌── #47 - │ ├── Scalar(DatePart) - │ │ └── [ "YEAR", #41 ] - │ └── Sub - │ ├── Mul - │ │ ├── #21 - │ │ └── Sub - │ │ ├── Cast { cast_to: Decimal128(20, 0), expr: 1(i64) } - │ │ └── #22 - │ └── Mul - │ ├── #35 - │ └── #20 - └── PhysicalHashJoin { join_type: Inner, left_keys: [ #12 ], right_keys: [ #0 ] } - ├── PhysicalHashJoin { join_type: Inner, left_keys: [ #9, #0 ], right_keys: [ #2, #1 ] } - │ ├── PhysicalNestedLoopJoin { join_type: Cross, cond: true } - │ │ ├── PhysicalFilter { cond: Like { expr: #1, pattern: "%green%", negated: false, case_insensitive: false } } - │ │ │ └── PhysicalScan { table: part } - │ │ └── PhysicalScan { table: supplier } - │ └── PhysicalHashJoin { join_type: Inner, left_keys: [ #0 ], right_keys: [ #0 ] } - │ ├── PhysicalHashJoin { join_type: Inner, left_keys: [ #2, #1 ], right_keys: [ #1, #0 ] } - │ │ ├── PhysicalScan { table: lineitem } - │ │ └── PhysicalScan { table: partsupp } - │ └── PhysicalScan { table: orders } - └── PhysicalScan { table: nation } -*/ - --- TPC-H Q9 -SELECT - nation, - o_year, - SUM(amount) AS sum_profit -FROM - ( - SELECT - n_name AS nation, - EXTRACT(YEAR FROM o_orderdate) AS o_year, - l_extendedprice * (1 - l_discount) - ps_supplycost * l_quantity AS amount - FROM - part, - supplier, - lineitem, - partsupp, - orders, - nation - WHERE - s_suppkey = l_suppkey - AND ps_suppkey = l_suppkey - AND ps_partkey = l_partkey - AND p_partkey = l_partkey - AND o_orderkey = l_orderkey - AND s_nationkey = n_nationkey - AND p_name LIKE '%green%' - ) AS profit -GROUP BY - nation, - o_year -ORDER BY - nation, - o_year DESC; - -/* -LogicalSort -├── exprs: -│ ┌── SortOrder { order: Asc } -│ │ └── #0 -│ └── SortOrder { order: Desc } -│ └── #1 -└── LogicalProjection { exprs: [ #0, #1, #2 ] } - └── LogicalAgg - ├── exprs:Agg(Sum) - │ └── [ #2 ] - ├── groups: [ #0, #1 ] - └── LogicalProjection - ├── exprs: - │ ┌── #47 - │ ├── Scalar(DatePart) - │ │ └── [ "YEAR", #41 ] - │ └── Sub - │ ├── Mul - │ │ ├── #21 - │ │ └── Sub - │ │ ├── Cast { cast_to: Decimal128(20, 0), expr: 1(i64) } - │ │ └── #22 - │ └── Mul - │ ├── #35 - │ └── #20 - └── LogicalFilter - ├── cond:And - │ ├── Eq - │ │ ├── #9 - │ │ └── #18 - │ ├── Eq - │ │ ├── #33 - │ │ └── #18 - │ ├── Eq - │ │ ├── #32 - │ │ └── #17 - │ ├── Eq - │ │ ├── #0 - │ │ └── #17 - │ ├── Eq - │ │ ├── #37 - │ │ └── #16 - │ ├── Eq - │ │ ├── #12 - │ │ └── #46 - │ └── Like { expr: #1, pattern: "%green%", negated: false, case_insensitive: false } - └── LogicalJoin { join_type: Cross, cond: true } - ├── LogicalJoin { join_type: Cross, cond: true } - │ ├── LogicalJoin { join_type: Cross, cond: true } - │ │ ├── LogicalJoin { join_type: Cross, cond: true } - │ │ │ ├── LogicalJoin { join_type: Cross, cond: true } - │ │ │ │ ├── LogicalScan { table: part } - │ │ │ │ └── LogicalScan { table: supplier } - │ │ │ └── LogicalScan { table: lineitem } - │ │ └── LogicalScan { table: partsupp } - │ └── LogicalScan { table: orders } - └── LogicalScan { table: nation } -PhysicalSort -├── exprs: -│ ┌── SortOrder { order: Asc } -│ │ └── #0 -│ └── SortOrder { order: Desc } -│ └── #1 -└── PhysicalProjection { exprs: [ #0, #1, #2 ] } - └── PhysicalAgg - ├── aggrs:Agg(Sum) - │ └── [ #2 ] - ├── groups: [ #0, #1 ] - └── PhysicalProjection - ├── exprs: - │ ┌── #47 - │ ├── Scalar(DatePart) - │ │ └── [ "YEAR", #41 ] - │ └── Sub - │ ├── Mul - │ │ ├── #21 - │ │ └── Sub - │ │ ├── Cast { cast_to: Decimal128(20, 0), expr: 1(i64) } - │ │ └── #22 - │ └── Mul - │ ├── #35 - │ └── #20 - └── PhysicalHashJoin { join_type: Inner, left_keys: [ #12 ], right_keys: [ #0 ] } - ├── PhysicalHashJoin { join_type: Inner, left_keys: [ #9, #0 ], right_keys: [ #2, #1 ] } - │ ├── PhysicalNestedLoopJoin { join_type: Cross, cond: true } - │ │ ├── PhysicalFilter { cond: Like { expr: #1, pattern: "%green%", negated: false, case_insensitive: false } } - │ │ │ └── PhysicalScan { table: part } - │ │ └── PhysicalScan { table: supplier } - │ └── PhysicalHashJoin { join_type: Inner, left_keys: [ #0 ], right_keys: [ #0 ] } - │ ├── PhysicalHashJoin { join_type: Inner, left_keys: [ #2, #1 ], right_keys: [ #1, #0 ] } - │ │ ├── PhysicalScan { table: lineitem } - │ │ └── PhysicalScan { table: partsupp } - │ └── PhysicalScan { table: orders } - └── PhysicalScan { table: nation } -*/ - --- TPC-H Q10 -SELECT - c_custkey, - c_name, - sum(l_extendedprice * (1 - l_discount)) as revenue, - c_acctbal, - n_name, - c_address, - c_phone, - c_comment -FROM - customer, - orders, - lineitem, - nation -WHERE - c_custkey = o_custkey - AND l_orderkey = o_orderkey - AND o_orderdate >= DATE '1993-07-01' - AND o_orderdate < DATE '1993-07-01' + INTERVAL '3' MONTH - AND l_returnflag = 'R' - AND c_nationkey = n_nationkey -GROUP BY - c_custkey, - c_name, - c_acctbal, - c_phone, - n_name, - c_address, - c_comment -ORDER BY - revenue DESC -LIMIT 20; - -/* -LogicalLimit { skip: 0(u64), fetch: 20(u64) } -└── LogicalSort - ├── exprs:SortOrder { order: Desc } - │ └── #2 - └── LogicalProjection { exprs: [ #0, #1, #7, #2, #4, #5, #3, #6 ] } - └── LogicalAgg - ├── exprs:Agg(Sum) - │ └── Mul - │ ├── #22 - │ └── Sub - │ ├── Cast { cast_to: Decimal128(20, 0), expr: 1(i64) } - │ └── #23 - ├── groups: [ #0, #1, #5, #4, #34, #2, #7 ] - └── LogicalFilter - ├── cond:And - │ ├── Eq - │ │ ├── #0 - │ │ └── #9 - │ ├── Eq - │ │ ├── #17 - │ │ └── #8 - │ ├── Geq - │ │ ├── #12 - │ │ └── Cast { cast_to: Date32, expr: "1993-07-01" } - │ ├── Lt - │ │ ├── #12 - │ │ └── Add - │ │ ├── Cast { cast_to: Date32, expr: "1993-07-01" } - │ │ └── INTERVAL_MONTH_DAY_NANO (3, 0, 0) - │ ├── Eq - │ │ ├── #25 - │ │ └── "R" - │ └── Eq - │ ├── #3 - │ └── #33 - └── LogicalJoin { join_type: Cross, cond: true } - ├── LogicalJoin { join_type: Cross, cond: true } - │ ├── LogicalJoin { join_type: Cross, cond: true } - │ │ ├── LogicalScan { table: customer } - │ │ └── LogicalScan { table: orders } - │ └── LogicalScan { table: lineitem } - └── LogicalScan { table: nation } -PhysicalLimit { skip: 0(u64), fetch: 20(u64) } -└── PhysicalSort - ├── exprs:SortOrder { order: Desc } - │ └── #2 - └── PhysicalProjection { exprs: [ #0, #1, #7, #2, #4, #5, #3, #6 ] } - └── PhysicalAgg - ├── aggrs:Agg(Sum) - │ └── Mul - │ ├── #22 - │ └── Sub - │ ├── Cast { cast_to: Decimal128(20, 0), expr: 1(i64) } - │ └── #23 - ├── groups: [ #0, #1, #5, #4, #34, #2, #7 ] - └── PhysicalHashJoin { join_type: Inner, left_keys: [ #3 ], right_keys: [ #0 ] } - ├── PhysicalHashJoin { join_type: Inner, left_keys: [ #0 ], right_keys: [ #1 ] } - │ ├── PhysicalScan { table: customer } - │ └── PhysicalHashJoin { join_type: Inner, left_keys: [ #0 ], right_keys: [ #0 ] } - │ ├── PhysicalFilter - │ │ ├── cond:And - │ │ │ ├── Geq - │ │ │ │ ├── #4 - │ │ │ │ └── Cast { cast_to: Date32, expr: "1993-07-01" } - │ │ │ └── Lt - │ │ │ ├── #4 - │ │ │ └── Add - │ │ │ ├── Cast { cast_to: Date32, expr: "1993-07-01" } - │ │ │ └── INTERVAL_MONTH_DAY_NANO (3, 0, 0) - │ │ └── PhysicalScan { table: orders } - │ └── PhysicalFilter - │ ├── cond:Eq - │ │ ├── #8 - │ │ └── "R" - │ └── PhysicalScan { table: lineitem } - └── PhysicalScan { table: nation } -*/ - --- TPC-H Q11 -select - ps_partkey, - sum(ps_supplycost * ps_availqty) as value -from - partsupp, - supplier, - nation -where - ps_suppkey = s_suppkey - and s_nationkey = n_nationkey - and n_name = 'CHINA' -group by - ps_partkey having - sum(ps_supplycost * ps_availqty) > ( - select - sum(ps_supplycost * ps_availqty) * 0.0001000000 - from - partsupp, - supplier, - nation - where - ps_suppkey = s_suppkey - and s_nationkey = n_nationkey - and n_name = 'CHINA' - ) -order by - value desc; - -/* -LogicalSort -├── exprs:SortOrder { order: Desc } -│ └── #1 -└── LogicalProjection { exprs: [ #0, #1 ] } - └── LogicalJoin - ├── join_type: Inner - ├── cond:Gt - │ ├── Cast { cast_to: Decimal128(38, 15), expr: #1 } - │ └── #2 - ├── LogicalAgg - │ ├── exprs:Agg(Sum) - │ │ └── Mul - │ │ ├── #2 - │ │ └── Cast { cast_to: Decimal128(10, 0), expr: #1 } - │ ├── groups: [ #0 ] - │ └── LogicalProjection { exprs: [ #0, #1, #2 ] } - │ └── LogicalJoin - │ ├── join_type: Inner - │ ├── cond:Eq - │ │ ├── #3 - │ │ └── #4 - │ ├── LogicalProjection { exprs: [ #0, #2, #3, #5 ] } - │ │ └── LogicalJoin - │ │ ├── join_type: Inner - │ │ ├── cond:Eq - │ │ │ ├── #1 - │ │ │ └── #4 - │ │ ├── LogicalProjection { exprs: [ #0, #1, #2, #3 ] } - │ │ │ └── LogicalScan { table: partsupp } - │ │ └── LogicalProjection { exprs: [ #0, #3 ] } - │ │ └── LogicalScan { table: supplier } - │ └── LogicalProjection { exprs: [ #0 ] } - │ └── LogicalFilter - │ ├── cond:Eq - │ │ ├── #1 - │ │ └── "CHINA" - │ └── LogicalProjection { exprs: [ #0, #1 ] } - │ └── LogicalScan { table: nation } - └── LogicalProjection - ├── exprs:Cast - │ ├── cast_to: Decimal128(38, 15) - │ ├── expr:Mul - │ │ ├── Cast { cast_to: Float64, expr: #0 } - │ │ └── 0.0001(float) - - └── LogicalAgg - ├── exprs:Agg(Sum) - │ └── Mul - │ ├── #1 - │ └── Cast { cast_to: Decimal128(10, 0), expr: #0 } - ├── groups: [] - └── LogicalProjection { exprs: [ #0, #1 ] } - └── LogicalJoin - ├── join_type: Inner - ├── cond:Eq - │ ├── #2 - │ └── #3 - ├── LogicalProjection { exprs: [ #1, #2, #4 ] } - │ └── LogicalJoin - │ ├── join_type: Inner - │ ├── cond:Eq - │ │ ├── #0 - │ │ └── #3 - │ ├── LogicalProjection { exprs: [ #1, #2, #3 ] } - │ │ └── LogicalScan { table: partsupp } - │ └── LogicalProjection { exprs: [ #0, #3 ] } - │ └── LogicalScan { table: supplier } - └── LogicalProjection { exprs: [ #0 ] } - └── LogicalFilter - ├── cond:Eq - │ ├── #1 - │ └── "CHINA" - └── LogicalProjection { exprs: [ #0, #1 ] } - └── LogicalScan { table: nation } -PhysicalSort -├── exprs:SortOrder { order: Desc } -│ └── #1 -└── PhysicalProjection { exprs: [ #0, #1 ] } - └── PhysicalProjection { exprs: [ #0, #1 ] } - └── PhysicalNestedLoopJoin - ├── join_type: Inner - ├── cond:Gt - │ ├── Cast { cast_to: Decimal128(38, 15), expr: #1 } - │ └── #0 - ├── PhysicalProjection - │ ├── exprs:Cast - │ │ ├── cast_to: Decimal128(38, 15) - │ │ ├── expr:Mul - │ │ │ ├── Cast { cast_to: Float64, expr: #0 } - │ │ │ └── 0.0001(float) - - │ └── PhysicalAgg - │ ├── aggrs:Agg(Sum) - │ │ └── Mul - │ │ ├── #1 - │ │ └── Cast { cast_to: Decimal128(10, 0), expr: #0 } - │ ├── groups: [] - │ └── PhysicalProjection { exprs: [ #0, #1 ] } - │ └── PhysicalHashJoin { join_type: Inner, left_keys: [ #2 ], right_keys: [ #0 ] } - │ ├── PhysicalProjection { exprs: [ #1, #2, #4 ] } - │ │ └── PhysicalHashJoin { join_type: Inner, left_keys: [ #0 ], right_keys: [ #0 ] } - │ │ ├── PhysicalProjection { exprs: [ #1, #2, #3 ] } - │ │ │ └── PhysicalScan { table: partsupp } - │ │ └── PhysicalProjection { exprs: [ #0, #3 ] } - │ │ └── PhysicalScan { table: supplier } - │ └── PhysicalProjection { exprs: [ #0 ] } - │ └── PhysicalProjection { exprs: [ #0, #1 ] } - │ └── PhysicalFilter - │ ├── cond:Eq - │ │ ├── #1 - │ │ └── "CHINA" - │ └── PhysicalScan { table: nation } - └── PhysicalAgg - ├── aggrs:Agg(Sum) - │ └── Mul - │ ├── #2 - │ └── Cast { cast_to: Decimal128(10, 0), expr: #1 } - ├── groups: [ #0 ] - └── PhysicalProjection { exprs: [ #0, #1, #2 ] } - └── PhysicalHashJoin { join_type: Inner, left_keys: [ #3 ], right_keys: [ #0 ] } - ├── PhysicalProjection { exprs: [ #0, #2, #3, #5 ] } - │ └── PhysicalHashJoin { join_type: Inner, left_keys: [ #1 ], right_keys: [ #0 ] } - │ ├── PhysicalProjection { exprs: [ #0, #1, #2, #3 ] } - │ │ └── PhysicalScan { table: partsupp } - │ └── PhysicalProjection { exprs: [ #0, #3 ] } - │ └── PhysicalScan { table: supplier } - └── PhysicalProjection { exprs: [ #0 ] } - └── PhysicalProjection { exprs: [ #0, #1 ] } - └── PhysicalFilter - ├── cond:Eq - │ ├── #1 - │ └── "CHINA" - └── PhysicalScan { table: nation } -*/ - --- TPC-H Q12 -SELECT - l_shipmode, - sum(case when o_orderpriority = '1-URGENT' - or o_orderpriority = '2-HIGH' - then 1 else 0 end) as high_priority_orders, - sum(case when o_orderpriority <> '1-URGENT' - and o_orderpriority <> '2-HIGH' - then 1 else 0 end) as low_priority_orders -FROM - orders, - lineitem -WHERE - o_orderkey = l_orderkey - AND l_shipmode in ('MAIL', 'SHIP') - AND l_commitdate < l_receiptdate - AND l_shipdate < l_commitdate - AND l_receiptdate >= DATE '1994-01-01' - AND l_receiptdate < DATE '1995-01-01' -GROUP BY - l_shipmode -ORDER BY - l_shipmode; - -/* -LogicalSort -├── exprs:SortOrder { order: Asc } -│ └── #0 -└── LogicalProjection { exprs: [ #0, #1, #2 ] } - └── LogicalAgg - ├── exprs: - │ ┌── Agg(Sum) - │ │ └── Case - │ │ └── - │ │ ┌── Or - │ │ │ ├── Eq - │ │ │ │ ├── #5 - │ │ │ │ └── "1-URGENT" - │ │ │ └── Eq - │ │ │ ├── #5 - │ │ │ └── "2-HIGH" - │ │ ├── 1(i64) - │ │ └── 0(i64) - │ └── Agg(Sum) - │ └── Case - │ └── - │ ┌── And - │ │ ├── Neq - │ │ │ ├── #5 - │ │ │ └── "1-URGENT" - │ │ └── Neq - │ │ ├── #5 - │ │ └── "2-HIGH" - │ ├── 1(i64) - │ └── 0(i64) - ├── groups: [ #23 ] - └── LogicalFilter - ├── cond:And - │ ├── Eq - │ │ ├── #0 - │ │ └── #9 - │ ├── InList { expr: #23, list: [ "MAIL", "SHIP" ], negated: false } - │ ├── Lt - │ │ ├── #20 - │ │ └── #21 - │ ├── Lt - │ │ ├── #19 - │ │ └── #20 - │ ├── Geq - │ │ ├── #21 - │ │ └── Cast { cast_to: Date32, expr: "1994-01-01" } - │ └── Lt - │ ├── #21 - │ └── Cast { cast_to: Date32, expr: "1995-01-01" } - └── LogicalJoin { join_type: Cross, cond: true } - ├── LogicalScan { table: orders } - └── LogicalScan { table: lineitem } -PhysicalSort -├── exprs:SortOrder { order: Asc } -│ └── #0 -└── PhysicalProjection { exprs: [ #0, #1, #2 ] } - └── PhysicalAgg - ├── aggrs: - │ ┌── Agg(Sum) - │ │ └── Case - │ │ └── - │ │ ┌── Or - │ │ │ ├── Eq - │ │ │ │ ├── #5 - │ │ │ │ └── "1-URGENT" - │ │ │ └── Eq - │ │ │ ├── #5 - │ │ │ └── "2-HIGH" - │ │ ├── 1(i64) - │ │ └── 0(i64) - │ └── Agg(Sum) - │ └── Case - │ └── - │ ┌── And - │ │ ├── Neq - │ │ │ ├── #5 - │ │ │ └── "1-URGENT" - │ │ └── Neq - │ │ ├── #5 - │ │ └── "2-HIGH" - │ ├── 1(i64) - │ └── 0(i64) - ├── groups: [ #23 ] - └── PhysicalHashJoin { join_type: Inner, left_keys: [ #0 ], right_keys: [ #0 ] } - ├── PhysicalScan { table: orders } - └── PhysicalFilter - ├── cond:And - │ ├── InList { expr: #14, list: [ "MAIL", "SHIP" ], negated: false } - │ ├── Lt - │ │ ├── #11 - │ │ └── #12 - │ ├── Lt - │ │ ├── #10 - │ │ └── #11 - │ ├── Geq - │ │ ├── #12 - │ │ └── Cast { cast_to: Date32, expr: "1994-01-01" } - │ └── Lt - │ ├── #12 - │ └── Cast { cast_to: Date32, expr: "1995-01-01" } - └── PhysicalScan { table: lineitem } -*/ - --- TPC-H Q14 -SELECT - 100.00 * sum(case when p_type like 'PROMO%' - then l_extendedprice * (1 - l_discount) - else 0 end) / sum(l_extendedprice * (1 - l_discount)) as promo_revenue -FROM - lineitem, - part -WHERE - l_partkey = p_partkey - AND l_shipdate >= DATE '1995-09-01' - AND l_shipdate < DATE '1995-09-01' + INTERVAL '1' MONTH; - -/* -LogicalProjection -├── exprs:Div -│ ├── Mul -│ │ ├── 100(float) -│ │ └── Cast { cast_to: Float64, expr: #0 } -│ └── Cast { cast_to: Float64, expr: #1 } -└── LogicalAgg - ├── exprs: - │ ┌── Agg(Sum) - │ │ └── Case - │ │ └── - │ │ ┌── Like { expr: #20, pattern: "PROMO%", negated: false, case_insensitive: false } - │ │ ├── Mul - │ │ │ ├── #5 - │ │ │ └── Sub - │ │ │ ├── Cast { cast_to: Decimal128(20, 0), expr: 1(i64) } - │ │ │ └── #6 - │ │ └── Cast { cast_to: Decimal128(38, 4), expr: 0(i64) } - │ └── Agg(Sum) - │ └── Mul - │ ├── #5 - │ └── Sub - │ ├── Cast { cast_to: Decimal128(20, 0), expr: 1(i64) } - │ └── #6 - ├── groups: [] - └── LogicalFilter - ├── cond:And - │ ├── Eq - │ │ ├── #1 - │ │ └── #16 - │ ├── Geq - │ │ ├── #10 - │ │ └── Cast { cast_to: Date32, expr: "1995-09-01" } - │ └── Lt - │ ├── #10 - │ └── Add - │ ├── Cast { cast_to: Date32, expr: "1995-09-01" } - │ └── INTERVAL_MONTH_DAY_NANO (1, 0, 0) - └── LogicalJoin { join_type: Cross, cond: true } - ├── LogicalScan { table: lineitem } - └── LogicalScan { table: part } -PhysicalProjection -├── exprs:Div -│ ├── Mul -│ │ ├── 100(float) -│ │ └── Cast { cast_to: Float64, expr: #0 } -│ └── Cast { cast_to: Float64, expr: #1 } -└── PhysicalAgg - ├── aggrs: - │ ┌── Agg(Sum) - │ │ └── Case - │ │ └── - │ │ ┌── Like { expr: #20, pattern: "PROMO%", negated: false, case_insensitive: false } - │ │ ├── Mul - │ │ │ ├── #5 - │ │ │ └── Sub - │ │ │ ├── Cast { cast_to: Decimal128(20, 0), expr: 1(i64) } - │ │ │ └── #6 - │ │ └── Cast { cast_to: Decimal128(38, 4), expr: 0(i64) } - │ └── Agg(Sum) - │ └── Mul - │ ├── #5 - │ └── Sub - │ ├── Cast { cast_to: Decimal128(20, 0), expr: 1(i64) } - │ └── #6 - ├── groups: [] - └── PhysicalHashJoin { join_type: Inner, left_keys: [ #1 ], right_keys: [ #0 ] } - ├── PhysicalFilter - │ ├── cond:And - │ │ ├── Geq - │ │ │ ├── #10 - │ │ │ └── Cast { cast_to: Date32, expr: "1995-09-01" } - │ │ └── Lt - │ │ ├── #10 - │ │ └── Add - │ │ ├── Cast { cast_to: Date32, expr: "1995-09-01" } - │ │ └── INTERVAL_MONTH_DAY_NANO (1, 0, 0) - │ └── PhysicalScan { table: lineitem } - └── PhysicalScan { table: part } -*/ - --- TPC-H Q15 -WITH revenue0 (supplier_no, total_revenue) AS -( - SELECT - l_suppkey, - SUM(l_extendedprice * (1 - l_discount)) - FROM - lineitem - WHERE - l_shipdate >= DATE '1993-01-01' - AND l_shipdate < DATE '1993-01-01' + INTERVAL '3' MONTH - GROUP BY - l_suppkey -) -SELECT - s_suppkey, - s_name, - s_address, - s_phone, - total_revenue -FROM - supplier, - revenue0 -WHERE - s_suppkey = supplier_no - AND total_revenue = - ( - SELECT - MAX(total_revenue) - FROM - revenue0 - ) -ORDER BY - s_suppkey; - -/* -LogicalSort -├── exprs:SortOrder { order: Asc } -│ └── #0 -└── LogicalProjection { exprs: [ #0, #1, #2, #3, #4 ] } - └── LogicalJoin - ├── join_type: Inner - ├── cond:Eq - │ ├── #4 - │ └── #5 - ├── LogicalProjection { exprs: [ #0, #1, #2, #3, #5 ] } - │ └── LogicalJoin - │ ├── join_type: Inner - │ ├── cond:Eq - │ │ ├── #0 - │ │ └── #4 - │ ├── LogicalProjection { exprs: [ #0, #1, #2, #4 ] } - │ │ └── LogicalScan { table: supplier } - │ └── LogicalProjection { exprs: [ #0, #1 ] } - │ └── LogicalAgg - │ ├── exprs:Agg(Sum) - │ │ └── Mul - │ │ ├── #1 - │ │ └── Sub - │ │ ├── 1(float) - │ │ └── #2 - │ ├── groups: [ #0 ] - │ └── LogicalProjection { exprs: [ #0, #1, #2 ] } - │ └── LogicalFilter - │ ├── cond:And - │ │ ├── Geq - │ │ │ ├── #3 - │ │ │ └── 8401(i64) - │ │ └── Lt - │ │ ├── #3 - │ │ └── 8491(i64) - │ └── LogicalProjection { exprs: [ #2, #5, #6, #10 ] } - │ └── LogicalScan { table: lineitem } - └── LogicalAgg - ├── exprs:Agg(Max) - │ └── [ #0 ] - ├── groups: [] - └── LogicalProjection { exprs: [ #1 ] } - └── LogicalAgg - ├── exprs:Agg(Sum) - │ └── Mul - │ ├── #1 - │ └── Sub - │ ├── 1(float) - │ └── #2 - ├── groups: [ #0 ] - └── LogicalProjection { exprs: [ #0, #1, #2 ] } - └── LogicalFilter - ├── cond:And - │ ├── Geq - │ │ ├── #3 - │ │ └── 8401(i64) - │ └── Lt - │ ├── #3 - │ └── 8491(i64) - └── LogicalProjection { exprs: [ #2, #5, #6, #10 ] } - └── LogicalScan { table: lineitem } -PhysicalSort -├── exprs:SortOrder { order: Asc } -│ └── #0 -└── PhysicalProjection { exprs: [ #0, #1, #2, #3, #4 ] } - └── PhysicalProjection { exprs: [ #0, #1, #2, #3, #5, #6 ] } - └── PhysicalHashJoin { join_type: Inner, left_keys: [ #0 ], right_keys: [ #0 ] } - ├── PhysicalProjection { exprs: [ #0, #1, #2, #4 ] } - │ └── PhysicalScan { table: supplier } - └── PhysicalProjection { exprs: [ #0, #1, #2 ] } - └── PhysicalProjection { exprs: [ #1, #2, #0 ] } - └── PhysicalHashJoin { join_type: Inner, left_keys: [ #0 ], right_keys: [ #1 ] } - ├── PhysicalAgg - │ ├── aggrs:Agg(Max) - │ │ └── [ #0 ] - │ ├── groups: [] - │ └── PhysicalProjection { exprs: [ #1 ] } - │ └── PhysicalAgg - │ ├── aggrs:Agg(Sum) - │ │ └── Mul - │ │ ├── #1 - │ │ └── Sub - │ │ ├── 1(float) - │ │ └── #2 - │ ├── groups: [ #0 ] - │ └── PhysicalProjection { exprs: [ #0, #1, #2 ] } - │ └── PhysicalProjection { exprs: [ #2, #5, #6, #10 ] } - │ └── PhysicalFilter - │ ├── cond:And - │ │ ├── Geq - │ │ │ ├── #10 - │ │ │ └── 8401(i64) - │ │ └── Lt - │ │ ├── #10 - │ │ └── 8491(i64) - │ └── PhysicalScan { table: lineitem } - └── PhysicalAgg - ├── aggrs:Agg(Sum) - │ └── Mul - │ ├── #1 - │ └── Sub - │ ├── 1(float) - │ └── #2 - ├── groups: [ #0 ] - └── PhysicalProjection { exprs: [ #0, #1, #2 ] } - └── PhysicalProjection { exprs: [ #2, #5, #6, #10 ] } - └── PhysicalFilter - ├── cond:And - │ ├── Geq - │ │ ├── #10 - │ │ └── 8401(i64) - │ └── Lt - │ ├── #10 - │ └── 8491(i64) - └── PhysicalScan { table: lineitem } -*/ - --- TPC-H Q17 -SELECT - ROUND(SUM(l_extendedprice) / 7.0, 16) AS avg_yearly -FROM - lineitem, - part -WHERE - p_partkey = l_partkey - AND p_brand = 'Brand#13' - AND p_container = 'JUMBO PKG' - AND l_quantity < ( - SELECT - 0.2 * AVG(l_quantity) - FROM - lineitem - WHERE - l_partkey = p_partkey - ); - -/* -LogicalProjection -├── exprs:Scalar(Round) -│ └── -│ ┌── Div -│ │ ├── Cast { cast_to: Float64, expr: #0 } -│ │ └── 7(float) -│ └── 16(i64) -└── LogicalAgg - ├── exprs:Agg(Sum) - │ └── [ #0 ] - ├── groups: [] - └── LogicalProjection { exprs: [ #1 ] } - └── LogicalJoin - ├── join_type: Inner - ├── cond:And - │ ├── Eq - │ │ ├── #2 - │ │ └── #4 - │ └── Lt - │ ├── Cast { cast_to: Decimal128(30, 15), expr: #0 } - │ └── #3 - ├── LogicalProjection { exprs: [ #1, #2, #3 ] } - │ └── LogicalJoin - │ ├── join_type: Inner - │ ├── cond:Eq - │ │ ├── #0 - │ │ └── #3 - │ ├── LogicalProjection { exprs: [ #1, #4, #5 ] } - │ │ └── LogicalScan { table: lineitem } - │ └── LogicalProjection { exprs: [ #0 ] } - │ └── LogicalFilter - │ ├── cond:And - │ │ ├── Eq - │ │ │ ├── #1 - │ │ │ └── "Brand#13" - │ │ └── Eq - │ │ ├── #2 - │ │ └── "JUMBO PKG" - │ └── LogicalProjection { exprs: [ #0, #3, #6 ] } - │ └── LogicalScan { table: part } - └── LogicalProjection - ├── exprs: - │ ┌── Cast - │ │ ├── cast_to: Decimal128(30, 15) - │ │ ├── expr:Mul - │ │ │ ├── 0.2(float) - │ │ │ └── Cast { cast_to: Float64, expr: #1 } - - │ └── #0 - └── LogicalAgg - ├── exprs:Agg(Avg) - │ └── [ #1 ] - ├── groups: [ #0 ] - └── LogicalProjection { exprs: [ #1, #4 ] } - └── LogicalScan { table: lineitem } -PhysicalProjection -├── exprs:Scalar(Round) -│ └── -│ ┌── Div -│ │ ├── Cast { cast_to: Float64, expr: #0 } -│ │ └── 7(float) -│ └── 16(i64) -└── PhysicalAgg - ├── aggrs:Agg(Sum) - │ └── [ #0 ] - ├── groups: [] - └── PhysicalProjection { exprs: [ #1 ] } - └── PhysicalNestedLoopJoin - ├── join_type: Inner - ├── cond:And - │ ├── Eq - │ │ ├── #2 - │ │ └── #0 - │ └── Lt - │ ├── Cast { cast_to: Decimal128(30, 15), expr: #0 } - │ └── #3 - ├── PhysicalProjection { exprs: [ #1, #2, #3 ] } - │ └── PhysicalHashJoin { join_type: Inner, left_keys: [ #0 ], right_keys: [ #0 ] } - │ ├── PhysicalProjection { exprs: [ #1, #4, #5 ] } - │ │ └── PhysicalScan { table: lineitem } - │ └── PhysicalProjection { exprs: [ #0 ] } - │ └── PhysicalProjection { exprs: [ #0, #3, #6 ] } - │ └── PhysicalFilter - │ ├── cond:And - │ │ ├── Eq - │ │ │ ├── #3 - │ │ │ └── "Brand#13" - │ │ └── Eq - │ │ ├── #6 - │ │ └── "JUMBO PKG" - │ └── PhysicalScan { table: part } - └── PhysicalProjection - ├── exprs: - │ ┌── Cast - │ │ ├── cast_to: Decimal128(30, 15) - │ │ ├── expr:Mul - │ │ │ ├── 0.2(float) - │ │ │ └── Cast { cast_to: Float64, expr: #1 } - - │ └── #0 - └── PhysicalAgg - ├── aggrs:Agg(Avg) - │ └── [ #1 ] - ├── groups: [ #0 ] - └── PhysicalProjection { exprs: [ #1, #4 ] } - └── PhysicalScan { table: lineitem } -*/ - --- TPC-H Q19 -SELECT - sum(l_extendedprice* (1 - l_discount)) as revenue -FROM - lineitem, - part -WHERE - ( - p_partkey = l_partkey - AND p_brand = 'Brand#12' - AND p_container IN ('SM CASE', 'SM BOX', 'SM PACK', 'SM PKG') - AND l_quantity >= 1 AND l_quantity <= 11 - AND p_size BETWEEN 1 AND 5 - AND l_shipmode IN ('AIR', 'AIR REG') - AND l_shipinstruct = 'DELIVER IN PERSON' - ) OR ( - p_partkey = l_partkey - AND p_brand = 'Brand#23' - AND p_container IN ('MED BAG', 'MED BOX', 'MED PKG', 'MED PACK') - AND l_quantity >= 10 AND l_quantity <= 20 - AND p_size BETWEEN 1 AND 10 - AND l_shipmode IN ('AIR', 'AIR REG') - AND l_shipinstruct = 'DELIVER IN PERSON' - ) OR ( - p_partkey = l_partkey - AND p_brand = 'Brand#34' - AND p_container IN ('LG CASE', 'LG BOX', 'LG PACK', 'LG PKG') - AND l_quantity >= 20 AND l_quantity <= 30 - AND p_size BETWEEN 1 AND 15 - AND l_shipmode IN ('AIR', 'AIR REG') - AND l_shipinstruct = 'DELIVER IN PERSON' - ) - -/* -LogicalProjection { exprs: [ #0 ] } -└── LogicalAgg - ├── exprs:Agg(Sum) - │ └── Mul - │ ├── #5 - │ └── Sub - │ ├── Cast { cast_to: Decimal128(20, 0), expr: 1(i64) } - │ └── #6 - ├── groups: [] - └── LogicalFilter - ├── cond:Or - │ ├── And - │ │ ├── Eq - │ │ │ ├── #16 - │ │ │ └── #1 - │ │ ├── Eq - │ │ │ ├── #19 - │ │ │ └── "Brand#12" - │ │ ├── InList { expr: #22, list: [ "SM CASE", "SM BOX", "SM PACK", "SM PKG" ], negated: false } - │ │ ├── Geq - │ │ │ ├── Cast { cast_to: Decimal128(22, 2), expr: #4 } - │ │ │ └── Cast { cast_to: Decimal128(22, 2), expr: 1(i64) } - │ │ ├── Leq - │ │ │ ├── Cast { cast_to: Decimal128(22, 2), expr: #4 } - │ │ │ └── Cast { cast_to: Decimal128(22, 2), expr: 11(i64) } - │ │ ├── Between { expr: Cast { cast_to: Int64, expr: #21 }, lower: 1(i64), upper: 5(i64) } - │ │ ├── InList { expr: #14, list: [ "AIR", "AIR REG" ], negated: false } - │ │ └── Eq - │ │ ├── #13 - │ │ └── "DELIVER IN PERSON" - │ ├── And - │ │ ├── Eq - │ │ │ ├── #16 - │ │ │ └── #1 - │ │ ├── Eq - │ │ │ ├── #19 - │ │ │ └── "Brand#23" - │ │ ├── InList { expr: #22, list: [ "MED BAG", "MED BOX", "MED PKG", "MED PACK" ], negated: false } - │ │ ├── Geq - │ │ │ ├── Cast { cast_to: Decimal128(22, 2), expr: #4 } - │ │ │ └── Cast { cast_to: Decimal128(22, 2), expr: 10(i64) } - │ │ ├── Leq - │ │ │ ├── Cast { cast_to: Decimal128(22, 2), expr: #4 } - │ │ │ └── Cast { cast_to: Decimal128(22, 2), expr: 20(i64) } - │ │ ├── Between { expr: Cast { cast_to: Int64, expr: #21 }, lower: 1(i64), upper: 10(i64) } - │ │ ├── InList { expr: #14, list: [ "AIR", "AIR REG" ], negated: false } - │ │ └── Eq - │ │ ├── #13 - │ │ └── "DELIVER IN PERSON" - │ └── And - │ ├── Eq - │ │ ├── #16 - │ │ └── #1 - │ ├── Eq - │ │ ├── #19 - │ │ └── "Brand#34" - │ ├── InList { expr: #22, list: [ "LG CASE", "LG BOX", "LG PACK", "LG PKG" ], negated: false } - │ ├── Geq - │ │ ├── Cast { cast_to: Decimal128(22, 2), expr: #4 } - │ │ └── Cast { cast_to: Decimal128(22, 2), expr: 20(i64) } - │ ├── Leq - │ │ ├── Cast { cast_to: Decimal128(22, 2), expr: #4 } - │ │ └── Cast { cast_to: Decimal128(22, 2), expr: 30(i64) } - │ ├── Between { expr: Cast { cast_to: Int64, expr: #21 }, lower: 1(i64), upper: 15(i64) } - │ ├── InList { expr: #14, list: [ "AIR", "AIR REG" ], negated: false } - │ └── Eq - │ ├── #13 - │ └── "DELIVER IN PERSON" - └── LogicalJoin { join_type: Cross, cond: true } - ├── LogicalScan { table: lineitem } - └── LogicalScan { table: part } -PhysicalProjection { exprs: [ #0 ] } -└── PhysicalAgg - ├── aggrs:Agg(Sum) - │ └── Mul - │ ├── #5 - │ └── Sub - │ ├── Cast { cast_to: Decimal128(20, 0), expr: 1(i64) } - │ └── #6 - ├── groups: [] - └── PhysicalNestedLoopJoin - ├── join_type: Inner - ├── cond:Or - │ ├── And - │ │ ├── Eq - │ │ │ ├── #16 - │ │ │ └── #1 - │ │ ├── Eq - │ │ │ ├── #19 - │ │ │ └── "Brand#12" - │ │ ├── InList { expr: #22, list: [ "SM CASE", "SM BOX", "SM PACK", "SM PKG" ], negated: false } - │ │ ├── Geq - │ │ │ ├── Cast { cast_to: Decimal128(22, 2), expr: #4 } - │ │ │ └── Cast { cast_to: Decimal128(22, 2), expr: 1(i64) } - │ │ ├── Leq - │ │ │ ├── Cast { cast_to: Decimal128(22, 2), expr: #4 } - │ │ │ └── Cast { cast_to: Decimal128(22, 2), expr: 11(i64) } - │ │ ├── Between { expr: Cast { cast_to: Int64, expr: #21 }, lower: 1(i64), upper: 5(i64) } - │ │ ├── InList { expr: #14, list: [ "AIR", "AIR REG" ], negated: false } - │ │ └── Eq - │ │ ├── #13 - │ │ └── "DELIVER IN PERSON" - │ ├── And - │ │ ├── Eq - │ │ │ ├── #16 - │ │ │ └── #1 - │ │ ├── Eq - │ │ │ ├── #19 - │ │ │ └── "Brand#23" - │ │ ├── InList { expr: #22, list: [ "MED BAG", "MED BOX", "MED PKG", "MED PACK" ], negated: false } - │ │ ├── Geq - │ │ │ ├── Cast { cast_to: Decimal128(22, 2), expr: #4 } - │ │ │ └── Cast { cast_to: Decimal128(22, 2), expr: 10(i64) } - │ │ ├── Leq - │ │ │ ├── Cast { cast_to: Decimal128(22, 2), expr: #4 } - │ │ │ └── Cast { cast_to: Decimal128(22, 2), expr: 20(i64) } - │ │ ├── Between { expr: Cast { cast_to: Int64, expr: #21 }, lower: 1(i64), upper: 10(i64) } - │ │ ├── InList { expr: #14, list: [ "AIR", "AIR REG" ], negated: false } - │ │ └── Eq - │ │ ├── #13 - │ │ └── "DELIVER IN PERSON" - │ └── And - │ ├── Eq - │ │ ├── #16 - │ │ └── #1 - │ ├── Eq - │ │ ├── #19 - │ │ └── "Brand#34" - │ ├── InList { expr: #22, list: [ "LG CASE", "LG BOX", "LG PACK", "LG PKG" ], negated: false } - │ ├── Geq - │ │ ├── Cast { cast_to: Decimal128(22, 2), expr: #4 } - │ │ └── Cast { cast_to: Decimal128(22, 2), expr: 20(i64) } - │ ├── Leq - │ │ ├── Cast { cast_to: Decimal128(22, 2), expr: #4 } - │ │ └── Cast { cast_to: Decimal128(22, 2), expr: 30(i64) } - │ ├── Between { expr: Cast { cast_to: Int64, expr: #21 }, lower: 1(i64), upper: 15(i64) } - │ ├── InList { expr: #14, list: [ "AIR", "AIR REG" ], negated: false } - │ └── Eq - │ ├── #13 - │ └── "DELIVER IN PERSON" - ├── PhysicalScan { table: lineitem } - └── PhysicalScan { table: part } -*/ - diff --git a/optd-sqlplannertest/tests/tpch/tpch.yml b/optd-sqlplannertest/tests/tpch/tpch.yml deleted file mode 100644 index cf651493..00000000 --- a/optd-sqlplannertest/tests/tpch/tpch.yml +++ /dev/null @@ -1,583 +0,0 @@ -- sql: | - CREATE TABLE NATION ( - N_NATIONKEY INT NOT NULL, - N_NAME CHAR(25) NOT NULL, - N_REGIONKEY INT NOT NULL, - N_COMMENT VARCHAR(152) - ); - - CREATE TABLE REGION ( - R_REGIONKEY INT NOT NULL, - R_NAME CHAR(25) NOT NULL, - R_COMMENT VARCHAR(152) - ); - - CREATE TABLE PART ( - P_PARTKEY INT NOT NULL, - P_NAME VARCHAR(55) NOT NULL, - P_MFGR CHAR(25) NOT NULL, - P_BRAND CHAR(10) NOT NULL, - P_TYPE VARCHAR(25) NOT NULL, - P_SIZE INT NOT NULL, - P_CONTAINER CHAR(10) NOT NULL, - P_RETAILPRICE DECIMAL(15,2) NOT NULL, - P_COMMENT VARCHAR(23) NOT NULL - ); - - CREATE TABLE SUPPLIER ( - S_SUPPKEY INT NOT NULL, - S_NAME CHAR(25) NOT NULL, - S_ADDRESS VARCHAR(40) NOT NULL, - S_NATIONKEY INT NOT NULL, - S_PHONE CHAR(15) NOT NULL, - S_ACCTBAL DECIMAL(15,2) NOT NULL, - S_COMMENT VARCHAR(101) NOT NULL - ); - - CREATE TABLE PARTSUPP ( - PS_PARTKEY INT NOT NULL, - PS_SUPPKEY INT NOT NULL, - PS_AVAILQTY INT NOT NULL, - PS_SUPPLYCOST DECIMAL(15,2) NOT NULL, - PS_COMMENT VARCHAR(199) NOT NULL - ); - - CREATE TABLE CUSTOMER ( - C_CUSTKEY INT NOT NULL, - C_NAME VARCHAR(25) NOT NULL, - C_ADDRESS VARCHAR(40) NOT NULL, - C_NATIONKEY INT NOT NULL, - C_PHONE CHAR(15) NOT NULL, - C_ACCTBAL DECIMAL(15,2) NOT NULL, - C_MKTSEGMENT CHAR(10) NOT NULL, - C_COMMENT VARCHAR(117) NOT NULL - ); - - CREATE TABLE ORDERS ( - O_ORDERKEY INT NOT NULL, - O_CUSTKEY INT NOT NULL, - O_ORDERSTATUS CHAR(1) NOT NULL, - O_TOTALPRICE DECIMAL(15,2) NOT NULL, - O_ORDERDATE DATE NOT NULL, - O_ORDERPRIORITY CHAR(15) NOT NULL, - O_CLERK CHAR(15) NOT NULL, - O_SHIPPRIORITY INT NOT NULL, - O_COMMENT VARCHAR(79) NOT NULL - ); - - CREATE TABLE LINEITEM ( - L_ORDERKEY INT NOT NULL, - L_PARTKEY INT NOT NULL, - L_SUPPKEY INT NOT NULL, - L_LINENUMBER INT NOT NULL, - L_QUANTITY DECIMAL(15,2) NOT NULL, - L_EXTENDEDPRICE DECIMAL(15,2) NOT NULL, - L_DISCOUNT DECIMAL(15,2) NOT NULL, - L_TAX DECIMAL(15,2) NOT NULL, - L_RETURNFLAG CHAR(1) NOT NULL, - L_LINESTATUS CHAR(1) NOT NULL, - L_SHIPDATE DATE NOT NULL, - L_COMMITDATE DATE NOT NULL, - L_RECEIPTDATE DATE NOT NULL, - L_SHIPINSTRUCT CHAR(25) NOT NULL, - L_SHIPMODE CHAR(10) NOT NULL, - L_COMMENT VARCHAR(44) NOT NULL - ); - desc: TPC-H schema - tasks: - - execute -- sql: | - SELECT - l_returnflag, - l_linestatus, - sum(l_quantity) as sum_qty, - sum(l_extendedprice) as sum_base_price, - sum(l_extendedprice * (1 - l_discount)) as sum_disc_price, - sum(l_extendedprice * (1 - l_discount) * (1 + l_tax)) as sum_charge, - avg(l_quantity) as avg_qty, - avg(l_extendedprice) as avg_price, - avg(l_discount) as avg_disc, - count(*) as count_order - FROM - lineitem - WHERE - l_shipdate <= date '1998-12-01' - interval '90' day - GROUP BY - l_returnflag, l_linestatus - ORDER BY - l_returnflag, l_linestatus; - desc: TPC-H Q1 - tasks: - - explain:logical_optd,physical_optd -- sql: | - select - s_acctbal, - s_name, - n_name, - p_partkey, - p_mfgr, - s_address, - s_phone, - s_comment - from - part, - supplier, - partsupp, - nation, - region - where - p_partkey = ps_partkey - and s_suppkey = ps_suppkey - and p_size = 4 - and p_type like '%TIN' - and s_nationkey = n_nationkey - and n_regionkey = r_regionkey - and r_name = 'AFRICA' - and ps_supplycost = ( - select - min(ps_supplycost) - from - partsupp, - supplier, - nation, - region - where - p_partkey = ps_partkey - and s_suppkey = ps_suppkey - and s_nationkey = n_nationkey - and n_regionkey = r_regionkey - and r_name = 'AFRICA' - ) - order by - s_acctbal desc, - n_name, - s_name, - p_partkey - limit 100; - desc: TPC-H Q2 - tasks: - - explain[use_df_logical]:logical_optd,physical_optd -- sql: | - SELECT - l_orderkey, - SUM(l_extendedprice * (1 - l_discount)) AS revenue, - o_orderdate, - o_shippriority - FROM - customer, - orders, - lineitem - WHERE - c_mktsegment = 'FURNITURE' - AND c_custkey = o_custkey - AND l_orderkey = o_orderkey - AND o_orderdate < DATE '1995-03-29' - AND l_shipdate > DATE '1995-03-29' - GROUP BY - l_orderkey, - o_orderdate, - o_shippriority - ORDER BY - revenue DESC, - o_orderdate LIMIT 10; - desc: TPC-H Q3 - tasks: - - explain[use_df_logical]:logical_optd,physical_optd -- sql: | - SELECT - n_name AS nation, - SUM(l_extendedprice * (1 - l_discount)) AS revenue - FROM - customer, - orders, - lineitem, - supplier, - nation, - region - WHERE - c_custkey = o_custkey - AND l_orderkey = o_orderkey - AND l_suppkey = s_suppkey - AND c_nationkey = s_nationkey - AND s_nationkey = n_nationkey - AND n_regionkey = r_regionkey - AND r_name = 'Asia' -- Specified region - AND o_orderdate >= DATE '2023-01-01' - AND o_orderdate < DATE '2024-01-01' - GROUP BY - n_name - ORDER BY - revenue DESC; - desc: TPC-H Q5 - tasks: - - explain:logical_optd,physical_optd -- sql: | - SELECT - SUM(l_extendedprice * l_discount) AS revenue_loss - FROM - lineitem - WHERE - l_shipdate >= DATE '2023-01-01' - AND l_shipdate < DATE '2024-01-01' - AND l_discount BETWEEN 0.05 AND 0.07 - AND l_quantity < 24; - desc: TPC-H Q6 - tasks: - - explain:logical_optd,physical_optd -- sql: | - SELECT - supp_nation, - cust_nation, - l_year, - SUM(volume) AS revenue - FROM - ( - SELECT - n1.n_name AS supp_nation, - n2.n_name AS cust_nation, - EXTRACT(YEAR FROM l_shipdate) AS l_year, - l_extendedprice * (1 - l_discount) AS volume - FROM - supplier, - lineitem, - orders, - customer, - nation n1, - nation n2 - WHERE - s_suppkey = l_suppkey - AND o_orderkey = l_orderkey - AND c_custkey = o_custkey - AND s_nationkey = n1.n_nationkey - AND c_nationkey = n2.n_nationkey - AND ( - (n1.n_name = 'FRANCE' AND n2.n_name = 'GERMANY') - OR (n1.n_name = 'GERMANY' AND n2.n_name = 'FRANCE') - ) - AND l_shipdate BETWEEN DATE '1995-01-01' AND DATE '1996-12-31' - ) AS shipping - GROUP BY - supp_nation, - cust_nation, - l_year - ORDER BY - supp_nation, - cust_nation, - l_year; - desc: TPC-H Q7 - tasks: - - explain:logical_optd,physical_optd -- sql: | - select - o_year, - sum(case - when nation = 'IRAQ' then volume - else 0 - end) / sum(volume) as mkt_share - from - ( - select - extract(year from o_orderdate) as o_year, - l_extendedprice * (1 - l_discount) as volume, - n2.n_name as nation - from - part, - supplier, - lineitem, - orders, - customer, - nation n1, - nation n2, - region - where - p_partkey = l_partkey - and s_suppkey = l_suppkey - and l_orderkey = o_orderkey - and o_custkey = c_custkey - and c_nationkey = n1.n_nationkey - and n1.n_regionkey = r_regionkey - and r_name = 'AMERICA' - and s_nationkey = n2.n_nationkey - and o_orderdate between date '1995-01-01' and date '1996-12-31' - and p_type = 'ECONOMY ANODIZED STEEL' - ) as all_nations - group by - o_year - order by - o_year; - desc: TPC-H Q8 without top-most limit node - tasks: - - explain:logical_optd,physical_optd -- sql: | - SELECT - nation, - o_year, - SUM(amount) AS sum_profit - FROM - ( - SELECT - n_name AS nation, - EXTRACT(YEAR FROM o_orderdate) AS o_year, - l_extendedprice * (1 - l_discount) - ps_supplycost * l_quantity AS amount - FROM - part, - supplier, - lineitem, - partsupp, - orders, - nation - WHERE - s_suppkey = l_suppkey - AND ps_suppkey = l_suppkey - AND ps_partkey = l_partkey - AND p_partkey = l_partkey - AND o_orderkey = l_orderkey - AND s_nationkey = n_nationkey - AND p_name LIKE '%green%' - ) AS profit - GROUP BY - nation, - o_year - ORDER BY - nation, - o_year DESC; - desc: TPC-H Q9 - tasks: - - explain:logical_optd,physical_optd -- sql: | - SELECT - nation, - o_year, - SUM(amount) AS sum_profit - FROM - ( - SELECT - n_name AS nation, - EXTRACT(YEAR FROM o_orderdate) AS o_year, - l_extendedprice * (1 - l_discount) - ps_supplycost * l_quantity AS amount - FROM - part, - supplier, - lineitem, - partsupp, - orders, - nation - WHERE - s_suppkey = l_suppkey - AND ps_suppkey = l_suppkey - AND ps_partkey = l_partkey - AND p_partkey = l_partkey - AND o_orderkey = l_orderkey - AND s_nationkey = n_nationkey - AND p_name LIKE '%green%' - ) AS profit - GROUP BY - nation, - o_year - ORDER BY - nation, - o_year DESC; - desc: TPC-H Q9 - tasks: - - explain:logical_optd,physical_optd -- sql: | - SELECT - c_custkey, - c_name, - sum(l_extendedprice * (1 - l_discount)) as revenue, - c_acctbal, - n_name, - c_address, - c_phone, - c_comment - FROM - customer, - orders, - lineitem, - nation - WHERE - c_custkey = o_custkey - AND l_orderkey = o_orderkey - AND o_orderdate >= DATE '1993-07-01' - AND o_orderdate < DATE '1993-07-01' + INTERVAL '3' MONTH - AND l_returnflag = 'R' - AND c_nationkey = n_nationkey - GROUP BY - c_custkey, - c_name, - c_acctbal, - c_phone, - n_name, - c_address, - c_comment - ORDER BY - revenue DESC - LIMIT 20; - desc: TPC-H Q10 - tasks: - - explain:logical_optd,physical_optd -- sql: | - select - ps_partkey, - sum(ps_supplycost * ps_availqty) as value - from - partsupp, - supplier, - nation - where - ps_suppkey = s_suppkey - and s_nationkey = n_nationkey - and n_name = 'CHINA' - group by - ps_partkey having - sum(ps_supplycost * ps_availqty) > ( - select - sum(ps_supplycost * ps_availqty) * 0.0001000000 - from - partsupp, - supplier, - nation - where - ps_suppkey = s_suppkey - and s_nationkey = n_nationkey - and n_name = 'CHINA' - ) - order by - value desc; - desc: TPC-H Q11 - tasks: - - explain[use_df_logical]:logical_optd,physical_optd -- sql: | - SELECT - l_shipmode, - sum(case when o_orderpriority = '1-URGENT' - or o_orderpriority = '2-HIGH' - then 1 else 0 end) as high_priority_orders, - sum(case when o_orderpriority <> '1-URGENT' - and o_orderpriority <> '2-HIGH' - then 1 else 0 end) as low_priority_orders - FROM - orders, - lineitem - WHERE - o_orderkey = l_orderkey - AND l_shipmode in ('MAIL', 'SHIP') - AND l_commitdate < l_receiptdate - AND l_shipdate < l_commitdate - AND l_receiptdate >= DATE '1994-01-01' - AND l_receiptdate < DATE '1995-01-01' - GROUP BY - l_shipmode - ORDER BY - l_shipmode; - desc: TPC-H Q12 - tasks: - - explain:logical_optd,physical_optd -- sql: | - SELECT - 100.00 * sum(case when p_type like 'PROMO%' - then l_extendedprice * (1 - l_discount) - else 0 end) / sum(l_extendedprice * (1 - l_discount)) as promo_revenue - FROM - lineitem, - part - WHERE - l_partkey = p_partkey - AND l_shipdate >= DATE '1995-09-01' - AND l_shipdate < DATE '1995-09-01' + INTERVAL '1' MONTH; - desc: TPC-H Q14 - tasks: - - explain:logical_optd,physical_optd -- sql: | - WITH revenue0 (supplier_no, total_revenue) AS - ( - SELECT - l_suppkey, - SUM(l_extendedprice * (1 - l_discount)) - FROM - lineitem - WHERE - l_shipdate >= DATE '1993-01-01' - AND l_shipdate < DATE '1993-01-01' + INTERVAL '3' MONTH - GROUP BY - l_suppkey - ) - SELECT - s_suppkey, - s_name, - s_address, - s_phone, - total_revenue - FROM - supplier, - revenue0 - WHERE - s_suppkey = supplier_no - AND total_revenue = - ( - SELECT - MAX(total_revenue) - FROM - revenue0 - ) - ORDER BY - s_suppkey; - desc: TPC-H Q15 - tasks: - - explain[use_df_logical]:logical_optd,physical_optd -- sql: | - SELECT - ROUND(SUM(l_extendedprice) / 7.0, 16) AS avg_yearly - FROM - lineitem, - part - WHERE - p_partkey = l_partkey - AND p_brand = 'Brand#13' - AND p_container = 'JUMBO PKG' - AND l_quantity < ( - SELECT - 0.2 * AVG(l_quantity) - FROM - lineitem - WHERE - l_partkey = p_partkey - ); - desc: TPC-H Q17 - tasks: - - explain[use_df_logical]:logical_optd,physical_optd -- sql: | - SELECT - sum(l_extendedprice* (1 - l_discount)) as revenue - FROM - lineitem, - part - WHERE - ( - p_partkey = l_partkey - AND p_brand = 'Brand#12' - AND p_container IN ('SM CASE', 'SM BOX', 'SM PACK', 'SM PKG') - AND l_quantity >= 1 AND l_quantity <= 11 - AND p_size BETWEEN 1 AND 5 - AND l_shipmode IN ('AIR', 'AIR REG') - AND l_shipinstruct = 'DELIVER IN PERSON' - ) OR ( - p_partkey = l_partkey - AND p_brand = 'Brand#23' - AND p_container IN ('MED BAG', 'MED BOX', 'MED PKG', 'MED PACK') - AND l_quantity >= 10 AND l_quantity <= 20 - AND p_size BETWEEN 1 AND 10 - AND l_shipmode IN ('AIR', 'AIR REG') - AND l_shipinstruct = 'DELIVER IN PERSON' - ) OR ( - p_partkey = l_partkey - AND p_brand = 'Brand#34' - AND p_container IN ('LG CASE', 'LG BOX', 'LG PACK', 'LG PKG') - AND l_quantity >= 20 AND l_quantity <= 30 - AND p_size BETWEEN 1 AND 15 - AND l_shipmode IN ('AIR', 'AIR REG') - AND l_shipinstruct = 'DELIVER IN PERSON' - ) - desc: TPC-H Q19 - tasks: - - explain:logical_optd,physical_optd