tabshift/pocketbase
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

added strftime filter function

Browse Source
This commit is contained in:
Gani Georgiev
2026-01-15 14:27:53 +02:00
parent 8bbd0c2d77
commit 6bf5eccfa7
10 changed files with 726 additions and 159 deletions
Download Patch File Download Diff File Expand all files Collapse all files

70
tools/search/multi_match_subquery.go Normal file
View File

@@ -0,0 +1,70 @@
package search
import (
"fmt"
"strings"
"github.com/pocketbase/dbx"
)
var _ dbx.Expression = (*MultiMatchSubquery)(nil)
// Join defines common fields required for a single SQL JOIN clause.
type Join struct {
TableName string
TableAlias string
On dbx.Expression
}
// MultiMatchSubquery defines a multi-match record subquery expression.
type MultiMatchSubquery struct {
TargetTableAlias string
FromTableName string
FromTableAlias string
ValueIdentifier string
Joins []*Join
Params dbx.Params
}
// Build converts the expression into a SQL fragment.
//
// Implements [dbx.Expression] interface.
func (m *MultiMatchSubquery) Build(db *dbx.DB, params dbx.Params) string {
if m.TargetTableAlias == "" || m.FromTableName == "" || m.FromTableAlias == "" {
return "0=1"
}
if params == nil {
params = m.Params
} else {
// merge by updating the parent params
for k, v := range m.Params {
params[k] = v
}
}
var mergedJoins strings.Builder
for i, j := range m.Joins {
if i > 0 {
mergedJoins.WriteString(" ")
}
mergedJoins.WriteString("LEFT JOIN ")
mergedJoins.WriteString(db.QuoteTableName(j.TableName))
mergedJoins.WriteString(" ")
mergedJoins.WriteString(db.QuoteTableName(j.TableAlias))
if j.On != nil {
mergedJoins.WriteString(" ON ")
mergedJoins.WriteString(j.On.Build(db, params))
}
}
return fmt.Sprintf(
`SELECT %s as [[multiMatchValue]] FROM %s %s %s WHERE %s = %s`,
db.QuoteColumnName(m.ValueIdentifier),
db.QuoteTableName(m.FromTableName),
db.QuoteTableName(m.FromTableAlias),
mergedJoins.String(),
db.QuoteColumnName(m.FromTableAlias+".id"),
db.QuoteColumnName(m.TargetTableAlias+".id"),
)
}

52
tools/search/multi_match_subquery_test.go Normal file
View File

@@ -0,0 +1,52 @@
package search_test
import (
"bytes"
"database/sql"
"encoding/json"
"testing"
"github.com/pocketbase/dbx"
"github.com/pocketbase/pocketbase/tools/search"
)
func TestMultiMatchSubqueryBuild(t *testing.T) {
// create a dummy db
sqlDB, err := sql.Open("sqlite", "file::memory:?cache=shared")
if err != nil {
t.Fatal(err)
}
db := dbx.NewFromDB(sqlDB, "sqlite")
mm := search.MultiMatchSubquery{
TargetTableAlias: "test_TargetTableAlias",
FromTableName: "test_FromTableName",
FromTableAlias: "test_FromTableAlias",
ValueIdentifier: "({:mm},{:external})",
Joins: []*search.Join{
{TableName: "join_table1", TableAlias: "join_alias1"},
{TableName: "join_table2", TableAlias: "join_alias2", On: dbx.NewExp("123={:join}", dbx.Params{"join": "test_join"})},
},
Params: dbx.Params{"mm": "test_mm"},
}
params := dbx.Params{"external": "test_external"}
result := mm.Build(db, params)
expectedResult := "SELECT ({:mm},{:external}) as [[multiMatchValue]] FROM `test_FromTableName` `test_FromTableAlias` LEFT JOIN `join_table1` `join_alias1` LEFT JOIN `join_table2` `join_alias2` ON 123={:join} WHERE `test_FromTableAlias`.`id` = `test_TargetTableAlias`.`id`"
if expectedResult != result {
t.Fatalf("Expected build result\n%v\ngot\n%v", expectedResult, result)
}
// the params from all expressions should be merged in the root
rawParams, err := json.Marshal(params)
if err != nil {
t.Fatal(err)
}
expectedParams := []byte(`{"external":"test_external","join":"test_join","mm":"test_mm"}`)
if !bytes.Equal(rawParams, expectedParams) {
t.Fatalf("Expected final params\n%s\ngot\n%s", expectedParams, rawParams)
}
}

