Apache DataFusion SQL Query Engine
fix: infer LIMIT and OFFSET parameter types (#25364)
Stefan Wangb7c7bc2c3930
diff --git a/datafusion/core/tests/sql/select.rs b/datafusion/core/tests/sql/select.rsindex c5c1ae54e7..fae2fb5bc5 100644--- a/datafusion/core/tests/sql/select.rs+++ b/datafusion/core/tests/sql/select.rs@@ -387,6 +387,79 @@ async fn test_query_parameters_with_metadata() -> Result<()> {Ok(())}+#[tokio::test]+async fn test_limit_offset_parameters_named() -> Result<()> {+ let ctx = SessionContext::new();+ let df = ctx+ .sql(+ "SELECT value FROM (VALUES (10), (20), (30)) AS t(value) \+ ORDER BY value LIMIT $rows OFFSET $skip",+ )+ .await?;+ assert_eq!(+ df.logical_plan().get_parameter_types()?,+ HashMap::from([+ ("$rows".to_string(), Some(DataType::Int64)),+ ("$skip".to_string(), Some(DataType::Int64)),+ ])+ );+ let results = df+ .with_param_values(vec![+ ("rows", ScalarValue::Int64(Some(1))),+ ("skip", ScalarValue::Int64(Some(1))),+ ])?+ .collect()+ .await?;+ datafusion::assert_batches_eq!(+ [+ "+-------+",+ "| value |",+ "+-------+",+ "| 20 |",+ "+-------+"+ ],+ &results+ );+ Ok(())+}++#[tokio::test]+async fn test_limit_offset_parameters_keep_field_metadata() -> Result<()> {+ let ctx = SessionContext::new();+ let metadata = HashMap::from([("some_key".to_string(), "some_value".to_string())]);+ let schema = Arc::new(Schema::new(vec![+ Field::new("value", DataType::Int32, false).with_metadata(metadata.clone()),+ ]));+ ctx.register_batch(+ "t",+ RecordBatch::try_new(schema, vec![Arc::new(Int32Array::from(vec![1, 1]))])?,+ )?;++ for clause in ["LIMIT", "OFFSET"] {+ let sql = format!("SELECT $1 AS value FROM t WHERE value = $1 {clause} $1");+ let df = ctx.sql(&sql).await?;+ let results = df+ .with_param_values(ParamValues::List(vec![ScalarAndMetadata::new(+ ScalarValue::Int32(Some(1)),+ Some(metadata.clone().into()),+ )]))?+ .collect()+ .await?;+ datafusion::assert_batches_eq!(+ [+ "+-------+",+ "| value |",+ "+-------+",+ "| 1 |",+ "+-------+"+ ],+ &results+ );+ }++ Ok(())+}+#[tokio::test]async fn test_version_function() {let expected_version = format!(diff --git a/datafusion/expr/src/logical_plan/plan.rs b/datafusion/expr/src/logical_plan/plan.rsindex 658516843a..ba813253bc 100644--- a/datafusion/expr/src/logical_plan/plan.rs+++ b/datafusion/expr/src/logical_plan/plan.rs@@ -1840,14 +1840,21 @@ impl LogicalPlan {.collect())}- /// Walk the logical plan, find any `Placeholder` tokens, and return a map of their IDs and FieldRefs+ /// Walk the logical plan, find any `Placeholder` tokens, and return a map of their IDs and FieldRefs.+ /// Bare `LIMIT`/`OFFSET` parameters default to `Int64` if no occurrence provides a type.pub fn get_parameter_fields(&self,) -> Result<HashMap<String, Option<FieldRef>>, DataFusionError> {let mut param_types: HashMap<String, Option<FieldRef>> = HashMap::new();+ let mut row_count_parameters: HashSet<String> = HashSet::new();self.apply_with_subqueries(|plan| {plan.apply_expressions(|expr| {+ if matches!(plan, LogicalPlan::Limit(_))+ && let Expr::Placeholder(Placeholder { id, field: None }) = expr+ {+ row_count_parameters.insert(id.clone());+ }expr.apply(|expr| {if let Expr::Placeholder(Placeholder { id, field }) = expr {let prev = param_types.get(id);@@ -1864,15 +1871,22 @@ impl LogicalPlan {param_types.insert(id.clone(), Some(Arc::clone(field)));}_ => {- param_types.insert(id.clone(), None);+ param_types.entry(id.clone()).or_insert(None);}}}Ok(TreeNodeRecursion::Continue)})})- })- .map(|_| param_types)+ })?;++ for id in row_count_parameters {+ param_types+ .entry(id)+ .or_default()+ .get_or_insert_with(|| Arc::new(Field::new("", DataType::Int64, true)));+ }+ Ok(param_types)}// ------------diff --git a/datafusion/optimizer/src/analyzer/type_coercion.rs b/datafusion/optimizer/src/analyzer/type_coercion.rsindex e805e5eeb2..39310eec1f 100644--- a/datafusion/optimizer/src/analyzer/type_coercion.rs+++ b/datafusion/optimizer/src/analyzer/type_coercion.rs@@ -98,6 +98,25 @@ impl AnalyzerRule for TypeCoercion {fn analyze(&self, plan: LogicalPlan, config: &ConfigOptions) -> Result<LogicalPlan> {static EMPTY_SCHEMA: LazyLock<DFSchema> = LazyLock::new(DFSchema::empty);+ // Record bare row-count parameter types before coercion makes them indistinguishable+ // from explicit casts. A type inferred elsewhere takes precedence over the default.+ let parameter_fields = plan.get_parameter_fields()?;+ let plan = plan+ .transform_up_with_subqueries(|plan| {+ if !matches!(plan, LogicalPlan::Limit(_)) {+ return Ok(Transformed::no(plan));+ }+ plan.map_expressions(|expr| match expr {+ Expr::Placeholder(mut placeholder) if placeholder.field.is_none() => {+ placeholder.field =+ parameter_fields.get(&placeholder.id).cloned().flatten();+ Ok(Transformed::yes(Expr::Placeholder(placeholder)))+ }+ expr => Ok(Transformed::no(expr)),+ })+ })?+ .data;+// recurselet transformed_plan = plan.transform_up_with_subqueries(|plan| {@@ -1743,10 +1762,10 @@ mod test {use arrow::datatypes::{DataType, Field, Schema, SchemaBuilder, TimeUnit};use insta::assert_snapshot;- use crate::analyzer::Analyzer;use crate::analyzer::type_coercion::{TypeCoercion, TypeCoercionRewriter, coerce_case_expression,};+ use crate::analyzer::{Analyzer, AnalyzerRule};use crate::assert_analyzed_plan_with_config_eq_snapshot;use datafusion_common::config::ConfigOptions;use datafusion_common::tree_node::{TransformedResult, TreeNode};@@ -1760,9 +1779,9 @@ mod test {use datafusion_expr::test::function_stub::avg_udaf;use datafusion_expr::{AccumulatorFactoryFunction, AggregateUDF, BinaryExpr, Case, ColumnarValue, Expr,- ExprSchemable, Filter, LogicalPlan, Operator, ScalarFunctionArgs, ScalarUDF,- ScalarUDFImpl, Signature, SimpleAggregateUDF, Subquery, Union, Volatility, cast,- col, create_udaf, is_true, lit,+ ExprSchemable, Filter, Limit, LogicalPlan, Operator, ScalarFunctionArgs,+ ScalarUDF, ScalarUDFImpl, Signature, SimpleAggregateUDF, Subquery, Union,+ Volatility, cast, col, create_udaf, is_true, lit, placeholder,};use datafusion_functions_aggregate::average::AvgAccumulator;@@ -1847,6 +1866,19 @@ mod test {Ok(())}+ #[test]+ fn untyped_limit_parameter_remains_inferable_after_coercion() -> Result<()> {+ let plan = LogicalPlan::Limit(Limit {+ input: empty(),+ fetch: Some(Box::new(placeholder("$1"))),+ skip: None,+ });+ let analyzed = TypeCoercion::new().analyze(plan, &ConfigOptions::default())?;++ assert_eq!(analyzed.get_parameter_types()?["$1"], Some(DataType::Int64));+ Ok(())+ }+#[test]fn simple_case() -> Result<()> {let expr = col("a").lt(lit(2_u32));diff --git a/datafusion/optimizer/tests/optimizer_integration.rs b/datafusion/optimizer/tests/optimizer_integration.rsindex 26b48c5e1f..eb4088e5e3 100644--- a/datafusion/optimizer/tests/optimizer_integration.rs+++ b/datafusion/optimizer/tests/optimizer_integration.rs@@ -670,6 +670,75 @@ fn optimize_plan(plan: LogicalPlan) -> Result<LogicalPlan> {optimizer.optimize(plan, &config, observe)}+#[test]+fn limit_offset_parameters_keep_type_after_optimization() -> Result<()> {+ for sql in [+ "SELECT 20 AS value LIMIT $1",+ "SELECT 20 AS value OFFSET $1",+ ] {+ let optimized = test_sql(sql)?;+ assert_eq!(+ optimized.get_parameter_types()?,+ HashMap::from([("$1".to_string(), Some(DataType::Int64))]),+ "{sql}"+ );+ }+ Ok(())+}++#[test]+fn limit_offset_parameters_leave_cast_inputs_unresolved_after_optimization() -> Result<()>+{+ for sql in [+ "SELECT $1 AS value",+ "SELECT $1 AS value LIMIT CAST($1 AS INT)",+ "SELECT $1 AS value LIMIT CAST($1 AS BIGINT)",+ "SELECT $1 AS value FROM (VALUES (1), (2)) AS t(v) OFFSET CAST($1 AS BIGINT)",+ "SELECT $1 AS value FROM (SELECT 1 LIMIT CAST($1 AS BIGINT)) AS t",+ ] {+ let optimized = test_sql(sql)?;+ assert_eq!(+ optimized.get_parameter_types()?,+ HashMap::from([("$1".to_string(), None)]),+ "{sql}"+ );+ }+ Ok(())+}++#[test]+fn limit_parameter_binding_with_inferred_type() -> Result<()> {+ let statements = Parser::parse_sql(+ &GenericDialect {},+ "SELECT $1 + CAST(1 AS INT) AS value LIMIT $1",+ )?;+ let context_provider = MyContextProvider::default();+ let plan =+ SqlToRel::new(&context_provider).sql_statement_to_plan(statements[0].clone())?;+ let analyzed =+ Analyzer::new().execute_and_check(plan, &ConfigOptions::default(), |_, _| {})?;+ let bound = analyzed.with_param_values(vec![ScalarValue::Int32(Some(1))])?;+ let optimized = optimize_plan(bound)?;+ let limit = match &optimized {+ LogicalPlan::Limit(limit) => limit,+ LogicalPlan::Projection(projection) => {+ let LogicalPlan::Limit(limit) = projection.input.as_ref() else {+ panic!("expected LIMIT under projection, got {optimized:?}");+ };+ limit+ }+ _ => panic!("expected LIMIT plan, got {optimized:?}"),+ };+ assert!(+ matches!(+ limit.get_fetch_type()?,+ datafusion_expr::FetchType::Literal(Some(1))+ ),+ "unexpected optimized LIMIT: {optimized}"+ );+ Ok(())+}+/// Extension node that does NOT implement `necessary_children_exprs`./// Used to test that the optimizer still processes subtrees below such nodes.#[derive(Debug, Hash, PartialEq, Eq)]diff --git a/datafusion/sql/src/statement.rs b/datafusion/sql/src/statement.rsindex 10420b9a61..ed6eeab284 100644--- a/datafusion/sql/src/statement.rs+++ b/datafusion/sql/src/statement.rs@@ -880,16 +880,18 @@ impl<S: ContextProvider> SqlToRel<'_, S> {if fields.is_empty() {let map_types = plan.get_parameter_fields()?;- let param_types: Vec<_> = (1..=map_types.len())- .filter_map(|i| {+ let param_types: Option<Vec<FieldRef>> = (1..=map_types.len())+ .map(|i| {let key = format!("${i}");map_types.get(&key).and_then(|opt| opt.clone())}).collect();- fields.extend(param_types.iter().cloned());- planner_context.with_prepare_param_data_types(- param_types.into_iter().map(Some).collect(),- );+ if let Some(param_types) = param_types {+ fields.extend(param_types.iter().cloned());+ planner_context.with_prepare_param_data_types(+ param_types.into_iter().map(Some).collect(),+ );+ }}Ok(LogicalPlan::Statement(PlanStatement::Prepare(Prepare {diff --git a/datafusion/sql/tests/cases/params.rs b/datafusion/sql/tests/cases/params.rsindex 3d51974071..4a1c71b79a 100644--- a/datafusion/sql/tests/cases/params.rs+++ b/datafusion/sql/tests/cases/params.rs@@ -987,32 +987,122 @@ fn test_prepare_statement_to_plan_having() {#[test]fn test_prepare_statement_to_plan_limit() {- let sql = "PREPARE my_plan(BIGINT, BIGINT) AS- SELECT id FROM person \- OFFSET $1 LIMIT $2";- let (plan, dt) = generate_prepare_stmt_and_data_types(sql);- assert_snapshot!(- plan,- @r#"+ for sql in [+ "PREPARE my_plan(BIGINT, BIGINT) AS SELECT id FROM person OFFSET $1 LIMIT $2",+ "PREPARE my_plan AS SELECT id FROM person OFFSET $1 LIMIT $2",+ ] {+ let test = ParameterTest {+ sql,+ expected_types: vec![+ ("$1", Some(DataType::Int64)),+ ("$2", Some(DataType::Int64)),+ ],+ param_values: vec![+ ScalarValue::Int64(Some(10)),+ ScalarValue::Int64(Some(200)),+ ],+ };+ insta::allow_duplicates! {+ assert_snapshot!(test.run(), @r#"+ ** Initial Plan:Prepare: "my_plan" [Int64, Int64]Limit: skip=$1, fetch=$2Projection: person.idTableScan: person- "#- );- assert_snapshot!(dt, @"Int64, Int64");-- // replace params with values- let param_values = vec![ScalarValue::Int64(Some(10)), ScalarValue::Int64(Some(200))];- let plan_with_params = plan.with_param_values(param_values).unwrap();- assert_snapshot!(- plan_with_params,- @r"+ ** Final Plan:Limit: skip=10, fetch=200Projection: person.idTableScan: person- "- );+ "#);+ }+ }+}++#[test]+fn test_limit_offset_parameters() {+ let mut plans = Vec::new();+ for sql in [+ "SELECT 20 AS value LIMIT $1",+ "SELECT 20 AS value OFFSET $1",+ "SELECT $1 AS value LIMIT $1",+ "SELECT $1 AS value FROM (VALUES (0), (0)) AS t(dummy) OFFSET $1",+ "SELECT value FROM (SELECT 20 AS value LIMIT $1) AS t",+ "SELECT (SELECT value FROM (VALUES (10), (20)) AS t(value) \+ ORDER BY value LIMIT $1) AS value",+ "SELECT 20 AS value WHERE EXISTS \+ (SELECT value FROM (VALUES (10), (20)) AS t(value) OFFSET $1)",+ ] {+ let test = ParameterTest {+ sql,+ expected_types: vec![("$1", Some(DataType::Int64))],+ param_values: vec![ScalarValue::Int64(Some(1))],+ };+ plans.push(format!("{sql}\n{}", test.run()));+ }++ let test = ParameterTest {+ sql: "SELECT $1 + CAST(1 AS INT) AS value \+ FROM (SELECT $1) AS t LIMIT $1",+ expected_types: vec![("$1", Some(DataType::Int32))],+ param_values: vec![ScalarValue::Int32(Some(1))],+ };+ plans.push(test.run());+ assert_snapshot!(plans.join("\n"));+}++#[test]+fn test_limit_offset_parameters_leave_cast_inputs_unresolved() {+ let mut plans = Vec::new();+ for sql in [+ "SELECT $1 AS value",+ "SELECT $1 AS value LIMIT CAST($1 AS INT)",+ "SELECT $1 AS value LIMIT CAST($1 AS BIGINT)",+ "SELECT $1 AS value FROM (VALUES (1), (2)) AS t(v) \+ OFFSET CAST($1 AS BIGINT)",+ "SELECT $1 AS value FROM (SELECT 1 LIMIT CAST($1 AS BIGINT)) AS t",+ ] {+ let test = ParameterTest {+ sql,+ expected_types: vec![("$1", None)],+ param_values: vec![ScalarValue::from("1")],+ };+ plans.push(format!("{sql}\n{}", test.run()));+ }+ assert_snapshot!(plans.join("\n"));+}++#[test]+fn test_limit_offset_parameters_keep_field_metadata() {+ let field = Field::new("value", DataType::Utf8, true)+ .with_metadata(Metadata::new().with("ARROW:extension:name", "example.string"));+ let mut plans = Vec::new();+ for clause in ["LIMIT", "OFFSET"] {+ let sql = format!(+ "SELECT $1 AS value FROM string_with_extension WHERE value = $1 {clause} $1"+ );+ let test = ParameterTestWithMetadata {+ sql: &sql,+ expected_types: vec![("$1", Some(field.clone().into()))],+ param_values: vec![ScalarAndMetadata::new(+ ScalarValue::from("1"),+ Some(field.metadata().into()),+ )],+ };+ plans.push(test.run());+ }+ assert_snapshot!(plans.join("\n"));+}++#[test]+fn test_limit_offset_parameters_reject_type_conflicts() {+ let plan = logical_plan(+ "SELECT $1 + CAST(1 AS INT) AS a, $1 + CAST(1 AS DOUBLE) AS b LIMIT $1",+ )+ .unwrap();+ let error = plan+ .get_parameter_fields()+ .expect_err("conflicting parameter types must fail");+ assert_contains!(error.to_string(), "Conflicting types for id $1");}#[test]diff --git a/datafusion/sql/tests/cases/snapshots/sql_integration__cases__params__limit_offset_parameters.snap b/datafusion/sql/tests/cases/snapshots/sql_integration__cases__params__limit_offset_parameters.snapnew file mode 100644index 0000000000..91c91d4818--- /dev/null+++ b/datafusion/sql/tests/cases/snapshots/sql_integration__cases__params__limit_offset_parameters.snap@@ -0,0 +1,111 @@+---+source: datafusion/sql/tests/cases/params.rs+expression: "plans.join(\"\\n\")"+---+SELECT 20 AS value LIMIT $1+** Initial Plan:+Limit: skip=0, fetch=$1+ Projection: Int64(20) AS value+ EmptyRelation: rows=1+** Final Plan:+Limit: skip=0, fetch=1+ Projection: Int64(20) AS value+ EmptyRelation: rows=1+SELECT 20 AS value OFFSET $1+** Initial Plan:+Limit: skip=$1, fetch=None+ Projection: Int64(20) AS value+ EmptyRelation: rows=1+** Final Plan:+Limit: skip=1, fetch=None+ Projection: Int64(20) AS value+ EmptyRelation: rows=1+SELECT $1 AS value LIMIT $1+** Initial Plan:+Limit: skip=0, fetch=$1+ Projection: $1 AS value+ EmptyRelation: rows=1+** Final Plan:+Limit: skip=0, fetch=1+ Projection: Int64(1) AS value+ EmptyRelation: rows=1+SELECT $1 AS value FROM (VALUES (0), (0)) AS t(dummy) OFFSET $1+** Initial Plan:+Limit: skip=$1, fetch=None+ Projection: $1 AS value+ SubqueryAlias: t+ Projection: column1 AS dummy+ Values: (Int64(0)), (Int64(0))+** Final Plan:+Limit: skip=1, fetch=None+ Projection: Int64(1) AS value+ SubqueryAlias: t+ Projection: column1 AS dummy+ Values: (Int64(0)), (Int64(0))+SELECT value FROM (SELECT 20 AS value LIMIT $1) AS t+** Initial Plan:+Projection: t.value+ SubqueryAlias: t+ Limit: skip=0, fetch=$1+ Projection: Int64(20) AS value+ EmptyRelation: rows=1+** Final Plan:+Projection: t.value+ SubqueryAlias: t+ Limit: skip=0, fetch=1+ Projection: Int64(20) AS value+ EmptyRelation: rows=1+SELECT (SELECT value FROM (VALUES (10), (20)) AS t(value) ORDER BY value LIMIT $1) AS value+** Initial Plan:+Projection: (<subquery>) AS value+ Subquery:+ Limit: skip=0, fetch=$1+ Sort: t.value ASC NULLS LAST+ Projection: t.value+ SubqueryAlias: t+ Projection: column1 AS value+ Values: (Int64(10)), (Int64(20))+ EmptyRelation: rows=1+** Final Plan:+Projection: (<subquery>) AS value+ Subquery:+ Limit: skip=0, fetch=1+ Sort: t.value ASC NULLS LAST+ Projection: t.value+ SubqueryAlias: t+ Projection: column1 AS value+ Values: (Int64(10)), (Int64(20))+ EmptyRelation: rows=1+SELECT 20 AS value WHERE EXISTS (SELECT value FROM (VALUES (10), (20)) AS t(value) OFFSET $1)+** Initial Plan:+Projection: Int64(20) AS value+ Filter: EXISTS (<subquery>)+ Subquery:+ Limit: skip=$1, fetch=None+ Projection: t.value+ SubqueryAlias: t+ Projection: column1 AS value+ Values: (Int64(10)), (Int64(20))+ EmptyRelation: rows=1+** Final Plan:+Projection: Int64(20) AS value+ Filter: EXISTS (<subquery>)+ Subquery:+ Limit: skip=1, fetch=None+ Projection: t.value+ SubqueryAlias: t+ Projection: column1 AS value+ Values: (Int64(10)), (Int64(20))+ EmptyRelation: rows=1+** Initial Plan:+Limit: skip=0, fetch=$1+ Projection: $1 + CAST(Int64(1) AS Int32) AS value+ SubqueryAlias: t+ Projection: $1+ EmptyRelation: rows=1+** Final Plan:+Limit: skip=0, fetch=Int32(1)+ Projection: Int32(1) + CAST(Int64(1) AS Int32) AS value+ SubqueryAlias: t+ Projection: Int32(1) AS $1+ EmptyRelation: rows=1diff --git a/datafusion/sql/tests/cases/snapshots/sql_integration__cases__params__limit_offset_parameters_keep_field_metadata.snap b/datafusion/sql/tests/cases/snapshots/sql_integration__cases__params__limit_offset_parameters_keep_field_metadata.snapnew file mode 100644index 0000000000..3be40e4451--- /dev/null+++ b/datafusion/sql/tests/cases/snapshots/sql_integration__cases__params__limit_offset_parameters_keep_field_metadata.snap@@ -0,0 +1,24 @@+---+source: datafusion/sql/tests/cases/params.rs+expression: "plans.join(\"\\n\")"+---+** Initial Plan:+Limit: skip=0, fetch=$1+ Projection: $1 AS value+ Filter: string_with_extension.value = $1+ TableScan: string_with_extension+** Final Plan:+Limit: skip=0, fetch=Utf8("1") FieldMetadata { inner: {"ARROW:extension:name": "example.string"} }+ Projection: Utf8("1") FieldMetadata { inner: {"ARROW:extension:name": "example.string"} } AS value+ Filter: string_with_extension.value = Utf8("1") FieldMetadata { inner: {"ARROW:extension:name": "example.string"} }+ TableScan: string_with_extension+** Initial Plan:+Limit: skip=$1, fetch=None+ Projection: $1 AS value+ Filter: string_with_extension.value = $1+ TableScan: string_with_extension+** Final Plan:+Limit: skip=Utf8("1") FieldMetadata { inner: {"ARROW:extension:name": "example.string"} }, fetch=None+ Projection: Utf8("1") FieldMetadata { inner: {"ARROW:extension:name": "example.string"} } AS value+ Filter: string_with_extension.value = Utf8("1") FieldMetadata { inner: {"ARROW:extension:name": "example.string"} }+ TableScan: string_with_extensiondiff --git a/datafusion/sql/tests/cases/snapshots/sql_integration__cases__params__limit_offset_parameters_leave_cast_inputs_unresolved.snap b/datafusion/sql/tests/cases/snapshots/sql_integration__cases__params__limit_offset_parameters_leave_cast_inputs_unresolved.snapnew file mode 100644index 0000000000..86ab25e91d--- /dev/null+++ b/datafusion/sql/tests/cases/snapshots/sql_integration__cases__params__limit_offset_parameters_leave_cast_inputs_unresolved.snap@@ -0,0 +1,55 @@+---+source: datafusion/sql/tests/cases/params.rs+expression: "plans.join(\"\\n\")"+---+SELECT $1 AS value+** Initial Plan:+Projection: $1 AS value+ EmptyRelation: rows=1+** Final Plan:+Projection: Utf8("1") AS value+ EmptyRelation: rows=1+SELECT $1 AS value LIMIT CAST($1 AS INT)+** Initial Plan:+Limit: skip=0, fetch=CAST($1 AS Int32)+ Projection: $1 AS value+ EmptyRelation: rows=1+** Final Plan:+Limit: skip=0, fetch=CAST(Utf8("1") AS Int32)+ Projection: Utf8("1") AS value+ EmptyRelation: rows=1+SELECT $1 AS value LIMIT CAST($1 AS BIGINT)+** Initial Plan:+Limit: skip=0, fetch=CAST($1 AS Int64)+ Projection: $1 AS value+ EmptyRelation: rows=1+** Final Plan:+Limit: skip=0, fetch=CAST(Utf8("1") AS Int64)+ Projection: Utf8("1") AS value+ EmptyRelation: rows=1+SELECT $1 AS value FROM (VALUES (1), (2)) AS t(v) OFFSET CAST($1 AS BIGINT)+** Initial Plan:+Limit: skip=CAST($1 AS Int64), fetch=None+ Projection: $1 AS value+ SubqueryAlias: t+ Projection: column1 AS v+ Values: (Int64(1)), (Int64(2))+** Final Plan:+Limit: skip=CAST(Utf8("1") AS Int64), fetch=None+ Projection: Utf8("1") AS value+ SubqueryAlias: t+ Projection: column1 AS v+ Values: (Int64(1)), (Int64(2))+SELECT $1 AS value FROM (SELECT 1 LIMIT CAST($1 AS BIGINT)) AS t+** Initial Plan:+Projection: $1 AS value+ SubqueryAlias: t+ Limit: skip=0, fetch=CAST($1 AS Int64)+ Projection: Int64(1)+ EmptyRelation: rows=1+** Final Plan:+Projection: Utf8("1") AS value+ SubqueryAlias: t+ Limit: skip=0, fetch=CAST(Utf8("1") AS Int64)+ Projection: Int64(1)+ EmptyRelation: rows=1diff --git a/datafusion/sqllogictest/test_files/prepare.slt b/datafusion/sqllogictest/test_files/prepare.sltindex 108b023ccf..00abf742b7 100644--- a/datafusion/sqllogictest/test_files/prepare.slt+++ b/datafusion/sqllogictest/test_files/prepare.slt@@ -19,6 +19,182 @@## Prepare Statement Tests##########+statement ok+PREPARE page AS SELECT value FROM (VALUES (10), (20), (30)) AS t(value) ORDER BY value LIMIT $1 OFFSET $2;++query I+EXECUTE page(1, 1);+----+20++statement ok+DEALLOCATE page;++statement ok+PREPARE page AS SELECT 20 AS value LIMIT $1;++query I+EXECUTE page(1);+----+20++statement ok+DEALLOCATE page;++statement ok+PREPARE page AS SELECT value FROM (VALUES (10), (20)) AS t(value) ORDER BY value OFFSET $1;++query I+EXECUTE page(1);+----+20++statement ok+DEALLOCATE page;++statement ok+PREPARE page AS SELECT $1 AS value LIMIT $1;++query I+EXECUTE page(1);+----+1++statement ok+DEALLOCATE page;++statement ok+PREPARE page AS SELECT $1 AS value FROM (VALUES (0), (0)) AS t(dummy) OFFSET $1;++query I+EXECUTE page(1);+----+1++statement ok+DEALLOCATE page;++statement ok+PREPARE page AS SELECT value FROM (SELECT 20 AS value LIMIT $1) AS t;++query I+EXECUTE page(1);+----+20++statement ok+DEALLOCATE page;++statement ok+PREPARE page AS SELECT (SELECT value FROM (VALUES (10), (20)) AS t(value) ORDER BY value LIMIT $1) AS value;++query I+EXECUTE page(1);+----+10++statement ok+DEALLOCATE page;++statement ok+PREPARE page AS SELECT 20 AS value WHERE EXISTS (SELECT value FROM (VALUES (10), (20)) AS t(value) OFFSET $1);++query I+EXECUTE page(1);+----+20++statement ok+DEALLOCATE page;++statement ok+PREPARE page AS SELECT $1 AS value LIMIT CAST($1 AS INT);++query T+EXECUTE page('1');+----+1++statement ok+DEALLOCATE page;++statement ok+PREPARE page AS SELECT $1 AS value LIMIT CAST($1 AS BIGINT);++query T+EXECUTE page('1');+----+1++statement ok+DEALLOCATE page;++statement ok+PREPARE page AS SELECT $1 AS value FROM (VALUES (1), (2)) AS t(v) OFFSET CAST($1 AS BIGINT);++query T+EXECUTE page('1');+----+1++statement ok+DEALLOCATE page;++statement ok+PREPARE page AS SELECT $1 AS value FROM (SELECT 1 LIMIT CAST($1 AS BIGINT)) AS t;++query T+EXECUTE page('1');+----+1++statement ok+DEALLOCATE page;++statement ok+PREPARE page AS SELECT $1 + CAST(1 AS INT) AS value FROM (SELECT $1) AS t LIMIT $1;++query I+EXECUTE page(1);+----+2++statement ok+DEALLOCATE page;++statement ok+PREPARE page AS SELECT $1 + CAST(1 AS INT) AS value LIMIT $1;++query I+EXECUTE page(1);+----+2++statement ok+DEALLOCATE page;++statement ok+PREPARE page AS SELECT $1 AS value LIMIT $2;++query T+EXECUTE page('row', 1);+----+row++statement ok+DEALLOCATE page;++statement ok+PREPARE page AS SELECT $1 AS value FROM (VALUES (0), (0)) AS t(dummy) OFFSET $2;++query T+EXECUTE page('row', 1);+----+row++statement ok+DEALLOCATE page;+statement okcreate table person (id int, first_name varchar, last_name varchar, age int, state varchar, salary double, birthday timestamp, "😀" int) as values (1, 'jane', 'smith', 20, 'MA', 100000.45, '2000-11-12T00:00:00'::timestamp, 99);@@ -379,6 +555,28 @@ EXECUTE get_N_rand_ints_from_last_run(2);statement okDEALLOCATE get_N_rand_ints_from_last_run;+statement ok+PREPARE limit_after_typed_filter AS SELECT id FROM test WHERE id = $1 LIMIT $2;++query I+EXECUTE limit_after_typed_filter(1, 1);+----+1++statement ok+DEALLOCATE limit_after_typed_filter;++statement ok+PREPARE limit_after_inferred_int32 AS SELECT $1 + CAST(1 AS INT) AS value LIMIT $1;++query I+EXECUTE limit_after_inferred_int32(1);+----+2++statement ok+DEALLOCATE limit_after_inferred_int32;+statement okDROP TABLE test;