You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
261 lines
6.7 KiB
261 lines
6.7 KiB
// Package query provides a parser for a custom query format:
|
|
//
|
|
// abci.invoice.number=22 AND abci.invoice.owner=Ivan
|
|
//
|
|
// See query.peg for the grammar, which is a https://en.wikipedia.org/wiki/Parsing_expression_grammar.
|
|
// More: https://github.com/PhilippeSigaud/Pegged/wiki/PEG-Basics
|
|
//
|
|
// It has a support for numbers (integer and floating point), dates and times.
|
|
package query
|
|
|
|
import (
|
|
"fmt"
|
|
"reflect"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
)
|
|
|
|
// Query holds the query string and the query parser.
|
|
type Query struct {
|
|
str string
|
|
parser *QueryParser
|
|
}
|
|
|
|
// New parses the given string and returns a query or error if the string is
|
|
// invalid.
|
|
func New(s string) (*Query, error) {
|
|
p := &QueryParser{Buffer: fmt.Sprintf(`"%s"`, s)}
|
|
p.Init()
|
|
if err := p.Parse(); err != nil {
|
|
return nil, err
|
|
}
|
|
return &Query{str: s, parser: p}, nil
|
|
}
|
|
|
|
// MustParse turns the given string into a query or panics; for tests or others
|
|
// cases where you know the string is valid.
|
|
func MustParse(s string) *Query {
|
|
q, err := New(s)
|
|
if err != nil {
|
|
panic(fmt.Sprintf("failed to parse %s: %v", s, err))
|
|
}
|
|
return q
|
|
}
|
|
|
|
// String returns the original string.
|
|
func (q *Query) String() string {
|
|
return q.str
|
|
}
|
|
|
|
type operator uint8
|
|
|
|
const (
|
|
opLessEqual operator = iota
|
|
opGreaterEqual
|
|
opLess
|
|
opGreater
|
|
opEqual
|
|
opContains
|
|
)
|
|
|
|
// Matches returns true if the query matches the given set of tags, false otherwise.
|
|
//
|
|
// For example, query "name=John" matches tags = {"name": "John"}. More
|
|
// examples could be found in parser_test.go and query_test.go.
|
|
func (q *Query) Matches(tags map[string]interface{}) bool {
|
|
if len(tags) == 0 {
|
|
return false
|
|
}
|
|
|
|
buffer, begin, end := q.parser.Buffer, 0, 0
|
|
|
|
var tag string
|
|
var op operator
|
|
|
|
// tokens must be in the following order: tag ("tx.gas") -> operator ("=") -> operand ("7")
|
|
for _, token := range q.parser.Tokens() {
|
|
switch token.pegRule {
|
|
|
|
case rulePegText:
|
|
begin, end = int(token.begin), int(token.end)
|
|
case ruletag:
|
|
tag = buffer[begin:end]
|
|
case rulele:
|
|
op = opLessEqual
|
|
case rulege:
|
|
op = opGreaterEqual
|
|
case rulel:
|
|
op = opLess
|
|
case ruleg:
|
|
op = opGreater
|
|
case ruleequal:
|
|
op = opEqual
|
|
case rulecontains:
|
|
op = opContains
|
|
case rulevalue:
|
|
// strip single quotes from value (i.e. "'NewBlock'" -> "NewBlock")
|
|
valueWithoutSingleQuotes := buffer[begin+1 : end-1]
|
|
|
|
// see if the triplet (tag, operator, operand) matches any tag
|
|
// "tx.gas", "=", "7", { "tx.gas": 7, "tx.ID": "4AE393495334" }
|
|
if !match(tag, op, reflect.ValueOf(valueWithoutSingleQuotes), tags) {
|
|
return false
|
|
}
|
|
case rulenumber:
|
|
number := buffer[begin:end]
|
|
if strings.Contains(number, ".") { // if it looks like a floating-point number
|
|
value, err := strconv.ParseFloat(number, 64)
|
|
if err != nil {
|
|
panic(fmt.Sprintf("got %v while trying to parse %s as float64 (should never happen if the grammar is correct)", err, number))
|
|
}
|
|
if !match(tag, op, reflect.ValueOf(value), tags) {
|
|
return false
|
|
}
|
|
} else {
|
|
value, err := strconv.ParseInt(number, 10, 64)
|
|
if err != nil {
|
|
panic(fmt.Sprintf("got %v while trying to parse %s as int64 (should never happen if the grammar is correct)", err, number))
|
|
}
|
|
if !match(tag, op, reflect.ValueOf(value), tags) {
|
|
return false
|
|
}
|
|
}
|
|
case ruletime:
|
|
value, err := time.Parse(time.RFC3339, buffer[begin:end])
|
|
if err != nil {
|
|
panic(fmt.Sprintf("got %v while trying to parse %s as time.Time / RFC3339 (should never happen if the grammar is correct)", err, buffer[begin:end]))
|
|
}
|
|
if !match(tag, op, reflect.ValueOf(value), tags) {
|
|
return false
|
|
}
|
|
case ruledate:
|
|
value, err := time.Parse("2006-01-02", buffer[begin:end])
|
|
if err != nil {
|
|
panic(fmt.Sprintf("got %v while trying to parse %s as time.Time / '2006-01-02' (should never happen if the grammar is correct)", err, buffer[begin:end]))
|
|
}
|
|
if !match(tag, op, reflect.ValueOf(value), tags) {
|
|
return false
|
|
}
|
|
}
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
// match returns true if the given triplet (tag, operator, operand) matches any tag.
|
|
//
|
|
// First, it looks up the tag in tags and if it finds one, tries to compare the
|
|
// value from it to the operand using the operator.
|
|
//
|
|
// "tx.gas", "=", "7", { "tx.gas": 7, "tx.ID": "4AE393495334" }
|
|
func match(tag string, op operator, operand reflect.Value, tags map[string]interface{}) bool {
|
|
// look up the tag from the query in tags
|
|
value, ok := tags[tag]
|
|
if !ok {
|
|
return false
|
|
}
|
|
switch operand.Kind() {
|
|
case reflect.Struct: // time
|
|
operandAsTime := operand.Interface().(time.Time)
|
|
v, ok := value.(time.Time)
|
|
if !ok { // if value from tags is not time.Time
|
|
return false
|
|
}
|
|
switch op {
|
|
case opLessEqual:
|
|
return v.Before(operandAsTime) || v.Equal(operandAsTime)
|
|
case opGreaterEqual:
|
|
return v.Equal(operandAsTime) || v.After(operandAsTime)
|
|
case opLess:
|
|
return v.Before(operandAsTime)
|
|
case opGreater:
|
|
return v.After(operandAsTime)
|
|
case opEqual:
|
|
return v.Equal(operandAsTime)
|
|
}
|
|
case reflect.Float64:
|
|
operandFloat64 := operand.Interface().(float64)
|
|
var v float64
|
|
// try our best to convert value from tags to float64
|
|
switch vt := value.(type) {
|
|
case float64:
|
|
v = vt
|
|
case float32:
|
|
v = float64(vt)
|
|
case int:
|
|
v = float64(vt)
|
|
case int8:
|
|
v = float64(vt)
|
|
case int16:
|
|
v = float64(vt)
|
|
case int32:
|
|
v = float64(vt)
|
|
case int64:
|
|
v = float64(vt)
|
|
default: // fail for all other types
|
|
panic(fmt.Sprintf("Incomparable types: %T (%v) vs float64 (%v)", value, value, operandFloat64))
|
|
}
|
|
switch op {
|
|
case opLessEqual:
|
|
return v <= operandFloat64
|
|
case opGreaterEqual:
|
|
return v >= operandFloat64
|
|
case opLess:
|
|
return v < operandFloat64
|
|
case opGreater:
|
|
return v > operandFloat64
|
|
case opEqual:
|
|
return v == operandFloat64
|
|
}
|
|
case reflect.Int64:
|
|
operandInt := operand.Interface().(int64)
|
|
var v int64
|
|
// try our best to convert value from tags to int64
|
|
switch vt := value.(type) {
|
|
case int64:
|
|
v = vt
|
|
case int8:
|
|
v = int64(vt)
|
|
case int16:
|
|
v = int64(vt)
|
|
case int32:
|
|
v = int64(vt)
|
|
case int:
|
|
v = int64(vt)
|
|
case float64:
|
|
v = int64(vt)
|
|
case float32:
|
|
v = int64(vt)
|
|
default: // fail for all other types
|
|
panic(fmt.Sprintf("Incomparable types: %T (%v) vs int64 (%v)", value, value, operandInt))
|
|
}
|
|
switch op {
|
|
case opLessEqual:
|
|
return v <= operandInt
|
|
case opGreaterEqual:
|
|
return v >= operandInt
|
|
case opLess:
|
|
return v < operandInt
|
|
case opGreater:
|
|
return v > operandInt
|
|
case opEqual:
|
|
return v == operandInt
|
|
}
|
|
case reflect.String:
|
|
v, ok := value.(string)
|
|
if !ok { // if value from tags is not string
|
|
return false
|
|
}
|
|
switch op {
|
|
case opEqual:
|
|
return v == operand.String()
|
|
case opContains:
|
|
return strings.Contains(v, operand.String())
|
|
}
|
|
default:
|
|
panic(fmt.Sprintf("Unknown kind of operand %v", operand.Kind()))
|
|
}
|
|
|
|
return false
|
|
}
|