key

package
v2.0.0-alpha1+incompat... Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Aug 25, 2015 License: BSD-3-Clause Imports: 9 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	// unset - no type for this KeyspaceId
	KIT_UNSET = KeyspaceIdType("")

	// uint64 - a uint64 value is used
	// this is represented as 'unsigned bigint' in mysql
	KIT_UINT64 = KeyspaceIdType("uint64")

	// bytes - a string of bytes is used
	// this is represented as 'varbinary' in mysql
	KIT_BYTES = KeyspaceIdType("bytes")
)

Variables

View Source 
var AllKeyspaceIdTypes = []KeyspaceIdType{
	KIT_UNSET,
	KIT_UINT64,
	KIT_BYTES,
}
View Source 
var MaxKey = KeyspaceId("")

MaxKey is bigger than all KeyspaceId (by convention).

View Source 
var MinKey = KeyspaceId("")

MinKey is smaller than all KeyspaceId (the value really is).

Functions

func EncodeValue 

func EncodeValue(value interface{}) string

func FindShardForKey 

func FindShardForKey(key interface{}, tabletKeys []KeyspaceId) (i int, err error)

Finds the shard that covers the given interface. The returned index is between 0 and len(tabletKeys)-1). The tabletKeys is an ordered list of the End values of the KeyRange structures for the shards.

func FindShardForValue 

func FindShardForValue(value string, tabletKeys []KeyspaceId) int

Finds the shard that covers the given value. The returned index is between 0 and len(tabletKeys)-1). The tabletKeys is an ordered list of the End values of the KeyRange structures for the shards.

This function will not check the value is under the last shard's max (we assume it will be empty, as checked by RebuildKeyspace)

func IsKeyspaceIdTypeInList 

func IsKeyspaceIdTypeInList(typ KeyspaceIdType, types []KeyspaceIdType) bool

IsKeyspaceIdTypeInList returns true if the given type is in the list. Use it with AllKeyspaceIdTypes for instance.

func KeyRangeContains 

func KeyRangeContains(kr *pb.KeyRange, id []byte) bool

KeyRangeContains returns true if the provided id is in the keyrange.

func KeyRangeEndEqual 

func KeyRangeEndEqual(left, right *pb.KeyRange) bool

KeyRangeEndEqual returns true if both key ranges have the same end

func KeyRangeEqual 

func KeyRangeEqual(left, right *pb.KeyRange) bool

KeyRangeEqual returns true if both key ranges cover the same area

func KeyRangeIsPartial 

func KeyRangeIsPartial(kr *pb.KeyRange) bool

KeyRangeIsPartial returns true if the KeyRange does not cover the entire space.

func KeyRangeStartEqual 

func KeyRangeStartEqual(left, right *pb.KeyRange) bool

KeyRangeStartEqual returns true if both key ranges have the same start

func KeyRangeToProto 

func KeyRangeToProto(k KeyRange) *pb.KeyRange

KeyRangeToProto translates a KeyRange to proto, or panics

func KeyRangesIntersect 

func KeyRangesIntersect(first, second KeyRange) bool

KeyRangesIntersect returns true if some Keyspace values exist in both ranges.

func KeyRangesIntersect3 

func KeyRangesIntersect3(first, second *pb.KeyRange) bool

KeyRangesIntersect3 returns true if some Keyspace values exist in both ranges.

func KeyRangesOverlap 

func KeyRangesOverlap(first, second *pb.KeyRange) (*pb.KeyRange, error)

KeyRangesOverlap returns the overlap between two KeyRanges. They need to overlap, otherwise an error is returned.

func KeyRangesToProto 

func KeyRangesToProto(ks []KeyRange) []*pb.KeyRange

KeyRangesToProto translates an array of KeyRange to proto

func KeyspaceIdTypeToProto 

func KeyspaceIdTypeToProto(k KeyspaceIdType) pb.KeyspaceIdType

KeyspaceIdTypeToProto translates a KeyspaceIdType to proto, or panics

func KeyspaceIdsToProto 

func KeyspaceIdsToProto(l []KeyspaceId) [][]byte

KeyspaceIdsToProto translates an array of KeyspaceId to proto

func ParseKeyRangeParts3 

func ParseKeyRangeParts3(start, end string) (*pb.KeyRange, error)

ParseKeyRangeParts3 parses a start and end hex values and build a proto KeyRange

Types

type HexKeyspaceId 

type HexKeyspaceId string

HexKeyspaceId is the hex represention of a KeyspaceId.

func (HexKeyspaceId) Unhex 

func (hkid HexKeyspaceId) Unhex() (KeyspaceId, error)

Unhex converts a HexKeyspaceId into a KeyspaceId (hex decoding).

type KeyError 

type KeyError string

func NewKeyError 

func NewKeyError(format string, args ...interface{}) KeyError

func (KeyError) Error 

func (ke KeyError) Error() string

type KeyRange 

type KeyRange struct {
	Start KeyspaceId
	End   KeyspaceId
}

KeyRange is an interval of KeyspaceId values. It contains Start, but excludes End. In other words, it is: [Start, End)

func ParseKeyRangeParts 

func ParseKeyRangeParts(start, end string) (KeyRange, error)

Parse a start and end hex values and build a KeyRange

func ParseShardingSpec 

