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。
TypeScript aicliclickhousedatabasedatabase-clientdatabase-managementdockerguimcpmongodbmysqlpostgresqlredisrustsql-serversqlitetaurivue
fix(sql): sort WITH query results via ORDER BY on the main query
Abel Yagubyan504e30936934
diff --git a/crates/dbx-sql-data/src/query_result_sql.rs b/crates/dbx-sql-data/src/query_result_sql.rsindex 0750b68479..d30bd9a1a5 100644--- a/crates/dbx-sql-data/src/query_result_sql.rs+++ b/crates/dbx-sql-data/src/query_result_sql.rs@@ -546,10 +546,14 @@ pub fn build_sorted_query_sql(options: SortedQuerySqlOptions) -> QuerySqlBuildRe} else {("", statement.as_str())};- if statement.trim_start().to_ascii_uppercase().starts_with("WITH") {- return err("with");- }- if !statement.trim_start().to_ascii_uppercase().starts_with("SELECT") {+ // SQL Server and other engines reject WITH inside a derived table, so a CTE+ // query is sorted by appending ORDER BY <position> to its main query.+ let is_cte = statement.trim_start().to_ascii_uppercase().starts_with("WITH");+ if is_cte {+ if !cte_main_statement_is_select(statement) || has_top_level_select_into(statement) {+ return err("with");+ }+ } else if !statement.trim_start().to_ascii_uppercase().starts_with("SELECT") {return err("not_select");}@@ -577,14 +581,16 @@ pub fn build_sorted_query_sql(options: SortedQuerySqlOptions) -> QuerySqlBuildReSome(DatabaseType::Mysql | DatabaseType::Goldendb) => has_duplicate_labels(str::eq_ignore_ascii_case),_ => false,};- if derived_table_rejects_duplicate_labels+ if is_cte+ || derived_table_rejects_duplicate_labels|| (options.database_type == Some(DatabaseType::OceanbaseOracle)&& !rownum_wrapper_projection_is_safe(statement)){- let parsed = if matches!(options.database_type, Some(DatabaseType::Mysql | DatabaseType::Goldendb)) {- Parser::parse_sql(&MySqlDialect {}, statement)- } else {- Parser::parse_sql(&GenericDialect {}, statement)+ let parsed = match options.database_type {+ Some(DatabaseType::Mysql | DatabaseType::Goldendb) => Parser::parse_sql(&MySqlDialect {}, statement),+ Some(DatabaseType::SqlServer) => Parser::parse_sql(&MsSqlDialect {}, statement),+ Some(DatabaseType::ClickHouse) => Parser::parse_sql(&ClickHouseDialect {}, statement),+ _ => Parser::parse_sql(&GenericDialect {}, statement),};let Ok(statements) = parsed else {return err("unsupported");@@ -7097,7 +7103,7 @@ WHERE u.id = picked.id;(" \n\t", "empty"),(";", "empty"),("SELECT 1; SELECT 2;", "multi"),- ("WITH cte AS (SELECT 1 AS id) SELECT id FROM cte", "with"),+ ("WITH cte AS (SELECT 1 AS id) INSERT INTO users SELECT id FROM cte", "with"),("SHOW TABLES", "not_select"),("UPDATE users SET id = 2", "not_select"),] {@@ -7612,19 +7618,152 @@ WHERE u.id = picked.id;assert_eq!(result.sql.unwrap(), "SELECT * FROM (SELECT id, name FROM users) t(id, name) ORDER BY id ASC;");}+ fn sorted_cte_sql(+ original_sql: &str,+ database_type: Option<DatabaseType>,+ result_columns: &[&str],+ column_index: usize,+ direction: QuerySortDirection,+ tie_breaker_column_indexes: Vec<usize>,+ ) -> QuerySqlBuildResult {+ build_sorted_query_sql(SortedQuerySqlOptions {+ original_sql: original_sql.to_string(),+ database_type,+ result_columns: result_columns.iter().map(|column| column.to_string()).collect(),+ column_index,+ column: result_columns.get(column_index).map(|column| column.to_string()).unwrap_or_default(),+ direction,+ tie_breaker_column_indexes,+ })+ }+#[test]- fn rejects_with_query_sorting() {- let result = build_sorted_query_sql(SortedQuerySqlOptions {- original_sql: "WITH cte AS (SELECT 1) SELECT * FROM cte".to_string(),- database_type: Some(DatabaseType::Postgres),- result_columns: vec!["id".to_string()],- column_index: 0,- column: "id".to_string(),- direction: QuerySortDirection::Asc,- tie_breaker_column_indexes: Vec::new(),- });+ fn sorts_with_query_by_appending_order_by_to_main_query() {+ for database_type in [+ None,+ Some(DatabaseType::Postgres),+ Some(DatabaseType::Mysql),+ Some(DatabaseType::SqlServer),+ Some(DatabaseType::Oracle),+ Some(DatabaseType::Dameng),+ Some(DatabaseType::Sqlite),+ Some(DatabaseType::ClickHouse),+ Some(DatabaseType::Hive),+ ] {+ let result = sorted_cte_sql(+ "WITH t AS (SELECT a, b, c FROM src) SELECT a, b, sum(c) AS total FROM t GROUP BY a, b",+ database_type,+ &["a", "b", "total"],+ 2,+ QuerySortDirection::Desc,+ Vec::new(),+ );- assert_eq!(result, err("with"));+ assert_eq!(+ result,+ ok("WITH t AS (SELECT a, b, c FROM src) SELECT a, b, sum(c) AS total FROM t GROUP BY a, b ORDER BY 3 DESC;"+ .to_string()),+ "{database_type:?}"+ );+ }+ }++ #[test]+ fn sorts_with_query_by_replacing_its_trailing_order_by() {+ let result = sorted_cte_sql(+ "WITH cte AS (SELECT id, name FROM users) SELECT id, name FROM cte ORDER BY id DESC;",+ Some(DatabaseType::Postgres),+ &["id", "name"],+ 1,+ QuerySortDirection::Asc,+ vec![0],+ );++ assert_eq!(+ result,+ ok("WITH cte AS (SELECT id, name FROM users) SELECT id, name FROM cte ORDER BY 2 ASC, 1 ASC;".to_string())+ );+ }++ #[test]+ fn sorts_with_query_keeping_order_by_inside_the_cte() {+ let result = sorted_cte_sql(+ "WITH top_users AS (SELECT TOP 5 id, name FROM users ORDER BY id) SELECT id, name FROM top_users",+ Some(DatabaseType::SqlServer),+ &["id", "name"],+ 1,+ QuerySortDirection::Desc,+ Vec::new(),+ );++ assert_eq!(+ result,+ ok("WITH top_users AS (SELECT TOP 5 id, name FROM users ORDER BY id) SELECT id, name FROM top_users ORDER BY 2 DESC;"+ .to_string())+ );+ }++ #[test]+ fn sorts_recursive_with_query() {+ for database_type in [Some(DatabaseType::Postgres), Some(DatabaseType::Mysql), Some(DatabaseType::Sqlite)] {+ let result = sorted_cte_sql(+ "WITH RECURSIVE nums(n) AS (SELECT 1 UNION ALL SELECT n + 1 FROM nums WHERE n < 5) SELECT n FROM nums",+ database_type,+ &["n"],+ 0,+ QuerySortDirection::Desc,+ Vec::new(),+ );++ assert_eq!(+ result,+ ok("WITH RECURSIVE nums(n) AS (SELECT 1 UNION ALL SELECT n + 1 FROM nums WHERE n < 5) SELECT n FROM nums ORDER BY 1 DESC;"+ .to_string()),+ "{database_type:?}"+ );+ }+ }++ #[test]+ fn sorts_with_query_whose_main_query_is_a_union() {+ let result = sorted_cte_sql(+ "WITH a AS (SELECT 1 AS id), b AS (SELECT 2 AS id) SELECT id FROM a UNION ALL SELECT id FROM b",+ Some(DatabaseType::Postgres),+ &["id"],+ 0,+ QuerySortDirection::Desc,+ Vec::new(),+ );++ assert_eq!(+ result,+ ok("WITH a AS (SELECT 1 AS id), b AS (SELECT 2 AS id) SELECT id FROM a UNION ALL SELECT id FROM b ORDER BY 1 DESC;"+ .to_string())+ );+ }++ #[test]+ fn rejects_with_query_sorting_when_order_by_cannot_be_appended() {+ for (original_sql, database_type, reason) in [+ ("WITH cte AS (SELECT 1 AS id) SELECT id FROM cte LIMIT 10", Some(DatabaseType::Postgres), "unsupported"),+ (+ "WITH cte AS (SELECT 1 AS id) SELECT id FROM cte FETCH FIRST 10 ROWS ONLY",+ Some(DatabaseType::Oracle),+ "unsupported",+ ),+ ("WITH cte AS (SELECT 1 AS id) SELECT TOP 10 id FROM cte", Some(DatabaseType::SqlServer), "unsupported"),+ ("WITH cte AS (SELECT 1 AS id) SELECT id FROM cte FOR UPDATE", Some(DatabaseType::Mysql), "unsupported"),+ ("WITH cte AS (SELECT 1 AS id) SELECT id INTO #ids FROM cte", Some(DatabaseType::SqlServer), "with"),+ (+ "WITH cte AS (SELECT 1 AS id) DELETE FROM users WHERE id IN (SELECT id FROM cte)",+ Some(DatabaseType::Postgres),+ "with",+ ),+ ] {+ let result = sorted_cte_sql(original_sql, database_type, &["id"], 0, QuerySortDirection::Asc, Vec::new());++ assert_eq!(result, err(reason), "{original_sql:?}");+ }}// -----------------------------------------------------------------------