-
Notifications
You must be signed in to change notification settings - Fork 0
/
gt_null_uuid.go
250 lines (208 loc) · 6.19 KB
/
gt_null_uuid.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
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
package gt
import (
"database/sql/driver"
"io"
)
/*
Creates a random UUID using `gt.ReadNullUuid` and "crypto/rand". Panics if
random bytes can't be read.
*/
func RandomNullUuid() NullUuid {
return NullUuid(RandomUuid())
}
// Creates a UUID (version 4 variant 1) from bytes from the provided reader.
func ReadNullUuid(src io.Reader) (NullUuid, error) {
val, err := ReadUuid(src)
return NullUuid(val), err
}
/*
Shortcut: parses successfully or panics. Should be used only in root scope. When
error handling is relevant, use `.Parse`.
*/
func ParseNullUuid(src string) (val NullUuid) {
try(val.Parse(src))
return
}
/*
Variant of `gt.Uuid` where zero value is considered empty in text, and null in
JSON and SQL. Features:
* Reversible encoding/decoding in text. Zero value is "".
* Reversible encoding/decoding in JSON. Zero value is `null`.
* Reversible encoding/decoding in SQL. Zero value is `null`.
* Text encoding uses simplified format without dashes.
* Text decoding supports formats with and without dashes, case-insensitive.
Differences from `"github.com/google/uuid".UUID`:
* Text encoding uses simplified format without dashes.
* Text decoding supports only simplified and canonical format.
* Supports only version 4 (random except for a few bits).
* Zero value is considered empty in text, and null in JSON and SQL.
Differences from `"github.com/google/uuid".NullUUID`:
* Fewer states: there is NO "00000000000000000000000000000000".
* Easier to use: `NullUuid` is a typedef of `Uuid`, not a wrapper.
For database columns, `NullUuid` is recommended over `Uuid`, even when columns
are non-nullable. It prevents you from accidentally using zero-initialized
"00000000000000000000000000000000" in SQL or JSON, without the hassle of
pointers or additional fields.
*/
type NullUuid Uuid
var (
_ = Encodable(NullUuid{})
_ = Decodable((*NullUuid)(nil))
)
// Implement `gt.Zeroable`. Equivalent to `reflect.ValueOf(self).IsZero()`.
func (self NullUuid) IsZero() bool { return Uuid(self).IsZero() }
// Implement `gt.Nullable`. True if zero.
func (self NullUuid) IsNull() bool { return self.IsZero() }
/*
Implement `gt.Getter`. If zero, returns `nil`, otherwise returns `[16]byte`
understood by many DB drivers.
*/
func (self NullUuid) Get() any {
if self.IsNull() {
return nil
}
return Uuid(self).Get()
}
// Implement `gt.Setter`, using `.Scan`. Panics on error.
func (self *NullUuid) Set(src any) { try(self.Scan(src)) }
// Implement `gt.Zeroer`, zeroing the receiver.
func (self *NullUuid) Zero() { (*Uuid)(self).Zero() }
/*
Implement `fmt.Stringer`. If zero, returns an empty string. Otherwise returns a
simplified text representation: lowercase without dashes.
*/
func (self NullUuid) String() string {
if self.IsNull() {
return ``
}
return Uuid(self).String()
}
/*
Implement `gt.Parser`. If the input is empty, zeroes the receiver. Otherwise
requires a valid UUID representation. Supports both the short format without
dashes, and the canonical format with dashes. Parsing is case-insensitive.
*/
func (self *NullUuid) Parse(src string) error {
if len(src) == 0 {
self.Zero()
return nil
}
return (*Uuid)(self).Parse(src)
}
// Implement `gt.AppenderTo`, using the same representation as `.String`.
func (self NullUuid) AppendTo(buf []byte) []byte {
if self.IsNull() {
return buf
}
return Uuid(self).AppendTo(buf)
}
/*
Implement `encoding.TextMarhaler`. If zero, returns nil. Otherwise returns the
same representation as `.String`.
*/
func (self NullUuid) MarshalText() ([]byte, error) {
if self.IsNull() {
return nil, nil
}
return Uuid(self).MarshalText()
}
// Implement `encoding.TextUnmarshaler`, using the same algorithm as `.Parse`.
func (self *NullUuid) UnmarshalText(src []byte) error {
return self.Parse(bytesString(src))
}
/*
Implement `json.Marshaler`. If zero, returns bytes representing `null`.
Otherwise returns bytes representing a JSON string with the same text as in
`.String`.
*/
func (self NullUuid) MarshalJSON() ([]byte, error) {
if self.IsNull() {
return bytesNull, nil
}
return Uuid(self).MarshalJSON()
}
/*
Implement `json.Unmarshaler`. If the input is empty or represents JSON `null`,
zeroes the receiver. Otherwise parses a JSON string, using the same algorithm
as `.Parse`.
*/
func (self *NullUuid) UnmarshalJSON(src []byte) error {
if isJsonEmpty(src) {
self.Zero()
return nil
}
if isJsonStr(src) {
return self.UnmarshalText(cutJsonStr(src))
}
return errJsonString(src, self)
}
// Implement `driver.Valuer`, using `.Get`.
func (self NullUuid) Value() (driver.Value, error) {
return self.Get(), nil
}
/*
Implement `sql.Scanner`, converting an arbitrary input to `gt.NullUuid` and
modifying the receiver. Acceptable inputs:
* `nil` -> use `.Zero`
* `string` -> use `.Parse`
* `[16]byte` -> assign
* `*[16]byte` -> use `.Zero` or assign
* `gt.Uuid` -> assign
* `gt.NullUuid` -> assign
* `gt.Getter` -> scan underlying value
*/
func (self *NullUuid) Scan(src any) error {
switch src := src.(type) {
case nil:
self.Zero()
return nil
case string:
return self.Parse(src)
case []byte:
return self.UnmarshalText(src)
case [UuidLen]byte:
*self = NullUuid(src)
return nil
case *[UuidLen]byte:
if src == nil {
self.Zero()
} else {
*self = NullUuid(*src)
}
return nil
case Uuid:
*self = NullUuid(src)
return nil
case NullUuid:
*self = src
return nil
default:
val, ok := get(src)
if ok {
return self.Scan(val)
}
return errScanType(self, src)
}
}
// Equivalent to `a.String() < b.String()`. Useful for sorting.
func (self NullUuid) Less(other NullUuid) bool {
return Uuid(self).Less(Uuid(other))
}
/*
Implement `fmt.GoStringer`, returning valid Go code that constructs this value.
The rendered code is biased for readability over performance: it parses a
string instead of using a literal constructor.
*/
func (self NullUuid) GoString() string {
if self.IsNull() {
return `gt.NullUuid{}`
}
const fun = `gt.ParseNullUuid`
var arr [len(fun) + len("(`") + len(uuidStrZero) + len("`)")]byte
buf := arr[:0]
buf = append(buf, fun...)
buf = append(buf, "(`"...)
buf = Uuid(self).AppendTo(buf) // `NullUuid.AppendTo` would use another zero check.
buf = append(buf, "`)"...)
return string(buf)
}