expression evaluation API change

cozo-bin/src/repl.rs

@@ -214,9 +214,7 @@ fn process_line(
         match op {
             "eval" => {
                 let out = evaluate_expressions(payload, params, params)?;
-                for val in out {
-                    println!("{val}");
-                }
+                println!("{out}");
             }
             "set" => {
                 let (key, v_str) = payload

cozo-core/src/cozoscript.pest

@@ -268,4 +268,4 @@ fts_and = {"AND"}
 fts_or = {"OR" | "," | ";"}
 fts_not = {"NOT"}
 
-expression_script = {SOI ~ expr ~ ("," ~ expr)* ~ EOI}
+expression_script = {SOI ~ expr ~ EOI}

cozo-core/src/parse/mod.rs

@@ -213,8 +213,7 @@ pub(crate) fn parse_type(src: &str) -> Result<NullableColType> {
 pub(crate) fn parse_expressions(
     src: &str,
     param_pool: &BTreeMap<String, DataValue>,
-) -> Result<Vec<Expr>> {
-    let mut ret = vec![];
+) -> Result<Expr> {
     let parsed = CozoScriptParser::parse(Rule::expression_script, src)
         .map_err(|err| {
             let span = match err.location {
@@ -224,18 +223,9 @@ pub(crate) fn parse_expressions(
             ParseError { span }
         })?
         .next()
-        .unwrap()
-        .into_inner();
-    for rule in parsed {
-        match rule.as_rule() {
-            Rule::expr => {
-                ret.push(build_expr(rule, param_pool)?);
-            }
-            Rule::EOI => {}
-            _ => unreachable!(),
-        }
-    }
-    Ok(ret)
+        .unwrap();
+
+    Ok(build_expr(parsed.into_inner().next().unwrap(), param_pool)?)
 }
 
 pub(crate) fn parse_script(

cozo-core/src/runtime/db.rs

@@ -1829,7 +1829,7 @@ pub fn evaluate_expressions(
     src: &str,
     params: &BTreeMap<String, DataValue>,
     vars: &BTreeMap<String, DataValue>,
-) -> Result<Vec<DataValue>> {
+) -> Result<DataValue> {
     _evaluate_expressions(src, params, vars).map_err(|err| {
         if err.source().is_none() {
             err.with_source_code(format!("{src} "))
@@ -1854,29 +1854,21 @@ fn _evaluate_expressions(
     src: &str,
     params: &BTreeMap<String, DataValue>,
     vars: &BTreeMap<String, DataValue>,
-) -> Result<Vec<DataValue>> {
-    let mut exprs = parse_expressions(src, params)?;
+) -> Result<DataValue> {
+    let mut expr = parse_expressions(src, params)?;
     let mut ctx = vec![];
     let mut binding_map = BTreeMap::new();
     for (i, (k, v)) in vars.iter().enumerate() {
         ctx.push(v.clone());
         binding_map.insert(Symbol::new(k, Default::default()), i);
     }
-    let mut ret = vec![];
-    for expr in exprs.iter_mut() {
     expr.fill_binding_indices(&binding_map)?;
-        ret.push(expr.eval(&ctx)?);
-    }
-    Ok(ret)
+    expr.eval(&ctx)
 }
 
 fn _get_variables(src: &str, params: &BTreeMap<String, DataValue>) -> Result<BTreeSet<String>> {
-    let mut exprs = parse_expressions(src, params)?;
-    let mut ret = BTreeSet::new();
-    for expr in exprs.iter_mut() {
-        ret.extend(expr.get_variables()?);
-    }
-    Ok(ret)
+    let expr = parse_expressions(src, params)?;
+    expr.get_variables()
 }
 
 /// Used for user-initiated termination of running queries

cozo-lib-python/src/lib.rs

@@ -417,11 +417,11 @@ fn eval_expressions(
     query: &str,
     params: &PyDict,
     bindings: &PyDict,
-) -> PyResult<Vec<PyObject>> {
+) -> PyResult<PyObject> {
     let params = convert_params(params).unwrap();
     let bindings = convert_params(bindings).unwrap();
     match evaluate_expressions(query, &params, &bindings) {
-        Ok(rows) => Ok(rows.into_iter().map(|r| value_to_py(r, py)).collect()),
+        Ok(v) => Ok(value_to_py(v, py)),
         Err(err) => {
             let reports = format_error_as_json(err, Some(query)).to_string();
             let json_mod = py.import("json")?;