forked from aptly-dev/aptly
/
query.go
267 lines (229 loc) · 5.95 KB
/
query.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
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
package deb
import (
"fmt"
"path/filepath"
"regexp"
"strings"
)
// PackageCatalog is abstraction on top of PackageCollection and PackageList
type PackageCatalog interface {
Scan(q PackageQuery) (result *PackageList)
Search(dep Dependency, allMatches bool) (searchResults []*Package)
SearchSupported() bool
SearchByKey(arch, name, version string) (result *PackageList)
}
// PackageQuery is interface of predicate on Package
type PackageQuery interface {
// Matches calculates match of condition against package
Matches(pkg *Package) bool
// Fast returns if search strategy is possible for this query
Fast(list PackageCatalog) bool
// Query performs search on package list
Query(list PackageCatalog) *PackageList
// String interface
String() string
}
// OrQuery is L | R
type OrQuery struct {
L, R PackageQuery
}
// AndQuery is L , R
type AndQuery struct {
L, R PackageQuery
}
// NotQuery is ! Q
type NotQuery struct {
Q PackageQuery
}
// FieldQuery is generic request against field
type FieldQuery struct {
Field string
Relation int
Value string
Regexp *regexp.Regexp `codec:"-"`
}
// PkgQuery is search request against specific package
type PkgQuery struct {
Pkg string
Version string
Arch string
}
// DependencyQuery is generic Debian-dependency like query
type DependencyQuery struct {
Dep Dependency
}
// Matches if any of L, R matches
func (q *OrQuery) Matches(pkg *Package) bool {
return q.L.Matches(pkg) || q.R.Matches(pkg)
}
// Fast is true only if both parts are fast
func (q *OrQuery) Fast(list PackageCatalog) bool {
return q.L.Fast(list) && q.R.Fast(list)
}
// Query strategy depends on nodes
func (q *OrQuery) Query(list PackageCatalog) (result *PackageList) {
if q.Fast(list) {
result = q.L.Query(list)
result.Append(q.R.Query(list))
} else {
result = list.Scan(q)
}
return
}
// String interface
func (q *OrQuery) String() string {
return fmt.Sprintf("(%s) | (%s)", q.L, q.R)
}
// Matches if both of L, R matches
func (q *AndQuery) Matches(pkg *Package) bool {
return q.L.Matches(pkg) && q.R.Matches(pkg)
}
// Fast is true if any of the parts are fast
func (q *AndQuery) Fast(list PackageCatalog) bool {
return q.L.Fast(list) || q.R.Fast(list)
}
// Query strategy depends on nodes
func (q *AndQuery) Query(list PackageCatalog) (result *PackageList) {
if !q.Fast(list) {
result = list.Scan(q)
} else {
if q.L.Fast(list) {
result = q.L.Query(list)
result = result.Scan(q.R)
} else {
result = q.R.Query(list)
result = result.Scan(q.L)
}
}
return
}
// String interface
func (q *AndQuery) String() string {
return fmt.Sprintf("(%s), (%s)", q.L, q.R)
}
// Matches if not matches
func (q *NotQuery) Matches(pkg *Package) bool {
return !q.Q.Matches(pkg)
}
// Fast is false
func (q *NotQuery) Fast(list PackageCatalog) bool {
return false
}
// Query strategy is scan always
func (q *NotQuery) Query(list PackageCatalog) (result *PackageList) {
result = list.Scan(q)
return
}
// String interface
func (q *NotQuery) String() string {
return fmt.Sprintf("!(%s)", q.Q)
}
// Matches on generic field
func (q *FieldQuery) Matches(pkg *Package) bool {
if q.Field == "$Version" {
return pkg.MatchesDependency(Dependency{Pkg: pkg.Name, Relation: q.Relation, Version: q.Value, Regexp: q.Regexp})
}
if q.Field == "$Architecture" && q.Relation == VersionEqual {
return pkg.MatchesArchitecture(q.Value)
}
field := pkg.GetField(q.Field)
switch q.Relation {
case VersionDontCare:
return field != ""
case VersionEqual:
return field == q.Value
case VersionGreater:
return field > q.Value
case VersionGreaterOrEqual:
return field >= q.Value
case VersionLess:
return field < q.Value
case VersionLessOrEqual:
return field <= q.Value
case VersionPatternMatch:
matched, err := filepath.Match(q.Value, field)
return err == nil && matched
case VersionRegexp:
if q.Regexp == nil {
q.Regexp = regexp.MustCompile(q.Value)
}
return q.Regexp.FindStringIndex(field) != nil
}
panic("unknown relation")
}
// Query runs iteration through list
func (q *FieldQuery) Query(list PackageCatalog) (result *PackageList) {
result = list.Scan(q)
return
}
// Fast depends on the query
func (q *FieldQuery) Fast(list PackageCatalog) bool {
return false
}
// String interface
func (q *FieldQuery) String() string {
escape := func(val string) string {
if strings.IndexAny(val, "()|,!{} \t\n") != -1 {
return "'" + strings.Replace(strings.Replace(val, "\\", "\\\\", -1), "'", "\\'", -1) + "'"
}
return val
}
var op string
switch q.Relation {
case VersionEqual:
op = "="
case VersionGreater:
op = ">>"
case VersionLess:
op = "<<"
case VersionRegexp:
op = "~"
case VersionPatternMatch:
op = "%"
case VersionGreaterOrEqual:
op = ">="
case VersionLessOrEqual:
op = "<="
}
return fmt.Sprintf("%s (%s %s)", escape(q.Field), op, escape(q.Value))
}
// Matches on dependency condition
func (q *DependencyQuery) Matches(pkg *Package) bool {
return pkg.MatchesDependency(q.Dep)
}
// Fast is always true for dependency query
func (q *DependencyQuery) Fast(list PackageCatalog) bool {
return list.SearchSupported()
}
// Query runs PackageList.Search
func (q *DependencyQuery) Query(list PackageCatalog) (result *PackageList) {
if q.Fast(list) {
result = NewPackageList()
for _, pkg := range list.Search(q.Dep, true) {
result.Add(pkg)
}
} else {
result = list.Scan(q)
}
return
}
// String interface
func (q *DependencyQuery) String() string {
return q.Dep.String()
}
// Matches on specific properties
func (q *PkgQuery) Matches(pkg *Package) bool {
return pkg.Name == q.Pkg && pkg.Version == q.Version && pkg.Architecture == q.Arch
}
// Fast is always true for package query
func (q *PkgQuery) Fast(list PackageCatalog) bool {
return true
}
// Query looks up specific package
func (q *PkgQuery) Query(list PackageCatalog) (result *PackageList) {
return list.SearchByKey(q.Arch, q.Pkg, q.Version)
}
// String interface
func (q *PkgQuery) String() string {
return fmt.Sprintf("%s_%s_%s", q.Pkg, q.Version, q.Arch)
}