Skip to content

Commit 1efb420

Browse files
committed
test(native): compare CTE fact recovery with Python function for function
A seeded differential compares native CTE fact recovery with Python's over 5,000 queries and adapter profiles through a test-only oracle binding. The model-analysis CTE recovery count is relabelled as a corpus floor over Python's reference run.
1 parent 1640fbd commit 1efb420

13 files changed

Lines changed: 667 additions & 7 deletions

File tree

‎crates/sqlbuild-analysis/src/assembly/analysis_session/constants.rs‎

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -95,6 +95,8 @@ pub(crate) const RENDERED_TYPE_NAMES: [(&str, &str); 12] = [
9595
];
9696
/// The stack a standalone dynamic pivot proof parses on, as the analysis workers have.
9797
pub(crate) const PIVOT_WORKER_STACK_BYTES: usize = 16 * 1024 * 1024;
98+
/// Stack for one standalone CTE fact recovery, whose AST walks recurse with query depth.
99+
pub(crate) const CTE_FACT_WORKER_STACK_BYTES: usize = 16 * 1024 * 1024;
98100
/// The wheel's node kinds Python's CTE fact recovery reads.
99101
pub(crate) const ANNOTATED_AST_KIND: &str = "annotated";
100102
pub(crate) const LITERAL_AST_KIND: &str = "literal";

‎crates/sqlbuild-analysis/src/assembly/analysis_session/main/mod.rs‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -2,5 +2,6 @@ pub mod expression_shapes;
22
pub mod finish_analysis_session;
33
pub mod prove_dynamic_contract;
44
pub mod provide_deferred_analyses;
5+
pub mod recover_cte_facts;
56
pub mod run_analysis_session;
67
pub mod start_analysis_session;
Lines changed: 47 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,47 @@
1+
//! Python's CTE pass-through facts and filtered non-null outputs for one query.
2+
3+
use crate::assembly::analysis_session::_helpers::cte_facts::{
4+
Recovery, RecoveryInput, RecoveryProfile, recovery,
5+
};
6+
use crate::assembly::analysis_session::constants::CTE_FACT_WORKER_STACK_BYTES;
7+
use crate::assembly::analysis_session::models::{CteFactRequest, CteFacts};
8+
9+
/// The facts enrichment recovers for the query, or why they are left to Python.
10+
pub fn recover_cte_facts(request: &CteFactRequest) -> Result<CteFacts, String> {
11+
std::thread::scope(|scope| {
12+
std::thread::Builder::new()
13+
.stack_size(CTE_FACT_WORKER_STACK_BYTES)
14+
.spawn_scoped(scope, || recovered_facts(request))
15+
.map_err(|error| error.to_string())?
16+
.join()
17+
.map_err(|_| "native CTE fact recovery panicked".to_owned())?
18+
})
19+
}
20+
21+
fn recovered_facts(request: &CteFactRequest) -> Result<CteFacts, String> {
22+
let recovered: Recovery = recovery(&RecoveryInput {
23+
cleaned_sql: &request.cleaned_sql,
24+
input_schemas: &request.input_schemas,
25+
recover: request.recover,
26+
null_filter: request.null_filter,
27+
profile: RecoveryProfile {
28+
dialect: &request.dialect,
29+
function_return_types: &request.function_return_types,
30+
rules: request.nullability_rules.as_ref(),
31+
},
32+
})?;
33+
let mut direct_outputs: Vec<String> = recovered.direct_outputs.into_iter().collect();
34+
direct_outputs.sort_unstable();
35+
let mut non_null_outputs: Vec<String> = recovered.non_null_outputs.into_iter().collect();
36+
non_null_outputs.sort_unstable();
37+
Ok(CteFacts {
38+
types: recovered.types,
39+
nullability: recovered
40+
.nullability
41+
.into_iter()
42+
.map(|(name, nullability)| (name, nullability.to_owned()))
43+
.collect(),
44+
direct_outputs,
45+
non_null_outputs,
46+
})
47+
}

‎crates/sqlbuild-analysis/src/assembly/analysis_session/models.rs‎

