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

more tests

Browse Source
This commit is contained in:
Alex Groleau
2026-04-10 01:06:02 -04:00
parent 3cca5ef2d5
commit be78af1507
11 changed files with 1081 additions and 965 deletions
Download Patch File Download Diff File Expand all files Collapse all files

134
src/queryer/compiler.rs
View File

@ -1,4 +1,6 @@
use crate::database::Database;
use std::sync::Arc;
pub struct Compiler<'a> {
pub db: &'a Database,
pub filter_keys: &'a [String],
@ -15,6 +17,7 @@ pub struct Node<'a> {
pub property_name: Option<String>,
pub depth: usize,
pub ast_path: String,
pub is_polymorphic_branch: bool,
}
impl<'a> Compiler<'a> {
@ -26,7 +29,7 @@ impl<'a> Compiler<'a> {
.get(schema_id)
.ok_or_else(|| format!("Schema not found: {}", schema_id))?;
let target_schema = std::sync::Arc::new(schema.clone());
let target_schema = std::sync::Arc::clone(schema);
let mut compiler = Compiler {
db: &self.db,
@ -43,6 +46,7 @@ impl<'a> Compiler<'a> {
property_name: None,
depth: 0,
ast_path: String::new(),
is_polymorphic_branch: false,
};
let (sql, _) = compiler.compile_node(node)?;
@ -54,7 +58,7 @@ impl<'a> Compiler<'a> {
fn compile_node(&mut self, node: Node<'a>) -> Result<(String, String), String> {
// Determine the base schema type (could be an array, object, or literal)
match &node.schema.obj.type_ {
Some(crate::database::schema::SchemaTypeOrArray::Single(t)) if t == "array" => {
Some(crate::database::object::SchemaTypeOrArray::Single(t)) if t == "array" => {
self.compile_array(node)
}
_ => self.compile_reference(node),
@ -116,12 +120,12 @@ impl<'a> Compiler<'a> {
}
// Handle Direct Refs via type pointer
if let Some(crate::database::schema::SchemaTypeOrArray::Single(t)) = &node.schema.obj.type_ {
if !crate::database::schema::is_primitive_type(t) {
if let Some(crate::database::object::SchemaTypeOrArray::Single(t)) = &node.schema.obj.type_ {
if !crate::database::object::is_primitive_type(t) {
// If it's just an ad-hoc struct ref, we should resolve it
if let Some(target_schema) = self.db.schemas.get(t) {
let mut ref_node = node.clone();
ref_node.schema = std::sync::Arc::new(target_schema.clone());
ref_node.schema = Arc::clone(target_schema);
return self.compile_node(ref_node);
}
return Err(format!("Unresolved schema type pointer: {}", t));
@ -133,7 +137,7 @@ impl<'a> Compiler<'a> {
if options.len() == 1 {
let target_id = options.values().next().unwrap();
let mut bypass_schema = crate::database::schema::Schema::default();
bypass_schema.obj.type_ = Some(crate::database::schema::SchemaTypeOrArray::Single(target_id.clone()));
bypass_schema.obj.type_ = Some(crate::database::object::SchemaTypeOrArray::Single(target_id.clone()));
let mut bypass_node = node.clone();
bypass_node.schema = std::sync::Arc::new(bypass_schema);
return self.compile_node(bypass_node);
@ -166,17 +170,28 @@ impl<'a> Compiler<'a> {
) -> Result<(String, String), String> {
let (table_aliases, from_clauses) = self.compile_from_clause(r#type);
// 2. Map properties and build jsonb_build_object args
let mut select_args = self.compile_select_clause(r#type, &table_aliases, node.clone())?;
let jsonb_obj_sql = if node.schema.obj.family.is_some() || node.schema.obj.one_of.is_some() {
let base_alias = table_aliases
.get(&r#type.name)
.cloned()
.unwrap_or_else(|| node.parent_alias.to_string());
let mut case_node = node.clone();
case_node.parent_alias = base_alias.clone();
let arc_aliases = std::sync::Arc::new(table_aliases.clone());
case_node.parent_type_aliases = Some(arc_aliases);
case_node.parent_type = Some(r#type);
// 2.5 Inject polymorphism directly into the query object
let mut poly_args = self.compile_polymorphism_select(r#type, &table_aliases, node.clone())?;
select_args.append(&mut poly_args);
let jsonb_obj_sql = if select_args.is_empty() {
"jsonb_build_object()".to_string()
let (case_sql, _) = self.compile_one_of(case_node)?;
case_sql
} else {
format!("jsonb_build_object({})", select_args.join(", "))
let select_args = self.compile_select_clause(r#type, &table_aliases, node.clone())?;
if select_args.is_empty() {
"jsonb_build_object()".to_string()
} else {
format!("jsonb_build_object({})", select_args.join(", "))
}
};
// 3. Build WHERE clauses
@ -205,55 +220,6 @@ impl<'a> Compiler<'a> {
))
}
fn compile_polymorphism_select(
&mut self,
r#type: &'a crate::database::r#type::Type,
table_aliases: &std::collections::HashMap<String, String>,
node: Node<'a>,
) -> Result<Vec<String>, String> {
let mut select_args = Vec::new();
if node.schema.obj.family.is_some() || node.schema.obj.one_of.is_some() {
let base_alias = table_aliases
.get(&r#type.name)
.cloned()
.unwrap_or_else(|| node.parent_alias.to_string());
let disc = node.schema.obj.compiled_discriminator.get();
if disc.is_none() {
return Ok(select_args);
}
let options = node.schema.obj.compiled_options.get();
if options.is_none() {
return Ok(select_args);
}
let options = options.unwrap();
if options.len() == 1 {
let target_id = options.values().next().unwrap();
if let Some(target_schema) = self.db.schemas.get(target_id) {
let mut bypass_node = node.clone();
bypass_node.schema = std::sync::Arc::new(target_schema.clone());
let mut bypassed_args = self.compile_select_clause(r#type, table_aliases, bypass_node)?;
select_args.append(&mut bypassed_args);
return Ok(select_args);
}
}
select_args.push(format!("'id', {}.id", base_alias));
let mut case_node = node.clone();
case_node.parent_alias = base_alias.clone();
let arc_aliases = std::sync::Arc::new(table_aliases.clone());
case_node.parent_type_aliases = Some(arc_aliases);
let (case_sql, _) = self.compile_one_of(case_node)?;
select_args.push(format!("'{}', {}", disc.unwrap(), case_sql));
}
Ok(select_args)
}
fn compile_object(
&mut self,
props: &std::collections::BTreeMap<String, std::sync::Arc<crate::database::schema::Schema>>,
@ -301,8 +267,25 @@ impl<'a> Compiler<'a> {
for (disc_val, target_id) in options {
if let Some(target_schema) = self.db.schemas.get(target_id) {
let mut child_node = node.clone();
child_node.schema = std::sync::Arc::new(target_schema.clone());
let (val_sql, _) = self.compile_node(child_node)?;
child_node.schema = Arc::clone(target_schema);
child_node.is_polymorphic_branch = true;
let val_sql = if disc == "kind" && node.parent_type.is_some() && node.parent_type_aliases.is_some() {
let aliases_arc = node.parent_type_aliases.as_ref().unwrap();
let aliases = aliases_arc.as_ref();
let p_type = node.parent_type.unwrap();
let select_args = self.compile_select_clause(p_type, aliases, child_node.clone())?;
if select_args.is_empty() {
"jsonb_build_object()".to_string()
} else {
format!("jsonb_build_object({})", select_args.join(", "))
}
} else {
let (sql, _) = self.compile_node(child_node)?;
sql
};
case_statements.push(format!(
"WHEN {}.{} = '{}' THEN ({})",
@ -365,18 +348,18 @@ impl<'a> Compiler<'a> {
let prop_schema = &merged_props[prop_key];
let is_object_or_array = match &prop_schema.obj.type_ {
Some(crate::database::schema::SchemaTypeOrArray::Single(s)) => {
Some(crate::database::object::SchemaTypeOrArray::Single(s)) => {
s == "object" || s == "array"
}
Some(crate::database::schema::SchemaTypeOrArray::Multiple(v)) => {
Some(crate::database::object::SchemaTypeOrArray::Multiple(v)) => {
v.contains(&"object".to_string()) || v.contains(&"array".to_string())
}
_ => false,
};
let is_custom_object_pointer = match &prop_schema.obj.type_ {
Some(crate::database::schema::SchemaTypeOrArray::Single(s)) => {
!crate::database::schema::is_primitive_type(s)
Some(crate::database::object::SchemaTypeOrArray::Single(s)) => {
!crate::database::object::is_primitive_type(s)
}
_ => false,
};
@ -426,6 +409,7 @@ impl<'a> Compiler<'a> {
} else {
format!("{}/{}", node.ast_path, prop_key)
},
is_polymorphic_branch: false,
};
let (val_sql, val_type) = self.compile_node(child_node)?;
@ -465,6 +449,8 @@ impl<'a> Compiler<'a> {
self.compile_filter_conditions(r#type, type_aliases, &node, &base_alias, &mut where_clauses);
self.compile_polymorphic_bounds(r#type, type_aliases, &node, &mut where_clauses);
let start_len = where_clauses.len();
self.compile_relation_conditions(
r#type,
type_aliases,
@ -473,6 +459,14 @@ impl<'a> Compiler<'a> {
&mut where_clauses,
)?;
if node.is_polymorphic_branch && where_clauses.len() == start_len {
if let Some(parent_aliases) = &node.parent_type_aliases {
if let Some(outer_entity_alias) = parent_aliases.get("entity") {
where_clauses.push(format!("{}.id = {}.id", entity_alias, outer_entity_alias));
}
}
}
Ok(where_clauses)
}