validity for algo apply

src/algo/all_pairs_shortest_path.rs

@@ -1,18 +1,16 @@
 use std::cmp::Reverse;
 use std::collections::BTreeMap;
 
+use itertools::Itertools;
 use miette::miette;
 use miette::Result;
-use itertools::Itertools;
 use ordered_float::OrderedFloat;
 use priority_queue::PriorityQueue;
 use rayon::prelude::*;
-use smartstring::{LazyCompact, SmartString};
 
 use crate::algo::shortest_path_dijkstra::dijkstra_keep_ties;
 use crate::algo::{get_bool_option_required, AlgoImpl};
-use crate::data::expr::Expr;
-use crate::data::program::{MagicAlgoRuleArg, MagicSymbol};
+use crate::data::program::{MagicAlgoApply, MagicSymbol};
 use crate::data::tuple::Tuple;
 use crate::data::value::DataValue;
 use crate::runtime::db::Poison;
@@ -25,17 +23,21 @@ impl AlgoImpl for BetweennessCentrality {
     fn run(
         &mut self,
         tx: &SessionTx,
-        rels: &[MagicAlgoRuleArg],
-        opts: &BTreeMap<SmartString<LazyCompact>, Expr>,
+        algo: &MagicAlgoApply,
         stores: &BTreeMap<MagicSymbol, DerivedRelStore>,
         out: &DerivedRelStore,
         poison: Poison,
     ) -> miette::Result<()> {
-        let edges = rels
+        let edges = algo
+            .rule_args
             .get(0)
             .ok_or_else(|| miette!("'betweenness_centrality' requires edges relation"))?;
-        let undirected =
-            get_bool_option_required("undirected", opts, Some(false), "betweenness_centrality")?;
+        let undirected = get_bool_option_required(
+            "undirected",
+            &algo.options,
+            Some(false),
+            "betweenness_centrality",
+        )?;
 
         let (graph, indices, _inv_indices, _) =
             edges.convert_edge_to_weighted_graph(undirected, false, tx, stores)?;
@@ -91,17 +93,21 @@ impl AlgoImpl for ClosenessCentrality {
     fn run(
         &mut self,
         tx: &SessionTx,
-        rels: &[MagicAlgoRuleArg],
-        opts: &BTreeMap<SmartString<LazyCompact>, Expr>,
+        algo: &MagicAlgoApply,
         stores: &BTreeMap<MagicSymbol, DerivedRelStore>,
         out: &DerivedRelStore,
         poison: Poison,
     ) -> miette::Result<()> {
-        let edges = rels
+        let edges = algo
+            .rule_args
             .get(0)
             .ok_or_else(|| miette!("'closeness_centrality' requires edges relation"))?;
-        let undirected =
-            get_bool_option_required("undirected", opts, Some(false), "closeness_centrality")?;
+        let undirected = get_bool_option_required(
+            "undirected",
+            &algo.options,
+            Some(false),
+            "closeness_centrality",
+        )?;
 
         let (graph, indices, _inv_indices, _) =
             edges.convert_edge_to_weighted_graph(undirected, false, tx, stores)?;
@@ -130,7 +136,11 @@ impl AlgoImpl for ClosenessCentrality {
     }
 }
 
-pub(crate) fn dijkstra_cost_only(edges: &[Vec<(usize, f64)>], start: usize, poison: Poison) -> Result<Vec<f64>> {
+pub(crate) fn dijkstra_cost_only(
+    edges: &[Vec<(usize, f64)>],
+    start: usize,
+    poison: Poison,
+) -> Result<Vec<f64>> {
     let mut distance = vec![f64::INFINITY; edges.len()];
     let mut pq = PriorityQueue::new();
     let mut back_pointers = vec![usize::MAX; edges.len()];

src/algo/astar.rs

@@ -4,11 +4,10 @@ use std::collections::BTreeMap;
 use miette::{miette, ensure, Result};
 use ordered_float::OrderedFloat;
 use priority_queue::PriorityQueue;
-use smartstring::{LazyCompact, SmartString};
 
 use crate::algo::AlgoImpl;
 use crate::data::expr::Expr;
-use crate::data::program::{MagicAlgoRuleArg, MagicSymbol};
+use crate::data::program::{MagicAlgoApply, MagicAlgoRuleArg, MagicSymbol};
 use crate::data::tuple::Tuple;
 use crate::data::value::DataValue;
 use crate::runtime::db::Poison;
@@ -21,12 +20,13 @@ impl AlgoImpl for ShortestPathAStar {
     fn run(
         &mut self,
         tx: &SessionTx,
-        rels: &[MagicAlgoRuleArg],
-        opts: &BTreeMap<SmartString<LazyCompact>, Expr>,
+        algo: &MagicAlgoApply,
         stores: &BTreeMap<MagicSymbol, DerivedRelStore>,
         out: &DerivedRelStore,
         poison: Poison,
     ) -> Result<()> {
+        let rels = &algo.rule_args;
+        let opts = &algo.options;
         let edges = rels
             .get(0)
             .ok_or_else(|| miette!("'shortest_path_astar' requires edges relation"))?;

src/algo/bfs.rs

@@ -1,11 +1,9 @@
 use std::collections::{BTreeMap, BTreeSet, VecDeque};
 
-use miette::{miette, ensure, Result};
-use smartstring::{LazyCompact, SmartString};
+use miette::{ensure, miette, Result};
 
 use crate::algo::AlgoImpl;
-use crate::data::expr::Expr;
-use crate::data::program::{MagicAlgoRuleArg, MagicSymbol};
+use crate::data::program::{MagicAlgoApply, MagicSymbol};
 use crate::data::tuple::Tuple;
 use crate::data::value::DataValue;
 use crate::runtime::db::Poison;
@@ -18,12 +16,13 @@ impl AlgoImpl for Bfs {
     fn run(
         &mut self,
         tx: &SessionTx,
-        rels: &[MagicAlgoRuleArg],
-        opts: &BTreeMap<SmartString<LazyCompact>, Expr>,
+        algo: &MagicAlgoApply,
         stores: &BTreeMap<MagicSymbol, DerivedRelStore>,
         out: &DerivedRelStore,
         poison: Poison,
     ) -> Result<()> {
+        let rels = &algo.rule_args;
+        let opts = &algo.options;
         ensure!(
             rels.len() == 2 || rels.len() == 3,
             "'bfs' requires two or three input relations"

src/algo/degree_centrality.rs

@@ -1,11 +1,9 @@
 use std::collections::BTreeMap;
 
-use miette::{miette, ensure};
-use smartstring::{LazyCompact, SmartString};
+use miette::{miette, ensure, Result};
 
 use crate::algo::AlgoImpl;
-use crate::data::expr::Expr;
-use crate::data::program::{MagicAlgoRuleArg, MagicSymbol};
+use crate::data::program::{MagicAlgoApply, MagicSymbol};
 use crate::data::tuple::Tuple;
 use crate::data::value::DataValue;
 use crate::runtime::db::Poison;
@@ -18,12 +16,12 @@ impl AlgoImpl for DegreeCentrality {
     fn run(
         &mut self,
         tx: &SessionTx,
-        rels: &[MagicAlgoRuleArg],
-        _opts: &BTreeMap<SmartString<LazyCompact>, Expr>,
+        algo: &MagicAlgoApply,
         stores: &BTreeMap<MagicSymbol, DerivedRelStore>,
         out: &DerivedRelStore,
         poison: Poison,
-    ) -> miette::Result<()> {
+    ) -> Result<()> {
+        let rels = &algo.rule_args;
         let it = rels
             .get(0)
             .ok_or_else(|| miette!(

src/algo/dfs.rs

@@ -1,11 +1,9 @@
 use std::collections::{BTreeMap, BTreeSet};
 
-use miette::{miette, ensure, Result};
-use smartstring::{LazyCompact, SmartString};
+use miette::{ensure, miette, Result};
 
 use crate::algo::AlgoImpl;
-use crate::data::expr::Expr;
-use crate::data::program::{MagicAlgoRuleArg, MagicSymbol};
+use crate::data::program::{MagicAlgoApply, MagicSymbol};
 use crate::data::tuple::Tuple;
 use crate::data::value::DataValue;
 use crate::runtime::db::Poison;
@@ -18,12 +16,13 @@ impl AlgoImpl for Dfs {
     fn run(
         &mut self,
         tx: &SessionTx,
-        rels: &[MagicAlgoRuleArg],
-        opts: &BTreeMap<SmartString<LazyCompact>, Expr>,
+        algo: &MagicAlgoApply,
         stores: &BTreeMap<MagicSymbol, DerivedRelStore>,
         out: &DerivedRelStore,
         poison: Poison,
     ) -> Result<()> {
+        let rels = &algo.rule_args;
+        let opts = &algo.options;
         ensure!(
             rels.len() == 2 || rels.len() == 3,
             "'dfs' requires two or three input relations"

src/algo/kruskal.rs

@@ -5,11 +5,9 @@ use miette::{miette, Result};
 use itertools::Itertools;
 use ordered_float::OrderedFloat;
 use priority_queue::PriorityQueue;
-use smartstring::{LazyCompact, SmartString};
 
 use crate::algo::AlgoImpl;
-use crate::data::expr::Expr;
-use crate::data::program::{MagicAlgoRuleArg, MagicSymbol};
+use crate::data::program::{MagicAlgoApply, MagicSymbol};
 use crate::data::tuple::Tuple;
 use crate::data::value::DataValue;
 use crate::runtime::db::Poison;
@@ -22,12 +20,12 @@ impl AlgoImpl for MinimumSpanningTreeKruskal {
     fn run(
         &mut self,
         tx: &SessionTx,
-        rels: &[MagicAlgoRuleArg],
-        _opts: &BTreeMap<SmartString<LazyCompact>, Expr>,
+        algo: &MagicAlgoApply,
         stores: &BTreeMap<MagicSymbol, DerivedRelStore>,
         out: &DerivedRelStore,
         poison: Poison,
     ) -> Result<()> {
+        let rels = &algo.rule_args;
         let edges = rels
             .get(0)
             .ok_or_else(|| miette!("'minimum_spanning_tree_kruskal' requires edge relation"))?;

src/algo/label_propagation.rs

@@ -3,11 +3,10 @@ use std::collections::BTreeMap;
 use miette::{miette, bail, ensure, Result};
 use itertools::Itertools;
 use rand::prelude::*;
-use smartstring::{LazyCompact, SmartString};
 
 use crate::algo::{get_bool_option_required, AlgoImpl};
 use crate::data::expr::Expr;
-use crate::data::program::{MagicAlgoRuleArg, MagicSymbol};
+use crate::data::program::{MagicAlgoApply, MagicSymbol};
 use crate::data::tuple::Tuple;
 use crate::data::value::DataValue;
 use crate::runtime::db::Poison;
@@ -20,12 +19,13 @@ impl AlgoImpl for LabelPropagation {
     fn run(
         &mut self,
         tx: &SessionTx,
-        rels: &[MagicAlgoRuleArg],
-        opts: &BTreeMap<SmartString<LazyCompact>, Expr>,
+        algo: &MagicAlgoApply,
         stores: &BTreeMap<MagicSymbol, DerivedRelStore>,
         out: &DerivedRelStore,
         poison: Poison,
     ) -> Result<()> {
+        let rels = &algo.rule_args;
+        let opts = &algo.options;
         let edges = rels
             .get(0)
             .ok_or_else(|| miette!("'label_propagation' requires edges relation"))?;

src/algo/louvain.rs

@@ -3,11 +3,10 @@ use std::collections::{BTreeMap, BTreeSet};
 use miette::{miette, bail, ensure, Result};
 use itertools::Itertools;
 use log::debug;
-use smartstring::{LazyCompact, SmartString};
 
 use crate::algo::{get_bool_option_required, AlgoImpl};
 use crate::data::expr::Expr;
-use crate::data::program::{MagicAlgoRuleArg, MagicSymbol};
+use crate::data::program::{MagicAlgoApply, MagicSymbol};
 use crate::data::tuple::Tuple;
 use crate::data::value::DataValue;
 use crate::runtime::db::Poison;
@@ -20,12 +19,13 @@ impl AlgoImpl for CommunityDetectionLouvain {
     fn run(
         &mut self,
         tx: &SessionTx,
-        rels: &[MagicAlgoRuleArg],
-        opts: &BTreeMap<SmartString<LazyCompact>, Expr>,
+        algo: &MagicAlgoApply,
         stores: &BTreeMap<MagicSymbol, DerivedRelStore>,
         out: &DerivedRelStore,
         poison: Poison,
     ) -> Result<()> {
+        let rels = &algo.rule_args;
+        let opts = &algo.options;
         let edges = rels
             .get(0)
             .ok_or_else(|| miette!("'community_detection_louvain' requires edges relation"))?;

src/algo/mod.rs

@@ -1,8 +1,8 @@
 use std::collections::BTreeMap;
 
-use miette::{miette, bail, ensure, Result};
 use either::Either;
 use itertools::Itertools;
+use miette::{bail, ensure, miette, Result};
 use smartstring::{LazyCompact, SmartString};
 
 use crate::algo::all_pairs_shortest_path::{BetweennessCentrality, ClosenessCentrality};
@@ -24,8 +24,8 @@ use crate::algo::triangles::ClusteringCoefficients;
 use crate::algo::yen::KShortestPathYen;
 use crate::data::expr::Expr;
 use crate::data::functions::OP_LIST;
-use crate::data::id::{EntityId, Validity};
-use crate::data::program::{AlgoRuleArg, MagicAlgoRuleArg, MagicSymbol, TripleDir};
+use crate::data::id::EntityId;
+use crate::data::program::{AlgoRuleArg, MagicAlgoApply, MagicAlgoRuleArg, MagicSymbol, TripleDir};
 use crate::data::symb::Symbol;
 use crate::data::tuple::{Tuple, TupleIter};
 use crate::data::value::DataValue;
@@ -57,8 +57,7 @@ pub(crate) trait AlgoImpl {
     fn run(
         &mut self,
         tx: &SessionTx,
-        rels: &[MagicAlgoRuleArg],
-        opts: &AlgoOptions,
+        algo: &MagicAlgoApply,
         stores: &BTreeMap<MagicSymbol, DerivedRelStore>,
         out: &DerivedRelStore,
         poison: Poison,
@@ -274,7 +273,7 @@ impl MagicAlgoRuleArg {
                 let t = Tuple(vec![prefix.clone()]);
                 Box::new(view_rel.scan_prefix(&t))
             }
-            MagicAlgoRuleArg::Triple(attr, _, dir) => {
+            MagicAlgoRuleArg::Triple(attr, _, dir, vld) => {
                 if *dir == TripleDir::Bwd && !attr.val_type.is_ref_type() {
                     ensure!(
                         attr.indexing.should_index(),
@@ -283,7 +282,7 @@ impl MagicAlgoRuleArg {
                     );
                     if attr.with_history {
                         Box::new(
-                            tx.triple_av_before_scan(attr.id, prefix, Validity::MAX)
+                            tx.triple_av_before_scan(attr.id, prefix, *vld)
                                 .map_ok(|(_, v, eid)| Tuple(vec![v, eid.as_datavalue()])),
                         )
                     } else {
@@ -304,7 +303,7 @@ impl MagicAlgoRuleArg {
                         TripleDir::Fwd => {
                             if attr.with_history {
                                 Box::new(
-                                    tx.triple_ea_before_scan(id, attr.id, Validity::MAX)
+                                    tx.triple_ea_before_scan(id, attr.id, *vld)
                                         .map_ok(|(eid, _, v)| Tuple(vec![eid.as_datavalue(), v])),
                                 )
                             } else {
@@ -316,12 +315,9 @@ impl MagicAlgoRuleArg {
                         }
                         TripleDir::Bwd => {
                             if attr.with_history {
-                                Box::new(
-                                    tx.triple_vref_a_before_scan(id, attr.id, Validity::MAX)
-                                        .map_ok(|(v, _, eid)| {
-                                            Tuple(vec![v.as_datavalue(), eid.as_datavalue()])
-                                        }),
-                                )
+                                Box::new(tx.triple_vref_a_before_scan(id, attr.id, *vld).map_ok(
+                                    |(v, _, eid)| Tuple(vec![v.as_datavalue(), eid.as_datavalue()]),
+                                ))
                             } else {
                                 Box::new(tx.triple_vref_a_scan(id, attr.id).map_ok(
                                     |(v, _, eid)| Tuple(vec![v.as_datavalue(), eid.as_datavalue()]),
@@ -349,7 +345,7 @@ impl MagicAlgoRuleArg {
                 let view_rel = tx.get_view_rel(s)?;
                 view_rel.metadata.arity
             }
-            MagicAlgoRuleArg::Triple(_, _, _) => 2,
+            MagicAlgoRuleArg::Triple(_, _, _, _) => 2,
         })
     }
     pub(crate) fn iter<'a>(
@@ -368,11 +364,11 @@ impl MagicAlgoRuleArg {
                 let view_rel = tx.get_view_rel(s)?;
                 Box::new(view_rel.scan_all()?)
             }
-            MagicAlgoRuleArg::Triple(attr, _, dir) => match dir {
+            MagicAlgoRuleArg::Triple(attr, _, dir, vld) => match dir {
                 TripleDir::Fwd => {
                     if attr.with_history {
                         Box::new(
-                            tx.triple_a_before_scan(attr.id, Validity::MAX)
+                            tx.triple_a_before_scan(attr.id, *vld)
                                 .map_ok(|(_, eid, v)| Tuple(vec![eid.as_datavalue(), v])),
                         )
                     } else {
@@ -385,7 +381,7 @@ impl MagicAlgoRuleArg {
                 TripleDir::Bwd => {
                     if attr.with_history {
                         Box::new(
-                            tx.triple_a_before_scan(attr.id, Validity::MAX)
+                            tx.triple_a_before_scan(attr.id, *vld)
                                 .map_ok(|(_, eid, v)| Tuple(vec![v, eid.as_datavalue()])),
                         )
                     } else {

src/algo/pagerank.rs

@@ -4,11 +4,10 @@ use std::mem;
 use miette::{miette, bail, ensure, Result};
 use approx::AbsDiffEq;
 use nalgebra::{Dynamic, OMatrix, U1};
-use smartstring::{LazyCompact, SmartString};
 
 use crate::algo::{get_bool_option_required, AlgoImpl};
 use crate::data::expr::Expr;
-use crate::data::program::{MagicAlgoRuleArg, MagicSymbol};
+use crate::data::program::{MagicAlgoApply, MagicSymbol};
 use crate::data::tuple::Tuple;
 use crate::data::value::{DataValue, Num};
 use crate::runtime::db::Poison;
@@ -21,12 +20,13 @@ impl AlgoImpl for PageRank {
     fn run(
         &mut self,
         tx: &SessionTx,
-        rels: &[MagicAlgoRuleArg],
-        opts: &BTreeMap<SmartString<LazyCompact>, Expr>,
+        algo: &MagicAlgoApply,
         stores: &BTreeMap<MagicSymbol, DerivedRelStore>,
         out: &DerivedRelStore,
         poison: Poison,
     ) -> Result<()> {
+        let rels = &algo.rule_args;
+        let opts = &algo.options;
         let edges = rels
             .get(0)
             .ok_or_else(|| miette!("'pagerank' requires edges relation"))?;

src/algo/prim.rs

@@ -4,11 +4,9 @@ use std::collections::BTreeMap;
 use miette::{miette, Result};
 use ordered_float::OrderedFloat;
 use priority_queue::PriorityQueue;
-use smartstring::{LazyCompact, SmartString};
 
 use crate::algo::AlgoImpl;
-use crate::data::expr::Expr;
-use crate::data::program::{MagicAlgoRuleArg, MagicSymbol};
+use crate::data::program::{MagicAlgoApply, MagicSymbol};
 use crate::data::tuple::Tuple;
 use crate::data::value::DataValue;
 use crate::runtime::db::Poison;
@@ -21,12 +19,12 @@ impl AlgoImpl for MinimumSpanningTreePrim {
     fn run(
         &mut self,
         tx: &SessionTx,
-        rels: &[MagicAlgoRuleArg],
-        _opts: &BTreeMap<SmartString<LazyCompact>, Expr>,
+        algo: &MagicAlgoApply,
         stores: &BTreeMap<MagicSymbol, DerivedRelStore>,
         out: &DerivedRelStore,
         poison: Poison,
     ) -> Result<()> {
+        let rels = &algo.rule_args;
         let edges = rels
             .get(0)
             .ok_or_else(|| miette!("'minimum_spanning_tree_prim' requires edge relation"))?;

src/algo/random_walk.rs

@@ -4,11 +4,10 @@ use miette::{miette, bail, ensure, Result};
 use itertools::Itertools;
 use rand::distributions::WeightedIndex;
 use rand::prelude::*;
-use smartstring::{LazyCompact, SmartString};
 
 use crate::algo::AlgoImpl;
 use crate::data::expr::Expr;
-use crate::data::program::{MagicAlgoRuleArg, MagicSymbol};
+use crate::data::program::{MagicAlgoApply, MagicSymbol};
 use crate::data::tuple::Tuple;
 use crate::data::value::DataValue;
 use crate::runtime::db::Poison;
@@ -21,12 +20,13 @@ impl AlgoImpl for RandomWalk {
     fn run(
         &mut self,
         tx: &SessionTx,
-        rels: &[MagicAlgoRuleArg],
-        opts: &BTreeMap<SmartString<LazyCompact>, Expr>,
+        algo: &MagicAlgoApply,
         stores: &BTreeMap<MagicSymbol, DerivedRelStore>,
         out: &DerivedRelStore,
         poison: Poison,
     ) -> Result<()> {
+        let rels = &algo.rule_args;
+        let opts = &algo.options;
         let edges = rels
             .get(0)
             .ok_or_else(|| miette!("'random_walk' requires edges relation as first argument"))?;

src/algo/reorder_sort.rs

@@ -2,12 +2,11 @@ use std::collections::BTreeMap;
 
 use miette::{miette, bail, ensure, Result};
 use itertools::Itertools;
-use smartstring::{LazyCompact, SmartString};
 
 use crate::algo::{get_bool_option_required, AlgoImpl};
 use crate::data::expr::Expr;
 use crate::data::functions::OP_LIST;
-use crate::data::program::{MagicAlgoRuleArg, MagicSymbol};
+use crate::data::program::{MagicAlgoApply, MagicSymbol};
 use crate::data::tuple::Tuple;
 use crate::data::value::DataValue;
 use crate::runtime::db::Poison;
@@ -20,12 +19,13 @@ impl AlgoImpl for ReorderSort {
     fn run(
         &mut self,
         tx: &SessionTx,
-        rels: &[MagicAlgoRuleArg],
-        opts: &BTreeMap<SmartString<LazyCompact>, Expr>,
+        algo: &MagicAlgoApply,
         stores: &BTreeMap<MagicSymbol, DerivedRelStore>,
         out: &DerivedRelStore,
         poison: Poison,
     ) -> Result<()> {
+        let rels = &algo.rule_args;
+        let opts = &algo.options;
         let in_rel = rels
             .get(0)
             .ok_or_else(|| miette!("'reorder_sort' requires an input relation"))?;

src/algo/shortest_path_dijkstra.rs

@@ -8,11 +8,9 @@ use ordered_float::OrderedFloat;
 use priority_queue::PriorityQueue;
 use rayon::prelude::*;
 use smallvec::{smallvec, SmallVec};
-use smartstring::{LazyCompact, SmartString};
 
 use crate::algo::{get_bool_option_required, AlgoImpl};
-use crate::data::expr::Expr;
-use crate::data::program::{MagicAlgoRuleArg, MagicSymbol};
+use crate::data::program::{MagicAlgoApply, MagicSymbol};
 use crate::data::tuple::Tuple;
 use crate::data::value::DataValue;
 use crate::runtime::db::Poison;
@@ -25,12 +23,13 @@ impl AlgoImpl for ShortestPathDijkstra {
     fn run(
         &mut self,
         tx: &SessionTx,
-        rels: &[MagicAlgoRuleArg],
-        opts: &BTreeMap<SmartString<LazyCompact>, Expr>,
+        algo: &MagicAlgoApply,
         stores: &BTreeMap<MagicSymbol, DerivedRelStore>,
         out: &DerivedRelStore,
         poison: Poison,
     ) -> Result<()> {
+        let rels = &algo.rule_args;
+        let opts = &algo.options;
         let edges = rels
             .get(0)
             .ok_or_else(|| miette!("'shortest_path_dijkstra' requires edges relation"))?;

src/algo/strongly_connected_components.rs

@@ -3,11 +3,10 @@ use std::collections::BTreeMap;
 
 use miette::{miette, bail, Result};
 use itertools::Itertools;
-use smartstring::{LazyCompact, SmartString};
 
 use crate::algo::AlgoImpl;
 use crate::data::expr::Expr;
-use crate::data::program::{MagicAlgoRuleArg, MagicSymbol};
+use crate::data::program::{MagicAlgoApply, MagicSymbol};
 use crate::data::tuple::Tuple;
 use crate::data::value::DataValue;
 use crate::runtime::db::Poison;
@@ -28,12 +27,13 @@ impl AlgoImpl for StronglyConnectedComponent {
     fn run(
         &mut self,
         tx: &SessionTx,
-        rels: &[MagicAlgoRuleArg],
-        opts: &BTreeMap<SmartString<LazyCompact>, Expr>,
+        algo: &MagicAlgoApply,
         stores: &BTreeMap<MagicSymbol, DerivedRelStore>,
         out: &DerivedRelStore,
         poison: Poison,
     ) -> Result<()> {
+        let rels = &algo.rule_args;
+        let opts = &algo.options;
         let edges = rels
             .get(0)
             .ok_or_else(|| miette!("'strongly_connected_components' missing edges relation"))?;

src/algo/top_sort.rs

@@ -1,11 +1,9 @@
 use std::collections::BTreeMap;
 
 use miette::{miette, Result};
-use smartstring::{LazyCompact, SmartString};
 
 use crate::algo::AlgoImpl;
-use crate::data::expr::Expr;
-use crate::data::program::{MagicAlgoRuleArg, MagicSymbol};
+use crate::data::program::{MagicAlgoApply, MagicSymbol};
 use crate::data::tuple::Tuple;
 use crate::data::value::DataValue;
 use crate::runtime::db::Poison;
@@ -18,12 +16,12 @@ impl AlgoImpl for TopSort {
     fn run(
         &mut self,
         tx: &SessionTx,
-        rels: &[MagicAlgoRuleArg],
-        _opts: &BTreeMap<SmartString<LazyCompact>, Expr>,
+        algo: &MagicAlgoApply,
         stores: &BTreeMap<MagicSymbol, DerivedRelStore>,
         out: &DerivedRelStore,
         poison: Poison,
     ) -> Result<()> {
+        let rels = &algo.rule_args;
         let edges = rels
             .get(0)
             .ok_or_else(|| miette!("'top_sort' missing edges relation"))?;

src/algo/triangles.rs

@@ -2,11 +2,9 @@ use std::collections::{BTreeMap, BTreeSet};
 
 use miette::{miette, Result};
 use rayon::prelude::*;
-use smartstring::{LazyCompact, SmartString};
 
 use crate::algo::AlgoImpl;
-use crate::data::expr::Expr;
-use crate::data::program::{MagicAlgoRuleArg, MagicSymbol};
+use crate::data::program::{MagicAlgoApply, MagicSymbol};
 use crate::data::tuple::Tuple;
 use crate::data::value::DataValue;
 use crate::runtime::db::Poison;
@@ -19,12 +17,12 @@ impl AlgoImpl for ClusteringCoefficients {
     fn run(
         &mut self,
         tx: &SessionTx,
-        rels: &[MagicAlgoRuleArg],
-        _opts: &BTreeMap<SmartString<LazyCompact>, Expr>,
+        algo: &MagicAlgoApply,
         stores: &BTreeMap<MagicSymbol, DerivedRelStore>,
         out: &DerivedRelStore,
         poison: Poison,
     ) -> Result<()> {
+        let rels = &algo.rule_args;
         let edges = rels
             .get(0)
             .ok_or_else(|| miette!("'clustering_coefficients' requires edges relation"))?;

src/algo/yen.rs

@@ -3,12 +3,10 @@ use std::collections::{BTreeMap, BTreeSet};
 use miette::{miette, ensure, Result};
 use itertools::Itertools;
 use rayon::prelude::*;
-use smartstring::{LazyCompact, SmartString};
 
 use crate::algo::shortest_path_dijkstra::dijkstra;
 use crate::algo::{get_bool_option_required, AlgoImpl};
-use crate::data::expr::Expr;
-use crate::data::program::{MagicAlgoRuleArg, MagicSymbol};
+use crate::data::program::{MagicAlgoApply, MagicSymbol};
 use crate::data::tuple::Tuple;
 use crate::data::value::DataValue;
 use crate::runtime::db::Poison;
@@ -21,12 +19,13 @@ impl AlgoImpl for KShortestPathYen {
     fn run(
         &mut self,
         tx: &SessionTx,
-        rels: &[MagicAlgoRuleArg],
-        opts: &BTreeMap<SmartString<LazyCompact>, Expr>,
+        algo: &MagicAlgoApply,
         stores: &BTreeMap<MagicSymbol, DerivedRelStore>,
         out: &DerivedRelStore,
         poison: Poison,
     ) -> Result<()> {
+        let rels = &algo.rule_args;
+        let opts = &algo.options;
         let edges = rels
             .get(0)
             .ok_or_else(|| miette!("'k_shortest_path_yen' requires edges relation"))?;

src/cozoscript.pest

@@ -29,7 +29,7 @@ compound_ident = {ident ~ ("." ~ ident)?}
 
 rule = {rule_head ~ ("@" ~ expr)? ~ ":=" ~ rule_body ~ ";"}
 const_rule = {rule_head ~ "<-" ~ expr ~ ";" }
-algo_rule = {rule_head ~ "<-" ~ algo_ident ~ "(" ~ (algo_arg ~ ",")* ~ algo_arg? ~ ")" ~ ";" }
+algo_rule = {rule_head ~ ("@" ~ expr)? ~ "<-" ~ algo_ident ~ "(" ~ (algo_arg ~ ",")* ~ algo_arg? ~ ")" ~ ";" }
 
 rule_head = {(prog_entry | ident) ~ "[" ~ (head_arg ~ ",")* ~ head_arg? ~ "]"}
 head_arg = {aggr_arg | var}

src/data/program.rs

@@ -96,6 +96,7 @@ pub(crate) struct AlgoApply {
     pub(crate) rule_args: Vec<AlgoRuleArg>,
     pub(crate) options: BTreeMap<SmartString<LazyCompact>, Expr>,
     pub(crate) head: Vec<Symbol>,
+    pub(crate) vld: Option<Validity>
 }
 
 impl AlgoApply {
@@ -154,7 +155,7 @@ pub(crate) enum AlgoRuleArg {
 pub(crate) enum MagicAlgoRuleArg {
     InMem(MagicSymbol, Vec<Symbol>),
     Stored(Symbol, Vec<Symbol>),
-    Triple(Attribute, Vec<Symbol>, TripleDir),
+    Triple(Attribute, Vec<Symbol>, TripleDir, Validity),
 }
 
 impl MagicAlgoRuleArg {
@@ -162,7 +163,7 @@ impl MagicAlgoRuleArg {
         let bindings = match self {
             MagicAlgoRuleArg::InMem(_, b) => b,
             MagicAlgoRuleArg::Stored(_, b) => b,
-            MagicAlgoRuleArg::Triple(_, b, dir) => {
+            MagicAlgoRuleArg::Triple(_, b, dir, _) => {
                 if *dir == TripleDir::Bwd {
                     return b
                         .iter()
@@ -225,8 +226,7 @@ impl InputProgram {
 
         None
     }
-    pub(crate) fn to_normalized_program(&self, tx: &SessionTx) -> Result<NormalFormProgram> {
-        let default_vld = Validity::current();
+    pub(crate) fn to_normalized_program(&self, tx: &SessionTx, default_vld: Validity) -> Result<NormalFormProgram> {
         let mut prog: BTreeMap<Symbol, _> = Default::default();
         for (k, rules_or_algo) in &self.prog {
             match rules_or_algo {

src/parse/query.rs

@@ -398,7 +398,19 @@ fn parse_algo_rule(
         aggr.iter().all(|v| v.is_none()),
         "aggregation cannot be applied to algo rule head"
     );
-    let algo_name = &src.next().unwrap().as_str().strip_suffix('!').unwrap();
+    let mut name_pair = src.next().unwrap();
+    let mut at = None;
+    match name_pair.as_rule() {
+        Rule::expr => {
+            let vld = build_expr(name_pair, param_pool)?.eval_to_const()?;
+            let vld = Validity::try_from(vld)?;
+            at = Some(vld);
+            name_pair = src.next().unwrap();
+        }
+        Rule::algo_ident => {}
+        _ => unreachable!(),
+    }
+    let algo_name = &name_pair.as_str().strip_suffix('!').unwrap();
     let mut rule_args: Vec<AlgoRuleArg> = vec![];
     let mut options: BTreeMap<SmartString<LazyCompact>, Expr> = Default::default();
 
@@ -469,6 +481,7 @@ fn parse_algo_rule(
             rule_args,
             options,
             head,
+            vld: at
         },
     ))
 }

src/query/eval.rs

@@ -149,8 +149,7 @@ impl SessionTx {
             .ok_or_else(|| miette!("cannot find algo store {:?}", rule_symb))?;
         algo_impl.run(
             self,
-            &algo_apply.rule_args,
-            &algo_apply.options,
+            &algo_apply,
             stores,
             out,
             poison

src/query/magic.rs

@@ -5,6 +5,7 @@ use itertools::Itertools;
 use miette::{miette, Result};
 use smallvec::SmallVec;
 
+use crate::data::id::Validity;
 use crate::data::program::{
     AlgoRuleArg, MagicAlgoApply, MagicAlgoRuleArg, MagicAtom, MagicAttrTripleAtom, MagicProgram,
     MagicRule, MagicRuleApplyAtom, MagicRulesOrAlgo, MagicSymbol, MagicViewApplyAtom,
@@ -35,12 +36,16 @@ impl NormalFormProgram {
 }
 
 impl StratifiedNormalFormProgram {
-    pub(crate) fn magic_sets_rewrite(self, tx: &SessionTx) -> Result<StratifiedMagicProgram> {
+    pub(crate) fn magic_sets_rewrite(
+        self,
+        tx: &SessionTx,
+        default_vld: Validity,
+    ) -> Result<StratifiedMagicProgram> {
         let mut exempt_rules = BTreeSet::from([PROG_ENTRY.clone()]);
         let mut collected = vec![];
         for prog in self.0 {
             prog.exempt_aggr_rules_for_magic_sets(&mut exempt_rules);
-            let adorned = prog.adorn(&exempt_rules, tx)?;
+            let adorned = prog.adorn(&exempt_rules, tx, default_vld)?;
             collected.push(adorned.magic_rewrite());
             exempt_rules.extend(prog.get_downstream_rules());
         }
@@ -276,7 +281,12 @@ impl NormalFormProgram {
         }
         downstream_rules
     }
-    fn adorn(&self, upstream_rules: &BTreeSet<Symbol>, tx: &SessionTx) -> Result<MagicProgram> {
+    fn adorn(
+        &self,
+        upstream_rules: &BTreeSet<Symbol>,
+        tx: &SessionTx,
+        default_vld: Validity,
+    ) -> Result<MagicProgram> {
         let rules_to_rewrite: BTreeSet<_> = self
             .prog
             .keys()
@@ -315,9 +325,10 @@ impl NormalFormProgram {
                                             MagicAlgoRuleArg::Stored(s.clone(), args.clone())
                                         }
                                         AlgoRuleArg::Triple(t, args, d) => {
-                                            let attr= tx.attr_by_name(t)?
-                                                .ok_or_else(||miette!("cannot find attribute {}", t))?;
-                                            MagicAlgoRuleArg::Triple(attr, args.clone(), *d)
+                                            let attr = tx.attr_by_name(t)?.ok_or_else(|| {
+                                                miette!("cannot find attribute {}", t)
+                                            })?;
+                                            MagicAlgoRuleArg::Triple(attr, args.clone(), *d, algo_apply.vld.unwrap_or(default_vld))
                                         }
                                     })
                                 })

src/runtime/db.rs

@@ -422,10 +422,11 @@ impl Db {
                 )
             }
         };
+        let default_vld = Validity::current();
         let program = input_program
-            .to_normalized_program(&tx)?
+            .to_normalized_program(&tx, default_vld)?
             .stratify()?
-            .magic_sets_rewrite(&tx)?;
+            .magic_sets_rewrite(&tx, default_vld)?;
         debug!("{:#?}", program);
         let (compiled, stores) =
             tx.stratified_magic_compile(&program, &input_program.const_rules)?;