gqlite 1.5.1 → 1.8.0

data/ext/gqlitedb/benches/common/pokec.rs

@@ -1,8 +1,8 @@
 use std::{collections::HashSet, fs};
 
 use ccutils::temporary::TemporaryFile;
-use gqlitedb::{value_map, Connection};
-use rand::{seq::IndexedRandom, Rng};
+use gqlitedb::{Connection, value_map};
+use rand::{Rng, seq::IndexedRandom};
 use regex::Regex;
 
 /// Marker trait to keep backend-specific resources alive for the benchmark lifetime.
@@ -244,4 +244,64 @@ impl Pokec
       )
       .unwrap();
   }
+  pub(crate) fn scan_limit_1(&self)
+  {
+    self
+      .connection
+      .execute_oc_query("MATCH (n:User) RETURN n LIMIT 1", Default::default())
+      .unwrap();
+  }
+  pub(crate) fn scan_limit_10(&self)
+  {
+    self
+      .connection
+      .execute_oc_query("MATCH (n:User) RETURN n LIMIT 10", Default::default())
+      .unwrap();
+  }
+  pub(crate) fn scan_limit_100(&self)
+  {
+    self
+      .connection
+      .execute_oc_query("MATCH (n:User) RETURN n LIMIT 100", Default::default())
+      .unwrap();
+  }
+  pub(crate) fn recursive_1_2<R>(&self, rng: &mut R)
+  where
+    R: Rng + ?Sized,
+  {
+    let random_id = self.ids.choose(rng).unwrap();
+    self
+      .connection
+      .execute_oc_query(
+        "MATCH (s:User {id: $id})-[*1..2]->(n:User) RETURN n.id",
+        value_map!("$id" => *random_id),
+      )
+      .unwrap();
+  }
+  pub(crate) fn recursive_1_3<R>(&self, rng: &mut R)
+  where
+    R: Rng + ?Sized,
+  {
+    let random_id = self.ids.choose(rng).unwrap();
+    self
+      .connection
+      .execute_oc_query(
+        "MATCH (s:User {id: $id})-[*1..3]->(n:User) RETURN n.id",
+        value_map!("$id" => *random_id),
+      )
+      .unwrap();
+  }
+  pub(crate) fn recursive_1_2_filter<R>(&self, rng: &mut R)
+  where
+    R: Rng + ?Sized,
+  {
+    let random_id = self.ids.choose(rng).unwrap();
+    self
+      .connection
+      .execute_oc_query(
+        "MATCH (s:User {id: $id})-[*1..2]->(n:User) WHERE n.age >= 18 RETURN n.id",
+        value_map!("$id" => *random_id),
+      )
+      .unwrap();
+  }
 }

data/ext/gqlitedb/benches/pokec_divan.rs

@@ -1,5 +1,5 @@
 use divan::Bencher;
-use rand::{rngs::StdRng, SeedableRng};
+use rand::{SeedableRng, rngs::StdRng};
 
 mod common;
 
@@ -8,6 +8,8 @@ use common::pokec::{Pokec, PokecSize};
 const FRIEND_OF_COUNT: u32 = 100;
 const SINGLE_VERTEX_COUNT: u32 = 100;
 const IMPORT_COUNT: u32 = 30;
+const LIMIT_COUNT: u32 = 200;
+const RECURSIVE_COUNT: u32 = 100;
 
 fn main()
 {
@@ -125,7 +127,6 @@ fn aggregate_count_filter(bencher: Bencher, backend: &str)
     tiny_pokec.aggregate_count_filter();
   });
 }
-
 #[divan::bench(args = ["postgres", "sqlite", "redb"])]
 fn aggregate_min_max_avg(bencher: Bencher, backend: &str)
 {
@@ -135,3 +136,66 @@ fn aggregate_min_max_avg(bencher: Bencher, backend: &str)
     tiny_pokec.aggregate_min_max_avg();
   });
 }
