feat(python/sedonadb): add DataFrame.intersect, intersect_distinct, except_

[jiayuasu]

Completes the relational set-op family on the Python DataFrame, after distinct/distinct_on (#961) and union/union_distinct (#965).

API

a.intersect(b)            # rows in both, multiset      (SQL INTERSECT ALL)
a.intersect_distinct(b)   # distinct rows in both       (SQL INTERSECT)
a.except_(b)              # distinct rows in a not in b (SQL EXCEPT)

• intersect preserves multiplicity; intersect_distinct de-duplicates.
• except_ uses a trailing underscore to avoid Python's except keyword (matching DuckDB's Python relational API).
• All three require the two inputs to have the same column names in the same order (shared _check_set_op_compatible guard, generalized from the union-only helper introduced in feat(python/sedonadb): add DataFrame.union and union_distinct #965), so a positional set op can't silently misalign differently-named columns. A positional combination of differently-named columns is opt-in: align names first with select.

Why no except_distinct

DataFusion's EXCEPT ALL does not preserve multiplicity — [1,1,1] EXCEPT ALL [1] returns [] (verified, including via raw SQL), the same result as EXCEPT. So a separate ALL/distinct pair for except would be two public methods that behave identically today. except_ therefore exposes the distinct semantics only (wired to DataFusion's except_distinct), documented as such. An except_all can be added if/when the engine gains multiplicity-preserving EXCEPT ALL.

(For intersect, INTERSECT ALL does work, so both variants are kept.)

Implementation

File	Change
python/sedonadb/src/dataframe.rs	InternalDataFrame::intersect / intersect_distinct / except_ — thin wrappers over DataFusion's intersect / intersect_distinct / except_distinct.
python/sedonadb/python/sedonadb/dataframe.py	DataFrame.intersect / intersect_distinct / except_; _check_union_compatible renamed to _check_set_op_compatible and reused by all set ops (union included).

Test plan

tests/expr/test_dataframe_set_ops.py:

• intersect preserves multiplicity; intersect_distinct dedupes; multi-column intersect.
• except_ distinct difference; multi-column except.
• Lazy return for all three.
• Parametrized over the three methods: different-column-names raises; non-DataFrame argument raises.

Local: full set-op + union suite + 31 doctests + expr suite + ruff + cargo fmt --check + clippy -Dwarnings all clean.

[Copilot]

Pull request overview

This PR completes the Python DataFrame relational set-operation surface by adding intersect, intersect_distinct, and except_, implemented as thin wrappers over the underlying DataFusion set-op APIs and guarded by a shared compatibility check to prevent accidental positional misalignment.

Changes:

• Add DataFrame.intersect, DataFrame.intersect_distinct, and DataFrame.except_ to the Python API with docstrings and input validation.
• Extend the Rust InternalDataFrame pyclass with corresponding set-op methods.
• Add a dedicated pytest suite covering semantics (multiplicity vs distinct), multi-column behavior, laziness, and argument/compatibility errors.

Reviewed changes

Copilot reviewed 3 out of 3 changed files in this pull request and generated 1 comment.

File	Description
python/sedonadb/src/dataframe.rs	Adds Rust-side InternalDataFrame wrappers for intersect/intersect_distinct/except_ via DataFusion.
python/sedonadb/python/sedonadb/dataframe.py	Adds the new Python DataFrame methods and generalizes the set-op compatibility guard used by union/intersect/except.
python/sedonadb/tests/expr/test_dataframe_set_ops.py	Introduces coverage for intersect/except semantics and error handling.

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.