Feature/fstrings

nemo-physical/src/function.rs

@@ -1,7 +1,7 @@
 //! This module contains data structures and implementations
 //! for realizing the evaluation of functions on columnar data.
 
+pub mod evaluation;
 pub mod tree;
 
 pub(crate) mod definitions;
-pub(crate) mod evaluation;

nemo-physical/src/function/evaluation.rs

@@ -52,7 +52,7 @@ pub(crate) enum StackOperation {
 
 /// Representation of a [FunctionTree] as a stack program
 #[derive(Debug, Clone)]
-pub(crate) struct StackProgram {
+pub struct StackProgram {
     /// Maximmum size of the stack
     size: usize,
     /// List of instructions
@@ -115,7 +115,7 @@ impl StackProgram {
     }
 
     /// Construct a [StackProgram] from [FunctionTree].
-    pub(crate) fn from_function_tree<ReferenceType: Hash + Eq + Debug + Clone>(
+    pub fn from_function_tree<ReferenceType: Hash + Eq + Debug + Clone>(
         tree: &FunctionTree<ReferenceType>,
         reference_map: &HashMap<ReferenceType, usize>,
         this: Option<ReferenceType>,
@@ -263,7 +263,7 @@ impl StackProgram {
     ///
     /// # Panics
     /// Panics if the [StackProgram] is not valid.
-    pub(crate) fn evaluate_data(&self, referenced_values: &[AnyDataValue]) -> Option<AnyDataValue> {
+    pub fn evaluate_data(&self, referenced_values: &[AnyDataValue]) -> Option<AnyDataValue> {
         self.evaluate(referenced_values, None)
     }
 
@@ -274,7 +274,7 @@ impl StackProgram {
     ///
     /// # Panics
     /// Panics if the [StackProgram] is not valid.
-    pub(crate) fn evaluate_bool(
+    pub fn evaluate_bool(
         &self,
         referenced_values: &[AnyDataValue],
         this: Option<AnyDataValue>,

nemo-python/src/lib.rs

@@ -13,7 +13,7 @@ use nemo::{
     rule_model::{
         components::{fact::Fact, tag::Tag, term::primitive::Primitive, ProgramComponent},
         error::ValidationErrorBuilder,
-        term_map::PrimitiveTermMap,
+        substitution::Substitution,
     },
 };
 
@@ -269,7 +269,7 @@ impl NemoTrace {
     }
 }
 
-fn assignement_to_dict(assignment: &PrimitiveTermMap, py: Python) -> PyResult<PyObject> {
+fn assignement_to_dict(assignment: &Substitution, py: Python) -> PyResult<PyObject> {
     let dict = PyDict::new_bound(py);
     for (variable, term) in assignment {
         if let Primitive::Ground(ground) = term {

nemo/src/execution/execution_engine.rs

@@ -28,7 +28,7 @@ use crate::{
             term::primitive::{ground::GroundTerm, variable::Variable, Primitive},
         },
         program::Program,
-        term_map::PrimitiveTermMap,
+        substitution::Substitution,
     },
     table_manager::{MemoryUsage, SubtableExecutionPlan, TableManager},
 };
@@ -452,9 +452,9 @@ impl<Strategy: RuleSelectionStrategy> ExecutionEngine<Strategy> {
 
                 let rule_application = TraceRuleApplication::new(
                     rule_index,
-                    PrimitiveTermMap::new(variable_assignment.into_iter().map(
-                        |(variable, value)| (Primitive::from(variable), Primitive::from(value)),
-                    )),
+                    Substitution::new(variable_assignment.into_iter().map(|(variable, value)| {
+                        (Primitive::from(variable), Primitive::from(value))
+                    })),
                     head_index,
                 );
 

nemo/src/execution/planning/operations.rs

@@ -7,5 +7,5 @@ pub(crate) mod filter;
 pub(crate) mod functions;
 pub(crate) mod join;
 pub(crate) mod negation;
-pub(super) mod operation;
+pub(crate) mod operation;
 pub(crate) mod union;

nemo/src/execution/planning/operations/operation.rs

@@ -11,7 +11,7 @@ use crate::{
 };
 
 /// Helper function to translate a [OperationTerm] into a [FunctionTree].
-pub(super) fn operation_term_to_function_tree(
+pub(crate) fn operation_term_to_function_tree(
     translation: &VariableTranslation,
     operation_term: &OperationTerm,
 ) -> FunctionTree<OperationColumnMarker> {
@@ -56,7 +56,7 @@ macro_rules! unary {
 }
 
 /// Helper function to translate a [Operation] into a [FunctionTree].
-pub(super) fn operation_to_function_tree(
+pub(crate) fn operation_to_function_tree(
     translation: &VariableTranslation,
     operation: &Operation,
 ) -> FunctionTree<OperationColumnMarker> {

nemo/src/execution/tracing/trace.rs

@@ -15,7 +15,7 @@ use crate::{
     rule_model::{
         components::{fact::Fact, rule::Rule},
         program::Program,
-        term_map::PrimitiveTermMap,
+        substitution::Substitution,
     },
 };
 
@@ -49,14 +49,14 @@ pub(crate) struct TraceRuleApplication {
     /// Index of the rule that was applied
     rule_index: RuleIndex,
     /// Variable assignment used during the rule application
-    assignment: PrimitiveTermMap,
+    assignment: Substitution,
     /// Index of the head atom which produced the fact under consideration
     _position: usize,
 }
 
 impl TraceRuleApplication {
     /// Create new [TraceRuleApplication].
-    pub fn new(rule_index: RuleIndex, assignment: PrimitiveTermMap, _position: usize) -> Self {
+    pub fn new(rule_index: RuleIndex, assignment: Substitution, _position: usize) -> Self {
         Self {
             rule_index,
             assignment,
@@ -201,30 +201,23 @@ pub struct TraceTreeRuleApplication {
     /// Rule that was applied
     pub rule: Rule,
     /// Variable assignment used during the rule application
-    pub assignment: PrimitiveTermMap,
+    pub assignment: Substitution,
     /// Index of the head atom which produced the fact under consideration
     _position: usize,
 }
 
 impl TraceTreeRuleApplication {
-    /// Instantiate the given rule with its assignment producing a [Rule] with only ground terms.
-    fn to_instantiated_rule(&self) -> Rule {
-        let mut rule = self.rule.clone();
-        self.assignment.apply(&mut rule);
-
-        rule
-    }
-
     /// Get the [Fact] that was produced by this rule application.
     fn to_derived_atom(&self) -> Fact {
-        let rule = self.to_instantiated_rule();
-        let derived_atom = rule.head()[self._position].clone();
-        Fact::from(derived_atom)
+        let mut fact = self.rule.head()[self._position].clone();
+        self.assignment.apply(&mut fact);
+
+        Fact::from(fact)
     }
 
     /// Get a string representation of the Instantiated rule.
     fn to_instantiated_string(&self) -> String {
-        self.to_instantiated_rule().to_string()
+        self.rule.display_instantiated(&self.assignment)
     }
 }
 
@@ -562,7 +555,7 @@ mod test {
                 ProgramComponent,
             },
             program::ProgramBuilder,
-            term_map::PrimitiveTermMap,
+            substitution::Substitution,
         },
     };
 
@@ -579,7 +572,7 @@ mod test {
                 )
             });
 
-            PrimitiveTermMap::new(terms)
+            Substitution::new(terms)
         }};
     }
 

nemo/src/parser/ast/expression.rs

@@ -8,8 +8,8 @@ use basic::{
     string::StringLiteral, variable::Variable,
 };
 use complex::{
-    aggregation::Aggregation, arithmetic::Arithmetic, atom::Atom, map::Map, negation::Negation,
-    operation::Operation, parenthesized::ParenthesizedExpression, tuple::Tuple,
+    aggregation::Aggregation, arithmetic::Arithmetic, atom::Atom, fstring::FormatString, map::Map,
+    negation::Negation, operation::Operation, parenthesized::ParenthesizedExpression, tuple::Tuple,
 };
 use nom::{branch::alt, combinator::map};
 
@@ -37,6 +37,8 @@ pub enum Expression<'a> {
     Boolean(Boolean<'a>),
     /// Constant
     Constant(Constant<'a>),
+    /// Format String
+    FormatString(FormatString<'a>),
     /// Map
     Map(Map<'a>),
     /// Negation
@@ -67,6 +69,7 @@ impl<'a> Expression<'a> {
             Expression::Blank(expression) => expression.context(),
             Expression::Boolean(expression) => expression.context(),
             Expression::Constant(expression) => expression.context(),
+            Expression::FormatString(expression) => expression.context(),
             Expression::Map(expression) => expression.context(),
             Expression::Number(expression) => expression.context(),
             Expression::Negation(expression) => expression.context(),
@@ -101,6 +104,7 @@ impl<'a> Expression<'a> {
             map(Map::parse, Self::Map),
             map(Negation::parse, Self::Negation),
             map(Tuple::parse, Self::Tuple),
+            map(FormatString::parse, Self::FormatString),
         ))(input)
     }
 }
@@ -116,6 +120,7 @@ impl<'a> ProgramAST<'a> for Expression<'a> {
             Expression::Blank(expression) => expression,
             Expression::Boolean(expression) => expression,
             Expression::Constant(expression) => expression,
+            Expression::FormatString(expression) => expression,
             Expression::Map(expression) => expression,
             Expression::Number(expression) => expression,
             Expression::Negation(expression) => expression,
@@ -136,6 +141,7 @@ impl<'a> ProgramAST<'a> for Expression<'a> {
             Expression::Blank(expression) => expression.span(),
             Expression::Boolean(expression) => expression.span(),
             Expression::Constant(expression) => expression.span(),
+            Expression::FormatString(expression) => expression.span(),
             Expression::Map(expression) => expression.span(),
             Expression::Number(expression) => expression.span(),
             Expression::Negation(expression) => expression.span(),
@@ -201,6 +207,7 @@ mod test {
             ("\"\"", ParserContext::String),
             ("(1,)", ParserContext::Tuple),
             ("?variable", ParserContext::Variable),
+            ("f\"{?x + ?y}\"", ParserContext::FormatString),
         ];
 
         for (input, expect) in test {

nemo/src/parser/ast/expression/basic/string.rs

@@ -2,6 +2,7 @@
 #![allow(missing_docs)]
 
 use nom::{
+    branch::alt,
     combinator::opt,
     sequence::{delimited, pair},
 };
@@ -39,7 +40,11 @@ impl<'a> StringLiteral<'a> {
 
     /// Parse the main part of the string.
     pub fn parse_string(input: ParserInput<'a>) -> ParserResult<'a, Token<'a>> {
-        delimited(Token::quote, Token::string, Token::quote)(input)
+        delimited(
+            Token::quote,
+            alt((Token::string, Token::empty)),
+            Token::quote,
+        )(input)
     }
 
     /// Parse the language tag of the string.

nemo/src/parser/ast/expression/complex.rs

@@ -3,6 +3,7 @@
 pub mod aggregation;
 pub mod arithmetic;
 pub mod atom;
+pub mod fstring;
 pub mod infix;
 pub mod map;
 pub mod negation;