+
+#[divan::bench(args = ["postgres", "sqlite", "redb"], sample_count = LIMIT_COUNT)]
+fn scan_limit_1(bencher: Bencher, backend: &str)
+{
+  let pokec = load_pokec(backend);
+
+  bencher.bench_local(move || {
+    pokec.scan_limit_1();
+  });
+}
+
+#[divan::bench(args = ["postgres", "sqlite", "redb"], sample_count = LIMIT_COUNT)]
+fn scan_limit_10(bencher: Bencher, backend: &str)
+{
+  let pokec = load_pokec(backend);
+
+  bencher.bench_local(move || {
+    pokec.scan_limit_10();
+  });
+}
+
+#[divan::bench(args = ["postgres", "sqlite", "redb"], sample_count = LIMIT_COUNT)]
+fn scan_limit_100(bencher: Bencher, backend: &str)
+{
+  let pokec = load_pokec(backend);
+
+  bencher.bench_local(move || {
+    pokec.scan_limit_100();
+  });
+}
+
+#[divan::bench(args = ["postgres", "sqlite", "redb"], sample_count = RECURSIVE_COUNT)]
+fn recursive_1_2(bencher: Bencher, backend: &str)
+{
+  let pokec = load_pokec(backend).read_ids();
+  let mut rng = StdRng::seed_from_u64(991173);
+
+  bencher.bench_local(move || {
+    pokec.recursive_1_2(&mut rng);
+  });
+}
+
+#[divan::bench(args = ["postgres", "sqlite", "redb"], sample_count = RECURSIVE_COUNT)]
+fn recursive_1_3(bencher: Bencher, backend: &str)
+{
+  let pokec = load_pokec(backend).read_ids();
+  let mut rng = StdRng::seed_from_u64(991173);
+
+  bencher.bench_local(move || {
+    pokec.recursive_1_3(&mut rng);
+  });
+}
+
+#[divan::bench(args = ["postgres", "sqlite", "redb"], sample_count = RECURSIVE_COUNT)]
+fn recursive_1_2_filter(bencher: Bencher, backend: &str)
+{
+  let pokec = load_pokec(backend).read_ids();
+  let mut rng = StdRng::seed_from_u64(991173);
+
+  bencher.bench_local(move || {
+    pokec.recursive_1_2_filter(&mut rng);
+  });
+}

data/ext/gqlitedb/benches/pokec_iai.rs

@@ -1,7 +1,7 @@
 use std::hint::black_box;
 
 use iai_callgrind::{library_benchmark, library_benchmark_group, main};
-use rand::{rngs::StdRng, SeedableRng};
+use rand::{SeedableRng, rngs::StdRng};
 
 mod common;
 
@@ -123,11 +123,68 @@ fn aggregate_min_max_avg(micro_pokec: Pokec)
   micro_pokec.aggregate_min_max_avg();
 }
 
+#[library_benchmark(setup = load_pokec)]
+#[bench::postgres("postgres")]
+#[bench::redb("redb")]
+#[bench::sqlite("sqlite")]
+fn scan_limit_1(micro_pokec: Pokec)
+{
+  micro_pokec.scan_limit_1();
+}
+
+#[library_benchmark(setup = load_pokec)]
+#[bench::postgres("postgres")]
+#[bench::redb("redb")]
+#[bench::sqlite("sqlite")]
+fn scan_limit_10(micro_pokec: Pokec)
+{
+  micro_pokec.scan_limit_10();
+}
+
+#[library_benchmark(setup = load_pokec)]
+#[bench::postgres("postgres")]
+#[bench::redb("redb")]
+#[bench::sqlite("sqlite")]
+fn scan_limit_100(micro_pokec: Pokec)
+{
+  micro_pokec.scan_limit_100();
+}
+
+#[library_benchmark(setup = load_with_ids)]
+#[bench::postgres("postgres")]
+#[bench::redb("redb")]
+#[bench::sqlite("sqlite")]
+fn recursive_1_2(micro_pokec: Pokec)
+{
+  let mut rng = StdRng::seed_from_u64(991173);
+  micro_pokec.recursive_1_2(&mut rng);
+}
+
+#[library_benchmark(setup = load_with_ids)]
+#[bench::postgres("postgres")]
+#[bench::redb("redb")]
+#[bench::sqlite("sqlite")]
+fn recursive_1_3(micro_pokec: Pokec)
+{
+  let mut rng = StdRng::seed_from_u64(991173);
+  micro_pokec.recursive_1_3(&mut rng);
+}
+
+#[library_benchmark(setup = load_with_ids)]
+#[bench::postgres("postgres")]
+#[bench::redb("redb")]
+#[bench::sqlite("sqlite")]
+fn recursive_1_2_filter(micro_pokec: Pokec)
+{
+  let mut rng = StdRng::seed_from_u64(991173);
+  micro_pokec.recursive_1_2_filter(&mut rng);
+}
+
 library_benchmark_group!(
     name = bench_micro_pokec_group;
-    benchmarks = import_micro_pokec, single_vertex, single_vertex_where, friend_of, friend_of_filter, friend_of_friend_of, friend_of_friend_of_filter, reciprocal_friends, aggregate_count, aggregate_count_filter, aggregate_min_max_avg
+    benchmarks = recursive_1_2, import_micro_pokec, single_vertex, single_vertex_where, friend_of, friend_of_filter, friend_of_friend_of, friend_of_friend_of_filter, reciprocal_friends, aggregate_count, aggregate_count_filter, aggregate_min_max_avg, scan_limit_1, scan_limit_10, scan_limit_100, recursive_1_3, recursive_1_2_filter
 );
 
 main!(
-  setup = common::get_bench_data(); 
+  setup = common::get_bench_data();
   library_benchmark_groups = bench_micro_pokec_group);

