func (g Gt) Build() ([]string, []interface{}) {
	return build(g, ">")
}
Build implements the Comparable interface
package builder
import (
	"errors"
	"fmt"
	"sort"
	"strings"
)
var (
	errInsertDataNotMatch = errors.New("insert data not match")
	errInsertNullData     = errors.New("insert null data")
	errOrderByParam       = errors.New("order param only should be ASC or DESC")
	allowedLockMode = map[string]string{
		"share":     " LOCK IN SHARE MODE",
		"exclusive": " FOR UPDATE",
	}
)
var (
	defaultSortAlgorithm = sort.Strings
)
type Comparable interface {
	Build() ([]string, []interface{})
}
type NullType byte
func (nt NullType) String() string {
	if nt == IsNull {
		return "IS NULL"
	}
	return "IS NOT NULL"
}
const (
	_ NullType = iota
	IsNull
	IsNotNull
)
type nullCompareble map[string]interface{}
func (n nullCompareble) Build() ([]string, []interface{}) {
	length := len(n)
	if nil == n || 0 == length {
		return nil, nil
	}
	sortedKey := make([]string, 0, length)
	cond := make([]string, 0, length)
	for k := range n {
		sortedKey = append(sortedKey, k)
	}
	defaultSortAlgorithm(sortedKey)
	for _, field := range sortedKey {
		v, ok := n[field]
		if !ok {
			continue
		}
		rv, ok := v.(NullType)
		if !ok {
			continue
		}
		cond = append(cond, field+" "+rv.String())
	}
	return cond, nil
}
type nilComparable byte
func (n nilComparable) Build() ([]string, []interface{}) {
	return nil, nil
}
type Like map[string]interface{}
func (l Like) Build() ([]string, []interface{}) {
	if nil == l || 0 == len(l) {
		return nil, nil
	}
	var cond []string
	var vals []interface{}
	for k := range l {
		cond = append(cond, k)
	}
	defaultSortAlgorithm(cond)
	for j := 0; j < len(cond); j++ {
		val := l[cond[j]]
		cond[j] = cond[j] + " LIKE ?"
		vals = append(vals, val)
	}
	return cond, vals
}
type NotLike map[string]interface{}
func (l NotLike) Build() ([]string, []interface{}) {
	if nil == l || 0 == len(l) {
		return nil, nil
	}
	var cond []string
	var vals []interface{}
	for k := range l {
		cond = append(cond, k)
	}
	defaultSortAlgorithm(cond)
	for j := 0; j < len(cond); j++ {
		val := l[cond[j]]
		cond[j] = cond[j] + " NOT LIKE ?"
		vals = append(vals, val)
	}
	return cond, vals
}
type Eq map[string]interface{}
func (e Eq) Build() ([]string, []interface{}) {
	return build(e, "=")
}
type Ne map[string]interface{}
func (n Ne) Build() ([]string, []interface{}) {
	return build(n, "!=")
}
type Lt map[string]interface{}
func (l Lt) Build() ([]string, []interface{}) {
	return build(l, "<")
}
type Lte map[string]interface{}
func (l Lte) Build() ([]string, []interface{}) {
	return build(l, "<=")
}
type Gt map[string]interface{}