2
tools/search/simple_field_resolver.go
View File

@@ -26,7 +26,7 @@ type ResolverResult struct {
// MultiMatchSubQuery is an optional sub query expression that will be added
// in addition to the combined ResolverResult expression during build.
MultiMatchSubQuery dbx.Expression
MultiMatchSubQuery *MultiMatchSubquery
// AfterBuild is an optional function that will be called after building
// and combining the result of both resolved operands/sides in a single expression.

136
tools/search/token_functions.go
View File

@@ -1,9 +1,13 @@
package search
import (
"errors"
"fmt"
"slices"
"strings"
"github.com/ganigeorgiev/fexpr"
"github.com/pocketbase/dbx"
)
var TokenFunctions = map[string]func(
@@ -53,4 +57,136 @@ var TokenFunctions = map[string]func(
Params: mergeParams(resolvedArgs[0].Params, resolvedArgs[1].Params, resolvedArgs[2].Params, resolvedArgs[3].Params),
}, nil
},
// strftime(format, [timeValue, modifier1, modifier2, ...]) returns
// a date string formatted according to the specified format argument.
//
// It is similar to the builtin SQLite strftime function (https://sqlite.org/lang_datefunc.html).
//
// It accepts 1, 2 or 3+ arguments.
//
// (1) The first (format) argument must be always a formatting string
// with valid substitutions listed in https://sqlite.org/lang_datefunc.html.
//
// (2) The second (time-value) argument is optional and must be either a date string, number or collection field identifier
// that matches one of the formats listed in https://sqlite.org/lang_datefunc.html#time_values.
//
// (3+) The remaining (modifiers) optional arguments are expected to be
// string literals matching the listed modifiers in https://sqlite.org/lang_datefunc.html#modifiers.
//
// Note that an invalid format, time-value, or modifier could result in COALESCE(strftime(...), null)
// for consistency with the non-null nature of the default PocketBase fields.
//
// A multi-match constraint will be also applied in case the time-value
// is an identifier as a result of a multi-value relation field.
"strftime": func(argTokenResolverFunc func(fexpr.Token) (*ResolverResult, error), args ...fexpr.Token) (*ResolverResult, error) {
totalArgs := len(args)
if totalArgs < 1 {
return nil, fmt.Errorf("[strftime] expected at least 1 arguments, got %d", len(args))
}
// limit the number of arguments to prevent abuse
if totalArgs > 10 {
return nil, fmt.Errorf("[strftime] too many arguments (max allowed 10, got %d)", totalArgs)
}
// format arg
// -----------------------------------------------------------
if args[0].Type != fexpr.TokenText {
return nil, errors.New("[strftime] expects the first argument to be a format string")
}
formatArgResult, err := argTokenResolverFunc(args[0])
if err != nil {
return nil, fmt.Errorf("[strftime] failed to resolve format argument: %w", err)
}
// no further arguments
if totalArgs == 1 {
formatArgResult.Identifier = "strftime(" + formatArgResult.Identifier + ")"
return formatArgResult, nil
}
// time-value arg
// -----------------------------------------------------------
allowedTimeValueTokens := []fexpr.TokenType{fexpr.TokenText, fexpr.TokenIdentifier, fexpr.TokenNumber}
if !slices.Contains(allowedTimeValueTokens, args[1].Type) {
return nil, errors.New("[strftime] expects the second argument to be of a valid time-value type")
}
timeValueArgResult, err := argTokenResolverFunc(args[1])
if err != nil {
return nil, fmt.Errorf("[strftime] failed to resolve time-value argument: %w", err)
}
// modifiers args
// -----------------------------------------------------------
resolvedModifierArgs := make([]*ResolverResult, totalArgs-2)
for i, arg := range args[2:] {
if arg.Type != fexpr.TokenText {
return nil, fmt.Errorf("[strftime] invalid modifier argument %d - can be only string", i)
}
resolved, err := argTokenResolverFunc(arg)
if err != nil {
return nil, fmt.Errorf("[strftime] failed to resolve modifier argument %d: %w", i, err)
}
resolvedModifierArgs[i] = resolved
}
// generating new ResolverResult
// -----------------------------------------------------------
result := &ResolverResult{Params: dbx.Params{}}
identifiers := make([]string, 0, totalArgs)
identifiers = append(identifiers, formatArgResult.Identifier)
if err = concatUniqueParams(result.Params, formatArgResult.Params); err != nil {
return nil, err
}
identifiers = append(identifiers, timeValueArgResult.Identifier)
if err = concatUniqueParams(result.Params, timeValueArgResult.Params); err != nil {
return nil, err
}
for _, m := range resolvedModifierArgs {
identifiers = append(identifiers, m.Identifier)
err = concatUniqueParams(result.Params, m.Params)
if err != nil {
return nil, err
}
}
result.Identifier = "strftime(" + strings.Join(identifiers, ",") + ")"
if timeValueArgResult.MultiMatchSubQuery != nil {
// replace the regular time-value identifier with the multi-match one
identifiers[1] = timeValueArgResult.MultiMatchSubQuery.ValueIdentifier
result.MultiMatchSubQuery = timeValueArgResult.MultiMatchSubQuery
result.MultiMatchSubQuery.ValueIdentifier = "strftime(" + strings.Join(identifiers, ",") + ")"
err = concatUniqueParams(result.MultiMatchSubQuery.Params, result.Params)
if err != nil {
return nil, err
}
}
return result, nil
},
}
func concatUniqueParams(destParams, newParams dbx.Params) error {
for k, v := range newParams {
found, ok := destParams[k]
if ok && v != found {
return fmt.Errorf("conflicting param key %s", k)
}
destParams[k] = v
}
return nil
}

