Skip to content

The IDE you know, rebuilt in Rust. IntelliJ IDEA–style keymap, tool windows and search-everywhere in a fast native app: editor, code insight, debugger, Git, terminal, database and HTTP clients for 60+ languages.

fix(remote): serve the database commands from the remote server (#1029)

arookieofcf00ce451aca7
diff --git a/crates/ide-host/src/ops/db.rs b/crates/ide-host/src/ops/db.rs
new file mode 100644
index 000000000..63c8419a0
--- /dev/null
+++ b/crates/ide-host/src/ops/db.rs
@@ -0,0 +1,422 @@
+//! Database commands shared by the desktop shell's IPC commands and the
+//! remote server ([`crate::rpc`]). `db_export_file` stays in the desktop
+//! shell: its path comes from a local save dialog, so the export must land
+//! on the user's machine, not the side the project runs on.
+use crate::Host;
+use crate::rpc::Dispatcher;
+use ide_core::{IdeError, IdeResult, IpcPath, RequestId};
+use ide_db::split::SqlStatement;
+use ide_db::{
+ CompletionModel, DataSource, Databases, DbObjectKind, DbRowEdit, HistoryEntry, PlanNode, QueryResult,
+ SchemaObjects, SortKey, TableDetails, TableInfo, TablePage,
+};
+use serde::{Deserialize, Serialize};
+use specta::Type;
+
+/// One statement of a console run.
+#[derive(Clone, Serialize, Deserialize, Type)]
+#[serde(rename_all = "camelCase")]
+#[serde(rename = "DbStatementOutcome")]
+pub struct StatementOutcome {
+ pub statement: SqlStatement,
+ pub result: Option<QueryResult>,
+ pub error: Option<String>,
+}
+
+pub(crate) fn register(d: &mut Dispatcher) {
+ d.add("db_sources", |c| async move { sources(&c.host, &c.window) });
+ d.add("db_save_sources", |c| async move {
+ let sources = c.arg("sources")?;
+ save_sources(&c.host, &c.window, sources).await
+ });
+ d.add("db_set_password", |c| async move {
+ let (id, password, save) =
+ (c.arg::<String>("id")?, c.arg::<Option<String>>("password")?, c.arg::<bool>("save")?);
+ set_password(&c.host, &c.window, &id, password, save).await
+ });
+ d.add("db_test", |c| async move {
+ let (source, password, ssh_secret) = (
+ c.arg::<DataSource>("source")?,
+ c.arg::<Option<String>>("password")?,
+ c.arg::<Option<String>>("sshSecret")?,
+ );
+ test(&c.host, &c.window, source, password, ssh_secret).await
+ });
+ d.add("db_set_ssh_secret", |c| async move {
+ let (id, secret, save) = (c.arg::<String>("id")?, c.arg::<Option<String>>("secret")?, c.arg::<bool>("save")?);
+ set_ssh_secret(&c.host, &c.window, &id, secret, save).await
+ });
+ d.add("db_trust_ssh_host", |c| async move {
+ let id = c.arg::<String>("id")?;
+ trust_ssh_host(&c.host, &c.window, &id).await
+ });
+ d.add("db_connected", |c| async move { connected(&c.host, &c.window) });
+ d.add("db_connect", |c| async move {
+ let id = c.arg::<String>("id")?;
+ connect(&c.host, &c.window, &id).await
+ });
+ d.add("db_set_manual_commit", |c| async move {
+ let (id, manual) = (c.arg::<String>("id")?, c.arg::<bool>("manual")?);
+ set_manual_commit(&c.host, &c.window, &id, manual).await
+ });
+ d.add("db_finish_transaction", |c| async move {
+ let (id, commit) = (c.arg::<String>("id")?, c.arg::<bool>("commit")?);
+ finish_transaction(&c.host, &c.window, &id, commit).await
+ });
+ d.add("db_disconnect", |c| async move {
+ let id = c.arg::<String>("id")?;
+ disconnect(&c.host, &c.window, &id).await
+ });
+ d.add("db_databases", |c| async move {
+ let id = c.arg::<String>("id")?;
+ databases(&c.host, &c.window, &id).await
+ });
+ d.add("db_schemas", |c| async move {
+ let id = c.arg::<String>("id")?;
+ schemas(&c.host, &c.window, &id).await
+ });
+ d.add("db_tables", |c| async move {
+ let (id, schema) = (c.arg::<String>("id")?, c.arg::<String>("schema")?);
+ tables(&c.host, &c.window, &id, &schema).await
+ });
+ d.add("db_table_details", |c| async move {
+ let (id, schema, table) = (c.arg::<String>("id")?, c.arg::<String>("schema")?, c.arg::<String>("table")?);
+ table_details(&c.host, &c.window, &id, &schema, &table).await
+ });
+ d.add("db_ddl", |c| async move {
+ let (id, schema, table) = (c.arg::<String>("id")?, c.arg::<String>("schema")?, c.arg::<String>("table")?);
+ ddl(&c.host, &c.window, &id, &schema, &table).await
+ });
+ d.add("db_schema_objects", |c| async move {
+ let (id, schema) = (c.arg::<String>("id")?, c.arg::<String>("schema")?);
+ schema_objects(&c.host, &c.window, &id, &schema).await
+ });
+ d.add("db_object_ddl", |c| async move {
+ let (id, schema, kind, name) = (
+ c.arg::<String>("id")?,
+ c.arg::<String>("schema")?,
+ c.arg::<DbObjectKind>("kind")?,
+ c.arg::<String>("name")?,
+ );
+ object_ddl(&c.host, &c.window, &id, &schema, kind, &name).await
+ });
+ d.add("db_explain", |c| async move {
+ let (request, id, statement) =
+ (c.arg::<RequestId>("request")?, c.arg::<String>("id")?, c.arg::<String>("statement")?);
+ explain(&c.host, &c.window, request, &id, &statement).await
+ });
+ d.add("db_history", |c| async move {
+ let id = c.arg::<String>("id")?;
+ history(&c.host, &c.window, &id).await
+ });
+ d.add("db_remove_history", |c| async move {
+ let (id, texts) = (c.arg::<String>("id")?, c.arg::<Option<Vec<String>>>("texts")?);
+ remove_history(&c.host, &c.window, &id, texts).await
+ });
+ d.add("db_completion", |c| async move {
+ let id = c.arg::<String>("id")?;
+ completion(&c.host, &c.window, &id).await
+ });
+ d.add("db_statements", |c| async move {
+ let (id, text, from, to) =
+ (c.arg::<String>("id")?, c.arg::<String>("text")?, c.arg::<u32>("from")?, c.arg::<u32>("to")?);
+ statements(&c.host, &c.window, &id, &text, from, to)
+ });
+ d.add("db_execute", |c| async move {
+ let (request, id, statements, max_rows) = (
+ c.arg::<RequestId>("request")?,
+ c.arg::<String>("id")?,
+ c.arg::<Vec<SqlStatement>>("statements")?,
+ c.arg::<u32>("maxRows")?,
+ );
+ execute(&c.host, &c.window, request, &id, statements, max_rows).await
+ });
+ d.add("db_table_page", |c| async move {
+ let (request, id, schema, table) = (
+ c.arg::<RequestId>("request")?,
+ c.arg::<String>("id")?,
+ c.arg::<String>("schema")?,
+ c.arg::<String>("table")?,
+ );
+ let (filter, sort, offset, limit) = (
+ c.arg::<Option<String>>("filter")?,
+ c.arg::<Vec<SortKey>>("sort")?,
+ c.arg::<u32>("offset")?,
+ c.arg::<u32>("limit")?,
+ );
+ table_page(&c.host, &c.window, request, &id, &schema, &table, filter, sort, offset, limit).await
+ });
+ d.add("db_apply_edits", |c| async move {
+ let (id, schema, table, edits) = (
+ c.arg::<String>("id")?,
+ c.arg::<String>("schema")?,
+ c.arg::<String>("table")?,
+ c.arg::<Vec<DbRowEdit>>("edits")?,
+ );
+ apply_edits(&c.host, &c.window, &id, &schema, &table, edits).await
+ });
+ d.add("db_console_path", |c| async move { console_path(&c.host, &c.arg::<String>("id")?) });
+}
+
+/// The data sources configured for the project (the tree's roots).
+pub fn sources(host: &Host, window: &str) -> IdeResult<Vec<DataSource>> {
+ host.project(window)?.db.sources()
+}
+
+/// Replaces the project's data sources with `sources`.
+pub async fn save_sources(host: &Host, window: &str, sources: Vec<DataSource>) -> IdeResult<()> {
+ let db = host.project(window)?.db.clone();
+ db.save_sources(sources).await
+}
+
+/// Remembers the password of data source `id` for the session, and in the OS
+/// saved passwords when `save` (`None` forgets it).
+pub async fn set_password(host: &Host, window: &str, id: &str, password: Option<String>, save: bool) -> IdeResult<()> {
+ let db = host.project(window)?.db.clone();
+ db.set_password(id, password, save).await
+}
+
+/// Test Connection: connects with unsaved settings and returns the server version.
+pub async fn test(
+ host: &Host,
+ window: &str,
+ source: DataSource,
+ password: Option<String>,
+ ssh_secret: Option<String>,
+) -> IdeResult<String> {
+ let db = host.project(window)?.db.clone();
+ db.test(&source, password, ssh_secret).await
+}
+
+/// Remembers the SSH password / key passphrase of a data source (see `set_password`).
+pub async fn set_ssh_secret(host: &Host, window: &str, id: &str, secret: Option<String>, save: bool) -> IdeResult<()> {
+ let db = host.project(window)?.db.clone();
+ db.set_ssh_secret(id, secret, save).await
+}
+
+/// Trusts the SSH host key that made the last connection of `id` fail with
+/// "Unknown SSH host key" (records it in `~/.ssh/known_hosts`).
+pub async fn trust_ssh_host(host: &Host, window: &str, id: &str) -> IdeResult<()> {
+ let db = host.project(window)?.db.clone();
+ db.trust_ssh_host(id).await
+}
+
+/// The data sources with an open connection.
+pub fn connected(host: &Host, window: &str) -> IdeResult<Vec<String>> {
+ Ok(host.project(window)?.db.connected())
+}
+
+/// Connects (fails with `permissionDenied` when the password is missing or wrong).
+pub async fn connect(host: &Host, window: &str, id: &str) -> IdeResult<()> {
+ let db = host.project(window)?.db.clone();
+ db.pool(id).await.map(|_| ())
+}
+
+/// Switches a data source between auto-commit and manual commit (leaving
+/// manual mode rolls back what was not committed).
+pub async fn set_manual_commit(host: &Host, window: &str, id: &str, manual: bool) -> IdeResult<()> {
+ let db = host.project(window)?.db.clone();
+ db.set_manual_commit(id, manual).await;
+ Ok(())
+}
+
+/// Commits or rolls back the open transaction of a manual-commit data source.
+pub async fn finish_transaction(host: &Host, window: &str, id: &str, commit: bool) -> IdeResult<()> {
+ let db = host.project(window)?.db.clone();
+ db.finish_transaction(id, commit).await
+}
+
+/// Closes the connection of data source `id`.
+pub async fn disconnect(host: &Host, window: &str, id: &str) -> IdeResult<()> {
+ let db = host.project(window)?.db.clone();
+ db.disconnect(id).await;
+ Ok(())
+}
+
+/// Databases of the server of data source `id` (PostgreSQL); connect to one as `<id>:<database>`.
+pub async fn databases(host: &Host, window: &str, id: &str) -> IdeResult<Databases> {
+ let db = host.project(window)?.db.clone();
+ db.databases(id).await
+}
+
+/// The schemas of data source `id`.
+pub async fn schemas(host: &Host, window: &str, id: &str) -> IdeResult<Vec<String>> {
+ let db = host.project(window)?.db.clone();
+ db.schemas(id).await
+}
+
+/// The tables and views of `schema`.
+pub async fn tables(host: &Host, window: &str, id: &str, schema: &str) -> IdeResult<Vec<TableInfo>> {
+ let db = host.project(window)?.db.clone();
+ db.tables(id, schema).await
+}
+
+/// Columns, keys and indexes of `table`.
+pub async fn table_details(host: &Host, window: &str, id: &str, schema: &str, table: &str) -> IdeResult<TableDetails> {
+ let db = host.project(window)?.db.clone();
+ db.table_details(id, schema, table).await
+}
+
+/// The DDL of table or view `table` (Go to DDL, Generate DDL).
+pub async fn ddl(host: &Host, window: &str, id: &str, schema: &str, table: &str) -> IdeResult<String> {
+ let db = host.project(window)?.db.clone();
+ db.ddl(id, schema, table).await
+}
+
+/// The routines and sequences of `schema` (the tree's `routines` / `sequences`).
+pub async fn schema_objects(host: &Host, window: &str, id: &str, schema: &str) -> IdeResult<SchemaObjects> {
+ let db = host.project(window)?.db.clone();
+ db.schema_objects(id, schema).await
+}
+
+/// The definition of a routine, trigger or sequence (Go to DDL, Quick Documentation).
+pub async fn object_ddl(
+ host: &Host,
+ window: &str,
+ id: &str,
+ schema: &str,
+ kind: DbObjectKind,
+ name: &str,
+) -> IdeResult<String> {
+ let db = host.project(window)?.db.clone();
+ db.object_ddl(id, schema, kind, name).await
+}
+
+/// Explain Plan: the execution plan of `statement` on `id`, without running it.
+pub async fn explain(
+ host: &Host,
+ window: &str,
+ request: RequestId,
+ id: &str,
+ statement: &str,
+) -> IdeResult<Vec<PlanNode>> {
+ let db = host.project(window)?.db.clone();
+ let cancel = host.begin_request(request);
+ let result = db.explain(id, statement, &cancel).await;
+ host.end_request(request);
+ result
+}
+
+/// The statements data source `id` ran, newest first (Browse Query History).
+pub async fn history(host: &Host, window: &str, id: &str) -> IdeResult<Vec<HistoryEntry>> {
+ let db = host.project(window)?.db.clone();
+ db.history(id).await
+}
+
+/// Removes statements from the query history of `id` (`None`: all of them).
+pub async fn remove_history(host: &Host, window: &str, id: &str, texts: Option<Vec<String>>) -> IdeResult<()> {
+ let db = host.project(window)?.db.clone();
+ db.remove_history(id, texts).await
+}
+
+/// Tables, columns and foreign keys for SQL completion.
+pub async fn completion(host: &Host, window: &str, id: &str) -> IdeResult<CompletionModel> {
+ let db = host.project(window)?.db.clone();
+ db.completion(id).await
+}
+
+/// Statements a console runs: the selection's (`from < to`) or the one at the caret (`from`).
+pub fn statements(host: &Host, window: &str, id: &str, text: &str, from: u32, to: u32) -> IdeResult<Vec<SqlStatement>> {
+ let driver = host.project(window)?.db.source(id)?.driver;
+ Ok(if from < to {
+ ide_db::split::statements_in(text, from, to, driver)
+ } else {
+ ide_db::split::statement_at(text, from, driver).into_iter().collect()
+ })
+}
+
+/// Runs `statements` in order on data source `id`, stopping at the first
+/// error. Cancel with `cancel_request(request)`.
+pub async fn execute(
+ host: &Host,
+ window: &str,
+ request: RequestId,
+ id: &str,
+ statements: Vec<SqlStatement>,
+ max_rows: u32,
+) -> IdeResult<Vec<StatementOutcome>> {
+ let db = host.project(window)?.db.clone();
+ let cancel = host.begin_request(request);
+ let mut out = Vec::new();
+ for statement in statements {
+ match db.execute(id, &statement.text, max_rows.max(1) as usize, &cancel).await {
+ Ok(result) => out.push(StatementOutcome { statement, result: Some(result), error: None }),
+ Err(e) if e.kind == ide_core::error::ErrorKind::Cancelled => {
+ host.end_request(request);
+ return Err(e);
+ }
+ Err(e) if e.kind == ide_core::error::ErrorKind::PermissionDenied && out.is_empty() => {
+ // Not connected for lack of a password: the UI asks and retries.
+ host.end_request(request);
+ return Err(e);
+ }
+ Err(e) => {
+ out.push(StatementOutcome { statement, result: None, error: Some(e.message) });
+ break;
+ }
+ }
+ }
+ host.end_request(request);
+ Ok(out)
+}
+
+/// One page of the rows of `table` (the table editor).
+#[allow(clippy::too_many_arguments)]
+pub async fn table_page(
+ host: &Host,
+ window: &str,
+ request: RequestId,
+ id: &str,
+ schema: &str,
+ table: &str,
+ filter: Option<String>,
+ sort: Vec<SortKey>,
+ offset: u32,
+ limit: u32,
+) -> IdeResult<TablePage> {
+ let db = host.project(window)?.db.clone();
+ let cancel = host.begin_request(request);
+ let result =
+ db.table_page(id, schema, table, filter.as_deref(), &sort, offset.into(), limit.max(1).into(), &cancel).await;
+ host.end_request(request);
+ result
+}
+
+/// Submits the table editor's changes in one transaction; returns the rows changed.
+pub async fn apply_edits(
+ host: &Host,
+ window: &str,
+ id: &str,
+ schema: &str,
+ table: &str,
+ edits: Vec<DbRowEdit>,
+) -> IdeResult<f64> {
+ let db = host.project(window)?.db.clone();
+ Ok(db.apply_edits(id, schema, table, &edits).await? as f64)
+}
+
+/// The query console file of data source `id` (`<dataDir>/consoles/db/<id>/console.sql`),
+/// created on first use. Consoles are files of the project, so a remote
+/// window resolves it on the host the project runs on.
+pub fn console_path(host: &Host, id: &str) -> IdeResult<IpcPath> {
+ let (source, database) = ide_db::split_target(id);
+ if source.is_empty() || !source.chars().all(|c| c.is_ascii_alphanumeric() || c == '-' || c == '_') {
+ return Err(IdeError::invalid("invalid data source id"));
+ }
+ // One console per database: `<id>` for the default one, `<id>.<database>` for the others.
+ let name = match database {
+ Some(db) => {
+ let safe: String =
+ db.chars().map(|c| if c.is_alphanumeric() || c == '-' || c == '_' { c } else { '_' }).collect();
+ format!("{source}.{safe}")
+ }
+ None => source.to_owned(),
+ };
+ let dir = host.data_dir.join("consoles").join("db").join(&name);
+ std::fs::create_dir_all(&dir)?;
+ let file = dir.join("console.sql");
+ if !file.exists() {
+ std::fs::write(&file, "")?;
+ }
+ Ok(file.into())
+}
diff --git a/crates/ide-host/src/ops/mod.rs b/crates/ide-host/src/ops/mod.rs
index c29dc4e95..9c020130b 100644
--- a/crates/ide-host/src/ops/mod.rs
+++ b/crates/ide-host/src/ops/mod.rs
@@ -7,6 +7,7 @@ pub mod analysis;
pub mod build;
pub mod bytes;
pub mod coverage;
+pub mod db;
pub mod debug;
pub mod dependencies;
pub mod deploy;
@@ -86,6 +87,7 @@ pub fn register_all(d: &mut crate::rpc::Dispatcher) {
run::register(d);
env::register(d);
deploy::register(d);
+ db::register(d);
}
impl Host {
diff --git a/crates/ide-host/tests/rpc.rs b/crates/ide-host/tests/rpc.rs
index a0ec5004c..f0158ac36 100644
--- a/crates/ide-host/tests/rpc.rs
+++ b/crates/ide-host/tests/rpc.rs
@@ -321,6 +321,33 @@ async fn local_deployment_runs_on_the_project_host() {
"remote_delete",
"remote_mkdir",
"remote_rename",
+ "db_sources",
+ "db_save_sources",
+ "db_set_password",
+ "db_test",
+ "db_set_ssh_secret",
+ "db_trust_ssh_host",
+ "db_connected",
+ "db_connect",
+ "db_set_manual_commit",
+ "db_finish_transaction",
+ "db_disconnect",
+ "db_databases",
+ "db_schemas",
+ "db_tables",
+ "db_table_details",
+ "db_ddl",
+ "db_schema_objects",
+ "db_object_ddl",
+ "db_explain",
+ "db_history",
+ "db_remove_history",
+ "db_completion",
+ "db_statements",
+ "db_execute",
+ "db_table_page",
+ "db_apply_edits",
+ "db_console_path",
] {
assert!(dispatcher.commands().contains(&cmd), "missing host command {cmd}");
}
diff --git a/src-tauri/src/commands/db.rs b/src-tauri/src/commands/db.rs
index 93f20ff66..0b9781c5b 100644
--- a/src-tauri/src/commands/db.rs
+++ b/src-tauri/src/commands/db.rs
@@ -1,29 +1,25 @@
+//! IPC commands of `ide_host::ops::db` (the shared implementation).
+
use crate::state::AppState;
-use ide_core::{IdeError, IdeResult, IpcPath, RequestId};
+use ide_core::{IdeResult, IpcPath, RequestId};
use ide_db::split::SqlStatement;
-use ide_db::{
- CompletionModel, DataSource, DbObjectKind, DbRowEdit, HistoryEntry, PlanNode, QueryResult, SchemaObjects, SortKey,
- TableDetails, TableInfo, TablePage,
-};
-use serde::{Deserialize, Serialize};
-use specta::Type;
+use ide_db::{DataSource, DbObjectKind, DbRowEdit, SortKey};
+#[allow(unused_imports)]
+pub use ide_host::ops::db::*;
use tauri::{State, Window};
#[tauri::command]
#[specta::specta]
pub fn db_sources(window: Window, state: State<'_, AppState>) -> IdeResult<Vec<DataSource>> {
- state.project(window.label())?.db.sources()
+ ide_host::ops::db::sources(&state.host, window.label())
}
#[tauri::command]
#[specta::specta]
pub async fn db_save_sources(window: Window, state: State<'_, AppState>, sources: Vec<DataSource>) -> IdeResult<()> {
- let db = state.project(window.label())?.db.clone();
- db.save_sources(sources).await
+ ide_host::ops::db::save_sources(&state.host, window.label(), sources).await
}
-/// Remembers the password of data source `id` for the session, and in the OS
-/// saved passwords when `save` (`None` forgets it).
#[tauri::command]
#[specta::specta]
pub async fn db_set_password(
@@ -33,11 +29,9 @@ pub async fn db_set_password(
password: Option<String>,
save: bool,
) -> IdeResult<()> {
- let db = state.project(window.label())?.db.clone();
- db.set_password(&id, password, save).await
+ ide_host::ops::db::set_password(&state.host, window.label(), &id, password, save).await
}
-/// Test Connection: connects with unsaved settings and returns the server version.
#[tauri::command]
#[specta::specta]
pub async fn db_test(
@@ -47,11 +41,9 @@ pub async fn db_test(
password: Option<String>,
ssh_secret: Option<String>,
) -> IdeResult<String> {
- let db = state.project(window.label())?.db.clone();
- db.test(&source, password, ssh_secret).await
+ ide_host::ops::db::test(&state.host, window.label(), source, password, ssh_secret).await
}
-/// Remembers the SSH password / key passphrase of a data source (see `db_set_password`).
#[tauri::command]
#[specta::specta]
pub async fn db_set_ssh_secret(
@@ -61,35 +53,27 @@ pub async fn db_set_ssh_secret(
secret: Option<String>,
save: bool,
) -> IdeResult<()> {
- let db = state.project(window.label())?.db.clone();
- db.set_ssh_secret(&id, secret, save).await
+ ide_host::ops::db::set_ssh_secret(&state.host, window.label(), &id, secret, save).await
}
-/// Trusts the SSH host key that made the last connection of `id` fail with
-/// "Unknown SSH host key" (records it in `~/.ssh/known_hosts`).
#[tauri::command]
#[specta::specta]
pub async fn db_trust_ssh_host(window: Window, state: State<'_, AppState>, id: String) -> IdeResult<()> {
- let db = state.project(window.label())?.db.clone();
- db.trust_ssh_host(&id).await
+ ide_host::ops::db::trust_ssh_host(&state.host, window.label(), &id).await
}
#[tauri::command]
#[specta::specta]
pub fn db_connected(window: Window, state: State<'_, AppState>) -> IdeResult<Vec<String>> {
- Ok(state.project(window.label())?.db.connected())
+ ide_host::ops::db::connected(&state.host, window.label())
}
-/// Connects (fails with `permissionDenied` when the password is missing or wrong).
#[tauri::command]
#[specta::specta]
pub async fn db_connect(window: Window, state: State<'_, AppState>, id: String) -> IdeResult<()> {
- let db = state.project(window.label())?.db.clone();
- db.pool(&id).await.map(|_| ())
+ ide_host::ops::db::connect(&state.host, window.label(), &id).await
}
-/// Switches a data source between auto-commit and manual commit (leaving
-/// manual mode rolls back what was not committed).
#[tauri::command]
#[specta::specta]
pub async fn db_set_manual_commit(
@@ -98,12 +82,9 @@ pub async fn db_set_manual_commit(
id: String,
manual: bool,
) -> IdeResult<()> {
- let db = state.project(window.label())?.db.clone();
- db.set_manual_commit(&id, manual).await;
- Ok(())
+ ide_host::ops::db::set_manual_commit(&state.host, window.label(), &id, manual).await
}
-/// Commits or rolls back the open transaction of a manual-commit data source.
#[tauri::command]
#[specta::specta]
pub async fn db_finish_transaction(
@@ -112,31 +93,25 @@ pub async fn db_finish_transaction(
id: String,
commit: bool,
) -> IdeResult<()> {
- let db = state.project(window.label())?.db.clone();
- db.finish_transaction(&id, commit).await
+ ide_host::ops::db::finish_transaction(&state.host, window.label(), &id, commit).await
}
#[tauri::command]
#[specta::specta]
pub async fn db_disconnect(window: Window, state: State<'_, AppState>, id: String) -> IdeResult<()> {
- let db = state.project(window.label())?.db.clone();
- db.disconnect(&id).await;
- Ok(())
+ ide_host::ops::db::disconnect(&state.host, window.label(), &id).await
}
-/// Databases of the server of data source `id` (PostgreSQL); connect to one as `<id>:<database>`.
#[tauri::command]
#[specta::specta]
pub async fn db_databases(window: Window, state: State<'_, AppState>, id: String) -> IdeResult<ide_db::Databases> {
- let db = state.project(window.label())?.db.clone();
- db.databases(&id).await
+ ide_host::ops::db::databases(&state.host, window.label(), &id).await
}
#[tauri::command]
#[specta::specta]
pub async fn db_schemas(window: Window, state: State<'_, AppState>, id: String) -> IdeResult<Vec<String>> {
- let db = state.project(window.label())?.db.clone();
- db.schemas(&id).await
+ ide_host::ops::db::schemas(&state.host, window.label(), &id).await
}
#[tauri::command]
@@ -146,9 +121,8 @@ pub async fn db_tables(
state: State<'_, AppState>,
id: String,
schema: String,
-) -> IdeResult<Vec<TableInfo>> {
- let db = state.project(window.label())?.db.clone();
- db.tables(&id, &schema).await
+) -> IdeResult<Vec<ide_db::TableInfo>> {
+ ide_host::ops::db::tables(&state.host, window.label(), &id, &schema).await
}
#[tauri::command]
@@ -159,12 +133,10 @@ pub async fn db_table_details(
id: String,
schema: String,
table: String,
-) -> IdeResult<TableDetails> {
- let db = state.project(window.label())?.db.clone();
- db.table_details(&id, &schema, &table).await
+) -> IdeResult<ide_db::TableDetails> {
+ ide_host::ops::db::table_details(&state.host, window.label(), &id, &schema, &table).await
}
-/// The DDL of table or view `table` (Go to DDL, Generate DDL).
#[tauri::command]
#[specta::specta]
pub async fn db_ddl(
@@ -174,11 +146,9 @@ pub async fn db_ddl(
schema: String,
table: String,
) -> IdeResult<String> {
- let db = state.project(window.label())?.db.clone();
- db.ddl(&id, &schema, &table).await
+ ide_host::ops::db::ddl(&state.host, window.label(), &id, &schema, &table).await
}
-/// The routines and sequences of `schema` (the tree's `routines` / `sequences`).
#[tauri::command]
#[specta::specta]
pub async fn db_schema_objects(
@@ -186,12 +156,10 @@ pub async fn db_schema_objects(
state: State<'_, AppState>,
id: String,
schema: String,
-) -> IdeResult<SchemaObjects> {
- let db = state.project(window.label())?.db.clone();
- db.schema_objects(&id, &schema).await
+) -> IdeResult<ide_db::SchemaObjects> {
+ ide_host::ops::db::schema_objects(&state.host, window.label(), &id, &schema).await
}
-/// The definition of a routine, trigger or sequence (Go to DDL, Quick Documentation).
#[tauri::command]
#[specta::specta]
pub async fn db_object_ddl(
@@ -202,11 +170,9 @@ pub async fn db_object_ddl(
kind: DbObjectKind,
name: String,
) -> IdeResult<String> {
- let db = state.project(window.label())?.db.clone();
- db.object_ddl(&id, &schema, kind, &name).await
+ ide_host::ops::db::object_ddl(&state.host, window.label(), &id, &schema, kind, &name).await
}
-/// Explain Plan: the execution plan of `statement` on `id`, without running it.
#[tauri::command]
#[specta::specta]
pub async fn db_explain(
@@ -215,23 +181,20 @@ pub async fn db_explain(
request: RequestId,
id: String,
statement: String,
-) -> IdeResult<Vec<PlanNode>> {
- let db = state.project(window.label())?.db.clone();
- let cancel = state.begin_request(request);
- let result = db.explain(&id, &statement, &cancel).await;
- state.end_request(request);
- result
+) -> IdeResult<Vec<ide_db::PlanNode>> {
+ ide_host::ops::db::explain(&state.host, window.label(), request, &id, &statement).await
}
-/// The statements data source `id` ran, newest first (Browse Query History).
#[tauri::command]
#[specta::specta]
-pub async fn db_history(window: Window, state: State<'_, AppState>, id: String) -> IdeResult<Vec<HistoryEntry>> {
- let db = state.project(window.label())?.db.clone();
- db.history(&id).await
+pub async fn db_history(
+ window: Window,
+ state: State<'_, AppState>,
+ id: String,
+) -> IdeResult<Vec<ide_db::HistoryEntry>> {
+ ide_host::ops::db::history(&state.host, window.label(), &id).await
}
-/// Removes statements from the query history of `id` (`None`: all of them).
#[tauri::command]
#[specta::specta]
pub async fn db_remove_history(
@@ -240,11 +203,12 @@ pub async fn db_remove_history(
id: String,
texts: Option<Vec<String>>,
) -> IdeResult<()> {
- let db = state.project(window.label())?.db.clone();
- db.remove_history(&id, texts).await
+ ide_host::ops::db::remove_history(&state.host, window.label(), &id, texts).await
}
-/// Writes exported result data (CSV, JSON, SQL…) to `path`.
+/// Writes exported result data (CSV, JSON, SQL…) to `path`. Stays in the
+/// desktop shell: the path comes from a local save dialog, and a remote
+/// window exports through its local fs commands instead.
#[tauri::command]
#[specta::specta]
pub async fn db_export_file(path: std::path::PathBuf, text: String) -> IdeResult<()> {
@@ -255,24 +219,16 @@ pub async fn db_export_file(path: std::path::PathBuf, text: String) -> IdeResult
.await
}
-/// Tables, columns and foreign keys for SQL completion.
#[tauri::command]
#[specta::specta]
-pub async fn db_completion(window: Window, state: State<'_, AppState>, id: String) -> IdeResult<CompletionModel> {
- let db = state.project(window.label())?.db.clone();
- db.completion(&id).await
-}
-
-#[derive(Clone, Serialize, Deserialize, Type)]
-#[serde(rename_all = "camelCase")]
-#[serde(rename = "DbStatementOutcome")]
-pub struct StatementOutcome {
- pub statement: SqlStatement,
- pub result: Option<QueryResult>,
- pub error: Option<String>,
+pub async fn db_completion(
+ window: Window,
+ state: State<'_, AppState>,
+ id: String,
+) -> IdeResult<ide_db::CompletionModel> {
+ ide_host::ops::db::completion(&state.host, window.label(), &id).await
}
-/// Statements a console runs: the selection's (`from < to`) or the one at the caret (`from`).
#[tauri::command]
#[specta::specta]
pub fn db_statements(
@@ -283,16 +239,9 @@ pub fn db_statements(
from: u32,
to: u32,
) -> IdeResult<Vec<SqlStatement>> {
- let driver = state.project(window.label())?.db.source(&id)?.driver;
- Ok(if from < to {
- ide_db::split::statements_in(&text, from, to, driver)
- } else {
- ide_db::split::statement_at(&text, from, driver).into_iter().collect()
- })
+ ide_host::ops::db::statements(&state.host, window.label(), &id, &text, from, to)
}
-/// Runs `statements` in order on data source `id`, stopping at the first
-/// error. Cancel with `cancel_request(request)`.
#[tauri::command]
#[specta::specta]
pub async fn db_execute(
@@ -303,29 +252,7 @@ pub async fn db_execute(
statements: Vec<SqlStatement>,
max_rows: u32,
) -> IdeResult<Vec<StatementOutcome>> {
- let db = state.project(window.label())?.db.clone();
- let cancel = state.begin_request(request);
- let mut out = Vec::new();
- for statement in statements {
- match db.execute(&id, &statement.text, max_rows.max(1) as usize, &cancel).await {
- Ok(result) => out.push(StatementOutcome { statement, result: Some(result), error: None }),
- Err(e) if e.kind == ide_core::error::ErrorKind::Cancelled => {
- state.end_request(request);
- return Err(e);
- }
- Err(e) if e.kind == ide_core::error::ErrorKind::PermissionDenied && out.is_empty() => {
- // Not connected for lack of a password: the UI asks and retries.
- state.end_request(request);
- return Err(e);
- }
- Err(e) => {
- out.push(StatementOutcome { statement, result: None, error: Some(e.message) });
- break;
- }
- }
- }
- state.end_request(request);
- Ok(out)
+ ide_host::ops::db::execute(&state.host, window.label(), request, &id, statements, max_rows).await
}
#[tauri::command]
@@ -342,17 +269,22 @@ pub async fn db_table_page(
sort: Vec<SortKey>,
offset: u32,
limit: u32,
-) -> IdeResult<TablePage> {
- let db = state.project(window.label())?.db.clone();
- let cancel = state.begin_request(request);
- let result = db
- .table_page(&id, &schema, &table, filter.as_deref(), &sort, offset.into(), limit.max(1).into(), &cancel)
- .await;
- state.end_request(request);
- result
+) -> IdeResult<ide_db::TablePage> {
+ ide_host::ops::db::table_page(
+ &state.host,
+ window.label(),
+ request,
+ &id,
+ &schema,
+ &table,
+ filter,
+ sort,
+ offset,
+ limit,
+ )
+ .await
}
-/// Submits the table editor's changes in one transaction; returns the rows changed.
#[tauri::command]
#[specta::specta]
pub async fn db_apply_edits(
@@ -363,32 +295,11 @@ pub async fn db_apply_edits(
table: String,
edits: Vec<DbRowEdit>,
) -> IdeResult<f64> {
- let db = state.project(window.label())?.db.clone();
- Ok(db.apply_edits(&id, &schema, &table, &edits).await? as f64)
+ ide_host::ops::db::apply_edits(&state.host, window.label(), &id, &schema, &table, edits).await
}
-/// The query console file of data source `id` (`<appData>/consoles/db/<id>/console.sql`), created on first use.
#[tauri::command]
#[specta::specta]
pub fn db_console_path(state: State<'_, AppState>, id: String) -> IdeResult<IpcPath> {
- let (source, database) = ide_db::split_target(&id);
- if source.is_empty() || !source.chars().all(|c| c.is_ascii_alphanumeric() || c == '-' || c == '_') {
- return Err(IdeError::invalid("invalid data source id"));
- }
- // One console per database: `<id>` for the default one, `<id>.<database>` for the others.
- let name = match database {
- Some(db) => {
- let safe: String =
- db.chars().map(|c| if c.is_alphanumeric() || c == '-' || c == '_' { c } else { '_' }).collect();
- format!("{source}.{safe}")
- }
- None => source.to_owned(),
- };
- let dir = state.data_dir.join("consoles").join("db").join(&name);
- std::fs::create_dir_all(&dir)?;
- let file = dir.join("console.sql");
- if !file.exists() {
- std::fs::write(&file, "")?;
- }
- Ok(file.into())
+ ide_host::ops::db::console_path(&state.host, &id)
}
diff --git a/src/bindings.ts b/src/bindings.ts
index fd9ac8c37..02fc09f73 100644
--- a/src/bindings.ts
+++ b/src/bindings.ts
@@ -973,17 +973,8 @@ export const commands = {
proxyCheckConnection: (proxy: ProxySettings, url: string) => typedError<string, IdeError>(__TAURI_INVOKE("proxy_check_connection", { proxy, url })),
dbSources: () => typedError<DataSource[], IdeError>(__TAURI_INVOKE("db_sources")),
dbSaveSources: (sources: DataSource[]) => typedError<null, IdeError>(__TAURI_INVOKE("db_save_sources", { sources })),
- /**
- * Remembers the password of data source `id` for the session, and in the OS
- * saved passwords when `save` (`None` forgets it).
- */
dbSetPassword: (id: string, password: string | null, save: boolean) => typedError<null, IdeError>(__TAURI_INVOKE("db_set_password", { id, password, save })),
- /** Remembers the SSH password / key passphrase of a data source (see `db_set_password`). */
dbSetSshSecret: (id: string, secret: string | null, save: boolean) => typedError<null, IdeError>(__TAURI_INVOKE("db_set_ssh_secret", { id, secret, save })),
- /**
- * Trusts the SSH host key that made the last connection of `id` fail with
- * "Unknown SSH host key" (records it in `~/.ssh/known_hosts`).
- */
dbTrustSshHost: (id: string) => typedError<null, IdeError>(__TAURI_INVOKE("db_trust_ssh_host", { id })),
/** Test Connection: connects with `config` as edited (not necessarily saved). */
sshTest: (config: SshConfiguration, secret: string | null) => typedError<string, IdeError>(__TAURI_INVOKE("ssh_test", { config, secret })),
@@ -1054,51 +1045,33 @@ export const commands = {
* (and the project's `remoteEnv` on a remote host); running ones keep theirs.
*/
envReload: () => typedError<EnvReloaded, IdeError>(__TAURI_INVOKE("env_reload")),
- /** Test Connection: connects with unsaved settings and returns the server version. */
dbTest: (source: DataSource, password: string | null, sshSecret: string | null) => typedError<string, IdeError>(__TAURI_INVOKE("db_test", { source, password, sshSecret })),
dbConnected: () => typedError<string[], IdeError>(__TAURI_INVOKE("db_connected")),
- /** Connects (fails with `permissionDenied` when the password is missing or wrong). */
dbConnect: (id: string) => typedError<null, IdeError>(__TAURI_INVOKE("db_connect", { id })),
dbDisconnect: (id: string) => typedError<null, IdeError>(__TAURI_INVOKE("db_disconnect", { id })),
- /** Databases of the server of data source `id` (PostgreSQL); connect to one as `<id>:<database>`. */
dbDatabases: (id: string) => typedError<DbDatabases, IdeError>(__TAURI_INVOKE("db_databases", { id })),
dbSchemas: (id: string) => typedError<string[], IdeError>(__TAURI_INVOKE("db_schemas", { id })),
dbTables: (id: string, schema: string) => typedError<DbTableInfo[], IdeError>(__TAURI_INVOKE("db_tables", { id, schema })),
dbTableDetails: (id: string, schema: string, table: string) => typedError<DbTableDetails, IdeError>(__TAURI_INVOKE("db_table_details", { id, schema, table })),
- /** The DDL of table or view `table` (Go to DDL, Generate DDL). */
dbDdl: (id: string, schema: string, table: string) => typedError<string, IdeError>(__TAURI_INVOKE("db_ddl", { id, schema, table })),
- /** The routines and sequences of `schema` (the tree's `routines` / `sequences`). */
dbSchemaObjects: (id: string, schema: string) => typedError<DbSchemaObjects, IdeError>(__TAURI_INVOKE("db_schema_objects", { id, schema })),
- /** The definition of a routine, trigger or sequence (Go to DDL, Quick Documentation). */
dbObjectDdl: (id: string, schema: string, kind: DbObjectKind, name: string) => typedError<string, IdeError>(__TAURI_INVOKE("db_object_ddl", { id, schema, kind, name })),
- /** Explain Plan: the execution plan of `statement` on `id`, without running it. */
dbExplain: (request: RequestId, id: string, statement: string) => typedError<DbPlanNode[], IdeError>(__TAURI_INVOKE("db_explain", { request, id, statement })),
- /** The statements data source `id` ran, newest first (Browse Query History). */
dbHistory: (id: string) => typedError<DbHistoryEntry[], IdeError>(__TAURI_INVOKE("db_history", { id })),
- /** Removes statements from the query history of `id` (`None`: all of them). */
dbRemoveHistory: (id: string, texts: string[] | null) => typedError<null, IdeError>(__TAURI_INVOKE("db_remove_history", { id, texts })),
- /** Tables, columns and foreign keys for SQL completion. */
dbCompletion: (id: string) => typedError<DbCompletion, IdeError>(__TAURI_INVOKE("db_completion", { id })),
- /** Writes exported result data (CSV, JSON, SQL…) to `path`. */
- dbExportFile: (path: string, text: string) => typedError<null, IdeError>(__TAURI_INVOKE("db_export_file", { path, text })),
/**
- * Switches a data source between auto-commit and manual commit (leaving
- * manual mode rolls back what was not committed).
+ * Writes exported result data (CSV, JSON, SQL…) to `path`. Stays in the
+ * desktop shell: the path comes from a local save dialog, and a remote
+ * window exports through its local fs commands instead.
*/
+ dbExportFile: (path: string, text: string) => typedError<null, IdeError>(__TAURI_INVOKE("db_export_file", { path, text })),
dbSetManualCommit: (id: string, manual: boolean) => typedError<null, IdeError>(__TAURI_INVOKE("db_set_manual_commit", { id, manual })),
- /** Commits or rolls back the open transaction of a manual-commit data source. */
dbFinishTransaction: (id: string, commit: boolean) => typedError<null, IdeError>(__TAURI_INVOKE("db_finish_transaction", { id, commit })),
- /** Statements a console runs: the selection's (`from < to`) or the one at the caret (`from`). */
dbStatements: (id: string, text: string, from: number, to: number) => typedError<SqlStatement[], IdeError>(__TAURI_INVOKE("db_statements", { id, text, from, to })),
- /**
- * Runs `statements` in order on data source `id`, stopping at the first
- * error. Cancel with `cancel_request(request)`.
- */
dbExecute: (request: RequestId, id: string, statements: SqlStatement[], maxRows: number) => typedError<DbStatementOutcome[], IdeError>(__TAURI_INVOKE("db_execute", { request, id, statements, maxRows })),
dbTablePage: (request: RequestId, id: string, schema: string, table: string, filter: string | null, sort: DbSortKey[], offset: number, limit: number) => typedError<DbTablePage, IdeError>(__TAURI_INVOKE("db_table_page", { request, id, schema, table, filter, sort, offset, limit })),
- /** Submits the table editor's changes in one transaction; returns the rows changed. */
dbApplyEdits: (id: string, schema: string, table: string, edits: DbRowEdit[]) => typedError<number | null, IdeError>(__TAURI_INVOKE("db_apply_edits", { id, schema, table, edits })),
- /** The query console file of data source `id` (`<appData>/consoles/db/<id>/console.sql`), created on first use. */
dbConsolePath: (id: string) => typedError<IpcPath, IdeError>(__TAURI_INVOKE("db_console_path", { id })),
};
@@ -2403,6 +2376,7 @@ export type DbSslMode = "disable" | "prefer" | "require" |
/** [`DbSslMode::VerifyCa`], and check that the certificate names the host. */
"verifyFull";
+/** One statement of a console run. */
export type DbStatementOutcome = {
statement: SqlStatement,
result: DbQueryResult | null,