From 9bf1f320eb249cbc875143380ab77f64aa2a6a80 Mon Sep 17 00:00:00 2001 From: Ernstjan Freriks Date: Mon, 16 Nov 2026 18:50:14 +0100 Subject: [PATCH] feat(database): export with pg_dump and restore with pg_restore / psql (#3718) PostgreSQL data sources, databases, schemas and tables get Import/Export > Export with 'pg_dump'... and Restore with 'pg_restore'/'psql'.... ide-db finds the installed client tools, turns the dialog's options into the command line, and runs it connected like the data source (SSH tunnel, SSL settings, read-only flag), with the password in PGPASSWORD and never in the arguments. Output streams to the UI; a RequestId cancels the run, which continues after the dialog closes and ends with a notification. The dialogs preselect the client matching the server's major version and warn when it does not fit; Restore reads the dump header to pick psql or pg_restore. Not offered in remote windows. Co-authored-by: EjaYF <9842286+EjaYF@users.noreply.github.com> --- crates/ide-db/src/lib.rs | 51 ++ crates/ide-db/src/tools/jobs.rs | 339 ++++++++++ crates/ide-db/src/tools/mod.rs | 536 +++++++++++++++ crates/ide-db/tests/postgres.rs | 75 +++ crates/ide-host/src/ops/db.rs | 32 + src-tauri/src/commands/db.rs | 62 ++ src-tauri/src/commands/mod.rs | 6 + src-tauri/tests/commands.snap | 6 + src/bindings.ts | 90 +++ src/features/database/Database.module.css | 59 ++ src/features/database/Dialogs.tsx | 22 + src/features/database/DumpDialogs.tsx | 783 ++++++++++++++++++++++ src/features/database/dumpTools.test.ts | 144 ++++ src/features/database/dumpTools.ts | 180 +++++ src/features/database/store.ts | 6 +- src/features/database/toolRuns.ts | 161 +++++ src/features/database/treeActions.ts | 40 ++ src/features/database/treeMenu.ts | 27 +- src/platform/i18n.test.ts | 4 + src/platform/locales/text/en.json | 66 +- src/platform/locales/text/zh.json | 64 +- 21 files changed, 2749 insertions(+), 4 deletions(-) create mode 100644 crates/ide-db/src/tools/jobs.rs create mode 100644 crates/ide-db/src/tools/mod.rs create mode 100644 src/features/database/DumpDialogs.tsx create mode 100644 src/features/database/dumpTools.test.ts create mode 100644 src/features/database/dumpTools.ts create mode 100644 src/features/database/toolRuns.ts diff --git a/crates/ide-db/src/lib.rs b/crates/ide-db/src/lib.rs index 57ba5b3f2..a438200cd 100644 --- a/crates/ide-db/src/lib.rs +++ b/crates/ide-db/src/lib.rs @@ -14,6 +14,7 @@ mod snowflake; pub mod source; pub mod split; pub mod sql; +pub mod tools; mod watch; pub use watch::SourcesWatch; @@ -787,6 +788,56 @@ impl DbManager { Ok(v.unwrap_or_else(|| "Connected".into())) } + /// Runs `job` with the client tool at `executable` against target `id`, connected like the + /// data source (through its SSH tunnel, with its SSL settings and password), until it exits + /// or `cancel` fires. Connects first, so a missing password fails the way it does for a + /// console. Returns the exit code. + pub async fn run_tool( + &self, + id: &str, + executable: &std::path::Path, + job: &tools::DbToolJob, + cancel: &CancellationToken, + on_output: impl FnMut(Vec), + ) -> IdeResult> { + let tool = job.tool(); + if !tool.is_program(executable) { + return Err(IdeError::invalid(format!("{} is not {}", executable.display(), tool.program()))); + } + let source = self.source(id)?; + if source.driver != tool.driver() { + return Err(IdeError::invalid(format!("{} cannot connect to {}", tool.program(), source.name))); + } + self.pool(id).await?; + let password = self.password(&source).await; + // Holding the tunnel keeps it open while the tool runs, even if the tree disconnects. + let (target, _tunnel) = self.endpoint(&source, None, true).await?; + let prepared = tools::prepare(job, &target, password.as_deref()); + tools::run(executable, &prepared.args, &prepared.env, cancel, on_output).await + } + + /// The command [`DbManager::run_tool`] would run, for the dialogs' preview: the data source's + /// own host and port (not a tunnel's local end), and no password. + pub fn tool_preview(&self, id: &str, executable: &std::path::Path, job: &tools::DbToolJob) -> IdeResult { + let source = self.source(id)?; + let prepared = tools::prepare(job, &source, None); + Ok(tools::command_line(executable, &prepared.args)) + } + + /// The PostgreSQL server's `server_version_num` (`150013` for 15.13). + pub async fn server_version(&self, id: &str) -> IdeResult { + let pool = self.pool(id).await?; + if pool.driver() != DbDriver::Postgres { + return Err(IdeError::invalid("not a PostgreSQL data source")); + } + let rows = pool.rows("SHOW server_version_num", 1).await?; + rows.into_iter() + .next() + .and_then(|r| r.into_iter().next().flatten()) + .and_then(|v| v.trim().parse().ok()) + .ok_or_else(|| IdeError::internal("no server version")) + } + pub fn is_connected(&self, id: &str) -> bool { self.pools.lock().contains_key(id) } diff --git a/crates/ide-db/src/tools/jobs.rs b/crates/ide-db/src/tools/jobs.rs new file mode 100644 index 000000000..c37a1f780 --- /dev/null +++ b/crates/ide-db/src/tools/jobs.rs @@ -0,0 +1,339 @@ +//! What a dump or restore dialog asks for, as typed options, and the arguments that do it. +//! The connection arguments come from [`super::connection`]; these are the rest. + +use super::DbTool; +use serde::{Deserialize, Serialize}; +use specta::Type; +use std::path::Path; + +#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Type)] +#[serde(rename_all = "camelCase")] +pub enum DbDumpFormat { + /// SQL text, restored with `psql`. + Plain, + Custom, + /// A directory of files; the only format `pg_dump` writes in parallel. + Directory, + Tar, +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Type)] +#[serde(rename_all = "camelCase")] +pub enum DbDumpStatements { + Copy, + Inserts, + ColumnInserts, +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Type)] +#[serde(rename_all = "camelCase")] +pub enum DbDumpContent { + All, + SchemaOnly, + DataOnly, +} + +/// Name lists hold `pg_dump` patterns (`*`, `?`, quoted names). +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)] +#[serde(rename_all = "camelCase")] +pub struct DbPgDumpOptions { + pub format: DbDumpFormat, + pub statements: DbDumpStatements, + pub content: DbDumpContent, + pub schemas: Vec, + pub tables: Vec, + pub exclude_tables: Vec, + /// Plain format only: archives get DROP / CREATE at restore. + pub clean: bool, + pub if_exists: bool, + pub create: bool, + pub no_owner: bool, + pub no_privileges: bool, + /// Directory format only. + pub jobs: u32, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)] +#[serde(rename_all = "camelCase")] +pub struct DbPgRestoreOptions { + pub content: DbDumpContent, + pub schemas: Vec, + pub clean: bool, + pub if_exists: bool, + pub no_owner: bool, + pub no_privileges: bool, + pub single_transaction: bool, + pub exit_on_error: bool, + /// Ignored with a single transaction, which `pg_restore` cannot split. + pub jobs: u32, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)] +#[serde(rename_all = "camelCase")] +pub struct DbPsqlOptions { + pub single_transaction: bool, + pub stop_on_error: bool, +} + +/// A run of a client tool: which one, the file it writes or reads, and its options. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)] +#[serde(tag = "tool", rename_all = "camelCase")] +pub enum DbToolJob { + PgDump { + file: String, + options: DbPgDumpOptions, + }, + /// `file`: an archive, or a directory archive. + PgRestore { + file: String, + options: DbPgRestoreOptions, + }, + Psql { + file: String, + options: DbPsqlOptions, + }, +} + +impl DbToolJob { + pub fn tool(&self) -> DbTool { + match self { + DbToolJob::PgDump { .. } => DbTool::PgDump, + DbToolJob::PgRestore { .. } => DbTool::PgRestore, + DbToolJob::Psql { .. } => DbTool::Psql, + } + } + + /// The arguments after the connection ones. + pub fn args(&self) -> Vec { + match self { + DbToolJob::PgDump { file, options } => pg_dump(options, file), + DbToolJob::PgRestore { file, options } => pg_restore(options, file), + DbToolJob::Psql { file, options } => psql(options, file), + } + } +} + +fn flag(on: bool, flag: &str) -> Option { + on.then(|| flag.to_owned()) +} + +fn content(c: DbDumpContent) -> Option { + match c { + DbDumpContent::All => None, + DbDumpContent::SchemaOnly => Some("--schema-only".into()), + DbDumpContent::DataOnly => Some("--data-only".into()), + } +} + +fn each(names: &[String], option: &str) -> impl Iterator { + names.iter().map(|n| n.trim()).filter(|n| !n.is_empty()).map(move |n| format!("--{option}={n}")) +} + +fn pg_dump(o: &DbPgDumpOptions, file: &str) -> Vec { + let plain = o.format == DbDumpFormat::Plain; + let format = match o.format { + DbDumpFormat::Plain => "p", + DbDumpFormat::Custom => "c", + DbDumpFormat::Directory => "d", + DbDumpFormat::Tar => "t", + }; + let mut args = vec![format!("--format={format}"), format!("--file={file}")]; + args.extend(match o.statements { + DbDumpStatements::Copy => None, + DbDumpStatements::Inserts => Some("--inserts".to_owned()), + DbDumpStatements::ColumnInserts => Some("--column-inserts".to_owned()), + }); + args.extend(content(o.content)); + args.extend(each(&o.schemas, "schema")); + args.extend(each(&o.tables, "table")); + args.extend(each(&o.exclude_tables, "exclude-table")); + args.extend(flag(plain && o.clean, "--clean")); + args.extend(flag(plain && o.clean && o.if_exists, "--if-exists")); + args.extend(flag(plain && o.create, "--create")); + args.extend(flag(o.no_owner, "--no-owner")); + args.extend(flag(o.no_privileges, "--no-privileges")); + if o.format == DbDumpFormat::Directory && o.jobs > 1 { + args.push(format!("--jobs={}", o.jobs)); + } + args.push("--verbose".into()); + args +} + +fn pg_restore(o: &DbPgRestoreOptions, file: &str) -> Vec { + let mut args: Vec = content(o.content).into_iter().collect(); + args.extend(each(&o.schemas, "schema")); + args.extend(flag(o.clean, "--clean")); + args.extend(flag(o.clean && o.if_exists, "--if-exists")); + args.extend(flag(o.no_owner, "--no-owner")); + args.extend(flag(o.no_privileges, "--no-privileges")); + args.extend(flag(o.single_transaction, "--single-transaction")); + args.extend(flag(o.exit_on_error, "--exit-on-error")); + if o.jobs > 1 && !o.single_transaction { + args.push(format!("--jobs={}", o.jobs)); + } + args.push("--verbose".into()); + if !file.is_empty() { + args.push(file.to_owned()); + } + args +} + +fn psql(o: &DbPsqlOptions, file: &str) -> Vec { + let mut args: Vec = (!file.is_empty()).then(|| format!("--file={file}")).into_iter().collect(); + args.extend(flag(o.single_transaction, "--single-transaction")); + args.extend(flag(o.stop_on_error, "--set=ON_ERROR_STOP=1")); + args +} + +/// The command as a shell would need it typed: the dialogs' preview. +pub fn command_line(program: &Path, args: &[String]) -> String { + let quote = |s: &str| { + if !s.is_empty() && s.chars().all(|c| c.is_ascii_alphanumeric() || "@%+=:,./-_".contains(c)) { + s.to_owned() + } else { + format!("'{}'", s.replace('\'', "'\\''")) + } + }; + std::iter::once(program.to_string_lossy().into_owned()) + .chain(args.iter().cloned()) + .map(|a| quote(&a)) + .collect::>() + .join(" ") +} + +#[cfg(test)] +mod tests { + use super::*; + + fn dump() -> DbPgDumpOptions { + DbPgDumpOptions { + format: DbDumpFormat::Plain, + statements: DbDumpStatements::Copy, + content: DbDumpContent::All, + schemas: vec![], + tables: vec![], + exclude_tables: vec![], + clean: false, + if_exists: false, + create: false, + no_owner: false, + no_privileges: false, + jobs: 1, + } + } + + fn restore() -> DbPgRestoreOptions { + DbPgRestoreOptions { + content: DbDumpContent::All, + schemas: vec![], + clean: false, + if_exists: false, + no_owner: false, + no_privileges: false, + single_transaction: false, + exit_on_error: true, + jobs: 1, + } + } + + fn args(job: DbToolJob) -> Vec { + job.args() + } + + #[test] + fn dumps_plain_sql_with_copy_by_default() { + let job = DbToolJob::PgDump { file: "/tmp/shop.sql".into(), options: dump() }; + assert_eq!(args(job), ["--format=p", "--file=/tmp/shop.sql", "--verbose"]); + } + + #[test] + fn turns_lists_and_switches_into_flags() { + let options = DbPgDumpOptions { + statements: DbDumpStatements::ColumnInserts, + content: DbDumpContent::DataOnly, + schemas: vec!["public".into(), "audit".into()], + tables: vec!["public.orders".into()], + exclude_tables: vec!["public.log_*".into()], + clean: true, + if_exists: true, + create: true, + no_owner: true, + ..dump() + }; + assert_eq!( + args(DbToolJob::PgDump { file: "/tmp/x.sql".into(), options }), + [ + "--format=p", + "--file=/tmp/x.sql", + "--column-inserts", + "--data-only", + "--schema=public", + "--schema=audit", + "--table=public.orders", + "--exclude-table=public.log_*", + "--clean", + "--if-exists", + "--create", + "--no-owner", + "--verbose", + ] + ); + } + + #[test] + fn leaves_drop_and_create_to_the_restore_of_an_archive() { + let options = DbPgDumpOptions { format: DbDumpFormat::Custom, clean: true, create: true, ..dump() }; + let a = args(DbToolJob::PgDump { file: "/tmp/x.dump".into(), options }); + assert!(!a.iter().any(|a| a == "--clean" || a == "--create"), "{a:?}"); + } + + #[test] + fn runs_parallel_jobs_only_where_the_tool_can() { + let dir = DbPgDumpOptions { format: DbDumpFormat::Directory, jobs: 4, ..dump() }; + assert!(args(DbToolJob::PgDump { file: "/tmp/d".into(), options: dir.clone() }).contains(&"--jobs=4".into())); + let custom = DbPgDumpOptions { format: DbDumpFormat::Custom, ..dir }; + assert!(!args(DbToolJob::PgDump { file: "/tmp/d".into(), options: custom }).contains(&"--jobs=4".into())); + let single = DbPgRestoreOptions { jobs: 4, single_transaction: true, ..restore() }; + let a = args(DbToolJob::PgRestore { file: "/tmp/x".into(), options: single }); + assert!(a.contains(&"--single-transaction".into()) && !a.iter().any(|a| a.starts_with("--jobs"))); + } + + #[test] + fn restores_the_archive_named_last_and_stops_on_the_first_error() { + assert_eq!( + args(DbToolJob::PgRestore { file: "/tmp/shop.dump".into(), options: restore() }), + ["--exit-on-error", "--verbose", "/tmp/shop.dump"] + ); + } + + #[test] + fn leaves_out_an_archive_not_chosen_yet() { + let a = args(DbToolJob::PgRestore { file: String::new(), options: restore() }); + assert_eq!(a, ["--exit-on-error", "--verbose"]); + } + + #[test] + fn runs_a_sql_file_in_one_transaction_that_stops_on_error() { + let options = DbPsqlOptions { single_transaction: true, stop_on_error: true }; + assert_eq!( + args(DbToolJob::Psql { file: "/tmp/shop.sql".into(), options }), + ["--file=/tmp/shop.sql", "--single-transaction", "--set=ON_ERROR_STOP=1"] + ); + } + + #[test] + fn quotes_what_a_shell_would_split() { + let line = command_line( + Path::new("/usr/bin/pg_dump"), + &["--port=5432".into(), "--file=/tmp/my dump.sql".into(), "--table=it's".into()], + ); + assert_eq!(line, r#"/usr/bin/pg_dump --port=5432 '--file=/tmp/my dump.sql' '--table=it'\''s'"#); + } + + #[test] + fn reads_the_job_the_dialog_sends() { + let json = r#"{"tool":"psql","file":"/tmp/a.sql","options":{"singleTransaction":true,"stopOnError":false}}"#; + let job: DbToolJob = serde_json::from_str(json).unwrap(); + assert_eq!(job.tool(), DbTool::Psql); + } +} diff --git a/crates/ide-db/src/tools/mod.rs b/crates/ide-db/src/tools/mod.rs new file mode 100644 index 000000000..6c0e4b5ef --- /dev/null +++ b/crates/ide-db/src/tools/mod.rs @@ -0,0 +1,536 @@ +//! Client tools of a database (`pg_dump`, `pg_restore`, `psql`): finding installed copies, the +//! arguments and environment that connect them like the data source, and running them. + +mod jobs; +pub use jobs::*; + +use crate::source::{DataSource, DbDriver, DbSslMode}; +use ide_core::{CancellationToken, IdeError, IdeResult}; +use serde::{Deserialize, Serialize}; +use specta::Type; +use std::ffi::OsStr; +use std::path::{Path, PathBuf}; +use std::process::Stdio; +use std::time::Duration; +use tokio::io::{AsyncBufReadExt, AsyncRead, BufReader}; + +#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Type)] +#[serde(rename_all = "camelCase")] +pub enum DbTool { + PgDump, + PgRestore, + Psql, +} + +impl DbTool { + pub fn program(self) -> &'static str { + self.programs()[0] + } + + /// Executable names. + pub fn programs(self) -> &'static [&'static str] { + match self { + DbTool::PgDump => &["pg_dump"], + DbTool::PgRestore => &["pg_restore"], + DbTool::Psql => &["psql"], + } + } + + pub fn driver(self) -> DbDriver { + DbDriver::Postgres + } + + /// Whether `path` names this tool (`pg_dump`, `pg_dump.exe`, `pg_dump-17`…). + /// The data source's password is handed only to such a program. + pub fn is_program(self, path: &Path) -> bool { + let Some(stem) = path.file_stem().and_then(OsStr::to_str) else { return false }; + self.programs().iter().any(|p| { + stem.strip_prefix(p).is_some_and(|rest| { + let digits = rest.strip_prefix(['-', '.', '_']).unwrap_or(rest); + digits.chars().all(|c| c.is_ascii_digit()) + }) + }) + } +} + +/// An installed copy of a tool. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)] +#[serde(rename_all = "camelCase", rename = "DbToolInstall")] +pub struct ToolInstall { + pub path: String, + /// First line of `--version`, e.g. `pg_dump (PostgreSQL) 17.2`. + pub version: String, +} + +/// A line the tool wrote. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)] +#[serde(rename_all = "camelCase", rename = "DbToolLine")] +pub struct ToolLine { + pub stderr: bool, + pub text: String, +} + +/// Directories holding the tools that are often missing from `PATH`, by platform. +fn known_dirs() -> Vec { + let mut dirs = Vec::new(); + if cfg!(target_os = "macos") { + for prefix in ["/opt/homebrew", "/usr/local"] { + dirs.push(PathBuf::from(format!("{prefix}/bin"))); + let opt = PathBuf::from(format!("{prefix}/opt")); + for keg in ["libpq", "postgresql"] { + dirs.extend(children(&opt, keg).into_iter().map(|d| d.join("bin"))); + } + } + dirs.extend( + children(Path::new("/Applications/Postgres.app/Contents/Versions"), "").into_iter().map(|d| d.join("bin")), + ); + } else if cfg!(windows) { + for var in ["ProgramFiles", "ProgramFiles(x86)"] { + if let Some(base) = std::env::var_os(var) { + let root = PathBuf::from(base).join("PostgreSQL"); + dirs.extend(children(&root, "").into_iter().map(|d| d.join("bin"))); + } + } + } else { + dirs.extend(children(Path::new("/usr/lib/postgresql"), "").into_iter().map(|d| d.join("bin"))); + dirs.extend(children(Path::new("/usr"), "pgsql-").into_iter().map(|d| d.join("bin"))); + } + dirs +} + +/// Subdirectories of `parent` whose name starts with `prefix`, newest version first. +fn children(parent: &Path, prefix: &str) -> Vec { + let Ok(entries) = std::fs::read_dir(parent) else { return Vec::new() }; + let mut dirs: Vec = entries + .flatten() + .filter(|e| e.file_name().to_str().is_some_and(|n| n.starts_with(prefix))) + .map(|e| e.path()) + .filter(|p| p.is_dir()) + .collect(); + dirs.sort_by_key(|p| std::cmp::Reverse(version_key(&p.to_string_lossy()))); + dirs +} + +/// The numbers in `text`, for comparing versions (`17.2` after `9.6`). +fn version_key(text: &str) -> Vec { + text.split(|c: char| !c.is_ascii_digit()).filter_map(|n| n.parse().ok()).collect() +} + +/// The installed copies of `tool` on `PATH` and in the usual install directories, newest first. +/// Blocking: runs each one's `--version`. +pub fn find_installs(tool: DbTool) -> Vec { + let path = ide_core::process::host_var_os("PATH").unwrap_or_default(); + let mut dirs: Vec = std::env::split_paths(&path).collect(); + dirs.extend(known_dirs()); + let mut seen = Vec::new(); + let mut out = Vec::new(); + for dir in dirs { + for program in tool.programs() { + let Some(found) = ide_core::process::find_executable(program, dir.as_os_str()) else { continue }; + let real = dunce::canonicalize(&found).unwrap_or_else(|_| found.clone()); + if seen.contains(&real) { + continue; + } + seen.push(real); + if let Ok(version) = version_of(&found) { + out.push(ToolInstall { path: found.to_string_lossy().into_owned(), version }); + } + } + } + out.sort_by_key(|i| std::cmp::Reverse(version_key(&i.version))); + out +} + +/// The first line `path --version` prints. Blocking. +pub fn version_of(path: &Path) -> IdeResult { + let (ok, text) = capture(path, "--version")?; + match text.lines().next().map(str::trim).filter(|l| !l.is_empty()) { + Some(line) if ok => Ok(line.to_owned()), + _ => Err(IdeError::invalid(format!("{} is not a working executable", path.display()))), + } +} + +/// Runs `path arg` for at most five seconds; whether it succeeded, and its standard output. +fn capture(path: &Path, arg: &str) -> IdeResult<(bool, String)> { + if !path.is_file() { + return Err(IdeError::not_found(format!("{} does not exist", path.display()))); + } + let mut cmd = std::process::Command::new(path); + cmd.arg(arg).stdin(Stdio::null()).stdout(Stdio::piped()).stderr(Stdio::null()); + ide_core::process::prepare(&mut cmd); + let mut child = cmd.spawn().map_err(|e| IdeError::invalid(format!("cannot run {}: {e}", path.display())))?; + let mut stdout = child.stdout.take().expect("piped"); + let reader = std::thread::spawn(move || { + let mut buf = Vec::new(); + let _ = std::io::Read::read_to_end(&mut stdout, &mut buf); + buf + }); + let deadline = std::time::Instant::now() + Duration::from_secs(5); + let status = loop { + if let Some(status) = child.try_wait()? { + break status; + } + if std::time::Instant::now() > deadline { + let _ = child.kill(); + let _ = child.wait(); + return Err(IdeError::invalid(format!("{} {arg} did not finish", path.display()))); + } + std::thread::sleep(Duration::from_millis(20)); + }; + let out = reader.join().unwrap_or_default(); + Ok((status.success(), String::from_utf8_lossy(&out).into_owned())) +} + +/// What made a dump, read from its first bytes (a directory: its `toc.dat`). +#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Type)] +#[serde(rename_all = "camelCase")] +pub enum DbDumpKind { + /// `pg_dump` custom or tar archive, or a directory archive: `pg_restore`. + PostgresArchive, + /// Plain SQL from `pg_dump`: `psql`. + PostgresSql, + /// `mysqldump` / `mariadb-dump`: not for the PostgreSQL tools. + MysqlSql, + Unknown, +} + +/// Blocking: reads at most the first 4 KiB. +pub fn dump_kind(path: &Path) -> IdeResult { + use std::io::Read; + if path.is_dir() { + return Ok(if path.join("toc.dat").is_file() { DbDumpKind::PostgresArchive } else { DbDumpKind::Unknown }); + } + let mut head = Vec::with_capacity(4096); + std::fs::File::open(path) + .map_err(|e| IdeError::not_found(format!("cannot read {}: {e}", path.display())))? + .take(4096) + .read_to_end(&mut head)?; + Ok(kind_of(&head)) +} + +fn kind_of(head: &[u8]) -> DbDumpKind { + // A tar archive keeps `toc.dat` first; its name starts the 512-byte header. + if head.starts_with(b"PGDMP") || head.starts_with(b"toc.dat\0") { + return DbDumpKind::PostgresArchive; + } + let text = String::from_utf8_lossy(head); + let comments: Vec<&str> = text.lines().take(20).filter(|l| l.starts_with("--")).collect(); + if comments.iter().any(|l| l.contains("PostgreSQL database dump")) { + DbDumpKind::PostgresSql + } else if comments.iter().any(|l| l.starts_with("-- MySQL dump") || l.starts_with("-- MariaDB dump")) { + DbDumpKind::MysqlSql + } else { + DbDumpKind::Unknown + } +} + +/// Arguments and environment that connect `tool` to `source` (already resolved, through its +/// tunnel when it has one). The password is left to [`prepare`]. +pub fn connection(tool: DbTool, source: &DataSource) -> (Vec, Vec<(String, String)>) { + let mut args = Vec::new(); + let host = source.host.trim(); + if !host.is_empty() { + args.push(format!("--host={host}")); + } + args.push(format!("--port={}", source.port.or(source.driver.default_port()).unwrap_or(5432))); + if !source.user.trim().is_empty() { + args.push(format!("--username={}", source.user.trim())); + } + if !source.database.is_empty() { + args.push(format!("--dbname={}", source.database)); + } + // Without a terminal a password prompt would wait forever: fail instead. + args.push("--no-password".into()); + + let mut env = vec![ + ("PGAPPNAME".to_owned(), format!("OpenIDEA {}", tool.program())), + ( + "PGSSLMODE".to_owned(), + match source.ssl { + DbSslMode::Disable => "disable", + DbSslMode::Prefer => "prefer", + DbSslMode::Require => "require", + DbSslMode::VerifyCa => "verify-ca", + DbSslMode::VerifyFull => "verify-full", + } + .to_owned(), + ), + ]; + for (var, file) in [ + ("PGSSLROOTCERT", &source.ssl_ca_file), + ("PGSSLCERT", &source.ssl_cert_file), + ("PGSSLKEY", &source.ssl_key_file), + ] { + if !file.trim().is_empty() { + env.push((var.to_owned(), ide_ssh::expand(file.trim()).to_string_lossy().into_owned())); + } + } + if source.read_only { + env.push(("PGOPTIONS".to_owned(), "-c default_transaction_read_only=on".to_owned())); + } + (args, env) +} + +/// How a tool is started: connection arguments, then the job's, and the environment. +pub struct Prepared { + pub args: Vec, + pub env: Vec<(String, String)>, +} + +/// The command for `job` against `source`. The password goes in `PGPASSWORD`, never in the +/// arguments, which other users of the machine can read in the process list. +pub fn prepare(job: &DbToolJob, source: &DataSource, password: Option<&str>) -> Prepared { + let (mut args, mut env) = connection(job.tool(), source); + args.extend(job.args()); + if let Some(p) = password.filter(|p| !p.is_empty()) { + env.push(("PGPASSWORD".into(), p.to_owned())); + } + Prepared { args, env } +} + +/// Runs `program` until it exits, passing its output in batches. Returns the exit code +/// (`None`: ended by a signal). Cancelling kills it and everything it started. +pub async fn run( + program: &Path, + args: &[String], + env: &[(String, String)], + cancel: &CancellationToken, + mut on_output: impl FnMut(Vec), +) -> IdeResult> { + let mut cmd = tokio::process::Command::new(program); + cmd.args(args) + .envs(env.iter().map(|(k, v)| (k, v))) + .stdin(Stdio::null()) + .stdout(Stdio::piped()) + .stderr(Stdio::piped()) + .kill_on_drop(true); + ide_core::process::prepare(cmd.as_std_mut()); + ide_core::process::own_group(cmd.as_std_mut()); + let mut child = cmd.spawn().map_err(|e| IdeError::invalid(format!("cannot start {}: {e}", program.display())))?; + let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel(); + if let Some(out) = child.stdout.take() { + forward(out, false, tx.clone()); + } + if let Some(err) = child.stderr.take() { + forward(err, true, tx); + } + + let mut batch = Vec::new(); + let mut tick = tokio::time::interval(Duration::from_millis(100)); + loop { + tokio::select! { + line = rx.recv() => match line { + Some(line) => { + batch.push(line); + if batch.len() >= 500 { + on_output(std::mem::take(&mut batch)); + } + } + None => break, + }, + _ = tick.tick() => { + if !batch.is_empty() { + on_output(std::mem::take(&mut batch)); + } + } + _ = cancel.cancelled() => { + if let Some(pid) = child.id() { + ide_core::process::kill_tree_of(pid); + } + let _ = child.kill().await; + return Err(IdeError::cancelled()); + } + } + } + if !batch.is_empty() { + on_output(batch); + } + let status = tokio::select! { + status = child.wait() => status?, + _ = cancel.cancelled() => { + if let Some(pid) = child.id() { + ide_core::process::kill_tree_of(pid); + } + let _ = child.kill().await; + return Err(IdeError::cancelled()); + } + }; + Ok(status.code()) +} + +fn forward( + pipe: impl AsyncRead + Unpin + Send + 'static, + stderr: bool, + tx: tokio::sync::mpsc::UnboundedSender, +) { + tokio::spawn(async move { + let mut reader = BufReader::new(pipe); + let mut buf = Vec::new(); + loop { + buf.clear(); + match reader.read_until(b'\n', &mut buf).await { + Ok(0) | Err(_) => break, + Ok(_) => { + let text = String::from_utf8_lossy(&buf).trim_end_matches(['\r', '\n']).to_owned(); + if tx.send(ToolLine { stderr, text }).is_err() { + break; + } + } + } + } + }); +} + +#[cfg(test)] +mod tests { + use super::*; + + fn pg() -> DataSource { + DataSource { + driver: DbDriver::Postgres, + host: "db.example.test".into(), + port: Some(6543), + user: "app".into(), + database: "shop".into(), + ..DataSource::default() + } + } + + #[test] + fn connects_like_the_data_source_without_prompting() { + let (args, env) = connection(DbTool::PgDump, &pg()); + assert_eq!(args, ["--host=db.example.test", "--port=6543", "--username=app", "--dbname=shop", "--no-password"]); + assert!(env.contains(&("PGSSLMODE".into(), "prefer".into()))); + assert!(!env.iter().any(|(k, _)| k == "PGPASSWORD" || k == "PGOPTIONS")); + } + + #[test] + fn default_port_and_optional_fields() { + let source = DataSource { port: None, user: String::new(), database: String::new(), ..pg() }; + let (args, _) = connection(DbTool::Psql, &source); + assert_eq!(args, ["--host=db.example.test", "--port=5432", "--no-password"]); + } + + #[test] + fn read_only_sources_refuse_writes() { + let source = DataSource { read_only: true, ssl: DbSslMode::VerifyFull, ..pg() }; + let (_, env) = connection(DbTool::PgRestore, &source); + assert!(env.contains(&("PGOPTIONS".into(), "-c default_transaction_read_only=on".into()))); + assert!(env.contains(&("PGSSLMODE".into(), "verify-full".into()))); + } + + #[test] + fn only_the_tool_itself_is_accepted() { + for ok in ["/usr/bin/pg_dump", "/pg/bin/pg_dump.exe", "/usr/bin/pg_dump-17", "/opt/pg_dump17"] { + assert!(DbTool::PgDump.is_program(Path::new(ok)), "{ok}"); + } + for bad in ["/usr/bin/pg_dumpall", "/bin/sh", "/usr/bin/pg_restore", "/tmp/evil"] { + assert!(!DbTool::PgDump.is_program(Path::new(bad)), "{bad}"); + } + } + + #[test] + fn tells_dumps_apart_by_their_header() { + assert_eq!(kind_of(b"PGDMP\x01\x0f"), DbDumpKind::PostgresArchive); + assert_eq!(kind_of(b"toc.dat\0\0\0"), DbDumpKind::PostgresArchive); + assert_eq!(kind_of(b"--\n-- PostgreSQL database dump\n--\n"), DbDumpKind::PostgresSql); + assert_eq!(kind_of(b"-- MySQL dump 10.13 Distrib 8.4.6\n--\n"), DbDumpKind::MysqlSql); + assert_eq!(kind_of(b"-- MariaDB dump 10.19 Distrib 11.4.2\n"), DbDumpKind::MysqlSql); + assert_eq!(kind_of(b"CREATE TABLE t (id int);\n"), DbDumpKind::Unknown); + } + + #[test] + fn newer_versions_sort_first() { + assert!(version_key("pg_dump (PostgreSQL) 17.2") > version_key("pg_dump (PostgreSQL) 9.6.24")); + } + + #[cfg(unix)] + #[tokio::test] + async fn streams_both_pipes_and_reports_the_exit_code() { + let mut lines = Vec::new(); + let code = run( + Path::new("/bin/sh"), + &["-c".into(), "echo out; echo err >&2; exit 3".into()], + &[], + &CancellationToken::new(), + |batch| lines.extend(batch), + ) + .await + .unwrap(); + assert_eq!(code, Some(3)); + assert!(lines.contains(&ToolLine { stderr: false, text: "out".into() })); + assert!(lines.contains(&ToolLine { stderr: true, text: "err".into() })); + } + + #[cfg(unix)] + #[tokio::test] + async fn cancelling_stops_the_process() { + let cancel = CancellationToken::new(); + let stop = cancel.clone(); + tokio::spawn(async move { + tokio::time::sleep(Duration::from_millis(100)).await; + stop.cancel(); + }); + let result = run(Path::new("/bin/sh"), &["-c".into(), "sleep 30".into()], &[], &cancel, |_| {}).await; + assert!(result.is_err()); + } + + /// A stand-in for `tool` that prints each argument on a line, then whether `PGPASSWORD` + /// holds the expected password. + #[cfg(unix)] + fn echo_tool(dir: &Path, tool: DbTool) -> PathBuf { + use std::os::unix::fs::PermissionsExt; + let path = dir.join(tool.program()); + std::fs::write( + &path, + "#!/bin/sh\nfor a in \"$@\"; do echo \"arg:$a\"; done\necho \"env:${PGPASSWORD:+set}\"\n", + ) + .unwrap(); + std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o755)).unwrap(); + path + } + + #[cfg(unix)] + #[tokio::test] + async fn the_password_never_reaches_the_arguments() { + const SECRET: &str = "s3cret-pass-do-not-leak"; + let dir = std::env::temp_dir().join(format!("openidea-tools-{}", uuid::Uuid::new_v4())); + std::fs::create_dir_all(&dir).unwrap(); + let file = dir.join("out.sql").to_string_lossy().into_owned(); + let jobs = [ + DbToolJob::PgDump { + file: file.clone(), + options: DbPgDumpOptions { + format: DbDumpFormat::Plain, + statements: DbDumpStatements::Copy, + content: DbDumpContent::All, + schemas: vec!["public".into()], + tables: vec![], + exclude_tables: vec![], + clean: true, + if_exists: true, + create: false, + no_owner: false, + no_privileges: false, + jobs: 1, + }, + }, + DbToolJob::Psql { + file: file.clone(), + options: DbPsqlOptions { single_transaction: true, stop_on_error: true }, + }, + ]; + for job in jobs { + let program = echo_tool(&dir, job.tool()); + let prepared = prepare(&job, &pg(), Some(SECRET)); + assert!(!prepared.args.iter().any(|a| a.contains(SECRET)), "{:?}", prepared.args); + let mut lines = Vec::new(); + run(&program, &prepared.args, &prepared.env, &CancellationToken::new(), |b| lines.extend(b)).await.unwrap(); + let text: Vec<&str> = lines.iter().map(|l| l.text.as_str()).collect(); + assert!(text.contains(&"arg:--dbname=shop"), "{text:?}"); + assert!(!text.iter().any(|l| l.contains(SECRET)), "{text:?}"); + assert!(text.contains(&"env:set"), "the tool gets the password from PGPASSWORD: {text:?}"); + } + std::fs::remove_dir_all(&dir).unwrap(); + } +} diff --git a/crates/ide-db/tests/postgres.rs b/crates/ide-db/tests/postgres.rs index b3a03d627..10d915e85 100644 --- a/crates/ide-db/tests/postgres.rs +++ b/crates/ide-db/tests/postgres.rs @@ -228,3 +228,78 @@ async fn opening_a_table_reads_multi_column_keys_in_order() -> IdeResult<()> { db.execute("p", "DROP SCHEMA oi_keys CASCADE", 10, &c).await?; Ok(()) } + +/// Runs `job` with the newest installed copy of its tool, the way the dialogs do. +async fn run_tool(db: &DbManager, target: &str, job: ide_db::tools::DbToolJob) -> IdeResult<()> { + let install = ide_db::tools::find_installs(job.tool()).into_iter().next().expect("installed"); + let mut lines = Vec::new(); + let code = db.run_tool(target, install.path.as_ref(), &job, &CancellationToken::new(), |b| lines.extend(b)).await?; + assert_eq!(code, Some(0), "{} failed: {lines:?}", job.tool().program()); + Ok(()) +} + +#[tokio::test] +async fn dumps_and_restores_with_the_client_tools() -> IdeResult<()> { + use ide_db::tools::{ + DbDumpContent, DbDumpFormat, DbDumpStatements, DbPgDumpOptions, DbPgRestoreOptions, DbPsqlOptions, DbTool, + DbToolJob, find_installs, + }; + let tmp = tempfile::tempdir().unwrap(); + let Some(db) = manager(&tmp).await else { return Ok(()) }; + let server = db.server_version("p").await? / 10000; + let major = |t: DbTool| { + find_installs(t).first().and_then(|i| i.version.split(' ').nth(2)?.split('.').next()?.parse::().ok()) + }; + // Other major versions write or refuse what this server needs; the dialogs warn about that instead. + if [DbTool::PgDump, DbTool::PgRestore, DbTool::Psql].into_iter().any(|t| major(t) != Some(server)) { + return Ok(()); + } + create_schemas(&db).await; + let c = CancellationToken::new(); + db.execute("p", "DROP DATABASE IF EXISTS oi_restore", 1, &c).await?; + db.execute("p", "CREATE DATABASE oi_restore", 1, &c).await?; + let file = |name: &str| tmp.path().join(name).to_string_lossy().into_owned(); + + let dump = |format, file: String, schema: &str| DbToolJob::PgDump { + file, + options: DbPgDumpOptions { + format, + statements: DbDumpStatements::Copy, + content: DbDumpContent::All, + schemas: vec![schema.into()], + tables: vec![], + exclude_tables: vec![], + clean: false, + if_exists: false, + create: false, + no_owner: false, + no_privileges: false, + jobs: 1, + }, + }; + let archive = file("a.dump"); + run_tool(&db, "p", dump(DbDumpFormat::Custom, archive.clone(), "oi_a")).await?; + let restore = DbPgRestoreOptions { + content: DbDumpContent::All, + schemas: vec![], + clean: false, + if_exists: false, + no_owner: false, + no_privileges: false, + single_transaction: false, + exit_on_error: true, + jobs: 1, + }; + run_tool(&db, "p:oi_restore", DbToolJob::PgRestore { file: archive, options: restore }).await?; + + let script = file("b.sql"); + run_tool(&db, "p", dump(DbDumpFormat::Plain, script.clone(), "oi_b")).await?; + let psql = DbPsqlOptions { single_transaction: true, stop_on_error: true }; + run_tool(&db, "p:oi_restore", DbToolJob::Psql { file: script, options: psql }).await?; + + let r = db.execute("p:oi_restore", "SELECT a.tag || ', ' || b.tag FROM oi_a.items a, oi_b.items b", 1, &c).await?; + assert_eq!(r.rows[0][0].as_deref(), Some("from a, from b")); + db.disconnect("p:oi_restore").await; + db.execute("p", "DROP DATABASE oi_restore", 1, &c).await?; + Ok(()) +} diff --git a/crates/ide-host/src/ops/db.rs b/crates/ide-host/src/ops/db.rs index f09388430..7e3e5ad94 100644 --- a/crates/ide-host/src/ops/db.rs +++ b/crates/ide-host/src/ops/db.rs @@ -532,3 +532,35 @@ fn console_dir(host: &Host, id: &str) -> IdeResult { std::fs::create_dir_all(&dir)?; Ok(dir) } + +/// Runs a client tool against target `id` until it exits or the request is cancelled. +/// Desktop only: the file paths come from local dialogs. +pub async fn run_tool( + host: &Host, + window: &str, + request: RequestId, + id: &str, + executable: &std::path::Path, + job: &ide_db::tools::DbToolJob, + on_output: impl FnMut(Vec), +) -> IdeResult> { + let db = host.project(window)?.db.clone(); + let cancel = host.begin_request(request); + let result = db.run_tool(id, executable, job, &cancel, on_output).await; + host.end_request(request); + result +} + +pub fn tool_preview( + host: &Host, + window: &str, + id: &str, + executable: &std::path::Path, + job: &ide_db::tools::DbToolJob, +) -> IdeResult { + host.project(window)?.db.tool_preview(id, executable, job) +} + +pub async fn server_version(host: &Host, window: &str, id: &str) -> IdeResult { + host.project(window)?.db.server_version(id).await +} diff --git a/src-tauri/src/commands/db.rs b/src-tauri/src/commands/db.rs index b499b7358..3ee3b7231 100644 --- a/src-tauri/src/commands/db.rs +++ b/src-tauri/src/commands/db.rs @@ -3,9 +3,11 @@ use crate::state::AppState; use ide_core::{IdeResult, IpcPath, RequestId}; use ide_db::split::SqlStatement; +use ide_db::tools::{DbDumpKind, DbTool, DbToolJob, ToolInstall, ToolLine}; use ide_db::{DataSource, DbObjectKind, DbRowEdit, SortKey}; #[allow(unused_imports)] pub use ide_host::ops::db::*; +use tauri::ipc::Channel; use tauri::{State, Window}; #[tauri::command] @@ -369,3 +371,63 @@ pub fn db_console_path(state: State<'_, AppState>, id: String) -> IdeResult, id: String, create: bool) -> IdeResult> { ide_host::ops::db::consoles(&state.host, &id, create) } + +/// Installed copies of `tool`, newest first. +#[tauri::command] +#[specta::specta] +pub async fn db_tool_installs(tool: DbTool) -> IdeResult> { + super::doc::blocking(move || Ok(ide_db::tools::find_installs(tool))).await +} + +/// The version line of the executable at `path`. +#[tauri::command] +#[specta::specta] +pub async fn db_tool_version(path: std::path::PathBuf) -> IdeResult { + super::doc::blocking(move || ide_db::tools::version_of(&path)).await +} + +/// What made the dump at `path` (from its first bytes), so a restore picks the right tool. +#[tauri::command] +#[specta::specta] +pub async fn db_dump_kind(path: std::path::PathBuf) -> IdeResult { + super::doc::blocking(move || ide_db::tools::dump_kind(&path)).await +} + +/// The command line `db_run_tool` would run, without the password. +#[tauri::command] +#[specta::specta] +pub fn db_tool_preview( + window: Window, + state: State<'_, AppState>, + id: String, + executable: std::path::PathBuf, + job: DbToolJob, +) -> IdeResult { + ide_host::ops::db::tool_preview(&state.host, window.label(), &id, &executable, &job) +} + +/// Runs `job` against target `id` and streams the tool's output; returns its exit code. Stays +/// in the desktop shell like [`db_export_file`]: the paths in `job` are local. +#[tauri::command] +#[specta::specta] +pub async fn db_run_tool( + window: Window, + state: State<'_, AppState>, + request: RequestId, + id: String, + executable: std::path::PathBuf, + job: DbToolJob, + on_output: Channel>, +) -> IdeResult> { + ide_host::ops::db::run_tool(&state.host, window.label(), request, &id, &executable, &job, |lines| { + let _ = on_output.send(lines); + }) + .await +} + +/// `server_version_num` of the PostgreSQL server of target `id` (connects first). +#[tauri::command] +#[specta::specta] +pub async fn db_server_version(window: Window, state: State<'_, AppState>, id: String) -> IdeResult { + ide_host::ops::db::server_version(&state.host, window.label(), &id).await +} diff --git a/src-tauri/src/commands/mod.rs b/src-tauri/src/commands/mod.rs index 6a176ec4a..95847294c 100644 --- a/src-tauri/src/commands/mod.rs +++ b/src-tauri/src/commands/mod.rs @@ -787,5 +787,11 @@ pub fn builder() -> tauri_specta::Builder { db::db_apply_edits, db::db_console_path, db::db_consoles, + db::db_tool_installs, + db::db_tool_version, + db::db_tool_preview, + db::db_dump_kind, + db::db_run_tool, + db::db_server_version, ]) } diff --git a/src-tauri/tests/commands.snap b/src-tauri/tests/commands.snap index d85725942..ab3ddcb71 100644 --- a/src-tauri/tests/commands.snap +++ b/src-tauri/tests/commands.snap @@ -96,6 +96,7 @@ db_database_catalog trusted project_host bin db_databases trusted project_host bindings async db_ddl trusted project_host bindings async db_disconnect trusted project_host bindings async +db_dump_kind trusted desktop bindings async db_execute trusted project_host bindings async db_explain trusted project_host bindings async db_export_file always desktop bindings async @@ -104,10 +105,12 @@ db_history trusted project_host bin db_object_ddl trusted project_host bindings async db_remove_history trusted project_host bindings async db_retain_catalog trusted project_host bindings async +db_run_tool trusted desktop bindings async db_save_sources trusted project_host bindings async db_saved_catalog trusted project_host bindings async db_schema_objects trusted project_host bindings async db_schemas trusted project_host bindings async +db_server_version trusted desktop bindings async db_session_context trusted project_host bindings async db_set_manual_commit trusted project_host bindings async db_set_password trusted project_host bindings async @@ -119,6 +122,9 @@ db_table_page trusted project_host bin db_tables trusted project_host bindings async db_test trusted project_host bindings async db_test_tunnel trusted project_host bindings async +db_tool_installs trusted desktop bindings async +db_tool_preview trusted desktop bindings sync +db_tool_version trusted desktop bindings async db_trust_ssh_host trusted project_host bindings async debug_attachable_processes always project_host bindings async debug_breakpoint_states trusted project_host bindings sync diff --git a/src/bindings.ts b/src/bindings.ts index f941f834c..390adf2b1 100644 --- a/src/bindings.ts +++ b/src/bindings.ts @@ -1903,6 +1903,21 @@ export const commands = { dbConsolePath: (id: string) => typedError(__TAURI_INVOKE("db_console_path", { id })), /** The query consoles of data source `id`; `create` adds the next one first. */ dbConsoles: (id: string, create: boolean) => typedError(__TAURI_INVOKE("db_consoles", { id, create })), + /** Installed copies of `tool`, newest first. */ + dbToolInstalls: (tool: DbTool) => typedError(__TAURI_INVOKE("db_tool_installs", { tool })), + /** The version line of the executable at `path`. */ + dbToolVersion: (path: string) => typedError(__TAURI_INVOKE("db_tool_version", { path })), + /** The command line `db_run_tool` would run, without the password. */ + dbToolPreview: (id: string, executable: string, job: DbToolJob) => typedError(__TAURI_INVOKE("db_tool_preview", { id, executable, job })), + /** What made the dump at `path` (from its first bytes), so a restore picks the right tool. */ + dbDumpKind: (path: string) => typedError(__TAURI_INVOKE("db_dump_kind", { path })), + /** + * Runs `job` against target `id` and streams the tool's output; returns its exit code. Stays + * in the desktop shell like [`db_export_file`]: the paths in `job` are local. + */ + dbRunTool: (request: RequestId, id: string, executable: string, job: DbToolJob, onOutput: Channel) => typedError(__TAURI_INVOKE("db_run_tool", { request, id, executable, job, onOutput })), + /** `server_version_num` of the PostgreSQL server of target `id` (connects first). */ + dbServerVersion: (id: string) => typedError(__TAURI_INVOKE("db_server_version", { id })), }; /* Types */ @@ -4120,6 +4135,25 @@ export type DbDriver = "sqlite" | "postgres" | /** Oracle Database (pure-Rust thin driver, no client library). */ "oracle" | "snowflake"; +export type DbDumpContent = "all" | "schemaOnly" | "dataOnly"; + +export type DbDumpFormat = +/** SQL text, restored with `psql`. */ +"plain" | "custom" | +/** A directory of files; the only format `pg_dump` writes in parallel. */ +"directory" | "tar"; + +/** What made a dump, read from its first bytes (a directory: its `toc.dat`). */ +export type DbDumpKind = +/** `pg_dump` custom or tar archive, or a directory archive: `pg_restore`. */ +"postgresArchive" | +/** Plain SQL from `pg_dump`: `psql`. */ +"postgresSql" | +/** `mysqldump` / `mariadb-dump`: not for the PostgreSQL tools. */ +"mysqlSql" | "unknown"; + +export type DbDumpStatements = "copy" | "inserts" | "columnInserts"; + /** `schema.table (columns) REFERENCES ref_schema.ref_table (ref_columns)`. */ export type DbForeignKey = { schema: string, @@ -4184,6 +4218,37 @@ export type DbPackageInfo = { name: string, }; +/** Name lists hold `pg_dump` patterns (`*`, `?`, quoted names). */ +export type DbPgDumpOptions = { + format: DbDumpFormat, + statements: DbDumpStatements, + content: DbDumpContent, + schemas: string[], + tables: string[], + excludeTables: string[], + /** Plain format only: archives get DROP / CREATE at restore. */ + clean: boolean, + ifExists: boolean, + create: boolean, + noOwner: boolean, + noPrivileges: boolean, + /** Directory format only. */ + jobs: number, +}; + +export type DbPgRestoreOptions = { + content: DbDumpContent, + schemas: string[], + clean: boolean, + ifExists: boolean, + noOwner: boolean, + noPrivileges: boolean, + singleTransaction: boolean, + exitOnError: boolean, + /** Ignored with a single transaction, which `pg_restore` cannot split. */ + jobs: number, +}; + /** One operation of a plan; `parent` indexes the plan's node list (roots: `None`). */ export type DbPlanNode = { parent: number | null, @@ -4209,6 +4274,11 @@ export type DbProperty = { value?: string, }; +export type DbPsqlOptions = { + singleTransaction: boolean, + stopOnError: boolean, +}; + export type DbQueryResult = { statement: string, columns: DbResultColumn[], @@ -4365,6 +4435,26 @@ export type DbTablePage = { offset: number | null, }; +export type DbTool = "pgDump" | "pgRestore" | "psql"; + +/** An installed copy of a tool. */ +export type DbToolInstall = { + path: string, + /** First line of `--version`, e.g. `pg_dump (PostgreSQL) 17.2`. */ + version: string, +}; + +/** A run of a client tool: which one, the file it writes or reads, and its options. */ +export type DbToolJob = { tool: "pgDump"; file: string; options: DbPgDumpOptions } | +/** `file`: an archive, or a directory archive. */ +{ tool: "pgRestore"; file: string; options: DbPgRestoreOptions } | { tool: "psql"; file: string; options: DbPsqlOptions }; + +/** A line the tool wrote. */ +export type DbToolLine = { + stderr: boolean, + text: string, +}; + export type DbTriggerInfo = { name: string, /** `before`, `after`, `instead of`. */ diff --git a/src/features/database/Database.module.css b/src/features/database/Database.module.css index 94b4c837d..79a96b4a1 100644 --- a/src/features/database/Database.module.css +++ b/src/features/database/Database.module.css @@ -1416,3 +1416,62 @@ height: 5px; cursor: row-resize; } + +/* Export with pg_dump / Restore with pg_restore or psql. */ +.dumpChecks { + display: grid; + grid-template-columns: repeat(2, minmax(0, 1fr)); + gap: var(--space-1-5) var(--space-4); +} +.dumpPreview { + grid-column: 1 / -1; + max-height: 96px; + overflow: auto; + padding: 6px 8px; + border: 1px solid var(--border); + border-radius: var(--radius-control); + background: var(--bg-editor); + font-family: var(--openidea-editor-font, var(--font-mono)); + font-size: var(--fs-code); + white-space: pre-wrap; + overflow-wrap: anywhere; +} +.dumpRun { + display: flex; + flex-direction: column; + gap: var(--space-2); + padding: 14px; +} +.dumpLog { + height: 320px; + overflow: auto; + padding: 6px 8px; + border: 1px solid var(--border); + border-radius: var(--radius-control); + background: var(--bg-editor); + font-family: var(--openidea-editor-font, var(--font-mono)); + font-size: var(--fs-code); + line-height: 1.5; + white-space: pre-wrap; + overflow-wrap: anywhere; +} +.dumpPath { + flex: 1; + min-width: 0; +} +.dumpStatus { + flex: 1; + display: flex; + flex-direction: column; + gap: var(--space-0-5); + min-width: 0; +} +.dumpRoute { + color: var(--fg-muted); + overflow: hidden; + text-overflow: ellipsis; + white-space: nowrap; +} +.dumpError { + color: var(--danger); +} diff --git a/src/features/database/Dialogs.tsx b/src/features/database/Dialogs.tsx index a591d42c5..ecef85b04 100644 --- a/src/features/database/Dialogs.tsx +++ b/src/features/database/Dialogs.tsx @@ -14,6 +14,8 @@ const ExportDialog = lazyComponent(() => import("./ExportDialog").then((m) => m. const HistoryDialog = lazyComponent(() => import("./DataDialogs").then((m) => m.HistoryDialog)); const ImportDialog = lazyComponent(() => import("./DataDialogs").then((m) => m.ImportDialog)); const SchemaCompareDialog = lazyComponent(() => import("./SchemaCompareDialog").then((m) => m.SchemaCompareDialog)); +const DumpDialog = lazyComponent(() => import("./DumpDialogs").then((m) => m.DumpDialog)); +const RestoreDialog = lazyComponent(() => import("./DumpDialogs").then((m) => m.RestoreDialog)); function PasswordDialog({ source, resolve }: { source: DataSource; resolve: (ok: boolean) => void }) { const [password, setPassword] = useState(""); @@ -192,6 +194,26 @@ export function DatabaseDialogs() { return ( ); + if (dialog.kind === "dump") + return ( + + ); + if (dialog.kind === "restore") + return ( + + ); if (dialog.kind === "sshSecret") return ( diff --git a/src/features/database/DumpDialogs.tsx b/src/features/database/DumpDialogs.tsx new file mode 100644 index 000000000..2890ea1c6 --- /dev/null +++ b/src/features/database/DumpDialogs.tsx @@ -0,0 +1,783 @@ +/** DataGrip's Export with 'pg_dump' and Restore with 'pg_restore' / 'psql' dialogs. */ +import { Fragment, useEffect, useLayoutEffect, useRef, useState } from "react"; +import clsx from "clsx"; +import { + call, + commands, + type DbDumpContent, + type DbDumpFormat, + type DbDumpKind, + type DbDumpStatements, + type DbPsqlOptions, + type DbTool, + type DbToolInstall, + type DbToolJob, +} from "@/platform/ipc"; +import { tx } from "@/platform/i18n"; +import { + Checkbox, + Dialog, + IconButton, + Input, + Select, + T, + Tabs, + copyText, + selectableText, + showContextMenu, + type DialogButton, +} from "@/ui"; +import { + DEFAULT_DUMP, + DEFAULT_PSQL, + DEFAULT_RESTORE, + DUMP_FORMATS, + dumpMismatch, + dumpOptions, + formatElapsed, + majorOf, + outputPath, + pickInstall, + restoreOptions, + restoreToolFor, + versionFit, + withExtension, + type DumpForm, + type DumpMismatch, + type RestoreForm, +} from "./dumpTools"; +import { splitTarget } from "./model"; +import { closeDialog, refresh, sourceById } from "./store"; +import { TOOL_PROGRAMS, startToolRun, stopToolRun, useToolRuns } from "./toolRuns"; +import { copySelectionOnKeyDown } from "@/ui/selectableText"; +import styles from "./Database.module.css"; + +const PROGRAM = TOOL_PROGRAMS; +export const pathKey = (tool: DbTool) => `openidea.db.toolPath.${tool}`; + +const CONTENT_OPTIONS: { value: DbDumpContent; label: string }[] = [ + { value: "all", label: "Schema and data" }, + { value: "schemaOnly", label: "Schema only" }, + { value: "dataOnly", label: "Data only" }, +]; + +/** The connection target of `database` on the data source of `target`. */ +function targetOf(target: string, database: string): string { + const { id } = splitTarget(target); + return database.trim() ? `${id}:${database.trim()}` : id; +} + +/** `150013` → 15. */ +const majorOfServer = (num: number | null) => (num ? Math.floor(num / 10000) : null); + +export function joinPath(dir: string, name: string): string { + return `${dir.replace(/[\\/]+$/, "")}/${name}`; +} + +/** What the hint under the executable says about its version next to the server's. */ +function versionHint(tool: DbTool, version: string, serverMajor: number | null): { text: string; warn: boolean } { + const toolMajor = majorOf(version); + const fit = versionFit(tool, toolMajor, serverMajor); + const server = String(serverMajor); + if (fit === "tooOld") + return { + text: tx`${version}: older than the server (PostgreSQL ${server}), which pg_dump refuses. Choose version ${server} or newer.`, + warn: true, + }; + if (fit === "newer") + return { + text: tx`${version}: newer than the server (PostgreSQL ${server}). What it writes may not load into PostgreSQL ${server}. Install the PostgreSQL ${server} client tools to restore into this server.`, + warn: true, + }; + return { text: version, warn: false }; +} + +/** The executable of `tool`: preselected by the server's version, shows its own and what is wrong. */ +export function ExecutableField({ + tool, + value, + onChange, + serverMajor, +}: { + tool: DbTool; + value: string; + onChange: (v: string) => void; + serverMajor: number | null; +}) { + const [installs, setInstalls] = useState(null); + const [check, setCheck] = useState<{ path: string; version?: string; error?: string } | null>(null); + const program = PROGRAM[tool]; + + useEffect(() => { + let live = true; + void call(commands.dbToolInstalls(tool)) + .catch(() => []) + .then((found) => { + if (!live) return; + setInstalls(found); + if (!value) onChange(pickInstall(found, serverMajor, localStorage.getItem(pathKey(tool)))); + }); + return () => { + live = false; + }; + // Only when the tool changes: `value` seeds the field once. + // eslint-disable-next-line react-hooks/exhaustive-deps + }, [tool]); + + useEffect(() => { + const path = value.trim(); + if (!path) return; + let live = true; + const timer = setTimeout(() => { + call(commands.dbToolVersion(path)) + .then((version) => live && setCheck({ path, version })) + .catch((e) => live && setCheck({ path, error: e instanceof Error ? e.message : String(e) })); + }, 250); + return () => { + live = false; + clearTimeout(timer); + }; + }, [value]); + + const browse = async () => { + try { + const { open } = await import("@/platform/dialog"); + const file = await open({ multiple: false, directory: false, title: tx`Path to ${program}` }); + if (typeof file === "string") onChange(file); + } catch { + // No dialog (tests): keep typing the path. + } + }; + + const found = installs ?? []; + const options = found.map((i) => ({ value: i.path, label: i.path, detail: i.version, verbatim: true })); + if (value && !found.some((i) => i.path === value)) options.push({ value, label: value, detail: "", verbatim: true }); + const current = check?.path === value.trim() ? check : null; + const hint = current?.version ? versionHint(tool, current.version, serverMajor) : null; + return ( + <> + + Path to executable: + +
+ {found.length > 0 ? ( + onChange(e.target.value)} + /> + )} + void browse()} /> +
+ + + {installs && !value.trim() + ? tx`${program} was not found. Install the PostgreSQL client tools or choose the executable.` + : (hint?.text ?? current?.error ?? "\u00a0")} + + + ); +} + +/** What made the dump at `path`, read from its header (`null` while unknown). */ +export function useDumpKind(path: string): DbDumpKind | null { + const [known, setKnown] = useState<{ path: string; kind: DbDumpKind } | null>(null); + useEffect(() => { + const p = path.trim(); + if (!p) return; + let live = true; + const timer = setTimeout(() => { + call(commands.dbDumpKind(p)) + .then((kind) => live && setKnown({ path: p, kind })) + .catch(() => live && setKnown({ path: p, kind: "unknown" })); + }, 250); + return () => { + live = false; + clearTimeout(timer); + }; + }, [path]); + return known?.path === path.trim() ? known.kind : null; +} + +/** Why the chosen tool cannot restore the chosen dump, as a hint under the path. */ +export function mismatchText(m: DumpMismatch): string { + switch (m) { + case "mysqlIntoPostgres": + return tx("This is a MySQL dump: restore it into a MySQL data source."); + case "archiveIntoPsql": + return tx("This is a pg_dump archive: restore it with pg_restore."); + case "sqlIntoPgRestore": + return tx("This is a plain SQL dump: restore it with psql."); + } +} + +/** The command line the backend would run for `job` on target `id` (empty while unknown). */ +function useToolPreview(id: string, executable: string, job: DbToolJob): string { + const key = JSON.stringify([id, executable, job]); + const [shown, setShown] = useState<{ key: string; line: string } | null>(null); + useEffect(() => { + let live = true; + const timer = setTimeout(() => { + call(commands.dbToolPreview(id, executable, job)) + .then((line) => live && setShown({ key, line })) + .catch(() => live && setShown({ key, line: "" })); + }, 150); + return () => { + live = false; + clearTimeout(timer); + }; + // `key` stands for the three inputs. + // eslint-disable-next-line react-hooks/exhaustive-deps + }, [key]); + return shown?.key === key ? shown.line : ""; +} + +function Preview({ text }: { text: string }) { + return ( +
void copySelectionOnKeyDown(e)}> + {text || "\u00a0"} +
+ ); +} + +/** The current time, ticking each second while `live`. */ +function useNow(live: boolean): number { + const [now, setNow] = useState(() => Date.now()); + useEffect(() => { + if (!live) return; + const timer = setInterval(() => setNow(Date.now()), 1000); + return () => clearInterval(timer); + }, [live]); + return now; +} + +/** Live output of a run, followed while scrolled to the bottom. */ +export function RunOutput({ runKey }: { runKey: number }) { + const run = useToolRuns((s) => s.runs[runKey]); + const now = useNow(run?.status === "running"); + const scroller = useRef(null); + const stick = useRef(true); + useLayoutEffect(() => { + const el = scroller.current; + if (el && stick.current) el.scrollTop = el.scrollHeight; + }, [run?.lines]); + if (!run) return null; + const took = formatElapsed((run.endedAt ?? now) - run.startedAt); + const status = + run.status === "running" + ? tx`Running ${PROGRAM[run.tool]}… ${took}` + : run.status === "done" + ? tx`Finished in ${took}` + : run.status === "cancelled" + ? tx`Stopped after ${took}` + : (run.error ?? tx`Failed with exit code ${String(run.exit ?? "?")} after ${took}`); + return ( +
+
+ + {status} + {run.route} + + void copyText(run.lines.map((l) => l.text).join("\n"))} + /> +
+
void copySelectionOnKeyDown(e)} + role="log" + aria-label={tx`${PROGRAM[run.tool]} output`} + onScroll={(e) => { + const el = e.currentTarget; + stick.current = el.scrollHeight - el.scrollTop - el.clientHeight < 8; + }} + > + {run.lines.map((l, i) => ( +
+ {l.text || " "} +
+ ))} +
+
+ ); +} + +/** Footer buttons while a run is shown: Stop while it runs, then Back to change the options. */ +export function runButtons(runKey: number, running: boolean, back: () => void): DialogButton[] { + return running + ? [ + { label: "Close", role: "cancel" }, + { label: "Stop", role: "default", onClick: () => stopToolRun(runKey) }, + ] + : [ + { label: "Back", role: "extra", onClick: back }, + { label: "Close", role: "default", onClick: closeDialog }, + ]; +} + +export function useHome(): string | null { + const [home, setHome] = useState(null); + useEffect(() => { + void import("@tauri-apps/api/path") + .then((p) => p.homeDir()) + .then(setHome) + .catch(() => {}); + }, []); + return home; +} + +export function DumpDialog({ + target, + database: initialDatabase, + schemas, + tables, + serverVersion, +}: { + target: string; + database: string; + schemas?: string; + tables?: string; + serverVersion: number | null; +}) { + const source = sourceById(target); + const home = useHome(); + const [executable, setExecutable] = useState(""); + const [database, setDatabase] = useState(initialDatabase); + const [options, setOptions] = useState({ + ...DEFAULT_DUMP, + schemas: schemas ?? "", + tables: tables ?? "", + }); + const [edited, setOutput] = useState(null); + const output = edited ?? (home ? joinPath(home, "{data_source}-{database}-{timestamp}.sql") : ""); + const [runKey, setRunKey] = useState(null); + const running = useToolRuns((s) => (runKey !== null ? s.runs[runKey]?.status === "running" : false)); + + const set = + (k: K) => + (v: DumpForm[K]) => + setOptions((o) => ({ ...o, [k]: v })); + const plain = options.format === "plain"; + const runTarget = targetOf(target, database); + const jobFor = (file: string): DbToolJob => ({ tool: "pgDump", file, options: dumpOptions(options) }); + const preview = useToolPreview(runTarget, executable || "pg_dump", jobFor(output)); + + const browse = async () => { + try { + const { save } = await import("@/platform/dialog"); + const path = await save({ defaultPath: output }); + if (path) setOutput(path); + } catch { + // No dialog (tests): keep typing the path. + } + }; + + const run = async () => { + const file = outputPath(output, { dataSource: source?.name ?? "", database, now: new Date() }); + const job = jobFor(file); + localStorage.setItem(pathKey("pgDump"), executable); + const commandLine = await call(commands.dbToolPreview(runTarget, executable, job)).catch(() => ""); + setRunKey( + startToolRun({ + target: runTarget, + executable, + job, + commandLine, + output: file, + from: database || (source?.name ?? target), + to: file, + }), + ); + }; + + const buttons: DialogButton[] = + runKey !== null + ? runButtons(runKey, running, () => setRunKey(null)) + : [ + { label: "Cancel", role: "cancel" }, + { label: "Run", role: "default", disabled: !executable.trim() || !output.trim(), onClick: () => void run() }, + ]; + + return ( + + {runKey !== null ? ( + + ) : ( +
+ + + Database: + + setDatabase(e.target.value)} /> + + Output result to: + +
+ setOutput(e.target.value)} + /> + void browse()} /> +
+ + + Allowed substitution patterns: {"{timestamp}, {data_source}, {database}"} + + + Format: + + set("statements")(v)} + /> + + Content: + + set(k)(e.target.value)} + /> + + ))} + {options.format === "directory" && ( + <> + + Parallel jobs: + + set("jobs")(Math.max(1, Number(e.target.value) || 1))} + /> + + )} + +
+ + + + + +
+ +
+ )} +
+ ); +} + +export function RestoreDialog({ + target, + database: initialDatabase, + serverVersion, +}: { + target: string; + database: string; + serverVersion: number | null; +}) { + const source = sourceById(target); + const [picked, setPicked] = useState<"pgRestore" | "psql" | null>(null); + const [executables, setExecutables] = useState>({ pgRestore: "", psql: "" }); + const [database, setDatabase] = useState(initialDatabase); + const [file, setFile] = useState(""); + const [restore, setRestore] = useState(DEFAULT_RESTORE); + const [psql, setPsql] = useState(DEFAULT_PSQL); + const [runKey, setRunKey] = useState(null); + const running = useToolRuns((s) => (runKey !== null ? s.runs[runKey]?.status === "running" : false)); + const kind = useDumpKind(file); + const tool = picked ?? restoreToolFor(file, kind); + const mismatch = dumpMismatch(tool, kind); + const executable = executables[tool]; + const readOnly = !!source?.readOnly; + + const changeFile = setFile; + const browse = async (directory: boolean) => { + try { + const { open } = await import("@/platform/dialog"); + const path = await open({ multiple: false, directory, title: tx("Path to dump") }); + if (typeof path === "string") changeFile(path); + } catch { + // No dialog (tests): keep typing the path. + } + }; + + const runTarget = targetOf(target, database); + const job: DbToolJob = + tool === "psql" ? { tool, file, options: psql } : { tool, file, options: restoreOptions(restore) }; + const preview = useToolPreview(runTarget, executable || PROGRAM[tool], job); + const setR = + (k: K) => + (v: RestoreForm[K]) => + setRestore((o) => ({ ...o, [k]: v })); + const setP = + (k: K) => + (v: DbPsqlOptions[K]) => + setPsql((o) => ({ ...o, [k]: v })); + + const run = async () => { + localStorage.setItem(pathKey(tool), executable); + const commandLine = await call(commands.dbToolPreview(runTarget, executable, job)).catch(() => preview); + setRunKey( + startToolRun({ + target: runTarget, + executable, + job, + commandLine, + from: file, + to: database || (source?.name ?? target), + onSuccess: () => void refresh(runTarget), + }), + ); + }; + + const buttons: DialogButton[] = + runKey !== null + ? runButtons(runKey, running, () => setRunKey(null)) + : [ + { label: "Cancel", role: "cancel" }, + { + label: "Run", + role: "default", + disabled: readOnly || !!mismatch || !executable.trim() || !file.trim(), + title: readOnly ? tx`The data source is read-only` : undefined, + onClick: () => void run(), + }, + ]; + + return ( + + {runKey !== null ? ( + + ) : ( + <> + setPicked(id as "pgRestore" | "psql")} + /> +
+ setExecutables((e) => ({ ...e, [tool]: v }))} + serverMajor={majorOfServer(serverVersion)} + /> + + Database: + + setDatabase(e.target.value)} /> + + Path to dump: + +
+ changeFile(e.target.value)} + /> + + tool === "pgRestore" + ? showContextMenu(e, [ + { label: "Choose File…", run: () => void browse(false) }, + { label: "Choose Directory Archive…", run: () => void browse(true) }, + ]) + : void browse(false) + } + /> +
+ + + {mismatch ? ( + mismatchText(mismatch) + ) : tool === "psql" ? ( + psql runs a plain SQL dump (.sql). + ) : ( + pg_restore reads custom, directory and tar archives. + )} + + {tool === "pgRestore" ? ( + <> + + Content: + + setR("schemas")(e.target.value)} + /> + + Parallel jobs: + + setR("jobs")(Math.max(1, Number(e.target.value) || 1))} + /> + +
+ + + + + + +
+ + ) : ( + <> + +
+ + +
+ + )} + {readOnly && ( + <> + + + The data source is read-only. + + + )} + +
+ + )} +
+ ); +} diff --git a/src/features/database/dumpTools.test.ts b/src/features/database/dumpTools.test.ts new file mode 100644 index 000000000..76e0fa53e --- /dev/null +++ b/src/features/database/dumpTools.test.ts @@ -0,0 +1,144 @@ +import { describe, expect, it } from "vitest"; +import type { DataSource, DbTableInfo } from "@/platform/ipc"; +import { + DEFAULT_DUMP, + DEFAULT_RESTORE, + baseName, + dumpMismatch, + dumpOptions, + dumpScope, + formatElapsed, + majorOf, + outputPath, + pickInstall, + restoreOptions, + restoreToolFor, + versionFit, + withExtension, +} from "./dumpTools"; + +const pg = { id: "s1", name: "Shop / dev", driver: "postgres", host: "localhost", user: "app" } as DataSource; + +describe("forms", () => { + it("send the typed name lists as lists", () => { + const options = dumpOptions({ + ...DEFAULT_DUMP, + schemas: "public, audit", + tables: " public.orders ", + excludeTables: "", + }); + expect([options.schemas, options.tables, options.excludeTables]).toEqual([ + ["public", "audit"], + ["public.orders"], + [], + ]); + expect(restoreOptions({ ...DEFAULT_RESTORE, schemas: "a b" }).schemas).toEqual(["a", "b"]); + }); +}); + +describe("restore", () => { + it("picks psql for .sql files and pg_restore for the rest", () => { + expect(restoreToolFor("/tmp/a.SQL")).toBe("psql"); + expect(restoreToolFor("/tmp/a.dump")).toBe("pgRestore"); + expect(restoreToolFor("/tmp/dir")).toBe("pgRestore"); + }); + + it("trusts the dump's header over its extension", () => { + expect(restoreToolFor("/tmp/a.backup", "postgresSql")).toBe("psql"); + expect(restoreToolFor("/tmp/a.sql", "postgresArchive")).toBe("pgRestore"); + }); + + it("refuses a dump the tool cannot read", () => { + expect(dumpMismatch("psql", "mysqlSql")).toBe("mysqlIntoPostgres"); + expect(dumpMismatch("psql", "postgresArchive")).toBe("archiveIntoPsql"); + expect(dumpMismatch("pgRestore", "postgresSql")).toBe("sqlIntoPgRestore"); + expect(dumpMismatch("psql", "postgresSql")).toBeNull(); + expect(dumpMismatch("psql", "unknown")).toBeNull(); + expect(dumpMismatch("pgRestore", null)).toBeNull(); + }); +}); + +describe("paths", () => { + it("fills the patterns with file-safe values", () => { + const now = new Date(2026, 2, 7, 9, 5, 2); + expect( + outputPath("/tmp/{data_source}-{database}-{timestamp}.sql", { dataSource: "Shop / dev", database: "shop", now }), + ).toBe("/tmp/Shop_dev-shop-2026-03-07_09-05-02.sql"); + }); + + it("follows the format's extension", () => { + expect(withExtension("/tmp/x-{timestamp}.sql", "custom")).toBe("/tmp/x-{timestamp}.dump"); + expect(withExtension("/tmp/x.dump", "directory")).toBe("/tmp/x"); + expect(withExtension("/tmp/x", "plain")).toBe("/tmp/x.sql"); + }); +}); + +describe("dumpScope", () => { + const table = { name: "Orders", kind: "table" } as DbTableInfo; + + it("applies to PostgreSQL sources, databases, schemas and tables", () => { + const shop = { ...pg, database: "shop" }; + expect(dumpScope({ kind: "source", key: "s1", source: shop }, shop)).toEqual({ target: "s1", database: "shop" }); + expect(dumpScope({ kind: "database", key: "k", id: "s1:crm", name: "crm", current: false }, pg)).toEqual({ + target: "s1:crm", + database: "crm", + }); + expect(dumpScope({ kind: "schema", key: "k", id: "s1:crm", schema: "public" }, pg)).toMatchObject({ + schemas: "public", + }); + expect(dumpScope({ kind: "table", key: "k", id: "s1:crm", schema: "public", table }, pg)).toMatchObject({ + tables: 'public."Orders"', + }); + }); + + it("does not apply to other drivers or views", () => { + const mysql = { ...pg, driver: "mysql" } as DataSource; + expect(dumpScope({ kind: "source", key: "s1", source: mysql }, mysql)).toBeNull(); + const view = { ...table, kind: "view" } as DbTableInfo; + expect(dumpScope({ kind: "table", key: "k", id: "s1", schema: "public", table: view }, pg)).toBeNull(); + }); +}); + +describe("client and server versions", () => { + const installs = [ + { path: "/opt/homebrew/bin/pg_dump", version: "pg_dump (PostgreSQL) 18.4 (Homebrew)" }, + { path: "/opt/homebrew/opt/postgresql@15/bin/pg_dump", version: "pg_dump (PostgreSQL) 15.13 (Homebrew)" }, + ]; + + it("reads the major version", () => { + expect(majorOf("pg_dump (PostgreSQL) 18.4 (Homebrew)")).toBe(18); + expect(majorOf("psql (PostgreSQL) 9.6.24")).toBe(9); + expect(majorOf("unknown")).toBeNull(); + }); + + it("flags a pg_dump older than the server, and dumps an older server cannot load", () => { + expect(versionFit("pgDump", 14, 15)).toBe("tooOld"); + expect(versionFit("pgDump", 18, 15)).toBe("newer"); + expect(versionFit("pgRestore", 18, 15)).toBe("newer"); + expect(versionFit("pgRestore", 14, 15)).toBe("ok"); + expect(versionFit("psql", 18, 15)).toBe("ok"); + expect(versionFit("pgDump", 15, null)).toBe("ok"); + }); + + it("preselects the server's version, else the last used, else the newest", () => { + expect(pickInstall(installs, 15, "/usr/bin/pg_dump")).toBe("/opt/homebrew/opt/postgresql@15/bin/pg_dump"); + expect(pickInstall(installs, 16, "/usr/bin/pg_dump")).toBe("/usr/bin/pg_dump"); + expect(pickInstall(installs, 16, null)).toBe("/opt/homebrew/bin/pg_dump"); + expect(pickInstall([], null, null)).toBe(""); + }); +}); + +describe("run summaries", () => { + it("formats how long a run took", () => { + expect(formatElapsed(350)).toBe("< 1 s"); + expect(formatElapsed(4_200)).toBe("4 s"); + expect(formatElapsed(724_000)).toBe("12 min 4 s"); + expect(formatElapsed(7_500_000)).toBe("2 h 5 min"); + }); + + it("shortens paths to their file name", () => { + expect(baseName("/tmp/dumps/shop.sql")).toBe("shop.sql"); + expect(baseName("C:\\dumps\\shop.dump")).toBe("shop.dump"); + expect(baseName("/tmp/dir/")).toBe("dir"); + }); +}); diff --git a/src/features/database/dumpTools.ts b/src/features/database/dumpTools.ts new file mode 100644 index 000000000..7da81e94c --- /dev/null +++ b/src/features/database/dumpTools.ts @@ -0,0 +1,180 @@ +/** The dump / restore dialogs' model: their forms, file names, tool choice and version hints. */ +import type { + DataSource, + DbDumpFormat, + DbDumpKind, + DbPgDumpOptions, + DbPgRestoreOptions, + DbPsqlOptions, + DbTool, + DbToolInstall, +} from "@/platform/ipc"; +import { splitTarget } from "./model"; +import { nodeTarget, type DbNode } from "./nodes"; + +export const DUMP_FORMATS: readonly { id: DbDumpFormat; label: string; extension: string }[] = [ + { id: "plain", label: "Plain SQL", extension: ".sql" }, + { id: "custom", label: "Custom archive", extension: ".dump" }, + { id: "directory", label: "Directory", extension: "" }, + { id: "tar", label: "Tar archive", extension: ".tar" }, +]; + +/** A name list as typed in a field (`public, audit`). */ +type Typed = Omit & { [P in K]: string }; + +export type DumpForm = Typed; +export type RestoreForm = Typed; + +export const DEFAULT_DUMP: DumpForm = { + format: "plain", + statements: "copy", + content: "all", + schemas: "", + tables: "", + excludeTables: "", + clean: false, + ifExists: false, + create: false, + noOwner: false, + noPrivileges: false, + jobs: 1, +}; + +export const DEFAULT_RESTORE: RestoreForm = { + content: "all", + schemas: "", + clean: false, + ifExists: false, + noOwner: false, + noPrivileges: false, + singleTransaction: false, + exitOnError: true, + jobs: 1, +}; + +export const DEFAULT_PSQL: DbPsqlOptions = { singleTransaction: true, stopOnError: true }; + +/** `a, b c` → `["a", "b", "c"]`. */ +export function nameList(text: string): string[] { + return text.split(/[\s,]+/).filter(Boolean); +} + +export function dumpOptions(f: DumpForm): DbPgDumpOptions { + return { ...f, schemas: nameList(f.schemas), tables: nameList(f.tables), excludeTables: nameList(f.excludeTables) }; +} + +export function restoreOptions(f: RestoreForm): DbPgRestoreOptions { + return { ...f, schemas: nameList(f.schemas) }; +} + +/** + * The PostgreSQL tool for a dump: from its header when known, else `psql` for a `.sql` file and + * `pg_restore` for anything else (archives, directories). + */ +export function restoreToolFor(path: string, kind: DbDumpKind | null = null): Extract { + if (kind === "postgresArchive") return "pgRestore"; + if (kind === "postgresSql") return "psql"; + return /\.sql$/i.test(path.trim()) ? "psql" : "pgRestore"; +} + +export type DumpMismatch = "mysqlIntoPostgres" | "archiveIntoPsql" | "sqlIntoPgRestore"; + +/** Why `tool` cannot restore a dump of `kind`; `null` when it can, or the kind is unknown. */ +export function dumpMismatch(tool: DbTool, kind: DbDumpKind | null): DumpMismatch | null { + if (!kind || kind === "unknown") return null; + if (kind === "mysqlSql") return "mysqlIntoPostgres"; + if (tool === "psql" && kind === "postgresArchive") return "archiveIntoPsql"; + if (tool === "pgRestore" && kind === "postgresSql") return "sqlIntoPgRestore"; + return null; +} + +/** `2026-03-07_09-05-02` (local time). */ +export function timestamp(d: Date): string { + const p = (n: number) => String(n).padStart(2, "0"); + return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())}_${p(d.getHours())}-${p(d.getMinutes())}-${p(d.getSeconds())}`; +} + +const unsafe = /[\\/:*?"<>|\s]+/g; + +/** Fills `{data_source}`, `{database}` and `{timestamp}` of an output path pattern. */ +export function outputPath(pattern: string, values: { dataSource: string; database: string; now: Date }): string { + return pattern + .replaceAll("{data_source}", values.dataSource.replace(unsafe, "_")) + .replaceAll("{database}", values.database.replace(unsafe, "_")) + .replaceAll("{timestamp}", timestamp(values.now)); +} + +/** The pattern with the format's extension in place of the previous one. */ +export function withExtension(pattern: string, format: DbDumpFormat): string { + const ext = DUMP_FORMATS.find((f) => f.id === format)!.extension; + return pattern.replace(/\.(sql|dump|backup|tar)$/i, "") + ext; +} + +/** A name as a `pg_dump` pattern: quoted unless it is a lower-case identifier. */ +function patternName(name: string): string { + return /^[a-z_][a-z0-9_$]*$/.test(name) ? name : `"${name.replaceAll('"', '""')}"`; +} + +export interface DumpScope { + target: string; + database: string; + schemas?: string; + tables?: string; +} + +/** What the dump / restore actions act on for tree node `n`; `null` when they don't apply. */ +export function dumpScope(n: DbNode, source: DataSource | undefined): DumpScope | null { + const target = nodeTarget(n); + if (!target || source?.driver !== "postgres") return null; + const database = n.kind === "database" ? n.name : (splitTarget(target).database ?? source.database ?? ""); + if (n.kind === "source" || n.kind === "database") return { target, database }; + if (n.kind === "schema") return { target, database, schemas: patternName(n.schema) }; + if (n.kind === "table" && n.table.kind === "table") + return { target, database, tables: `${patternName(n.schema)}.${patternName(n.table.name)}` }; + return null; +} + +/** The major version in a `--version` line (`pg_dump (PostgreSQL) 17.2` → 17). */ +export function majorOf(version: string): number | null { + const m = /(\d+)(?:\.\d+)?/.exec(version); + return m ? Number(m[1]) : null; +} + +/** + * How a tool's major version fits the server's: `pg_dump` refuses an older-than-server + * copy, and what newer `pg_dump` / `pg_restore` write may not load into an older server + * (17 and later set `transaction_timeout`, unknown before 17). + */ +export function versionFit(tool: DbTool, toolMajor: number | null, serverMajor: number | null) { + if (tool === "psql" || toolMajor === null || serverMajor === null || toolMajor === serverMajor) return "ok"; + if (toolMajor < serverMajor) return tool === "pgDump" ? "tooOld" : "ok"; + return "newer"; +} + +/** The copy to preselect: the server's major version, else the one used last, else the newest. */ +export function pickInstall(installs: DbToolInstall[], serverMajor: number | null, last: string | null): string { + const matching = installs.find((i) => majorOf(i.version) === serverMajor); + return matching?.path ?? last ?? installs[0]?.path ?? ""; +} + +/** `< 1 s`, `4 s`, `12 min 4 s`, `2 h 5 min`. */ +export function formatElapsed(ms: number): string { + if (ms < 1000) return "< 1 s"; + const total = Math.floor(ms / 1000); + const h = Math.floor(total / 3600); + const m = Math.floor((total % 3600) / 60); + const sec = total % 60; + if (h) return `${h} h ${m} min`; + if (m) return `${m} min ${sec} s`; + return `${sec} s`; +} + +/** The last part of a path, for one-line summaries. */ +export function baseName(path: string): string { + return ( + path + .replace(/[\\/]+$/, "") + .split(/[\\/]/) + .pop() || path + ); +} diff --git a/src/features/database/store.ts b/src/features/database/store.ts index e3aa2b679..0f3958883 100644 --- a/src/features/database/store.ts +++ b/src/features/database/store.ts @@ -146,7 +146,11 @@ export type DialogState = /** Import Data from File into a table. */ | { kind: "import"; id: string; schema: string; table: string } /** Compare Structure: `source` starts as the schema the action was invoked on. */ - | { kind: "compareSchemas"; source: { id: string; schema: string } | null }; + | { kind: "compareSchemas"; source: { id: string; schema: string } | null } + /** Export with 'pg_dump' of a database, schema or table. */ + | { kind: "dump"; target: string; database: string; schemas?: string; tables?: string; serverVersion: number | null } + /** Restore with 'pg_restore' / 'psql' into a database. */ + | { kind: "restore"; target: string; database: string; serverVersion: number | null }; /** The schemas and tables of a data source's databases, as far as introspection has read them. */ export interface SourceCatalog { diff --git a/src/features/database/toolRuns.ts b/src/features/database/toolRuns.ts new file mode 100644 index 000000000..258e2bc12 --- /dev/null +++ b/src/features/database/toolRuns.ts @@ -0,0 +1,161 @@ +/** Runs of `pg_dump` / `pg_restore` / `psql`: they outlive the dialog that started them. */ +import { Channel } from "@tauri-apps/api/core"; +import { create } from "zustand"; +import { + call, + commands, + isCancelled, + nextRequestId, + type DbTool, + type DbToolJob, + type DbToolLine, + type RequestId, +} from "@/platform/ipc"; +import { tx } from "@/platform/i18n"; +import { canRevealInFileManager, revealInFileManager, revealInFileManagerLabel } from "@/platform/fileManager"; +import { notifications } from "@/workbench/contributions"; +import { baseName, formatElapsed } from "./dumpTools"; +import { log, targetLabel, withConnection } from "./store"; + +const MAX_LINES = 5000; + +export const TOOL_PROGRAMS: Record = { + pgDump: "pg_dump", + pgRestore: "pg_restore", + psql: "psql", +}; + +export interface ToolRun { + key: number; + tool: DbTool; + target: string; + lines: DbToolLine[]; + status: "running" | "done" | "failed" | "cancelled"; + /** The process's exit code, or why it did not start. */ + exit: number | null; + error?: string; + /** What moves where, e.g. `shop → shop-2026-03-07.sql` (file names shortened). */ + route: string; + startedAt: number; + endedAt?: number; +} + +export const useToolRuns = create<{ runs: Record }>(() => ({ runs: {} })); + +let nextKey = 1; +const requests = new Map(); + +function update(key: number, change: (r: ToolRun) => Partial) { + useToolRuns.setState((s) => { + const r = s.runs[key]; + return r ? { runs: { ...s.runs, [key]: { ...r, ...change(r) } } } : s; + }); +} + +export interface ToolRunRequest { + target: string; + executable: string; + job: DbToolJob; + /** Shown in the Output tab. */ + commandLine: string; + /** The file or directory a dump writes, offered in the finish notification. */ + output?: string; + /** Shown as `from → to`; paths are shortened to their file name. */ + from: string; + to: string; + onSuccess?: () => void; +} + +/** Starts the tool (asking for the password first when needed) and returns its run's key. */ +export function startToolRun(req: ToolRunRequest): number { + const key = nextKey++; + const run: ToolRun = { + key, + tool: req.job.tool, + target: req.target, + lines: [], + status: "running", + exit: null, + route: `${shorten(req.from)} → ${shorten(req.to)}`, + startedAt: Date.now(), + }; + useToolRuns.setState((s) => ({ runs: { ...s.runs, [key]: run } })); + log("statement", req.commandLine); + void execute(key, req); + return key; +} + +async function execute(key: number, req: ToolRunRequest) { + const label = targetLabel(req.target); + const program = TOOL_PROGRAMS[req.job.tool]; + try { + const exit = await withConnection(req.target, () => { + const request = nextRequestId(); + requests.set(key, request); + const channel = new Channel(); + channel.onmessage = (batch) => + update(key, (r) => { + const lines = r.lines.concat(batch); + return { lines: lines.length > MAX_LINES ? lines.slice(lines.length - MAX_LINES) : lines }; + }); + return call(commands.dbRunTool(request, req.target, req.executable, req.job, channel)); + }); + const ok = exit === 0; + const took = finish(key, { status: ok ? "done" : "failed", exit }); + const route = routeOf(key); + log(ok ? "result" : "error", tx`${program} finished with exit code ${String(exit ?? "?")} in ${took}`); + if (ok) req.onSuccess?.(); + const reveal = + ok && req.output && canRevealInFileManager() + ? [{ label: revealInFileManagerLabel(), run: () => void revealInFileManager(req.output!) }] + : []; + notifications().notify({ + level: ok ? "info" : "error", + title: ok ? tx`${program} finished: ${label}` : tx`${program} failed: ${label}`, + body: ok + ? tx`${route} in ${took}` + : errorTail(key) || + tx`Exit code ${String(exit ?? "?")}. The Database tool window's Output tab has the command.`, + actions: reveal, + key: `db-tool-${key}`, + }); + } catch (e) { + if (isCancelled(e)) { + const took = finish(key, { status: "cancelled" }); + log("info", tx`${program} stopped after ${took}`); + return; + } + const error = e instanceof Error ? e.message : String(e); + finish(key, { status: "failed", error }); + log("error", error); + notifications().notify({ level: "error", title: tx`Cannot run ${program}`, body: error, key: `db-tool-${key}` }); + } finally { + requests.delete(key); + } +} + +/** Records the end of run `key` and returns how long it took. */ +function finish(key: number, change: Partial): string { + const endedAt = Date.now(); + update(key, () => ({ ...change, endedAt })); + return formatElapsed(endedAt - (useToolRuns.getState().runs[key]?.startedAt ?? endedAt)); +} + +const routeOf = (key: number) => useToolRuns.getState().runs[key]?.route ?? ""; + +const shorten = (s: string) => (/[\\/]/.test(s) ? baseName(s) : s); + +/** The last lines the tool wrote to stderr, where it reports what went wrong. */ +function errorTail(key: number): string { + const lines = useToolRuns.getState().runs[key]?.lines ?? []; + return lines + .filter((l) => l.stderr) + .slice(-3) + .map((l) => l.text) + .join("\n"); +} + +export function stopToolRun(key: number) { + const request = requests.get(key); + if (request) void commands.cancelRequest(request); +} diff --git a/src/features/database/treeActions.ts b/src/features/database/treeActions.ts index 7cca3535c..833dfdf8f 100644 --- a/src/features/database/treeActions.ts +++ b/src/features/database/treeActions.ts @@ -14,6 +14,7 @@ import { canDrop, canModifyTable, canRename, reference, scriptSql, type ScriptKi import { DB_TOOL_WINDOW, OUTPUT_TAB, + connect, RESULTS_VIEW, detailsKey, disconnect, @@ -44,6 +45,7 @@ import { removeSource, } from "./store"; import { tableInput } from "./tableInput"; +import { dumpScope } from "./dumpTools"; import { tx } from "@/platform/i18n"; import { chooseItem } from "@/workbench/inputDialogs"; import { databaseRequest } from "./requests"; @@ -100,6 +102,19 @@ async function tablesIn(id: string, schema: string): Promise { return l?.status === "ok" ? l.value : []; } +/** + * Connects to `target` before a dump / restore dialog opens (a password prompt would replace + * the dialog) and reads the server's version; `undefined` when the user cancelled. + */ +async function serverVersionOf(target: string): Promise { + if (!(await connect(target))) return undefined; + try { + return await withConnection(target, () => call(commands.dbServerVersion(target))); + } catch { + return null; + } +} + /** DDL of a table / view, or of every table and view of a schema or data source. */ async function ddlOf(n: DbNode): Promise<{ id: string; text: string } | null> { const id = nodeTarget(n); @@ -428,6 +443,31 @@ export function registerDatabaseTreeActions(): () => void { openDialog({ kind: "import", id: n.id, schema: n.schema, table: n.table.name }); }, }), + tree({ + id: "db.dumpWithPgDump", + title: "Export with 'pg_dump'…", + icon: "export", + keywords: ["backup", "dump", "postgresql"], + run: async ({ arg }) => { + const n = nodeFrom(arg); + const scope = n && dumpScope(n, sourceOf(n)); + const serverVersion = scope && (await serverVersionOf(scope.target)); + if (scope && serverVersion !== undefined) openDialog({ kind: "dump", ...scope, serverVersion }); + }, + }), + tree({ + id: "db.restoreWithPgRestore", + title: "Restore with 'pg_restore'/'psql'…", + icon: "download", + keywords: ["backup", "restore", "load dump", "postgresql"], + run: async ({ arg }) => { + const n = nodeFrom(arg); + const scope = n && dumpScope(n, sourceOf(n)); + const serverVersion = scope && (await serverVersionOf(scope.target)); + if (scope && serverVersion !== undefined) + openDialog({ kind: "restore", target: scope.target, database: scope.database, serverVersion }); + }, + }), tree({ id: "db.copyReference", title: "Copy Reference", diff --git a/src/features/database/treeMenu.ts b/src/features/database/treeMenu.ts index ecf11c530..0456660cd 100644 --- a/src/features/database/treeMenu.ts +++ b/src/features/database/treeMenu.ts @@ -7,6 +7,8 @@ import { nodeTarget, objectOf, tableOf, type DbNode } from "./nodes"; import { SCRIPT_LABELS, canDrop, canModifyTable, canRename, type ScriptKind } from "./objects"; import { connectedTargets, openDialog, openSourceDialog, sourceById, useDatabase } from "./store"; import { readClipboardPlainText } from "@/platform/clipboard"; +import { useRemote } from "@/platform/remote"; +import { dumpScope } from "./dumpTools"; const act = ( action: string, @@ -81,6 +83,20 @@ function sqlScripts(n: DbNode, table: boolean): MenuItem { return { label: "SQL Scripts", submenu: [act("db.ddlToClipboard", n), act("db.ddlToConsole", n), sep, ...scripts] }; } +/** Export with 'pg_dump' / Restore of a PostgreSQL node; the tools run on this machine, so not in remote windows. */ +function dumpItems(n: DbNode, restore: boolean): MenuItem[] { + const source = sourceById(nodeTarget(n)); + if (useRemote.getState().session || !dumpScope(n, source)) return []; + return [ + act("db.dumpWithPgDump", n), + ...(restore ? [act("db.restoreWithPgRestore", n, { disabled: !!source?.readOnly })] : []), + ]; +} + +function importExport(items: MenuItem[]): MenuItem[] { + return items.length ? [{ label: "Import/Export", submenu: items }] : []; +} + /** Context menu of a tree node (`null`: the empty area). */ export function nodeMenu(n: DbNode | null): MenuItem[] { if (!n) return [{ label: "New", icon: "plus", submenu: newMenu() }]; @@ -118,6 +134,7 @@ export function nodeMenu(n: DbNode | null): MenuItem[] { sep, sqlScripts(n, false), act("db.compareSchemas", n), + ...importExport(dumpItems(n, true)), sep, act("db.drop", n, { label: "Remove Data Source…" }), ]; @@ -131,6 +148,7 @@ export function nodeMenu(n: DbNode | null): MenuItem[] { sep, navigation(), sqlScripts(n, false), + ...importExport(dumpItems(n, true)), ]; case "schema": case "folder": @@ -144,6 +162,7 @@ export function nodeMenu(n: DbNode | null): MenuItem[] { sep, sqlScripts(n, false), ...(n.kind === "schema" ? [act("db.compareSchemas", n)] : []), + ...importExport(dumpItems(n, true)), ...(n.kind === "schema" ? [sep, drop] : []), ]; case "table": @@ -177,7 +196,13 @@ export function nodeMenu(n: DbNode | null): MenuItem[] { sqlScripts(n, true), ...(n.kind === "table" && !view ? [ - { label: "Import/Export", submenu: [act("db.importData", n, { disabled: driver === "clickhouse" })] }, + { + label: "Import/Export", + submenu: [ + act("db.importData", n, { disabled: driver === "clickhouse" }), + ...(dumpItems(n, false).length ? [sep, ...dumpItems(n, false)] : []), + ], + }, { label: "Object Actions", submenu: [act("db.truncate", n)] }, ] : []), diff --git a/src/platform/i18n.test.ts b/src/platform/i18n.test.ts index 1d1063d7d..c3816aeb1 100644 --- a/src/platform/i18n.test.ts +++ b/src/platform/i18n.test.ts @@ -277,6 +277,10 @@ describe("catalogs", () => { "Kotlin", "PHP", "SQL", + "COPY", + "INSERT", + "pg_restore", + "psql", "JavaScript", "TypeScript", "HTML", diff --git a/src/platform/locales/text/en.json b/src/platform/locales/text/en.json index da4ba19db..778b68bf6 100644 --- a/src/platform/locales/text/en.json +++ b/src/platform/locales/text/en.json @@ -2228,5 +2228,69 @@ "Values can no longer be expanded after the program resumed": "Values can no longer be expanded after the program resumed", "Each step shows its first {limit} values": "Each step shows its first {limit} values", "Steps": "Steps", - "No result": "No result" + "No result": "No result", + "Add CREATE DATABASE": "Add CREATE DATABASE", + "Add DROP before CREATE": "Add DROP before CREATE", + "Allowed substitution patterns:": "Allowed substitution patterns:", + "COPY": "COPY", + "Cannot run {program}": "Cannot run {program}", + "Content:": "Content:", + "Content": "Content", + "Custom archive": "Custom archive", + "Data only": "Data only", + "Drop objects before recreating them": "Drop objects before recreating them", + "Exit code {exit}. The Database tool window's Output tab has the command.": "Exit code {exit}. The Database tool window's Output tab has the command.", + "Export with 'pg_dump' ({target})": "Export with 'pg_dump' ({target})", + "Export with 'pg_dump'…": "Export with 'pg_dump'…", + "Format:": "Format:", + "Format": "Format", + "INSERT with column names": "INSERT with column names", + "INSERT": "INSERT", + "Output result to:": "Output result to:", + "Output result to": "Output result to", + "Parallel jobs:": "Parallel jobs:", + "Parallel jobs": "Parallel jobs", + "Path to dump:": "Path to dump:", + "Path to dump": "Path to dump", + "Path to executable:": "Path to executable:", + "Path to {program}": "Path to {program}", + "Plain SQL": "Plain SQL", + "Restore tool": "Restore tool", + "Restore with 'pg_restore'/'psql' ({target})": "Restore with 'pg_restore'/'psql' ({target})", + "Restore with 'pg_restore'/'psql'…": "Restore with 'pg_restore'/'psql'…", + "Schema and data": "Schema and data", + "Schema only": "Schema only", + "Schemas:": "Schemas:", + "Skip ownership (--no-owner)": "Skip ownership (--no-owner)", + "Skip privileges (--no-privileges)": "Skip privileges (--no-privileges)", + "Statements:": "Statements:", + "Stop on the first error": "Stop on the first error", + "Tar archive": "Tar archive", + "The data source is read-only.": "The data source is read-only.", + "The data source is read-only": "The data source is read-only", + "Use DROP … IF EXISTS": "Use DROP … IF EXISTS", + "Wrap the restore in BEGIN … COMMIT": "Wrap the restore in BEGIN … COMMIT", + "pg_restore reads custom, directory and tar archives.": "pg_restore reads custom, directory and tar archives.", + "pg_restore": "pg_restore", + "psql runs a plain SQL dump (.sql).": "psql runs a plain SQL dump (.sql).", + "psql": "psql", + "{program} failed: {label}": "{program} failed: {label}", + "{program} finished: {label}": "{program} finished: {label}", + "{program} was not found. Install the PostgreSQL client tools or choose the executable.": "{program} was not found. Install the PostgreSQL client tools or choose the executable.", + "{version}: older than the server (PostgreSQL {server}), which pg_dump refuses. Choose version {server} or newer.": "{version}: older than the server (PostgreSQL {server}), which pg_dump refuses. Choose version {server} or newer.", + "{version}: newer than the server (PostgreSQL {server}). What it writes may not load into PostgreSQL {server}. Install the PostgreSQL {server} client tools to restore into this server.": "{version}: newer than the server (PostgreSQL {server}). What it writes may not load into PostgreSQL {server}. Install the PostgreSQL {server} client tools to restore into this server.", + "Copy Output": "Copy Output", + "Running {tool}… {took}": "Running {tool}… {took}", + "Finished in {took}": "Finished in {took}", + "Stopped after {took}": "Stopped after {took}", + "Failed with exit code {exit} after {took}": "Failed with exit code {exit} after {took}", + "{program} finished with exit code {exit} in {took}": "{program} finished with exit code {exit} in {took}", + "{route} in {took}": "{route} in {took}", + "{program} stopped after {took}": "{program} stopped after {took}", + "All databases": "All databases", + "Choose File…": "Choose File…", + "Choose Directory Archive…": "Choose Directory Archive…", + "This is a MySQL dump: restore it into a MySQL data source.": "This is a MySQL dump: restore it into a MySQL data source.", + "This is a pg_dump archive: restore it with pg_restore.": "This is a pg_dump archive: restore it with pg_restore.", + "This is a plain SQL dump: restore it with psql.": "This is a plain SQL dump: restore it with psql." } diff --git a/src/platform/locales/text/zh.json b/src/platform/locales/text/zh.json index ff765efec..76047ffe4 100644 --- a/src/platform/locales/text/zh.json +++ b/src/platform/locales/text/zh.json @@ -8615,5 +8615,67 @@ "Values can no longer be expanded after the program resumed": "程序恢复运行后,值无法再展开", "Each step shows its first {limit} values": "每个步骤仅显示前 {limit} 个值", "Steps": "步骤", - "No result": "无结果" + "No result": "无结果", + "Add CREATE DATABASE": "添加 CREATE DATABASE", + "Add DROP before CREATE": "在 CREATE 之前添加 DROP", + "Allowed substitution patterns:": "可用的替换模式:", + "COPY": "COPY", + "Cannot run {program}": "无法运行 {program}", + "Content:": "内容:", + "Content": "内容", + "Custom archive": "自定义归档", + "Data only": "仅数据", + "Drop objects before recreating them": "重新创建前删除对象", + "Exit code {exit}. The Database tool window's Output tab has the command.": "退出代码 {exit}。命令见“数据库”工具窗口的“输出”标签页。", + "Export with 'pg_dump' ({target})": "使用 'pg_dump' 导出({target})", + "Export with 'pg_dump'…": "使用 'pg_dump' 导出…", + "Format:": "格式:", + "Format": "格式", + "INSERT with column names": "带列名的 INSERT", + "INSERT": "INSERT", + "Output result to:": "输出结果到:", + "Output result to": "输出结果到", + "Parallel jobs:": "并行任务数:", + "Parallel jobs": "并行任务数", + "Path to dump:": "转储文件路径:", + "Path to dump": "转储文件路径", + "Path to executable:": "可执行文件路径:", + "Path to {program}": "{program} 的路径", + "Plain SQL": "纯 SQL", + "Restore tool": "恢复工具", + "Restore with 'pg_restore'/'psql' ({target})": "使用 'pg_restore'/'psql' 恢复({target})", + "Restore with 'pg_restore'/'psql'…": "使用 'pg_restore'/'psql' 恢复…", + "Schema and data": "结构和数据", + "Schema only": "仅结构", + "Schemas:": "模式:", + "Skip ownership (--no-owner)": "跳过所有者(--no-owner)", + "Skip privileges (--no-privileges)": "跳过权限(--no-privileges)", + "Statements:": "语句:", + "Stop on the first error": "遇到第一个错误时停止", + "Tar archive": "Tar 归档", + "The data source is read-only.": "该数据源为只读。", + "The data source is read-only": "该数据源为只读", + "Use DROP … IF EXISTS": "使用 DROP … IF EXISTS", + "Wrap the restore in BEGIN … COMMIT": "将恢复包装在 BEGIN … COMMIT 中", + "pg_restore reads custom, directory and tar archives.": "pg_restore 读取自定义、目录和 tar 归档。", + "pg_restore": "pg_restore", + "psql runs a plain SQL dump (.sql).": "psql 执行纯 SQL 转储(.sql)。", + "psql": "psql", + "{program} failed: {label}": "{program} 失败:{label}", + "{program} finished: {label}": "{program} 已完成:{label}", + "{program} was not found. Install the PostgreSQL client tools or choose the executable.": "未找到 {program}。请安装 PostgreSQL 客户端工具或选择可执行文件。", + "{version}: older than the server (PostgreSQL {server}), which pg_dump refuses. Choose version {server} or newer.": "{version}:比服务器(PostgreSQL {server})旧,pg_dump 会拒绝运行。请选择 {server} 或更高版本。", + "{version}: newer than the server (PostgreSQL {server}). What it writes may not load into PostgreSQL {server}. Install the PostgreSQL {server} client tools to restore into this server.": "{version}:比服务器(PostgreSQL {server})新。它写出的内容可能无法载入 PostgreSQL {server}。如需恢复到此服务器,请安装 PostgreSQL {server} 客户端工具。", + "Copy Output": "复制输出", + "Running {tool}… {took}": "正在运行 {tool}… {took}", + "Finished in {took}": "已完成,用时 {took}", + "Stopped after {took}": "已停止,运行了 {took}", + "Failed with exit code {exit} after {took}": "运行 {took} 后失败,退出代码 {exit}", + "{program} finished with exit code {exit} in {took}": "{program} 已结束,退出代码 {exit},用时 {took}", + "{route} in {took}": "{route},用时 {took}", + "{program} stopped after {took}": "{program} 运行 {took} 后已停止", + "Choose Directory Archive…": "选择目录归档…", + "This is a MySQL dump: restore it into a MySQL data source.": "这是 MySQL 转储:请恢复到 MySQL 数据源。", + "This is a pg_dump archive: restore it with pg_restore.": "这是 pg_dump 归档:请使用 pg_restore 恢复。", + "This is a plain SQL dump: restore it with psql.": "这是纯 SQL 转储:请使用 psql 恢复。" }