fix(sqlite): preserve leading slash in database URLs

crates/dataprof-db/src/connection.rs

@@ -71,7 +71,13 @@ impl ConnectionInfo {
                 Some(url.username().to_string())
             },
             password: url.password().map(|s| s.to_string()),
-            database: if url.path().len() > 1 {
+            database: if url.scheme() == "sqlite" {
+                match url.host_str() {
+                    Some(host) if !host.is_empty() => Some(format!("{}{}", host, url.path())),
+                    _ if url.path().len() > 1 => Some(url.path().to_string()),
+                    _ => None,
+                }
+            } else if url.path().len() > 1 {
                 Some(url.path().trim_start_matches('/').to_string())
             } else {
                 None
@@ -233,6 +239,7 @@ mod tests {
 
         assert_eq!(info.scheme, "sqlite");
         assert_eq!(info.database_type(), "sqlite");
+        assert_eq!(info.database, Some("/path/to/db.sqlite".to_string()));
     }
 
     #[test]
@@ -244,4 +251,11 @@ mod tests {
         assert_eq!(info.path, Some("/path/to/database.db".to_string()));
         assert_eq!(info.database_type(), "sqlite");
     }
+    #[test]
+    fn test_parse_sqlite_relative_url() {
+        let info = ConnectionInfo::parse("sqlite://rel.sqlite").unwrap();
+
+        assert_eq!(info.scheme, "sqlite");
+        assert_eq!(info.database, Some("rel.sqlite".to_string()));
+    }
 }

crates/dataprof-db/src/connectors/sqlite.rs

@@ -42,6 +42,16 @@ impl SqliteConnector {
             });
         }
 
+        if connection_info.scheme == "sqlite"
+            && (connection_info.username.is_some()
+                || connection_info.password.is_some()
+                || connection_info.port.is_some())
+        {
+            return Err(DataProfilerError::DatabaseConfigError {
+                message: "SQLite URLs do not support credentials or ports".to_string(),
+            });
+        }
+
         Ok(Self {
             config,
             connection_info,

crates/dataprof-db/src/lib.rs

@@ -106,6 +106,7 @@ pub fn create_connector(
         || connection_str.ends_with(".db")
         || connection_str.ends_with(".sqlite")
         || connection_str == ":memory:"
+        || connection_str == "sqlite::memory:"
     {
         Ok(Box::new(connectors::sqlite::SqliteConnector::new(config)?))
     } else {
@@ -150,7 +151,7 @@ fn apply_environment_configuration(
                 .apply_to_connection_string(config.connection_string.clone(), database_type);
         }
 
-        if config.load_credentials_from_env {
+        if config.load_credentials_from_env && database_type != "sqlite" {
             let credentials = DatabaseCredentials::from_environment(database_type);
             config.connection_string =
                 credentials.apply_to_connection_string(&config.connection_string);

crates/dataprof-db/tests/column_order.rs

@@ -202,3 +202,113 @@ async fn the_order_is_the_same_on_every_run() {
 
     connector.disconnect().await.unwrap();
 }
+
+#[tokio::test]
+async fn sqlite_absolute_url_opens_existing_database() {
+    let (_dir, db_path) = fixture(1).await;
+
+    let path = db_path.replace('\\', "/");
+    let url = if cfg!(windows) {
+        format!("sqlite:///{}", path)
+    } else {
+        format!("sqlite://{}", path)
+    };
+    let mut connector = connect(&url).await;
+
+    let columns = connector.profile_query("SELECT * FROM t").await.unwrap();
+    assert_eq!(names(&columns), DECLARED_ORDER);
+
+    connector.disconnect().await.unwrap();
+}
+
+#[tokio::test]
+async fn sqlite_absolute_url_with_default_config_opens_existing_database() {
+    let (_dir, db_path) = fixture(1).await;
+
+    let path = db_path.replace('\\', "/");
+    let url = if cfg!(windows) {
+        format!("sqlite:///{}", path)
+    } else {
+        format!("sqlite://{}", path)
+    };
+
+    let mut connector = create_connector(DatabaseConfig {
+        connection_string: url,
+        ..Default::default()
+    })
+    .unwrap();
+
+    connector.connect().await.unwrap();
+
+    let columns = connector.profile_query("SELECT * FROM t").await.unwrap();
+    assert_eq!(names(&columns), DECLARED_ORDER);
+    assert_eq!(columns.row_count(), 1);
+
+    connector.disconnect().await.unwrap();
+}
+
+#[tokio::test]
+async fn sqlite_relative_url_opens_existing_database() {
+    let cwd = std::env::current_dir().unwrap();
+    let dir = tempfile::tempdir_in(&cwd).unwrap();
+    let db_path = dir.path().join("relative.db");
+    std::fs::File::create(&db_path).unwrap();
+
+    let pool = SqlitePoolOptions::new()
+        .max_connections(1)
+        .connect(&format!("sqlite://{}", db_path.display()))
+        .await
+        .unwrap();
+    sqlx::query("CREATE TABLE relative_marker (id INTEGER)")
+        .execute(&pool)
+        .await
+        .unwrap();
+    sqlx::query("INSERT INTO relative_marker (id) VALUES (1)")
+        .execute(&pool)
+        .await
+        .unwrap();
+    pool.close().await;
+
+    let relative_path = db_path.strip_prefix(&cwd).unwrap();
+    let relative_path = relative_path.to_string_lossy().replace('\\', "/");
+
+    let mut connector = create_connector(DatabaseConfig {
+        connection_string: format!("sqlite://{relative_path}"),
+        ..Default::default()
+    })
+    .unwrap();
+
+    connector.connect().await.unwrap();
+
+    let columns = connector
+        .profile_query("SELECT * FROM relative_marker")
+        .await
+        .unwrap();
+    assert_eq!(names(&columns), ["id"]);
+
+    connector.disconnect().await.unwrap();
+    drop(connector);
+    std::fs::remove_file(&db_path).unwrap();
+}
+
+#[tokio::test]
+async fn sqlite_explicit_memory_url_connects() {
+    let mut connector = create_connector(DatabaseConfig {
+        connection_string: "sqlite::memory:".to_string(),
+        ..Default::default()
+    })
+    .unwrap();
+
+    connector.connect().await.unwrap();
+    connector.disconnect().await.unwrap();
+}
+
+#[test]
+fn sqlite_url_with_credentials_is_rejected() {
+    let result = create_connector(DatabaseConfig {
+        connection_string: "sqlite://user:password@server/database.db".to_string(),
+        ..Default::default()
+    });
+
+    assert!(result.is_err(), "SQLite URLs must not accept credentials");
+}