Skip to content

armgit / dbx

Public Imported from GitHub
0

25 MB lightweight cross-platform database client for 100+ databases, including MySQL, PostgreSQL, SQLite, Redis, MongoDB, DuckDB, SQL Server, and Dameng. Built-in AI, MCP Server, CLI, desktop and Docker. | 轻量级跨平台数据库管理工具,支持 MySQL、PostgreSQL、SQLite、Redis、MongoDB、达梦等 100+ 数据库,提供桌面端、Docker、CLI、内置 AI 助手和 MCP。

fix(read-only): allow REPLACE()/INSERT() scalar functions in queries

zipg4975b72b69dc
diff --git a/crates/dbx-sql/src/query_execution_sql.rs b/crates/dbx-sql/src/query_execution_sql.rs
index fc2539621c..10e967aae5 100644
--- a/crates/dbx-sql/src/query_execution_sql.rs
+++ b/crates/dbx-sql/src/query_execution_sql.rs
@@ -255,11 +255,65 @@ fn is_safe_oracle_explain_dml_source(sql: &str) -> bool {
["INSERT", "UPDATE", "DELETE", "MERGE"].iter().any(|keyword| starts_with_keyword(&source, keyword))
}
+/// Write verbs that mark a read-leading statement as a write, for example a
+/// data-modifying CTE (`WITH x AS (DELETE FROM t RETURNING *) SELECT * FROM x`).
+const DANGEROUS_SQL_KEYWORDS: &[&str] =
+ &["drop", "delete", "truncate", "alter", "update", "merge", "replace", "insert", "create"];
+
+/// Write verbs that are also scalar function names, so `REPLACE(col, 'a', 'b')`
+/// and `INSERT(str, pos, len, new)` are ordinary parts of a read-only query.
+///
+/// Only these two verbs are exempted when they are called with parentheses.
+/// `update` stays dangerous even then: MySQL accepts a parenthesized table
+/// reference (`UPDATE (t) SET c = 1`, verified on MySQL 8.4), while
+/// `REPLACE (`/`INSERT (` are rejected there as statements, so a parenthesized
+/// call can never hide a write for the exempted verbs.
+const WRITE_VERBS_WITH_SCALAR_FUNCTION_FORMS: &[&str] = &["replace", "insert"];
+
pub fn contains_dangerous_sql_keyword(sql: &str) -> bool {
let source = strip_sql_comments_and_literals(sql).to_lowercase();
- ["drop", "delete", "truncate", "alter", "update", "merge", "replace", "insert", "create"]
- .iter()
- .any(|keyword| contains_word(&source, keyword))
+ DANGEROUS_SQL_KEYWORDS.iter().any(|keyword| contains_dangerous_sql_verb(&source, keyword))
+}
+
+/// Match a write verb as a whole word. A verb called with parentheses is a
+/// scalar function for [`WRITE_VERBS_WITH_SCALAR_FUNCTION_FORMS`] (`SELECT
+/// REPLACE(name, 'a', 'b') FROM users` must stay read-only), including when the
+/// dialect allows whitespace before the parenthesis.
+fn contains_dangerous_sql_verb(source: &str, keyword: &str) -> bool {
+ let bytes = source.as_bytes();
+ let keyword_bytes = keyword.as_bytes();
+ if keyword_bytes.is_empty() || bytes.len() < keyword_bytes.len() {
+ return false;
+ }
+ let allows_function_form = WRITE_VERBS_WITH_SCALAR_FUNCTION_FORMS.contains(&keyword);
+
+ for idx in 0..=bytes.len() - keyword_bytes.len() {
+ if &bytes[idx..idx + keyword_bytes.len()] != keyword_bytes {
+ continue;
+ }
+ if is_identifier_byte(idx.checked_sub(1).and_then(|i| bytes.get(i)).copied()) {
+ continue;
+ }
+ let rest = &bytes[idx + keyword_bytes.len()..];
+ match rest.first().copied() {
+ None => return true,
+ Some(b'(') if allows_function_form => continue,
+ Some(byte) if is_identifier_byte(Some(byte)) => continue,
+ Some(byte) => {
+ if allows_function_form && byte.is_ascii_whitespace() && starts_with_parenthesis(rest) {
+ continue;
+ }
+ return true;
+ }
+ }
+ }
+ false
+}
+
+/// True when the first non-whitespace byte is `(` (SQL Server style `REPLACE (a, b, c)`).
+fn starts_with_parenthesis(rest: &[u8]) -> bool {
+ let offset = rest.iter().take_while(|byte| byte.is_ascii_whitespace()).count();
+ rest.get(offset) == Some(&b'(')
}
/// Keywords that start a read-only SQL statement.
@@ -1744,6 +1798,55 @@ mod tests {
assert!(!contains_dangerous_sql_keyword("SELECT inserted FROM t"));
}
+ #[test]
+ fn contains_dangerous_sql_keyword_ignores_scalar_functions_named_like_writes() {
+ // #9978: REPLACE()/INSERT() are scalar functions, not statements.
+ assert!(!contains_dangerous_sql_keyword("SELECT REPLACE(name, 'a', 'b') FROM users"));
+ assert!(!contains_dangerous_sql_keyword("SELECT REPLACE (name, 'a', 'b') FROM users"));
+ assert!(!contains_dangerous_sql_keyword("SELECT INSERT('Quadratic', 3, 4, 'What')"));
+ assert!(!contains_dangerous_sql_keyword("SELECT dropped, inserted FROM t"));
+ assert!(contains_dangerous_sql_keyword("REPLACE INTO users VALUES (1)"));
+ assert!(contains_dangerous_sql_keyword("REPLACE users SET name = 'x'"));
+ assert!(contains_dangerous_sql_keyword("INSERT INTO users VALUES (1)"));
+ // `UPDATE (t)` is a real write: MySQL accepts a parenthesized table reference.
+ assert!(contains_dangerous_sql_keyword("UPDATE (users) SET name = 'x'"));
+ }
+
+ #[test]
+ fn is_write_sql_allows_mysql_json_table_query_with_replace_function() {
+ // #9978: a JSON_TABLE query using REPLACE() must not be treated as a write,
+ // otherwise read-only connections ask for write permission before running it.
+ let sql = "with tmp as (\n select '张三,李四,王五' as `names`\n)\nSELECT jt.name\nFROM tmp t\nJOIN JSON_TABLE(\n CONCAT('[\"',REPLACE(t.`names`,',','\",\"'),'\"]'),\n '$[*]' COLUMNS(name VARCHAR(50) PATH '$')\n) jt";
+ assert!(!is_write_sql_for_database(sql, DatabaseType::Mysql), "JSON_TABLE + REPLACE() must stay read-only");
+ assert!(!is_write_sql_for_database("SELECT REPLACE(name, 'a', 'b') FROM users", DatabaseType::Mysql));
+ assert!(!is_write_sql_for_database("SELECT INSERT('Quadratic', 3, 4, 'What')", DatabaseType::Mysql));
+ assert!(!is_write_sql_for_database("SELECT REPLACE (name, 'a', 'b') FROM users", DatabaseType::SqlServer));
+ assert!(!is_write_sql_for_database("SELECT replace(name, 'a', 'b') FROM users", DatabaseType::Postgres));
+ assert!(!is_write_sql(sql));
+ }
+
+ #[test]
+ fn is_write_sql_still_blocks_writes_using_function_like_verbs() {
+ assert!(is_write_sql_for_database("REPLACE INTO users VALUES (1)", DatabaseType::Mysql));
+ assert!(is_write_sql_for_database("REPLACE users SET name = 'x'", DatabaseType::Mysql));
+ assert!(is_write_sql_for_database("INSERT INTO users VALUES (1)", DatabaseType::Mysql));
+ // MySQL accepts a parenthesized table reference, so `UPDATE (` is a write.
+ assert!(is_write_sql_for_database("UPDATE (users) SET name = 'x'", DatabaseType::Mysql));
+ assert!(is_write_sql_for_database(
+ "WITH x AS (SELECT 1 AS n) UPDATE (users) SET name = 'x'",
+ DatabaseType::Mysql
+ ));
+ // Data-modifying CTEs keep being detected.
+ assert!(is_write_sql_for_database(
+ "WITH x AS (INSERT INTO users VALUES (1) RETURNING *) SELECT * FROM x",
+ DatabaseType::Postgres
+ ));
+ assert!(is_write_sql_for_database(
+ "WITH x AS (DELETE FROM users RETURNING *) SELECT * FROM x",
+ DatabaseType::Postgres
+ ));
+ }
+
#[test]
fn contains_dangerous_sql_keyword_ignores_in_string_literals() {
assert!(!contains_dangerous_sql_keyword("SELECT 'DROP TABLE users' FROM t"));