func (c *Criterion) ContainsAll(values ...interface{}) *Query {
	c.operator = all
	c.values = values
	q := c.query
	q.fieldCriteria[q.currentField] = append(q.fieldCriteria[q.currentField], c)
	return q
}
ContainsAll tests if the current field is a slice that contains all of the passed in values.  If any of the
values are NOT contained in the slice, then no match is made
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
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),
		},
	}
}
func (q *Query) And(field string) *Criterion {
	if !startsUpper(field) {
		panic("The first letter of a field in a badgerhold query must be upper-case")
	}
	q.currentField = field
	return &Criterion{
		query: q,
	}
}
func (q *Query) Skip(amount int) *Query {
	if amount < 0 {
		panic("Skip must be set to a positive number")
	}
	if q.skip != 0 {
		panic(fmt.Sprintf("Skip has already been set to %d", q.skip))
	}
	q.skip = amount
	return q
}
func (q *Query) Limit(amount int) *Query {
	if amount < 0 {
		panic("Limit must be set to a positive number")
	}
	if q.limit != 0 {
		panic(fmt.Sprintf("Limit has already been set to %d", q.limit))
	}
	q.limit = amount
	return q
}
func (c *Criterion) Contains(value interface{}) *Query {
	return c.op(contains, value)
}