data/ext/gqlitedb/release.toml

@@ -1,7 +1,7 @@
 pre-release-replacements = [
   { file = "../../CHANGELOG.md", search = "Unreleased", replace = "{{version}}" },
-  { file = "../../CHANGELOG.md", search = "\\.\\.\\.dev/1", replace = "...{{tag_name}}", exactly = 1 },
+  { file = "../../CHANGELOG.md", search = "\\.\\.\\.dev/1", replace = "...gqlitedb-v{{version}}", exactly = 1 },
   { file = "../../CHANGELOG.md", search = "ReleaseDate", replace = "{{date}}" },
   { file = "../../CHANGELOG.md", search = "<!-- next-header -->", replace = "<!-- next-header -->\n\n## [Unreleased] - ReleaseDate", exactly = 1 },
-  { file = "../../CHANGELOG.md", search = "<!-- next-url -->", replace = "<!-- next-url -->\n[Unreleased]: https://gitlab.com/gqlite/gqlite/compare/{{tag_name}}...dev/1", exactly = 1 },
+  { file = "../../CHANGELOG.md", search = "<!-- next-url -->", replace = "<!-- next-url -->\n[Unreleased]: https://gitlab.com/auksys/gqlite/compare/gqlitedb-v{{version}}...dev/1", exactly = 1 },
 ]

data/ext/gqlitedb/src/aggregators/arithmetic.rs

@@ -2,7 +2,7 @@ use std::fmt::Debug;
 
 use super::AggregatorState;
 
