Drop support for simultaneous use of both sqlite and postgres DBs

Author: Mark-Simulacrum

database/src/bin/ingest-json.rs

@@ -600,13 +600,6 @@ async fn main() {
         Pool::Postgres(mut p) => {
             postgres = Some(p.raw().open().await.into());
         }
-        Pool::Both {
-            sqlite: mut s,
-            postgres: mut p,
-        } => {
-            sqlite = Some(s.raw().open().await.into_inner().unwrap());
-            postgres = Some(p.raw().open().await.into());
-        }
     }
 
     if let Some(s) = &mut sqlite {

database/src/pool.rs

@@ -5,7 +5,6 @@ use std::sync::{Arc, Mutex};
 use std::time::Duration;
 use tokio::sync::{OwnedSemaphorePermit, Semaphore};
 
-pub mod both;
 pub mod postgres;
 pub mod sqlite;
 
@@ -160,43 +159,19 @@ where
 pub enum Pool {
     Sqlite(ConnectionPool<sqlite::Sqlite>),
     Postgres(ConnectionPool<postgres::Postgres>),
-    Both {
-        sqlite: ConnectionPool<sqlite::Sqlite>,
-        postgres: ConnectionPool<postgres::Postgres>,
-    },
 }
 
 impl Pool {
     pub async fn connection(&self) -> Box<dyn Connection> {
         match self {
             Pool::Sqlite(p) => Box::new(sqlite::SqliteConnection::new(p.get().await)),
             Pool::Postgres(p) => Box::new(p.get().await),
-            Pool::Both { sqlite, postgres } => Box::new(both::BothConnection::new(
-                sqlite::SqliteConnection::new(sqlite.get().await),
-                postgres.get().await,
-            )),
         }
     }
 
     pub fn open(uri: &str) -> Pool {
         if uri.starts_with("postgres") {
             Pool::Postgres(ConnectionPool::new(postgres::Postgres::new(uri.into())))
-        } else if uri.starts_with("both://") {
-            let mut parts = uri["both://".len()..].rsplitn(2, ';');
-            let p1 = parts.next().unwrap();
-            let p2 = parts.next().unwrap();
-            match (Pool::open(p1), Pool::open(p2)) {
-                (Pool::Sqlite(s), Pool::Postgres(p)) | (Pool::Postgres(p), Pool::Sqlite(s)) => {
-                    Pool::Both {
-                        sqlite: s,
-                        postgres: p,
-                    }
-                }
-                _ => panic!(
-                    "unsupported inputs, must be sqlite and postgres: {} and {}",
-                    p1, p2
-                ),
-            }
         } else {
             Pool::Sqlite(ConnectionPool::new(sqlite::Sqlite::new(uri.into())))
         }