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

chore: JSPG Engine tuple decoupling and core routing optimizations

Browse Source
This commit is contained in:
Alex Groleau
2026-04-13 22:41:32 -04:00
parent 665a821bf9
commit 0017c598e1
57 changed files with 5510 additions and 5166 deletions
Download Patch File Download Diff File Expand all files Collapse all files

252
src/queryer/compiler.rs
View File

@ -18,6 +18,7 @@ pub struct Node<'a> {
pub depth: usize,
pub ast_path: String,
pub is_polymorphic_branch: bool,
pub schema_id: Option<String>,
}
impl<'a> Compiler<'a> {
@ -47,6 +48,7 @@ impl<'a> Compiler<'a> {
depth: 0,
ast_path: String::new(),
is_polymorphic_branch: false,
schema_id: Some(schema_id.to_string()),
};
let (sql, _) = compiler.compile_node(node)?;
@ -66,17 +68,31 @@ impl<'a> Compiler<'a> {
}
fn compile_array(&mut self, node: Node<'a>) -> Result<(String, String), String> {
// 1. Array of DB Entities (`type` or `$family` pointing to a table limit)
if let Some(items) = &node.schema.obj.items {
let mut resolved_type = None;
if let Some(family_target) = items.obj.family.as_ref() {
let base_type_name = family_target
.split('.')
.next_back()
.unwrap_or(family_target);
resolved_type = self.db.types.get(base_type_name);
} else if let Some(base_type_name) = items.obj.identifier() {
resolved_type = self.db.types.get(&base_type_name);
if let Some(sid) = &node.schema_id {
resolved_type = self
.db
.types
.get(&sid.split('.').next_back().unwrap_or(sid).to_string());
}
if resolved_type.is_none() {
if let Some(family_target) = items.obj.family.as_ref() {
let base_type_name = family_target
.split('.')
.next_back()
.unwrap_or(family_target);
resolved_type = self.db.types.get(base_type_name);
} else if let Some(crate::database::object::SchemaTypeOrArray::Single(t)) = &items.obj.type_
{
if !crate::database::object::is_primitive_type(t) {
resolved_type = self
.db
.types
.get(&t.split('.').next_back().unwrap_or(t).to_string());
}
}
}
if let Some(type_def) = resolved_type {
@ -105,16 +121,28 @@ impl<'a> Compiler<'a> {
// Determine if this schema represents a Database Entity
let mut resolved_type = None;
if let Some(family_target) = node.schema.obj.family.as_ref() {
let base_type_name = family_target
.split('.')
.next_back()
.unwrap_or(family_target);
resolved_type = self.db.types.get(base_type_name);
} else if let Some(base_type_name) = node.schema.obj.identifier() {
if let Some(sid) = &node.schema_id {
let base_type_name = sid.split('.').next_back().unwrap_or(sid).to_string();
resolved_type = self.db.types.get(&base_type_name);
}
if resolved_type.is_none() {
if let Some(family_target) = node.schema.obj.family.as_ref() {
let base_type_name = family_target
.split('.')
.next_back()
.unwrap_or(family_target);
resolved_type = self.db.types.get(base_type_name);
} else if let Some(crate::database::object::SchemaTypeOrArray::Single(t)) =
&node.schema.obj.type_
{
if !crate::database::object::is_primitive_type(t) {
let base_type_name = t.split('.').next_back().unwrap_or(t).to_string();
resolved_type = self.db.types.get(&base_type_name);
}
}
}
if let Some(type_def) = resolved_type {
return self.compile_entity(type_def, node.clone(), false);
}
@ -126,6 +154,7 @@ impl<'a> Compiler<'a> {
if let Some(target_schema) = self.db.schemas.get(t) {
let mut ref_node = node.clone();
ref_node.schema = Arc::clone(target_schema);
ref_node.schema_id = Some(t.clone());
return self.compile_node(ref_node);
}
return Err(format!("Unresolved schema type pointer: {}", t));
@ -133,17 +162,21 @@ impl<'a> Compiler<'a> {
}
// Handle Polymorphism fallbacks for relations
if node.schema.obj.family.is_some() || node.schema.obj.one_of.is_some() {
if let Some(options) = node.schema.obj.compiled_options.get() {
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::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);
if let Some(options) = node.schema.obj.compiled_options.get() {
if options.len() == 1 {
let (_, target_opt) = options.values().next().unwrap();
if let Some(target_id) = target_opt {
let mut bypass_schema = crate::database::schema::Schema::default();
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);
}
}
return self.compile_one_of(node);
}
}
return self.compile_one_of(node);
}
// Just an inline object definition?
@ -171,27 +204,27 @@ impl<'a> Compiler<'a> {
let (table_aliases, from_clauses) = self.compile_from_clause(r#type);
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);
let base_alias = table_aliases
.get(&r#type.name)
.cloned()
.unwrap_or_else(|| node.parent_alias.to_string());
let (case_sql, _) = self.compile_one_of(case_node)?;
case_sql
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);
let (case_sql, _) = self.compile_one_of(case_node)?;
case_sql
} else {
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(", "))
}
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
@ -249,14 +282,21 @@ impl<'a> Compiler<'a> {
Ok((combined, "object".to_string()))
}
fn compile_one_of(
&mut self,
node: Node<'a>,
) -> Result<(String, String), String> {
fn compile_one_of(&mut self, node: Node<'a>) -> Result<(String, String), String> {
let mut case_statements = Vec::new();
let options = node.schema.obj.compiled_options.get().ok_or("Missing compiled options for polymorphism")?;
let disc = node.schema.obj.compiled_discriminator.get().ok_or("Missing compiled discriminator for polymorphism")?;
let options = node
.schema
.obj
.compiled_options
.get()
.ok_or("Missing compiled options for polymorphism")?;
let disc = node
.schema
.obj
.compiled_discriminator
.get()
.ok_or("Missing compiled discriminator for polymorphism")?;
let type_col = if let Some(prop) = &node.property_name {
format!("{}_{}", prop, disc)
@ -264,36 +304,73 @@ impl<'a> Compiler<'a> {
disc.to_string()
};
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 = Arc::clone(target_schema);
child_node.is_polymorphic_branch = true;
for (disc_val, (idx_opt, target_id_opt)) in options {
if let Some(target_id) = target_id_opt {
if let Some(target_schema) = self.db.schemas.get(target_id) {
let mut child_node = node.clone();
child_node.schema = Arc::clone(target_schema);
child_node.schema_id = Some(target_id.clone());
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() {
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 {
} else {
format!("jsonb_build_object({})", select_args.join(", "))
}
} else {
let (sql, _) = self.compile_node(child_node)?;
sql
};
}
} else {
let (sql, _) = self.compile_node(child_node)?;
sql
};
case_statements.push(format!(
"WHEN {}.{} = '{}' THEN ({})",
node.parent_alias, type_col, disc_val, val_sql
));
case_statements.push(format!(
"WHEN {}.{} = '{}' THEN ({})",
node.parent_alias, type_col, disc_val, val_sql
));
}
} else if let Some(idx) = idx_opt {
if let Some(target_schema) = node
.schema
.obj
.one_of
.as_ref()
.and_then(|options| options.get(*idx))
{
let mut child_node = node.clone();
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 ({})",
node.parent_alias, type_col, disc_val, val_sql
));
}
}
}
if case_statements.is_empty() {
return Ok(("NULL".to_string(), "string".to_string()));
}
@ -339,14 +416,14 @@ impl<'a> Compiler<'a> {
let mut select_args = Vec::new();
let grouped_fields = r#type.grouped_fields.as_ref().and_then(|v| v.as_object());
let default_props = std::collections::BTreeMap::new();
let merged_props = node.schema.obj.compiled_properties.get().unwrap_or(&default_props);
let mut sorted_keys: Vec<&String> = merged_props.keys().collect();
sorted_keys.sort();
for prop_key in sorted_keys {
let prop_schema = &merged_props[prop_key];
let merged_props = node
.schema
.obj
.compiled_properties
.get()
.unwrap_or(&default_props);
for (prop_key, prop_schema) in merged_props {
let is_object_or_array = match &prop_schema.obj.type_ {
Some(crate::database::object::SchemaTypeOrArray::Single(s)) => {
s == "object" || s == "array"
@ -410,6 +487,7 @@ impl<'a> Compiler<'a> {
format!("{}/{}", node.ast_path, prop_key)
},
is_polymorphic_branch: false,
schema_id: None,
};
let (val_sql, val_type) = self.compile_node(child_node)?;
@ -449,7 +527,7 @@ 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,
@ -491,8 +569,12 @@ impl<'a> Compiler<'a> {
.unwrap_or(family_target)
.to_string(),
);
} else if let Some(lookup_key) = prop_schema.obj.identifier() {
bound_type_name = Some(lookup_key);
} else if let Some(crate::database::object::SchemaTypeOrArray::Single(t)) =
&prop_schema.obj.type_
{
if !crate::database::object::is_primitive_type(t) {
bound_type_name = Some(t.split('.').next_back().unwrap_or(t).to_string());
}
}
if let Some(type_name) = bound_type_name {