func ParseShardingSpec(spec string) ([]KeyRange, error)

ParseShardingSpec parses a string that describes a sharding specification. a-b-c-d will be parsed as a-b, b-c, c-d. The empty string may serve both as the start and end of the keyspace: -a-b- will be parsed as start-a, a-b, b-end.

func ProtoToKeyRange 

func ProtoToKeyRange(k *pb.KeyRange) KeyRange

ProtoToKeyRange translates a proto KeyRange, or panics

func ProtoToKeyRanges 

func ProtoToKeyRanges(ks []*pb.KeyRange) []KeyRange

ProtoToKeyRanges translates a proto into an array of KeyRanges

func (KeyRange) Contains 

func (kr KeyRange) Contains(i KeyspaceId) bool

func (KeyRange) IsPartial 

func (kr KeyRange) IsPartial() bool

Returns true if the KeyRange does not cover the entire space.

func (KeyRange) MapKey 

func (kr KeyRange) MapKey() string

func (*KeyRange) MarshalBson 

func (keyRange *KeyRange) MarshalBson(buf *bytes2.ChunkedWriter, key string)

MarshalBson bson-encodes KeyRange.

func (KeyRange) String 

func (kr KeyRange) String() string

func (*KeyRange) UnmarshalBson 

func (keyRange *KeyRange) UnmarshalBson(buf *bytes.Buffer, kind byte)

UnmarshalBson bson-decodes into KeyRange.

type KeyRangeArray 

type KeyRangeArray []KeyRange

KeyRangeArray is an array of KeyRange that can be sorted We use it only if we need to sort []KeyRange

func (KeyRangeArray) Len 

func (p KeyRangeArray) Len() int

func (KeyRangeArray) Less 

func (p KeyRangeArray) Less(i, j int) bool

func (KeyRangeArray) Sort 

func (p KeyRangeArray) Sort()

func (KeyRangeArray) Swap 

func (p KeyRangeArray) Swap(i, j int)

type KeyspaceId 

type KeyspaceId string

KeyspaceId is the type we base sharding on.

func ProtoToKeyspaceIds 

func ProtoToKeyspaceIds(l [][]byte) []KeyspaceId

ProtoToKeyspaceIds translates a proto into an array of KeyspaceIds

func (KeyspaceId) Hex 

func (kid KeyspaceId) Hex() HexKeyspaceId

Hex prints a KeyspaceId in lower case hex.

func (KeyspaceId) MarshalBson 

func (keyspaceId KeyspaceId) MarshalBson(buf *bytes2.ChunkedWriter, key string)

MarshalBson bson-encodes KeyspaceId.

func (KeyspaceId) MarshalJSON 

func (kid KeyspaceId) MarshalJSON() ([]byte, error)

MarshalJSON turns a KeyspaceId into json (using hex encoding).

func (KeyspaceId) String 

func (kid KeyspaceId) String() string

func (*KeyspaceId) UnmarshalBson 

func (keyspaceId *KeyspaceId) UnmarshalBson(buf *bytes.Buffer, kind byte)

UnmarshalBson bson-decodes into KeyspaceId.

func (*KeyspaceId) UnmarshalJSON 

func (kid *KeyspaceId) UnmarshalJSON(data []byte) (err error)

UnmarshalJSON reads a KeyspaceId from json (hex decoding).

type KeyspaceIdArray 

type KeyspaceIdArray []KeyspaceId

KeyspaceIdArray is an array of KeyspaceId that can be sorted We use it only if we need to sort []KeyspaceId

func (KeyspaceIdArray) Len 

func (p KeyspaceIdArray) Len() int

func (KeyspaceIdArray) Less 

func (p KeyspaceIdArray) Less(i, j int) bool

func (KeyspaceIdArray) Sort 

func (p KeyspaceIdArray) Sort()

func (KeyspaceIdArray) Swap 

func (p KeyspaceIdArray) Swap(i, j int)

type KeyspaceIdType 

type KeyspaceIdType string

KeyspaceIdType represents the type of the KeyspaceId. Usually we don't care, but some parts of the code will need that info.

func ProtoToKeyspaceIdType 

func ProtoToKeyspaceIdType(k pb.KeyspaceIdType) KeyspaceIdType

ProtoToKeyspaceIdType translates a proto KeyspaceIdType, or panics

func (KeyspaceIdType) MarshalBson 

func (keyspaceIdType KeyspaceIdType) MarshalBson(buf *bytes2.ChunkedWriter, key string)

MarshalBson bson-encodes KeyspaceIdType.

func (*KeyspaceIdType) UnmarshalBson 

func (keyspaceIdType *KeyspaceIdType) UnmarshalBson(buf *bytes.Buffer, kind byte)

UnmarshalBson bson-decodes into KeyspaceIdType.

type Uint64Key 

type Uint64Key uint64

Uint64Key is a uint64 that can be converted into a KeyspaceId.

func (Uint64Key) Bytes 

func (i Uint64Key) Bytes() []byte

Bytes returns the keyspace id (as bytes) associated with a Uint64Key.

func (Uint64Key) KeyspaceId 

func (i Uint64Key) KeyspaceId() KeyspaceId

KeyspaceId returns the KeyspaceId associated with a Uint64Key.

func (Uint64Key) String 

func (i Uint64Key) String() string

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.