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
114 lines (96 loc) · 2.78 KB
/
param.go
File metadata and controls
114 lines (96 loc) · 2.78 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
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
}
// 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}
}
// 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
}
// 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}
}