test: improve binder and operator coverage

Author: KKould

src/binder/select.rs

@@ -2280,6 +2280,25 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn test_select_bind_reports_set_alias_join_and_subquery_errors() -> Result<(), DatabaseError> {
+        let table_states = build_t1_table()?;
+        let invalid_queries = [
+            "select c1 from t1 union all select c3, c4 from t2",
+            "select * from t1 as aliased(only_one)",
+            "select * from t1 join t2 using (missing)",
+            "select exists(select c3 from t2) from t1",
+            "select * from t1 where c1 = (select c3 from t2 where c4 = c2)",
+            "select * from t1 where exists(select 1 from t2) and c1 = (select max(c3) from t2)",
+        ];
+
+        for sql in invalid_queries {
+            assert!(table_states.plan(sql).is_err(), "query should fail: {sql}");
+        }
+
+        Ok(())
+    }
+
     #[test]
     fn test_right_side_position_globalizer_only_shifts_right_columns() -> Result<(), DatabaseError>
     {

src/optimizer/rule/normalization/parameterized_index.rs

@@ -234,3 +234,144 @@ fn schema_contains_column(
         .iter()
         .any(|candidate| arena.same_column(*candidate, *column))
 }
+
+// GRCOV_EXCL_START
+#[cfg(all(test, not(target_arch = "wasm32")))]
+mod tests {
+    use super::*;
+    use crate::catalog::{ColumnCatalog, ColumnDesc};
+    use crate::optimizer::core::rule::NormalizationRule;
+    use crate::planner::operator::filter::FilterOperator;
+    use crate::planner::{PlanArena, TableArenaCell};
+    use crate::types::LogicalType;
+
+    fn column(arena: &mut PlanArena, name: &str) -> ColumnRef {
+        arena.alloc_column(ColumnCatalog::new(
+            name.to_string(),
+            true,
+            ColumnDesc::new(LogicalType::Integer, None, false, None).unwrap(),
+        ))
+    }
+
+    fn eq(left: ScalarExpression, right: ScalarExpression) -> ScalarExpression {
+        ScalarExpression::Binary {
+            op: BinaryOperator::Eq,
+            left_expr: Box::new(left),
+            right_expr: Box::new(right),
+            evaluator: None,
+            ty: LogicalType::Boolean,
+        }
+    }
+
+    #[test]
+    fn probe_detection_covers_quantifiers_and_rejected_sides() -> Result<(), DatabaseError> {
+        let table_arena = TableArenaCell::default();
+        let mut arena = PlanArena::new(&table_arena);
+        let left = column(&mut arena, "left");
+        let right = column(&mut arena, "right");
+        let outside = column(&mut arena, "outside");
+        let left_schema = vec![left];
+        let right_schema = vec![right];
+        let overlapping_schema = vec![left, right];
+
+        assert!(find_parameterized_probe(
+            MarkApplyKind::Quantified(MarkApplyQuantifier::Any),
+            &[],
+            &left_schema,
+            &right_schema,
+            &arena,
+        )?
+        .is_none());
+        assert!(find_parameterized_probe(
+            MarkApplyKind::Quantified(MarkApplyQuantifier::All),
+            &[eq(
+                ScalarExpression::column_expr(right, 0),
+                ScalarExpression::column_expr(left, 0),
+            )],
+            &left_schema,
+            &right_schema,
+            &arena,
+        )?
+        .is_none());
+
+        let predicates = vec![
+            ScalarExpression::from(true),
+            eq(
+                ScalarExpression::column_expr(right, 0),
+                ScalarExpression::column_expr(left, 0),
+            ),
+        ];
+        let probe = find_parameterized_probe(
+            MarkApplyKind::Exists,
+            &predicates,
+            &left_schema,
+            &right_schema,
+            &arena,
+        )?
+        .expect("right = left should be parameterizable");
+        assert_eq!(probe.0, right);
+
+        assert!(extract_parameterized_probe(
+            &eq(
+                ScalarExpression::column_expr(right, 0),
+                ScalarExpression::column_expr(outside, 0),
+            ),
+            &left_schema,
+            &right_schema,
+            &arena,
+        )?
+        .is_none());
+        assert!(extract_parameterized_probe(
+            &eq(
+                ScalarExpression::column_expr(right, 0),
+                ScalarExpression::column_expr(right, 0),
+            ),
+            &overlapping_schema,
+            &right_schema,
+            &arena,
+        )?
+        .is_none());
+        assert!(extract_parameterized_probe(
+            &ScalarExpression::from(false),
+            &left_schema,
+            &right_schema,
+            &arena,
+        )?
+        .is_none());
+
+        Ok(())
+    }
+
+    #[test]
+    fn parameterization_rejects_unsupported_operator_and_child_shapes() -> Result<(), DatabaseError>
+    {
+        let table_arena = TableArenaCell::default();
+        let mut arena = PlanArena::new(&table_arena);
+        let column = column(&mut arena, "value");
+        let mut plan = LogicalPlan::new(Operator::Dummy, Childrens::None);
+
+        assert!(!ParameterizeMarkApply.apply(&mut plan, &mut arena)?);
+        assert!(!parameterize_right_subtree(&mut plan, &column, &arena));
+
+        let mut filter = LogicalPlan::new(
+            Operator::Filter(FilterOperator {
+                predicate: ScalarExpression::from(true),
+                is_optimized: false,
+                having: false,
+            }),
+            Childrens::None,
+        );
+        assert!(!parameterize_right_subtree(&mut filter, &column, &arena));
+
+        assert_eq!(
+            index_priority(IndexType::PrimaryKey { is_multiple: false }),
+            0
+        );
+        assert_eq!(index_priority(IndexType::Unique), 1);
+        assert_eq!(index_priority(IndexType::Composite), 2);
+        assert_eq!(index_priority(IndexType::Normal), 3);
+
+        Ok(())
+    }
+}
+// GRCOV_EXCL_STOP

src/planner/operator/mod.rs

@@ -667,6 +667,11 @@ mod tests {
             PlanImpl::IndexScan(Box::new(index_info())).to_string(),
             "IndexScan By #4 => EMPTY"
         );
+        #[cfg(feature = "copy")]
+        {
+            assert_eq!(PlanImpl::CopyFromFile.to_string(), "CopyFromFile");
+            assert_eq!(PlanImpl::CopyToFile.to_string(), "CopyToFile");
+        }
     }
 
     #[test]
