From 886c11f8e69bd480a13b19803ae47f7203f0790c Mon Sep 17 00:00:00 2001 From: t8y2 <1156263951@qq.com> Date: Wed, 24 Jun 2026 14:04:01 +0800 Subject: [PATCH] fix(postgres): cast grid like filters --- apps/desktop/src/components/grid/DataGrid.vue | 82 +++++++++++-------- crates/dbx-core/src/data_grid_sql.rs | 58 ++++++++++++- 2 files changed, 104 insertions(+), 36 deletions(-) diff --git a/apps/desktop/src/components/grid/DataGrid.vue b/apps/desktop/src/components/grid/DataGrid.vue index 244c0ab754..bc08c6c376 100644 --- a/apps/desktop/src/components/grid/DataGrid.vue +++ b/apps/desktop/src/components/grid/DataGrid.vue @@ -137,16 +137,19 @@ import { useDataGridEditor } from "@/composables/useDataGridEditor"; import { useSqlHighlighter } from "@/composables/useSqlHighlighter"; import { useCellDetailEditor, type UseCellDetailEditorReturn } from "@/composables/useCellDetailEditor"; import { useTheme } from "@/composables/useTheme"; +import { useConnectionStore } from "@/stores/connectionStore"; import { useSettingsStore } from "@/stores/settingsStore"; import type { DataGridSortDirection } from "@/lib/dataGridSort"; import { getTableMetadataCapabilities } from "@/lib/tableMetadataCapabilities"; import { forgetDataGridConditionHistory, loadDataGridConditionHistory, rememberDataGridConditionHistory } from "@/lib/dataGridConditionHistory"; import { caretPositionInsideInsertedSqlSingleQuotes, insertedSqlSingleQuoteAtCaret } from "@/lib/sqlQuoteCaret"; +import { effectiveDatabaseTypeForConnection } from "@/lib/jdbcDialect"; const SqlPreviewPanel = defineAsyncComponent(() => import("@/components/editor/SqlPreviewPanel.vue")); const { t } = useI18n(); const slots = useSlots(); +const connectionStore = useConnectionStore(); const settingsStore = useSettingsStore(); const { isDark } = useTheme(); const { toast } = useToast(); @@ -285,6 +288,7 @@ const columnTypeMap = computed(() => { } return map; }); +const resolvedDatabaseType = computed(() => props.databaseType ?? effectiveDatabaseTypeForConnection(connectionStore.getConfig(props.connectionId ?? ""))); const columnCommentMap = computed(() => { const map = new Map(); @@ -933,7 +937,7 @@ async function applyTypedLocalFilterValue() { const columnName = props.result.columns[draft.columnIndex]; if (!columnName) return; const condition = await buildColumnValueFilterCondition({ - databaseType: props.databaseType, + databaseType: resolvedDatabaseType.value, columnName, columnInfo: props.tableMeta?.columns.find((column) => column.name === columnName), rawValue: localFilterTypedValue.value, @@ -978,6 +982,34 @@ function cachedStructuredFilterState(): StructuredFilterCacheState | undefined { return cached?.scopeKey === structuredFilterScopeKey.value ? cached : undefined; } +async function buildStructuredWhereFromRules(rules: StructuredFilterRule[]): Promise { + const rulesWithConditions = ( + await Promise.all( + rules.map(async (rule) => { + if (!rule.columnName) return { rule, condition: null }; + if (filterModeNeedsValue(rule.mode) && !rule.rawValue.trim()) return { rule, condition: null }; + const columnInfo = filterBuilderColumns.value.find((column) => column.name === rule.columnName); + return { + rule, + condition: + (await buildDataGridContextFilterCondition({ + databaseType: resolvedDatabaseType.value, + columnName: rule.columnName, + columnInfo, + mode: rule.mode, + value: filterModeNeedsValue(rule.mode) ? parseFilterValue(rule.rawValue, columnInfo) : null, + })) ?? null, + }; + }), + ) + ).filter((item): item is { rule: StructuredFilterRule; condition: string } => !!item.condition); + + return buildGroupedWhere( + rulesWithConditions.map((item) => item.condition), + rulesWithConditions.map((item) => item.rule), + ); +} + function persistStructuredFilterState() { structuredFilterStateCache.set(structuredFilterCacheKey.value, { scopeKey: structuredFilterScopeKey.value, @@ -990,10 +1022,16 @@ function persistStructuredFilterState() { function loadStructuredFilterStateForScope() { const cached = cachedStructuredFilterState(); if (cached) { + const cacheKey = structuredFilterCacheKey.value; + const scopeKey = structuredFilterScopeKey.value; structuredFilterRules.value = cloneStructuredFilterRules(cached.rules); - appliedStructuredWhereInput.value = cached.appliedWhereInput; whereFilterInput.value = cached.manualWhereInput; - nextTick(() => emit("update:whereInput", currentWhereInput() ?? "")); + appliedStructuredWhereInput.value = ""; + void buildStructuredWhereFromRules(structuredFilterRules.value).then((whereInput) => { + if (structuredFilterCacheKey.value !== cacheKey || structuredFilterScopeKey.value !== scopeKey) return; + appliedStructuredWhereInput.value = whereInput; + nextTick(() => emit("update:whereInput", currentWhereInput() ?? "")); + }); return; } appliedStructuredWhereInput.value = ""; @@ -1077,31 +1115,7 @@ function buildGroupedWhere(conditions: string[], rules: StructuredFilterRule[]): async function applyStructuredFilters() { if (!canUseWhereSearch.value) return; - const rulesWithConditions = ( - await Promise.all( - structuredFilterRules.value.map(async (rule) => { - if (!rule.columnName) return { rule, condition: null }; - if (filterModeNeedsValue(rule.mode) && !rule.rawValue.trim()) return { rule, condition: null }; - const columnInfo = filterBuilderColumns.value.find((column) => column.name === rule.columnName); - return { - rule, - condition: - (await buildDataGridContextFilterCondition({ - databaseType: props.databaseType, - columnName: rule.columnName, - columnInfo, - mode: rule.mode, - value: filterModeNeedsValue(rule.mode) ? parseFilterValue(rule.rawValue, columnInfo) : null, - })) ?? null, - }; - }), - ) - ).filter((item): item is { rule: StructuredFilterRule; condition: string } => !!item.condition); - - appliedStructuredWhereInput.value = buildGroupedWhere( - rulesWithConditions.map((item) => item.condition), - rulesWithConditions.map((item) => item.rule), - ); + appliedStructuredWhereInput.value = await buildStructuredWhereFromRules(structuredFilterRules.value); filterBuilderOpen.value = false; await applyWhereFilter(); } @@ -3468,7 +3482,7 @@ async function prefetchDetailSqlCondition() { try { const condition = await buildDataGridContextFilterCondition({ - databaseType: props.databaseType, + databaseType: resolvedDatabaseType.value, columnName: detail.column, columnInfo: props.tableMeta?.columns.find((column) => column.name === detail.column), mode: "equals", @@ -3757,7 +3771,7 @@ async function contextFilterCondition(mode: FilterMode): Promise if (!contextColumn.value) return null; return ( (await buildDataGridContextFilterCondition({ - databaseType: props.databaseType, + databaseType: resolvedDatabaseType.value, columnName: contextColumn.value, columnInfo: props.tableMeta?.columns.find((column) => column.name === contextColumn.value), mode, @@ -3815,7 +3829,7 @@ async function applyOrderBySearch() { const tableMeta = await waitForTableMeta(); if (!tableMeta) return; const sql = await buildTableSelectSql({ - databaseType: props.databaseType, + databaseType: resolvedDatabaseType.value, schema: tableMeta.schema, tableName: tableMeta.tableName, columns: tableMeta.columns.map((column) => column.name), @@ -3823,7 +3837,7 @@ async function applyOrderBySearch() { orderBy: orderByClause, limit: pageSize.value, whereInput: currentWhereInput(), - includeRowId: usesSyntheticRowIdKey(props.databaseType, tableMeta.primaryKeys), + includeRowId: usesSyntheticRowIdKey(resolvedDatabaseType.value, tableMeta.primaryKeys), }); await props.onExecuteSql(sql); } catch (e: any) { @@ -3845,7 +3859,7 @@ async function applyWhereFilter() { const tableMeta = await waitForTableMeta(); if (!tableMeta) return; const sql = await buildTableSelectSql({ - databaseType: props.databaseType, + databaseType: resolvedDatabaseType.value, schema: tableMeta.schema, tableName: tableMeta.tableName, columns: tableMeta.columns.map((column) => column.name), @@ -3853,7 +3867,7 @@ async function applyWhereFilter() { orderBy: orderByInput.value.trim() || (sortCol.value ? `${queryColumnRef(sortCol.value)} ${sortDir.value.toUpperCase()}` : undefined), limit: pageSize.value, whereInput, - includeRowId: usesSyntheticRowIdKey(props.databaseType, tableMeta.primaryKeys), + includeRowId: usesSyntheticRowIdKey(resolvedDatabaseType.value, tableMeta.primaryKeys), }); await props.onExecuteSql(sql); } catch (e: any) { diff --git a/crates/dbx-core/src/data_grid_sql.rs b/crates/dbx-core/src/data_grid_sql.rs index 3a65005834..7245699aac 100644 --- a/crates/dbx-core/src/data_grid_sql.rs +++ b/crates/dbx-core/src/data_grid_sql.rs @@ -329,6 +329,7 @@ pub fn build_data_grid_copy_insert_statement(options: DataGridCopyInsertStatemen pub fn build_data_grid_context_filter_condition(options: DataGridContextFilterConditionOptions) -> Option { let column = column_filter_ref(options.database_type, &options.column_name); + let like_column = column_like_filter_ref(options.database_type, &options.column_name, options.column_info.as_ref()); let value = &options.value; match options.mode { DataGridContextFilterMode::IsNull => Some(format!("{column} IS NULL")), @@ -336,7 +337,7 @@ pub fn build_data_grid_context_filter_condition(options: DataGridContextFilterCo DataGridContextFilterMode::Equals if value.is_null() => Some(format!("{column} IS NULL")), DataGridContextFilterMode::NotEquals if value.is_null() => Some(format!("{column} IS NOT NULL")), DataGridContextFilterMode::Like => Some(format!( - "{column} LIKE {}", + "{like_column} LIKE {}", format_grid_sql_literal( &Value::String(format!("%{}%", value_to_filter_text(value))), options.database_type, @@ -344,7 +345,7 @@ pub fn build_data_grid_context_filter_condition(options: DataGridContextFilterCo ) )), DataGridContextFilterMode::NotLike => Some(format!( - "{column} NOT LIKE {}", + "{like_column} NOT LIKE {}", format_grid_sql_literal( &Value::String(format!("%{}%", value_to_filter_text(value))), options.database_type, @@ -1407,6 +1408,37 @@ fn column_filter_ref(database_type: Option, column_name: &str) -> } } +fn column_like_filter_ref( + database_type: Option, + column_name: &str, + column_info: Option<&DataGridColumnInfo>, +) -> String { + let column = column_filter_ref(database_type, column_name); + if is_postgres_like_pattern_database(database_type) + && column_info.map(|column_info| !is_textual_column_type(&column_info.data_type)).unwrap_or(true) + { + format!("{column}::text") + } else { + column + } +} + +fn is_postgres_like_pattern_database(database_type: Option) -> bool { + matches!( + database_type, + Some( + DatabaseType::Postgres + | DatabaseType::Redshift + | DatabaseType::Gaussdb + | DatabaseType::Kwdb + | DatabaseType::Kingbase + | DatabaseType::Highgo + | DatabaseType::Vastbase + | DatabaseType::OpenGauss + ) + ) +} + fn value_to_filter_text(value: &Value) -> String { if let Some(value) = value.as_str() { value.to_string() @@ -1645,6 +1677,28 @@ mod tests { .as_deref(), Some("\"status\" LIKE '%active%'") ); + assert_eq!( + build_data_grid_context_filter_condition(DataGridContextFilterConditionOptions { + database_type: Some(DatabaseType::Postgres), + column_name: "update_date".to_string(), + mode: DataGridContextFilterMode::Like, + value: json!("128"), + column_info: Some(column("update_date", "bigint", false, None)), + }) + .as_deref(), + Some("\"update_date\"::text LIKE '%128%'") + ); + assert_eq!( + build_data_grid_context_filter_condition(DataGridContextFilterConditionOptions { + database_type: Some(DatabaseType::Postgres), + column_name: "created_at".to_string(), + mode: DataGridContextFilterMode::NotLike, + value: json!("2026"), + column_info: Some(column("created_at", "timestamp without time zone", false, None)), + }) + .as_deref(), + Some("\"created_at\"::text NOT LIKE '%2026%'") + ); } #[test]