func Where(field string) *Criterion {
	if !startsUpper(field) {
		panic("The first letter of a field in a badgerhold query must be upper-case")
	}
	return &Criterion{
		query: &Query{
			currentField:  field,
			fieldCriteria: make(map[string][]*Criterion),
		},
	}
}
Where starts a query for specifying the criteria that an object in the badgerhold needs to match to
be returned in a Find result
/*
Query API Example

s.Find(badgerhold.Where("FieldName").Eq(value).And("AnotherField").Lt(AnotherValue).
Or(badgerhold.Where("FieldName").Eq(anotherValue)

Since Gobs only encode exported fields, this will panic if you pass in a field with a lower case first letter
package badgerhold
import (
	"fmt"
	"reflect"
	"regexp"
	"sort"
	"strings"
	"unicode"
	"github.com/dgraph-io/badger/v3"
)
const (
	eq    = iota  
	ne            
	gt            
	lt            
	ge            
	le            
	in            
	re            
	fn            
	isnil         
	sw            
	ew            
	hk            
	contains  
	any       
	all       
)
const Key = ""
type Query struct {
	index         string
	currentField  string
	fieldCriteria map[string][]*Criterion
	ors           []*Query
	badIndex bool
	dataType reflect.Type
	tx       *badger.Txn
	writable bool
	subquery bool
	bookmark *iterBookmark
	limit   int
	skip    int
	sort    []string
	reverse bool
}
func Slice(value interface{}) []interface{} {
	slc := reflect.ValueOf(value)
	s := make([]interface{}, slc.Len(), slc.Len())  
	for i := range s {
		s[i] = slc.Index(i).Interface()
	}
	return s
}
func (q *Query) IsEmpty() bool {
	if q.index != "" {
		return false
	}
	if len(q.fieldCriteria) != 0 {
		return false
	}
	if q.ors != nil {
		return false
	}
	return true
}
type Criterion struct {
	query    *Query
	operator int
	value    interface{}
	values   []interface{}
}
func hasMatchFunc(criteria []*Criterion) bool {
	for _, c := range criteria {
		if c.operator == fn {
			return true
		}
	}
	return false
}
type Field string