-use crate::{error::RunTimeError, value::Value, Result};
+use crate::{Result, error::RunTimeError, value::Value};
 
 trait Op
 {
@@ -45,9 +45,11 @@ where
       | Value::Node(..)
       | Value::Edge(..)
       | Value::Array(..)
+      | Value::Tensor(..)
       | Value::String(..)
       | Value::TimeStamp(..)
       | Value::Map(..)
+      | Value::SinglePath(..)
       | Value::Path(..) => Err(RunTimeError::InvalidBinaryOperands)?,
       Value::Null =>
       {

data/ext/gqlitedb/src/aggregators/containers.rs

@@ -1,6 +1,6 @@
 use super::AggregatorState;
 
-use crate::{value::Value, Result};
+use crate::{Result, value::Value};
 
 #[derive(Debug)]
 struct CollectState

data/ext/gqlitedb/src/aggregators/stats.rs

@@ -26,17 +26,17 @@ impl AggregatorState for AvgState
 {
   fn next(&mut self, value: value::Value) -> crate::Result<()>
   {
-    if self.value.is_null()
-    {
-      self.value = value;
-    }
-    else
+    match value
     {
-      match value
+      value::Value::Null => Ok(()),
+      value::Value::Integer(i) =>
       {
-        value::Value::Null =>
-        {}
-        value::Value::Integer(i) =>
+        if self.value.is_null()
+        {
+          self.value = value::Value::Integer(i);
+          self.count = 1;
+        }
+        else
         {
           self.count += 1;
           match self.value
@@ -46,7 +46,16 @@ impl AggregatorState for AvgState
             _ => Err(InternalError::InvalidAggregationState)?,
           }
         }
-        value::Value::Float(f) =>
+        Ok(())
+      }
+      value::Value::Float(f) =>
+      {
+        if self.value.is_null()
+        {
+          self.value = value::Value::Float(f);
+          self.count = 1;
+        }
+        else
         {
           self.count += 1;
           match self.value
@@ -56,10 +65,10 @@ impl AggregatorState for AvgState
             _ => Err(InternalError::InvalidAggregationState)?,
           }
         }
-        _ => Err(RunTimeError::InvalidArgumentType)?,
+        Ok(())
       }
+      _ => Err(RunTimeError::InvalidArgumentType)?,
     }
-    Ok(())
   }
   fn finalise(self: Box<Self>) -> crate::Result<crate::value::Value>
   {

data/ext/gqlitedb/src/capi.rs

@@ -41,7 +41,7 @@ fn check_error(context: *mut GqliteApiContextT)
   {
     let context = unsafe { Box::from_raw(context) };
     let stri = context.string.to_str().unwrap();
-    println!("Error message '{stri:?}' was not cleared from context!");
+    log::error!("Error message '{stri:?}' was not cleared from context!");
     let _ = Box::into_raw(context);
   }
 }

data/ext/gqlitedb/src/compiler/expression_analyser.rs

@@ -1,4 +1,6 @@
-use crate::{compiler::variables_manager::VariablesManager, parser::ast, prelude::*};
+use gqlparser::oc::ast;
+
+use crate::{compiler::variables_manager::VariablesManager, prelude::*};
 
 // __     __         _       _     _     _____
 // \ \   / /_ _ _ __(_) __ _| |__ | | __|_   _|   _ _ __   ___
@@ -23,6 +25,8 @@ pub(crate) enum ExpressionType
   String,
   TimeStamp,
   Variant,
+  #[expect(dead_code)]
+  Tensor,
 }
 
 //             _ _     _       _
@@ -34,7 +38,7 @@ pub(crate) enum ExpressionType
 
 mod validators
 {
-  use crate::{error, Result};
+  use crate::{Result, error};
 
   use super::{ExpressionInfo, ExpressionType};
 
@@ -136,15 +140,15 @@ where
   }
 }
 
-impl<VT> ExpressionAnalyser for (&ast::Expression, VT)
-where
-  VT: Fn(ExpressionInfo) -> Result<ExpressionInfo>,
-{
-  fn analyse<'b>(self, analyser: &Analyser<'b>) -> Result<Vec<ExpressionInfo>>
-  {
-    Ok(vec![self.1(analyser.analyse(self.0)?)?])
-  }
-}
+// impl<VT> ExpressionAnalyser for (&ast::Expression, VT)
+// where
+//   VT: Fn(ExpressionInfo) -> Result<ExpressionInfo>,
+// {
+//   fn analyse<'b>(self, analyser: &Analyser<'b>) -> Result<Vec<ExpressionInfo>>
+//   {
+//     Ok(vec![self.1(analyser.analyse(self.0)?)?])
+//   }
+// }
 
 impl<'a, VT0, VT1> ExpressionAnalyser for ((&'a ast::Expression, &'a ast::Expression), (VT0, VT1))
 where
@@ -154,8 +158,8 @@ where
   fn analyse<'b>(self, analyser: &Analyser<'b>) -> Result<Vec<ExpressionInfo>>
   {
     Ok(vec![
-      self.1 .0(analyser.analyse(self.0 .0)?)?,
-      self.1 .1(analyser.analyse(self.0 .1)?)?,
+      self.1.0(analyser.analyse(self.0.0)?)?,
+      self.1.1(analyser.analyse(self.0.1)?)?,
     ])
   }
 }
@@ -171,17 +175,21 @@ where
 pub(crate) struct ExpressionInfo
 {
   pub(crate) expression_type: ExpressionType,
-  pub(crate) constant: bool,
+  /// runtime constant indicates a constant that can be evaluated during compilation, but
+  /// that might not always be deterministic. For instance, `toInteger(rand()*9)` is such
+  /// a contant.
+  pub(crate) runtime_constant: bool,
   pub(crate) aggregation_result: bool,
 }
 
 impl ExpressionInfo
 {
-  fn new(expression_type: ExpressionType, constant: bool, aggregation_result: bool) -> Self
+  fn new(expression_type: ExpressionType, runtime_constant: bool, aggregation_result: bool)
+  -> Self
   {
     Self {
       expression_type,
-      constant,
+      runtime_constant,
       aggregation_result,
     }
   }
@@ -190,7 +198,7 @@ impl ExpressionInfo
     let dependents = dependents.into();
     Self {
       expression_type,
-      constant: dependents.iter().all(|x| x.constant),
+      runtime_constant: dependents.iter().all(|x| x.runtime_constant),
       aggregation_result: dependents.into_iter().any(|x| x.aggregation_result),
     }
   }
