feat(backup): support restoring selected MySQL tables
This commit is contained in:
1 parent
e8b3c1457a
commit
2d9521898f
30 files changed
+1014
-9
No files matched your search
@@ -59,6 +59,8 @@ pub struct SqlFileRequest {
|
||||
pub database: String,
|
||||
pub file_path: String,
|
||||
pub continue_on_error: bool,
|
||||
#[serde(default)]
|
||||
pub selected_tables: Option<Vec<crate::sql_file_import::SqlFileTable>>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||||
|
||||
@@ -27,6 +27,10 @@ use crate::sql::{
|
||||
};
|
||||
use crate::types::QueryResult;
|
||||
|
||||
mod table_restore;
|
||||
pub use table_restore::SqlFileTable;
|
||||
use table_restore::TableRestoreFilter;
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
struct SqlFileImportTarget {
|
||||
db_type: DatabaseType,
|
||||
@@ -340,11 +344,22 @@ pub async fn execute_sql_file_content(
|
||||
mut emit: impl FnMut(SqlFileProgress),
|
||||
) -> Result<(), String> {
|
||||
let import_target = sql_file_import_target(state, &request.connection_id).await;
|
||||
let statements = split_sql_file_import_statements_with_control(
|
||||
validate_table_restore_target(request, import_target.as_ref(), 1)?;
|
||||
let mut statements = split_sql_file_import_statements_with_control(
|
||||
file_content,
|
||||
import_target.as_ref().map(|target| target.db_type),
|
||||
);
|
||||
|
||||
if let Some(selected) = &request.selected_tables {
|
||||
let mut scan = TableRestoreFilter::default();
|
||||
for statement in &statements {
|
||||
scan.inspect(&statement.sql)?;
|
||||
}
|
||||
let (tables, views) = scan.finish();
|
||||
validate_selected_tables(selected, &tables)?;
|
||||
filter_restore_statements(&mut statements, &mut TableRestoreFilter::with_views(views), selected)?;
|
||||
}
|
||||
|
||||
let planned_statements = optimize_controlled_sql_file_import_statements(
|
||||
&statements,
|
||||
import_target.as_ref().map(|target| target.db_type),
|
||||
@@ -403,6 +418,29 @@ pub async fn execute_sql_file_paths(
|
||||
import_target.as_ref().map(|target| SqlParsingOptions::for_database_type(target.db_type)).unwrap_or_default();
|
||||
let database_type = import_target.as_ref().map(|target| target.db_type);
|
||||
let mut progress = SqlFileExecutionProgress::new();
|
||||
// Validate the entire dump before any SQL reaches the database. This also
|
||||
// identifies view placeholders whose final CREATE VIEW appears later.
|
||||
let restore_filter = async {
|
||||
validate_table_restore_target(request, import_target.as_ref(), file_paths.len())?;
|
||||
let Some(selected) = &request.selected_tables else {
|
||||
return Ok(None);
|
||||
};
|
||||
let (tables, views) = scan_sql_file_tables(file_paths[0], &token).await?;
|
||||
validate_selected_tables(selected, &tables)?;
|
||||
Ok::<_, String>(Some(TableRestoreFilter::with_views(views)))
|
||||
}
|
||||
.await;
|
||||
let mut restore_filter = match restore_filter {
|
||||
Ok(filter) => filter,
|
||||
Err(error) => {
|
||||
if token.is_cancelled() {
|
||||
emit_sql_file_terminal_progress(request, &token, started_at, &progress, &mut emit);
|
||||
return Ok(());
|
||||
}
|
||||
emit(sql_file_execution_error_progress(&request.execution_id, started_at, &progress, error.clone()));
|
||||
return Err(error);
|
||||
}
|
||||
};
|
||||
let mut mysql_executor = match MySqlSqlFileExecutor::build(state, request, import_target.as_ref()).await {
|
||||
Ok(executor) => executor,
|
||||
Err(error) => {
|
||||
@@ -475,7 +513,23 @@ pub async fn execute_sql_file_paths(
|
||||
emit_sql_file_terminal_progress(request, &token, started_at, &progress, &mut emit);
|
||||
return Ok(());
|
||||
}
|
||||
pending_statements.extend(splitter.push_chunk(&chunk));
|
||||
let mut next_statements = splitter.push_chunk(&chunk);
|
||||
if let Some(filter) = restore_filter.as_mut() {
|
||||
if let Err(error) = filter_restore_statements(
|
||||
&mut next_statements,
|
||||
filter,
|
||||
request.selected_tables.as_deref().unwrap_or_default(),
|
||||
) {
|
||||
emit(sql_file_execution_error_progress(
|
||||
&request.execution_id,
|
||||
started_at,
|
||||
&progress,
|
||||
error.clone(),
|
||||
));
|
||||
return Err(error);
|
||||
}
|
||||
}
|
||||
pending_statements.extend(next_statements);
|
||||
if pending_statements.len() < SQL_FILE_STATEMENT_BATCH_SIZE {
|
||||
continue;
|
||||
}
|
||||
@@ -493,7 +547,18 @@ pub async fn execute_sql_file_paths(
|
||||
.await?;
|
||||
}
|
||||
|
||||
pending_statements.extend(splitter.finish());
|
||||
let mut next_statements = splitter.finish();
|
||||
if let Some(filter) = restore_filter.as_mut() {
|
||||
if let Err(error) = filter_restore_statements(
|
||||
&mut next_statements,
|
||||
filter,
|
||||
request.selected_tables.as_deref().unwrap_or_default(),
|
||||
) {
|
||||
emit(sql_file_execution_error_progress(&request.execution_id, started_at, &progress, error.clone()));
|
||||
return Err(error);
|
||||
}
|
||||
}
|
||||
pending_statements.extend(next_statements);
|
||||
execute_sql_file_statement_batch(
|
||||
state,
|
||||
request,
|
||||
@@ -533,6 +598,79 @@ pub async fn execute_sql_file_paths(
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub async fn inspect_sql_file_tables(file_path: &Path) -> Result<Vec<SqlFileTable>, String> {
|
||||
scan_sql_file_tables(file_path, &CancellationToken::new()).await.map(|(tables, _)| tables)
|
||||
}
|
||||
|
||||
async fn scan_sql_file_tables(
|
||||
file_path: &Path,
|
||||
token: &CancellationToken,
|
||||
) -> Result<(Vec<SqlFileTable>, std::collections::BTreeSet<SqlFileTable>), String> {
|
||||
let mut decoder = SqlFileStreamDecoder::open_for_target(file_path, true).await?;
|
||||
let mut splitter = StreamingSqlFileSplitter::new(Some(DatabaseType::Mysql), SqlParsingOptions::mysql_compatible());
|
||||
let mut scan = TableRestoreFilter::default();
|
||||
while let Some(chunk) = decoder.next_chunk().await? {
|
||||
if token.is_cancelled() {
|
||||
return Err("Table inspection cancelled".to_string());
|
||||
}
|
||||
for statement in splitter.push_chunk(&chunk) {
|
||||
scan.inspect(&statement.sql)?;
|
||||
}
|
||||
}
|
||||
for statement in splitter.finish() {
|
||||
scan.inspect(&statement.sql)?;
|
||||
}
|
||||
Ok(scan.finish())
|
||||
}
|
||||
|
||||
fn validate_table_restore_target(
|
||||
request: &SqlFileRequest,
|
||||
target: Option<&SqlFileImportTarget>,
|
||||
file_count: usize,
|
||||
) -> Result<(), String> {
|
||||
let Some(selected) = &request.selected_tables else {
|
||||
return Ok(());
|
||||
};
|
||||
if selected.is_empty() {
|
||||
return Err("Select at least one table to restore".to_string());
|
||||
}
|
||||
if file_count != 1 {
|
||||
return Err("Selected-table restore requires exactly one SQL file".to_string());
|
||||
}
|
||||
if !target.is_some_and(|target| {
|
||||
crate::sql::supports_connection_level_database_bootstrap_target(
|
||||
&target.db_type,
|
||||
target.driver_profile.as_deref(),
|
||||
)
|
||||
}) {
|
||||
return Err("Selected-table restore is only supported for MySQL-compatible connections".to_string());
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn validate_selected_tables(selected: &[SqlFileTable], available: &[SqlFileTable]) -> Result<(), String> {
|
||||
if selected.iter().any(|table| !available.contains(table)) {
|
||||
return Err("A selected table is no longer present in the backup; scan the file again".to_string());
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn filter_restore_statements(
|
||||
statements: &mut Vec<SqlStatementWithControl>,
|
||||
filter: &mut TableRestoreFilter,
|
||||
selected: &[SqlFileTable],
|
||||
) -> Result<(), String> {
|
||||
let mut filtered = Vec::new();
|
||||
for mut statement in std::mem::take(statements) {
|
||||
if let Some(sql) = filter.filter(&statement.sql, selected)? {
|
||||
statement.sql = sql;
|
||||
filtered.push(statement);
|
||||
}
|
||||
}
|
||||
*statements = filtered;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub async fn read_sql_file_preview(file_path: &Path, max_chars: usize) -> Result<String, String> {
|
||||
let mut decoder =
|
||||
SqlFileStreamDecoder::open_with_detection_limit(file_path, Some(SQL_FILE_PREVIEW_ENCODING_SAMPLE_BYTES))
|
||||
@@ -1916,6 +2054,74 @@ mod tests {
|
||||
path
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn table_restore_scan_reads_beyond_preview_and_supports_gzip_and_utf16() {
|
||||
let sql = format!(
|
||||
"CREATE TABLE a (id INT); INSERT INTO a VALUES ('{}'); CREATE TABLE late_table (id INT);",
|
||||
"x".repeat(1_100_000)
|
||||
);
|
||||
let mut utf16 = vec![0xff, 0xfe];
|
||||
for unit in sql.encode_utf16() {
|
||||
utf16.extend_from_slice(&unit.to_le_bytes());
|
||||
}
|
||||
for path in [
|
||||
temporary_sql_file(sql.as_bytes()).await,
|
||||
temporary_gzip_sql_file(sql.as_bytes()).await,
|
||||
temporary_sql_file(&utf16).await,
|
||||
] {
|
||||
let tables = inspect_sql_file_tables(&path).await.unwrap();
|
||||
tokio::fs::remove_file(&path).await.unwrap();
|
||||
assert_eq!(tables.iter().map(|table| table.name.as_str()).collect::<Vec<_>>(), vec!["a", "late_table"]);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn table_restore_stream_filters_each_statement_once_across_chunks() {
|
||||
let selected = [
|
||||
SqlFileTable { database: None, name: "a".to_string() },
|
||||
SqlFileTable { database: Some("second".to_string()), name: "b".to_string() },
|
||||
];
|
||||
let mut splitter =
|
||||
StreamingSqlFileSplitter::new(Some(DatabaseType::Mysql), SqlParsingOptions::mysql_compatible());
|
||||
let mut filter = TableRestoreFilter::default();
|
||||
let mut statements = Vec::new();
|
||||
for chunk in ["INSERT INTO a VALUES (1); USE second;", "INSERT INTO b VALUES (2); INSERT INTO a VALUES (3);"] {
|
||||
let mut next = splitter.push_chunk(chunk);
|
||||
filter_restore_statements(&mut next, &mut filter, &selected).unwrap();
|
||||
statements.extend(next);
|
||||
}
|
||||
let mut next = splitter.finish();
|
||||
filter_restore_statements(&mut next, &mut filter, &selected).unwrap();
|
||||
statements.extend(next);
|
||||
assert_eq!(
|
||||
statements.iter().map(|statement| statement.sql.as_str()).collect::<Vec<_>>(),
|
||||
vec!["INSERT INTO a VALUES (1)", "USE second", "INSERT INTO b VALUES (2)"]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn table_restore_request_is_opt_in_and_rejects_empty_or_missing_selections() {
|
||||
let mut request: SqlFileRequest = serde_json::from_value(serde_json::json!({"executionId":"test", "connectionId":"conn", "database":"app", "filePath":"backup.sql", "continueOnError":false})).unwrap();
|
||||
assert!(request.selected_tables.is_none());
|
||||
assert!(validate_table_restore_target(&request, None, 1).is_ok());
|
||||
request.selected_tables = Some(Vec::new());
|
||||
assert!(validate_table_restore_target(&request, None, 1).is_err());
|
||||
request.selected_tables = Some(vec![SqlFileTable { database: None, name: "a".to_string() }]);
|
||||
assert!(validate_table_restore_target(
|
||||
&request,
|
||||
Some(&SqlFileImportTarget { db_type: DatabaseType::Postgres, driver_profile: None }),
|
||||
1
|
||||
)
|
||||
.is_err());
|
||||
assert!(validate_table_restore_target(
|
||||
&request,
|
||||
Some(&SqlFileImportTarget { db_type: DatabaseType::Mysql, driver_profile: None }),
|
||||
2
|
||||
)
|
||||
.is_err());
|
||||
assert!(validate_selected_tables(request.selected_tables.as_ref().unwrap(), &[]).is_err());
|
||||
}
|
||||
|
||||
fn test_progress(status: SqlFileStatus, statement_index: usize) -> SqlFileProgress {
|
||||
SqlFileProgress {
|
||||
execution_id: "test-execution".to_string(),
|
||||
@@ -2302,6 +2508,7 @@ mod tests {
|
||||
database: String::new(),
|
||||
file_path: path.to_string_lossy().to_string(),
|
||||
continue_on_error: true,
|
||||
selected_tables: None,
|
||||
};
|
||||
let mut progress = Vec::new();
|
||||
|
||||
|
||||
@@ -0,0 +1,395 @@
|
||||
use std::collections::BTreeSet;
|
||||
|
||||
use serde::{Deserialize, Serialize};
|
||||
use sqlparser::dialect::MySqlDialect;
|
||||
use sqlparser::tokenizer::{Token, Tokenizer};
|
||||
|
||||
/// The database is the scope in the dump, not the destination selected in the UI.
|
||||
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct SqlFileTable {
|
||||
pub database: Option<String>,
|
||||
pub name: String,
|
||||
}
|
||||
|
||||
#[derive(Default)]
|
||||
pub(super) struct TableRestoreFilter {
|
||||
database: Option<String>,
|
||||
pub tables: BTreeSet<SqlFileTable>,
|
||||
views: BTreeSet<SqlFileTable>,
|
||||
}
|
||||
|
||||
enum Scope {
|
||||
Table(SqlFileTable),
|
||||
DropTables(Vec<SqlFileTable>, bool),
|
||||
Session,
|
||||
DatabaseSession(String),
|
||||
Skip,
|
||||
}
|
||||
|
||||
impl TableRestoreFilter {
|
||||
pub fn inspect(&mut self, sql: &str) -> Result<(), String> {
|
||||
match self.classify(sql)? {
|
||||
Scope::Table(table) => {
|
||||
self.tables.insert(table);
|
||||
}
|
||||
Scope::DropTables(tables, _) => self.tables.extend(tables),
|
||||
_ => {}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn with_views(views: BTreeSet<SqlFileTable>) -> Self {
|
||||
Self { views, ..Self::default() }
|
||||
}
|
||||
|
||||
pub fn finish(mut self) -> (Vec<SqlFileTable>, BTreeSet<SqlFileTable>) {
|
||||
self.tables.retain(|table| !self.views.contains(table));
|
||||
(self.tables.into_iter().collect(), self.views)
|
||||
}
|
||||
|
||||
pub fn filter(&mut self, sql: &str, selected: &[SqlFileTable]) -> Result<Option<String>, String> {
|
||||
let scope = self.classify(sql)?;
|
||||
let includes = |table: &SqlFileTable| !self.views.contains(table) && selected.contains(table);
|
||||
match scope {
|
||||
Scope::Table(table) => {
|
||||
let included = includes(&table);
|
||||
self.tables.insert(table);
|
||||
Ok(included.then(|| sql.to_string()))
|
||||
}
|
||||
Scope::DropTables(tables, if_exists) => {
|
||||
let kept = tables.iter().filter(|table| includes(table)).map(quoted_table).collect::<Vec<_>>();
|
||||
self.tables.extend(tables);
|
||||
Ok((!kept.is_empty())
|
||||
.then(|| format!("DROP TABLE {}{}", if if_exists { "IF EXISTS " } else { "" }, kept.join(", "))))
|
||||
}
|
||||
Scope::Session => Ok(Some(sql.to_string())),
|
||||
Scope::DatabaseSession(database) => {
|
||||
Ok(selected.iter().any(|table| table.database.as_ref() == Some(&database)).then(|| sql.to_string()))
|
||||
}
|
||||
Scope::Skip => Ok(None),
|
||||
}
|
||||
}
|
||||
|
||||
fn classify(&mut self, sql: &str) -> Result<Scope, String> {
|
||||
// INSERT payloads can be gigabytes. Only tokenize the header; the existing
|
||||
// streaming splitter remains responsible for statement boundaries.
|
||||
let limit = sql.char_indices().nth(16_384).map_or(sql.len(), |(offset, _)| offset);
|
||||
let mut tokens = Vec::new();
|
||||
let tokenized = Tokenizer::new(&MySqlDialect {}, &sql[..limit]).tokenize_with_location_into_buf(&mut tokens);
|
||||
let tokens = tokens
|
||||
.into_iter()
|
||||
.map(|token| token.token)
|
||||
.filter(|token| !matches!(token, Token::Whitespace(_) | Token::EOF))
|
||||
.collect::<Vec<_>>();
|
||||
let mut cursor = Tokens { tokens: &tokens, index: 0 };
|
||||
if tokens.is_empty() && tokenized.is_ok() && limit == sql.len() {
|
||||
return Ok(Scope::Skip);
|
||||
}
|
||||
if cursor.eat("INSERT") || cursor.eat("REPLACE") {
|
||||
for modifier in ["LOW_PRIORITY", "DELAYED", "HIGH_PRIORITY", "IGNORE"] {
|
||||
cursor.eat(modifier);
|
||||
}
|
||||
cursor.eat("INTO");
|
||||
return cursor.table(&self.database).map(Scope::Table).ok_or_else(|| unsupported(sql));
|
||||
}
|
||||
// Object ownership is in the header even if a long definition was
|
||||
// truncated inside a string literal by the tokenizer limit.
|
||||
if cursor.eat("CREATE") {
|
||||
if cursor.eat("TEMPORARY") {
|
||||
return Err(unsupported(sql));
|
||||
}
|
||||
if cursor.eat("TABLE") {
|
||||
cursor.eat_if_not_exists();
|
||||
return cursor.table(&self.database).map(Scope::Table).ok_or_else(|| unsupported(sql));
|
||||
}
|
||||
// Dumps may use CREATE ... DEFINER ... SQL SECURITY ... VIEW.
|
||||
// Track views to exclude mysqldump's temporary table placeholders too.
|
||||
if let Some(index) = tokens.iter().take_while(|token| **token != Token::LParen).position(|token| {
|
||||
["VIEW", "PROCEDURE", "FUNCTION", "TRIGGER", "EVENT"].iter().any(|kind| word_is(token, kind))
|
||||
}) {
|
||||
if word_is(&tokens[index], "VIEW") {
|
||||
cursor.index = index + 1;
|
||||
self.views.insert(cursor.table(&self.database).ok_or_else(|| unsupported(sql))?);
|
||||
}
|
||||
return Ok(Scope::Skip);
|
||||
}
|
||||
}
|
||||
tokenized.map_err(|_| unsupported(sql))?;
|
||||
if limit != sql.len() {
|
||||
return Err(unsupported(sql));
|
||||
}
|
||||
cursor.index = 0;
|
||||
if cursor.eat("USE") {
|
||||
let database = cursor.identifier().ok_or_else(|| unsupported(sql))?;
|
||||
self.database = Some(database.clone());
|
||||
return Ok(Scope::DatabaseSession(database));
|
||||
}
|
||||
if cursor.eat("SET") {
|
||||
if cursor.eat("STATEMENT") {
|
||||
// MariaDB's SET STATEMENT ... FOR can wrap arbitrary mutations.
|
||||
return Err(unsupported(sql));
|
||||
}
|
||||
// Server-wide settings (including GTID_PURGED) are not part of a table restore.
|
||||
return Ok(
|
||||
if tokens.iter().any(|token| {
|
||||
word_is(token, "GLOBAL")
|
||||
|| word_is(token, "@@GLOBAL")
|
||||
|| word_is(token, "PERSIST")
|
||||
|| word_is(token, "PERSIST_ONLY")
|
||||
}) {
|
||||
Scope::Skip
|
||||
} else {
|
||||
Scope::Session
|
||||
},
|
||||
);
|
||||
}
|
||||
if cursor.eat("BEGIN") {
|
||||
cursor.eat("WORK");
|
||||
cursor.eat_token(&Token::SemiColon);
|
||||
return if cursor.index == tokens.len() { Ok(Scope::Session) } else { Err(unsupported(sql)) };
|
||||
}
|
||||
if cursor.eat("START") && cursor.eat("TRANSACTION")
|
||||
|| word_is(&tokens[0], "COMMIT")
|
||||
|| word_is(&tokens[0], "ROLLBACK")
|
||||
{
|
||||
return Ok(Scope::Session);
|
||||
}
|
||||
if word_is(&tokens[0], "LOCK") || word_is(&tokens[0], "UNLOCK") {
|
||||
// The SQL-file executor already omits dump table locks.
|
||||
return Ok(Scope::Skip);
|
||||
}
|
||||
cursor.index = 0;
|
||||
if cursor.eat("CREATE") {
|
||||
if cursor.eat("DATABASE") || cursor.eat("SCHEMA") {
|
||||
// Keep only idempotent bootstrap, never destructive database DDL.
|
||||
if cursor.eat("IF") && cursor.eat("NOT") && cursor.eat("EXISTS") {
|
||||
return Ok(Scope::DatabaseSession(cursor.identifier().ok_or_else(|| unsupported(sql))?));
|
||||
}
|
||||
return Ok(Scope::Skip);
|
||||
}
|
||||
cursor.eat("UNIQUE");
|
||||
cursor.eat("FULLTEXT");
|
||||
cursor.eat("SPATIAL");
|
||||
if cursor.eat("INDEX") {
|
||||
if let Some(index) = tokens.iter().position(|token| word_is(token, "ON")) {
|
||||
cursor.index = index + 1;
|
||||
return cursor.table(&self.database).map(Scope::Table).ok_or_else(|| unsupported(sql));
|
||||
}
|
||||
}
|
||||
}
|
||||
cursor.index = 0;
|
||||
if cursor.eat("DROP") {
|
||||
if cursor.eat("TEMPORARY") {
|
||||
return Err(unsupported(sql));
|
||||
}
|
||||
if cursor.eat("TABLE") {
|
||||
let if_exists = cursor.eat("IF") && cursor.eat("EXISTS");
|
||||
let mut tables = vec![cursor.table(&self.database).ok_or_else(|| unsupported(sql))?];
|
||||
while cursor.eat_token(&Token::Comma) {
|
||||
tables.push(cursor.table(&self.database).ok_or_else(|| unsupported(sql))?);
|
||||
}
|
||||
cursor.eat("RESTRICT");
|
||||
cursor.eat("CASCADE");
|
||||
cursor.eat_token(&Token::SemiColon);
|
||||
if cursor.index != tokens.len() {
|
||||
return Err(unsupported(sql));
|
||||
}
|
||||
return Ok(Scope::DropTables(tables, if_exists));
|
||||
}
|
||||
if ["DATABASE", "SCHEMA", "VIEW", "PROCEDURE", "FUNCTION", "TRIGGER", "EVENT"]
|
||||
.iter()
|
||||
.any(|kind| cursor.eat(kind))
|
||||
{
|
||||
return Ok(Scope::Skip);
|
||||
}
|
||||
}
|
||||
cursor.index = 0;
|
||||
if cursor.eat("ALTER") && cursor.eat("TABLE") {
|
||||
let table = cursor.table(&self.database).ok_or_else(|| unsupported(sql))?;
|
||||
// Renaming/exchanging a table can also mutate an unselected table.
|
||||
if tokens[cursor.index..].iter().any(|token| word_is(token, "RENAME") || word_is(token, "EXCHANGE")) {
|
||||
return Err(unsupported(sql));
|
||||
}
|
||||
return Ok(Scope::Table(table));
|
||||
}
|
||||
Err(unsupported(sql))
|
||||
}
|
||||
}
|
||||
|
||||
fn unsupported(sql: &str) -> String {
|
||||
format!("Cannot safely restore selected tables from this statement: {}", crate::sql::statement_summary(sql))
|
||||
}
|
||||
|
||||
fn word_is(token: &Token, expected: &str) -> bool {
|
||||
matches!(token, Token::Word(word) if word.quote_style.is_none() && word.value.eq_ignore_ascii_case(expected))
|
||||
}
|
||||
|
||||
struct Tokens<'a> {
|
||||
tokens: &'a [Token],
|
||||
index: usize,
|
||||
}
|
||||
|
||||
impl Tokens<'_> {
|
||||
fn eat(&mut self, word: &str) -> bool {
|
||||
if self.tokens.get(self.index).is_some_and(|token| word_is(token, word)) {
|
||||
self.index += 1;
|
||||
true
|
||||
} else {
|
||||
false
|
||||
}
|
||||
}
|
||||
|
||||
fn eat_token(&mut self, token: &Token) -> bool {
|
||||
if self.tokens.get(self.index) == Some(token) {
|
||||
self.index += 1;
|
||||
true
|
||||
} else {
|
||||
false
|
||||
}
|
||||
}
|
||||
|
||||
fn eat_if_not_exists(&mut self) {
|
||||
if self.eat("IF") {
|
||||
self.eat("NOT");
|
||||
self.eat("EXISTS");
|
||||
}
|
||||
}
|
||||
|
||||
fn identifier(&mut self) -> Option<String> {
|
||||
let Token::Word(word) = self.tokens.get(self.index)? else {
|
||||
return None;
|
||||
};
|
||||
self.index += 1;
|
||||
Some(word.value.clone())
|
||||
}
|
||||
|
||||
fn table(&mut self, database: &Option<String>) -> Option<SqlFileTable> {
|
||||
let first = self.identifier()?;
|
||||
if self.eat_token(&Token::Period) {
|
||||
Some(SqlFileTable { database: Some(first), name: self.identifier()? })
|
||||
} else {
|
||||
Some(SqlFileTable { database: database.clone(), name: first })
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn quoted_table(table: &SqlFileTable) -> String {
|
||||
let quote = |name: &str| format!("`{}`", name.replace('`', "``"));
|
||||
match &table.database {
|
||||
Some(database) => format!("{}.{}", quote(database), quote(&table.name)),
|
||||
None => quote(&table.name),
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::models::connection::DatabaseType;
|
||||
use crate::sql::split_sql_statements_for_database;
|
||||
|
||||
fn table(database: Option<&str>, name: &str) -> SqlFileTable {
|
||||
SqlFileTable { database: database.map(str::to_string), name: name.to_string() }
|
||||
}
|
||||
|
||||
fn restore(sql: &str, selected: &[SqlFileTable]) -> Result<Vec<String>, String> {
|
||||
let statements = split_sql_statements_for_database(sql, DatabaseType::Mysql);
|
||||
let mut scan = TableRestoreFilter::default();
|
||||
for statement in &statements {
|
||||
scan.inspect(statement)?;
|
||||
}
|
||||
let (_, views) = scan.finish();
|
||||
let mut filter = TableRestoreFilter::with_views(views);
|
||||
statements.iter().filter_map(|sql| filter.filter(sql, selected).transpose()).collect()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn restores_only_selected_structure_and_data_with_session_context() {
|
||||
let sql = "SET FOREIGN_KEY_CHECKS=0; CREATE TABLE `a` (id INT); INSERT INTO a VALUES (1, 'DROP TABLE b;'); CREATE TABLE b (id INT); INSERT INTO b VALUES (2); SET FOREIGN_KEY_CHECKS=1;";
|
||||
assert_eq!(
|
||||
restore(sql, &[table(None, "a")]).unwrap(),
|
||||
vec![
|
||||
"SET FOREIGN_KEY_CHECKS=0",
|
||||
"CREATE TABLE `a` (id INT)",
|
||||
"INSERT INTO a VALUES (1, 'DROP TABLE b;')",
|
||||
"SET FOREIGN_KEY_CHECKS=1",
|
||||
]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn distinguishes_databases_and_escaped_identifiers() {
|
||||
let sql = "USE first; INSERT INTO `a``b` VALUES (1); USE second; INSERT INTO `a``b` VALUES (2); INSERT INTO first.`a``b` VALUES (3);";
|
||||
let statements = restore(sql, &[table(Some("first"), "a`b")]).unwrap();
|
||||
assert_eq!(statements.iter().filter(|sql| sql.starts_with("INSERT")).count(), 2);
|
||||
assert!(!statements.iter().any(|sql| sql.contains("(2)")));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn filters_multi_table_drop_without_dropping_unselected_tables() {
|
||||
assert_eq!(
|
||||
restore("DROP TABLE IF EXISTS a, b;", &[table(None, "a")]).unwrap(),
|
||||
vec!["DROP TABLE IF EXISTS `a`"]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn excludes_view_placeholders_routines_and_global_changes() {
|
||||
let sql = "CREATE TABLE v (id INT); DROP TABLE IF EXISTS v; CREATE VIEW v AS SELECT * FROM a; DROP DATABASE other; SET @@GLOBAL.GTID_PURGED='x'; CREATE TABLE a (id INT);";
|
||||
assert_eq!(restore(sql, &[table(None, "a"), table(None, "v")]).unwrap(), vec!["CREATE TABLE a (id INT)"]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn handles_version_comments_key_toggles_and_insert_modifiers() {
|
||||
let sql = "/*!40000 ALTER TABLE a DISABLE KEYS */; INSERT IGNORE INTO a VALUES (1); REPLACE INTO b VALUES (2); /*!40000 ALTER TABLE a ENABLE KEYS */;";
|
||||
assert_eq!(restore(sql, &[table(None, "a")]).unwrap().len(), 3);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rejects_unknown_and_multi_target_mutations_before_execution() {
|
||||
for sql in [
|
||||
"CALL remove_all()",
|
||||
"UPDATE a JOIN b SET b.id=1",
|
||||
"ALTER TABLE a RENAME TO b",
|
||||
"RENAME TABLE a TO b",
|
||||
"DROP TEMPORARY TABLE a",
|
||||
"CREATE TEMPORARY TABLE a (id INT)",
|
||||
"SET STATEMENT max_statement_time=1 FOR DELETE FROM b",
|
||||
"BEGIN NOT ATOMIC DELETE FROM b; END",
|
||||
] {
|
||||
assert!(restore(sql, &[table(None, "a")]).is_err(), "{sql}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn identifies_large_insert_without_tokenizing_its_values() {
|
||||
let sql = format!("INSERT INTO a VALUES ('{}');", "x".repeat(1_000_000));
|
||||
assert_eq!(restore(&sql, &[table(None, "a")]).unwrap().len(), 1);
|
||||
assert!(restore(&sql, &[table(None, "b")]).unwrap().is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn identifies_large_definitions_without_parsing_their_bodies() {
|
||||
let body = "x".repeat(100_000);
|
||||
let ddl = format!("CREATE TABLE a (body TEXT COMMENT '{body}')");
|
||||
let sql = format!("{ddl}; CREATE VIEW v AS SELECT '{body}';\nDELIMITER ;;\nCREATE PROCEDURE p() BEGIN SELECT '{body}'; END;;\nDELIMITER ;\n");
|
||||
assert_eq!(restore(&sql, &[table(None, "a")]).unwrap(), vec![ddl]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn skips_mysqldump_view_placeholders_and_delimited_triggers() {
|
||||
let sql = "/*!40101 SET @OLD_CHARACTER_SET_CLIENT=@@CHARACTER_SET_CLIENT */;
|
||||
CREATE TABLE a (id INT);
|
||||
CREATE TABLE v (id INT);
|
||||
DELIMITER ;;
|
||||
/*!50003 CREATE*/ /*!50017 DEFINER=`root`@`localhost`*/ /*!50003 TRIGGER tr AFTER INSERT ON a FOR EACH ROW BEGIN INSERT INTO audit VALUES (NEW.id); END */;;
|
||||
DELIMITER ;
|
||||
DROP TABLE IF EXISTS v;
|
||||
/*!50001 CREATE ALGORITHM=UNDEFINED */ /*!50013 DEFINER=`root`@`localhost` SQL SECURITY DEFINER */ /*!50001 VIEW v AS SELECT id FROM a */;
|
||||
INSERT INTO a VALUES (1);
|
||||
/*!40101 SET CHARACTER_SET_CLIENT=@OLD_CHARACTER_SET_CLIENT */;";
|
||||
let statements = restore(sql, &[table(None, "a"), table(None, "v")]).unwrap();
|
||||
assert_eq!(statements.len(), 4);
|
||||
assert!(statements.iter().any(|sql| sql == "INSERT INTO a VALUES (1)"));
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user