cellular/jspg
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

queryer fixes in place

Browse Source
This commit is contained in:
Alex Groleau
2026-03-17 22:13:34 -04:00
parent 3d66a7fc3c
commit 091007006d
15 changed files with 1148 additions and 885 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
src/tests/mod.rs
View File

@ -2,7 +2,6 @@ use crate::*;
pub mod runner;
pub mod types;
use serde_json::json;
pub mod sql_validator;
// Database module tests moved to src/database/executors/mock.rs

17
src/tests/runner.rs
View File

@ -1,19 +1,10 @@
use crate::tests::types::Suite;
use serde::Deserialize;
use serde_json::Value;
use std::collections::HashMap;
use std::fs;
use std::sync::{Arc, OnceLock, RwLock};
#[derive(Debug, Deserialize)]
pub struct TestSuite {
#[allow(dead_code)]
pub description: String,
pub database: serde_json::Value,
pub tests: Vec<TestCase>,
}
use crate::tests::types::TestCase;
use serde_json::Value;
pub fn deserialize_some<'de, D>(deserializer: D) -> Result<Option<Value>, D::Error>
where
D: serde::Deserializer<'de>,
@ -23,7 +14,7 @@ where
}
// Type alias for easier reading
type CompiledSuite = Arc<Vec<(TestSuite, Arc<crate::database::Database>)>>;
type CompiledSuite = Arc<Vec<(Suite, Arc<crate::database::Database>)>>;
// Global cache mapping filename -> Vector of (Parsed JSON suite, Compiled Database)
static CACHE: OnceLock<RwLock<HashMap<String, CompiledSuite>>> = OnceLock::new();
@ -46,7 +37,7 @@ fn get_cached_file(path: &str) -> CompiledSuite {
} else {
let content =
fs::read_to_string(path).unwrap_or_else(|_| panic!("Failed to read file: {}", path));
let suites: Vec<TestSuite> = serde_json::from_str(&content)
let suites: Vec<Suite> = serde_json::from_str(&content)
.unwrap_or_else(|e| panic!("Failed to parse JSON in {}: {}", path, e));
let mut compiled_suites = Vec::new();

194
src/tests/sql_validator.rs
View File

@ -1,194 +0,0 @@
use sqlparser::ast::{Expr, Query, SelectItem, Statement, TableFactor};
use sqlparser::dialect::PostgreSqlDialect;
use sqlparser::parser::Parser;
use std::collections::HashSet;
pub fn validate_semantic_sql(sql: &str) -> Result<(), String> {
let dialect = PostgreSqlDialect {};
let statements = match Parser::parse_sql(&dialect, sql) {
Ok(s) => s,
Err(e) => return Err(format!("SQL Syntax Error: {}\nSQL: {}", e, sql)),
};
for statement in statements {
validate_statement(&statement, sql)?;
}
Ok(())
}
fn validate_statement(stmt: &Statement, original_sql: &str) -> Result<(), String> {
match stmt {
Statement::Query(query) => validate_query(query, &HashSet::new(), original_sql)?,
Statement::Insert(insert) => {
if let Some(query) = &insert.source {
validate_query(query, &HashSet::new(), original_sql)?
}
}
Statement::Update(update) => {
if let Some(expr) = &update.selection {
validate_expr(expr, &HashSet::new(), original_sql)?;
}
}
Statement::Delete(delete) => {
if let Some(expr) = &delete.selection {
validate_expr(expr, &HashSet::new(), original_sql)?;
}
}
_ => {}
}
Ok(())
}
fn validate_query(
query: &Query,
available_aliases: &HashSet<String>,
original_sql: &str,
) -> Result<(), String> {
if let sqlparser::ast::SetExpr::Select(select) = &*query.body {
validate_select(&select, available_aliases, original_sql)?;
}
Ok(())
}
fn validate_select(
select: &sqlparser::ast::Select,
parent_aliases: &HashSet<String>,
original_sql: &str,
) -> Result<(), String> {
let mut available_aliases = parent_aliases.clone();
// 1. Collect all declared table aliases in the FROM clause and JOINs
for table_with_joins in &select.from {
collect_aliases_from_table_factor(&table_with_joins.relation, &mut available_aliases);
for join in &table_with_joins.joins {
collect_aliases_from_table_factor(&join.relation, &mut available_aliases);
}
}
// 2. Validate all SELECT projection fields
for projection in &select.projection {
if let SelectItem::UnnamedExpr(expr) | SelectItem::ExprWithAlias { expr, .. } = projection {
validate_expr(expr, &available_aliases, original_sql)?;
}
}
// 3. Validate ON conditions in joins
for table_with_joins in &select.from {
for join in &table_with_joins.joins {
if let sqlparser::ast::JoinOperator::Inner(sqlparser::ast::JoinConstraint::On(expr))
| sqlparser::ast::JoinOperator::LeftOuter(sqlparser::ast::JoinConstraint::On(expr))
| sqlparser::ast::JoinOperator::RightOuter(sqlparser::ast::JoinConstraint::On(expr))
| sqlparser::ast::JoinOperator::FullOuter(sqlparser::ast::JoinConstraint::On(expr))
| sqlparser::ast::JoinOperator::Join(sqlparser::ast::JoinConstraint::On(expr)) =
&join.join_operator
{
validate_expr(expr, &available_aliases, original_sql)?;
}
}
}
// 4. Validate WHERE conditions
if let Some(selection) = &select.selection {
validate_expr(selection, &available_aliases, original_sql)?;
}
Ok(())
}
fn collect_aliases_from_table_factor(tf: &TableFactor, aliases: &mut HashSet<String>) {
match tf {
TableFactor::Table { name, alias, .. } => {
if let Some(table_alias) = alias {
aliases.insert(table_alias.name.value.clone());
} else if let Some(last) = name.0.last() {
match last {
sqlparser::ast::ObjectNamePart::Identifier(i) => {
aliases.insert(i.value.clone());
}
_ => {}
}
}
}
TableFactor::Derived {
subquery,
alias: Some(table_alias),
..
} => {
aliases.insert(table_alias.name.value.clone());
// A derived table is technically a nested scope which is opaque outside, but for pure semantic checks
// its internal contents should be validated purely within its own scope (not leaking external aliases in, usually)
// but Postgres allows lateral correlation. We will validate its interior with an empty scope.
let _ = validate_query(subquery, &HashSet::new(), "");
}
_ => {}
}
}
fn validate_expr(
expr: &Expr,
available_aliases: &HashSet<String>,
sql: &str,
) -> Result<(), String> {
match expr {
Expr::CompoundIdentifier(idents) => {
if idents.len() == 2 {
let alias = &idents[0].value;
if !available_aliases.is_empty() && !available_aliases.contains(alias) {
return Err(format!(
"Semantic Error: Orchestrated query referenced table alias '{}' but it was not declared in the query's FROM/JOIN clauses.\nAvailable aliases: {:?}\nSQL: {}",
alias, available_aliases, sql
));
}
} else if idents.len() > 2 {
let alias = &idents[1].value; // In form schema.table.column, 'table' is idents[1]
if !available_aliases.is_empty() && !available_aliases.contains(alias) {
return Err(format!(
"Semantic Error: Orchestrated query referenced table '{}' but it was not mapped.\nAvailable aliases: {:?}\nSQL: {}",
alias, available_aliases, sql
));
}
}
}
Expr::Subquery(subquery) => validate_query(subquery, available_aliases, sql)?,
Expr::Exists { subquery, .. } => validate_query(subquery, available_aliases, sql)?,
Expr::InSubquery {
expr: e, subquery, ..
} => {
validate_expr(e, available_aliases, sql)?;
validate_query(subquery, available_aliases, sql)?;
}
Expr::BinaryOp { left, right, .. } => {
validate_expr(left, available_aliases, sql)?;
validate_expr(right, available_aliases, sql)?;
}
Expr::IsFalse(e)
| Expr::IsNotFalse(e)
| Expr::IsTrue(e)
| Expr::IsNotTrue(e)
| Expr::IsNull(e)
| Expr::IsNotNull(e)
| Expr::InList { expr: e, .. }
| Expr::Nested(e)
| Expr::UnaryOp { expr: e, .. }
| Expr::Cast { expr: e, .. }
| Expr::Like { expr: e, .. }
| Expr::ILike { expr: e, .. }
| Expr::AnyOp { left: e, .. }
| Expr::AllOp { left: e, .. } => {
validate_expr(e, available_aliases, sql)?;
}
Expr::Function(func) => {
if let sqlparser::ast::FunctionArguments::List(args) = &func.args {
if let Some(sqlparser::ast::FunctionArg::Unnamed(sqlparser::ast::FunctionArgExpr::Expr(
e,
))) = args.args.get(0)
{
validate_expr(e, available_aliases, sql)?;
}
}
}
_ => {}
}
Ok(())
}

10
src/tests/types/case.rs
View File

@ -1,11 +1,11 @@
use super::expect::ExpectBlock;
use super::expect::Expect;
use crate::database::Database;
use serde::Deserialize;
use serde_json::Value;
use std::sync::Arc;
#[derive(Debug, Deserialize)]
pub struct TestCase {
pub struct Case {
pub description: String,
#[serde(default = "default_action")]
@ -30,14 +30,14 @@ pub struct TestCase {
#[serde(default)]
pub mocks: Option<serde_json::Value>,
pub expect: Option<ExpectBlock>,
pub expect: Option<Expect>,
}
fn default_action() -> String {
"validate".to_string()
}
impl TestCase {
impl Case {
pub fn run_compile(&self, db: Arc<Database>) -> Result<(), String> {
let expected_success = self.expect.as_ref().map(|e| e.success).unwrap_or(false);
@ -138,6 +138,7 @@ impl TestCase {
))
} else if let Some(expect) = &self.expect {
let queries = db.executor.get_queries();
expect.assert_pattern(&queries)?;
expect.assert_sql(&queries)
} else {
Ok(())
@ -176,6 +177,7 @@ impl TestCase {
))
} else if let Some(expect) = &self.expect {
let queries = db.executor.get_queries();
expect.assert_pattern(&queries)?;
expect.assert_sql(&queries)
} else {
Ok(())

22
src/tests/types/expect/mod.rs Normal file
View File

@ -0,0 +1,22 @@
pub mod pattern;
pub mod sql;
use serde::Deserialize;
use std::collections::HashMap;
#[derive(Debug, Deserialize)]
#[serde(untagged)]
pub enum SqlExpectation {
Single(String),
Multi(Vec<String>),
}
#[derive(Debug, Deserialize)]
pub struct Expect {
pub success: bool,
pub result: Option<serde_json::Value>,
pub errors: Option<Vec<serde_json::Value>>,
pub stems: Option<HashMap<String, HashMap<String, serde_json::Value>>>,
#[serde(default)]
pub sql: Option<Vec<SqlExpectation>>,
}

33
src/tests/types/expect.rs → src/tests/types/expect/pattern.rs
View File

@ -1,30 +1,13 @@
use super::Expect;
use regex::Regex;
use serde::Deserialize;
use std::collections::HashMap;
#[derive(Debug, Deserialize)]
#[serde(untagged)]
pub enum SqlExpectation {
Single(String),
Multi(Vec<String>),
}
#[derive(Debug, Deserialize)]
pub struct ExpectBlock {
pub success: bool,
pub result: Option<serde_json::Value>,
pub errors: Option<Vec<serde_json::Value>>,
pub stems: Option<HashMap<String, HashMap<String, serde_json::Value>>>,
#[serde(default)]
pub sql: Option<Vec<SqlExpectation>>,
}
impl ExpectBlock {
impl Expect {
/// Advanced SQL execution assertion algorithm ported from `assert.go`.
/// This compares two arrays of strings, one containing {{uuid:name}} or {{timestamp}} placeholders,
/// and the other containing actual executed database queries. It ensures that placeholder UUIDs
/// are consistently mapped to the same actual UUIDs across all lines, and strictly validates line-by-line sequences.
pub fn assert_sql(&self, actual: &[String]) -> Result<(), String> {
pub fn assert_pattern(&self, actual: &[String]) -> Result<(), String> {
let patterns = match &self.sql {
Some(s) => s,
None => return Ok(()),
@ -39,12 +22,6 @@ impl ExpectBlock {
));
}
for query in actual {
if let Err(e) = crate::tests::sql_validator::validate_semantic_sql(query) {
return Err(e);
}
}
let ws_re = Regex::new(r"\s+").unwrap();
let types = HashMap::from([
@ -82,8 +59,8 @@ impl ExpectBlock {
let aline = clean_str(aline_raw);
let pattern_str_raw = match pattern_expect {
SqlExpectation::Single(s) => s.clone(),
SqlExpectation::Multi(m) => m.join(" "),
super::SqlExpectation::Single(s) => s.clone(),
super::SqlExpectation::Multi(m) => m.join(" "),
};
let pattern_str = clean_str(&pattern_str_raw);

206
src/tests/types/expect/sql.rs Normal file
View File

@ -0,0 +1,206 @@
use super::Expect;
use sqlparser::ast::{Expr, Query, SelectItem, Statement, TableFactor};
use sqlparser::dialect::PostgreSqlDialect;
use sqlparser::parser::Parser;
use std::collections::HashSet;
impl Expect {
pub fn assert_sql(&self, actual: &[String]) -> Result<(), String> {
for query in actual {
if let Err(e) = Self::validate_semantic_sql(query) {
return Err(e);
}
}
Ok(())
}
pub fn validate_semantic_sql(sql: &str) -> Result<(), String> {
let dialect = PostgreSqlDialect {};
let statements = match Parser::parse_sql(&dialect, sql) {
Ok(s) => s,
Err(e) => return Err(format!("SQL Syntax Error: {}\nSQL: {}", e, sql)),
};
for statement in statements {
Self::validate_statement(&statement, sql)?;
}
Ok(())
}
fn validate_statement(stmt: &Statement, original_sql: &str) -> Result<(), String> {
match stmt {
Statement::Query(query) => Self::validate_query(query, &HashSet::new(), original_sql)?,
Statement::Insert(insert) => {
if let Some(query) = &insert.source {
Self::validate_query(query, &HashSet::new(), original_sql)?
}
}
Statement::Update(update) => {
if let Some(expr) = &update.selection {
Self::validate_expr(expr, &HashSet::new(), original_sql)?;
}
}
Statement::Delete(delete) => {
if let Some(expr) = &delete.selection {
Self::validate_expr(expr, &HashSet::new(), original_sql)?;
}
}
_ => {}
}
Ok(())
}
fn validate_query(
query: &Query,
available_aliases: &HashSet<String>,
original_sql: &str,
) -> Result<(), String> {
if let sqlparser::ast::SetExpr::Select(select) = &*query.body {
Self::validate_select(&select, available_aliases, original_sql)?;
}
Ok(())
}
fn validate_select(
select: &sqlparser::ast::Select,
parent_aliases: &HashSet<String>,
original_sql: &str,
) -> Result<(), String> {
let mut available_aliases = parent_aliases.clone();
// 1. Collect all declared table aliases in the FROM clause and JOINs
for table_with_joins in &select.from {
Self::collect_aliases_from_table_factor(&table_with_joins.relation, &mut available_aliases);
for join in &table_with_joins.joins {
Self::collect_aliases_from_table_factor(&join.relation, &mut available_aliases);
}
}
// 2. Validate all SELECT projection fields
for projection in &select.projection {
if let SelectItem::UnnamedExpr(expr) | SelectItem::ExprWithAlias { expr, .. } = projection {
Self::validate_expr(expr, &available_aliases, original_sql)?;
}
}
// 3. Validate ON conditions in joins
for table_with_joins in &select.from {
for join in &table_with_joins.joins {
if let sqlparser::ast::JoinOperator::Inner(sqlparser::ast::JoinConstraint::On(expr))
| sqlparser::ast::JoinOperator::LeftOuter(sqlparser::ast::JoinConstraint::On(expr))
| sqlparser::ast::JoinOperator::RightOuter(sqlparser::ast::JoinConstraint::On(expr))
| sqlparser::ast::JoinOperator::FullOuter(sqlparser::ast::JoinConstraint::On(expr))
| sqlparser::ast::JoinOperator::Join(sqlparser::ast::JoinConstraint::On(expr)) =
&join.join_operator
{
Self::validate_expr(expr, &available_aliases, original_sql)?;
}
}
}
// 4. Validate WHERE conditions
if let Some(selection) = &select.selection {
Self::validate_expr(selection, &available_aliases, original_sql)?;
}
Ok(())
}
fn collect_aliases_from_table_factor(tf: &TableFactor, aliases: &mut HashSet<String>) {
match tf {
TableFactor::Table { name, alias, .. } => {
if let Some(table_alias) = alias {
aliases.insert(table_alias.name.value.clone());
} else if let Some(last) = name.0.last() {
match last {
sqlparser::ast::ObjectNamePart::Identifier(i) => {
aliases.insert(i.value.clone());
}
_ => {}
}
}
}
TableFactor::Derived {
subquery,
alias: Some(table_alias),
..
} => {
aliases.insert(table_alias.name.value.clone());
// A derived table is technically a nested scope which is opaque outside, but for pure semantic checks
// its internal contents should be validated purely within its own scope (not leaking external aliases in, usually)
// but Postgres allows lateral correlation. We will validate its interior with an empty scope.
let _ = Self::validate_query(subquery, &HashSet::new(), "");
}
_ => {}
}
}
fn validate_expr(
expr: &Expr,
available_aliases: &HashSet<String>,
sql: &str,
) -> Result<(), String> {
match expr {
Expr::CompoundIdentifier(idents) => {
if idents.len() == 2 {
let alias = &idents[0].value;
if !available_aliases.is_empty() && !available_aliases.contains(alias) {
return Err(format!(
"Semantic Error: Orchestrated query referenced table alias '{}' but it was not declared in the query's FROM/JOIN clauses.\nAvailable aliases: {:?}\nSQL: {}",
alias, available_aliases, sql
));
}
} else if idents.len() > 2 {
let alias = &idents[1].value; // In form schema.table.column, 'table' is idents[1]
if !available_aliases.is_empty() && !available_aliases.contains(alias) {
return Err(format!(
"Semantic Error: Orchestrated query referenced table '{}' but it was not mapped.\nAvailable aliases: {:?}\nSQL: {}",
alias, available_aliases, sql
));
}
}
}
Expr::Subquery(subquery) => Self::validate_query(subquery, available_aliases, sql)?,
Expr::Exists { subquery, .. } => Self::validate_query(subquery, available_aliases, sql)?,
Expr::InSubquery {
expr: e, subquery, ..
} => {
Self::validate_expr(e, available_aliases, sql)?;
Self::validate_query(subquery, available_aliases, sql)?;
}
Expr::BinaryOp { left, right, .. } => {
Self::validate_expr(left, available_aliases, sql)?;
Self::validate_expr(right, available_aliases, sql)?;
}
Expr::IsFalse(e)
| Expr::IsNotFalse(e)
| Expr::IsTrue(e)
| Expr::IsNotTrue(e)
| Expr::IsNull(e)
| Expr::IsNotNull(e)
| Expr::InList { expr: e, .. }
| Expr::Nested(e)
| Expr::UnaryOp { expr: e, .. }
| Expr::Cast { expr: e, .. }
| Expr::Like { expr: e, .. }
| Expr::ILike { expr: e, .. }
| Expr::AnyOp { left: e, .. }
| Expr::AllOp { left: e, .. } => {
Self::validate_expr(e, available_aliases, sql)?;
}
Expr::Function(func) => {
if let sqlparser::ast::FunctionArguments::List(args) = &func.args {
if let Some(sqlparser::ast::FunctionArg::Unnamed(sqlparser::ast::FunctionArgExpr::Expr(
e,
))) = args.args.get(0)
{
Self::validate_expr(e, available_aliases, sql)?;
}
}
}
_ => {}
}
Ok(())
}
}

6
src/tests/types/mod.rs
View File

@ -2,6 +2,6 @@ pub mod case;
pub mod expect;
pub mod suite;
pub use case::TestCase;
pub use expect::ExpectBlock;
pub use suite::TestSuite;
pub use case::Case;
pub use expect::Expect;
pub use suite::Suite;

6
src/tests/types/suite.rs
View File

@ -1,10 +1,10 @@
use super::case::TestCase;
use super::case::Case;
use serde::Deserialize;
#[derive(Debug, Deserialize)]
pub struct TestSuite {
pub struct Suite {
#[allow(dead_code)]
pub description: String,
pub database: serde_json::Value,
pub tests: Vec<TestCase>,
pub tests: Vec<Case>,
}