func (i identifier) BitwiseRightShift(val interface{}) BitwiseExpression {
	return bitwiseRightShift(i, val)
}
Returns a BooleanExpression for bit RIGHT shift (e.g "my_col" >> 1)
package exp
import (
	"strings"
)
type (
	identifier struct {
		schema string
		table  string
		col    interface{}
	}
)
var (
	tableAndColumnParts                 = 2
	schemaTableAndColumnIdentifierParts = 3
)
func ParseIdentifier(ident string) IdentifierExpression {
	parts := strings.Split(ident, ".")
	switch len(parts) {
	case tableAndColumnParts:
		return NewIdentifierExpression("", parts[0], parts[1])
	case schemaTableAndColumnIdentifierParts:
		return NewIdentifierExpression(parts[0], parts[1], parts[2])
	}
	return NewIdentifierExpression("", "", ident)
}
func NewIdentifierExpression(schema, table string, col interface{}) IdentifierExpression {
	return identifier{}.Schema(schema).Table(table).Col(col)
}
func (i identifier) clone() identifier {
	return identifier{schema: i.schema, table: i.table, col: i.col}
}
func (i identifier) Clone() Expression {
	return i.clone()
}
func (i identifier) IsQualified() bool {
	schema, table, col := i.schema, i.table, i.col
	switch c := col.(type) {
	case string:
		if c != "" {
			return len(table) > 0 || len(schema) > 0
		}
	default:
		if c != nil {
			return len(table) > 0 || len(schema) > 0
		}
	}
	if len(table) > 0 {
		return len(schema) > 0
	}
	return false
}
func (i identifier) Table(table string) IdentifierExpression {
	i.table = table
	return i
}
func (i identifier) GetTable() string {
	return i.table
}
func (i identifier) Schema(schema string) IdentifierExpression {
	i.schema = schema
	return i
}
func (i identifier) GetSchema() string {
	return i.schema
}
func (i identifier) Col(col interface{}) IdentifierExpression {
	if col == "*" {
		i.col = Star()
	} else {
		i.col = col
	}
	return i
}
func (i identifier) Expression() Expression { return i }
func (i identifier) All() IdentifierExpression { return i.Col("*") }
func (i identifier) IsEmpty() bool {
	isEmpty := i.schema == "" && i.table == ""
	if isEmpty {
		switch t := i.col.(type) {
		case nil:
			return true
		case string:
			return t == ""
		default:
			return false
		}
	}
	return isEmpty
}
func (i identifier) GetCol() interface{} { return i.col }
func (i identifier) Set(val interface{}) UpdateExpression { return set(i, val) }
func (i identifier) As(val interface{}) AliasedExpression {
	if v, ok := val.(string); ok {
		ident := ParseIdentifier(v)
		if i.col != nil && i.col != "" {
			return NewAliasExpression(i, ident)
		}
		aliasCol := ident.GetCol()
		if i.table != "" {
			return NewAliasExpression(i, NewIdentifierExpression("", aliasCol.(string), nil))
		} else if i.schema != "" {
			return NewAliasExpression(i, NewIdentifierExpression(aliasCol.(string), "", nil))
		}
	}
	return NewAliasExpression(i, val)
}
func (i identifier) Eq(val interface{}) BooleanExpression { return eq(i, val) }
func (i identifier) Neq(val interface{}) BooleanExpression { return neq(i, val) }
func (i identifier) Gt(val interface{}) BooleanExpression { return gt(i, val) }
func (i identifier) Gte(val interface{}) BooleanExpression { return gte(i, val) }
func (i identifier) Lt(val interface{}) BooleanExpression { return lt(i, val) }
func (i identifier) Lte(val interface{}) BooleanExpression { return lte(i, val) }
func (i identifier) BitwiseInversion() BitwiseExpression { return bitwiseInversion(i) }
func (i identifier) BitwiseOr(val interface{}) BitwiseExpression { return bitwiseOr(i, val) }
func (i identifier) BitwiseAnd(val interface{}) BitwiseExpression { return bitwiseAnd(i, val) }
func (i identifier) BitwiseXor(val interface{}) BitwiseExpression { return bitwiseXor(i, val) }
func (i identifier) BitwiseLeftShift(val interface{}) BitwiseExpression {
	return bitwiseLeftShift(i, val)
}