use std::collections::HashMap;
use std::path::Path;
use fhir_sqlite_map::model::{
Elem, ElemKind, Prim, RelMap, ResourceMap, SearchDef, SearchTarget, SearchTy, TargetKind,
};
use serde_json::Value;
use crate::GenError;
use crate::names::ucfirst;
pub fn compile_search(map: &mut RelMap, definitions_dir: &Path) -> Result<(), GenError> {
let path = definitions_dir.join("search-parameters.json");
let bytes =
std::fs::read(&path).map_err(|e| GenError::Spec(format!("{}: {e}", path.display())))?;
let bundle: Value = serde_json::from_slice(&bytes)
.map_err(|e| GenError::Spec(format!("{}: {e}", path.display())))?;
let mut by_base: HashMap<String, Vec<(String, SearchTy, Option<String>)>> = HashMap::new();
for entry in bundle
.get("entry")
.and_then(Value::as_array)
.into_iter()
.flatten()
{
let Some(res) = entry.get("resource") else {
continue;
};
if res.get("resourceType").and_then(Value::as_str) != Some("SearchParameter") {
continue;
}
let Some(code) = res.get("code").and_then(Value::as_str) else {
continue;
};
let Some(ty) = res.get("type").and_then(Value::as_str).map(search_ty) else {
continue;
};
let expr = res
.get("expression")
.and_then(Value::as_str)
.map(str::to_string);
for base in res
.get("base")
.and_then(Value::as_array)
.into_iter()
.flatten()
.filter_map(Value::as_str)
{
by_base
.entry(base.to_string())
.or_default()
.push((code.to_string(), ty, expr.clone()));
}
}
for (rname, rm) in map.resources.iter_mut() {
let Some(params) = by_base.get(rname) else {
continue;
};
let mut defs = Vec::new();
for (code, ty, expr) in params {
defs.push(compile_param(rm, rname, code, *ty, expr.as_deref()));
}
defs.sort_by(|a, b| a.code.cmp(&b.code));
rm.search = defs;
}
Ok(())
}
fn search_ty(s: &str) -> SearchTy {
match s {
"number" => SearchTy::Number,
"date" => SearchTy::Date,
"string" => SearchTy::String,
"token" => SearchTy::Token,
"reference" => SearchTy::Reference,
"composite" => SearchTy::Composite,
"quantity" => SearchTy::Quantity,
"uri" => SearchTy::Uri,
_ => SearchTy::Special,
}
}
fn unsupported(code: &str, ty: SearchTy, note: &str) -> SearchDef {
SearchDef {
code: code.to_string(),
ty,
targets: Vec::new(),
note: Some(note.to_string()),
}
}
fn compile_param(
rm: &ResourceMap,
rname: &str,
code: &str,
ty: SearchTy,
expr: Option<&str>,
) -> SearchDef {
if matches!(ty, SearchTy::Composite | SearchTy::Special) {
return unsupported(code, ty, "composite/special parameters are not compiled");
}
let Some(expr) = expr else {
return unsupported(code, ty, "no expression");
};
let mut targets = Vec::new();
let mut notes = Vec::new();
for alt in split_top(expr, '|') {
match compile_alt(rm, rname, alt.trim(), ty) {
Ok(mut t) => targets.append(&mut t),
Err(n) => notes.push(n),
}
}
let mut seen = std::collections::HashSet::new();
targets.retain(|t| seen.insert(format!("{:?}", t)));
SearchDef {
code: code.to_string(),
ty,
targets,
note: if notes.is_empty() {
None
} else {
Some(notes.join("; "))
},
}
}
fn split_top(s: &str, sep: char) -> Vec<&str> {
let mut out = Vec::new();
let mut depth = 0usize;
let mut start = 0usize;
for (i, c) in s.char_indices() {
match c {
'(' => depth += 1,
')' => depth = depth.saturating_sub(1),
c if c == sep && depth == 0 => {
out.push(&s[start..i]);
start = i + 1;
}
_ => {}
}
}
out.push(&s[start..]);
out
}
fn compile_alt(
rm: &ResourceMap,
rname: &str,
alt: &str,
ty: SearchTy,
) -> Result<Vec<SearchTarget>, String> {
let mut alt = alt.trim();
let mut cast: Option<String> = None;
if alt.starts_with('(') && alt.ends_with(')') {
let inner = &alt[1..alt.len() - 1];
if let Some((path, casttype)) = inner.rsplit_once(" as ") {
alt = path.trim();
cast = Some(casttype.trim().to_string());
} else {
alt = inner.trim();
}
}
let mut segs: Vec<String> = split_top(alt, '.')
.into_iter()
.map(|s| s.trim().to_string())
.collect();
if let Some(c) = cast {
segs.push(format!("ofType({c})"));
}
if segs.first().map(String::as_str) != Some(rname) {
return Err(format!("path does not start at {rname}: {alt:?}"));
}
segs.remove(0);
let mut table: u32 = 0;
let mut node = rm.root;
let mut leaf: Option<&Elem> = None;
let mut i = 0usize;
while i < segs.len() {
let seg = &segs[i];
i += 1;
if let Some(arg) = seg.strip_prefix("where(").and_then(|s| s.strip_suffix(')')) {
let a = arg.trim();
let is_value_restriction = a.split_once('=').is_some_and(|(lhs, rhs)| {
!lhs.contains('(')
&& !lhs.trim().is_empty()
&& lhs.trim().chars().all(|c| c.is_alphanumeric() || c == '_')
&& rhs.trim().starts_with('\'')
});
if is_value_restriction {
return Err(format!(
"where() value restriction cannot be dropped: {seg:?}"
));
}
continue; }
if seg == "first()" || seg == "exists()" {
continue;
}
if seg.starts_with("extension(") {
return Err("extension() paths are not compiled".to_string());
}
if let Some(t) = seg
.strip_prefix("ofType(")
.or_else(|| seg.strip_prefix("as("))
.and_then(|s| s.strip_suffix(')'))
{
let Some(elem) = leaf else {
return Err(format!("cast with no preceding element: {alt:?}"));
};
let ElemKind::Choice(variants) = &elem.kind else {
continue;
};
if let Some(t) = elem.table {
table = t;
}
let want = format!("{}{}", elem.json, ucfirst(t.trim()));
let Some(var) = variants.iter().find(|v| v.json == want) else {
return Err(format!("no choice variant {want:?}"));
};
leaf = Some(var);
continue;
}
if seg.contains('(') {
return Err(format!("unsupported function segment {seg:?}"));
}
if let Some(elem) = leaf {
match &elem.kind {
ElemKind::Group(n) => {
if let Some(t) = elem.table {
table = t;
}
node = *n;
}
ElemKind::Choice(_) => {
return Err(format!("choice {:?} navigated without ofType()", elem.json));
}
_ => return Err(format!("cannot navigate into {:?}", elem.json)),
}
}
let Some(elem) = rm.node(node).elems.iter().find(|e| e.json == *seg) else {
return Err(format!("no element {seg:?} under {alt:?}"));
};
leaf = Some(elem);
}
let Some(elem) = leaf else {
return Err(format!("empty path {alt:?}"));
};
targets_for(rm, table, node, elem, ty).map_err(|n| format!("{alt:?}: {n}"))
}
fn targets_for(
rm: &ResourceMap,
table: u32,
_node: u32,
elem: &Elem,
ty: SearchTy,
) -> Result<Vec<SearchTarget>, String> {
let (etable, enode) = match &elem.kind {
ElemKind::Group(n) => (elem.table.unwrap_or(table), *n),
_ => (elem.table.unwrap_or(table), u32::MAX),
};
let one = |t: u32, kind: TargetKind| Ok(vec![SearchTarget { table: t, kind }]);
match (&elem.kind, ty) {
(ElemKind::Choice(variants), _) => {
let mut out = Vec::new();
for var in variants {
if let Ok(mut t) = targets_for(rm, elem.table.unwrap_or(table), _node, var, ty) {
out.append(&mut t);
}
}
if out.is_empty() {
Err("no compilable choice variant".to_string())
} else {
Ok(out)
}
}
(ElemKind::Prim(pc), SearchTy::Token) => one(
etable,
TargetKind::Token {
system: None,
code: pc.col.clone(),
},
),
(ElemKind::Prim(pc), SearchTy::String) => one(
etable,
TargetKind::Str {
col: pc.col.clone(),
norm: None,
},
),
(ElemKind::Prim(pc), SearchTy::Uri) => one(
etable,
TargetKind::Uri {
col: pc.col.clone(),
},
),
(ElemKind::Prim(pc), SearchTy::Number) => match pc.prim {
Prim::Int | Prim::Int64 | Prim::Decimal => one(
etable,
TargetKind::Number {
col: pc.col.clone(),
},
),
_ => Err("number parameter on non-numeric element".to_string()),
},
(ElemKind::Prim(pc), SearchTy::Date) => match &pc.sort {
Some(sc) => one(
etable,
TargetKind::Date {
lo: sc.clone(),
hi: None,
},
),
None => Err("date parameter on element without a sort column".to_string()),
},
(ElemKind::Prim(pc), SearchTy::Reference) => {
one(
etable,
TargetKind::Uri {
col: pc.col.clone(),
},
)
}
(ElemKind::Group(_), _) => group_targets(rm, etable, enode, elem, ty),
(ElemKind::RefStr(rc), SearchTy::Reference) => one(
etable,
TargetKind::Reference {
c_type: rc.c_type.clone(),
c_id: rc.c_id.clone(),
c_url: rc.c_url.clone(),
},
),
_ => Err(format!("cannot compile {:?} parameter here", ty)),
}
}
fn group_targets(
rm: &ResourceMap,
table: u32,
node: u32,
elem: &Elem,
ty: SearchTy,
) -> Result<Vec<SearchTarget>, String> {
let elems = &rm.node(node).elems;
let find = |name: &str| elems.iter().find(|e| e.json == name);
let prim_col = |name: &str| -> Option<(u32, String, Option<String>)> {
find(name).and_then(|e| match &e.kind {
ElemKind::Prim(pc) => Some((e.table.unwrap_or(table), pc.col.clone(), pc.sort.clone())),
_ => None,
})
};
match ty {
SearchTy::Token => {
if let Some(coding) = find("coding")
&& let ElemKind::Group(cn) = coding.kind
{
return group_targets(
rm,
coding.table.unwrap_or(table),
cn,
coding,
SearchTy::Token,
);
}
if let (Some((st, sys, _)), Some((ct, code, _))) =
(prim_col("system"), prim_col("code"))
&& st == ct
{
return Ok(vec![SearchTarget {
table: ct,
kind: TargetKind::Token {
system: Some(sys),
code,
},
}]);
}
if let (Some((st, sys, _)), Some((vt, value, _))) =
(prim_col("system"), prim_col("value"))
&& st == vt
{
return Ok(vec![SearchTarget {
table: vt,
kind: TargetKind::Token {
system: Some(sys),
code: value,
},
}]);
}
Err(format!("no token shape in {:?}", elem.json))
}
SearchTy::String => {
let mut out = Vec::new();
for part in [
"family",
"text",
"city",
"district",
"state",
"postalCode",
"country",
] {
if let Some((t, col, _)) = prim_col(part) {
out.push(SearchTarget {
table: t,
kind: TargetKind::Str { col, norm: None },
});
}
}
for part in ["given", "line", "prefix", "suffix"] {
if let Some(e) = find(part)
&& let (ElemKind::Prim(pc), Some(t)) = (&e.kind, e.table)
{
out.push(SearchTarget {
table: t,
kind: TargetKind::Str {
col: pc.col.clone(),
norm: None,
},
});
}
}
if out.is_empty() {
Err(format!("no string parts in {:?}", elem.json))
} else {
Ok(out)
}
}
SearchTy::Date => {
if let (Some((t1, _, Some(lo))), Some((t2, _, Some(hi)))) =
(prim_col("start"), prim_col("end"))
&& t1 == t2
{
return Ok(vec![SearchTarget {
table: t1,
kind: TargetKind::Date { lo, hi: Some(hi) },
}]);
}
Err(format!("no date shape in {:?}", elem.json))
}
SearchTy::Quantity => {
if let Some((t, value, _)) = prim_col("value") {
let system = prim_col("system").filter(|(st, ..)| *st == t).map(|x| x.1);
let code = prim_col("code")
.filter(|(ct, ..)| *ct == t)
.map(|x| x.1)
.or_else(|| {
prim_col("currency")
.filter(|(ct, ..)| *ct == t)
.map(|x| x.1)
});
return Ok(vec![SearchTarget {
table: t,
kind: TargetKind::Quantity {
value,
system,
code,
},
}]);
}
Err(format!("no quantity shape in {:?}", elem.json))
}
SearchTy::Reference => {
if let Some(r) = elems.iter().find_map(|e| match &e.kind {
ElemKind::RefStr(rc) => Some(rc.clone()),
_ => None,
}) {
return Ok(vec![SearchTarget {
table,
kind: TargetKind::Reference {
c_type: r.c_type,
c_id: r.c_id,
c_url: r.c_url,
},
}]);
}
if let Some(inner) = find("reference")
&& let ElemKind::Group(n) = inner.kind
{
return group_targets(rm, inner.table.unwrap_or(table), n, inner, ty);
}
Err(format!("no reference shape in {:?}", elem.json))
}
_ => Err(format!("cannot compile {ty:?} on complex {:?}", elem.json)),
}
}
pub fn add_norm_columns(map: &mut RelMap) {
use crate::names::Registry;
use fhir_sqlite_map::model::{ColTy, Column};
for rm in map.resources.values_mut() {
let mut regs: Vec<Registry> = rm
.tables
.iter()
.map(|t| Registry::seeded(t.cols.iter().map(|c| c.name.as_str())))
.collect();
let mut wanted: Vec<(u32, String)> = Vec::new();
for def in &rm.search {
for t in &def.targets {
if let TargetKind::Str { col, norm: None } = &t.kind {
wanted.push((t.table, col.clone()));
}
}
}
let mut assigned: HashMap<(u32, String), String> = HashMap::new();
for (table, col) in wanted {
let key = (table, col.clone());
if assigned.contains_key(&key) {
continue;
}
let t = &mut rm.tables[table as usize];
if let Some((_, existing)) = t.norm_cols.iter().find(|(src, _)| *src == col) {
assigned.insert(key, existing.clone());
continue;
}
let path = t
.cols
.iter()
.find(|c| c.name == col)
.map(|c| c.path.clone())
.unwrap_or_default();
let name = regs[table as usize].claim(&format!("{col}_norm"));
t.cols.push(Column {
name: name.clone(),
ty: ColTy::TextC,
path,
});
t.norm_cols.push((col.clone(), name.clone()));
assigned.insert(key, name);
}
for def in &mut rm.search {
for t in &mut def.targets {
if let TargetKind::Str { col, norm } = &mut t.kind
&& norm.is_none()
&& let Some(n) = assigned.get(&(t.table, col.clone()))
{
*norm = Some(n.clone());
}
}
}
}
}
pub fn add_adjunct_columns(map: &mut RelMap) {
use crate::names::Registry;
use fhir_sqlite_map::model::{Adjuncts, ColTy, Column, TableKind};
if !fhir_sqlite_map::ddl::TEXT_ADJUNCTS {
return;
}
for rm in map.resources.values_mut() {
let mut regs: Vec<Registry> = rm
.tables
.iter()
.map(|t| Registry::seeded(t.cols.iter().map(|c| c.name.as_str())))
.collect();
let mut want: HashMap<(u32, String), (bool, bool)> = HashMap::new();
for def in &rm.search {
for t in &def.targets {
let (cols, need): (Vec<&String>, (bool, bool)) = match &t.kind {
TargetKind::Str { col, .. } => (vec![col], (true, true)),
TargetKind::Token { system, code } => (
system.iter().chain(std::iter::once(code)).collect(),
(false, true),
),
TargetKind::Uri { col } => (vec![col], (true, true)),
TargetKind::Reference {
c_type,
c_id,
c_url,
} => (vec![c_type, c_id, c_url], (false, true)),
_ => (Vec::new(), (false, false)),
};
for c in cols {
let e = want.entry((t.table, c.clone())).or_insert((false, false));
e.0 |= need.0;
e.1 |= need.1;
}
}
}
for (ti, t) in rm.tables.iter().enumerate() {
if !matches!(t.kind, TableKind::Ext | TableKind::Deep) {
continue;
}
for (col, need) in [
("url", (true, true)),
("v_text", (true, true)),
("leaf", (false, true)),
] {
if t.cols.iter().any(|c| c.name == col) {
let e = want
.entry((u32::try_from(ti).expect("table index"), col.to_string()))
.or_insert((false, false));
e.0 |= need.0;
e.1 |= need.1;
}
}
}
let mut keys: Vec<((u32, String), (bool, bool))> = want.into_iter().collect();
keys.sort();
for ((table, col), (bounded, digest)) in keys {
if !bounded && !digest {
continue;
}
let t = &mut rm.tables[table as usize];
if t.adjunct_cols.iter().any(|a| a.source == col) {
continue;
}
let Some(src) = t.cols.iter().find(|c| c.name == col) else {
continue;
};
if !fhir_sqlite_map::ddl::needs_adjunct(src.ty) {
continue;
}
let path = src.path.clone();
let idx = bounded.then(|| regs[table as usize].claim(&format!("{col}_idx")));
let dig = digest.then(|| regs[table as usize].claim(&format!("{col}_h")));
if let Some(n) = &idx {
t.cols.push(Column {
name: n.clone(),
ty: ColTy::TextIdx,
path: path.clone(),
});
}
if let Some(n) = &dig {
t.cols.push(Column {
name: n.clone(),
ty: ColTy::Digest,
path,
});
}
t.adjunct_cols.push(Adjuncts {
source: col,
bounded: idx,
digest: dig,
});
}
}
}
#[cfg(test)]
mod where_restriction_tests {
fn is_value_restriction(arg: &str) -> bool {
let a = arg.trim();
a.split_once('=').is_some_and(|(lhs, rhs)| {
!lhs.contains('(')
&& !lhs.trim().is_empty()
&& lhs.trim().chars().all(|c| c.is_alphanumeric() || c == '_')
&& rhs.trim().starts_with('\'')
})
}
#[test]
fn value_restriction_is_refused() {
for a in [
"type='composed-of'",
"type='depends-on'",
"type='derived-from'",
"type='predecessor'",
"type='successor'",
" code = 'final' ",
] {
assert!(is_value_restriction(a), "must refuse: {a:?}");
}
}
#[test]
fn type_restriction_stays_lenient() {
for a in [
"resolve() is Patient",
"resolve() is Practitioner",
"$this is Reference",
] {
assert!(!is_value_restriction(a), "must stay lenient: {a:?}");
}
}
}
#[cfg(test)]
mod adjunct_rules {
use fhir_sqlite_map::ddl::{TEXT_ADJUNCTS, needs_adjunct};
use fhir_sqlite_map::model::ColTy;
#[test]
fn indexable_types_never_need_an_adjunct() {
for ty in [
ColTy::Bool,
ColTy::Int,
ColTy::BigInt,
ColTy::Date,
ColTy::Timestamptz,
ColTy::TextC,
ColTy::TextIdx,
ColTy::Digest,
] {
assert!(
!needs_adjunct(ty),
"{ty:?} indexes and compares as bound; an adjunct over it is a \
column nothing reads"
);
}
}
#[test]
fn the_two_dialect_answers_agree() {
let any = [ColTy::Text, ColTy::Numeric, ColTy::Jsonb]
.into_iter()
.any(needs_adjunct);
assert_eq!(
any, TEXT_ADJUNCTS,
"TEXT_ADJUNCTS says {TEXT_ADJUNCTS} but needs_adjunct says {any}"
);
}
}