use std::collections::HashMap;
use pyo3::exceptions::PyValueError;
use pyo3::prelude::*;
use crate::compiler::dialects;
use crate::compiler::universe::{LogicaProgram, Pagination};
use crate::parser::{parse_file, Json};
use crate::verifier::{builtin_function_names, reserved_predicate_names, validate};
fn map_err<E: std::fmt::Display>(e: E) -> PyErr {
PyValueError::new_err(e.to_string())
}
fn parse_source(
source: &str,
file_name: Option<&str>,
import_root: Option<Vec<String>>,
) -> PyResult<Json> {
parse_file(source, file_name, &import_root.unwrap_or_default()).map_err(map_err)
}
fn check_engine(engine: Option<&str>) -> PyResult<()> {
match engine {
None => Ok(()),
Some(engine) if dialects::SUPPORTED_ENGINES.contains(&engine) => Ok(()),
Some(engine) => Err(PyValueError::new_err(format!(
"Unsupported engine '{}'. Supported engines: {}.",
engine,
dialects::SUPPORTED_ENGINES.join(", ")
))),
}
}
fn build_program(parsed: &Json, engine: Option<&str>) -> PyResult<LogicaProgram> {
LogicaProgram::new_with_engine(
parsed,
HashMap::new(),
HashMap::new(),
engine,
)
.map_err(map_err)
}
#[pyfunction]
#[pyo3(signature = (source, file_name=None, engine=None, import_root=None))]
fn parse(
source: &str,
file_name: Option<&str>,
engine: Option<&str>,
import_root: Option<Vec<String>>,
) -> PyResult<String> {
check_engine(engine)?;
let parsed = parse_source(source, file_name, import_root)?;
Ok(parsed.to_string_fmt(true))
}
#[pyfunction]
#[pyo3(signature = (source, predicate, limit=None, offset=None, engine=None, import_root=None))]
fn compile(
source: &str,
predicate: &str,
limit: Option<u64>,
offset: Option<u64>,
engine: Option<&str>,
import_root: Option<Vec<String>>,
) -> PyResult<String> {
check_engine(engine)?;
let parsed = parse_source(source, None, import_root)?;
let program = build_program(&parsed, engine)?;
let pagination = Pagination { limit, offset };
program
.formatted_predicate_sql_with_pagination(predicate, &pagination)
.map_err(map_err)
}
#[pyfunction]
#[pyo3(signature = (source, predicate, pattern, limit=None, offset=None, engine=None, import_root=None))]
fn search(
source: &str,
predicate: &str,
pattern: &str,
limit: Option<u64>,
offset: Option<u64>,
engine: Option<&str>,
import_root: Option<Vec<String>>,
) -> PyResult<String> {
check_engine(engine)?;
let parsed = parse_source(source, None, import_root)?;
let program = build_program(&parsed, engine)?;
let pagination = Pagination { limit, offset };
program
.formatted_predicate_sql_with_search(predicate, pattern, &pagination)
.map_err(map_err)
}
#[pyfunction]
#[pyo3(signature = (source, engine=None, import_root=None))]
fn compile_all(
source: &str,
engine: Option<&str>,
import_root: Option<Vec<String>>,
) -> PyResult<HashMap<String, String>> {
check_engine(engine)?;
let parsed = parse_source(source, None, import_root)?;
let program = build_program(&parsed, engine)?;
let mut out = HashMap::new();
let pagination = Pagination { limit: None, offset: None };
for name in program.user_defined_predicates() {
let sql = program
.formatted_predicate_sql_with_pagination(&name, &pagination)
.map_err(map_err)?;
out.insert(name, sql);
}
Ok(out)
}
#[pyfunction]
#[pyo3(signature = (source, engine=None, import_root=None))]
fn check(
source: &str,
engine: Option<&str>,
import_root: Option<Vec<String>>,
) -> PyResult<Vec<String>> {
check_engine(engine)?;
let parsed = parse_source(source, None, import_root)?;
let result = validate(&parsed);
Ok(result.errors.iter().map(|e| e.to_string()).collect())
}
#[pyfunction]
fn reserved_predicates() -> Vec<String> {
let mut names: Vec<String> = reserved_predicate_names().iter().cloned().collect();
names.sort();
names
}
#[pyfunction]
fn builtin_functions() -> Vec<String> {
let mut names: Vec<String> = builtin_function_names().iter().cloned().collect();
names.sort();
names
}
#[pymodule]
fn _synalog(m: &Bound<'_, PyModule>) -> PyResult<()> {
m.add("SUPPORTED_ENGINES", dialects::SUPPORTED_ENGINES.to_vec())?;
m.add_function(wrap_pyfunction!(parse, m)?)?;
m.add_function(wrap_pyfunction!(compile, m)?)?;
m.add_function(wrap_pyfunction!(search, m)?)?;
m.add_function(wrap_pyfunction!(compile_all, m)?)?;
m.add_function(wrap_pyfunction!(check, m)?)?;
m.add_function(wrap_pyfunction!(reserved_predicates, m)?)?;
m.add_function(wrap_pyfunction!(builtin_functions, m)?)?;
Ok(())
}