1 package exp
2
3 type (
4 SelectClauses interface {
5 HasSources() bool
6 IsDefaultSelect() bool
7 clone() *selectClauses
8
9 Select() ColumnListExpression
10 SelectAppend(cl ColumnListExpression) SelectClauses
11 SetSelect(cl ColumnListExpression) SelectClauses
12
13 Distinct() ColumnListExpression
14 SetDistinct(cle ColumnListExpression) SelectClauses
15
16 From() ColumnListExpression
17 SetFrom(cl ColumnListExpression) SelectClauses
18
19 HasAlias() bool
20 Alias() IdentifierExpression
21 SetAlias(ie IdentifierExpression) SelectClauses
22
23 Joins() JoinExpressions
24 JoinsAppend(jc JoinExpression) SelectClauses
25
26 Where() ExpressionList
27 ClearWhere() SelectClauses
28 WhereAppend(expressions ...Expression) SelectClauses
29
30 Having() ExpressionList
31 ClearHaving() SelectClauses
32 HavingAppend(expressions ...Expression) SelectClauses
33
34 Order() ColumnListExpression
35 HasOrder() bool
36 ClearOrder() SelectClauses
37 SetOrder(oes ...OrderedExpression) SelectClauses
38 OrderAppend(...OrderedExpression) SelectClauses
39 OrderPrepend(...OrderedExpression) SelectClauses
40
41 GroupBy() ColumnListExpression
42 SetGroupBy(cl ColumnListExpression) SelectClauses
43 GroupByAppend(cl ColumnListExpression) SelectClauses
44
45 Limit() interface{}
46 HasLimit() bool
47 ClearLimit() SelectClauses
48 SetLimit(limit interface{}) SelectClauses
49
50 Offset() uint
51 ClearOffset() SelectClauses
52 SetOffset(offset uint) SelectClauses
53
54 Compounds() []CompoundExpression
55 CompoundsAppend(ce CompoundExpression) SelectClauses
56
57 Lock() Lock
58 SetLock(l Lock) SelectClauses
59
60 CommonTables() []CommonTableExpression
61 CommonTablesAppend(cte CommonTableExpression) SelectClauses
62
63 Windows() []WindowExpression
64 SetWindows(ws []WindowExpression) SelectClauses
65 WindowsAppend(ws ...WindowExpression) SelectClauses
66 ClearWindows() SelectClauses
67 }
68 selectClauses struct {
69 commonTables []CommonTableExpression
70 selectColumns ColumnListExpression
71 distinct ColumnListExpression
72 from ColumnListExpression
73 joins JoinExpressions
74 where ExpressionList
75 alias IdentifierExpression
76 groupBy ColumnListExpression
77 having ExpressionList
78 order ColumnListExpression
79 limit interface{}
80 offset uint
81 compounds []CompoundExpression
82 lock Lock
83 windows []WindowExpression
84 }
85 )
86
87 func NewSelectClauses() SelectClauses {
88 return &selectClauses{
89 selectColumns: NewColumnListExpression(Star()),
90 }
91 }
92
93 func (c *selectClauses) HasSources() bool {
94 return c.from != nil && len(c.from.Columns()) > 0
95 }
96
97 func (c *selectClauses) IsDefaultSelect() bool {
98 ret := false
99 if c.selectColumns != nil {
100 selects := c.selectColumns.Columns()
101 if len(selects) == 1 {
102 if l, ok := selects[0].(LiteralExpression); ok && l.Literal() == "*" {
103 ret = true
104 }
105 }
106 }
107 return ret
108 }
109
110 func (c *selectClauses) clone() *selectClauses {
111 return &selectClauses{
112 commonTables: c.commonTables,
113 selectColumns: c.selectColumns,
114 distinct: c.distinct,
115 from: c.from,
116 joins: c.joins[0:len(c.joins):len(c.joins)],
117 where: c.where,
118 alias: c.alias,
119 groupBy: c.groupBy,
120 having: c.having,
121 order: c.order,
122 limit: c.limit,
123 offset: c.offset,
124 compounds: c.compounds,
125 lock: c.lock,
126 windows: c.windows,
127 }
128 }
129
130 func (c *selectClauses) CommonTables() []CommonTableExpression {
131 return c.commonTables
132 }
133
134 func (c *selectClauses) CommonTablesAppend(cte CommonTableExpression) SelectClauses {
135 ret := c.clone()
136 ret.commonTables = append(ret.commonTables, cte)
137 return ret
138 }
139
140 func (c *selectClauses) Select() ColumnListExpression {
141 return c.selectColumns
142 }
143
144 func (c *selectClauses) SelectAppend(cl ColumnListExpression) SelectClauses {
145 ret := c.clone()
146 ret.selectColumns = ret.selectColumns.Append(cl.Columns()...)
147 return ret
148 }
149
150 func (c *selectClauses) SetSelect(cl ColumnListExpression) SelectClauses {
151 ret := c.clone()
152 ret.selectColumns = cl
153 return ret
154 }
155
156 func (c *selectClauses) Distinct() ColumnListExpression {
157 return c.distinct
158 }
159
160 func (c *selectClauses) SetDistinct(cle ColumnListExpression) SelectClauses {
161 ret := c.clone()
162 ret.distinct = cle
163 return ret
164 }
165
166 func (c *selectClauses) From() ColumnListExpression {
167 return c.from
168 }
169
170 func (c *selectClauses) SetFrom(cl ColumnListExpression) SelectClauses {
171 ret := c.clone()
172 ret.from = cl
173 return ret
174 }
175
176 func (c *selectClauses) HasAlias() bool {
177 return c.alias != nil
178 }
179
180 func (c *selectClauses) Alias() IdentifierExpression {
181 return c.alias
182 }
183
184 func (c *selectClauses) SetAlias(ie IdentifierExpression) SelectClauses {
185 ret := c.clone()
186 ret.alias = ie
187 return ret
188 }
189
190 func (c *selectClauses) Joins() JoinExpressions {
191 return c.joins
192 }
193
194 func (c *selectClauses) JoinsAppend(jc JoinExpression) SelectClauses {
195 ret := c.clone()
196 ret.joins = append(ret.joins, jc)
197 return ret
198 }
199
200 func (c *selectClauses) Where() ExpressionList {
201 return c.where
202 }
203
204 func (c *selectClauses) ClearWhere() SelectClauses {
205 ret := c.clone()
206 ret.where = nil
207 return ret
208 }
209
210 func (c *selectClauses) WhereAppend(expressions ...Expression) SelectClauses {
211 if len(expressions) == 0 {
212 return c
213 }
214 ret := c.clone()
215 if ret.where == nil {
216 ret.where = NewExpressionList(AndType, expressions...)
217 } else {
218 ret.where = ret.where.Append(expressions...)
219 }
220 return ret
221 }
222
223 func (c *selectClauses) Having() ExpressionList {
224 return c.having
225 }
226
227 func (c *selectClauses) ClearHaving() SelectClauses {
228 ret := c.clone()
229 ret.having = nil
230 return ret
231 }
232
233 func (c *selectClauses) HavingAppend(expressions ...Expression) SelectClauses {
234 if len(expressions) == 0 {
235 return c
236 }
237 ret := c.clone()
238 if ret.having == nil {
239 ret.having = NewExpressionList(AndType, expressions...)
240 } else {
241 ret.having = ret.having.Append(expressions...)
242 }
243 return ret
244 }
245
246 func (c *selectClauses) Lock() Lock {
247 return c.lock
248 }
249
250 func (c *selectClauses) SetLock(l Lock) SelectClauses {
251 ret := c.clone()
252 ret.lock = l
253 return ret
254 }
255
256 func (c *selectClauses) Order() ColumnListExpression {
257 return c.order
258 }
259
260 func (c *selectClauses) HasOrder() bool {
261 return c.order != nil
262 }
263
264 func (c *selectClauses) ClearOrder() SelectClauses {
265 ret := c.clone()
266 ret.order = nil
267 return ret
268 }
269
270 func (c *selectClauses) SetOrder(oes ...OrderedExpression) SelectClauses {
271 ret := c.clone()
272 ret.order = NewOrderedColumnList(oes...)
273 return ret
274 }
275
276 func (c *selectClauses) OrderAppend(oes ...OrderedExpression) SelectClauses {
277 if c.order == nil {
278 return c.SetOrder(oes...)
279 }
280 ret := c.clone()
281 ret.order = ret.order.Append(NewOrderedColumnList(oes...).Columns()...)
282 return ret
283 }
284
285 func (c *selectClauses) OrderPrepend(oes ...OrderedExpression) SelectClauses {
286 if c.order == nil {
287 return c.SetOrder(oes...)
288 }
289 ret := c.clone()
290 ret.order = NewOrderedColumnList(oes...).Append(ret.order.Columns()...)
291 return ret
292 }
293
294 func (c *selectClauses) GroupBy() ColumnListExpression {
295 return c.groupBy
296 }
297
298 func (c *selectClauses) GroupByAppend(cl ColumnListExpression) SelectClauses {
299 if c.groupBy == nil {
300 return c.SetGroupBy(cl)
301 }
302 ret := c.clone()
303 ret.groupBy = ret.groupBy.Append(cl.Columns()...)
304 return ret
305 }
306
307 func (c *selectClauses) SetGroupBy(cl ColumnListExpression) SelectClauses {
308 ret := c.clone()
309 ret.groupBy = cl
310 return ret
311 }
312
313 func (c *selectClauses) Limit() interface{} {
314 return c.limit
315 }
316
317 func (c *selectClauses) HasLimit() bool {
318 return c.limit != nil
319 }
320
321 func (c *selectClauses) ClearLimit() SelectClauses {
322 ret := c.clone()
323 ret.limit = nil
324 return ret
325 }
326
327 func (c *selectClauses) SetLimit(limit interface{}) SelectClauses {
328 ret := c.clone()
329 ret.limit = limit
330 return ret
331 }
332
333 func (c *selectClauses) Offset() uint {
334 return c.offset
335 }
336
337 func (c *selectClauses) ClearOffset() SelectClauses {
338 ret := c.clone()
339 ret.offset = 0
340 return ret
341 }
342
343 func (c *selectClauses) SetOffset(offset uint) SelectClauses {
344 ret := c.clone()
345 ret.offset = offset
346 return ret
347 }
348
349 func (c *selectClauses) Compounds() []CompoundExpression {
350 return c.compounds
351 }
352
353 func (c *selectClauses) CompoundsAppend(ce CompoundExpression) SelectClauses {
354 ret := c.clone()
355 ret.compounds = append(ret.compounds, ce)
356 return ret
357 }
358
359 func (c *selectClauses) Windows() []WindowExpression {
360 return c.windows
361 }
362
363 func (c *selectClauses) SetWindows(ws []WindowExpression) SelectClauses {
364 ret := c.clone()
365 ret.windows = ws
366 return ret
367 }
368
369 func (c *selectClauses) WindowsAppend(ws ...WindowExpression) SelectClauses {
370 ret := c.clone()
371 ret.windows = append(ret.windows, ws...)
372 return ret
373 }
374
375 func (c *selectClauses) ClearWindows() SelectClauses {
376 ret := c.clone()
377 ret.windows = nil
378 return ret
379 }
380
View as plain text