fix(sql): improve read-only statement detection

This commit is contained in:
二丫讲梵 authored and GitHub committed 2026-07-12 23:05:32 +08:00
1 parent 1ecd8cf406
commit 0e779f9edc
5 files changed
+495 -45

No files matched your search

+93 -8
View File
@@ -5,6 +5,8 @@ use sqlparser::dialect::{
};
use sqlparser::parser::Parser;
use crate::models::connection::DatabaseType;
/// SQL risk level for agent tool safety classification.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum SqlRisk {
@@ -33,7 +35,8 @@ impl std::fmt::Display for SqlRisk {
/// Mirrors the logic in `sql_analysis::normalize_dialect`.
fn normalize_dialect(dialect: &str) -> &'static str {
match dialect.to_ascii_lowercase().as_str() {
"postgres" | "postgresql" | "redshift" | "opengauss" | "gaussdb" | "highgo" => "postgres",
"postgres" | "postgresql" | "redshift" | "opengauss" | "gaussdb" | "kingbase" | "highgo" | "vastbase"
| "kwdb" => "postgres",
"mysql" | "mariadb" | "doris" | "starrocks" | "manticoresearch" | "oceanbase" => "mysql",
"sqlite" => "sqlite",
"sqlserver" | "mssql" => "sqlserver",
@@ -57,11 +60,11 @@ fn resolve_dialect(dialect: &str) -> Box<dyn sqlparser::dialect::Dialect> {
}
/// Classify a single SQL statement into a risk level using AST analysis.
fn classify_statement(stmt: &Statement) -> SqlRisk {
fn classify_statement(stmt: &Statement, detect_select_into: bool) -> SqlRisk {
match stmt {
// Pure reads
Statement::Query(query) => {
if query_contains_select_into(query) {
if detect_select_into && query_contains_select_into(query) {
SqlRisk::Write
} else {
SqlRisk::ReadOnly
@@ -69,7 +72,7 @@ fn classify_statement(stmt: &Statement) -> SqlRisk {
}
Statement::Explain { analyze, statement, .. } => {
if *analyze {
classify_statement(statement)
classify_statement(statement, detect_select_into)
} else {
SqlRisk::ReadOnly
}
@@ -148,22 +151,49 @@ fn set_expr_contains_select_into(expr: &SetExpr) -> bool {
/// Multi-statement input: returns the highest risk level across all statements.
pub fn classify_sql_risk(sql: &str, dialect: &str) -> Result<SqlRisk, String> {
let normalized = normalize_dialect(dialect);
let parser_dialect = resolve_dialect(normalized);
classify_sql_risk_with_database(sql, normalized, None)
}
/// Classify SQL risk using both the parser dialect and the concrete database
/// type so dialect-specific write forms cannot be mistaken for read queries.
pub fn classify_sql_risk_for_database(sql: &str, database_type: DatabaseType) -> Result<SqlRisk, String> {
let database_type_name = format!("{database_type:?}");
let normalized = normalize_dialect(&database_type_name);
classify_sql_risk_with_database(sql, normalized, Some(database_type))
}
fn classify_sql_risk_with_database(
sql: &str,
normalized_dialect: &str,
database_type: Option<DatabaseType>,
) -> Result<SqlRisk, String> {
let parser_dialect = resolve_dialect(normalized_dialect);
let detect_select_into = database_type.is_none();
let has_dialect_specific_write = database_type
.is_some_and(|database_type| crate::query_execution_sql::has_dialect_specific_write(sql, database_type));
match Parser::parse_sql(parser_dialect.as_ref(), sql) {
Ok(stmts) if !stmts.is_empty() => {
let mut max_risk = SqlRisk::ReadOnly;
for stmt in &stmts {
let risk = classify_statement(stmt);
let risk = classify_statement(stmt, detect_select_into);
if risk as u8 > max_risk as u8 {
max_risk = risk;
}
}
Ok(max_risk)
if max_risk == SqlRisk::ReadOnly && has_dialect_specific_write {
Ok(SqlRisk::Write)
} else {
Ok(max_risk)
}
}
_ => {
// Fallback: keyword-based classification
if crate::query_execution_sql::is_write_sql(sql) {
let is_write = database_type.map_or_else(
|| crate::query_execution_sql::is_write_sql(sql),
|database_type| crate::query_execution_sql::is_write_sql_for_database(sql, database_type),
);
if is_write {
Ok(SqlRisk::Write)
} else {
Ok(SqlRisk::ReadOnly)
@@ -210,6 +240,61 @@ mod tests {
assert_eq!(classify_sql_risk("/*! DELETE FROM users */", "mysql").unwrap(), SqlRisk::Write);
}
#[test]
fn classify_dialect_specific_select_into_as_write() {
for sql in [
"SELECT 3156 INTO OUTFILE '/var/lib/mysql-files/dbx_ro_probe.txt'",
"SELECT 3156 INTO DUMPFILE '/var/lib/mysql-files/dbx_ro_probe.bin'",
] {
assert_eq!(classify_sql_risk_for_database(sql, DatabaseType::Mysql).unwrap(), SqlRisk::Write);
}
for database_type in [
DatabaseType::Postgres,
DatabaseType::Redshift,
DatabaseType::Gaussdb,
DatabaseType::OpenGauss,
DatabaseType::Kingbase,
DatabaseType::Highgo,
DatabaseType::Vastbase,
DatabaseType::Kwdb,
] {
assert_eq!(
classify_sql_risk_for_database("SELECT * INTO copied_users FROM users", database_type).unwrap(),
SqlRisk::Write,
"expected PostgreSQL-family SELECT INTO to be a write for {database_type:?}"
);
}
assert_eq!(
classify_sql_risk_for_database("SELECT * INTO #copied_users FROM users", DatabaseType::SqlServer).unwrap(),
SqlRisk::Write
);
assert_eq!(
classify_sql_risk_for_database(
"SELECT 3156 /*!50000 INTO OUTFILE '/var/lib/mysql-files/dbx_ro_probe.txt' */",
DatabaseType::Mysql,
)
.unwrap(),
SqlRisk::Write
);
}
#[test]
fn typed_classification_preserves_existing_risk_levels() {
assert_eq!(
classify_sql_risk_for_database("SELECT * FROM users", DatabaseType::Postgres).unwrap(),
SqlRisk::ReadOnly
);
assert_eq!(
classify_sql_risk_for_database("CREATE TABLE users (id INT)", DatabaseType::Postgres).unwrap(),
SqlRisk::Ddl
);
assert_eq!(
classify_sql_risk_for_database("SELECT 1 INTO unsupported", DatabaseType::Sqlite).unwrap(),
SqlRisk::ReadOnly
);
}
#[test]
fn classify_ddl_statements() {
assert_eq!(classify_sql_risk("CREATE TABLE users (id INT)", "postgres").unwrap(), SqlRisk::Ddl);