support unscoped map in select

src/algebra/op/select.rs

@@ -2,7 +2,7 @@ use crate::algebra::op::RelationalAlgebra;
 use crate::algebra::parser::{assert_rule, build_relational_expr, AlgebraParseError};
 use crate::context::TempDbContext;
 use crate::data::expr::{Expr, StaticExpr};
-use crate::data::parser::parse_scoped_dict;
+use crate::data::parser::{parse_keyed_dict, parse_scoped_dict};
 use crate::data::tuple::{DataKind, OwnTuple};
 use crate::data::tuple_set::{
     BindingMap, BindingMapEvalContext, TupleSet, TupleSetEvalContext, TupleSetIdx,
@@ -41,8 +41,17 @@ impl<'a> SelectOp<'a> {
             .into_inner()
             .next()
             .unwrap();
-        assert_rule(&pair, Rule::scoped_dict, NAME_SELECT, 2)?;
+        let (binding, keys, extract_map) = match pair.as_rule() {
-        let (binding, keys, extract_map) = parse_scoped_dict(pair)?;
+            Rule::keyed_dict => {
+                let (keys, vals) = parse_keyed_dict(pair)?;
+                ("_".to_string(), keys, vals)
+            }
+            _ => {
+                assert_rule(&pair, Rule::scoped_dict, NAME_SELECT, 2)?;
+                parse_scoped_dict(pair)?
+            }
+        };
+
         if !keys.is_empty() {
             return Err(
                 AlgebraParseError::Parse("Cannot have keyed map in Select".to_string()).into(),

src/algebra/parser.rs

@@ -147,7 +147,7 @@ pub(crate) mod tests {
             let s = r#"
              From(e:Employee)
             .Where(e.id >= 122, e.id < 130)
-            .Select(f: {...e, ohhh: 123312, x: e.id})
+            .Select({...e, ohhh: 123312, x: e.id})
             "#;
             let ra = build_relational_expr(
                 &ctx,

src/data/parser.rs

@@ -324,6 +324,11 @@ pub(crate) fn parse_scoped_dict(pair: Pair) -> Result<(String, BTreeMap<String,
     let mut pairs = pair.into_inner();
     let binding = pairs.next().unwrap().as_str().to_string();
     let keyed_dict = pairs.next().unwrap();
+    let (keys, vals) = parse_keyed_dict(keyed_dict)?;
+    Ok((binding, keys, vals))
+}
+
+pub(crate) fn parse_keyed_dict(keyed_dict: Pair) -> Result<(BTreeMap<String, Expr>, Expr)> {
     let mut keys = BTreeMap::new();
     let mut spread_collected = vec![];
     let mut collected = BTreeMap::new();
@@ -377,7 +382,7 @@ pub(crate) fn parse_scoped_dict(pair: Pair) -> Result<(String, BTreeMap<String,
         }
         Expr::Apply(Arc::new(OpMerge), spread_collected)
     };
-    Ok((binding, keys, vals))
+    Ok((keys, vals))
 }
 
 #[cfg(test)]