Refactor transaction pruning to use two request instead of one

A first request obtains the highest `block_range_root.start` and a
second use it, and a given number of block to keep, as the prune
threshold.

We do that this instead of using a join to make it simple to test (else
the tests would need data on the two tables, our test framework doesn't
allow yet to do that without a lot of boilerplate).

Author: Alenar

internal/mithril-persistence/src/database/provider/cardano_transaction/delete_cardano_transaction.rs

@@ -36,21 +36,18 @@ impl<'conn> DeleteCardanoTransactionProvider<'conn> {
         Self { connection }
     }
 
-    fn get_prune_condition(&self, number_of_block_to_keep: BlockNumber) -> WhereCondition {
-        let number_of_block_to_keep = Value::Integer(number_of_block_to_keep.try_into().unwrap());
+    fn get_prune_condition(&self, threshold: BlockNumber) -> WhereCondition {
+        let threshold = Value::Integer(threshold.try_into().unwrap());
 
-        WhereCondition::new(
-            "block_number < ((select max(block_number) from cardano_tx) - ?*)",
-            vec![number_of_block_to_keep],
-        )
+        WhereCondition::new("block_number < ?*", vec![threshold])
     }
 
-    /// Prune the cardano transaction data after the given number of block.
+    /// Prune the cardano transaction data below the given threshold.
     pub fn prune(
         &self,
-        number_of_block_to_keep: BlockNumber,
+        threshold: BlockNumber,
     ) -> StdResult<EntityCursor<CardanoTransactionRecord>> {
-        let filters = self.get_prune_condition(number_of_block_to_keep);
+        let filters = self.get_prune_condition(threshold);
 
         self.find(filters)
     }
@@ -96,44 +93,44 @@ mod tests {
     }
 
     #[test]
-    fn test_prune_keep_all_data_if_given_block_number_is_larger_than_stored_number_of_block() {
+    fn test_prune_all_data_if_given_block_number_is_larger_than_stored_number_of_block() {
         let connection = cardano_tx_db_connection().unwrap();
         insert_transactions(&connection, test_transaction_set());
 
         let prune_provider = DeleteCardanoTransactionProvider::new(&connection);
         let cursor = prune_provider.prune(100_000).unwrap();
-        assert_eq!(0, cursor.count());
+        assert_eq!(test_transaction_set().len(), cursor.count());
 
         let get_provider = GetCardanoTransactionProvider::new(&connection);
         let cursor = get_provider.get_all().unwrap();
-        assert_eq!(test_transaction_set().len(), cursor.count());
+        assert_eq!(0, cursor.count());
     }
 
     #[test]
-    fn test_prune_keep_only_tx_of_last_block_if_given_number_of_block_is_zero() {
+    fn test_prune_keep_all_tx_of_last_block_if_given_number_of_block_is_zero() {
         let connection = cardano_tx_db_connection().unwrap();
         insert_transactions(&connection, test_transaction_set());
 
         let prune_provider = DeleteCardanoTransactionProvider::new(&connection);
         let cursor = prune_provider.prune(0).unwrap();
-        assert_eq!(4, cursor.count());
+        assert_eq!(0, cursor.count());
 
         let get_provider = GetCardanoTransactionProvider::new(&connection);
         let cursor = get_provider.get_all().unwrap();
-        assert_eq!(2, cursor.count());
+        assert_eq!(test_transaction_set().len(), cursor.count());
     }
 
     #[test]
-    fn test_prune_data_of_older_than_n_blocks() {
+    fn test_prune_data_of_below_given_blocks() {
         let connection = cardano_tx_db_connection().unwrap();
         insert_transactions(&connection, test_transaction_set());
 
         let prune_provider = DeleteCardanoTransactionProvider::new(&connection);
-        let cursor = prune_provider.prune(1).unwrap();
-        assert_eq!(2, cursor.count());
+        let cursor = prune_provider.prune(12).unwrap();
+        assert_eq!(4, cursor.count());
 
         let get_provider = GetCardanoTransactionProvider::new(&connection);
         let cursor = get_provider.get_all().unwrap();
-        assert_eq!(4, cursor.count());
+        assert_eq!(2, cursor.count());
     }
 }

internal/mithril-persistence/src/database/repository/cardano_transaction_repository.rs

@@ -289,10 +289,18 @@ impl CardanoTransactionRepository {
         Ok(transactions.collect())
     }
 
-    /// Prune the transaction strictly after the given number of block.
-    pub async fn prune_transaction(&self, number_of_block_to_keep: BlockNumber) -> StdResult<()> {
-        let provider = DeleteCardanoTransactionProvider::new(&self.connection);
-        provider.prune(number_of_block_to_keep)?.next();
+    /// Prune the transactions older than the given number of blocks (based on the block range root
+    /// stored).
+    pub async fn prune_transaction(&self, number_of_blocks_to_keep: BlockNumber) -> StdResult<()> {
+        if let Some(highest_block_range_start) = self
+            .get_highest_start_block_number_for_block_range_roots()
+            .await?
+        {
+            let provider = DeleteCardanoTransactionProvider::new(&self.connection);
+            let threshold = highest_block_range_start - number_of_blocks_to_keep;
+            provider.prune(threshold)?.next();
+        }
+
         Ok(())
     }
 }
@@ -878,13 +886,22 @@ mod tests {
             .create_transactions(cardano_transactions.clone())
             .await
             .unwrap();
+        repository
+            .create_block_range_roots(vec![(
+                BlockRange::from_block_number(45),
+                MKTreeNode::from_hex("BBBB").unwrap(),
+            )])
+            .await
+            .unwrap();
 
         let transaction_result = repository.get_all().await.unwrap();
         assert_eq!(cardano_transactions.len(), transaction_result.len());
 
-        repository.prune_transaction(24).await.unwrap();
+        // Since the highest block range start is 45, pruning with 20 should remove transactions
+        // with a block number strictly below 25.
+        repository.prune_transaction(20).await.unwrap();
         let transaction_result = repository
-            .get_transactions_in_range_blocks(0..26)
+            .get_transactions_in_range_blocks(0..25)
             .await
             .unwrap();
         assert_eq!(Vec::<CardanoTransactionRecord>::new(), transaction_result);