-
Notifications
You must be signed in to change notification settings - Fork 0
/
where.go
140 lines (127 loc) · 3.48 KB
/
where.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
package dat
import (
"bytes"
"reflect"
"strings"
)
// Eq is a map column -> value pairs which must be matched in a query
type Eq map[string]interface{}
type whereFragment struct {
Condition string
Values []interface{}
EqualityMap map[string]interface{}
}
func newWhereFragment(whereSqlOrMap interface{}, args []interface{}) *whereFragment {
switch pred := whereSqlOrMap.(type) {
case string:
return &whereFragment{Condition: pred, Values: args}
case map[string]interface{}:
return &whereFragment{EqualityMap: pred}
case Eq:
return &whereFragment{EqualityMap: map[string]interface{}(pred)}
default:
panic("Invalid argument passed to Where. Pass a string or an Eq map.")
}
}
func remapPlaceholders(buf *bytes.Buffer, statement string, pos int64) int64 {
if !strings.Contains(statement, "$") {
buf.WriteString(statement)
return 0
}
//var buf bytes.Buffer
var discardDigits bool
var replaced int64
for _, r := range statement {
if discardDigits {
if '0' <= r && r <= '9' {
continue
}
discardDigits = false
}
if r != '$' {
buf.WriteRune(r)
} else if r == '$' {
// replace relative $1 with absolute like $4
writePlaceholder64(buf, pos+replaced)
replaced++
discardDigits = true
}
}
return replaced
}
// Invariant: only called when len(fragments) > 0
func writeWhereFragmentsToSql(fragments []*whereFragment, sql *bytes.Buffer, args *[]interface{}, pos *int64) {
hasConditions := false
for _, f := range fragments {
if f.Condition != "" {
if hasConditions {
sql.WriteString(" AND (")
} else {
sql.WriteRune('(')
hasConditions = true
}
if len(f.Values) > 0 {
// map relative $1, $2 placeholders to absolute
replaced := remapPlaceholders(sql, f.Condition, *pos)
*pos += replaced
*args = append(*args, f.Values...)
} else {
sql.WriteString(f.Condition)
}
sql.WriteRune(')')
} else if f.EqualityMap != nil {
hasConditions = writeEqualityMapToSql(f.EqualityMap, sql, args, hasConditions, pos)
} else {
panic("invalid equality map")
}
}
}
func writeEqualityMapToSql(eq map[string]interface{}, sql *bytes.Buffer, args *[]interface{}, anyConditions bool, pos *int64) bool {
for k, v := range eq {
if v == nil {
anyConditions = writeWhereCondition(sql, k, " IS NULL", anyConditions)
} else {
vVal := reflect.ValueOf(v)
if vVal.Kind() == reflect.Array || vVal.Kind() == reflect.Slice {
vValLen := vVal.Len()
if vValLen == 0 {
if vVal.IsNil() {
anyConditions = writeWhereCondition(sql, k, " IS NULL", anyConditions)
} else {
if anyConditions {
sql.WriteString(" AND (1=0)")
} else {
sql.WriteString("(1=0)")
}
}
} else if vValLen == 1 {
anyConditions = writeWhereCondition(sql, k, equalsPlaceholderTab[*pos], anyConditions)
*args = append(*args, vVal.Index(0).Interface())
*pos++
} else {
// " IN $n"
anyConditions = writeWhereCondition(sql, k, inPlaceholderTab[*pos], anyConditions)
*args = append(*args, v)
*pos++
}
} else {
anyConditions = writeWhereCondition(sql, k, equalsPlaceholderTab[*pos], anyConditions)
*args = append(*args, v)
*pos++
}
}
}
return anyConditions
}
func writeWhereCondition(sql *bytes.Buffer, k string, pred string, anyConditions bool) bool {
if anyConditions {
sql.WriteString(" AND (")
} else {
sql.WriteRune('(')
anyConditions = true
}
Dialect.WriteIdentifier(sql, k)
sql.WriteString(pred)
sql.WriteRune(')')
return anyConditions
}