[EASY] Drop auction_orders table (cowprotocol#3747)

# Description
Drops the `auction_orders` table, which contains duplicated data in the
`competition_auctions` table.
The same data is used there:

https://github.com/cowprotocol/services/blob/979e924dae38ba18bf398447e399092867edaf3f/crates/autopilot/src/infra/persistence/mod.rs#L302-L306

## How to test
Existing tests. No usages apart from this repo:
https://github.com/search?q=org%3Acowprotocol+auction_orders+-repo%3Acowprotocol%2Fservices&type=code

The following query returns 0, which should tell how many
`auction_orders.auction_id` do not exist in `competition_auctions.id`.
```sql
SELECT COUNT(*) 
FROM auction_orders ao
WHERE NOT EXISTS (
  SELECT 1 FROM competition_auctions ca
  WHERE ca.id = ao.auction_id
);
```

Author: squadgazzz

crates/autopilot/src/database/competition.rs

@@ -39,14 +39,6 @@ impl super::Postgres {
             .with_label_values(&["save_competition"])
             .start_timer();
 
-        let competition_orders = competition
-            .competition_table
-            .auction
-            .orders
-            .iter()
-            .map(|order| ByteArray(order.0))
-            .collect::<Vec<_>>();
-
         // offload CPU intensive work of serializing to a blocking thread so we can
         // already start with the DB queries in the mean time.
         let json = tokio::task::spawn_blocking(move || {
@@ -100,10 +92,6 @@ impl super::Postgres {
         .await
         .context("auction_prices::insert")?;
 
-        database::auction_orders::insert(&mut ex, competition.auction_id, &competition_orders)
-            .await
-            .context("auction_orders::insert")?;
-
         let json = json
             .await
             .context("failed to await blocking task")?

crates/autopilot/src/infra/persistence/mod.rs

@@ -367,7 +367,7 @@ impl Persistence {
 
         let orders = {
             // get all orders from a competition auction
-            let auction_orders = database::auction_orders::fetch(&mut ex, auction_id)
+            let auction_orders = database::auction::get_order_uids(&mut ex, auction_id)
                 .await
                 .map_err(error::Auction::DatabaseError)?
                 .ok_or(error::Auction::NotFound)?

crates/database/src/auction.rs

@@ -72,6 +72,18 @@ pub async fn fetch(ex: &mut PgConnection, id: AuctionId) -> Result<Option<Auctio
     sqlx::query_as(QUERY).bind(id).fetch_optional(ex).await
 }
 
+pub async fn get_order_uids(
+    ex: &mut PgConnection,
+    auction_id: AuctionId,
+) -> Result<Option<Vec<OrderUid>>, sqlx::Error> {
+    const QUERY: &str = r#"SELECT order_uids FROM competition_auctions WHERE id = $1;"#;
+    let record: Option<(Vec<OrderUid>,)> = sqlx::query_as(QUERY)
+        .bind(auction_id)
+        .fetch_optional(ex)
+        .await?;
+    Ok(record.map(|(order_uids,)| order_uids))
+}
+
 #[cfg(test)]
 mod tests {
     use {super::*, crate::byte_array::ByteArray, sqlx::Connection};
@@ -102,13 +114,16 @@ mod tests {
             id: id_,
             block: 1,
             deadline: 2,
-            order_uids: vec![ByteArray([1u8; 56])],
+            order_uids: vec![ByteArray([1u8; 56]), ByteArray([2u8; 56])],
             price_tokens: vec![ByteArray([1u8; 20])],
             price_values: vec![BigDecimal::from(1)],
             surplus_capturing_jit_order_owners: vec![ByteArray([1u8; 20])],
         };
         save(&mut db, auction.clone()).await.unwrap();
         let auction_ = fetch(&mut db, id_).await.unwrap().unwrap();
         assert_eq!(auction, auction_);
+
+        let order_uids = get_order_uids(&mut db, id_).await.unwrap().unwrap();
+        assert_eq!(auction.order_uids, order_uids);
     }
 }

crates/database/src/auction_orders.rs

@@ -1,6 +1,5 @@
 pub mod app_data;
 pub mod auction;
-pub mod auction_orders;
 pub mod auction_participants;
 pub mod auction_prices;
 pub mod byte_array;
@@ -53,7 +52,6 @@ pub type PgTransaction<'a> = sqlx::Transaction<'a, sqlx::Postgres>;
 /// The names of tables we use in the db.
 pub const TABLES: &[&str] = &[
     "app_data",
-    "auction_orders",
     "auctions",
     "ethflow_orders",
     "ethflow_refunds",

crates/database/src/lib.rs

@@ -482,18 +482,6 @@ Indexes:
 - PRIMARY KEY: btree(`block_number`, `log_index`)
 - trade\_order\_uid: btree (`order_uid`, `block_number`, `log_index`)
 
-### auction\_orders
-
-Stores all orders that were included in a given auction. The same order can be included in multiple auctions.
-
- Column     | Type    | Nullable | Details
-------------|---------|----------|--------
-auction\_id | bigint  | not null | which auction this order was part of
-order\_uids | bytea[] | not null | order uids that were included in the auction
-
-Indexes:
-- PRIMARY KEY: btree(`auction_uid`)
-
 ### surplus\_capturing\_jit\_order\_owners
 
 Stores all surplus capturing jit order owners that are part of an auction. JIT orders settled for addresses which were not part of a given auction will not count towards surplus.

database/README.md

@@ -0,0 +1,2 @@
+-- Drop auction_orders table
+DROP TABLE IF EXISTS auction_orders;