@@ -254,8 +262,7 @@ impl<'b> Analyser<'b>
             &call.name,
             arguments.iter().map(|x| x.expression_type).collect(),
           )?,
-          self.functions_manager.is_deterministic(&call.name)?
-            && arguments.iter().all(|x| x.constant),
+          arguments.iter().all(|x| x.runtime_constant),
           self.functions_manager.is_aggregate(&call.name)?,
         ))
       }
@@ -410,6 +417,7 @@ impl<'b> Analyser<'b>
         match val.value
         {
           value::Value::Array(_) => ExpressionType::Array,
+          value::Value::Tensor(_) => ExpressionType::Array,
           value::Value::Key(_) => ExpressionType::Key,
           value::Value::Boolean(_) => ExpressionType::Boolean,
           value::Value::Edge(_) => ExpressionType::Edge,
@@ -418,7 +426,7 @@ impl<'b> Analyser<'b>
           value::Value::Integer(_) => ExpressionType::Integer,
           value::Value::Null => ExpressionType::Null,
           value::Value::Map(_) => ExpressionType::Map,
-          value::Value::Path(_) => ExpressionType::Path,
+          value::Value::SinglePath(_) | value::Value::Path(_) => ExpressionType::Path,
           value::Value::String(_) => ExpressionType::String,
           value::Value::TimeStamp(_) => ExpressionType::TimeStamp,
         },

data/ext/gqlitedb/src/compiler/variables_manager.rs

@@ -1,13 +1,14 @@
 use std::collections::HashMap;
 
-use crate::prelude::*;
+use gqlparser::oc::ast;
+
+use crate::{planner::LogicalPlan, prelude::*};
 
 use compiler::expression_analyser::{self, ExpressionType};
-use parser::ast;
 
 fn unknown_variable_error(name: &ast::VariableIdentifier) -> ErrorType
 {
-  InternalError::UnknownVariable {
+  CompileTimeError::UndefinedVariable {
     name: name.name().clone(),
   }
   .into()
@@ -77,7 +78,8 @@ impl Variable
             labels: ast::LabelExpression::None,
             properties: None,
           },
-          directivity: crate::graph::EdgeDirectivity::Directed,
+          directivity: graphcore::EdgeDirectivity::Directed,
+          recursive_range: None,
         }),
         variable_type: ExpressionType::Edge,
         col_id,