@@ -749,6 +754,48 @@ mod tests {
         });
         assert_eq!(referenced_columns(&update, &mut arena)?, vec![a]);
 
+        let add_column = Operator::AddColumn(AddColumnOperator {
+            table_name: "users".into(),
+            if_not_exists: false,
+            column: ColumnCatalog::new(
+                "added".to_string(),
+                true,
+                ColumnDesc::new(
+                    LogicalType::Integer,
+                    None,
+                    false,
+                    Some(ScalarExpression::from(1_i32)),
+                )?,
+            ),
+        });
+        assert!(referenced_columns(&add_column, &mut arena)?.is_empty());
+
+        let change_column = Operator::ChangeColumn(ChangeColumnOperator {
+            table_name: "users".into(),
+            old_column_name: "old".to_string(),
+            new_column_name: "new".to_string(),
+            data_type: LogicalType::Integer,
+            default_change: DefaultChange::Set(column_expr(b, 1)),
+            not_null_change: NotNullChange::NoChange,
+        });
+        assert_eq!(referenced_columns(&change_column, &mut arena)?, vec![b]);
+
+        let create_table = Operator::CreateTable(CreateTableOperator {
+            table_name: "created".into(),
+            columns: vec![ColumnCatalog::new(
+                "value".to_string(),
+                true,
+                ColumnDesc::new(
+                    LogicalType::Integer,
+                    None,
+                    false,
+                    Some(ScalarExpression::from(2_i32)),
+                )?,
+            )],
+            if_not_exists: false,
+        });
+        assert!(referenced_columns(&create_table, &mut arena)?.is_empty());
+
         let table_scan = Operator::TableScan(TableScanOperator {
             table_name: "users".into(),
             columns: vec![a, d],
@@ -1134,7 +1181,7 @@ mod tests {
 
     #[cfg(feature = "copy")]
     #[test]
-    fn copy_from_file_display_formats_source_table_and_schema() {
+    fn copy_display_formats_source_target_table_and_schema() {
         use crate::binder::copy::{ExtSource, FileFormat};
         use std::path::PathBuf;
 
@@ -1161,6 +1208,21 @@ mod tests {
             operator.to_string(),
             "Copy /tmp/users.csv -> users [#0, #1]"
         );
+        assert_eq!(
+            Operator::CopyToFile(CopyToFileOperator {
+                target: ExtSource {
+                    path: PathBuf::from("/tmp/output.csv"),
+                    format: FileFormat::Csv {
+                        delimiter: ',',
+                        quote: '"',
+                        escape: None,
+                        header: false,
+                    },
+                },
+            })
+            .to_string(),
+            "Copy To /tmp/output.csv"
+        );
     }
 }
 // GRCOV_EXCL_STOP