filter - a simple struct field filter and sorter for go

Query Syntax

Matching

Explicit match: <struct field>:<struct value>

Wildcard match (use ** to match the '*' character):

<struct field>:*<right part of struct value>
<struct field>:<left part of struct value>*
<struct field>:*<middl of struct value>*

Nested structs: <struct field>.<struct field>:<struct value>

Multiple matches (seperated by a single whitespace):

<struct field>:<struct value> <struct field>:<struct value>*

Bool does not support the wildcard operator, only the literal strings true and false.

Sorting

The sort statement consists of the literal string sort, the field name (nesting like above is supported) and the literal strings asc or desc.

sort:<struct field>:asc
sort:<struct field>:desc
sort:<struct field>.<struct field>:desc

Struct fields

Supported struct field values are:

• int, int8, int16, int32, int64
• float32, float64
• string
• bool

For nested structs:

• struct

Filter logic

Supported logical matching:

• AND - all statements have to match (if no logic is provided, this is the default)
• OR - only one statement has to match
• NOT - none of the statements have to match

Examples

// Example data structure
type Example struct {
        String string
        Int    int
        Bool   bool
        Struct Struct1
}

type Struct1 struct {
        String string
        Struct Struct2
}

type Struct2 struct {
        Int int
}

// Filter implements the filter.Filter interface
type Filter []Example

func (v Filter) Len() int                { return len(v) }
func (v Filter) Index(i int) interface{} { return v[i] }
func (v *Filter) Remove(i, j int)        { *v = append((*v)[:i], (*v)[j:]...) }

// Example data
var data = Filter{
        {"str1", 42, true, Struct1{"s1", Struct2{1}}},
        {"2str", 42, true, Struct1{"s2", Struct2{2}}},
        {"str3", 42, false, Struct1{"s3", Struct2{3}}},
}

Explicit match

filter.NewQuery("OR Bool:true").Filter(&data)

data = [{str1 42 true {s1 {1}}} {str2 42 true {s2 {2}}}]

Wildcard match

Wildcard operator: *
To match the '*' character use: **

filter.NewQuery("OR String:s*").Filter(&data)

data = [{str1 42 true {s1 {1}}} {str3 42 false {s3 {3}}}]

Nested struct match

filter.NewQuery("OR Struct.Struct.Int:3").Filter(&data)

data = [{str3 42 false {s3 {3}}}]

Multiple matches

filter.NewQuery("Struct.String:*2 Bool:true").Filter(&data)

data = [{2str 42 true {s2 {2}}}]

Sorting

The GenericFilter does not support sorting.

Sort

filter.NewQuery("sort:Bool:desc").Filter(&data)

data = [{str1 42 false {s1 {1}}} {2str 42 true {s2 {2}}} {str3 42 true {s3 {3}}}]

Sort and Filter

filter.NewQuery("sort:Bool:desc String:str*").Filter(&data)

data = [{str1 42 false {s1 {1}}} {str3 42 true {s3 {3}}}]

Benchmarks

go test -bench .
BenchmarkNewQuerySimple-4           	 2000000	       974 ns/op	     272 B/op	       8 allocs/op
BenchmarkNewQueryComplex-4          	  500000	      2779 ns/op	     848 B/op	      20 allocs/op
BenchmarkNewQueryComplexOr-4        	  500000	      2677 ns/op	     832 B/op	      20 allocs/op
BenchmarkNewQuerySort-4             	 3000000	       576 ns/op	     160 B/op	       4 allocs/op
BenchmarkNewQuerySortSimple-4       	 1000000	      1192 ns/op	     304 B/op	       9 allocs/op
BenchmarkNewQuerySortComplex-4      	  500000	      2598 ns/op	     784 B/op	      19 allocs/op
BenchmarkNewQuerySortComplexOr-4    	  500000	      2326 ns/op	     768 B/op	      19 allocs/op
BenchmarkFilterSimple-4             	 1000000	      2123 ns/op	     432 B/op	      12 allocs/op
BenchmarkFilterComplex-4            	  200000	      6840 ns/op	     672 B/op	      42 allocs/op
BenchmarkFilterComplexOr-4          	  300000	      5929 ns/op	     744 B/op	      30 allocs/op
BenchmarkSort-4                     	  200000	      7859 ns/op	    1864 B/op	      51 allocs/op
BenchmarkSortFilterSimple-4         	  200000	      6294 ns/op	    1432 B/op	      39 allocs/op
BenchmarkSortFilterComplex-4        	  200000	     11990 ns/op	    1672 B/op	      69 allocs/op
BenchmarkSortFilterComplexOr-4      	  200000	     12138 ns/op	    2176 B/op	      69 allocs/op
BenchmarkGenericFilterSimple-4      	  300000	      5939 ns/op	    1200 B/op	      24 allocs/op
BenchmarkGenericFilterComplex-4     	  100000	     16638 ns/op	    1680 B/op	      84 allocs/op
BenchmarkGenericFilterComplexOr-4   	  200000	     11846 ns/op	    2360 B/op	      49 allocs/op