1#![forbid(unsafe_code)]
28
29pub mod error;
30pub mod exec;
31#[cfg(feature = "json")]
32pub mod json;
33pub mod rewrite;
34pub mod tables;
35
36pub use error::{Result, SynalogError};
37pub use exec::{SynalogJob, SynalogResult};
38pub use oxilite_core::sql::SqlValue;
39pub use synalog;
41pub use tables::Table;
42
43use oxilite_core::sql::Capabilities;
44use std::collections::HashMap;
45use std::panic::{catch_unwind, AssertUnwindSafe};
46use synalog::compiler::universe::{LogicaProgram, Pagination};
47use synalog::parser::Json;
48
49pub const ENGINES: &[&str] = synalog::compiler::dialects::SUPPORTED_ENGINES;
51
52#[derive(Debug, Clone, Default)]
55pub struct Options {
56 pub union_default_graph: bool,
58 pub include_inferred: bool,
60 pub limit: Option<u64>,
62 pub offset: Option<u64>,
64 pub tables: Vec<Table>,
66 pub as_of: Option<String>,
69 pub as_of_tick: Option<i64>,
71}
72
73#[derive(Debug, Clone)]
75pub struct Compiled {
76 pub sql: String,
78 pub columns: Vec<String>,
80 pub tables: Vec<String>,
82}
83
84fn guarded<T>(f: impl FnOnce() -> Result<T>) -> Result<T> {
86 catch_unwind(AssertUnwindSafe(f)).unwrap_or_else(|panic| {
87 let why = panic
88 .downcast_ref::<&str>()
89 .map(|s| (*s).to_owned())
90 .or_else(|| panic.downcast_ref::<String>().cloned())
91 .unwrap_or_else(|| "unknown cause".into());
92 Err(SynalogError::Compile(format!(
93 "the Synalog compiler failed: {why}"
94 )))
95 })
96}
97
98fn parse_checked(src: &str) -> Result<Json> {
100 guarded(|| {
101 let parsed = synalog::parser::parse_file(src, None, &[])
102 .map_err(|e| SynalogError::Parse(e.to_string()))?;
103 let checked = synalog::verifier::validate(&parsed);
104 if !checked.is_valid() {
105 return Err(SynalogError::Verify(
106 checked.errors.iter().map(ToString::to_string).collect(),
107 ));
108 }
109 Ok(parsed)
110 })
111}
112
113pub fn check(src: &str) -> Result<()> {
115 parse_checked(src).map(|_| ())
116}
117
118pub fn compile_for_engine(
120 src: &str,
121 predicate: &str,
122 engine: &str,
123 limit: Option<u64>,
124 offset: Option<u64>,
125) -> Result<String> {
126 if !ENGINES.contains(&engine) {
127 return Err(SynalogError::unsupported(format!(
128 "engine `{engine}`; Synalog supports {}",
129 ENGINES.join(", ")
130 )));
131 }
132 let parsed = parse_checked(src)?;
133 guarded(|| {
134 let program = program(&parsed, engine)?;
135 defined(&program, predicate)?;
136 program
137 .formatted_predicate_sql_with_pagination(predicate, &Pagination { limit, offset })
138 .map_err(|e| SynalogError::Compile(e.to_string()))
139 })
140}
141
142fn program(parsed: &Json, engine: &str) -> Result<LogicaProgram> {
143 LogicaProgram::new_with_engine(parsed, HashMap::new(), HashMap::new(), Some(engine))
144 .map_err(|e| SynalogError::Compile(e.to_string()))
145}
146
147fn defined(program: &LogicaProgram, predicate: &str) -> Result<()> {
148 if program.defined_predicates().contains(predicate) {
149 return Ok(());
150 }
151 let mut defined = program.user_defined_predicates();
152 defined.sort();
153 Err(SynalogError::UnknownPredicate {
154 predicate: predicate.to_owned(),
155 defined,
156 })
157}
158
159pub fn compile(
161 src: &str,
162 predicate: &str,
163 caps: &Capabilities,
164 options: &Options,
165) -> Result<Compiled> {
166 if options.as_of.is_some() && options.as_of_tick.is_none() {
167 return Err(SynalogError::unsupported(
168 "as_of must be resolved to a tick by the store before compiling",
169 ));
170 }
171 if options.as_of_tick.is_some() && options.include_inferred {
172 return Err(SynalogError::unsupported(
173 "inferences describe the current state only; they cannot be combined with as_of",
174 ));
175 }
176 let mut declared = tables::pragmas(src)?;
177 declared.extend(options.tables.iter().cloned());
178 tables::validate(&declared)?;
179
180 let parsed = parse_checked(src)?;
181 let (raw, columns) = guarded(|| {
182 let program = program(&parsed, "sqlite")?;
183 defined(&program, predicate)?;
184 let pagination = Pagination {
185 limit: options.limit,
186 offset: options.offset,
187 };
188 let sql = program
189 .formatted_predicate_sql_with_pagination(predicate, &pagination)
190 .map_err(|e| SynalogError::Compile(e.to_string()))?;
191 Ok((sql, program.predicate_columns(predicate)))
192 })?;
193 let body = rewrite::portable(&raw)?;
194 let (sql, tables) = tables::inject(&body, &declared, options);
195 rewrite::check_limits(&sql, caps)?;
196 Ok(Compiled {
197 sql,
198 columns,
199 tables,
200 })
201}
202
203pub fn prepare(
205 src: &str,
206 predicate: &str,
207 caps: &Capabilities,
208 options: &Options,
209) -> Result<SynalogJob> {
210 Ok(SynalogJob::new(compile(src, predicate, caps, options)?))
211}