forked from sqlc-dev/sqlc
-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathparam.go
More file actions
129 lines (109 loc) · 3.13 KB
/
param.go
File metadata and controls
129 lines (109 loc) · 3.13 KB
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
package named
// nullability represents the nullability of a named parameter.
// The nullability can be:
// 1. unspecified
// 2. inferred
// 3. user-defined
// A user-specified nullability carries a higher precedence than an inferred one
//
// The representation is such that you can bitwise OR together nullability types to
// combine them together.
type nullability int
const (
nullUnspecified nullability = 0b0000
inferredNull nullability = 0b0001
inferredNotNull nullability = 0b0010
nullable nullability = 0b0100
notNullable nullability = 0b1000
)
// String implements the Stringer interface
func (n nullability) String() string {
switch n {
case nullUnspecified:
return "NullUnspecified"
case inferredNull:
return "InferredNull"
case inferredNotNull:
return "InferredNotNull"
case nullable:
return "Nullable"
case notNullable:
return "NotNullable"
default:
return "NullInvalid"
}
}
// Param represents a input argument to the query which can be specified using:
// - positional parameters $1
// - named parameter operator @param
// - named parameter function calls sqlc.arg(param)
type Param struct {
name string
nullability nullability
isSqlcSlice bool
}
// NewParam builds a new params with unspecified nullability
func NewParam(name string) Param {
return Param{name: name, nullability: nullUnspecified}
}
// NewInferredParam builds a new params with inferred nullability
func NewInferredParam(name string, notNull bool) Param {
if notNull {
return Param{name: name, nullability: inferredNotNull}
}
return Param{name: name, nullability: inferredNull}
}
// NewUserNullableParam is a parameter that has been overridden
// by the user to be nullable.
func NewUserNullableParam(name string) Param {
return Param{name: name, nullability: nullable}
}
// NewSqlcSlice is a sqlc.slice() parameter.
func NewSqlcSlice(name string) Param {
return Param{name: name, nullability: nullUnspecified, isSqlcSlice: true}
}
// Name is the user defined name to use for this parameter
func (p Param) Name() string {
return p.name
}
// is checks if this params object has the specified nullability bit set
func (p Param) is(n nullability) bool {
return (p.nullability & n) == n
}
// NonNull determines whether this param should be "not null" in its current state
func (p Param) NotNull() bool {
const null = false
const notNull = true
if p.is(notNullable) {
return notNull
}
if p.is(nullable) {
return null
}
if p.is(inferredNotNull) {
return notNull
}
if p.is(inferredNull) {
return null
}
// This param is unspecified, so by default we choose nullable
// which matches the default behavior of most databases
return null
}
// IsSlice returns whether this param is a sqlc.slice() param.
func (p Param) IsSqlcSlice() bool {
return p.isSqlcSlice
}
// mergeParam creates a new param from 2 partially specified params
// If the parameters have different names, the first is preferred
func mergeParam(a, b Param) Param {
name := a.name
if name == "" {
name = b.name
}
return Param{
name: name,
nullability: a.nullability | b.nullability,
isSqlcSlice: a.isSqlcSlice || b.isSqlcSlice,
}
}