Extend query to allow to define delta scope

Definition of custom SQL keywords:
 * `BRANCH`: defines which branch should be used for the scope
 * `AS OF`: defines the date in which the query needs to be run.

Author: aleics

README.md

@@ -41,7 +41,7 @@ cargo run --release
 
  - `POST /entities/{entity_name}`: define a new entity with a given name.
  - `PUT /data/{entity_name}`: store or update data in bulk in an entity entry.
- - `POST /deltas/{entity_name}`: store deltas with a given context in an entity entry.
+ - `POST /deltas/{entity_name}`: store deltas with a given branch in an entity entry.
  - `PUT /indices/{entity_name}`: create a new index for a given property in an entity entry.
  - `POST /options`: list filter options given a search query.
  - `POST /search`: send a search query.

examples/simple.rs

@@ -86,14 +86,14 @@ fn main() -> Result<(), Error> {
         DecreaseScoreDelta::create(lionel_messi_id, 9.0),
     ];
 
-    let delta_scope = DeltaScope::context(0, Date::from_calendar_date(2023, Month::January, 1)?);
+    let delta_scope = DeltaScope::branch(0, Date::from_calendar_date(2023, Month::January, 1)?);
 
     engine.store_deltas(name, &delta_scope, lower_scores)?;
 
     let query = QueryExecution::new()
         .for_entity(name.to_string())
         .with_sort(Sort::new("score").with_direction(SortDirection::DESC))
-        .with_scope(DeltaScope::context(
+        .with_scope(DeltaScope::branch(
             0,
             Date::from_calendar_date(2024, Month::January, 1)?,
         ));

src/lib.rs

@@ -575,17 +575,17 @@ mod tests {
     }
 
     #[test]
-    fn query_with_delta_context() {
+    fn query_with_delta_branch() {
         // given
         let runner = STORAGES.start_runner(vec![
             MICHAEL_JORDAN.clone(),
             LIONEL_MESSI.clone(),
             CRISTIANO_RONALDO.clone(),
         ]);
 
-        let context = 0;
-        let delta_scope = DeltaScope::context(
-            context,
+        let branch = 0;
+        let delta_scope = DeltaScope::branch(
+            branch,
             Date::from_calendar_date(2023, Month::January, 1).unwrap(),
         );
 
@@ -602,39 +602,39 @@ mod tests {
         // when
         let filter = CompositeFilter::eq("sport", FieldValue::str("Football"));
 
-        let execution_without_context = QueryExecution::new()
+        let execution_without_branch = QueryExecution::new()
             .for_entity(runner.name.clone())
             .with_filter(filter.clone())
             .with_scope(DeltaScope::date(
                 Date::from_calendar_date(2024, Month::January, 1).unwrap(),
             ));
 
-        let mut matches_without_context = runner.engine.query(execution_without_context).unwrap();
+        let mut matches_without_branch = runner.engine.query(execution_without_branch).unwrap();
 
         // then
-        matches_without_context.sort_by(|a, b| a.id.cmp(&b.id));
+        matches_without_branch.sort_by(|a, b| a.id.cmp(&b.id));
 
         assert_eq!(
-            matches_without_context,
+            matches_without_branch,
             vec![LIONEL_MESSI.clone(), CRISTIANO_RONALDO.clone(),]
         );
 
         // when
-        let execution_with_context = QueryExecution::new()
+        let execution_with_branch = QueryExecution::new()
             .for_entity(runner.name.clone())
             .with_filter(filter.clone())
-            .with_scope(DeltaScope::context(
-                context,
+            .with_scope(DeltaScope::branch(
+                branch,
                 Date::from_calendar_date(2024, Month::January, 1).unwrap(),
             ));
 
-        let mut matches_with_context = runner.engine.query(execution_with_context).unwrap();
+        let mut matches_with_branch = runner.engine.query(execution_with_branch).unwrap();
 
         // then
-        matches_with_context.sort_by(|a, b| a.id.cmp(&b.id));
+        matches_with_branch.sort_by(|a, b| a.id.cmp(&b.id));
 
         assert_eq!(
-            matches_with_context,
+            matches_with_branch,
             vec![
                 Player {
                     id: 0,

src/main.rs

@@ -99,14 +99,7 @@ impl App {
     }
 
     fn build_query_execution(input: QueryInput) -> Result<QueryExecution, AppError> {
-        let mut execution =
-            QueryExecution::parse_query(&input.query).map_err(|_| AppError::InvalidFilterQuery)?;
-
-        if let Some(scope) = input.scope {
-            execution = execution.with_scope(scope.map_delta_scope()?);
-        }
-
-        Ok(execution)
+        QueryExecution::parse_query(&input.query).map_err(|_| AppError::InvalidFilterQuery)
     }
 
     fn options(&self, input: QueryOptionsInput) -> Result<Vec<FilterOption>, AppError> {
@@ -121,14 +114,7 @@ impl App {
     fn build_options_execution(
         input: QueryOptionsInput,
     ) -> Result<OptionsQueryExecution, AppError> {
-        let mut execution = OptionsQueryExecution::parse_query(&input.query)
-            .map_err(|_| AppError::InvalidFilterQuery)?;
-
-        if let Some(scope) = input.scope {
-            execution = execution.with_scope(scope.map_delta_scope()?);
-        }
-
-        Ok(execution)
+        OptionsQueryExecution::parse_query(&input.query).map_err(|_| AppError::InvalidFilterQuery)
     }
 
     fn create_index(&self, name: &str, input: CreateIndexInput) -> Result<(), AppError> {
@@ -255,7 +241,7 @@ async fn bulk_upsert_entity(
 
 #[derive(Deserialize)]
 #[serde(rename_all = "camelCase")]
-struct BulkStoreDeltas {
+struct BulkStoreDeltasInput {
     scope: DeltaScopeInput,
     deltas: Vec<DeltaChangeInput>,
 }
@@ -308,7 +294,7 @@ fn parse_date(string: &str) -> Result<Date, time::error::Parse> {
 #[derive(Debug, Deserialize)]
 #[serde(rename_all = "camelCase")]
 struct DeltaScopeInput {
-    context: Option<u32>,
+    branch: Option<u32>,
     date: String,
 }
 
@@ -318,14 +304,14 @@ impl DeltaScopeInput {
             message: "Date format is invalid. Only ISO 8601 is supported.".to_string(),
         })?;
 
-        Ok(DeltaScope::new(self.context, date))
+        Ok(DeltaScope::new(self.branch, date))
     }
 }
 
 async fn bulk_add_deltas(
     State(search): State<App>,
     Path(name): Path<String>,
-    Json(input): Json<BulkStoreDeltas>,
+    Json(input): Json<BulkStoreDeltasInput>,
 ) -> Result<Json<()>, AppError> {
     search.add_deltas(&name, input.scope, input.deltas)?;
     Ok(Json(()))
@@ -335,7 +321,6 @@ async fn bulk_add_deltas(
 #[serde(rename_all = "camelCase")]
 struct QueryOptionsInput {
     query: String,
-    scope: Option<DeltaScopeInput>,
 }
 
 async fn options(
@@ -376,7 +361,6 @@ async fn create_index(
 #[serde(rename_all = "camelCase")]
 struct QueryInput {
     query: String,
-    scope: Option<DeltaScopeInput>,
 }
 
 #[derive(Debug, Serialize)]