libsql: attach databases from other namespaces as readonly

With this proof-of-concept patch, other namespaces hosted
on the same sqld machine can now be attached in readonly mode,
so that users can read from other databases when connected
to a particular one.

TODO:
 * hide it as an opt-in flag: abuse risk

Author: psarna

libsql-server/src/connection/libsql.rs

@@ -180,7 +180,7 @@ impl<W: Wal> WrapWal<W> for InhibitCheckpointWalWrapper {
         _buf: &mut [u8],
     ) -> libsql_sys::wal::Result<(u32, u32)> {
         tracing::warn!(
-            "chackpoint inhibited: this connection is not allowed to perform checkpoints"
+            "checkpoint inhibited: this connection is not allowed to perform checkpoints"
         );
         Err(rusqlite::ffi::Error::new(SQLITE_BUSY))
     }
@@ -276,6 +276,7 @@ where
             )?;
             conn.conn
                 .pragma_update(None, "max_page_count", max_db_size)?;
+
             Ok(conn)
         })
         .await
@@ -692,12 +693,32 @@ impl<W: Wal> Connection<W> {
             StmtKind::Read | StmtKind::TxnBegin | StmtKind::Other => config.block_reads,
             StmtKind::Write => config.block_reads || config.block_writes,
             StmtKind::TxnEnd | StmtKind::Release | StmtKind::Savepoint => false,
+            StmtKind::Attach | StmtKind::Detach => false,
         };
         if blocked {
             return Err(Error::Blocked(config.block_reason.clone()));
         }
 
-        let mut stmt = self.conn.prepare(&query.stmt.stmt)?;
+        let mut stmt = if matches!(query.stmt.kind, StmtKind::Attach) {
+            let attached_db_name: &str = query.stmt.id.as_deref().unwrap_or("");
+            let path = PathBuf::from(self.conn.path().unwrap_or("."));
+            let dbs_path = path
+                .parent()
+                .unwrap_or_else(|| std::path::Path::new(".."))
+                .parent()
+                .unwrap_or_else(|| std::path::Path::new(".."))
+                .canonicalize()
+                .unwrap_or_else(|_| std::path::PathBuf::from(".."));
+            let query = format!(
+                "ATTACH DATABASE 'file:{}?mode=ro' AS \"{attached_db_name}\"",
+                dbs_path.join(attached_db_name).join("data").display()
+            );
+            tracing::trace!("ATTACH rewritten to: {query}");
+            self.conn.prepare(&query)?
+        } else {
+            self.conn.prepare(&query.stmt.stmt)?
+        };
+
         if stmt.readonly() {
             READ_QUERY_COUNT.increment(1);
         } else {

libsql-server/src/query_analysis.rs

@@ -1,6 +1,6 @@
 use anyhow::Result;
 use fallible_iterator::FallibleIterator;
-use sqlite3_parser::ast::{Cmd, PragmaBody, QualifiedName, Stmt};
+use sqlite3_parser::ast::{Cmd, Expr, Id, PragmaBody, QualifiedName, Stmt};
 use sqlite3_parser::lexer::sql::{Parser, ParserError};
 
 /// A group of statements to be executed together.
@@ -11,6 +11,8 @@ pub struct Statement {
     /// Is the statement an INSERT, UPDATE or DELETE?
     pub is_iud: bool,
     pub is_insert: bool,
+    // Optional id associated with the statement (used for attach/detach)
+    pub id: Option<String>,
 }
 
 impl Default for Statement {
@@ -30,6 +32,8 @@ pub enum StmtKind {
     Write,
     Savepoint,
     Release,
+    Attach,
+    Detach,
     Other,
 }
 
@@ -113,6 +117,12 @@ impl StmtKind {
                 savepoint_name: Some(_),
                 ..
             }) => Some(Self::Release),
+            Cmd::Stmt(Stmt::Attach {
+                expr: Expr::Id(Id(expr)),
+                db_name: Expr::Id(Id(name)),
+                ..
+            }) if expr == name => Some(Self::Attach),
+            Cmd::Stmt(Stmt::Detach(_)) => Some(Self::Detach),
             _ => None,
         }
     }
@@ -237,6 +247,7 @@ impl Statement {
             kind: StmtKind::Read,
             is_iud: false,
             is_insert: false,
+            id: None,
         }
     }
 
@@ -258,6 +269,7 @@ impl Statement {
                         kind,
                         is_iud: false,
                         is_insert: false,
+                        id: None,
                     });
                 }
             }
@@ -268,11 +280,22 @@ impl Statement {
             );
             let is_insert = matches!(c, Cmd::Stmt(Stmt::Insert { .. }));
 
+            let id = match &c {
+                Cmd::Stmt(Stmt::Attach {
+                    expr: Expr::Id(Id(expr)),
+                    db_name: Expr::Id(Id(name)),
+                    ..
+                }) if expr == name => Some(name.clone()),
+                Cmd::Stmt(Stmt::Detach(Expr::Id(Id(expr)))) => Some(expr.clone()),
+                _ => None,
+            };
+
             Ok(Statement {
                 stmt: c.to_string(),
                 kind,
                 is_iud,
                 is_insert,
+                id,
             })
         }
         // The parser needs to be boxed because it's large, and you don't want it on the stack.