Documentation
¶
Index ¶
- Constants
- func CombineCompareResult(x int, y int) (int, error)
- func DecodeColumnFieldTypes(t Table) map[string]*types.FieldType
- func Type(ft *types.FieldType) typ
- type BitSet
- type Bool
- type Byte
- type Equality
- type IncompatibleError
- type Int
- type Int64
- type Lattice
- type LatticeMap
- type StringList
- type Table
- type Tuple
- type Uint
Constants ¶
const ( // ErrMsgTypeMismatch is the error message for type mismatch. ErrMsgTypeMismatch = "type mismatch (%T vs %T)" // ErrMsgTupleLengthMismatch is the error message for tuple length mismatch. ErrMsgTupleLengthMismatch = "tuple length mismatch (%d vs %d)" // ErrMsgDistinctSingletons is the error message for distinct singletons. ErrMsgDistinctSingletons = "distinct singletons (%v vs %v)" // ErrMsgIncompatibleType is the error message for incompatible type. ErrMsgIncompatibleType = "incompatible mysql type (%v vs %v)" // ErrMsgAtTupleIndex is the error message for at tuple index. ErrMsgAtTupleIndex = "at tuple index %d: %v" // ErrMsgAtMapKey is the error message for at map key. ErrMsgAtMapKey = "at map key %q: %v" // ErrMsgNonInclusiveBitSets is the error message for non-inclusive bit sets. ErrMsgNonInclusiveBitSets = "non-inclusive bit sets (%#x vs %#x)" // ErrMsgContradictingOrders is the error message for contradicting orders. ErrMsgContradictingOrders = "combining contradicting orders (%d && %d)" // ErrMsgStringListElemMismatch is the error message for string list elem mismatch. ErrMsgStringListElemMismatch = "at string list index %d: distinct values (%q vs %q)" )
const (
ErrMsgAutoTypeWithoutKey = "auto type but not defined as a key"
)
Please ensure this list is synchronized with the order of Tuple{} in encodeFieldTypeToLattice().
Variables ¶
This section is empty.
Functions ¶
func CombineCompareResult ¶
CombineCompareResult combines two comparison results.
func DecodeColumnFieldTypes ¶
DecodeColumnFieldTypes is used to decode column field types from Lattice.
Types ¶
type BitSet ¶
type BitSet uint
BitSet is a set of bits where `a < b` iff `a` is a subset of `b`.
type Equality ¶
type Equality interface {
// Equals returns true if this instance should be equal to another object.
Equals(other Equality) bool
}
Equality allows custom equality.
type IncompatibleError ¶
IncompatibleError is the error type for incompatible schema.
func (*IncompatibleError) Error ¶
func (e *IncompatibleError) Error() string
type Int64 ¶
type Int64 int64
Int64 is an int64 implementing Lattice.
type Lattice ¶
type Lattice interface {
// Unwrap returns the underlying object supporting the lattice. This
// operation is deep.
Unwrap() any
// Compare this instance with another instance.
//
// Returns -1 if `self < other`, 0 if `self == other`, 1 if `self > other`.
// Returns `IncompatibleError` if the two instances are not ordered.
Compare(other Lattice) (int, error)
// Join finds the "least upper bound" of two Lattice instances. The result
// is `>=` both inputs. Returns an error if the join does not exist.
Join(other Lattice) (Lattice, error)
}
Lattice is implemented for types which forms a join-semilattice.
func EqualitySingleton ¶
EqualitySingleton wraps an unordered value with equality defined by custom code instead of the `==` operator.
func FieldTp ¶
FieldTp is used for the column field type (`github.com/pingcap/tidb/pkg/parser/types.FieldType.Tp`).
func MaybeSingletonInterface ¶
MaybeSingletonInterface is a convenient function calling `Maybe(Singleton(value))`.
func MaybeSingletonString ¶
MaybeSingletonString is a convenient function calling `Maybe(Singleton(s))`.
type LatticeMap ¶
type LatticeMap interface {
// New creates an empty LatticeMap of the same type as the receiver.
New() LatticeMap
// Insert inserts a key-value pair into the map.
Insert(key string, value Lattice)
// Get obtains the Lattice object at the given key. Returns nil if the key
// does not exist.
Get(key string) Lattice
// ForEach iterates the map.
ForEach(func(key string, value Lattice) error) error
// CompareWithNil returns the comparison result when the value is compared
// with a non-existing entry.
CompareWithNil(value Lattice) (int, error)
// JoinWithNil returns the result when the value is joined with a
// non-existing entry. If the joined result should be non-existing, this
// method should return nil, nil.
JoinWithNil(value Lattice) (Lattice, error)
// ShouldDeleteIncompatibleJoin returns true if two incompatible entries
// should be deleted instead of propagating the error.
ShouldDeleteIncompatibleJoin() bool
}
LatticeMap is a map of Lattice objects keyed by strings.
type StringList ¶
type StringList []string
StringList is a list of string where `a <= b` iff `a == b[:len(a)]`.
func (StringList) Compare ¶
func (a StringList) Compare(other Lattice) (int, error)
Compare implements Lattice.
type Table ¶
type Table struct {
// contains filtered or unexported fields
}
Table is a table in the database.
type Tuple ¶
type Tuple []Lattice
Tuple of Lattice instances. Given two Tuples `a` and `b`, we define `a <= b` iff `a[i] <= b[i]` for all `i`.
Source Files