forked from dgraph-io/dgraph
/
keys.go
187 lines (154 loc) · 3.63 KB
/
keys.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
package x
import (
"encoding/binary"
"math"
)
const (
byteData = byte(0x00)
byteIndex = byte(0x01)
byteReverse = byte(0x02)
byteSchema = byte(0x03)
// same prefix for data, index and reverse keys so that relative order of data doesn't change
// keys of same attributes are located together
defaultPrefix = byte(0x00)
)
func writeAttr(buf []byte, attr string) []byte {
AssertTrue(len(attr) < math.MaxUint16)
binary.BigEndian.PutUint16(buf[:2], uint16(len(attr)))
rest := buf[2:]
AssertTrue(len(attr) == copy(rest, attr[:]))
return rest[len(attr):]
}
// SchemaKey returns schema key for given attribute,
// schema keys are stored separately with unique prefix,
// since we need to iterate over all schema keys
func SchemaKey(attr string) []byte {
buf := make([]byte, 2+len(attr)+2)
buf[0] = byteSchema
rest := buf[1:]
rest = writeAttr(rest, attr)
rest[0] = byteSchema
return buf
}
func DataKey(attr string, uid uint64) []byte {
buf := make([]byte, 2+len(attr)+2+8)
buf[0] = defaultPrefix
rest := buf[1:]
rest = writeAttr(rest, attr)
rest[0] = byteData
rest = rest[1:]
binary.BigEndian.PutUint64(rest, uid)
return buf
}
func ReverseKey(attr string, uid uint64) []byte {
buf := make([]byte, 2+len(attr)+2+8)
buf[0] = defaultPrefix
rest := buf[1:]
rest = writeAttr(rest, attr)
rest[0] = byteReverse
rest = rest[1:]
binary.BigEndian.PutUint64(rest, uid)
return buf
}
func IndexKey(attr, term string) []byte {
buf := make([]byte, 2+len(attr)+2+len(term))
buf[0] = defaultPrefix
rest := buf[1:]
rest = writeAttr(rest, attr)
rest[0] = byteIndex
rest = rest[1:]
AssertTrue(len(term) == copy(rest, term[:]))
return buf
}
type ParsedKey struct {
byteType byte
Attr string
Uid uint64
Term string
bytePrefix byte
}
func (p ParsedKey) IsData() bool {
return p.byteType == byteData
}
func (p ParsedKey) IsReverse() bool {
return p.byteType == byteReverse
}
func (p ParsedKey) IsIndex() bool {
return p.byteType == byteIndex
}
func (p ParsedKey) IsSchema() bool {
return p.byteType == byteSchema
}
func (p ParsedKey) SkipPredicate() []byte {
buf := make([]byte, 2+len(p.Attr)+2)
buf[0] = p.bytePrefix
rest := buf[1:]
k := writeAttr(rest, p.Attr)
AssertTrue(len(k) == 1)
k[0] = 0xFF
return buf
}
func (p ParsedKey) SkipRangeOfSameType() []byte {
buf := make([]byte, 2+len(p.Attr)+2)
buf[0] = p.bytePrefix
rest := buf[1:]
k := writeAttr(rest, p.Attr)
AssertTrue(len(k) == 1)
k[0] = p.byteType + 1
return buf
}
func (p ParsedKey) SkipSchema() []byte {
buf := make([]byte, 1)
buf[0] = byteSchema + 1
return buf
}
// DataPrefix returns the prefix for data keys.
func (p ParsedKey) DataPrefix() []byte {
buf := make([]byte, 2+len(p.Attr)+2)
buf[0] = p.bytePrefix
rest := buf[1:]
k := writeAttr(rest, p.Attr)
AssertTrue(len(k) == 1)
k[0] = byteData
return buf
}
// IndexPrefix returns the prefix for index keys.
func (p ParsedKey) IndexPrefix() []byte {
buf := make([]byte, 2+len(p.Attr)+2)
buf[0] = p.bytePrefix
rest := buf[1:]
k := writeAttr(rest, p.Attr)
AssertTrue(len(k) == 1)
k[0] = byteIndex
return buf
}
// SchemaPrefix returns the prefix for Schema keys.
func SchemaPrefix() []byte {
buf := make([]byte, 1)
buf[0] = byteSchema
return buf
}
func Parse(key []byte) *ParsedKey {
p := &ParsedKey{}
p.bytePrefix = key[0]
sz := int(binary.BigEndian.Uint16(key[1:3]))
k := key[3:]
p.Attr = string(k[:sz])
k = k[sz:]
p.byteType = k[0]
k = k[1:]
switch p.byteType {
case byteData:
fallthrough
case byteReverse:
p.Uid = binary.BigEndian.Uint64(k)
case byteIndex:
p.Term = string(k)
case byteSchema:
break
default:
// Some other data type.
return nil
}
return p
}