clean ups

crates/sui-indexer-alt/src/handlers/ev_emit_mod.rs

@@ -61,11 +61,16 @@ impl Handler for EvEmitMod {
             .await?)
     }
 
-    async fn prune(from: u64, to: u64, conn: &mut db::Connection<'_>) -> Result<usize> {
+    async fn prune(
+        &self,
+        from: u64,
+        to_exclusive: u64,
+        conn: &mut db::Connection<'_>,
+    ) -> Result<usize> {
         let Range {
             start: from_tx,
             end: to_tx,
-        } = tx_interval(conn, from..to).await?;
+        } = tx_interval(conn, from..to_exclusive).await?;
 
         let filter = ev_emit_mod::table
             .filter(ev_emit_mod::tx_sequence_number.between(from_tx as i64, to_tx as i64 - 1));

crates/sui-indexer-alt/src/handlers/ev_struct_inst.rs

@@ -65,11 +65,16 @@ impl Handler for EvStructInst {
             .await?)
     }
 
-    async fn prune(from: u64, to: u64, conn: &mut db::Connection<'_>) -> Result<usize> {
+    async fn prune(
+        &self,
+        from: u64,
+        to_exclusive: u64,
+        conn: &mut db::Connection<'_>,
+    ) -> Result<usize> {
         let Range {
             start: from_tx,
             end: to_tx,
-        } = tx_interval(conn, from..to).await?;
+        } = tx_interval(conn, from..to_exclusive).await?;
 
         let filter = ev_struct_inst::table
             .filter(ev_struct_inst::tx_sequence_number.between(from_tx as i64, to_tx as i64 - 1));

crates/sui-indexer-alt/src/handlers/kv_checkpoints.rs

@@ -40,9 +40,14 @@ impl Handler for KvCheckpoints {
             .await?)
     }
 
-    async fn prune(from: u64, to: u64, conn: &mut db::Connection<'_>) -> Result<usize> {
+    async fn prune(
+        &self,
+        from: u64,
+        to_exclusive: u64,
+        conn: &mut db::Connection<'_>,
+    ) -> Result<usize> {
         let filter = kv_checkpoints::table
-            .filter(kv_checkpoints::sequence_number.between(from as i64, to as i64 - 1));
+            .filter(kv_checkpoints::sequence_number.between(from as i64, to_exclusive as i64 - 1));
 
         Ok(diesel::delete(filter).execute(conn).await?)
     }

crates/sui-indexer-alt/src/handlers/kv_epoch_ends.rs

@@ -131,11 +131,16 @@ impl Handler for KvEpochEnds {
             .await?)
     }
 
