Skip to content

refactor(types, frontends): column lineage replaces table qualifiers (#1207 PR 2b) - #1233

Merged
zzylol merged 5 commits into
mainfrom
refactor/1207-lineage
Nov 11, 2026
Merged

zzylol merged 5 commits into
mainfrom
refactor/1207-lineage

Conversation

@zzylol

@zzylol zzylol commented Nov 6, 2026 •

Copy link
Copy Markdown
Contributor

Summary

  • Problem: schema fields carried a table qualifier (Field::table) that every operator rule had to keep right; aggregate coverage named a column by (table, name) (ColumnIdentity), so a rename made one source column look like two, and Memo::add_candidate's exact schema compare rejected a readout renamed to an aggregate's column because its qualifier differed.
  • Change: a group property GroupProperties::column_lineage (each output column's SourceColumn { source, scan_ordinal, column }, or Computed { group, column }, the memo group and column that computed it) replaces the qualifier, derived with column_signs from main's one per-operator column layout, a memo-scope property beside ValueSign; the memo's coverage derivation reads each input group's stored lineage and keys selections by SourceColumn; fields lose table, the IR Project loses qualifier; front ends bind f.src with their own scope while they lower.
  • Effect: for SELECT f.src, approx_distinct(f.dst) FROM flows f WHERE f.proto = 'tcp' GROUP BY f.src, the aggregate, the HLL state and its readout each have lineage [flows.src, Computed by that group at column 1], the state's selection is { flows.proto ∈ {tcp} }, and the readout renamed to the aggregate's columns is accepted as the aggregate group's candidate (rejected before by qualifier).

Review guide

Behavior: before → after

The SQL query above, through Stage 0 and the Pass 1 candidate it needs (an_hll_readout_renamed_to_the_aggregate_column_is_its_candidate). It serves the design need of the concepts doc, section 3, "Column lineage": a column's identity across groups that survives renames and keeps a join's two regions apart.

Before (main) After (this PR)
Column identity Field::table per field, kept by every rule plus two patches column_lineage per group: [flows.src, flows.dst, flows.proto, flows.ts] (scan 0) for the scan, [flows.src, Computed { group, column: 1 }] for aggregate, state and readout, each its own group
FROM flows a JOIN flows b … WHERE a.proto = 'tcp' (a, proto): keyed by alias (flows, 0, proto); b.proto is (flows, 1, proto); renaming the aliases keeps the key
a * on(job) group_left(team) b, a with its own team team keeps a.team team is b.team with b's sign (PromQL overwrites it); group_right(team) takes a.team
SELECT source … FROM (SELECT f.src AS source FROM flows f) vs GROUP BY f.src (none, source) vs (f, src): two columns both flows.src
A selection on a computed column (rate(m[5m]) > 0) lifted as value ∈ (0, ∞) stays in unlifted_operators
Readout renamed to the aggregate's columns add_candidate rejects it (qualifier differs) accepted (strict compare unchanged)
Schema JSON fields carry "table" no "table" key; older plan files still deserialize

Interfaces

Against main 99356a314. crates/types/src/ir/operator/arguments.rs · crates/types/src/stages/logical/column_properties.rs · crates/types/src/stages/logical/group.rs · crates/types/src/ir/properties/selection.rs · crates/types/src/ir/schema/mod.rs · crates/types/src/ir/operator/non_asap.rs · crates/planner/src/lib.rs

+// ir/operator/arguments.rs, below `impl Source`
+pub struct SourceColumn {   // Ord, serde {source, scan_ordinal, column}
+    pub source: Source,
+    /// Which scan of `source`: 0 for the first, counted left to right
+    /// across joins (a self-join's right side is 1).
+    pub scan_ordinal: u32,
+    pub column: String,
+}
+// stages/logical/column_properties.rs, beside ValueSign; asap_types::stages::ColumnLineage
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum ColumnLineage {
+    /// Copied unchanged from a column of one scan of a source.
+    SourceColumn(SourceColumn),
+    /// Column `column` of memo group `group`, where it was computed.
+    Computed { group: MemoGroupId, column: ColumnId },
+}
 pub struct GroupProperties {
     pub schema: Schema,
     pub result_kind: OperatorResultKind,
+    pub column_lineage: Vec<ColumnLineage>,
     pub column_signs: Vec<ValueSign>,
     …
 }
-pub(super) fn column_signs(operator, output, source_facts) -> Vec<ValueSign>;
+pub(super) fn column_lineage_and_signs(group: MemoGroupId, operator, output, source_facts) -> (Vec<ColumnLineage>, Vec<ValueSign>);
+/// None: computed by the group being derived.
+pub(super) fn project_lineage<C>(cols: &[ProjectItem<C>], input: &[Option<ColumnLineage>]) -> Vec<Option<ColumnLineage>>;
-pub(super) fn derive_group_properties(memo, expression) -> Result<GroupProperties, MemoGroupError>;
+pub(super) fn derive_group_properties(memo, group: MemoGroupId, expression) -> Result<GroupProperties, MemoGroupError>;
 // validate_expression_over_input_groups(operator), aggregate_coverage(operator): unchanged
 pub struct SelectionBox {
-    pub(crate) columns: BTreeMap<ColumnIdentity, Constraint>,
+    pub(crate) columns: BTreeMap<SourceColumn, Constraint>,
 }
-pub struct ColumnIdentity { pub(crate) table: Option<String>, pub(crate) name: String }
 pub struct Field<T = FieldDataType> {
     pub name: String, pub dtype: T, pub nullable: bool,
-    pub table: Option<String>,
 }
-impl<T> Field<T> { pub fn with_table(self, table: impl Into<String>) -> Self; }
-impl Schema { pub(crate) fn column_id_qualified(&self, table: &str, name: &str) -> Option<ColumnId>; }
-NonASAPOp::Project { cols, qualifier: Option<String>, child }
+NonASAPOp::Project { cols, child }
+pub(crate) fn topk_output_name(k: usize, output_names: &[String]) -> String;   // ir/schema/topk.rs
-pub use asap_types::ir::properties::selection::ColumnIdentity;   // planner facade
-pub fn resolve_column_refs(cols: &[ColumnRef], schema: &Schema) -> Result<Vec<ColumnId>, ResolveError>;   // unused
+// test_support::memo_fixtures
+pub fn series_column(metric: &str, scan_ordinal: u32, column: &str) -> SourceColumn;
+pub fn table_column(table: &str, scan_ordinal: u32, column: &str) -> SourceColumn;

OperatorInput is unchanged: no lineage accessor. Front ends: UnresolvedOp::Scan::qualifier: Option<String> and the resolver's private Scope / Bound (frontend-common); resolve_column_ref ignores a qualifier (ColumnRef::Qualified { name, .. } resolves by name; the front end binds the qualifier first). Scope::resolve binds t.c to the column qualified t, else to the unique c whose qualifier is not known, never to a c qualified by another table; Bound stores one qualifier per column (None when unqualified; no empty-list sentinel) and Bound::new debug_assert!s it; an aggregate whose measures add label columns (count_values, absent) or a top-k is unqualified at its call site, sized by its node's schema.

Algorithm changes

One column layout for lineage and sign

  • Problem: lineage needs the same per-operator column layout as column_signs; a second layout could disagree.
  • After: column_lineage_and_signs matches the operator once and returns a ColumnProperties { lineage, sign } per output column, then splits it into column_lineage and column_signs. It reuses main's layout: aggregate_output and summary_agg_layout give each output column's OutputColumnSource (InputColumn copied with its lineage and sign; Measure computed with measure_sign; AddedLabel computed, Unknown). A Scan gives SourceColumn { source: its Source, scan_ordinal: 0, column: field name } with its declared sign (still keyed by source name and column, SourceFacts); Filter, Sort, Limit, Dedup, TimeRange, TimeShift and the row-selecting PromQL operators pass their input's columns; a Project column item copies its input column, an expression item is Computed by the group with expression_sign (project_lineage, also used by lineage_at_top); a chain is its build's layout without the build's time column, after a computed window_end; the SummaryMerge of a chain's selected windows has the chain build's layout; a readout copies its state's plain columns; a Join concatenates, shifting the right side's scan ordinals of a source the left also scans past the left's (after_left_scans; Semi/Anti keep the left only); SetOp, Concat and a SummaryMerge keep what their inputs agree on, a column they disagree on is computed by the group (a regrouping SummaryMerge's state is always computed by it); a BinaryOp takes its labels from the output side, the left for one-to-one and group_left, the right ("many") side for group_right (a matched label has equal values on both sides, so the output side's lineage and sign), and for or what both sides agree on; it computes the value with main's sign rules (arithmetic_sign, …), copies the labels the match adds from the right side, and gives a label group_left(...) names the right ("one") side's lineage and sign, one group_right(...) names the left side's, overwriting a column of that name in place. A BinaryOp does not concatenate both sides' columns, so it shifts no scan ordinal: in rate(x[5m]) / rate(x[1h]) job stays (x, 0, job). A column the group computes is Computed { group: its id, column: its output index }: find_or_add_group passes the new group's id (MemoGroupId(groups.len())) to derive_group_properties.
  • Correctness: one entry per output column (debug_assert_eq!); two columns have equal lineage only when they hold the same values (the same column of the same scan, or the same computation); main's sign tests (memo_group_properties.rs, Stage 0's a_scan_reads_the_declared_column_signs) pass unchanged.
  • Complexity: derived once per group, O(columns).

Aggregate coverage: which conjuncts are lifted

  • Problem: selections named columns by (table, name); a rename made one source column two, and a conjunct on a computed column (a rate value) was lifted although no source column names it.
  • Before / after: 1. Collect the conjuncts the walk can lift (residual). 2. Before: lift one when it is a value set or interval on one column whose (table, name) is unique in the aggregate's input; after: whose lineage is a SourceColumn unique among the input's columns (source_column). 3. Key the selection by that source column. The aggregate input's lineage is the stored column_lineage of the group below the liftable chain (read through MemoGroupAsInput), carried up through the chain (lineage_at_top: Filter/TimeRange/TimeShift keep it, a Project follows project_lineage, its expression items None: computed, never a selection key), so a rule's temporary build needs no lineage of its own. regrouped maps each key to the build input's column of equal lineage (a computed key matches only the same group and column); the timestamp column a DisjointInTime merge and a window selection constrain is named by its lineage.
  • Correctness: a source column's lineage is the same in every group whose column copies it, so two selections on one lineage constrain the same values; distinct lineages are distinct source columns (a join's two regions, a self-join's two scans). A Computed column stays in the definition. Tests: types/tests/column_lineage.rs, memo_aggregate_coverage.rs.
  • Complexity: O(columns) per conjunct, as before.
  • Assumptions and limits: rate(m[5m]) > 0 no longer lifts value ∈ (0, ∞). A top-k readout's and a population evaluation's columns are Computed.

Front-end binding of qualified names

  • After: resolve returns a private Bound { node, qualifiers }. Qualified references resolve in a Scope { schema, qualifiers }: the column with that qualifier and name, else the unique column of that name whose qualifier is not known; a column qualified by another table never matches (before: any unique name). A Scan has its own qualifier (the SQL frontend sets UnresolvedOp::Scan::qualifier to the table or alias), a pass-through operator its input's, a Project its alias or none, an aggregate's by keys their input's, a Join left then right, a SetOp the left side's; PromQL operators have none.
  • Correctness: a_qualified_group_key_binds_its_join_side (frontend-sql), a_qualified_name_never_binds_another_tables_column (frontend-common).

Decisions and open questions

Needs reviewer decision: None.

Decided:

  • 2026-11-11 (review, approved): Computed lineage = memo group + column. ColumnLineage::Computed { group: MemoGroupId, column: ColumnId }; a passed-through column keeps its identity, a column the group computes (or its union-like inputs disagree on) is Computed by the group at its output index; the regroup key check stays an equality. Only column_lineage_and_signs (and derive_group_properties, which calls it) takes the group's id; elsewhere a computed column is None (project_lineage, lineage_at_top, source_column), which no selection names.
  • 2026-11-11 (review, approved): self-joins: scan_ordinal. SourceColumn { source, scan_ordinal, column }; a Scan is 0; only at a Join (column concatenation) do the right side's source columns of a source the left also has shift by the left's largest ordinal for it plus one; union-like operators and BinaryOp do not shift.
  • 2026-11-11 (review, approved): BinaryOp labels come from the output side: the left for one-to-one and group_left, the right ("many") side for group_right; matched labels have equal values on both sides, so the output side's lineage and sign. or keeps what both sides agree on. The namesakes check stays (Project [a AS k, a AS k2]).
  • 2026-11-11 (review, approved): match-grouping labels from the one side. group_left(labels) takes them from the right side, group_right(labels) from the left, lineage and sign, overwriting an existing column of that name in place. Supersedes the R4 entry's agreed-label rule for named labels.
  • 2026-11-11 (review, approved): one Project lineage rule (project_lineage) for project_columns and lineage_at_top; ColumnLineage drops Hash/serde, SourceColumn drops Hash; the two parallel Vecs on GroupProperties stay; a qualified name never binds another table's column; Bound::new asserts its qualifier count.
  • 2026-11-11 (review round 2, approved): group id threaded only to column_lineage_and_signs; Option lineage in coverage; ColumnProperties: Default; or makes a right-only label computed; resolver stores a qualifier per column; shared series_column / table_column fixtures; resolve_column_refs and the planner's SourceColumn re-export deleted (unused); stale qualifier docs removed.
  • 2026-11-10 (design change, approved): lineage is memo-scope, no OperatorInput accessor. Aggregate coverage is a memo-group property (refactor(types): aggregate coverage is a memo-group property: types and derivation in stages, no IR generic (#1207) #1273), so ColumnLineage lives beside ValueSign in stages/logical/column_properties.rs (ir/properties/column_lineage.rs is not added) and the memo's coverage derivation reads each input group's stored GroupProperties::column_lineage through MemoGroupAsInput; OperatorInput::column_lineage is not added. SourceColumn { source: Source, column } stays in ir/operator/arguments.rs beside Source; selection keys are SourceColumn and ColumnIdentity is deleted; lineage_at_top stays the rule, in the memo-scope derivation. This supersedes the ColumnLineage placement and the OperatorInput::column_lineage accessor of the entry below.
  • 2026-11-10 (restack design, approved): SourceColumn { source: Source, column: String } in ir/operator/arguments.rs beside Source (typed Source, not a name); ColumnLineage in ir/properties/column_lineage.rs with OperatorInput::column_lineage (both superseded by the entry above). The derivation stays memo-scope in stages/logical/column_properties.rs, with column_signs, over main's one layout (OutputColumnSource / summary_agg_layout; no second layout). GroupProperties::column_lineage: Vec<ColumnLineage>. Declared signs stay keyed by source name and column (SourceFacts), not by SourceColumn. This supersedes the 2026-11-09 entries that put ColumnLineage in stages and gave SourceColumn a String source.
  • 2026-11-10: coverage keys a selection's columns by SourceColumn lineage; ColumnIdentity deleted; the rules of the previous PR 2b carry over (a predicate on a Computed column, or on one of two columns of one lineage, is not lifted; the regrouping key check compares lineage).
  • 2026-11-07: UnresolvedOp::Scan::qualifier: Option<String>; ResolveError::Ambiguous message "matches several columns"; resolve_column_ref ignores a qualifier.
  • 2026-11-09 (R4): a BinaryOp's match-added labels carry their sign: copied from the right side's column with its lineage; for or / group_right, a left label keeps what both sides agree on. One layout copies lineage and sign together, so they cannot disagree. Example: in a * on(job) group_left(team) b, the last column team has lineage b.team and b's team sign.
  • Restack choices (2026-11-10): the aggregate input's lineage is carried up from the first input below the liftable chain (lineage_at_top) instead of deriving a temporary build's lineage; for a memo group it equals the group's stored lineage. (SourceColumn's Hash was dropped in review: nothing hashes it.) A BinaryOp's value column is Computed (also under a comparison filter), as before.

Deleted besides the interfaces above: requalification in OperatorNode::with_new_children and validate_structure (node.rs; only names may be overridden); private column_identity (→ source_column) and build_input_schema (→ build_input, the input for its schema and lineage); column_signs' sign-only helpers (signs_of, project_signs, aggregate_signs, signs_from_sources, state_signs, readout_signs, sign-only agreed) → their ColumnProperties versions; copies of the topk_{k} output-name rule → topk_output_name; unused resolve_column_refs and the planner facade's SourceColumn re-export; the test files' local lineage helpers (column_of, column_of_scan, source_column, latency_column, series_column) → memo_fixtures::series_column / table_column; tests qualified_field_serde_roundtrip and the qualified case of partitions_over_matches_keys_by_column.

Verification

cargo test --workspace --no-fail-fast at a6c1ffe51 and at main 99356a314 (temporary worktree), compared by test name: main 1140 passed / 189 failed / 9 ignored, this PR 1154 / 189 / 9. 0 newly failing; the 189 failures are the same tests on both (later PRs' todo!()s). +14 passing: the 15 new tests (types column_lineage: the six concepts-doc and chain tests, a_self_join_names_its_two_scans_apart, a_group_left_label_comes_from_the_right_side, a_group_left_label_overwrites_the_left_sides_column_of_that_name, a_group_right_label_comes_from_the_left_side, a_same_source_binary_op_keeps_its_labels_scan, a_same_source_group_right_takes_the_right_sides_labels, an_or_label_only_the_right_side_has_is_computed; frontend-sql a_qualified_group_key_binds_its_join_side; frontend-common a_qualified_name_never_binds_another_tables_column) minus the deleted qualified_field_serde_roundtrip. cargo fmt --all --check and cargo clippy --workspace --all-targets -- -D warnings clean; cargo doc --no-deps -p asap-types -p asap-frontend-common -p asap-planner reports the same six warnings as main (none in files this PR touches). Nothing under types/src/ir/ imports crate::stages.

scan_predicates_lift_and_their_states_merge (example 4, memo_aggregate_coverage.rs) also asserts latency.job.

Wire format: the exported Schema JSON has no "table" key on fields; a selection key serializes as {source, scan_ordinal, column} with source the Source enum (only in a materialized view's coverage). view_coverage's content id hashes the expanded definition, which holds no selection keys, so lineage does not enter it; the selection is a BTreeMap serialized in key order.

Design docs: pre-asap-ir.md and operator-sharing.md lose the stale Field.table / Project qualifier; asap-primitive-schema.md §2's table, §4.2.2 (worked example and "Which column a condition is on") and the Field, Schema, SelectionBox and SourceColumn listings use lineage; §6.6 names ColumnLineage in stages/logical/column_properties.rs and SourceColumn in ir/operator/arguments.rs; scan ordinals and Computed { group, column } are described in §2, §4.2.2 and §6.6; the concepts-doc reference is plain text (the file is not on main).

Follow-ups

@zzylol zzylol added ir Pre-ASAP or post-ASAP intermediate representation refactor schema Schema, type, key, and nullability contracts labels Nov 6, 2026
@zzylol
zzylol force-pushed the refactor/1207-memo branch 3 times, most recently from fe0ff33 to 8095a51 Compare November 9, 2026 04:40
@zzylol
zzylol force-pushed the refactor/1207-lineage branch from e2b5456 to 58549f2 Compare November 9, 2026 06:16
@zzylol
zzylol force-pushed the refactor/1207-memo branch from 8095a51 to 49a145c Compare November 9, 2026 16:33
@zzylol
zzylol force-pushed the refactor/1207-lineage branch from 58549f2 to b3655e1 Compare November 9, 2026 16:50
@zzylol
zzylol force-pushed the refactor/1207-memo branch from 49a145c to 43f81fe Compare November 10, 2026 01:26
@zzylol
zzylol force-pushed the refactor/1207-lineage branch from b3655e1 to 0479df3 Compare November 10, 2026 01:26
@zzylol
zzylol force-pushed the refactor/1207-memo branch from 43f81fe to 36312cb Compare November 10, 2026 13:37
@zzylol
zzylol force-pushed the refactor/1207-lineage branch from 0479df3 to 50686ae Compare November 10, 2026 13:37
@zzylol
zzylol force-pushed the refactor/1207-memo branch from 36312cb to 77fc121 Compare November 10, 2026 16:28
@zzylol
zzylol changed the base branch from refactor/1207-memo to main November 10, 2026 21:15
@zzylol
zzylol force-pushed the refactor/1207-lineage branch from 50686ae to a6eca31 Compare November 10, 2026 21:37
…1207 PR 2b)

GroupProperties gains column_lineage (one ColumnLineage per output column,
derived once from the input groups'). Lineage and column_signs are
derived together in stages/logical/column_properties.rs by main's one
per-operator column layout (aggregate_output / summary_agg_layout and
OutputColumnSource): a copied column keeps its lineage and sign, a
computed one is Computed with the operator's sign rule. Chains compute
window_end and their state and keep their keys' lineage; a TimeRange or
TimeShift over a chain, and TimeShift { at: End | Start } above a
selector, pass lineage through; a merge of a chain's selected windows has
the chain build's layout; a label of `or` or group_right keeps what both
sides agree on.

SourceColumn { source: Source, column } is in ir/operator/arguments.rs
beside Source. ColumnLineage is a memo-scope property beside ValueSign in
stages/logical/column_properties.rs; the memo's coverage derivation reads
each input group's stored lineage through MemoGroupAsInput, with no
OperatorInput accessor, and carries it up through the liftable operators
above the aggregate's input (lineage_at_top). Aggregate coverage names a selection's column by its
SourceColumn lineage; ColumnIdentity is deleted. A predicate on a
Computed column, or on one of two columns of one lineage, is not lifted;
the regrouping key check compares lineage. Schema fields and the IR
Project lose their table qualifier; the front ends bind qualified names
with their own scope while lowering. Declared signs stay keyed by source
name and column (SourceFacts).
@zzylol
zzylol force-pushed the refactor/1207-lineage branch from a6eca31 to 03163fd Compare November 10, 2026 22:08
@zzylol
zzylol marked this pull request as ready for review November 11, 2026 02:28
…join scans, one-side match labels

- ColumnLineage::Computed { group, column }: a computed column is named by
  the memo group and output column that computed it, so two computed
  columns are equal only when they are the same computation. The new
  group's id is passed to column_lineage_and_signs, derive_group_properties,
  validate_expression_over_input_groups and aggregate_coverage. A
  regrouping merge's state is computed by the merge.
- SourceColumn gains scan_ordinal: a Scan is 0; at a Join and a vector-match
  BinaryOp the right side's columns of a source the left also scans shift
  past the left's ordinals, so a self-join's two sides are different keys.
  SourceColumn moves below impl Source and drops Hash; ColumnLineage drops
  Hash and serde.
- project_lineage: one Project lineage rule for project_columns and
  lineage_at_top.
- BinaryOp: labels named in group_left(...) take the right side's lineage
  and sign, in group_right(...) the left side's, overwriting a column of
  that name in place.
- Front-end resolver: a qualified name never binds a column qualified by
  another table; Bound::new asserts one qualifier per column or none, and
  an aggregate whose measures add label columns is made unqualified at its
  call site.
- Tests: self-join scan ordinals and alias-renamed key; three match-grouping
  label tests; qualified binding unit test. Design doc: scan_ordinal,
  Computed { group, column }, SourceColumn location, plain concepts-doc
  reference.
…ts scan ordinals

A BinaryOp does not concatenate both sides' columns: its labels are the
left side's for one-to-one and group_left, the right ("many") side's for
group_right, and a matched label has equal values on both sides, so it
takes the output side's lineage and sign (`or` keeps what both sides agree
on). No scan ordinal shifts at a BinaryOp; only a Join's right side shifts.
Labels named in group_left/group_right still come from the one side.

Tests: rate(x[5m]) / rate(x[1h]) keeps job as x scan 0; a same-source
group_right takes the right side's labels (failed before this change).
…re computed, Option lineage in coverage, resolver qualifiers per column

- The memo group id reaches only column_lineage_and_signs (via
  derive_group_properties); project_lineage returns Option lineage (None:
  computed here), which lineage_at_top and source_column read, so
  aggregate_coverage, validate_expression_over_input_groups and the
  coverage helpers lose the group parameter.
- ColumnProperties: Default (computed, sign Unknown) and all_computed
  replace the repeated computed(Unknown) forms; Debug/PartialEq dropped;
  ColumnLineage drops Eq.
- BinaryOp `or`: a label only the right side has is computed (null on the
  left side's rows).
- regrouped key check reads with matches!.
- Deleted: resolve_column_refs (unused) and the planner's SourceColumn
  re-export (unused).
- Front-end resolver: Bound stores one qualifier per column (None when
  unqualified); the padding closure, the window-function check and the
  empty-list sentinel go; one Scope::qualifier accessor; pass-through
  operators move the child node. An aggregate's qualifiers are sized by
  its node's schema.
- Tests: memo_fixtures::series_column / table_column replace the local
  lineage helpers; latency_series and series use memo_fixtures::scan; new
  test an_or_label_only_the_right_side_has_is_computed.
- Docs: drop the stale Field.table and Project qualifier from pre-asap-ir
  and operator-sharing; SourceColumn doc no longer names crate::stages.
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

ir Pre-ASAP or post-ASAP intermediate representation refactor schema Schema, type, key, and nullability contracts

Projects

None yet

Development

Successfully merging this pull request may close these issues.

1 participant