PoC interpreting evaluator (#197)

Author: jpschorr

Cargo.toml

@@ -1,3 +1,10 @@
+[workspace.package]
+authors = ["PartiQL Team <[email protected]>"]
+homepage = "https://github.com/partiql/partiql-lang-rust"
+repository = "https://github.com/partiql/partiql-lang-rust"
+version = "0.1.0"
+edition = "2021"
+
 [workspace]
 
 members = [
@@ -6,12 +13,14 @@ members = [
   "partiql-conformance-tests",
   "partiql-conformance-test-generator",
   "partiql-source-map",
+  "partiql-logical",
   "partiql-eval",
   "partiql-ir",
   "partiql-irgen",
   "partiql-parser",
   "partiql-rewriter",
   "partiql-types",
+  "partiql-value",
 ]
 
 exclude = [

partiql-eval/Cargo.toml

@@ -1,22 +1,34 @@
 [package]
 name = "partiql-eval"
-authors = ["PartiQL Team <[email protected]>"]
 description = "PartiQL Expression Evaluator"
-homepage = "https://github.com/partiql/partiql-lang-rust"
-repository = "https://github.com/partiql/partiql-lang-rust"
+authors.workspace = true
+homepage.workspace = true
+repository.workspace = true
 license = "Apache-2.0"
 readme = "../README.md"
 keywords = ["sql", "parser", "query", "compilers", "interpreters"]
-categories = ["database", "compilers", "parser-implementations"]
+categories = ["database", "compilers"]
 exclude = [
   "**/.git/**",
   "**/.github/**",
   "**/.travis.yml",
   "**/.appveyor.yml",
 ]
-edition = "2021"
-version = "0.1.0"
+version.workspace = true
+edition.workspace = true
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+partiql-logical = { path = "../partiql-logical" }
+partiql-value = { path = "../partiql-value" }
+ordered-float = "3.*"
+itertools = "0.10.*"
+unicase = "2.*"
+
+[dev-dependencies]
+criterion = "0.4"
+
+[[bench]]
+name = "bench_eval"
+harness = false

partiql-eval/benches/bench_eval.rs

@@ -0,0 +1,103 @@
+use criterion::{black_box, criterion_group, criterion_main, Criterion};
+
+use partiql_eval::env::basic::MapBindings;
+use partiql_eval::eval::{
+    BasicContext, EvalFrom, EvalOutputAccumulator, EvalPath, EvalVarRef, Evaluable, Output,
+    PathComponent,
+};
+use partiql_value::{partiql_bag, partiql_list, Bag, BindingsName, List, Tuple, Value};
+use std::cell::RefCell;
+use std::rc::Rc;
+use std::time::Duration;
+
+fn data() -> MapBindings<Value> {
+    let employees = partiql_bag![
+        Tuple::from([
+            ("id", 3.into()),
+            ("name", "Bob Smith".into()),
+            ("title", Value::Null),
+            (
+                "projects",
+                partiql_list![
+                    "AWS Redshift Spectrum querying".into(),
+                    "AWS Redshift security".into(),
+                    "AWS Aurora security".into()
+                ]
+                .into()
+            ),
+        ])
+        .into(),
+        Tuple::from([
+            ("id", 4.into()),
+            ("name", "Susan Smith".into()),
+            ("title", "Dev Mgr".into()),
+            ("projects", partiql_list![].into()),
+        ])
+        .into(),
+        Tuple::from([
+            ("id", 6.into()),
+            ("name", "Jane Smith".into()),
+            ("title", "Software Eng 2".into()),
+            (
+                "projects",
+                partiql_list!["AWS Redshift security".into()].into()
+            ),
+        ])
+        .into(),
+    ];
+    let hr = Tuple::from([("employeesNestScalars", Value::from(employees))]);
+
+    let mut p0: MapBindings<Value> = MapBindings::default();
+    p0.insert("hr", hr.into());
+    p0
+}
+
+fn eval_bench(c: &mut Criterion) {
+    fn eval(eval: bool) {
+        let output = Rc::new(RefCell::new(EvalOutputAccumulator::default()));
+        let eout = Box::new(Output { output });
+
+        // eval plan for SELECT * FROM hr.employeesNestScalars
+        let mut from = EvalFrom::new(
+            Box::new(EvalPath {
+                expr: Box::new(EvalVarRef {
+                    name: BindingsName::CaseInsensitive("hr".to_string()),
+                }),
+                components: vec![PathComponent::Key("employeesNestScalars".to_string())],
+            }),
+            "x",
+            eout,
+        );
+
+        let ctx = BasicContext::new(data());
+        if eval {
+            from.evaluate(&ctx);
+        }
+    }
+
+    let _dummy = "dummy";
+    c.bench_function("simple", |b| b.iter(|| eval(black_box(true))));
+    c.bench_function("simple-no", |b| b.iter(|| eval(black_box(false))));
+    c.bench_function("numbers", |b| {
+        b.iter(|| {
+            black_box(Value::Integer(0));
+            black_box(Value::Integer(7));
+            black_box(Value::Integer(29));
+            black_box(Value::Integer(119));
+            black_box(Value::Integer(1209));
+            black_box(Value::Integer(12209));
+            black_box(Value::Integer(122039));
+            black_box(Value::Integer(1220339));
+            black_box(Value::Integer(12203392));
+            black_box(Value::Integer(122033942));
+        })
+    });
+}
+
+criterion_group! {
+    name = eval;
+    config = Criterion::default().measurement_time(Duration::new(5, 0));
+    targets = eval_bench
+}
+
+criterion_main!(eval);

partiql-eval/src/env.rs

@@ -0,0 +1,65 @@
+use std::fmt::Debug;
+
+use partiql_value::{BindingsName, Tuple, Value};
+use unicase::UniCase;
+
+pub trait Bindings<T> {
+    fn get(&self, name: &BindingsName) -> Option<&T>;
+}
+
+impl Bindings<Value> for Tuple {
+    fn get(&self, name: &BindingsName) -> Option<&Value> {
+        match name {
+            BindingsName::CaseSensitive(s) => self.0.get(s),
+            BindingsName::CaseInsensitive(s) => {
+                //TODO
+                self.0.get(s)
+            }
+        }
+    }
+}
+
+pub mod basic {
+    use super::*;
+    use std::collections::HashMap;
+
+    #[derive(Debug)]
+    pub struct MapBindings<T> {
+        sensitive: HashMap<String, usize>,
+        insensitive: HashMap<UniCase<String>, usize>,
+        values: Vec<T>,
+    }
+
+    impl<T> Default for MapBindings<T> {
+        fn default() -> Self {
+            MapBindings {
+                sensitive: HashMap::new(),
+                insensitive: HashMap::new(),
+                values: vec![],
+            }
+        }
+    }
+
+    impl<T> MapBindings<T> {
+        pub fn insert(&mut self, name: &str, value: T) {
+            // TODO error on duplicate insensitive
+            let idx = self.values.len();
+            self.values.push(value);
+            self.sensitive.insert(name.to_string(), idx);
+            self.insensitive.insert(UniCase::new(name.to_string()), idx);
+        }
+    }
+
+    impl<T> Bindings<T> for MapBindings<T> {
+        #[inline]
+        fn get(&self, name: &BindingsName) -> Option<&T> {
+            let idx = match name {
+                BindingsName::CaseSensitive(s) => self.sensitive.get(s),
+                BindingsName::CaseInsensitive(s) => {
+                    self.insensitive.get(&UniCase::new(s.to_string()))
+                }
+            };
+            idx.and_then(|idx| self.values.get(*idx))
+        }
+    }
+}