forked from doug-martin/goqu
-
Notifications
You must be signed in to change notification settings - Fork 0
/
dataset_test.go
798 lines (732 loc) · 34.2 KB
/
dataset_test.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
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
package goqu
import (
"database/sql/driver"
"fmt"
"regexp"
"testing"
"time"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/suite"
)
type datasetTest struct {
suite.Suite
}
func (me *datasetTest) Truncate(buf *SqlBuilder) *SqlBuilder {
buf.Truncate(0)
buf.args = make([]interface{}, 0)
return buf
}
func (me *datasetTest) TestClone() {
t := me.T()
ds := From("test")
assert.Equal(t, ds.Clone(), ds)
}
func (me *datasetTest) TestExpression() {
t := me.T()
ds := From("test")
assert.Equal(t, ds.Expression(), ds)
}
func (me *datasetTest) TestAdapter() {
t := me.T()
ds := From("test")
assert.Equal(t, ds.Adapter(), ds.adapter)
}
func (me *datasetTest) TestSetAdapter() {
t := me.T()
ds := From("test")
adapter := NewAdapter("default", ds)
ds.SetAdapter(adapter)
assert.Equal(t, ds.Adapter(), adapter)
}
func (me *datasetTest) TestPrepared() {
t := me.T()
ds := From("test")
preparedDs := ds.Prepared(true)
assert.True(t, preparedDs.isPrepared)
assert.False(t, ds.isPrepared)
//should apply the prepared to any datasets created from the root
assert.True(t, preparedDs.Where(Ex{"a": 1}).isPrepared)
}
func (me *datasetTest) TestLiteralUnsupportedType() {
t := me.T()
assert.EqualError(t, From("test").Literal(NewSqlBuilder(false), struct{}{}), "goqu: Unable to encode value {}")
}
type unknowExpression struct {
}
func (me unknowExpression) Expression() Expression {
return me
}
func (me unknowExpression) Clone() Expression {
return me
}
func (me *datasetTest) TestLiteralUnsupportedExpression() {
t := me.T()
assert.EqualError(t, From("test").Literal(NewSqlBuilder(false), unknowExpression{}), "goqu: Unsupported expression type goqu.unknowExpression")
}
func (me *datasetTest) TestLiteralFloatTypes() {
t := me.T()
ds := From("test")
var float float64
buf := NewSqlBuilder(false)
assert.NoError(t, ds.Literal(buf, float32(10.01)))
assert.Equal(t, buf.String(), "10.010000228881836")
assert.NoError(t, ds.Literal(me.Truncate(buf), float64(10.01)))
assert.Equal(t, buf.String(), "10.01")
assert.NoError(t, ds.Literal(me.Truncate(buf), &float))
assert.Equal(t, buf.String(), "0")
buf = NewSqlBuilder(true)
assert.NoError(t, ds.Literal(buf, float32(10.01)))
assert.Equal(t, buf.args, []interface{}{float64(float32(10.01))})
assert.Equal(t, buf.String(), "?")
assert.NoError(t, ds.Literal(me.Truncate(buf), float64(10.01)))
assert.Equal(t, buf.args, []interface{}{float64(10.01)})
assert.Equal(t, buf.String(), "?")
assert.NoError(t, ds.Literal(me.Truncate(buf), &float))
assert.Equal(t, buf.args, []interface{}{float})
assert.Equal(t, buf.String(), "?")
}
func (me *datasetTest) TestLiteralIntTypes() {
t := me.T()
ds := From("test")
var i int64
buf := NewSqlBuilder(false)
assert.NoError(t, ds.Literal(buf, int(10)))
assert.Equal(t, buf.String(), "10")
assert.NoError(t, ds.Literal(me.Truncate(buf), int8(10)))
assert.Equal(t, buf.String(), "10")
assert.NoError(t, ds.Literal(me.Truncate(buf), int16(10)))
assert.Equal(t, buf.String(), "10")
assert.NoError(t, ds.Literal(me.Truncate(buf), int32(10)))
assert.Equal(t, buf.String(), "10")
assert.NoError(t, ds.Literal(me.Truncate(buf), int64(10)))
assert.Equal(t, buf.String(), "10")
assert.NoError(t, ds.Literal(me.Truncate(buf), uint(10)))
assert.Equal(t, buf.String(), "10")
assert.NoError(t, ds.Literal(me.Truncate(buf), uint8(10)))
assert.Equal(t, buf.String(), "10")
assert.NoError(t, ds.Literal(me.Truncate(buf), uint16(10)))
assert.Equal(t, buf.String(), "10")
assert.NoError(t, ds.Literal(me.Truncate(buf), uint32(10)))
assert.Equal(t, buf.String(), "10")
assert.NoError(t, ds.Literal(me.Truncate(buf), uint64(10)))
assert.Equal(t, buf.String(), "10")
assert.NoError(t, ds.Literal(me.Truncate(buf), &i))
assert.Equal(t, buf.String(), "0")
buf = NewSqlBuilder(true)
assert.NoError(t, ds.Literal(buf, int(10)))
assert.Equal(t, buf.args, []interface{}{int64(10)})
assert.Equal(t, buf.String(), "?")
assert.NoError(t, ds.Literal(me.Truncate(buf), int8(10)))
assert.Equal(t, buf.args, []interface{}{int64(10)})
assert.Equal(t, buf.String(), "?")
assert.NoError(t, ds.Literal(me.Truncate(buf), int16(10)))
assert.Equal(t, buf.args, []interface{}{int64(10)})
assert.Equal(t, buf.String(), "?")
assert.NoError(t, ds.Literal(me.Truncate(buf), int32(10)))
assert.Equal(t, buf.args, []interface{}{int64(10)})
assert.Equal(t, buf.String(), "?")
assert.NoError(t, ds.Literal(me.Truncate(buf), int64(10)))
assert.Equal(t, buf.args, []interface{}{int64(10)})
assert.Equal(t, buf.String(), "?")
assert.NoError(t, ds.Literal(me.Truncate(buf), uint(10)))
assert.Equal(t, buf.args, []interface{}{int64(10)})
assert.Equal(t, buf.String(), "?")
assert.NoError(t, ds.Literal(me.Truncate(buf), uint8(10)))
assert.Equal(t, buf.args, []interface{}{int64(10)})
assert.Equal(t, buf.String(), "?")
assert.NoError(t, ds.Literal(me.Truncate(buf), uint16(10)))
assert.Equal(t, buf.args, []interface{}{int64(10)})
assert.Equal(t, buf.String(), "?")
assert.NoError(t, ds.Literal(me.Truncate(buf), uint32(10)))
assert.Equal(t, buf.args, []interface{}{int64(10)})
assert.Equal(t, buf.String(), "?")
assert.NoError(t, ds.Literal(me.Truncate(buf), uint64(10)))
assert.Equal(t, buf.args, []interface{}{int64(10)})
assert.Equal(t, buf.String(), "?")
assert.NoError(t, ds.Literal(me.Truncate(buf), &i))
assert.Equal(t, buf.args, []interface{}{i})
assert.Equal(t, buf.String(), "?")
}
func (me *datasetTest) TestLiteralStringTypes() {
t := me.T()
ds := From("test")
var str string
buf := NewSqlBuilder(false)
assert.NoError(t, ds.Literal(me.Truncate(buf), "Hello"))
assert.Equal(t, buf.String(), "'Hello'")
//should esacpe single quotes
assert.NoError(t, ds.Literal(me.Truncate(buf), "hello'"))
assert.Equal(t, buf.String(), "'hello'''")
assert.NoError(t, ds.Literal(me.Truncate(buf), &str))
assert.Equal(t, buf.String(), "''")
buf = NewSqlBuilder(true)
assert.NoError(t, ds.Literal(me.Truncate(buf), "Hello"))
assert.Equal(t, buf.args, []interface{}{"Hello"})
assert.Equal(t, buf.String(), "?")
assert.NoError(t, ds.Literal(me.Truncate(buf), "hello'"))
assert.Equal(t, buf.args, []interface{}{"hello'"})
assert.Equal(t, buf.String(), "?")
assert.NoError(t, ds.Literal(me.Truncate(buf), &str))
assert.Equal(t, buf.args, []interface{}{str})
assert.Equal(t, buf.String(), "?")
}
func (me *datasetTest) TestLiteralBoolTypes() {
t := me.T()
var b bool
buf := NewSqlBuilder(false)
ds := From("test")
assert.NoError(t, ds.Literal(me.Truncate(buf), true))
assert.Equal(t, buf.String(), "TRUE")
assert.NoError(t, ds.Literal(me.Truncate(buf), false))
assert.Equal(t, buf.String(), "FALSE")
assert.NoError(t, ds.Literal(me.Truncate(buf), &b))
assert.Equal(t, buf.String(), "FALSE")
buf = NewSqlBuilder(true)
assert.NoError(t, ds.Literal(me.Truncate(buf), true))
assert.Equal(t, buf.args, []interface{}{true})
assert.Equal(t, buf.String(), "?")
assert.NoError(t, ds.Literal(me.Truncate(buf), false))
assert.Equal(t, buf.args, []interface{}{false})
assert.Equal(t, buf.String(), "?")
assert.NoError(t, ds.Literal(me.Truncate(buf), &b))
assert.Equal(t, buf.args, []interface{}{b})
assert.Equal(t, buf.String(), "?")
}
func (me *datasetTest) TestLiteralTimeTypes() {
t := me.T()
buf := NewSqlBuilder(false)
ds := From("test")
now := time.Now().UTC()
assert.NoError(t, ds.Literal(me.Truncate(buf), now))
assert.Equal(t, buf.String(), "'"+now.Format(time.RFC3339Nano)+"'")
assert.NoError(t, ds.Literal(me.Truncate(buf), &now))
assert.Equal(t, buf.String(), "'"+now.Format(time.RFC3339Nano)+"'")
buf = NewSqlBuilder(true)
assert.NoError(t, ds.Literal(me.Truncate(buf), now))
assert.Equal(t, buf.args, []interface{}{now})
assert.Equal(t, buf.String(), "?")
assert.NoError(t, ds.Literal(me.Truncate(buf), &now))
assert.Equal(t, buf.args, []interface{}{now})
assert.Equal(t, buf.String(), "?")
}
func (me *datasetTest) TestLiteralNilTypes() {
t := me.T()
buf := NewSqlBuilder(false)
ds := From("test")
assert.NoError(t, ds.Literal(me.Truncate(buf), nil))
assert.Equal(t, buf.String(), "NULL")
buf = NewSqlBuilder(true)
assert.NoError(t, ds.Literal(me.Truncate(buf), nil))
assert.Equal(t, buf.args, []interface{}{nil})
assert.Equal(t, buf.String(), "?")
}
type datasetValuerType int64
func (j datasetValuerType) Value() (driver.Value, error) {
return []byte(fmt.Sprintf("Hello World %d", j)), nil
}
func (me *datasetTest) TestLiteralValuer() {
t := me.T()
buf := NewSqlBuilder(false)
ds := From("test")
assert.NoError(t, ds.Literal(me.Truncate(buf), datasetValuerType(10)))
assert.Equal(t, buf.String(), "'Hello World 10'")
buf = NewSqlBuilder(true)
assert.NoError(t, ds.Literal(me.Truncate(buf), datasetValuerType(10)))
assert.Equal(t, buf.args, []interface{}{"Hello World 10"})
assert.Equal(t, buf.String(), "?")
}
func (me *datasetTest) TestLiteraSlice() {
t := me.T()
buf := NewSqlBuilder(false)
ds := From("test")
assert.NoError(t, ds.Literal(me.Truncate(buf), []string{"a", "b", "c"}))
assert.Equal(t, buf.String(), `('a', 'b', 'c')`)
buf = NewSqlBuilder(true)
assert.NoError(t, ds.Literal(me.Truncate(buf), []string{"a", "b", "c"}))
assert.Equal(t, buf.args, []interface{}{"a", "b", "c"})
assert.Equal(t, buf.String(), `(?, ?, ?)`)
}
func (me *datasetTest) TestLiteralDataset() {
t := me.T()
buf := NewSqlBuilder(false)
ds := From("test")
assert.NoError(t, ds.Literal(me.Truncate(buf), From("a")))
assert.Equal(t, buf.String(), `(SELECT * FROM "a")`)
assert.NoError(t, ds.Literal(me.Truncate(buf), From("a").As("b")))
assert.Equal(t, buf.String(), `(SELECT * FROM "a") AS "b"`)
buf = NewSqlBuilder(true)
assert.NoError(t, ds.Literal(me.Truncate(buf), From("a")))
assert.Equal(t, buf.args, []interface{}{})
assert.Equal(t, buf.String(), `(SELECT * FROM "a")`)
assert.NoError(t, ds.Literal(me.Truncate(buf), From("a").As("b")))
assert.Equal(t, buf.args, []interface{}{})
assert.Equal(t, buf.String(), `(SELECT * FROM "a") AS "b"`)
}
func (me *datasetTest) TestLiteralColumnList() {
t := me.T()
buf := NewSqlBuilder(false)
ds := From("test")
assert.NoError(t, ds.Literal(me.Truncate(buf), cols("a", Literal("true"))))
assert.Equal(t, buf.String(), `"a", true`)
buf = NewSqlBuilder(true)
assert.NoError(t, ds.Literal(me.Truncate(buf), cols("a", Literal("true"))))
assert.Equal(t, buf.args, []interface{}{})
assert.Equal(t, buf.String(), `"a", true`)
}
func (me *datasetTest) TestLiteralExpressionList() {
t := me.T()
buf := NewSqlBuilder(false)
ds := From("test")
assert.NoError(t, ds.Literal(me.Truncate(buf), And(I("a").Eq("b"), I("c").Neq(1))))
assert.Equal(t, buf.String(), `(("a" = 'b') AND ("c" != 1))`)
assert.NoError(t, ds.Literal(me.Truncate(buf), Or(I("a").Eq("b"), I("c").Neq(1))))
assert.Equal(t, buf.String(), `(("a" = 'b') OR ("c" != 1))`)
assert.NoError(t, ds.Literal(me.Truncate(buf), Or(I("a").Eq("b"), And(I("c").Neq(1), I("d").Eq(Literal("NOW()"))))))
assert.Equal(t, buf.String(), `(("a" = 'b') OR (("c" != 1) AND ("d" = NOW())))`)
buf = NewSqlBuilder(true)
assert.NoError(t, ds.Literal(me.Truncate(buf), And(I("a").Eq("b"), I("c").Neq(1))))
assert.Equal(t, buf.args, []interface{}{"b", 1})
assert.Equal(t, buf.String(), `(("a" = ?) AND ("c" != ?))`)
assert.NoError(t, ds.Literal(me.Truncate(buf), Or(I("a").Eq("b"), I("c").Neq(1))))
assert.Equal(t, buf.args, []interface{}{"b", 1})
assert.Equal(t, buf.String(), `(("a" = ?) OR ("c" != ?))`)
assert.NoError(t, ds.Literal(me.Truncate(buf), Or(I("a").Eq("b"), And(I("c").Neq(1), I("d").Eq(Literal("NOW()"))))))
assert.Equal(t, buf.args, []interface{}{"b", 1})
assert.Equal(t, buf.String(), `(("a" = ?) OR (("c" != ?) AND ("d" = NOW())))`)
}
func (me *datasetTest) TestLiteralLiteralExpression() {
t := me.T()
buf := NewSqlBuilder(false)
ds := From("test")
assert.NoError(t, ds.Literal(me.Truncate(buf), Literal(`"b"::DATE = '2010-09-02'`)))
assert.Equal(t, buf.String(), `"b"::DATE = '2010-09-02'`)
assert.NoError(t, ds.Literal(me.Truncate(buf), Literal(`"b" = ? or "c" = ? or d IN ?`, "a", 1, []int{1, 2, 3, 4})))
assert.Equal(t, buf.String(), `"b" = 'a' or "c" = 1 or d IN (1, 2, 3, 4)`)
buf = NewSqlBuilder(true)
assert.NoError(t, ds.Literal(me.Truncate(buf), Literal(`"b"::DATE = '2010-09-02'`)))
assert.Equal(t, buf.args, []interface{}{})
assert.Equal(t, buf.String(), `"b"::DATE = '2010-09-02'`)
assert.NoError(t, ds.Literal(me.Truncate(buf), Literal(`"b" = ? or "c" = ? or d IN ?`, "a", 1, []int{1, 2, 3, 4})))
assert.Equal(t, buf.args, []interface{}{"a", 1, 1, 2, 3, 4})
assert.Equal(t, buf.String(), `"b" = ? or "c" = ? or d IN (?, ?, ?, ?)`)
}
func (me *datasetTest) TestLiteralAliasedExpression() {
t := me.T()
buf := NewSqlBuilder(false)
ds := From("test")
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").As("b")))
assert.Equal(t, buf.String(), `"a" AS "b"`)
assert.NoError(t, ds.Literal(me.Truncate(buf), Literal("count(*)").As("count")))
assert.Equal(t, buf.String(), `count(*) AS "count"`)
buf = NewSqlBuilder(true)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").As("b")))
assert.Equal(t, buf.args, []interface{}{})
assert.Equal(t, buf.String(), `"a" AS "b"`)
assert.NoError(t, ds.Literal(me.Truncate(buf), Literal("count(*)").As("count")))
assert.Equal(t, buf.args, []interface{}{})
assert.Equal(t, buf.String(), `count(*) AS "count"`)
buf = NewSqlBuilder(false)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").As(I("b"))))
assert.Equal(t, buf.String(), `"a" AS "b"`)
}
func (me *datasetTest) TestBooleanExpression() {
t := me.T()
buf := NewSqlBuilder(false)
ds := From("test")
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").Eq(1)))
assert.Equal(t, buf.String(), `("a" = 1)`)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").Eq(true)))
assert.Equal(t, buf.String(), `("a" IS TRUE)`)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").Eq(false)))
assert.Equal(t, buf.String(), `("a" IS FALSE)`)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").Eq(nil)))
assert.Equal(t, buf.String(), `("a" IS NULL)`)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").Eq([]int64{1, 2, 3})))
assert.Equal(t, buf.String(), `("a" IN (1, 2, 3))`)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").Eq(From("test2").Select("id"))))
assert.Equal(t, buf.String(), `("a" IN (SELECT "id" FROM "test2"))`)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").Neq(1)))
assert.Equal(t, buf.String(), `("a" != 1)`)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").Neq(true)))
assert.Equal(t, buf.String(), `("a" IS NOT TRUE)`)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").Neq(false)))
assert.Equal(t, buf.String(), `("a" IS NOT FALSE)`)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").Neq(nil)))
assert.Equal(t, buf.String(), `("a" IS NOT NULL)`)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").Neq([]int64{1, 2, 3})))
assert.Equal(t, buf.String(), `("a" NOT IN (1, 2, 3))`)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").Neq(From("test2").Select("id"))))
assert.Equal(t, buf.String(), `("a" NOT IN (SELECT "id" FROM "test2"))`)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").Is(nil)))
assert.Equal(t, buf.String(), `("a" IS NULL)`)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").Is(false)))
assert.Equal(t, buf.String(), `("a" IS FALSE)`)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").Is(true)))
assert.Equal(t, buf.String(), `("a" IS TRUE)`)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").IsNot(nil)))
assert.Equal(t, buf.String(), `("a" IS NOT NULL)`)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").IsNot(false)))
assert.Equal(t, buf.String(), `("a" IS NOT FALSE)`)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").IsNot(true)))
assert.Equal(t, buf.String(), `("a" IS NOT TRUE)`)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").Gt(1)))
assert.Equal(t, buf.String(), `("a" > 1)`)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").Gte(1)))
assert.Equal(t, buf.String(), `("a" >= 1)`)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").Lt(1)))
assert.Equal(t, buf.String(), `("a" < 1)`)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").Lte(1)))
assert.Equal(t, buf.String(), `("a" <= 1)`)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").In([]int{1, 2, 3})))
assert.Equal(t, buf.String(), `("a" IN (1, 2, 3))`)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").NotIn([]int{1, 2, 3})))
assert.Equal(t, buf.String(), `("a" NOT IN (1, 2, 3))`)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").Like("a%")))
assert.Equal(t, buf.String(), `("a" LIKE 'a%')`)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").Like(regexp.MustCompile("(a|b)"))))
assert.Equal(t, buf.String(), `("a" ~ '(a|b)')`)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").NotLike("a%")))
assert.Equal(t, buf.String(), `("a" NOT LIKE 'a%')`)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").NotLike(regexp.MustCompile("(a|b)"))))
assert.Equal(t, buf.String(), `("a" !~ '(a|b)')`)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").ILike("a%")))
assert.Equal(t, buf.String(), `("a" ILIKE 'a%')`)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").ILike(regexp.MustCompile("(a|b)"))))
assert.Equal(t, buf.String(), `("a" ~* '(a|b)')`)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").NotILike("a%")))
assert.Equal(t, buf.String(), `("a" NOT ILIKE 'a%')`)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").NotILike(regexp.MustCompile("(a|b)"))))
assert.Equal(t, buf.String(), `("a" !~* '(a|b)')`)
buf = NewSqlBuilder(true)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").Eq(1)))
assert.Equal(t, buf.args, []interface{}{1})
assert.Equal(t, buf.String(), `("a" = ?)`)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").Eq(true)))
assert.Equal(t, buf.args, []interface{}{})
assert.Equal(t, buf.String(), `("a" IS TRUE)`)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").Eq(false)))
assert.Equal(t, buf.args, []interface{}{})
assert.Equal(t, buf.String(), `("a" IS FALSE)`)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").Eq(nil)))
assert.Equal(t, buf.args, []interface{}{nil})
assert.Equal(t, buf.String(), `("a" IS ?)`)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").Eq([]int64{1, 2, 3})))
assert.Equal(t, buf.args, []interface{}{1, 2, 3})
assert.Equal(t, buf.String(), `("a" IN (?, ?, ?))`)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").Neq(1)))
assert.Equal(t, buf.args, []interface{}{1})
assert.Equal(t, buf.String(), `("a" != ?)`)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").Neq(true)))
assert.Equal(t, buf.args, []interface{}{})
assert.Equal(t, buf.String(), `("a" IS NOT TRUE)`)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").Neq(false)))
assert.Equal(t, buf.args, []interface{}{})
assert.Equal(t, buf.String(), `("a" IS NOT FALSE)`)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").Neq(nil)))
assert.Equal(t, buf.args, []interface{}{nil})
assert.Equal(t, buf.String(), `("a" IS NOT ?)`)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").Neq([]int64{1, 2, 3})))
assert.Equal(t, buf.args, []interface{}{1, 2, 3})
assert.Equal(t, buf.String(), `("a" NOT IN (?, ?, ?))`)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").Is(nil)))
assert.Equal(t, buf.args, []interface{}{nil})
assert.Equal(t, buf.String(), `("a" IS ?)`)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").Is(false)))
assert.Equal(t, buf.args, []interface{}{})
assert.Equal(t, buf.String(), `("a" IS FALSE)`)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").Is(true)))
assert.Equal(t, buf.args, []interface{}{})
assert.Equal(t, buf.String(), `("a" IS TRUE)`)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").IsNot(nil)))
assert.Equal(t, buf.args, []interface{}{nil})
assert.Equal(t, buf.String(), `("a" IS NOT ?)`)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").IsNot(false)))
assert.Equal(t, buf.args, []interface{}{})
assert.Equal(t, buf.String(), `("a" IS NOT FALSE)`)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").IsNot(true)))
assert.Equal(t, buf.args, []interface{}{})
assert.Equal(t, buf.String(), `("a" IS NOT TRUE)`)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").Gt(1)))
assert.Equal(t, buf.args, []interface{}{1})
assert.Equal(t, buf.String(), `("a" > ?)`)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").Gte(1)))
assert.Equal(t, buf.args, []interface{}{1})
assert.Equal(t, buf.String(), `("a" >= ?)`)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").Lt(1)))
assert.Equal(t, buf.args, []interface{}{1})
assert.Equal(t, buf.String(), `("a" < ?)`)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").Lte(1)))
assert.Equal(t, buf.args, []interface{}{1})
assert.Equal(t, buf.String(), `("a" <= ?)`)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").In([]int{1, 2, 3})))
assert.Equal(t, buf.args, []interface{}{1, 2, 3})
assert.Equal(t, buf.String(), `("a" IN (?, ?, ?))`)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").NotIn([]int{1, 2, 3})))
assert.Equal(t, buf.args, []interface{}{1, 2, 3})
assert.Equal(t, buf.String(), `("a" NOT IN (?, ?, ?))`)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").Like("a%")))
assert.Equal(t, buf.args, []interface{}{"a%"})
assert.Equal(t, buf.String(), `("a" LIKE ?)`)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").Like(regexp.MustCompile("(a|b)"))))
assert.Equal(t, buf.args, []interface{}{"(a|b)"})
assert.Equal(t, buf.String(), `("a" ~ ?)`)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").NotLike("a%")))
assert.Equal(t, buf.args, []interface{}{"a%"})
assert.Equal(t, buf.String(), `("a" NOT LIKE ?)`)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").NotLike(regexp.MustCompile("(a|b)"))))
assert.Equal(t, buf.args, []interface{}{"(a|b)"})
assert.Equal(t, buf.String(), `("a" !~ ?)`)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").ILike("a%")))
assert.Equal(t, buf.args, []interface{}{"a%"})
assert.Equal(t, buf.String(), `("a" ILIKE ?)`)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").ILike(regexp.MustCompile("(a|b)"))))
assert.Equal(t, buf.args, []interface{}{"(a|b)"})
assert.Equal(t, buf.String(), `("a" ~* ?)`)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").NotILike("a%")))
assert.Equal(t, buf.args, []interface{}{"a%"})
assert.Equal(t, buf.String(), `("a" NOT ILIKE ?)`)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").NotILike(regexp.MustCompile("(a|b)"))))
assert.Equal(t, buf.args, []interface{}{"(a|b)"})
assert.Equal(t, buf.String(), `("a" !~* ?)`)
}
func (me *datasetTest) TestLiteralOrderedExpression() {
t := me.T()
buf := NewSqlBuilder(false)
ds := From("test")
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").Asc()))
assert.Equal(t, buf.String(), `"a" ASC`)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").Desc()))
assert.Equal(t, buf.String(), `"a" DESC`)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").Asc().NullsLast()))
assert.Equal(t, buf.String(), `"a" ASC NULLS LAST`)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").Desc().NullsLast()))
assert.Equal(t, buf.String(), `"a" DESC NULLS LAST`)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").Asc().NullsFirst()))
assert.Equal(t, buf.String(), `"a" ASC NULLS FIRST`)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").Desc().NullsFirst()))
assert.Equal(t, buf.String(), `"a" DESC NULLS FIRST`)
buf = NewSqlBuilder(true)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").Asc()))
assert.Equal(t, buf.args, []interface{}{})
assert.Equal(t, buf.String(), `"a" ASC`)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").Desc()))
assert.Equal(t, buf.args, []interface{}{})
assert.Equal(t, buf.String(), `"a" DESC`)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").Asc().NullsLast()))
assert.Equal(t, buf.args, []interface{}{})
assert.Equal(t, buf.String(), `"a" ASC NULLS LAST`)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").Desc().NullsLast()))
assert.Equal(t, buf.args, []interface{}{})
assert.Equal(t, buf.String(), `"a" DESC NULLS LAST`)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").Asc().NullsFirst()))
assert.Equal(t, buf.args, []interface{}{})
assert.Equal(t, buf.String(), `"a" ASC NULLS FIRST`)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").Desc().NullsFirst()))
assert.Equal(t, buf.args, []interface{}{})
assert.Equal(t, buf.String(), `"a" DESC NULLS FIRST`)
}
func (me *datasetTest) TestLiteralUpdateExpression() {
t := me.T()
buf := NewSqlBuilder(false)
ds := From("test")
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").Set(1)))
assert.Equal(t, buf.String(), `"a"=1`)
buf = NewSqlBuilder(true)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").Set(1)))
assert.Equal(t, buf.args, []interface{}{1})
assert.Equal(t, buf.String(), `"a"=?`)
}
func (me *datasetTest) TestLiteralSqlFunctionExpression() {
t := me.T()
buf := NewSqlBuilder(false)
ds := From("test")
assert.NoError(t, ds.Literal(me.Truncate(buf), Func("MIN", I("a"))))
assert.Equal(t, buf.String(), `MIN("a")`)
assert.NoError(t, ds.Literal(me.Truncate(buf), MIN("a")))
assert.Equal(t, buf.String(), `MIN("a")`)
assert.NoError(t, ds.Literal(me.Truncate(buf), COALESCE(I("a"), "a")))
assert.Equal(t, buf.String(), `COALESCE("a", 'a')`)
buf = NewSqlBuilder(true)
assert.NoError(t, ds.Literal(me.Truncate(buf), Func("MIN", I("a"))))
assert.Equal(t, buf.args, []interface{}{})
assert.Equal(t, buf.String(), `MIN("a")`)
assert.NoError(t, ds.Literal(me.Truncate(buf), MIN("a")))
assert.Equal(t, buf.args, []interface{}{})
assert.Equal(t, buf.String(), `MIN("a")`)
assert.NoError(t, ds.Literal(me.Truncate(buf), COALESCE(I("a"), "a")))
assert.Equal(t, buf.args, []interface{}{"a"})
assert.Equal(t, buf.String(), `COALESCE("a", ?)`)
}
func (me *datasetTest) TestLiteralCastExpression() {
t := me.T()
buf := NewSqlBuilder(false)
ds := From("test")
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").Cast("DATE")))
assert.Equal(t, buf.String(), `CAST("a" AS DATE)`)
buf = NewSqlBuilder(true)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").Cast("DATE")))
assert.Equal(t, buf.args, []interface{}{})
assert.Equal(t, buf.String(), `CAST("a" AS DATE)`)
}
func (me *datasetTest) TestCompoundExpression() {
t := me.T()
buf := NewSqlBuilder(false)
ds := From("test")
assert.NoError(t, ds.Literal(me.Truncate(buf), Union(From("b"))))
assert.Equal(t, buf.String(), ` UNION (SELECT * FROM "b")`)
assert.NoError(t, ds.Literal(me.Truncate(buf), UnionAll(From("b"))))
assert.Equal(t, buf.String(), ` UNION ALL (SELECT * FROM "b")`)
assert.NoError(t, ds.Literal(me.Truncate(buf), Intersect(From("b"))))
assert.Equal(t, buf.String(), ` INTERSECT (SELECT * FROM "b")`)
assert.NoError(t, ds.Literal(me.Truncate(buf), IntersectAll(From("b"))))
assert.Equal(t, buf.String(), ` INTERSECT ALL (SELECT * FROM "b")`)
buf = NewSqlBuilder(true)
assert.NoError(t, ds.Literal(me.Truncate(buf), Union(From("b"))))
assert.Equal(t, buf.args, []interface{}{})
assert.Equal(t, buf.String(), ` UNION (SELECT * FROM "b")`)
assert.NoError(t, ds.Literal(me.Truncate(buf), UnionAll(From("b"))))
assert.Equal(t, buf.args, []interface{}{})
assert.Equal(t, buf.String(), ` UNION ALL (SELECT * FROM "b")`)
assert.NoError(t, ds.Literal(me.Truncate(buf), Intersect(From("b"))))
assert.Equal(t, buf.args, []interface{}{})
assert.Equal(t, buf.String(), ` INTERSECT (SELECT * FROM "b")`)
assert.NoError(t, ds.Literal(me.Truncate(buf), IntersectAll(From("b"))))
assert.Equal(t, buf.args, []interface{}{})
assert.Equal(t, buf.String(), ` INTERSECT ALL (SELECT * FROM "b")`)
}
func (me *datasetTest) TestLiteralIdentifierExpression() {
t := me.T()
buf := NewSqlBuilder(false)
ds := From("test")
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a")))
assert.Equal(t, buf.String(), `"a"`)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a.b")))
assert.Equal(t, buf.String(), `"a"."b"`)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a.b.c")))
assert.Equal(t, buf.String(), `"a"."b"."c"`)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a.b.*")))
assert.Equal(t, buf.String(), `"a"."b".*`)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a.*")))
assert.Equal(t, buf.String(), `"a".*`)
buf = NewSqlBuilder(true)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a")))
assert.Equal(t, buf.String(), `"a"`)
assert.Equal(t, buf.args, []interface{}{})
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a.b")))
assert.Equal(t, buf.String(), `"a"."b"`)
assert.Equal(t, buf.args, []interface{}{})
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a.b.c")))
assert.Equal(t, buf.String(), `"a"."b"."c"`)
assert.Equal(t, buf.args, []interface{}{})
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a.b.*")))
assert.Equal(t, buf.String(), `"a"."b".*`)
assert.Equal(t, buf.args, []interface{}{})
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a.*")))
assert.Equal(t, buf.String(), `"a".*`)
assert.Equal(t, buf.args, []interface{}{})
}
func (me *datasetTest) TestLiteralExpressionMap() {
t := me.T()
buf := NewSqlBuilder(false)
ds := From("test")
assert.NoError(t, ds.Literal(me.Truncate(buf), Ex{"a": 1}))
assert.Equal(t, buf.String(), `("a" = 1)`)
assert.NoError(t, ds.Literal(me.Truncate(buf), Ex{"a": true}))
assert.Equal(t, buf.String(), `("a" IS TRUE)`)
assert.NoError(t, ds.Literal(me.Truncate(buf), Ex{"a": false}))
assert.Equal(t, buf.String(), `("a" IS FALSE)`)
assert.NoError(t, ds.Literal(me.Truncate(buf), Ex{"a": nil}))
assert.Equal(t, buf.String(), `("a" IS NULL)`)
assert.NoError(t, ds.Literal(me.Truncate(buf), Ex{"a": []string{"a", "b", "c"}}))
assert.Equal(t, buf.String(), `("a" IN ('a', 'b', 'c'))`)
assert.NoError(t, ds.Literal(me.Truncate(buf), Ex{"a": Op{"neq": 1}}))
assert.Equal(t, buf.String(), `("a" != 1)`)
assert.NoError(t, ds.Literal(me.Truncate(buf), Ex{"a": Op{"isnot": true}}))
assert.Equal(t, buf.String(), `("a" IS NOT TRUE)`)
assert.NoError(t, ds.Literal(me.Truncate(buf), Ex{"a": Op{"gt": 1}}))
assert.Equal(t, buf.String(), `("a" > 1)`)
assert.NoError(t, ds.Literal(me.Truncate(buf), Ex{"a": Op{"gte": 1}}))
assert.Equal(t, buf.String(), `("a" >= 1)`)
assert.NoError(t, ds.Literal(me.Truncate(buf), Ex{"a": Op{"lt": 1}}))
assert.Equal(t, buf.String(), `("a" < 1)`)
assert.NoError(t, ds.Literal(me.Truncate(buf), Ex{"a": Op{"lte": 1}}))
assert.Equal(t, buf.String(), `("a" <= 1)`)
assert.NoError(t, ds.Literal(me.Truncate(buf), Ex{"a": Op{"like": "a%"}}))
assert.Equal(t, buf.String(), `("a" LIKE 'a%')`)
assert.NoError(t, ds.Literal(me.Truncate(buf), Ex{"a": Op{"notLike": "a%"}}))
assert.Equal(t, buf.String(), `("a" NOT LIKE 'a%')`)
assert.NoError(t, ds.Literal(me.Truncate(buf), Ex{"a": Op{"notLike": "a%"}}))
assert.Equal(t, buf.String(), `("a" NOT LIKE 'a%')`)
assert.NoError(t, ds.Literal(me.Truncate(buf), Ex{"a": Op{"in": []string{"a", "b", "c"}}}))
assert.Equal(t, buf.String(), `("a" IN ('a', 'b', 'c'))`)
assert.NoError(t, ds.Literal(me.Truncate(buf), Ex{"a": Op{"notIn": []string{"a", "b", "c"}}}))
assert.Equal(t, buf.String(), `("a" NOT IN ('a', 'b', 'c'))`)
assert.NoError(t, ds.Literal(me.Truncate(buf), Ex{"a": Op{"is": nil, "eq": 10}}))
assert.Equal(t, buf.String(), `(("a" = 10) OR ("a" IS NULL))`)
buf = NewSqlBuilder(true)
assert.NoError(t, ds.Literal(me.Truncate(buf), Ex{"a": 1}))
assert.Equal(t, buf.args, []interface{}{1})
assert.Equal(t, buf.String(), `("a" = ?)`)
assert.NoError(t, ds.Literal(me.Truncate(buf), Ex{"a": true}))
assert.Equal(t, buf.String(), `("a" IS TRUE)`)
assert.NoError(t, ds.Literal(me.Truncate(buf), Ex{"a": false}))
assert.Equal(t, buf.String(), `("a" IS FALSE)`)
assert.NoError(t, ds.Literal(me.Truncate(buf), Ex{"a": nil}))
assert.Equal(t, buf.args, []interface{}{nil})
assert.Equal(t, buf.String(), `("a" IS ?)`)
assert.NoError(t, ds.Literal(me.Truncate(buf), Ex{"a": []string{"a", "b", "c"}}))
assert.Equal(t, buf.args, []interface{}{"a", "b", "c"})
assert.Equal(t, buf.String(), `("a" IN (?, ?, ?))`)
assert.NoError(t, ds.Literal(me.Truncate(buf), Ex{"a": Op{"neq": 1}}))
assert.Equal(t, buf.args, []interface{}{1})
assert.Equal(t, buf.String(), `("a" != ?)`)
assert.NoError(t, ds.Literal(me.Truncate(buf), Ex{"a": Op{"isnot": true}}))
assert.Equal(t, buf.args, []interface{}{})
assert.Equal(t, buf.String(), `("a" IS NOT TRUE)`)
assert.NoError(t, ds.Literal(me.Truncate(buf), Ex{"a": Op{"gt": 1}}))
assert.Equal(t, buf.args, []interface{}{1})
assert.Equal(t, buf.String(), `("a" > ?)`)
assert.NoError(t, ds.Literal(me.Truncate(buf), Ex{"a": Op{"gte": 1}}))
assert.Equal(t, buf.args, []interface{}{1})
assert.Equal(t, buf.String(), `("a" >= ?)`)
assert.NoError(t, ds.Literal(me.Truncate(buf), Ex{"a": Op{"lt": 1}}))
assert.Equal(t, buf.args, []interface{}{1})
assert.Equal(t, buf.String(), `("a" < ?)`)
assert.NoError(t, ds.Literal(me.Truncate(buf), Ex{"a": Op{"lte": 1}}))
assert.Equal(t, buf.args, []interface{}{1})
assert.Equal(t, buf.String(), `("a" <= ?)`)
assert.NoError(t, ds.Literal(me.Truncate(buf), Ex{"a": Op{"like": "a%"}}))
assert.Equal(t, buf.args, []interface{}{"a%"})
assert.Equal(t, buf.String(), `("a" LIKE ?)`)
assert.NoError(t, ds.Literal(me.Truncate(buf), Ex{"a": Op{"notLike": "a%"}}))
assert.Equal(t, buf.args, []interface{}{"a%"})
assert.Equal(t, buf.String(), `("a" NOT LIKE ?)`)
assert.NoError(t, ds.Literal(me.Truncate(buf), Ex{"a": Op{"in": []string{"a", "b", "c"}}}))
assert.Equal(t, buf.args, []interface{}{"a", "b", "c"})
assert.Equal(t, buf.String(), `("a" IN (?, ?, ?))`)
assert.NoError(t, ds.Literal(me.Truncate(buf), Ex{"a": Op{"notIn": []string{"a", "b", "c"}}}))
assert.Equal(t, buf.args, []interface{}{"a", "b", "c"})
assert.Equal(t, buf.String(), `("a" NOT IN (?, ?, ?))`)
assert.NoError(t, ds.Literal(me.Truncate(buf), Ex{"a": Op{"is": nil, "eq": 10}}))
assert.Equal(t, buf.args, []interface{}{10, nil})
assert.Equal(t, buf.String(), `(("a" = ?) OR ("a" IS ?))`)
}
func (me *datasetTest) TestLiteralExpressionOrMap() {
t := me.T()
buf := NewSqlBuilder(false)
ds := From("test")
assert.NoError(t, ds.Literal(me.Truncate(buf), ExOr{"a": 1, "b": true}))
assert.Equal(t, buf.String(), `(("a" = 1) OR ("b" IS TRUE))`)
assert.NoError(t, ds.Literal(me.Truncate(buf), ExOr{"a": 1, "b": []string{"a", "b", "c"}}))
assert.Equal(t, buf.String(), `(("a" = 1) OR ("b" IN ('a', 'b', 'c')))`)
buf = NewSqlBuilder(true)
assert.NoError(t, ds.Literal(me.Truncate(buf), ExOr{"a": 1, "b": true}))
assert.Equal(t, buf.args, []interface{}{1})
assert.Equal(t, buf.String(), `(("a" = ?) OR ("b" IS TRUE))`)
assert.NoError(t, ds.Literal(me.Truncate(buf), ExOr{"a": 1, "b": []string{"a", "b", "c"}}))
assert.Equal(t, buf.args, []interface{}{1, "a", "b", "c"})
assert.Equal(t, buf.String(), `(("a" = ?) OR ("b" IN (?, ?, ?)))`)
}
func TestDatasetSuite(t *testing.T) {
suite.Run(t, new(datasetTest))
}