-    async fn prune(from: u64, to: u64, conn: &mut db::Connection<'_>) -> Result<usize> {
+    async fn prune(
+        &self,
+        from: u64,
+        to_exclusive: u64,
+        conn: &mut db::Connection<'_>,
+    ) -> Result<usize> {
         let Range {
             start: from_epoch,
             end: to_epoch,
-        } = epoch_interval(conn, from..to).await?;
+        } = epoch_interval(conn, from..to_exclusive).await?;
         if from_epoch < to_epoch {
             let filter = kv_epoch_ends::table
                 .filter(kv_epoch_ends::epoch.between(from_epoch as i64, to_epoch as i64 - 1));

crates/sui-indexer-alt/src/handlers/kv_epoch_starts.rs

@@ -78,11 +78,16 @@ impl Handler for KvEpochStarts {
             .await?)
     }
 
-    async fn prune(from: u64, to: u64, conn: &mut db::Connection<'_>) -> Result<usize> {
+    async fn prune(
+        &self,
+        from: u64,
+        to_exclusive: u64,
+        conn: &mut db::Connection<'_>,
+    ) -> Result<usize> {
         let Range {
             start: from_epoch,
             end: to_epoch,
-        } = epoch_interval(conn, from..to).await?;
+        } = epoch_interval(conn, from..to_exclusive).await?;
         if from_epoch < to_epoch {
             let filter = kv_epoch_starts::table
                 .filter(kv_epoch_starts::epoch.between(from_epoch as i64, to_epoch as i64 - 1));

crates/sui-indexer-alt/src/handlers/kv_transactions.rs

@@ -68,11 +68,17 @@ impl Handler for KvTransactions {
             .await?)
     }
 
-    async fn prune(from: u64, to: u64, conn: &mut db::Connection<'_>) -> Result<usize> {
+    async fn prune(
+        &self,
+        from: u64,
+        to_exclusive: u64,
+        conn: &mut db::Connection<'_>,
+    ) -> Result<usize> {
         // TODO: use tx_interval. `tx_sequence_number` needs to be added to this table, and an index
         // created as its primary key is on `tx_digest`.
-        let filter = kv_transactions::table
-            .filter(kv_transactions::cp_sequence_number.between(from as i64, to as i64 - 1));
+        let filter = kv_transactions::table.filter(
+            kv_transactions::cp_sequence_number.between(from as i64, to_exclusive as i64 - 1),
+        );
 
         Ok(diesel::delete(filter).execute(conn).await?)
     }

crates/sui-indexer-alt/src/handlers/tx_affected_addresses.rs

@@ -75,11 +75,16 @@ impl Handler for TxAffectedAddresses {
             .await?)
     }
 
-    async fn prune(from: u64, to: u64, conn: &mut db::Connection<'_>) -> Result<usize> {
+    async fn prune(
+        &self,
+        from: u64,
+        to_exclusive: u64,
+        conn: &mut db::Connection<'_>,
+    ) -> Result<usize> {
         let Range {
             start: from_tx,
             end: to_tx,
-        } = tx_interval(conn, from..to).await?;
+        } = tx_interval(conn, from..to_exclusive).await?;
         let filter = tx_affected_addresses::table.filter(
             tx_affected_addresses::tx_sequence_number.between(from_tx as i64, to_tx as i64 - 1),
         );

crates/sui-indexer-alt/src/handlers/tx_affected_objects.rs

@@ -65,11 +65,16 @@ impl Handler for TxAffectedObjects {
             .await?)
     }
 
-    async fn prune(from: u64, to: u64, conn: &mut db::Connection<'_>) -> Result<usize> {
+    async fn prune(
+        &self,
+        from: u64,
+        to_exclusive: u64,
+        conn: &mut db::Connection<'_>,
+    ) -> Result<usize> {
         let Range {
             start: from_tx,
             end: to_tx,
-        } = tx_interval(conn, from..to).await?;
+        } = tx_interval(conn, from..to_exclusive).await?;
         let filter = tx_affected_objects::table.filter(
             tx_affected_objects::tx_sequence_number.between(from_tx as i64, to_tx as i64 - 1),
         );

crates/sui-indexer-alt/src/handlers/tx_balance_changes.rs

@@ -71,11 +71,16 @@ impl Handler for TxBalanceChanges {
             .await?)
     }
 
-    async fn prune(from: u64, to: u64, conn: &mut db::Connection<'_>) -> Result<usize> {
+    async fn prune(
+        &self,
+        from: u64,
+        to_exclusive: u64,
+        conn: &mut db::Connection<'_>,
+    ) -> Result<usize> {
         let Range {
             start: from_tx,
             end: to_tx,
-        } = tx_interval(conn, from..to).await?;
+        } = tx_interval(conn, from..to_exclusive).await?;
         let filter = tx_balance_changes::table.filter(
             tx_balance_changes::tx_sequence_number.between(from_tx as i64, to_tx as i64 - 1),
         );

crates/sui-indexer-alt/src/handlers/tx_calls.rs

@@ -68,11 +68,16 @@ impl Handler for TxCalls {
             .await?)
     }
 
-    async fn prune(from: u64, to: u64, conn: &mut db::Connection<'_>) -> Result<usize> {
+    async fn prune(
+        &self,
+        from: u64,
+        to_exclusive: u64,
+        conn: &mut db::Connection<'_>,
+    ) -> Result<usize> {
         let Range {
             start: from_tx,
             end: to_tx,
-        } = tx_interval(conn, from..to).await?;
+        } = tx_interval(conn, from..to_exclusive).await?;
         let filter = tx_calls::table
             .filter(tx_calls::tx_sequence_number.between(from_tx as i64, to_tx as i64 - 1));
 

crates/sui-indexer-alt/src/handlers/tx_digests.rs

@@ -55,11 +55,11 @@ impl Handler for TxDigests {
             .await?)
     }
 
-    async fn prune(from: u64, to: u64, conn: &mut db::Connection<'_>) -> Result<usize> {
+    async fn prune(&self, from: u64, to_exclusive: u64, conn: &mut db::Connection<'_>) -> Result<usize> {
         let Range {
             start: from_tx,
             end: to_tx,
-        } = tx_interval(conn, from..to).await?;
+        } = tx_interval(conn, from..to_exclusive).await?;
         let filter = tx_digests::table
             .filter(tx_digests::tx_sequence_number.between(from_tx as i64, to_tx as i64 - 1));
 

crates/sui-indexer-alt/src/handlers/tx_kinds.rs

@@ -66,11 +66,16 @@ impl Handler for TxKinds {
             .await?)
     }
 
-    async fn prune(from: u64, to: u64, conn: &mut db::Connection<'_>) -> Result<usize> {
+    async fn prune(
+        &self,
+        from: u64,
+        to_exclusive: u64,
+        conn: &mut db::Connection<'_>,
+    ) -> Result<usize> {
         let Range {
             start: from_tx,
             end: to_tx,
-        } = tx_interval(conn, from..to).await?;
+        } = tx_interval(conn, from..to_exclusive).await?;
         let filter = tx_kinds::table
             .filter(tx_kinds::tx_sequence_number.between(from_tx as i64, to_tx as i64 - 1));