wdevs/ResolveSpec
5
0
Fork 0
mirror of https://github.com/bitechdev/ResolveSpec.git synced 2026-08-13 12:56:07 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

feat(resolvespec): add 'contains' operator for array overlap

Browse Source 
* Implemented 'contains' operator using BuildArrayOverlapCondition for real array containment.
* Updated documentation to clarify differences between text-cast ILIKE and array overlap.
This commit is contained in:
warkanum
2026-08-10 15:01:23 +02:00
parent 16cc7d350e
commit c60565e4e0
6 changed files with 208 additions and 90 deletions
Download Patch File Download Diff File Expand all files Collapse all files
pkg/common/sql_helpers.go
+18
View File
@@ -1040,3 +1040,21 @@ func BuildInCondition(column string, v interface{}) (query string, args []interf
} }
return fmt.Sprintf("%s IN (%s)", column, strings.Join(placeholders, ",")), values return fmt.Sprintf("%s IN (%s)", column, strings.Join(placeholders, ",")), values
} }
// BuildArrayOverlapCondition builds a parameterized condition testing whether an
// array column has at least one element in common with the given value(s), using
// PostgreSQL's array overlap operator (&&). Unlike a text-cast ILIKE, this performs
// real element-wise containment (no substring false positives) and can use a GIN
// index on the column. A single value is treated as a one-element array.
// Returns ("", nil) if the value is empty.
func BuildArrayOverlapCondition(column string, v interface{}) (query string, args []interface{}) {
values := FilterValueToSlice(v)
if len(values) == 0 {
return "", nil
}
placeholders := make([]string, len(values))
for i := range values {
placeholders[i] = "?"
}
return fmt.Sprintf("%s && ARRAY[%s]", column, strings.Join(placeholders, ",")), values
}
pkg/common/sql_helpers_test.go
+145 -87
View File
@@ -889,93 +889,151 @@ func TestSanitizeWhereClause_PreservesParenthesesWithOR(t *testing.T) {
} }
func TestAddTablePrefixToColumns_ComplexConditions(t *testing.T) { func TestAddTablePrefixToColumns_ComplexConditions(t *testing.T) {
tests := []struct { tests := []struct {
name string name string
where string where string
tableName string tableName string
expected string expected string
}{ }{
{ {
name: "Parentheses with true AND condition - should not prefix true", name: "Parentheses with true AND condition - should not prefix true",
where: "(true AND status = 'active')", where: "(true AND status = 'active')",
tableName: "mastertask", tableName: "mastertask",
expected: "(true AND mastertask.status = 'active')", expected: "(true AND mastertask.status = 'active')",
}, },
{ {
name: "Parentheses with multiple conditions including true", name: "Parentheses with multiple conditions including true",
where: "(true AND status = 'active' AND id > 5)", where: "(true AND status = 'active' AND id > 5)",
tableName: "mastertask", tableName: "mastertask",
expected: "(true AND mastertask.status = 'active' AND mastertask.id > 5)", expected: "(true AND mastertask.status = 'active' AND mastertask.id > 5)",
}, },
{ {
name: "Nested parentheses with true", name: "Nested parentheses with true",
where: "((true AND status = 'active'))", where: "((true AND status = 'active'))",
tableName: "mastertask", tableName: "mastertask",
expected: "((true AND mastertask.status = 'active'))", expected: "((true AND mastertask.status = 'active'))",
}, },
{ {
name: "Mixed: false AND valid conditions", name: "Mixed: false AND valid conditions",
where: "(false AND name = 'test')", where: "(false AND name = 'test')",
tableName: "mastertask", tableName: "mastertask",
expected: "(false AND mastertask.name = 'test')", expected: "(false AND mastertask.name = 'test')",
}, },
{ {
name: "Mixed: null AND valid conditions", name: "Mixed: null AND valid conditions",
where: "(null AND status = 'active')", where: "(null AND status = 'active')",
tableName: "mastertask", tableName: "mastertask",
expected: "(null AND mastertask.status = 'active')", expected: "(null AND mastertask.status = 'active')",
}, },
{ {
name: "Multiple true conditions in parentheses", name: "Multiple true conditions in parentheses",
where: "(true AND true AND status = 'active')", where: "(true AND true AND status = 'active')",
tableName: "mastertask", tableName: "mastertask",
expected: "(true AND true AND mastertask.status = 'active')", expected: "(true AND true AND mastertask.status = 'active')",
}, },
{ {
name: "Simple true without parens - should not prefix", name: "Simple true without parens - should not prefix",
where: "true", where: "true",
tableName: "mastertask", tableName: "mastertask",
expected: "true", expected: "true",
}, },
{ {
name: "Simple condition without parens - should prefix", name: "Simple condition without parens - should prefix",
where: "status = 'active'", where: "status = 'active'",
tableName: "mastertask", tableName: "mastertask",
expected: "mastertask.status = 'active'", expected: "mastertask.status = 'active'",
}, },
{ {
name: "Unregistered table with true - should not prefix true", name: "Unregistered table with true - should not prefix true",
where: "(true AND status = 'active')", where: "(true AND status = 'active')",
tableName: "unregistered_table", tableName: "unregistered_table",
expected: "(true AND unregistered_table.status = 'active')", expected: "(true AND unregistered_table.status = 'active')",
}, },
// BETWEEN regression: date literals inside BETWEEN must not be prefixed as columns. // BETWEEN regression: date literals inside BETWEEN must not be prefixed as columns.
{ {
name: "BETWEEN date range - second date must not be prefixed", name: "BETWEEN date range - second date must not be prefixed",
where: "applicationdate between '2025-08-31' and '1970-01-01'", where: "applicationdate between '2025-08-31' and '1970-01-01'",
tableName: "unregistered_table", tableName: "unregistered_table",
expected: "unregistered_table.applicationdate between '2025-08-31' and '1970-01-01'", expected: "unregistered_table.applicationdate between '2025-08-31' and '1970-01-01'",
}, },
{ {
name: "Already-prefixed BETWEEN column - unchanged", name: "Already-prefixed BETWEEN column - unchanged",
where: `"v_webui_clients".applicationdate between '2025-08-31' and '1970-01-01'`, where: `"v_webui_clients".applicationdate between '2025-08-31' and '1970-01-01'`,
tableName: "v_webui_clients", tableName: "v_webui_clients",
expected: `"v_webui_clients".applicationdate between '2025-08-31' and '1970-01-01'`, expected: `"v_webui_clients".applicationdate between '2025-08-31' and '1970-01-01'`,
}, },
{ {
name: "Complex OR block with multiple BETWEENs - date values must not be prefixed", name: "Complex OR block with multiple BETWEENs - date values must not be prefixed",
where: `("v_webui_clients".applicationdate between '2025-08-31' and '1970-01-01' or "v_webui_clients".clientcapturedate between '2025-08-31' and '1970-01-01' or "v_webui_clients".startdate between '2025-08-31' AND '1970-01-01')`, where: `("v_webui_clients".applicationdate between '2025-08-31' and '1970-01-01' or "v_webui_clients".clientcapturedate between '2025-08-31' and '1970-01-01' or "v_webui_clients".startdate between '2025-08-31' AND '1970-01-01')`,
tableName: "v_webui_clients", tableName: "v_webui_clients",
expected: `("v_webui_clients".applicationdate between '2025-08-31' and '1970-01-01' or "v_webui_clients".clientcapturedate between '2025-08-31' and '1970-01-01' or "v_webui_clients".startdate between '2025-08-31' AND '1970-01-01')`, expected: `("v_webui_clients".applicationdate between '2025-08-31' and '1970-01-01' or "v_webui_clients".clientcapturedate between '2025-08-31' and '1970-01-01' or "v_webui_clients".startdate between '2025-08-31' AND '1970-01-01')`,
}, },
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
result := AddTablePrefixToColumns(tt.where, tt.tableName)
if result != tt.expected {
t.Errorf("AddTablePrefixToColumns(%q, %q) = %q; want %q", tt.where, tt.tableName, result, tt.expected)
}
})
}
} }
for _, tt := range tests { func TestBuildArrayOverlapCondition(t *testing.T) {
t.Run(tt.name, func(t *testing.T) { tests := []struct {
result := AddTablePrefixToColumns(tt.where, tt.tableName) name string
if result != tt.expected { column string
t.Errorf("AddTablePrefixToColumns(%q, %q) = %q; want %q", tt.where, tt.tableName, result, tt.expected) value interface{}
} expectedCond string
}) expectedArgs int
} }{
{
name: "single scalar value",
column: "tags",
value: "urgent",
expectedCond: "tags && ARRAY[?]",
expectedArgs: 1,
},
{
name: "multiple values",
column: "tags",
value: []string{"urgent", "billing", "vip"},
expectedCond: "tags && ARRAY[?,?,?]",
expectedArgs: 3,
},
{
name: "JSON-decoded []interface{} value",
column: "tags",
value: []interface{}{"urgent", "billing"},
expectedCond: "tags && ARRAY[?,?]",
expectedArgs: 2,
},
{
name: "nil value",
column: "tags",
value: nil,
expectedCond: "",
expectedArgs: 0,
},
{
name: "empty slice value",
column: "tags",
value: []string{},
expectedCond: "",
expectedArgs: 0,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
cond, args := BuildArrayOverlapCondition(tt.column, tt.value)
if cond != tt.expectedCond {
t.Errorf("BuildArrayOverlapCondition(%q, %v) condition = %q; want %q", tt.column, tt.value, cond, tt.expectedCond)
}
if len(args) != tt.expectedArgs {
t.Errorf("BuildArrayOverlapCondition(%q, %v) args = %d; want %d", tt.column, tt.value, len(args), tt.expectedArgs)
}
})
}
} }
pkg/resolvespec/filter_test.go
+30
View File
@@ -57,6 +57,36 @@ func TestBuildFilterCondition(t *testing.T) {
expectedCondition: "CAST(email AS TEXT) LIKE ?", expectedCondition: "CAST(email AS TEXT) LIKE ?",
expectedArgsCount: 1, expectedArgsCount: 1,
}, },
{
name: "CONTAINS operator with single value",
filter: common.FilterOption{
Column: "tags",
Operator: "contains",
Value: "urgent",
},
expectedCondition: "tags && ARRAY[?]",
expectedArgsCount: 1,
},
{
name: "CONTAINS operator with multiple values",
filter: common.FilterOption{
Column: "tags",
Operator: "contains",
Value: []string{"urgent", "billing"},
},
expectedCondition: "tags && ARRAY[?,?]",
expectedArgsCount: 2,
},
{
name: "CONTAINS operator with empty value",
filter: common.FilterOption{
Column: "tags",
Operator: "contains",
Value: nil,
},
expectedCondition: "",
expectedArgsCount: 0,
},
} }
for _, tt := range tests { for _, tt := range tests {
pkg/resolvespec/handler.go
+10
View File
@@ -1895,6 +1895,11 @@ func (h *Handler) buildFilterCondition(filter common.FilterOption) (conditionStr
if condition == "" { if condition == "" {
return "", nil return "", nil
} }
case "contains":
condition, args = common.BuildArrayOverlapCondition(filter.Column, filter.Value)
if condition == "" {
return "", nil
}
default: default:
return "", nil return "", nil
} }
@@ -1939,6 +1944,11 @@ func (h *Handler) applyFilter(query common.SelectQuery, filter common.FilterOpti
if condition == "" { if condition == "" {
return query return query
} }
case "contains":
condition, args = common.BuildArrayOverlapCondition(filter.Column, filter.Value)
if condition == "" {
return query
}
default: default:
return query return query
} }
pkg/restheadspec/HEADERS.md
+1 -1
View File
@@ -88,7 +88,7 @@ This will match any records where the column contains the search term (case-inse
Search with specific operators (AND logic). Search with specific operators (AND logic).
**Supported Operators:** **Supported Operators:**
- `contains` - Contains substring (case-insensitive) - `contains` - Contains substring (case-insensitive). Implemented as `CAST(col AS TEXT) ILIKE '%value%'` for every column type, including arrays (stringifies the array, then substring-matches). **Not** array containment — no GIN index use, and can false-positive on partial matches within array elements. resolvespec (a different spec package in this repo) defines `contains` differently: real PostgreSQL array-overlap (`&&`). Don't assume the two behave the same.
- `beginswith` / `startswith` - Starts with (case-insensitive) - `beginswith` / `startswith` - Starts with (case-insensitive)
- `endswith` - Ends with (case-insensitive) - `endswith` - Ends with (case-insensitive)
- `equals` / `eq` - Exact match - `equals` / `eq` - Exact match
pkg/restheadspec/README.md
+2
View File
@@ -96,6 +96,8 @@ X-Limit: 50
**Available Operators**: `eq`, `neq`, `gt`, `gte`, `lt`, `lte`, `contains`, `startswith`, `endswith`, `between`, `betweeninclusive`, `in`, `empty`, `notempty` **Available Operators**: `eq`, `neq`, `gt`, `gte`, `lt`, `lte`, `contains`, `startswith`, `endswith`, `between`, `betweeninclusive`, `in`, `empty`, `notempty`
> Note: `contains` here is a text-cast ILIKE substring match (works on any column type, including arrays, by stringifying first) — not array containment. resolvespec's `contains` operator has different semantics (real array overlap). See [HEADERS.md](HEADERS.md) for details.
For complete header documentation, see [HEADERS.md](HEADERS.md). For complete header documentation, see [HEADERS.md](HEADERS.md).
## Lifecycle Hooks ## Lifecycle Hooks