querytool

README

The root structure for select request

{
   "filters":{},
   "sorting":[],
   "limit":100,
   "offset":0
}

Every field may be ommited for using default params.

Available filtering operators

Strict selection

Examples for using strict operator = (equal):
{"username": "john_doe"} is similar "{username": { "=": "john_doe" }}
For non string types: {"status": 2}, {"is_moderated": false}

Examples for using strict operator!= (not equal):
{"username": { "!=": "john_smith" }}, {"status": { "!=": 3 }}, {"is_moderated": { "!=": true }}

List entry selection

Examples for using operator in:
{"country": { "in": [ "ru", "us", "es" ]}}, {"status": { "in": [3, 4, 5] }}
Examples for using operator not in:
{"country": { "not in": [ "ua", "kz" ] }}, {"sex": { "in": [0, 1]}}

Conditional selection

Available operators:

• "lt" less than "<"
• "gt" greater than ">"
• "lte" greater than "<="
• "gte" greater than ">="

{"balance": { "lte": 4.3242 }}, {"size": { "lt": 15 }}

Wildcard string selection

{"username": { "like": "%super%" }}, {"firstname": { "like": "John S%" }}

Using sorting

Sorting may get string array column direction or array of key-value{"column" : "direction"}, but do not mix it: Examples: ["id DESC", "balance ASC"] or [{"id" : "DESC"}, {"balance" : "ASC"}]

Example JSON request

{
   "filters":{
      "phone":{
         "like":"+1213%"
      },
      "sex":1,
      "firstname":{
         "in":[
            "John",
            "Jake"
         ]
      }
   },
   "sorting":[
      {"id": "DESC"}
   ],
   "limit":200,
   "offset":0
}

Example QUERY request

http://example.com/list?filters[phone][like]=+1213%&filters[sex]=1&filters[firstname][in][]=John&filters[firstname][in][]=Jake&sorting[0][id]=DESC&limit=200&offset=0

Example code

package requests

import (
	querytool "github.com/censync/go-squirrel-querytool"
)

type UsersListQueryForm struct {
	querytool.Query
}

Binding JSON request

func GetUsersList(c echo.Context) error {
   request := &req.UsersListQueryForm{}

   err := request.BindQuery(c.QueryParams())

   if err != nil {
	return err
   }
   
   users := service.UserService().GetUsersList(request)
   return c.JSON(200, users)
}

Binding query request

```go
func GetUsersList(c echo.Context) error {
   request := &req.UsersListQueryForm{}

   err := c.Bind(request)

   if err != nil {
	return err
   }
   
   users := service.UserService().GetUsersList(request)
   return c.JSON(200, users)
}

Documentation

Overview

query example:

{
   "filters":{
      "phone":{
         "like":"+7%"
      },
      "sex":0,
      "firstname":{
         "in":[
            "firstname",
            ""
         ]
      }
   },
   "sort":[
      "created_at ASC"
   ],
   "limit":200,
   "offset":0
}

Index

• Variables
• func ApplyQuery(q *squirrel.SelectBuilder, scheme *Scheme, query *Query) error
• type BoolResolver
  • func (fr BoolResolver) ToExpr(arg interface{}, label string) (string, []interface{}, error)
• type FilterResolver
• type FloatResolver
  • func (fr FloatResolver) ToExpr(arg interface{}, label string) (string, []interface{}, error)
• type IntResolver
  • func (ir IntResolver) ToExpr(arg interface{}, label string) (string, []interface{}, error)
• type Query
  • func (f *Query) BindQuery(params url.Values) (err error)
• type Scheme
• type StringResolver
  • func (sr StringResolver) ToExpr(arg interface{}, label string) (string, []interface{}, error)
• type TimestampResolver
  • func (ir TimestampResolver) ToExpr(arg interface{}, label string) (string, []interface{}, error)

Variables

var (
	Int     = IntResolver{}.ToExpr
	Float   = FloatResolver{}.ToExpr
	String  = StringResolver{}.ToExpr
	Boolean = BoolResolver{}.ToExpr
)

var ErrUnknownField = errors.New("unknown_field")

var (
	ErrWrongType = errors.New("wrong_type")
)

Functions

func ApplyQuery

func ApplyQuery(q *squirrel.SelectBuilder, scheme *Scheme, query *Query) error

Types

type BoolResolver

type BoolResolver struct{}

func (BoolResolver) ToExpr

func (fr BoolResolver) ToExpr(arg interface{}, label string) (string, []interface{}, error)

type FilterResolver

type FilterResolver func(arg interface{}, label string) (string, []interface{}, error)

type FloatResolver

type FloatResolver struct{}

func (FloatResolver) ToExpr

func (fr FloatResolver) ToExpr(arg interface{}, label string) (string, []interface{}, error)

type IntResolver

type IntResolver struct{}

func (IntResolver) ToExpr

func (ir IntResolver) ToExpr(arg interface{}, label string) (string, []interface{}, error)

type Query

type Query struct {
	Filters map[string]interface{} `json:"filters"`
	Sorting interface{}            `json:"sorting"`
	Limit   uint64                 `json:"limit"`
	Offset  uint64                 `json:"offset"`
}

func (*Query) BindQuery

func (f *Query) BindQuery(params url.Values) (err error)

Parse query from url values

type Scheme

type Scheme struct {
	Resolvers     map[string]FilterResolver
	DefaultOffset uint64
	DefaultLimit  uint64 // global default = globalDefaultLimit
	DefaultSort   []string
}

type StringResolver

type StringResolver struct{}

func (StringResolver) ToExpr

func (sr StringResolver) ToExpr(arg interface{}, label string) (string, []interface{}, error)

type TimestampResolver

type TimestampResolver struct{}

func (TimestampResolver) ToExpr

func (ir TimestampResolver) ToExpr(arg interface{}, label string) (string, []interface{}, error)