343
tools/search/token_functions_test.go
View File

@@ -209,6 +209,345 @@ func TestTokenFunctionsGeoDistanceExec(t *testing.T) {
}
}
func TestTokenFunctionsStrftime(t *testing.T) {
t.Parallel()
testDB, err := createTestDB()
if err != nil {
t.Fatal(err)
}
defer testDB.Close()
fn, ok := TokenFunctions["strftime"]
if !ok {
t.Error("Expected strftime token function to be registered.")
}
baseTokenResolver := func(t fexpr.Token) (*ResolverResult, error) {
placeholder := "t" + security.PseudorandomString(5)
return &ResolverResult{Identifier: "{:" + placeholder + "}", Params: map[string]any{placeholder: t.Literal}}, nil
}
scenarios := []struct {
name string
args []fexpr.Token
resolver func(t fexpr.Token) (*ResolverResult, error)
result *ResolverResult
expectErr bool
}{
{
"no args",
nil,
baseTokenResolver,
nil,
true,
},
// format arg
// -----------------------------------------------------------
{
"(format arg) invalid token type function",
[]fexpr.Token{
{Literal: "abc", Type: fexpr.TokenFunction},
},
baseTokenResolver,
nil,
true,
},
{
"(format arg) invalid token type ws",
[]fexpr.Token{
{Literal: "abc", Type: fexpr.TokenWS},
},
baseTokenResolver,
nil,
true,
},
{
"(format arg) invalid token type number",
[]fexpr.Token{
{Literal: "abc", Type: fexpr.TokenNumber},
},
baseTokenResolver,
nil,
true,
},
{
"(format arg) invalid token type identifier",
[]fexpr.Token{
{Literal: "abc", Type: fexpr.TokenIdentifier},
},
baseTokenResolver,
nil,
true,
},
{
"(format arg) valid token type text",
[]fexpr.Token{
{Literal: "abc", Type: fexpr.TokenText},
},
baseTokenResolver,
&ResolverResult{
Identifier: `strftime({:format})`,
Params: map[string]any{"format": "abc"},
},
false,
},
// format + time-value args
// -----------------------------------------------------------
{
"(format arg) invalid token type function",
[]fexpr.Token{
{Literal: "1", Type: fexpr.TokenText},
{Literal: "2", Type: fexpr.TokenFunction},
},
baseTokenResolver,
nil,
true,
},
{
"(format arg) invalid token type ws",
[]fexpr.Token{
{Literal: "1", Type: fexpr.TokenText},
{Literal: "2", Type: fexpr.TokenWS},
},
baseTokenResolver,
nil,
true,
},
{
"(format arg) valid token type number",
[]fexpr.Token{
{Literal: "1", Type: fexpr.TokenText},
{Literal: "2", Type: fexpr.TokenNumber},
},
baseTokenResolver,
&ResolverResult{
Identifier: `strftime({:format},{:time})`,
Params: map[string]any{"format": "1", "time": "2"},
},
false,
},
{
"(format arg) valid token type identifier",
[]fexpr.Token{
{Literal: "1", Type: fexpr.TokenText},
{Literal: "2", Type: fexpr.TokenIdentifier},
},
baseTokenResolver,
&ResolverResult{
Identifier: `strftime({:format},{:time})`,
Params: map[string]any{"format": "1", "time": "2"},
},
false,
},
{
"(format arg) valid token type text",
[]fexpr.Token{
{Literal: "1", Type: fexpr.TokenText},
{Literal: "2", Type: fexpr.TokenText},
},
baseTokenResolver,
&ResolverResult{
Identifier: `strftime({:format},{:time})`,
Params: map[string]any{"format": "1", "time": "2"},
},
false,
},
// format + time-value + modifier args
// -----------------------------------------------------------
{
"(modifiers arg) invalid token type function",
[]fexpr.Token{
{Literal: "1", Type: fexpr.TokenText}, // valid format
{Literal: "2", Type: fexpr.TokenText}, // valid time-value
{Literal: "3", Type: fexpr.TokenText}, // valid modifier
{Literal: "4", Type: fexpr.TokenFunction},
},
baseTokenResolver,
nil,
true,
},
{
"(modifiers arg) invalid token type ws",
[]fexpr.Token{
{Literal: "1", Type: fexpr.TokenText}, // valid format
{Literal: "2", Type: fexpr.TokenText}, // valid time-value
{Literal: "3", Type: fexpr.TokenText}, // valid modifier
{Literal: "4", Type: fexpr.TokenWS},
},
baseTokenResolver,
nil,
true,
},
{
"(modifiers arg) valid token type number",
[]fexpr.Token{
{Literal: "1", Type: fexpr.TokenText}, // valid format
{Literal: "2", Type: fexpr.TokenText}, // valid time-value
{Literal: "3", Type: fexpr.TokenText}, // valid modifier
{Literal: "4", Type: fexpr.TokenNumber},
},
baseTokenResolver,
nil,
true,
},
{
"(modifiers arg) valid token type identifier",
[]fexpr.Token{
{Literal: "1", Type: fexpr.TokenText}, // valid format
{Literal: "2", Type: fexpr.TokenText}, // valid time-value
{Literal: "3", Type: fexpr.TokenText}, // valid modifier
{Literal: "4", Type: fexpr.TokenIdentifier},
},
baseTokenResolver,
nil,
true,
},
{
"(modifiers arg) valid token type text",
[]fexpr.Token{
{Literal: "1", Type: fexpr.TokenText}, // valid format
{Literal: "2", Type: fexpr.TokenText}, // valid time-value
{Literal: "3", Type: fexpr.TokenText}, // valid modifier
{Literal: "4", Type: fexpr.TokenText}, // valid modifier
},
baseTokenResolver,
&ResolverResult{
Identifier: `strftime({:format},{:time},{:m1},{:m2})`,
Params: map[string]any{"format": "1", "time": "2", "m1": "3", "m2": "4"},
},
false,
},
// -----------------------------------------------------------
{
"= 10 args limit",
[]fexpr.Token{
{Literal: "1", Type: fexpr.TokenText},
{Literal: "2", Type: fexpr.TokenText},
{Literal: "3", Type: fexpr.TokenText},
{Literal: "4", Type: fexpr.TokenText},
{Literal: "5", Type: fexpr.TokenText},
{Literal: "6", Type: fexpr.TokenText},
{Literal: "7", Type: fexpr.TokenText},
{Literal: "8", Type: fexpr.TokenText},
{Literal: "9", Type: fexpr.TokenText},
{Literal: "10", Type: fexpr.TokenText},
},
baseTokenResolver,
&ResolverResult{
Identifier: `strftime({:format},{:time},{:m1},{:m2},{:m3},{:m4},{:m5},{:m6},{:m7},{:m8})`,
Params: map[string]any{
"format": "1",
"time": "2",
"m1": "3",
"m2": "4",
"m3": "5",
"m4": "6",
"m5": "7",
"m6": "8",
"m7": "9",
"m8": "10",
},
},
false,
},
{
"> 10 args limit",
[]fexpr.Token{
{Literal: "1", Type: fexpr.TokenText},
{Literal: "2", Type: fexpr.TokenText},
{Literal: "3", Type: fexpr.TokenText},
{Literal: "4", Type: fexpr.TokenText},
{Literal: "5", Type: fexpr.TokenText},
{Literal: "6", Type: fexpr.TokenText},
{Literal: "7", Type: fexpr.TokenText},
{Literal: "8", Type: fexpr.TokenText},
{Literal: "9", Type: fexpr.TokenText},
{Literal: "10", Type: fexpr.TokenText},
{Literal: "11", Type: fexpr.TokenText},
},
baseTokenResolver,
nil,
true,
},
{
"valid arguments but with resolver error",
[]fexpr.Token{
{Literal: "1", Type: fexpr.TokenText},
{Literal: "2", Type: fexpr.TokenText},
{Literal: "3", Type: fexpr.TokenText},
},
func(t fexpr.Token) (*ResolverResult, error) {
return nil, errors.New("test")
},
nil,
true,
},
}
for _, s := range scenarios {
t.Run(s.name, func(t *testing.T) {
result, err := fn(s.resolver, s.args...)
hasErr := err != nil
if hasErr != s.expectErr {
t.Fatalf("Expected hasErr %v, got %v (%v)", s.expectErr, hasErr, err)
}
testCompareResults(t, s.result, result)
})
}
}
func TestTokenFunctionsStrftimeExec(t *testing.T) {
t.Parallel()
testDB, err := createTestDB()
if err != nil {
t.Fatal(err)
}
defer testDB.Close()
fn, ok := TokenFunctions["strftime"]
if !ok {
t.Error("Expected strftime token function to be registered.")
}
result, err := fn(
func(t fexpr.Token) (*ResolverResult, error) {
placeholder := "t" + security.PseudorandomString(5)
return &ResolverResult{Identifier: "{:" + placeholder + "}", Params: map[string]any{placeholder: t.Literal}}, nil
},
fexpr.Token{Literal: "%Y-%m", Type: fexpr.TokenText},
fexpr.Token{Literal: "2026-01-02 01:02:03.456Z", Type: fexpr.TokenText},
fexpr.Token{Literal: "+1 years", Type: fexpr.TokenText},
fexpr.Token{Literal: "+5 months", Type: fexpr.TokenText},
)
if err != nil {
t.Fatal(err)
}
column := []string{}
err = testDB.NewQuery("select " + result.Identifier).Bind(result.Params).Column(&column)
if err != nil {
t.Fatal(err)
}
if len(column) != 1 {
t.Fatalf("Expected exactly 1 column value as result, got %v", column)
}
expected := "2027-06"
if column[0] != expected {
t.Fatalf("Expected date value %s, got %s", expected, column[0])
}
}
// -------------------------------------------------------------------
func testCompareResults(t *testing.T, a, b *ResolverResult) {
@@ -262,6 +601,10 @@ func testCompareResults(t *testing.T, a, b *ResolverResult) {
t.Fatalf("Expected NoCoalesce to match, got %v vs %v", a.NoCoalesce, b.NoCoalesce)
}
if len(a.Params) != len(b.Params) {
t.Fatalf("Expected equal number of params, got %v vs %v", len(a.Params), len(b.Params))
}
// loose placeholders replacement
var aResolved = a.Identifier
for k, v := range a.Params {