func Like(column string) Cmp {
	return Cmp{
		op:     like,
		column: column,
		value:  param(column),
	}
}
Like produces column LIKE ?.
package qb
import (
	"bytes"
)
type op byte
const (
	eq op = iota
	ne
	lt
	leq
	gt
	geq
	in
	cnt
	cntKey
	like
)
type Cmp struct {
	op     op
	column string
	value  value
}
func (c Cmp) writeCql(cql *bytes.Buffer) (names []string) {
	cql.WriteString(c.column)
	switch c.op {
	case eq:
		cql.WriteByte('=')
	case ne:
		cql.WriteString("!=")
	case lt:
		cql.WriteByte('<')
	case leq:
		cql.WriteByte('<')
		cql.WriteByte('=')
	case gt:
		cql.WriteByte('>')
	case geq:
		cql.WriteByte('>')
		cql.WriteByte('=')
	case in:
		cql.WriteString(" IN ")
	case cnt:
		cql.WriteString(" CONTAINS ")
	case cntKey:
		cql.WriteString(" CONTAINS KEY ")
	case like:
		cql.WriteString(" LIKE ")
	}
	return c.value.writeCql(cql)
}
func Eq(column string) Cmp {
	return Cmp{
		op:     eq,
		column: column,
		value:  param(column),
	}
}
func EqTuple(column string, count int) Cmp {
	return Cmp{
		op:     eq,
		column: column,
		value: tupleParam{
			param: param(column),
			count: count,
		},
	}
}
func EqNamed(column, name string) Cmp {
	return Cmp{
		op:     eq,
		column: column,
		value:  param(name),
	}
}
func EqLit(column, literal string) Cmp {
	return Cmp{
		op:     eq,
		column: column,
		value:  lit(literal),
	}
}
func EqFunc(column string, fn *Func) Cmp {
	return Cmp{
		op:     eq,
		column: column,
		value:  fn,
	}
}
func Ne(column string) Cmp {
	return Cmp{
		op:     ne,
		column: column,
		value:  param(column),
	}
}
func NeTuple(column string, count int) Cmp {
	return Cmp{
		op:     ne,
		column: column,
		value: tupleParam{
			param: param(column),
			count: count,
		},
	}
}
func NeNamed(column, name string) Cmp {
	return Cmp{
		op:     ne,
		column: column,
		value:  param(name),
	}
}
func NeLit(column, literal string) Cmp {
	return Cmp{
		op:     ne,
		column: column,
		value:  lit(literal),
	}
}
func NeFunc(column string, fn *Func) Cmp {
	return Cmp{
		op:     ne,
		column: column,
		value:  fn,
	}
}
func Lt(column string) Cmp {
	return Cmp{
		op:     lt,
		column: column,
		value:  param(column),
	}
}
func LtTuple(column string, count int) Cmp {
	return Cmp{
		op:     lt,
		column: column,
		value: tupleParam{
			param: param(column),
			count: count,
		},
	}
}
func LtNamed(column, name string) Cmp {
	return Cmp{
		op:     lt,
		column: column,
		value:  param(name),
	}
}
func LtLit(column, literal string) Cmp {
	return Cmp{
		op:     lt,
		column: column,
		value:  lit(literal),
	}
}
func LtFunc(column string, fn *Func) Cmp {
	return Cmp{
		op:     lt,
		column: column,
		value:  fn,
	}
}
func LtOrEq(column string) Cmp {
	return Cmp{
		op:     leq,
		column: column,
		value:  param(column),
	}
}
func LtOrEqTuple(column string, count int) Cmp {
	return Cmp{
		op:     leq,
		column: column,
		value: tupleParam{
			param: param(column),
			count: count,
		},
	}
}
func LtOrEqNamed(column, name string) Cmp {
	return Cmp{
		op:     leq,
		column: column,
		value:  param(name),
	}
}
func LtOrEqLit(column, literal string) Cmp {
	return Cmp{
		op:     leq,
		column: column,
		value:  lit(literal),
	}
}
func LtOrEqFunc(column string, fn *Func) Cmp {
	return Cmp{
		op:     leq,
		column: column,
		value:  fn,
	}
}
func Gt(column string) Cmp {
	return Cmp{
		op:     gt,
		column: column,
		value:  param(column),
	}
}
func GtTuple(column string, count int) Cmp {
	return Cmp{
		op:     gt,
		column: column,
		value: tupleParam{
			param: param(column),
			count: count,
		},
	}
}
func GtNamed(column, name string) Cmp {
	return Cmp{
		op:     gt,
		column: column,
		value:  param(name),
	}
}
func GtLit(column, literal string) Cmp {
	return Cmp{
		op:     gt,
		column: column,
		value:  lit(literal),
	}
}
func GtFunc(column string, fn *Func) Cmp {
	return Cmp{
		op:     gt,
		column: column,
		value:  fn,
	}
}
func GtOrEq(column string) Cmp {
	return Cmp{
		op:     geq,
		column: column,
		value:  param(column),
	}
}
func GtOrEqTuple(column string, count int) Cmp {
	return Cmp{
		op:     geq,
		column: column,
		value: tupleParam{
			param: param(column),
			count: count,
		},
	}
}
func GtOrEqNamed(column, name string) Cmp {
	return Cmp{
		op:     geq,
		column: column,
		value:  param(name),
	}
}
func GtOrEqLit(column, literal string) Cmp {
	return Cmp{
		op:     geq,
		column: column,
		value:  lit(literal),
	}
}
func GtOrEqFunc(column string, fn *Func) Cmp {
	return Cmp{
		op:     geq,
		column: column,
		value:  fn,
	}
}
func In(column string) Cmp {
	return Cmp{
		op:     in,
		column: column,
		value:  param(column),
	}
}
func InTuple(column string, count int) Cmp {
	return Cmp{
		op:     in,
		column: column,
		value: tupleParam{
			param: param(column),
			count: count,
		},
	}
}
func InNamed(column, name string) Cmp {
	return Cmp{
		op:     in,
		column: column,
		value:  param(name),
	}
}
func InLit(column, literal string) Cmp {
	return Cmp{
		op:     in,
		column: column,
		value:  lit(literal),
	}
}
func Contains(column string) Cmp {
	return Cmp{
		op:     cnt,
		column: column,
		value:  param(column),
	}
}
func ContainsTuple(column string, count int) Cmp {
	return Cmp{
		op:     cnt,
		column: column,
		value: tupleParam{
			param: param(column),
			count: count,
		},
	}
}
func ContainsKey(column string) Cmp {
	return Cmp{
		op:     cntKey,
		column: column,
		value:  param(column),
	}
}
func ContainsKeyTuple(column string, count int) Cmp {
	return Cmp{
		op:     cntKey,
		column: column,
		value: tupleParam{
			param: param(column),
			count: count,
		},
	}
}
func ContainsNamed(column, name string) Cmp {
	return Cmp{
		op:     cnt,
		column: column,
		value:  param(name),
	}
}
func ContainsKeyNamed(column, name string) Cmp {
	return Cmp{
		op:     cntKey,
		column: column,
		value:  param(name),
	}
}
func ContainsLit(column, literal string) Cmp {
	return Cmp{
		op:     cnt,
		column: column,
		value:  lit(literal),
	}
}