@@ -253,7 +255,7 @@ impl VariablesManager
               }
             }
             _ => Err(
-              InternalError::ExpectedNode {
+              CompileTimeError::ExpectedNode {
                 context: "validate_node",
               }
               .into(),
@@ -358,7 +360,7 @@ impl VariablesManager
               }
             }
             _ => Err(
-              InternalError::ExpectedNode {
+              CompileTimeError::ExpectedNode {
                 context: "is_valid_existing_node",
               }
               .into(),
@@ -413,7 +415,7 @@ impl VariablesManager
               }
             }
             _ => Err(
-              InternalError::ExpectedEdge {
+              CompileTimeError::ExpectedEdge {
                 context: "is_valid_existing_edge",
               }
               .into(),
@@ -459,7 +461,7 @@ impl VariablesManager
   fn analyse_edge_path(
     &mut self,
     path_variable: Option<ast::VariableIdentifier>,
-    edge: &crate::parser::ast::EdgePattern,
+    edge: &gqlparser::oc::ast::EdgePattern,
     is_create: bool,
   ) -> Result<()>
   {
@@ -538,7 +540,7 @@ impl VariablesManager
     self.variables = new_variables;
     Ok(())
   }
-  pub(crate) fn analyse(&mut self, statement: &ast::Statement) -> Result<()>
+  pub(crate) fn analyse(&mut self, logical_plan: &LogicalPlan) -> Result<()>
   {
     if self.variables.iter().any(|(_, var)| !var.is_set)
     {
@@ -559,17 +561,17 @@ impl VariablesManager
         .into(),
       );
     }
-    match statement
+    match logical_plan
     {
-      ast::Statement::CreateGraph(..) =>
+      LogicalPlan::CreateGraph { .. } =>
       {}
-      ast::Statement::DropGraph(..) =>
+      LogicalPlan::DropGraph { .. } =>
       {}
-      ast::Statement::UseGraph(..) =>
+      LogicalPlan::UseGraph { .. } =>
       {}
-      ast::Statement::Create(create) =>
+      LogicalPlan::Create { patterns } =>
       {
-        for pattern in create.patterns.iter()
+        for pattern in patterns.iter()
         {
           if let ast::Pattern::Node(n) = &pattern
             && self.has_variable(&n.variable)
@@ -584,31 +586,97 @@ impl VariablesManager
           self.analyse_pattern(pattern, true)?;
         }
       }
-      ast::Statement::Match(match_statement) =>
+      LogicalPlan::NodeScan { patterns, .. } =>
       {
-        for pattern in match_statement.patterns.iter()
+        for pattern in patterns.iter()
         {
           self.analyse_pattern(pattern, false)?;
         }
       }
-      ast::Statement::Return(..) =>
-      {}
-      ast::Statement::Call(..) =>
+      LogicalPlan::Filter { source, .. }
+      | LogicalPlan::Sort { source, .. }
+      | LogicalPlan::Skip { source, .. }
+      | LogicalPlan::Limit { source, .. } => self.analyse(source.as_ref())?,
+      LogicalPlan::Projection { .. } =>
       {}
-      ast::Statement::With(..) =>
+      LogicalPlan::Call { .. } =>
       {}
-      ast::Statement::Unwind(unwind) =>
+      LogicalPlan::Unwind { identifier, .. } =>
       {
-        self.declare_variable(
-          &unwind.identifier.to_owned(),
-          expression_analyser::ExpressionType::Variant,
-        )?;
-        self.mark_variables_as_set(&unwind.identifier)?;
+        self.declare_variable(identifier, expression_analyser::ExpressionType::Variant)?;
+        self.mark_variables_as_set(identifier)?;
       }
-      ast::Statement::Delete(..) =>
+      LogicalPlan::Delete { .. } =>
       {}
-      ast::Statement::Update(..) =>
+      LogicalPlan::Update { .. } =>
       {}
+      LogicalPlan::Merge { patterns, .. } =>
+      {
+        for pattern in patterns.iter()
+        {
+          match pattern
+          {
+            ast::Pattern::Node(n) =>
+            {
+              if self.has_variable(&n.variable)
+              {
+                return Err(
+                  CompileTimeError::VariableAlreadyBound {
+                    name: n.variable.as_ref().unwrap().name().clone(),
+                  }
+                  .into(),
+                );
+              }
+            }
+            ast::Pattern::Edge(e) =>
+            {
+              if self.has_variable(&e.variable)
+              {
+                return Err(
+                  CompileTimeError::VariableAlreadyBound {
+                    name: e.variable.as_ref().unwrap().name().clone(),
+                  }
+                  .into(),
+                );
+              }
+            }
+            ast::Pattern::Path(p) =>
+            {
+              if self.has_variable(&Some(p.variable.clone()))
+              {
+                return Err(
+                  CompileTimeError::VariableAlreadyBound {
+                    name: p.variable.name().clone(),
+                  }
+                  .into(),
+                );
+              }
+            }
+          }
+          self.analyse_pattern(pattern, false)?;
+        }
+      }
+      LogicalPlan::VectorSearch {
+        result_var,
+        score_var,
+        ..
+      } =>
+      {
+        // Declare the result variable as a Node
+        self.declare_variable(result_var, expression_analyser::ExpressionType::Node)?;
+        self.mark_variables_as_set(result_var)?;
+
+        // Declare the score variable if present
+        if let Some(score_var_id) = score_var
+        {
+          self.declare_variable(score_var_id, expression_analyser::ExpressionType::Float)?;
+          self.mark_variables_as_set(score_var_id)?;
+        }
+      }
+      LogicalPlan::CreateVectorIndex { .. } =>
+      {
+        // Schema operation - no variable analysis needed
+      }
     }
     Ok(())
   }