1package pgtype
2
3import (
4 "bytes"
5 "database/sql/driver"
6 "fmt"
7 "io"
8
9 "github.com/jackc/pgio"
10)
11
12type <%= range_type %> struct {
13 Lower <%= element_type %>
14 Upper <%= element_type %>
15 LowerType BoundType
16 UpperType BoundType
17 Status Status
18}
19
20func (dst *<%= range_type %>) Set(src interface{}) error {
21 // untyped nil and typed nil interfaces are different
22 if src == nil {
23 *dst = <%= range_type %>{Status: Null}
24 return nil
25 }
26
27 switch value := src.(type) {
28 case <%= range_type %>:
29 *dst = value
30 case *<%= range_type %>:
31 *dst = *value
32 case string:
33 return dst.DecodeText(nil, []byte(value))
34 default:
35 return fmt.Errorf("cannot convert %v to <%= range_type %>", src)
36 }
37
38 return nil
39}
40
41func (dst <%= range_type %>) Get() interface{} {
42 switch dst.Status {
43 case Present:
44 return dst
45 case Null:
46 return nil
47 default:
48 return dst.Status
49 }
50}
51
52func (src *<%= range_type %>) AssignTo(dst interface{}) error {
53 return fmt.Errorf("cannot assign %v to %T", src, dst)
54}
55
56func (dst *<%= range_type %>) DecodeText(ci *ConnInfo, src []byte) error {
57 if src == nil {
58 *dst = <%= range_type %>{Status: Null}
59 return nil
60 }
61
62 utr, err := ParseUntypedTextRange(string(src))
63 if err != nil {
64 return err
65 }
66
67 *dst = <%= range_type %>{Status: Present}
68
69 dst.LowerType = utr.LowerType
70 dst.UpperType = utr.UpperType
71
72 if dst.LowerType == Empty {
73 return nil
74 }
75
76 if dst.LowerType == Inclusive || dst.LowerType == Exclusive {
77 if err := dst.Lower.DecodeText(ci, []byte(utr.Lower)); err != nil {
78 return err
79 }
80 }
81
82 if dst.UpperType == Inclusive || dst.UpperType == Exclusive {
83 if err := dst.Upper.DecodeText(ci, []byte(utr.Upper)); err != nil {
84 return err
85 }
86 }
87
88 return nil
89}
90
91func (dst *<%= range_type %>) DecodeBinary(ci *ConnInfo, src []byte) error {
92 if src == nil {
93 *dst = <%= range_type %>{Status: Null}
94 return nil
95 }
96
97 ubr, err := ParseUntypedBinaryRange(src)
98 if err != nil {
99 return err
100 }
101
102 *dst = <%= range_type %>{Status: Present}
103
104 dst.LowerType = ubr.LowerType
105 dst.UpperType = ubr.UpperType
106
107 if dst.LowerType == Empty {
108 return nil
109 }
110
111 if dst.LowerType == Inclusive || dst.LowerType == Exclusive {
112 if err := dst.Lower.DecodeBinary(ci, ubr.Lower); err != nil {
113 return err
114 }
115 }
116
117 if dst.UpperType == Inclusive || dst.UpperType == Exclusive {
118 if err := dst.Upper.DecodeBinary(ci, ubr.Upper); err != nil {
119 return err
120 }
121 }
122
123 return nil
124}
125
126func (src <%= range_type %>) EncodeText(ci *ConnInfo, buf []byte) ([]byte, error) {
127 switch src.Status {
128 case Null:
129 return nil, nil
130 case Undefined:
131 return nil, errUndefined
132 }
133
134 switch src.LowerType {
135 case Exclusive, Unbounded:
136 buf = append(buf, '(')
137 case Inclusive:
138 buf = append(buf, '[')
139 case Empty:
140 return append(buf, "empty"...), nil
141 default:
142 return nil, fmt.Errorf("unknown lower bound type %v", src.LowerType)
143 }
144
145 var err error
146
147 if src.LowerType != Unbounded {
148 buf, err = src.Lower.EncodeText(ci, buf)
149 if err != nil {
150 return nil, err
151 } else if buf == nil {
152 return nil, fmt.Errorf("Lower cannot be null unless LowerType is Unbounded")
153 }
154 }
155
156 buf = append(buf, ',')
157
158 if src.UpperType != Unbounded {
159 buf, err = src.Upper.EncodeText(ci, buf)
160 if err != nil {
161 return nil, err
162 } else if buf == nil {
163 return nil, fmt.Errorf("Upper cannot be null unless UpperType is Unbounded")
164 }
165 }
166
167 switch src.UpperType {
168 case Exclusive, Unbounded:
169 buf = append(buf, ')')
170 case Inclusive:
171 buf = append(buf, ']')
172 default:
173 return nil, fmt.Errorf("unknown upper bound type %v", src.UpperType)
174 }
175
176 return buf, nil
177}
178
179func (src <%= range_type %>) EncodeBinary(ci *ConnInfo, buf []byte) ([]byte, error) {
180 switch src.Status {
181 case Null:
182 return nil, nil
183 case Undefined:
184 return nil, errUndefined
185 }
186
187 var rangeType byte
188 switch src.LowerType {
189 case Inclusive:
190 rangeType |= lowerInclusiveMask
191 case Unbounded:
192 rangeType |= lowerUnboundedMask
193 case Exclusive:
194 case Empty:
195 return append(buf, emptyMask), nil
196 default:
197 return nil, fmt.Errorf("unknown LowerType: %v", src.LowerType)
198 }
199
200 switch src.UpperType {
201 case Inclusive:
202 rangeType |= upperInclusiveMask
203 case Unbounded:
204 rangeType |= upperUnboundedMask
205 case Exclusive:
206 default:
207 return nil, fmt.Errorf("unknown UpperType: %v", src.UpperType)
208 }
209
210 buf = append(buf, rangeType)
211
212 var err error
213
214 if src.LowerType != Unbounded {
215 sp := len(buf)
216 buf = pgio.AppendInt32(buf, -1)
217
218 buf, err = src.Lower.EncodeBinary(ci, buf)
219 if err != nil {
220 return nil, err
221 }
222 if buf == nil {
223 return nil, fmt.Errorf("Lower cannot be null unless LowerType is Unbounded")
224 }
225
226 pgio.SetInt32(buf[sp:], int32(len(buf[sp:])-4))
227 }
228
229 if src.UpperType != Unbounded {
230 sp := len(buf)
231 buf = pgio.AppendInt32(buf, -1)
232
233 buf, err = src.Upper.EncodeBinary(ci, buf)
234 if err != nil {
235 return nil, err
236 }
237 if buf == nil {
238 return nil, fmt.Errorf("Upper cannot be null unless UpperType is Unbounded")
239 }
240
241 pgio.SetInt32(buf[sp:], int32(len(buf[sp:])-4))
242 }
243
244 return buf, nil
245}
246
247// Scan implements the database/sql Scanner interface.
248func (dst *<%= range_type %>) Scan(src interface{}) error {
249 if src == nil {
250 *dst = <%= range_type %>{Status: Null}
251 return nil
252 }
253
254 switch src := src.(type) {
255 case string:
256 return dst.DecodeText(nil, []byte(src))
257 case []byte:
258 srcCopy := make([]byte, len(src))
259 copy(srcCopy, src)
260 return dst.DecodeText(nil, srcCopy)
261 }
262
263 return fmt.Errorf("cannot scan %T", src)
264}
265
266// Value implements the database/sql/driver Valuer interface.
267func (src <%= range_type %>) Value() (driver.Value, error) {
268 return EncodeValueText(src)
269}
View as plain text