Lines changed: 27 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -259,3 +259,30 @@ pub struct AnalysisSession {
259259
pub(crate) publications: Shapes,
260260
pub(crate) failures: Vec<String>,
261261
}
262+
263+
/// One query's CTE fact recovery, as Python's compact enrichment runs it.
264+
#[derive(Debug, Clone)]
265+
pub struct CteFactRequest {
266+
pub cleaned_sql: String,
267+
pub dialect: String,
268+
/// Input relation types; every input column's nullability is unknown, as in enrichment.
269+
pub input_schemas: Shapes,
270+
pub function_return_types: Pairs,
271+
/// Adapter nullability rules as `(function name, rule id)`; None where one is not Python's.
272+
pub nullability_rules: Option<Pairs>,
273+
/// Whether Python runs `_polyglot_cte_passthrough_facts` past its early return.
274+
pub recover: bool,
275+
/// Whether a filter reads NULL, so Python looks for filtered non-null outputs.
276+
pub null_filter: bool,
277+
}
278+
279+
/// Python's recovered CTE pass-through facts and filtered non-null outputs for one query.
280+
#[derive(Debug, Clone, PartialEq, Eq)]
281+
pub struct CteFacts {
282+
pub types: Pairs,
283+
pub nullability: Pairs,
284+
/// Sorted direct CTE output names.
285+
pub direct_outputs: Vec<String>,
286+
/// Sorted outputs a filter proves non-null.
287+
pub non_null_outputs: Vec<String>,
288+
}
Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1,2 +1,3 @@
1+
pub(crate) mod oracle;
12
pub(crate) mod registration;
23
pub(crate) mod session;
Lines changed: 62 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,62 @@
1+
//! Test-only hook comparing native CTE fact recovery with Python's, function for function.
2+
3+
use pyo3::prelude::{Bound, PyModule, PyModuleMethods, PyResult, Python};
4+
use pyo3::{pyfunction, wrap_pyfunction};
5+
use sqlbuild_analysis::assembly::analysis_session::main::recover_cte_facts::recover_cte_facts;
6+
use sqlbuild_analysis::assembly::analysis_session::models::{CteFactRequest, CteFacts};
7+
use sqlbuild_analysis::assembly::analysis_session::types::{Pairs, Shapes};
8+
9+
use crate::bindings::_helpers::boundary::panics::value_error;
10+
use crate::bindings::types::CompilerDetach;
11+
12+
/// `(cleaned SQL, dialect, input schemas, return types, nullability rules, recover, null filter)`.
13+
type RecoveryRow = (String, String, Shapes, Pairs, Option<Pairs>, bool, bool);
14+
/// `(deferral, types, nullability, sorted direct outputs, sorted non-null outputs)`.
15+
type FactsRow = (Option<String>, Pairs, Pairs, Vec<String>, Vec<String>);
16+
17+
/// The facts native enrichment recovers for one query, or the reason it defers to Python.
18+
#[pyfunction]
19+
fn _oracle_cte_fact_recovery(py: Python<'_>, request: RecoveryRow) -> PyResult<FactsRow> {
20+
let (
21+
cleaned_sql,
22+
dialect,
23+
input_schemas,
24+
function_return_types,
25+
nullability_rules,
26+
recover,
27+
null_filter,
28+
) = request;
29+
let request = CteFactRequest {
30+
cleaned_sql,
31+
dialect,
32+
input_schemas,
33+
function_return_types,
34+
nullability_rules,
35+
recover,
36+
null_filter,
37+
};
38+
let facts: Result<CteFacts, String> = py
39+
.compiler_detach(|| Ok(recover_cte_facts(&request)))
40+
.map_err(value_error)?;
41+
Ok(match facts {
42+
Ok(facts) => (
43+
None,
44+
facts.types,
45+
facts.nullability,
46+
facts.direct_outputs,
47+
facts.non_null_outputs,
48+
),
49+
Err(deferral) => (
50+
Some(deferral),
51+
Vec::new(),
52+
Vec::new(),
53+
Vec::new(),
54+
Vec::new(),
55+
),
56+
})
57+
}
58+
59+
pub(crate) fn register(module: &Bound<'_, PyModule>) -> PyResult<()> {
60+
module.add_function(wrap_pyfunction!(_oracle_cte_fact_recovery, module)?)?;
61+
Ok(())
62+
}

‎crates/sqlbuild-python/src/bindings/_helpers/analysis_session/registration.rs‎

Lines changed: 3 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -2,8 +2,9 @@
22
33
use pyo3::prelude::{Bound, PyModule, PyResult};
44

5-
use crate::bindings::_helpers::analysis_session::session;
5+
use crate::bindings::_helpers::analysis_session::{oracle, session};
66

77
pub(crate) fn register(module: &Bound<'_, PyModule>) -> PyResult<()> {
8-
session::register(module)
8+
session::register(module)?;
9+
oracle::register(module)
910
}

‎src/sqlbuild/_native.pyi‎

Lines changed: 12 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -452,6 +452,18 @@ def prove_dynamic_column_contract(
452452
def infer_expression_source_shapes(
453453
catalog: object, request: tuple[str, bool, list[tuple[str, str]], list[str]], /
454454
) -> tuple[list[tuple[bool, list[tuple[str, str]] | None]], str | None]: ...
455+
def _oracle_cte_fact_recovery(
456+
request: tuple[
457+
str,
458+
str,
459+
list[tuple[str, list[tuple[str, str]]]],
460+
list[tuple[str, str]],
461+
list[tuple[str, str]] | None,
462+
bool,
463+
bool,
464+
],
465+
/,
466+
) -> tuple[str | None, list[tuple[str, str]], list[tuple[str, str]], list[str], list[str]]: ...
455467

456468
# Native analysis: semantic completion.
457469
class SemanticTypeRecovery:

0 commit comments

Comments
 (0)