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。

feat(mongodb): add range and list operators to document filters

zipg6d8e0d886afc
diff --git a/apps/desktop/src/components/document/DocumentBrowser.vue b/apps/desktop/src/components/document/DocumentBrowser.vue
index 765ab4c77c..5b5f785a37 100644
--- a/apps/desktop/src/components/document/DocumentBrowser.vue
+++ b/apps/desktop/src/components/document/DocumentBrowser.vue
@@ -39,6 +39,8 @@ import {
searchDocumentFieldPathTree,
documentFilterModeNeedsValue,
documentFilterModeOptionsFor,
+ documentFilterModeUsesList,
+ documentFilterModeUsesRange,
documentFilterValueTypeOptions,
documentStoreProviderFor,
elasticsearchBoolClauseOptions,
@@ -893,6 +895,7 @@ function updateDocumentFilterRule(ruleId: string, patch: Partial<DocumentFilterR
} else {
if (patch.fieldName !== undefined && patch.fieldName !== rule.fieldName) next.valueType = "auto";
if (!documentFilterModeNeedsValue(next.mode)) next.rawValue = "";
+ if (!documentFilterModeUsesRange(next.mode)) next.rawEndValue = "";
}
return next;
});
@@ -3092,8 +3095,39 @@ defineExpose({ focusSearch });
</SelectContent>
</Select>
+ <div v-if="documentStoreProvider.kind !== 'elasticsearch' && documentFilterModeUsesRange(rule.mode)" class="flex min-w-0 items-center gap-1.5">
+ <Input
+ :model-value="rule.rawValue"
+ class="h-8 min-w-0 flex-1 text-xs"
+ :placeholder="t('grid.filterBuilderRangeStart')"
+ @update:model-value="(value) => updateDocumentFilterRule(rule.id, { rawValue: String(value ?? '') })"
+ @compositionend="endDocumentFilterImeComposition(`value-start:${rule.id}`)"
+ @compositionstart="startDocumentFilterImeComposition(`value-start:${rule.id}`)"
+ @keydown="handleDocumentFilterValueKeydown($event, rule.id)"
+ />
+ <span class="shrink-0 text-[10px] text-muted-foreground">—</span>
+ <Input
+ :model-value="rule.rawEndValue"
+ class="h-8 min-w-0 flex-1 text-xs"
+ :placeholder="t('grid.filterBuilderRangeEnd')"
+ @update:model-value="(value) => updateDocumentFilterRule(rule.id, { rawEndValue: String(value ?? '') })"
+ @compositionend="endDocumentFilterImeComposition(`value-end:${rule.id}`)"
+ @compositionstart="startDocumentFilterImeComposition(`value-end:${rule.id}`)"
+ @keydown="handleDocumentFilterValueKeydown($event, rule.id)"
+ />
+ </div>
+ <textarea
+ v-else-if="documentStoreProvider.kind !== 'elasticsearch' && documentFilterModeUsesList(rule.mode)"
+ :value="rule.rawValue"
+ rows="2"
+ class="min-h-8 w-full min-w-0 resize-y rounded-md border bg-background px-2 py-1 text-xs outline-none"
+ :placeholder="t('grid.filterBuilderValues')"
+ @input="updateDocumentFilterRule(rule.id, { rawValue: ($event.target as HTMLTextAreaElement).value })"
+ @keydown.ctrl.enter.prevent="applyDocumentStructuredFilters"
+ @keydown.meta.enter.prevent="applyDocumentStructuredFilters"
+ />
<Input
- v-if="documentStoreProvider.kind === 'elasticsearch' ? elasticsearchQueryTypeNeedsValue(rule.elasticsearchQueryType) : documentFilterModeNeedsValue(rule.mode)"
+ v-else-if="documentStoreProvider.kind === 'elasticsearch' ? elasticsearchQueryTypeNeedsValue(rule.elasticsearchQueryType) : documentFilterModeNeedsValue(rule.mode)"
:model-value="rule.rawValue"
class="h-8 min-w-0 text-xs"
:placeholder="t('grid.filterBuilderValue')"
diff --git a/apps/desktop/src/components/document/MongoBucketBrowser.vue b/apps/desktop/src/components/document/MongoBucketBrowser.vue
index 9225824334..9afff482da 100644
--- a/apps/desktop/src/components/document/MongoBucketBrowser.vue
+++ b/apps/desktop/src/components/document/MongoBucketBrowser.vue
@@ -8,7 +8,18 @@ import { Input } from "@/components/ui/input";
import { Popover, PopoverContent, PopoverTrigger } from "@/components/ui/popover";
import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select";
import { useToast } from "@/composables/useToast";
-import { buildDocumentFilterCondition, currentDocumentFilterJson, currentDocumentSortJson, documentFilterModeNeedsValue, documentFilterModeOptions, documentStoreProviderFor, type DocumentFilterMode, type DocumentFilterRule } from "@/lib/app/documentStoreProvider";
+import {
+ buildDocumentFilterCondition,
+ currentDocumentFilterJson,
+ currentDocumentSortJson,
+ documentFilterModeNeedsValue,
+ documentFilterModeOptions,
+ documentFilterModeUsesList,
+ documentFilterModeUsesRange,
+ documentStoreProviderFor,
+ type DocumentFilterMode,
+ type DocumentFilterRule,
+} from "@/lib/app/documentStoreProvider";
import { isTauriRuntime } from "@/lib/backend/tauriRuntime";
import * as api from "@/lib/backend/api";
import { uuid } from "@/lib/common/utils";
@@ -147,6 +158,7 @@ function updateFilterRule(ruleId: string, patch: Partial<DocumentFilterRule>) {
if (rule.id !== ruleId) return rule;
const next = { ...rule, ...patch };
if (!documentFilterModeNeedsValue(next.mode)) next.rawValue = "";
+ if (!documentFilterModeUsesRange(next.mode)) next.rawEndValue = "";
return next;
});
}
@@ -548,8 +560,23 @@ watch(
</SelectContent>
</Select>
+ <div v-if="documentFilterModeUsesRange(rule.mode)" class="flex min-w-0 items-center gap-1.5">
+ <Input :model-value="rule.rawValue" class="h-8 min-w-0 flex-1 text-xs" :placeholder="t('grid.filterBuilderRangeStart')" @update:model-value="(value) => updateFilterRule(rule.id, { rawValue: String(value ?? '') })" @keydown.enter.prevent="applyStructuredFilters" />
+ <span class="shrink-0 text-[10px] text-muted-foreground">—</span>
+ <Input :model-value="rule.rawEndValue" class="h-8 min-w-0 flex-1 text-xs" :placeholder="t('grid.filterBuilderRangeEnd')" @update:model-value="(value) => updateFilterRule(rule.id, { rawEndValue: String(value ?? '') })" @keydown.enter.prevent="applyStructuredFilters" />
+ </div>
+ <textarea
+ v-else-if="documentFilterModeUsesList(rule.mode)"
+ :value="rule.rawValue"
+ rows="2"
+ class="min-h-8 w-full min-w-0 resize-y rounded-md border bg-background px-2 py-1 text-xs outline-none"
+ :placeholder="t('grid.filterBuilderValues')"
+ @input="updateFilterRule(rule.id, { rawValue: ($event.target as HTMLTextAreaElement).value })"
+ @keydown.ctrl.enter.prevent="applyStructuredFilters"
+ @keydown.meta.enter.prevent="applyStructuredFilters"
+ />
<Input
- v-if="documentFilterModeNeedsValue(rule.mode)"
+ v-else-if="documentFilterModeNeedsValue(rule.mode)"
:model-value="rule.rawValue"
class="h-8 min-w-0 text-xs"
:placeholder="t('grid.filterBuilderValue')"
diff --git a/apps/desktop/src/lib/__tests__/app/documentStoreProvider.filter.spec.ts b/apps/desktop/src/lib/__tests__/app/documentStoreProvider.filter.spec.ts
index 58775ae634..d2f5b16dee 100644
--- a/apps/desktop/src/lib/__tests__/app/documentStoreProvider.filter.spec.ts
+++ b/apps/desktop/src/lib/__tests__/app/documentStoreProvider.filter.spec.ts
@@ -1,5 +1,5 @@
import { describe, expect, it } from "vitest";
-import { buildDocumentFilterCondition, documentFieldPathTreeFromDocuments, documentFilterModeOptions, documentFilterValueTypeOptions } from "@/lib/app/documentStoreProvider";
+import { buildDocumentFilterCondition, documentFieldPathTreeFromDocuments, documentFilterModeOptions, documentFilterModeOptionsFor, documentFilterValueTypeOptions } from "@/lib/app/documentStoreProvider";
describe("document store structured filters", () => {
it("offers and builds inclusive comparison filters", () => {
@@ -78,4 +78,64 @@ describe("document store structured filters", () => {
expect(tree[0]).toMatchObject({ path: "_id", sampleValue: "001" });
});
+
+ it("offers the PostgreSQL-style operators for MongoDB only", () => {
+ const mongoModes = documentFilterModeOptionsFor("mongodb").map((option) => option.value);
+ expect(mongoModes).toEqual(expect.arrayContaining(["begins-with", "ends-with", "in", "not-in", "between", "not-between"]));
+ for (const kind of ["elasticsearch", "dynamodb", "meilisearch"] as const) {
+ const modes = documentFilterModeOptionsFor(kind).map((option) => option.value);
+ for (const mode of ["begins-with", "ends-with", "in", "not-in", "between", "not-between"] as const) {
+ expect(modes).not.toContain(mode);
+ }
+ }
+ expect(buildDocumentFilterCondition({ id: "starts", fieldName: "name", mode: "begins-with", rawValue: "张", conjunction: "AND" }, { kind: "elasticsearch", sampleValue: "张三" })).toBeNull();
+ });
+
+ it("builds anchored prefix and suffix filters", () => {
+ expect(buildDocumentFilterCondition({ id: "starts", fieldName: "name", mode: "begins-with", rawValue: "张", conjunction: "AND" }, { kind: "mongodb", sampleValue: "张三" })).toEqual({
+ name: { $regex: "^张", $options: "i" },
+ });
+ expect(buildDocumentFilterCondition({ id: "ends", fieldName: "name", mode: "ends-with", rawValue: "三", conjunction: "AND" }, { kind: "mongodb", sampleValue: "张三" })).toEqual({
+ name: { $regex: "三$", $options: "i" },
+ });
+ expect(buildDocumentFilterCondition({ id: "starts", fieldName: "name", mode: "begins-with", rawValue: "a.b", conjunction: "AND" }, { kind: "mongodb", sampleValue: "alice" })).toEqual({
+ name: { $regex: "^a\\.b", $options: "i" },
+ });
+ });
+
+ it("matches numeric MongoDB fields for prefix and suffix filters", () => {
+ expect(buildDocumentFilterCondition({ id: "starts", fieldName: "age", mode: "begins-with", rawValue: "2", conjunction: "AND" }, { kind: "mongodb", sampleValue: 28 })).toEqual({
+ $expr: {
+ $regexMatch: {
+ input: { $convert: { input: "$age", to: "string", onError: "", onNull: "" } },
+ regex: "^2",
+ options: "i",
+ },
+ },
+ });
+ });
+
+ it("builds in and not-in filters from comma or newline separated values", () => {
+ expect(buildDocumentFilterCondition({ id: "in", fieldName: "name", mode: "in", rawValue: "张三, 李四\n王五", conjunction: "AND" }, { kind: "mongodb", sampleValue: "张三" })).toEqual({
+ name: { $in: ["张三", "李四", "王五"] },
+ });
+ expect(buildDocumentFilterCondition({ id: "not-in", fieldName: "age", mode: "not-in", rawValue: "18, 30", valueType: "number", conjunction: "AND" }, { kind: "mongodb" })).toEqual({
+ age: { $nin: [18, 30] },
+ });
+ expect(buildDocumentFilterCondition({ id: "in", fieldName: "name", mode: "in", rawValue: "'a,b'", conjunction: "AND" }, { kind: "mongodb", sampleValue: "a" })).toEqual({
+ name: { $in: ["a,b"] },
+ });
+ expect(buildDocumentFilterCondition({ id: "in", fieldName: "name", mode: "in", rawValue: " , \n ", conjunction: "AND" }, { kind: "mongodb" })).toBeNull();
+ });
+
+ it("builds between and not-between filters", () => {
+ expect(buildDocumentFilterCondition({ id: "between", fieldName: "age", mode: "between", rawValue: "18", rawEndValue: "30", valueType: "number", conjunction: "AND" }, { kind: "mongodb" })).toEqual({
+ age: { $gte: 18, $lte: 30 },
+ });
+ expect(buildDocumentFilterCondition({ id: "not-between", fieldName: "age", mode: "not-between", rawValue: "18", rawEndValue: "30", valueType: "number", conjunction: "AND" }, { kind: "mongodb" })).toEqual({
+ $or: [{ age: { $lt: 18 } }, { age: { $gt: 30 } }],
+ });
+ expect(buildDocumentFilterCondition({ id: "between", fieldName: "age", mode: "between", rawValue: "18", rawEndValue: "", conjunction: "AND" }, { kind: "mongodb" })).toBeNull();
+ expect(buildDocumentFilterCondition({ id: "between", fieldName: "age", mode: "between", rawValue: "18", rawEndValue: "30", conjunction: "AND" }, { kind: "mysql" as never })).toBeNull();
+ });
});
diff --git a/apps/desktop/src/lib/app/documentStoreProvider.ts b/apps/desktop/src/lib/app/documentStoreProvider.ts
index 35d3e447f9..d04948a227 100644
--- a/apps/desktop/src/lib/app/documentStoreProvider.ts
+++ b/apps/desktop/src/lib/app/documentStoreProvider.ts
@@ -5,7 +5,7 @@ import { quoteUnquotedObjectKeys } from "@/lib/mongo/mongoShellCommand";
import { formatMongoShellLiteral } from "@/lib/mongo/mongoDocumentValues";
export type DocumentStoreKind = "mongodb" | "dynamodb" | "elasticsearch" | "meilisearch";
-export type DocumentFilterMode = "equals" | "not-equals" | "like" | "not-like" | "greater-than" | "greater-than-or-equal" | "less-than" | "less-than-or-equal" | "is-null" | "is-not-null";
+export type DocumentFilterMode = "equals" | "not-equals" | "like" | "not-like" | "begins-with" | "ends-with" | "greater-than" | "greater-than-or-equal" | "less-than" | "less-than-or-equal" | "in" | "not-in" | "between" | "not-between" | "is-null" | "is-not-null";
export type DocumentFilterValueType = "auto" | "string" | "number" | "boolean" | "object-id" | "date" | "int32" | "int64" | "decimal128" | "json";
export type ElasticsearchBoolClause = "filter" | "must" | "should" | "must_not";
export type ElasticsearchQueryType = "term" | "terms" | "match" | "match_phrase" | "wildcard" | "range_gt" | "range_gte" | "range_lt" | "range_lte" | "exists";
@@ -15,6 +15,7 @@ export type DocumentFilterRule = {
fieldName: string;
mode: DocumentFilterMode;
rawValue: string;
+ rawEndValue?: string;
conjunction: "AND" | "OR";
valueType?: DocumentFilterValueType;
elasticsearchClause?: ElasticsearchBoolClause;
@@ -56,16 +57,31 @@ export const documentFilterModeOptions: Array<{ value: DocumentFilterMode; label
{ value: "not-equals", labelKey: "grid.filterBuilderNotEquals" },
{ value: "like", labelKey: "grid.filterBuilderContains" },
{ value: "not-like", labelKey: "grid.filterBuilderNotContains" },
+ { value: "begins-with", labelKey: "grid.filterBuilderBeginsWith" },
+ { value: "ends-with", labelKey: "grid.filterBuilderEndsWith" },
{ value: "greater-than", labelKey: "grid.filterBuilderGreaterThan" },
{ value: "greater-than-or-equal", labelKey: "grid.filterBuilderGreaterThanOrEqual" },
{ value: "less-than", labelKey: "grid.filterBuilderLessThan" },
{ value: "less-than-or-equal", labelKey: "grid.filterBuilderLessThanOrEqual" },
+ { value: "in", labelKey: "grid.filterBuilderIn" },
+ { value: "not-in", labelKey: "grid.filterBuilderNotIn" },
+ { value: "between", labelKey: "grid.filterBuilderBetween" },
+ { value: "not-between", labelKey: "grid.filterBuilderNotBetween" },
{ value: "is-null", labelKey: "grid.filterBuilderIsNull" },
{ value: "is-not-null", labelKey: "grid.filterBuilderIsNotNull" },
];
+/**
+ * Operators that are only expressible in MongoDB filter documents. The other
+ * document stores keep their previous operator set so their query builders are
+ * not offered predicates they cannot express.
+ */
+const MONGO_ONLY_DOCUMENT_FILTER_MODES = new Set<DocumentFilterMode>(["begins-with", "ends-with", "in", "not-in", "between", "not-between"]);
+
export function documentFilterModeOptionsFor(kind: DocumentStoreKind): Array<{ value: DocumentFilterMode; labelKey: string }> {
- return kind === "meilisearch" ? documentFilterModeOptions.filter((option) => option.value !== "like" && option.value !== "not-like") : documentFilterModeOptions;
+ if (kind === "meilisearch") return documentFilterModeOptions.filter((option) => option.value !== "like" && option.value !== "not-like" && !MONGO_ONLY_DOCUMENT_FILTER_MODES.has(option.value));
+ if (kind === "mongodb") return documentFilterModeOptions;
+ return documentFilterModeOptions.filter((option) => !MONGO_ONLY_DOCUMENT_FILTER_MODES.has(option.value));
}
export const documentFilterValueTypeOptions: Array<{ value: DocumentFilterValueType; labelKey: string }> = [
@@ -190,6 +206,7 @@ export function defaultDocumentFilterRule(id: string, fieldName = ""): DocumentF
fieldName,
mode: "equals",
rawValue: "",
+ rawEndValue: "",
conjunction: "AND",
valueType: "auto",
elasticsearchClause: "filter",
@@ -201,6 +218,16 @@ export function documentFilterModeNeedsValue(mode: DocumentFilterMode): boolean
return mode !== "is-null" && mode !== "is-not-null";
}
+/** List predicates take a comma/newline separated value list. */
+export function documentFilterModeUsesList(mode: DocumentFilterMode): boolean {
+ return mode === "in" || mode === "not-in";
+}
+
+/** Range predicates take a start and an end value. */
+export function documentFilterModeUsesRange(mode: DocumentFilterMode): boolean {
+ return mode === "between" || mode === "not-between";
+}
+
type DocumentFieldPathAccumulatorNode = {
key: string;
path: string;
@@ -492,8 +519,12 @@ type DocumentFilterParseOptions = {
export function buildDocumentFilterCondition(rule: DocumentFilterRule, options: DocumentFilterParseOptions = {}): Record<string, unknown> | null {
if (!rule.fieldName) return null;
if (documentFilterModeNeedsValue(rule.mode) && !rule.rawValue.trim()) return null;
- const value = documentFilterModeNeedsValue(rule.mode) ? parseDocumentFilterValue(rule.rawValue, { ...options, valueType: rule.valueType }) : null;
- const textValue = documentFilterModeNeedsValue(rule.mode) ? String(parseDocumentFilterValue(rule.rawValue)) : "";
+ if (documentFilterModeUsesRange(rule.mode) && !(rule.rawEndValue ?? "").trim()) return null;
+ // Range and list predicates parse their raw input inside their own case, so the
+ // single-value parse must not run for them (it would reject "18, 30" as a number).
+ const parsesSingleValue = documentFilterModeNeedsValue(rule.mode) && !documentFilterModeUsesList(rule.mode) && !documentFilterModeUsesRange(rule.mode);
+ const value = parsesSingleValue ? parseDocumentFilterValue(rule.rawValue, { ...options, valueType: rule.valueType }) : null;
+ const textValue = parsesSingleValue ? String(parseDocumentFilterValue(rule.rawValue)) : "";
switch (rule.mode) {
case "equals":
return { [rule.fieldName]: value };
@@ -511,6 +542,13 @@ export function buildDocumentFilterCondition(rule: DocumentFilterRule, options:
return mongoNumericContainsCondition(rule.fieldName, textValue, true);
}
return { [rule.fieldName]: { $not: { $regex: escapeRegexLiteral(textValue), $options: "i" } } };
+ case "begins-with":
+ case "ends-with": {
+ if (!mongoDocumentFilterKind(options)) return null;
+ const pattern = `${rule.mode === "begins-with" ? "^" : ""}${escapeRegexLiteral(textValue)}${rule.mode === "ends-with" ? "$" : ""}`;
+ if (mongoFilterValueIsNumeric(rule.valueType, options.sampleValue)) return mongoNumericRegexCondition(rule.fieldName, pattern);
+ return { [rule.fieldName]: { $regex: pattern, $options: "i" } };
+ }
case "greater-than":
return { [rule.fieldName]: { $gt: value } };
case "greater-than-or-equal":
@@ -519,6 +557,27 @@ export function buildDocumentFilterCondition(rule: DocumentFilterRule, options:
return { [rule.fieldName]: { $lt: value } };
case "less-than-or-equal":
return { [rule.fieldName]: { $lte: value } };
+ case "in":
+ case "not-in": {
+ if (!mongoDocumentFilterKind(options)) return null;
+ const values = parseDocumentFilterValueList(rule.rawValue, { ...options, valueType: rule.valueType });
+ if (values.length === 0) return null;
+ return { [rule.fieldName]: rule.mode === "in" ? { $in: values } : { $nin: values } };
+ }
+ case "between": {
+ if (!mongoDocumentFilterKind(options)) return null;
+ const start = parseDocumentFilterValue(rule.rawValue, { ...options, valueType: rule.valueType });
+ const end = parseDocumentFilterValue(rule.rawEndValue ?? "", { ...options, valueType: rule.valueType });
+ return { [rule.fieldName]: { $gte: start, $lte: end } };
+ }
+ case "not-between": {
+ if (!mongoDocumentFilterKind(options)) return null;
+ // "Outside range" is the complement of [start, end]; `$not` cannot wrap a
+ // multi-operator predicate, so the two open-ended bounds are OR-ed.
+ const start = parseDocumentFilterValue(rule.rawValue, { ...options, valueType: rule.valueType });
+ const end = parseDocumentFilterValue(rule.rawEndValue ?? "", { ...options, valueType: rule.valueType });
+ return { $or: [{ [rule.fieldName]: { $lt: start } }, { [rule.fieldName]: { $gt: end } }] };
+ }
case "is-null":
return { [rule.fieldName]: null };
case "is-not-null":
@@ -530,6 +589,55 @@ function escapeRegexLiteral(value: string): string {
return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
}
+function mongoDocumentFilterKind(options: DocumentFilterParseOptions): boolean {
+ return options.kind === undefined || options.kind === "mongodb";
+}
+
+/** Splits a comma/newline separated filter value list, keeping quoted values intact. */
+function parseDocumentFilterValueList(raw: string, options: DocumentFilterParseOptions): unknown[] {
+ const tokens: string[] = [];
+ let current = "";
+ let quote: "'" | '"' | null = null;
+ for (let index = 0; index < raw.length; index += 1) {
+ const char = raw[index] ?? "";
+ const next = raw[index + 1];
+ if (quote) {
+ current += char;
+ if (char === quote) {
+ if (next === quote) {
+ current += next;
+ index += 1;
+ } else {
+ quote = null;
+ }
+ }
+ continue;
+ }
+ if ((char === "'" || char === '"') && current.trim().length === 0) {
+ quote = char;
+ current += char;
+ continue;
+ }
+ if (char === "," || char === "\n" || char === "\r") {
+ tokens.push(current);
+ current = "";
+ continue;
+ }
+ current += char;
+ }
+ tokens.push(current);
+ return tokens
+ .map((token) => token.trim())
+ .filter((token) => token.length > 0)
+ .map((token) => parseDocumentFilterValue(unquoteSingleQuotedListToken(token), options));
+}
+
+/** Mongo shell style single-quoted list values are unquoted; double quotes stay for the JSON parser. */
+function unquoteSingleQuotedListToken(token: string): string {
+ if (token.length >= 2 && token.startsWith("'") && token.endsWith("'")) return token.slice(1, -1).replace(/''/g, "'");
+ return token;
+}
+
function mongoFilterValueIsNumeric(valueType?: DocumentFilterValueType, sampleValue?: unknown): boolean {
if (valueType === "number" || valueType === "int32" || valueType === "int64" || valueType === "decimal128") return true;
if (typeof sampleValue === "number") return true;
@@ -539,7 +647,11 @@ function mongoFilterValueIsNumeric(valueType?: DocumentFilterValueType, sampleVa
}
function mongoNumericContainsCondition(fieldName: string, textValue: string, negate = false): Record<string, unknown> {
- const regexMatch = { $regexMatch: { input: { $convert: { input: `$${fieldName}`, to: "string", onError: "", onNull: "" } }, regex: escapeRegexLiteral(textValue), options: "i" } };
+ return mongoNumericRegexCondition(fieldName, escapeRegexLiteral(textValue), negate);
+}
+
+function mongoNumericRegexCondition(fieldName: string, regex: string, negate = false): Record<string, unknown> {
+ const regexMatch = { $regexMatch: { input: { $convert: { input: `$${fieldName}`, to: "string", onError: "", onNull: "" } }, regex, options: "i" } };
return negate ? { $expr: { $not: [regexMatch] } } : { $expr: regexMatch };
}
diff --git a/docs/screenshots/issue-9240-after-filter-operators.png b/docs/screenshots/issue-9240-after-filter-operators.png
new file mode 100644
index 0000000000..2b22ef1b9a
Binary files /dev/null and b/docs/screenshots/issue-9240-after-filter-operators.png differ
diff --git a/docs/screenshots/issue-9240-after-not-between.png b/docs/screenshots/issue-9240-after-not-between.png
new file mode 100644
index 0000000000..3baae8fb38
Binary files /dev/null and b/docs/screenshots/issue-9240-after-not-between.png differ
diff --git a/docs/screenshots/issue-9240-before-filter-operators.png b/docs/screenshots/issue-9240-before-filter-operators.png
new file mode 100644
index 0000000000..090d4cd7e4
Binary files /dev/null and b/docs/screenshots/issue-9240-before-filter-operators.png differ