MentaBean

Rev

Rev 206 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
149 erico 1
package org.mentabean.jdbc;
2
 
163 erico 3
import static org.junit.Assert.assertEquals;
4
import static org.junit.Assert.assertFalse;
5
import static org.junit.Assert.assertNotNull;
6
import static org.junit.Assert.assertNull;
7
import static org.junit.Assert.assertTrue;
8
 
149 erico 9
import java.sql.PreparedStatement;
10
import java.sql.ResultSet;
11
import java.util.ArrayList;
12
import java.util.List;
13
 
182 erico 14
import junit.framework.Assert;
15
 
157 erico 16
import org.junit.After;
17
import org.junit.Before;
149 erico 18
import org.junit.Test;
19
import org.mentabean.BeanConfig;
20
import org.mentabean.BeanException;
21
import org.mentabean.BeanManager;
22
import org.mentabean.BeanSession;
23
import org.mentabean.DBTypes;
24
import org.mentabean.jdbc.QueryBuilder.Alias;
151 erico 25
import org.mentabean.jdbc.QueryBuilder.Query;
154 erico 26
import org.mentabean.sql.Sentence;
152 erico 27
import org.mentabean.sql.conditions.Between;
149 erico 28
import org.mentabean.sql.conditions.Equals;
152 erico 29
import org.mentabean.sql.conditions.GreaterThan;
149 erico 30
import org.mentabean.sql.conditions.In;
163 erico 31
import org.mentabean.sql.conditions.LessThan;
149 erico 32
import org.mentabean.sql.conditions.Like;
163 erico 33
import org.mentabean.sql.conditions.NotEquals;
153 erico 34
import org.mentabean.sql.conditions.NotIn;
182 erico 35
import org.mentabean.sql.functions.Avg;
154 erico 36
import org.mentabean.sql.functions.Count;
151 erico 37
import org.mentabean.sql.functions.Length;
149 erico 38
import org.mentabean.sql.functions.Lower;
39
import org.mentabean.sql.functions.Substring;
151 erico 40
import org.mentabean.sql.functions.Upper;
169 erico 41
import org.mentabean.sql.operations.Add;
182 erico 42
import org.mentabean.sql.param.DefaultParamHandler;
43
import org.mentabean.sql.param.Param;
151 erico 44
import org.mentabean.sql.param.ParamField;
45
import org.mentabean.sql.param.ParamFunction;
182 erico 46
import org.mentabean.sql.param.ParamHandler;
151 erico 47
import org.mentabean.sql.param.ParamSubQuery;
48
import org.mentabean.sql.param.ParamValue;
149 erico 49
import org.mentabean.util.PropertiesProxy;
50
import org.mentabean.util.SQLUtils;
51
 
52
public class QueryBuilderTest extends AbstractBeanSessionTest {
53
 
153 erico 54
        public static class Country {
55
 
56
                private String name;
57
 
58
                public Country(String name) {
59
                        this.name = name;
60
                }
61
 
62
                public Country() {
63
 
64
                }
65
 
66
                public String getName() {
67
                        return name;
68
                }
69
 
70
                public void setName(String name) {
71
                        this.name = name;
72
                }
73
 
74
        }
75
 
76
        public static class City {
77
 
78
                private int code;
79
                private String name;
80
                private Country country;
81
 
82
                public City(int code, String name, Country country) {
83
                        this.code = code;
84
                        this.name = name;
85
                        this.country = country;
86
                }
87
 
88
                public City() {
89
 
90
                }
91
 
92
                public String getName() {
93
                        return name;
94
                }
95
                public void setName(String name) {
96
                        this.name = name;
97
                }
98
 
99
                public int getCode() {
100
                        return code;
101
                }
102
 
103
                public void setCode(int code) {
104
                        this.code = code;
105
                }
106
 
107
                public Country getCountry() {
108
                        return country;
109
                }
110
 
111
                public void setCountry(Country country) {
112
                        this.country = country;
113
                }
114
        }
115
 
149 erico 116
        public static class Company {
117
 
118
                private String id;
119
                private String name;
153 erico 120
                private City city;
154 erico 121
                private int employeesCount;
149 erico 122
 
152 erico 123
                public Company(String name) {
124
                        this.name = name;
125
                }
126
 
127
                public Company() {
128
 
129
                }
130
 
149 erico 131
                public String getName() {
132
                        return name;
133
                }
134
                public void setName(String name) {
135
                        this.name = name;
136
                }
137
                public String getId() {
138
                        return id;
139
                }
140
                public void setId(String id) {
141
                        this.id = id;
142
                }
153 erico 143
                public City getCity() {
144
                        return city;
145
                }
146
 
147
                public void setCity(City city) {
148
                        this.city = city;
149
                }
150
 
154 erico 151
                public int getEmployeesCount() {
152
                        return employeesCount;
153
                }
154
 
155
                public void setEmployeesCount(int employeesCount) {
156
                        this.employeesCount = employeesCount;
157
                }
158
 
149 erico 159
                @Override
160
                public String toString() {
153 erico 161
                        return "Company [id=" + id + ", name=" + name + ", city=" + city
162
                                        + "]";
149 erico 163
                }
153 erico 164
 
149 erico 165
        }
166
 
167
        public static class Employee {
168
 
169
                private long number;
170
                private String name;
171
                private double salary;
172
 
155 erico 173
                public Employee(long number, String name, double salary) {
174
                        this.number = number;
152 erico 175
                        this.name = name;
155 erico 176
                        this.salary = salary;
149 erico 177
                }
155 erico 178
 
152 erico 179
                public Employee() {
180
 
149 erico 181
                }
152 erico 182
 
149 erico 183
                public long getNumber() {
184
                        return number;
185
                }
186
                public void setNumber(long number) {
187
                        this.number = number;
188
                }
189
                public String getName() {
190
                        return name;
191
                }
192
                public void setName(String name) {
193
                        this.name = name;
194
                }
195
                public double getSalary() {
196
                        return salary;
197
                }
198
                public void setSalary(double salary) {
199
                        this.salary = salary;
200
                }
154 erico 201
 
202
                @Override
203
                public String toString() {
157 erico 204
                        return "\n"+number + " - " + name + " - " + salary;
154 erico 205
                }
149 erico 206
 
207
        }
208
 
209
        public static class Post {
210
 
211
                private Employee employee;
212
                private Company company;
213
                private String description;
214
 
152 erico 215
                public Post(Employee employee, Company company, String description) {
216
                        this.employee = employee;
217
                        this.company = company;
218
                        this.description = description;
219
                }
220
 
221
                public Post() {
222
 
223
                }
224
 
149 erico 225
                public Employee getEmployee() {
226
                        return employee;
227
                }
228
                public void setEmployee(Employee employee) {
229
                        this.employee = employee;
230
                }
231
                public Company getCompany() {
232
                        return company;
233
                }
234
                public void setCompany(Company company) {
235
                        this.company = company;
236
                }
237
                public String getDescription() {
238
                        return description;
239
                }
240
                public void setDescription(String description) {
241
                        this.description = description;
242
                }
154 erico 243
 
244
                @Override
245
                public String toString() {
246
                        return "Post [employee=" + employee + ", company=" + company
247
                                        + ", description=" + description + "]";
248
                }
149 erico 249
 
250
        }
251
 
252
        private BeanManager configure() {
253
 
254
                BeanManager manager = new BeanManager();
255
 
256
                Company comPxy = PropertiesProxy.create(Company.class);
257
                BeanConfig comConf = new BeanConfig(Company.class, "company")
151 erico 258
                .pk(comPxy.getId(), "idcompany", DBTypes.STRING)
153 erico 259
                .field(comPxy.getCity().getCode(), "c_code", DBTypes.INTEGER)
149 erico 260
                .field(comPxy.getName(), DBTypes.STRING);
261
                manager.addBeanConfig(comConf);
262
 
263
                Employee empPxy = PropertiesProxy.create(Employee.class);
264
                BeanConfig employeeConf = new BeanConfig(Employee.class, "employee")
152 erico 265
                .pk(empPxy.getNumber(), "idemployee", DBTypes.LONG)
149 erico 266
                .field(empPxy.getName(), DBTypes.STRING)
267
                .field(empPxy.getSalary(), DBTypes.DOUBLE);
268
                manager.addBeanConfig(employeeConf);
269
 
270
                Post postPxy = PropertiesProxy.create(Post.class);
271
                BeanConfig postConf = new BeanConfig(Post.class, "post")
152 erico 272
                .pk(postPxy.getEmployee().getNumber(), "idemployee", DBTypes.LONG)
149 erico 273
                .pk(postPxy.getCompany().getId(), "idcompany", DBTypes.STRING)
274
                .field(postPxy.getDescription(), DBTypes.STRING);
275
                manager.addBeanConfig(postConf);
276
 
153 erico 277
                City cityPxy = PropertiesProxy.create(City.class);
278
                BeanConfig cityConf = new BeanConfig(City.class, "cities")
279
                .pk(cityPxy.getCode(), "city_code", DBTypes.INTEGER)
280
                .field(cityPxy.getCountry().getName(), "country_name", DBTypes.STRING)
281
                .field(cityPxy.getName(), "city_name", DBTypes.STRING);
282
                manager.addBeanConfig(cityConf);
283
 
284
                Country countryPxy = PropertiesProxy.create(Country.class);
285
                BeanConfig countryConf = new BeanConfig(Country.class, "countries")
286
                .pk(countryPxy.getName(), "country_ident", DBTypes.STRING);
287
                manager.addBeanConfig(countryConf);
288
 
149 erico 289
                return manager;
290
 
291
        }
292
 
293
        @Test
294
        public void test() {
295
 
296
                PreparedStatement ppst = null;
297
 
298
                try {
299
 
300
                        Company comp = new Company();
301
                        comp.setId("4356136");
302
                        comp.setName("W3C");
303
                        session.insert(comp);
304
 
305
                        Company basicComp = session.createBasicInstance(comp);
157 erico 306
                        assertFalse(comp == basicComp);
307
                        assertNotNull(basicComp.getId());
308
                        assertNull(basicComp.getName());
149 erico 309
 
310
                        if (AnsiSQLBeanSession.DEBUG) {
311
                                System.out.println("Company:             " + comp);
312
                                System.out.println("Company (only pks):  " + basicComp);
313
                        }
314
 
315
                        Employee emp = new Employee();
316
                        emp.setName("√Črico");
317
                        emp.setNumber(391);
318
                        emp.setSalary(9999);
319
                        session.insert(emp);
320
 
321
                        Employee basicEmp = session.createBasicInstance(emp);
157 erico 322
                        assertNull(basicEmp.getName());
323
                        assertEquals(0d, basicEmp.getSalary(), 0);
324
                        assertEquals(emp.getNumber(), basicEmp.getNumber());
149 erico 325
 
326
                        Post post = new Post();
327
                        post.setCompany(comp);
328
                        post.setEmployee(emp);
329
                        post.setDescription("Programmer");
330
                        session.insert(post);
331
 
332
                        QueryBuilder builder = session.buildQuery();
333
                        Alias<Employee> e = builder.aliasTo(Employee.class, "emp");
334
                        Alias<Company> c = builder.aliasTo(Company.class, "com");
335
                        Alias<Post> p = builder.aliasTo(Post.class, "p");
336
                        Alias<Employee> e2 = builder.aliasTo(Employee.class, "emp2");
337
                        e2.setReturns(e2.pxy().getNumber());
338
 
151 erico 339
                        Query query = builder.select(p, c, e)
149 erico 340
                        .from(p)
341
 
155 erico 342
                        .join(c).pkOf(c).in(p)
343
                        .join(e).pkOf(e).in(p)
149 erico 344
 
345
                        .where()
151 erico 346
                        .clause(new Substring(new ParamField(e, e.pxy().getName()))
347
 
348
                                /*
349
                                 * it's joke (only for showing that's possible to do that)
350
                                 */
351
                                .beginIndex(new ParamFunction(new Length(
352
                                                new ParamFunction(new Lower(
353
                                                                new ParamFunction(new Upper(
354
                                                                                new ParamValue("c"))))))))
355
                                .endIndex(new ParamFunction(new Length(
356
                                                new ParamFunction(new Lower(
357
                                                                new ParamField(e, e.pxy().getName())))))))
358
                                .condition(new Like(new ParamValue("%o"))).and()
359
 
182 erico 360
                        .clause(e.pxy().getNumber()).condition(
151 erico 361
                                        new In(new ParamSubQuery(builder.subQuery()
362
                                                        .select(e2)
363
                                                        .from(e2)
364
                                                        .where()
365
                                                        .clause(new Substring(new ParamValue("teste")).endIndex(
366
                                                                        new ParamFunction(new Length(new ParamValue("CA")))))
152 erico 367
                                                                        .condition(new Equals(new ParamValue("te")))
368
                                                        ))).and()
149 erico 369
 
155 erico 370
                        .clause(new Lower(new ParamField(c, c.pxy().getName()))).condition(
152 erico 371
                                                        new Equals(new ParamFunction(new Lower(new ParamValue("W3c")))))
149 erico 372
                        .orderBy().asc(p, p.pxy().getDescription())
152 erico 373
                        .limit(10);
149 erico 374
 
151 erico 375
                        ppst = query.prepare();
149 erico 376
 
151 erico 377
                        if (AnsiSQLBeanSession.DEBUG_NATIVE) {
378
                                System.out.println("CUSTOM: "+ppst);
379
                        }
380
 
149 erico 381
                        ResultSet rs = ppst.executeQuery();
382
 
383
                        List<Post> list = new ArrayList<Post>();
384
 
385
                        while (rs.next()) {
386
 
387
                                Post pObj = new Post();
388
                                p.populateBean(rs, pObj);
389
                                c.populateBean(rs, pObj.getCompany());
390
                                e.populateBean(rs, pObj.getEmployee());
391
 
392
                                list.add(pObj);
393
                        }
394
 
157 erico 395
                        assertEquals(1, list.size());
396
                        assertNotNull(list.get(0));
397
                        assertNotNull(list.get(0).getCompany());
398
                        assertNotNull(list.get(0).getEmployee());
149 erico 399
 
400
                }catch (Exception e) {
401
 
402
                        throw new BeanException(e);
403
 
404
                }finally {
405
 
157 erico 406
                        SQLUtils.close(ppst);
149 erico 407
                }
408
        }
409
 
157 erico 410
        private BeanSession session;
411
 
412
        @Before
413
        public void setUp() {
414
                AnsiSQLBeanSession.DEBUG = false;
415
                AnsiSQLBeanSession.DEBUG_NATIVE = false;
152 erico 416
 
157 erico 417
                session = new H2BeanSession(configure(), getConnection());
418
                session.createTables();
419
 
420
                prepareData();
421
        }
422
 
423
        @After
424
        public void tearDown() {
425
                SQLUtils.close(session.getConnection());
426
        }
427
 
428
        public void prepareData() {
152 erico 429
 
157 erico 430
                Company comp;
431
                Employee emp;
432
                Post post;
433
 
434
                Country usa = new Country("United States");
435
                session.insert(usa);
436
 
437
                City ny = new City(123, "New York", usa);
438
                session.insert(ny);
439
                City sf = new City(1020, "San Francisco", usa);
440
                session.insert(sf);
441
 
442
                /*
443
                 * Companies
444
                 */
445
                comp = new Company();
446
                comp.setId("1");
447
                comp.setName("Google");
448
                comp.setCity(ny);
449
                session.insert(comp);
450
 
451
                comp = new Company();
452
                comp.setId("2");
453
                comp.setName("IBM");
454
                session.insert(comp);
455
 
456
                comp = new Company();
457
                comp.setId("3");
458
                comp.setName("Oracle");
459
                comp.setCity(sf);
460
                session.insert(comp);
461
 
462
 
463
                /*
464
                 * Google employees
465
                 */
466
                comp = session.loadList(new Company("Google")).get(0);
467
 
468
                emp = new Employee(19, "Maile Ohye", 19750);
469
                session.insert(emp);
470
                post = new Post(emp, comp, "Developer Programs Tech Lead");
471
                session.insert(post);
472
 
473
                emp = new Employee(12, "Ilya Grigorik", 10000);
474
                session.insert(emp);
475
                post = new Post(emp, comp, "Developer Advocate");
476
                session.insert(post);
477
 
478
                emp = new Employee(15, "Michael Manoochehri", 18100);
479
                session.insert(emp);
480
                post = new Post(emp, comp, "Developer Programs Engineer");
481
                session.insert(post);
482
 
483
                emp = new Employee(18, "Brian Cairns", 12500);
484
                session.insert(emp);
485
                post = new Post(emp, comp, "Software Engineer");
486
                session.insert(post);
487
 
488
 
489
                /*
490
                 * Oracle employees
491
                 */
492
                comp = session.loadList(new Company("Oracle")).get(0);
493
 
494
                emp = new Employee(2, "Lawrence J. Ellison", 38900);
495
                session.insert(emp);
496
                post = new Post(emp, comp, "Chief Executive Officer");
497
                session.insert(post);
498
 
499
                emp = new Employee(1, "Mark V. Hurd", 63250);
500
                session.insert(emp);
501
                post = new Post(emp, comp, "President");
502
                session.insert(post);
503
 
504
                /*
505
                 * No company employee
506
                 */
507
                emp = new Employee();
508
                emp.setName("No company");
509
                emp.setNumber(999);
510
                session.insert(emp);
511
 
152 erico 512
        }
513
 
514
        /**
515
         * Retrieve all employees
516
         */
157 erico 517
        @Test
518
        public void query01() throws Exception {
153 erico 519
 
520
                QueryBuilder builder = session.buildQuery();
521
                Alias<Employee> e = builder.aliasTo(Employee.class, "emp");
522
 
523
                Query query = builder
524
                                .select(e)
525
                                .from(e);
526
 
527
                List<Employee> list = query.executeQuery();
528
 
157 erico 529
                assertEquals(7, list.size());
152 erico 530
        }
531
 
532
        /**
533
         * Retrieve all employees which salary is greater then $15000 sorting by name
534
         */
157 erico 535
        @Test
536
        public void query02() throws Exception {
152 erico 537
 
153 erico 538
                QueryBuilder builder = session.buildQuery();
539
                Alias<Employee> e = builder.aliasTo(Employee.class, "emp");
152 erico 540
 
153 erico 541
                Query query = builder
542
                                .select(e)
543
                                .from(e)
544
                                .where()
182 erico 545
                                .clause(e.pxy().getSalary())
153 erico 546
                                .condition(new GreaterThan(15000))
547
                                .orderBy().asc(e, e.pxy().getName());
152 erico 548
 
153 erico 549
                List<Employee> list = query.executeQuery();
152 erico 550
 
157 erico 551
                assertEquals(4, list.size());
552
                assertEquals(list.get(0).getName(), "Lawrence J. Ellison"); //first
553
                assertEquals(list.get(3).getName(), "Michael Manoochehri"); //last
152 erico 554
        }
555
 
556
        /**
557
         * Retrieve all Google employees which name starts with "M" sorting by name
558
         */
157 erico 559
        @Test
560
        public void query03() throws Exception {
153 erico 561
 
562
                QueryBuilder builder = session.buildQuery();
563
                Alias<Employee> e = builder.aliasTo(Employee.class, "emp");
564
                Alias<Company> c = builder.aliasTo(Company.class, "com");
565
                Alias<Post> p = builder.aliasTo(Post.class);
566
 
567
                Query query = builder
568
                                .select(e)
569
                                .from(e)
155 erico 570
                                .join(p).pkOf(e).in(p)
571
                                .join(c).pkOf(c).in(p)
153 erico 572
                                .where()
182 erico 573
                                .clause(c.pxy().getName())
153 erico 574
                                .condition(new Equals("Google"))
575
                                .and()
182 erico 576
                                .clause(e.pxy().getName())
153 erico 577
                                .condition(new Like("M%"))
578
                                .orderBy().asc(e, e.pxy().getName());
579
 
580
                List<Employee> list = query.executeQuery();
581
 
157 erico 582
                assertEquals(2, list.size());
583
                assertEquals(list.get(0).getName(), "Maile Ohye"); //first
584
                assertEquals(list.get(1).getName(), "Michael Manoochehri"); //last
152 erico 585
        }
586
 
587
        /**
588
         * Retrieve all Google employees which salary between 10000 and 15000 sorting by salary
589
         */
157 erico 590
        @Test
591
        public void query04() throws Exception {
153 erico 592
 
593
                QueryBuilder builder = session.buildQuery();
594
                Alias<Employee> e = builder.aliasTo(Employee.class, "emp");
595
                Alias<Company> c = builder.aliasTo(Company.class, "com");
596
                Alias<Post> p = builder.aliasTo(Post.class);
597
 
598
                Query query = builder
599
                                .select(e)
600
                                .from(e)
155 erico 601
                                .join(p).pkOf(e).in(p)
602
                                .join(c).pkOf(c).in(p)
153 erico 603
                                .where()
182 erico 604
                                .clause(c.pxy().getId())
158 erico 605
                                .condition(new Equals("1"))
153 erico 606
                                .and()
182 erico 607
                                .clause(e.pxy().getSalary())
153 erico 608
                                .condition(new Between(10000, 15000))
609
                                .orderBy().asc(e, e.pxy().getSalary());
610
 
611
                List<Employee> list = query.executeQuery();
612
 
157 erico 613
                assertEquals(2, list.size());
614
                assertEquals(list.get(0).getName(), "Ilya Grigorik"); //first
615
                assertEquals(list.get(1).getName(), "Brian Cairns"); //last
152 erico 616
        }
617
 
618
        /**
153 erico 619
         * Retrieve all posts (with employees and companies) sorting by company name ASC and employee name DESC
152 erico 620
         */
157 erico 621
        @Test
622
        public void query05() throws Exception {
153 erico 623
 
624
                QueryBuilder builder = session.buildQuery();
625
                Alias<Employee> e = builder.aliasTo(Employee.class, "emp");
626
                Alias<Company> c = builder.aliasTo(Company.class, "com");
627
                Alias<Post> p = builder.aliasTo(Post.class);
628
 
629
                Query query = builder
630
                                .select(p, e, c)
631
                                .from(p)
152 erico 632
 
155 erico 633
                                .join(e).pkOf(e).in(p)
153 erico 634
                                //here we set the bean where 'e' alias (employee) will be populate
154 erico 635
                                .inProperty(p.pxy().getEmployee())
152 erico 636
 
155 erico 637
                                .join(c).pkOf(c).in(p)
153 erico 638
                                //here we set the bean where 'c' alias (company) will be populate                               
154 erico 639
                                .inProperty(p.pxy().getCompany())
152 erico 640
 
153 erico 641
                                .orderBy()
642
                                .asc(c, c.pxy().getName())
643
                                .desc(e, e.pxy().getName());
644
 
645
                List<Post> list = query.executeQuery();
646
 
157 erico 647
                assertNotNull(list.get(0).getCompany().getName());
648
                assertEquals(6, list.size());
649
                assertEquals(list.get(0).getEmployee().getName(), "Michael Manoochehri"); //first
650
                assertEquals(list.get(0).getCompany().getName(), "Google"); //first
651
                assertEquals(list.get(5).getEmployee().getName(), "Lawrence J. Ellison"); //last
652
                assertEquals(list.get(5).getCompany().getName(), "Oracle"); //last
153 erico 653
        }
654
 
655
        /**
656
         * Retrieve all employees that have no company
657
         */
157 erico 658
        @Test
659
        public void query06() {
153 erico 660
 
661
                QueryBuilder builder = session.buildQuery();
662
                Alias<Employee> e = builder.aliasTo(Employee.class, "emp");
663
                Alias<Employee> eSub = builder.aliasTo(Employee.class, "emp_sub");
664
                eSub.setReturns(eSub.pxy().getNumber());
665
                Alias<Post> p = builder.aliasTo(Post.class);
666
 
667
                Query query = builder
668
                                .select(e)
669
                                .from(e)
670
                                .where()
155 erico 671
 
182 erico 672
                                .clause(e.pxy().getNumber())
152 erico 673
 
153 erico 674
                                //sub query in 'NOT IN' condition
675
                                .condition(new NotIn(new ParamSubQuery(
676
                                                builder.subQuery()
677
                                                .select(eSub)
678
                                                .from(eSub)
155 erico 679
                                                .join(p).pkOf(eSub).in(p))
153 erico 680
                                ));
681
 
682
                List<Employee> list = query.executeQuery();
683
 
157 erico 684
                assertEquals(1, list.size());
685
                assertEquals(list.get(0).getName(), "No company");
152 erico 686
        }
687
 
153 erico 688
        /**
689
         * Retrieve all employees that have no company (same as above, just another way to build the SQL query)
690
         */
157 erico 691
        @Test
692
        public void query07() {
153 erico 693
 
694
                QueryBuilder builder = session.buildQuery();
695
                Alias<Employee> e = builder.aliasTo(Employee.class, "emp");
696
                Alias<Post> p = builder.aliasTo(Post.class);
697
 
698
                Query query = builder
699
                                .select(e)
700
                                .from(e)
155 erico 701
                                .leftJoin(p).pkOf(e).in(p)
153 erico 702
                                .where()
182 erico 703
                                .clause(p.pxy().getDescription())
153 erico 704
 
705
                                //this will be converted to 'IS NULL' in query. See the Equals condition
706
                                .condition(new Equals(null));
707
 
708
                List<Employee> list = query.executeQuery();
709
 
157 erico 710
                assertEquals(1, list.size());
711
                assertEquals(list.get(0).getName(), "No company");
153 erico 712
        }
713
 
154 erico 714
        /**
715
         * Retrieve all employees which name length is greater then 15 sorting by length ASC, name DESC
716
         */
157 erico 717
        @Test
718
        public void query08() {
154 erico 719
 
720
                QueryBuilder builder = session.buildQuery();
721
                Alias<Employee> e = builder.aliasTo(Employee.class, "emp");
722
 
723
                Query query = builder
724
                                .select(e)
725
                                .from(e)
726
                                .where()
727
 
728
                                .clause(new Length(new ParamField(e, e.pxy().getName())))
729
                                .condition(new GreaterThan(15))
730
 
731
                                .orderBy()
732
                                .asc(new ParamFunction(new Length(new ParamField(e, e.pxy().getName()))))
733
                                .desc(e, e.pxy().getName());
734
 
735
                List<Employee> list = query.executeQuery();
736
 
157 erico 737
                assertEquals(2, list.size());
738
                assertEquals(list.get(0).getName(), "Michael Manoochehri");
739
                assertEquals(list.get(1).getName(), "Lawrence J. Ellison");
154 erico 740
        }
741
 
742
        /**
743
         * Retrieve all companies with a count of employees sorting by company name ASC
744
         */
157 erico 745
        @Test
746
        public void query09() {
154 erico 747
 
748
                QueryBuilder builder = session.buildQuery();
157 erico 749
                Alias<Company> c = builder.aliasTo(Company.class, "c");
750
                Alias<Employee> e = builder.aliasTo(Employee.class, "e");
751
                Alias<Post> p = builder.aliasTo(Post.class, "p");
154 erico 752
 
157 erico 753
                Sentence count = new Sentence(new Count(new ParamField(e, e.pxy().getNumber())))
754
                        .fromProperty(c.pxy().getEmployeesCount());
755
 
154 erico 756
                Query query = builder
157 erico 757
                                .select(c)
758
                                .add(count)
154 erico 759
                                .from(c)
155 erico 760
                                .leftJoin(p).pkOf(c).in(p)
761
                                .leftJoin(e).pkOf(e).in(p)
154 erico 762
                                .groupBy(c)
763
                                .orderBy()
764
                                .asc(c, c.pxy().getName());
765
 
766
                List<Company> list = query.executeQuery();
767
 
157 erico 768
                assertEquals(3, list.size());
769
                assertEquals(list.get(0).getName(), "Google");
770
                assertEquals(list.get(0).getEmployeesCount(), 4);
771
                assertEquals(list.get(1).getName(), "IBM");
772
                assertEquals(list.get(1).getEmployeesCount(), 0);
773
                assertEquals(list.get(2).getName(), "Oracle");
774
                assertEquals(list.get(2).getEmployeesCount(), 2);
775
        }
776
 
777
        /**
778
         * Retrieve all companies having count of employees greater than 0 (zero) sorting by number of employees ASC
779
         */
780
        @Test
781
        public void query10() {
154 erico 782
 
157 erico 783
                QueryBuilder builder = session.buildQuery();
784
                Alias<Company> c = builder.aliasTo(Company.class, "c");
785
                Alias<Employee> e = builder.aliasTo(Employee.class, "e");
786
                Alias<Post> p = builder.aliasTo(Post.class, "p");
787
 
788
                Sentence count = new Sentence(new Count(new ParamField(e, e.pxy().getNumber())))
789
                        .fromProperty(c.pxy().getEmployeesCount());
790
 
791
                Query query = builder
792
                                .select(c)
793
                                .add(count)
794
                                .from(c)
795
                                .leftJoin(p).pkOf(c).in(p)
796
                                .leftJoin(e).pkOf(e).in(p)
797
                                .groupBy(c)
798
                                        .having()
799
                                        .clause(count)
800
                                        .condition(new GreaterThan(0))
801
                                .orderBy()
802
                                .asc(new ParamFunction(count));
803
 
804
                List<Company> list = query.executeQuery();
805
 
806
                assertEquals(2, list.size());
807
                assertEquals(list.get(0).getName(), "Oracle");
808
                assertEquals(list.get(0).getEmployeesCount(), 2);
809
                assertEquals(list.get(1).getName(), "Google");
810
                assertEquals(list.get(1).getEmployeesCount(), 4);
154 erico 811
        }
812
 
813
        /**
814
         * Retrieve all companies with a count of employees sorting by company name ASC
815
         */
157 erico 816
        @Test
817
        public void query11() {
154 erico 818
 
819
                QueryBuilder builder = session.buildQuery();
820
                Alias<Company> c = builder.aliasTo(Company.class, "com");
821
                Alias<Employee> e = builder.aliasTo(Employee.class, "emp");
822
                Alias<Post> p = builder.aliasTo(Post.class, "p");
823
                Alias<Post> p2 = builder.aliasTo(Post.class, "p2");
824
 
825
                Query sub = builder.subQuery()
826
                                .select(new Sentence(new Count(new ParamField(p2, p2.pxy().getDescription()))).name("count_sub"))
827
                                .from(p2)
828
                                .where()
182 erico 829
                                .clause(p2.pxy().getCompany().getId())
154 erico 830
                                .condition(new Equals(new ParamField(c, c.pxy().getId())));
831
 
832
                Query query = builder
833
                                .select(p, c)
834
                                        .add(new Sentence(sub)
155 erico 835
                                        .fromProperty(p.pxy().getCompany().getEmployeesCount()))
154 erico 836
                                .from(p)
155 erico 837
                                .leftJoin(c).pkOf(c).in(p)
154 erico 838
                                .inProperty(p.pxy().getCompany())
155 erico 839
                                .leftJoin(e).pkOf(e).in(p)
154 erico 840
                                .inProperty(p.pxy().getEmployee())
841
                                .orderBy()
842
                                .asc(c, c.pxy().getName());
843
 
844
                List<Post> list = query.executeQuery();
845
 
157 erico 846
                assertEquals(6, list.size());
847
                assertEquals(list.get(0).getCompany().getName(), "Google");
848
                assertEquals(list.get(0).getCompany().getEmployeesCount(), 4);
849
                assertEquals(list.get(5).getCompany().getName(), "Oracle");
850
                assertEquals(list.get(5).getCompany().getEmployeesCount(), 2);
851
        }
852
 
853
        /**
854
         * Retrieve all companies with name upper case
855
         */
856
        @Test
857
        public void query12() {
154 erico 858
 
157 erico 859
                QueryBuilder builder = session.buildQuery();
860
                Alias<Company> c = builder.aliasTo(Company.class, "c");
861
 
862
                Sentence nameUpper = new Sentence(new Upper(new ParamField(c, c.pxy().getName())))
863
                        .fromProperty(c.pxy().getName());
864
 
865
                Query query = builder
866
                                .select(c)
867
                                .add(nameUpper)
868
                                .from(c)
869
                                .orderBy()
870
                                .asc(c, c.pxy().getName());
871
 
872
                List<Company> list = query.executeQuery();
873
 
874
                assertEquals(3, list.size());
875
                assertEquals(list.get(0).getName(), "GOOGLE");
876
                assertEquals(list.get(1).getName(), "IBM");
877
                assertEquals(list.get(2).getName(), "ORACLE");
154 erico 878
        }
879
 
157 erico 880
        /**
881
         * Retrieve all companies with name upper case and a count of employees
882
         */
883
        @Test
884
        public void query13() {
885
 
886
                QueryBuilder builder = session.buildQuery();
887
                Alias<Company> c = builder.aliasTo(Company.class, "c");
888
                c.setReturnMinus(c.pxy().getName());
889
                Alias<Employee> e = builder.aliasTo(Employee.class, "e");
890
                Alias<Post> p = builder.aliasTo(Post.class, "p");
891
 
892
                Sentence nameUpper = new Sentence(new Upper(new ParamField(c, c.pxy().getName())))
893
                .fromProperty(c.pxy().getName());
894
 
895
                Sentence count = new Sentence(new Count(new ParamField(e, e.pxy().getNumber())))
896
                .fromProperty(c.pxy().getEmployeesCount());
897
 
898
                Query query = builder
899
                                .select(c)
900
                                .add(count)
901
                                .add(nameUpper)
902
                                .from(c)
903
                                .leftJoin(p).pkOf(c).in(p)
904
                                .leftJoin(e).pkOf(e).in(p)
905
                                .groupBy();
906
 
907
                List<Company> list = query.executeQuery();
908
 
909
                assertEquals(3, list.size());
910
 
911
                assertEquals("ORACLE", list.get(0).getName());
912
                assertEquals(2, list.get(0).getEmployeesCount());
913
 
914
                assertEquals("GOOGLE", list.get(1).getName());
915
                assertEquals(4, list.get(1).getEmployeesCount());
916
 
917
                assertEquals("IBM", list.get(2).getName());
918
                assertEquals(0, list.get(2).getEmployeesCount());
919
 
920
        }
921
 
922
        /**
923
         * Retrieve all posts
924
         */
925
        @Test
926
        public void query14() {
927
 
928
                QueryBuilder builder = session.buildQuery();
929
                Alias<Post> p = builder.aliasTo(Post.class, "p");
930
 
169 erico 931
                Query query = builder.selectFrom(p);
157 erico 932
 
933
                List<Post> list = query.executeQuery();
934
 
935
                assertEquals(6, list.size());
936
                for (Post post : list) {
937
                        assertNotNull(post.getCompany());
938
                        assertNotNull(post.getEmployee());
939
                        assertNotNull(post.getCompany().getId());
940
                        assertTrue(post.getEmployee().getNumber() > 0);
941
                        assertNull(post.getCompany().getName());
942
                        assertNull(post.getEmployee().getName());
943
                }
944
        }
945
 
946
        /**
163 erico 947
         * Retrieve all posts with company and employee using <code>executeQuery()</code> method
157 erico 948
         */
949
        @Test
950
        public void queryExecuteQuery() {
951
 
952
                QueryBuilder builder = session.buildQuery();
953
                Alias<Company> c = builder.aliasTo(Company.class, "c");
954
                Alias<Employee> e = builder.aliasTo(Employee.class, "e");
955
                Alias<Post> p = builder.aliasTo(Post.class, "p");
956
 
957
                Query query = builder
958
                                .select(p, e, c)
959
                                .from(p)
960
                                .leftJoin(c).pkOf(c).in(p)
961
                                        .inProperty(p.pxy().getCompany())
962
                                .leftJoin(e).pkOf(e).in(p)
963
                                        .inProperty(p.pxy().getEmployee());
964
 
965
                List<Post> list = query.executeQuery();
966
 
967
                assertEquals(6, list.size());
968
                for (Post post : list) {
969
                        assertNotNull(post.getCompany());
970
                        assertNotNull(post.getEmployee());
971
                        assertNotNull(post.getCompany().getId());
972
                        assertTrue(post.getEmployee().getNumber() > 0);
973
                        assertNotNull(post.getCompany().getName());
974
                        assertNotNull(post.getEmployee().getName());
975
                }
976
        }
977
 
978
        /**
979
         * Retrieve all posts using <code>prepare()</code> and <code>populateBean</code> methods.
980
         */
981
        @Test
982
        public void queryPrepare() {
983
 
984
                PreparedStatement ppst = null;
985
 
986
                try {
987
 
988
                        QueryBuilder builder = session.buildQuery();
989
                        Alias<Company> c = builder.aliasTo(Company.class, "c");
990
                        Alias<Employee> e = builder.aliasTo(Employee.class, "e");
991
                        Alias<Post> p = builder.aliasTo(Post.class, "p");
992
 
993
                        Query query = builder
994
                                        .select(p, e, c)
995
                                        .from(p)
996
                                        .leftJoin(c).pkOf(c).in(p)
997
                                        .leftJoin(e).pkOf(e).in(p);
998
 
999
                        List<Post> list = new ArrayList<Post>();
1000
                        ppst = query.prepare();
1001
                        ResultSet rs = ppst.executeQuery();
1002
                        Post obj;
1003
                        while (rs.next()) {
1004
                                obj = new Post();
1005
                                p.populateBean(rs, obj);
1006
 
1007
                                if (obj.getCompany() != null) {
1008
                                        c.populateBean(rs, obj.getCompany());
1009
                                }
1010
 
1011
                                if (obj.getEmployee() != null) {
1012
                                        e.populateBean(rs, obj.getEmployee());
1013
                                }
1014
                                list.add(obj);
1015
                        }
1016
 
1017
                        assertEquals(6, list.size());
1018
 
1019
                        for (Post post : list) {
1020
                                assertNotNull(post.getCompany());
1021
                                assertNotNull(post.getEmployee());
1022
                                assertNotNull(post.getCompany().getId());
1023
                                assertTrue(post.getEmployee().getNumber() > 0);
1024
                                assertNotNull(post.getCompany().getName());
1025
                                assertNotNull(post.getEmployee().getName());
1026
                        }
1027
 
1028
                }catch (Exception e) {
1029
                        throw new BeanException(e);
1030
                }finally {
1031
                        SQLUtils.close(ppst);
1032
                }
1033
        }
1034
 
1035
        /**
1036
         * Retrieve all companies with a count of employees (manual way)
1037
         */
1038
        @Test
1039
        public void query15() {
1040
 
1041
                PreparedStatement ppst = null;
1042
 
1043
                try {
1044
                        QueryBuilder builder = session.buildQuery();
1045
                        Alias<Company> c = builder.aliasTo(Company.class, "c");
1046
                        Alias<Employee> e = builder.aliasTo(Employee.class, "e");
1047
                        Alias<Post> p = builder.aliasTo(Post.class, "p");
1048
 
1049
                        Sentence count = new Sentence(new Count(
1050
                                        new ParamField(e, e.pxy().getNumber())))
1051
                                        .returnType(DBTypes.INTEGER)
1052
                                        .name("count");
1053
 
1054
                        Query query = builder
1055
                                        .select(c)
1056
                                        .add(count)
1057
                                        .from(c)
1058
                                        .leftJoin(p).pkOf(c).in(p)
1059
                                        .leftJoin(e).pkOf(e).in(p)
1060
                                        .groupBy();
1061
 
1062
                        List<Company> list = new ArrayList<Company>();
1063
                        ppst = query.prepare();
1064
                        ResultSet rs = ppst.executeQuery();
1065
                        Company obj;
1066
 
1067
                        while (rs.next()) {
1068
                                obj = new Company();
1069
                                c.populateBean(rs, obj);
1070
 
159 erico 1071
                                Integer employeesCount = query.getValueFromResultSet(rs, "count");
157 erico 1072
                                obj.setEmployeesCount(employeesCount);
1073
 
1074
                                list.add(obj);
1075
                        }
1076
 
1077
                        assertEquals(3, list.size());
1078
 
1079
                        assertEquals("Oracle", list.get(0).getName());
1080
                        assertEquals(2, list.get(0).getEmployeesCount());
1081
 
1082
                        assertEquals("IBM", list.get(1).getName());
1083
                        assertEquals(0, list.get(1).getEmployeesCount());
1084
 
1085
                        assertEquals("Google", list.get(2).getName());
1086
                        assertEquals(4, list.get(2).getEmployeesCount());
1087
 
1088
                }catch (Exception e) {
1089
                        throw new BeanException(e);
1090
                }finally {
1091
                        SQLUtils.close(ppst);
1092
                }
1093
        }
1094
 
158 erico 1095
        /**
1096
         * Returns only the count of posts in database
1097
         */
1098
        @Test
1099
        public void queryCount() {
1100
 
1101
                QueryBuilder builder = session.buildQuery();
1102
                Alias<Post> p = builder.aliasTo(Post.class, "p");
1103
 
1104
                Sentence count = new Sentence(
169 erico 1105
                                new Add()
1106
                                .param(new Count(new ParamField(p, p.pxy().getDescription())))
1107
                                .param(4))
158 erico 1108
                .name("count")
1109
                .returnType(DBTypes.INTEGER);
1110
 
1111
                Query query = builder
1112
                                .select(count)
1113
                                .from(p);
1114
 
159 erico 1115
                Integer postCount = query.executeSentence();
158 erico 1116
 
169 erico 1117
                assertEquals(6 + 4, (int)postCount);
158 erico 1118
        }
1119
 
1120
        /**
1121
         * Throws an exception because there are no sentences in query
1122
         */
1123
        @Test (expected = BeanException.class)
1124
        public void queryCountWithNoSentence() {
1125
 
1126
                QueryBuilder builder = session.buildQuery();
1127
                Alias<Post> p = builder.aliasTo(Post.class, "p");
1128
 
1129
                Query query = builder
168 erico 1130
                                .selectFrom(p);
158 erico 1131
 
1132
                query.executeSentence();
1133
        }
1134
 
163 erico 1135
        /**
1136
         * Retrieve all posts where company or employe name contains 'O' and salary less than 50000,
1137
         * order by post description
1138
         */
1139
        @Test
1140
        public void query16() {
1141
 
1142
                QueryBuilder builder = session.buildQuery();
1143
                Alias<Post> p = builder.aliasTo(Post.class, "p");
1144
                Alias<Employee> e = builder.aliasTo(Employee.class, "e");
1145
                Alias<Company> c = builder.aliasTo(Company.class, "c");
1146
 
1147
                Query query = builder
1148
                                .select(p, e, c)
1149
                                .from(p)
1150
                                .leftJoin(c).pkOf(c).in(p)
1151
                                        .inProperty(p.pxy().getCompany())
1152
                                .leftJoin(e).pkOf(e).in(p)
1153
                                        .inProperty(p.pxy().getEmployee())
1154
                                .where()
1155
                                .openPar()
182 erico 1156
                                        .clause(c.pxy().getName())
163 erico 1157
                                        .condition(new Like("%O%"))
1158
                                        .or()
182 erico 1159
                                        .clause(e.pxy().getName())
163 erico 1160
                                        .condition(new Like("%O%"))
1161
                                .closePar()
1162
                                .and()
182 erico 1163
                                .clause(e.pxy().getSalary())
163 erico 1164
                                .condition(new LessThan(50000))
1165
                                .orderBy()
1166
                                .asc(p, p.pxy().getDescription());
1167
 
1168
                List<Post> list = query.executeQuery();
1169
 
1170
                assertEquals(2, list.size());
1171
 
1172
                assertEquals("Lawrence J. Ellison", list.get(0).getEmployee().getName());
1173
                assertEquals("Maile Ohye", list.get(1).getEmployee().getName());
1174
        }
1175
 
1176
        /**
1177
         * Retrieve posts using parenthesis
1178
         */
1179
        @Test
1180
        public void queryParenthesis() {
1181
 
1182
                QueryBuilder builder = session.buildQuery();
1183
                Alias<Company> c = builder.aliasTo(Company.class, "c");
1184
                Alias<Employee> e = builder.aliasTo(Employee.class, "e");
1185
                Alias<Post> p = builder.aliasTo(Post.class, "p");
1186
 
182 erico 1187
                assertEquals(6, builder
163 erico 1188
                                .select(p, e, c)
1189
                                .from(p)
182 erico 1190
                                .leftJoin(c).on(c.pxy().getId()).eq(p.pxy().getCompany().getId())
1191
                                        .eqProperty(p.pxy().getCompany())
1192
                                .leftJoin(e).on(e.pxy().getNumber()).eq(p.pxy().getEmployee().getNumber())
1193
                                        .eqProperty(p.pxy().getEmployee())
163 erico 1194
                                .where()
1195
                                .openPar()
182 erico 1196
                                .clauseIf(false, c.pxy().getName())
163 erico 1197
                                .condition(new Like("Google"))
1198
                                .or()
182 erico 1199
                                .clauseIf(false, c.pxy().getName())
163 erico 1200
                                .condition(new Like("Oracle"))
1201
                                .closePar()
1202
                                .executeQuery().size());
1203
 
204 erico 1204
                assertEquals(6, builder
1205
                                .select(p, e, c)
1206
                                .from(p)
1207
                                .leftJoin(c).on(c.pxy().getId()).eq(p.pxy().getCompany().getId())
1208
                                .eqProperty(p.pxy().getCompany())
1209
                                .leftJoin(e).on(e.pxy().getNumber()).eq(p.pxy().getEmployee().getNumber())
1210
                                .eqProperty(p.pxy().getEmployee())
1211
                                .where()
1212
                                .openPar()
1213
                                        .clauseIf(false, c.pxy().getName())
1214
                                        .condition(new Like("Google"))
1215
                                        .or()
1216
                                        .clauseIf(true, c.pxy().getName())
1217
                                        .condition(new Like("%"))
1218
                                        .or()
1219
                                        .clauseIf(false, c.pxy().getName())
1220
                                        .condition(new Like("Oracle"))
1221
                                .closePar()
1222
                                .executeQuery().size());
1223
 
182 erico 1224
                assertEquals(4, builder
163 erico 1225
                                .select(p, e, c)
1226
                                .from(p)
204 erico 1227
                                .leftJoin(c).on(c.pxy().getId()).eq(p.pxy().getCompany().getId())
1228
                                .eqProperty(p.pxy().getCompany())
1229
                                .leftJoin(e).on(e.pxy().getNumber()).eq(p.pxy().getEmployee().getNumber())
1230
                                .eqProperty(p.pxy().getEmployee())
1231
                                .where()
1232
                                .openPar()
1233
                                        .clauseIf(true, c.pxy().getName())
1234
                                        .condition(new Like("Google"))
1235
                                        .or()
1236
                                        .clauseIf(false, c.pxy().getName())
1237
                                        .condition(new Like("Oracle"))
1238
                                .closePar()
1239
                                .and()
1240
                                .openPar()
1241
                                        .clauseIf(false, c.pxy().getName())
1242
                                        .condition(new Like("Oracle"))
1243
                                .closePar()
1244
                                .executeQuery().size());
1245
 
1246
                assertEquals(4, builder
1247
                                .select(p, e, c)
1248
                                .from(p)
1249
                                .leftJoin(c).on(c.pxy().getId()).eq(p.pxy().getCompany().getId())
1250
                                .eqProperty(p.pxy().getCompany())
1251
                                .leftJoin(e).on(e.pxy().getNumber()).eq(p.pxy().getEmployee().getNumber())
1252
                                .eqProperty(p.pxy().getEmployee())
1253
                                .where()
1254
                                .openPar()
1255
                                        .clauseIf(true, c.pxy().getName())
1256
                                        .condition(new Like("Google"))
1257
                                        .or()
1258
                                        .clauseIf(false, c.pxy().getName())
1259
                                        .condition(new Like("Oracle"))
1260
                                .closePar()
1261
                                .and()
1262
                                .openPar()
1263
                                        .clauseIf(false, c.pxy().getName())
1264
                                        .condition(new Like("Oracle"))
1265
                                        .and()
1266
                                        .clauseIf(true, c.pxy().getName())
1267
                                        .condition(new Like("Google"))
1268
                                .closePar()
1269
                                .executeQuery().size());
1270
 
1271
                assertEquals(4, builder
1272
                                .select(p, e, c)
1273
                                .from(p)
1274
                                .leftJoin(c).on(c.pxy().getId()).eq(p.pxy().getCompany().getId())
1275
                                .eqProperty(p.pxy().getCompany())
1276
                                .leftJoin(e).on(e.pxy().getNumber()).eq(p.pxy().getEmployee().getNumber())
1277
                                .eqProperty(p.pxy().getEmployee())
1278
                                .where()
1279
                                .openPar()
1280
                                        .clauseIf(true, c.pxy().getName())
1281
                                        .condition(new Like("Google"))
1282
                                        .or()
1283
                                        .clauseIf(false, c.pxy().getName())
1284
                                        .condition(new Like("Oracle"))
1285
                                .closePar()
1286
                                .and()
1287
                                .openPar()
1288
                                        .clauseIf(false, c.pxy().getName())
1289
                                        .condition(new Like("Oracle"))
1290
                                        .and()
1291
                                        .clauseIf(false, c.pxy().getName())
1292
                                        .condition(new Like("Google"))
1293
                                .closePar()
1294
                                .executeQuery().size());
1295
 
205 erico 1296
                assertEquals(2, builder
1297
                                .select(p, e, c)
1298
                                .from(p)
1299
                                .leftJoin(c).on(c.pxy().getId()).eq(p.pxy().getCompany().getId())
1300
                                .eqProperty(p.pxy().getCompany())
1301
                                .leftJoin(e).on(e.pxy().getNumber()).eq(p.pxy().getEmployee().getNumber())
1302
                                .eqProperty(p.pxy().getEmployee())
1303
                                .where()
1304
                                .openPar()
1305
                                        .clauseIf(false, c.pxy().getName())
1306
                                        .condition(new Like("Google"))
1307
                                        .or()
1308
                                        .clauseIf(false, c.pxy().getName())
1309
                                        .condition(new Like("Oracle"))
1310
                                .closePar()
1311
                                .or()
1312
                                .openPar()
1313
                                        .clauseIf(true, c.pxy().getName())
1314
                                        .condition(new Like("Oracle"))
1315
                                        .and()
1316
                                        .clauseIf(false, c.pxy().getName())
1317
                                        .condition(new Like("Google"))
1318
                                .closePar()
1319
                                .executeQuery().size());
1320
 
206 erico 1321
                assertEquals(6, builder
1322
                                .select(p, e, c)
1323
                                .from(p)
1324
                                .leftJoin(c).on(c.pxy().getId()).eq(p.pxy().getCompany().getId())
1325
                                .eqProperty(p.pxy().getCompany())
1326
                                .leftJoin(e).on(e.pxy().getNumber()).eq(p.pxy().getEmployee().getNumber())
1327
                                .eqProperty(p.pxy().getEmployee())
1328
                                .where()
1329
                                .openPar()
1330
                                        .clauseIf(false, c.pxy().getName())
1331
                                        .condition(new Like("Google"))
1332
                                        .or()
1333
                                        .clauseIf(false, c.pxy().getName())
1334
                                        .condition(new Like("Oracle"))
1335
                                .closePar()
1336
                                .or()
1337
                                .openPar()
1338
                                        .clauseIf(false, c.pxy().getName())
1339
                                        .condition(new Like("Oracle"))
1340
                                        .and()
1341
                                        .clauseIf(false, c.pxy().getName())
1342
                                        .condition(new Like("Google"))
1343
                                .closePar()
1344
                                .executeQuery().size());
1345
 
204 erico 1346
                assertEquals(0, builder
1347
                                .select(p, e, c)
1348
                                .from(p)
1349
                                .leftJoin(c).on(c.pxy().getId()).eq(p.pxy().getCompany().getId())
1350
                                .eqProperty(p.pxy().getCompany())
1351
                                .leftJoin(e).on(e.pxy().getNumber()).eq(p.pxy().getEmployee().getNumber())
1352
                                .eqProperty(p.pxy().getEmployee())
1353
                                .where()
1354
                                .openPar()
1355
                                        .clauseIf(true, c.pxy().getName())
1356
                                        .condition(new Like("Google"))
1357
                                        .or()
1358
                                        .clauseIf(false, c.pxy().getName())
1359
                                        .condition(new Like("Oracle"))
1360
                                .closePar()
1361
                                .and()
1362
                                .clause(c.pxy().getName())
1363
                                .condition(new Like("Oracle"))
1364
                                .executeQuery().size());
1365
 
1366
                assertEquals(4, builder
1367
                                .select(p, e, c)
1368
                                .from(p)
163 erico 1369
                                .leftJoin(c).pkOf(c).in(p)
1370
                                        .inProperty(p.pxy().getCompany())
1371
                                .leftJoin(e).pkOf(e).in(p)
1372
                                        .inProperty(p.pxy().getEmployee())
1373
                                .where()
1374
                                .openPar()
182 erico 1375
                                .clauseIf(true, c.pxy().getName())
163 erico 1376
                                .condition(new Like("Google"))
1377
                                .or()
182 erico 1378
                                .clauseIf(false, c.pxy().getName())
163 erico 1379
                                .condition(new Like("Oracle"))
1380
                                .closePar()
1381
                                .executeQuery().size());
1382
 
182 erico 1383
                assertEquals(2, builder
163 erico 1384
                                .select(p, e, c)
1385
                                .from(p)
1386
                                .leftJoin(c).pkOf(c).in(p)
1387
                                        .inProperty(p.pxy().getCompany())
1388
                                .leftJoin(e).pkOf(e).in(p)
1389
                                        .inProperty(p.pxy().getEmployee())
1390
                                .where()
1391
                                .openPar()
182 erico 1392
                                .clauseIf(false, c.pxy().getName())
163 erico 1393
                                .condition(new Like("Google"))
1394
                                .or()
182 erico 1395
                                .clauseIf(true, c.pxy().getName())
163 erico 1396
                                .condition(new Like("Oracle"))
1397
                                .closePar()
1398
                                .executeQuery().size());
1399
 
182 erico 1400
                assertEquals(0, builder
163 erico 1401
                                .select(p, e, c)
1402
                                .from(p)
1403
                                .leftJoin(c).pkOf(c).in(p)
1404
                                        .inProperty(p.pxy().getCompany())
1405
                                .leftJoin(e).pkOf(e).in(p)
1406
                                        .inProperty(p.pxy().getEmployee())
1407
                                .where()
1408
                                .openPar()
182 erico 1409
                                .clauseIf(true, c.pxy().getName())
163 erico 1410
                                .condition(new Like("Google"))
1411
                                .and()
182 erico 1412
                                .clauseIf(true, c.pxy().getName())
163 erico 1413
                                .condition(new Like("Oracle"))
1414
                                .closePar()
1415
                                .executeQuery().size());
1416
 
182 erico 1417
                assertEquals(6, builder
207 erico 1418
                                .select(p, e, c)
1419
                                .from(p)
1420
                                .leftJoin(c).pkOf(c).in(p)
1421
                                        .inProperty(p.pxy().getCompany())
1422
                                .leftJoin(e).pkOf(e).in(p)
1423
                                        .inProperty(p.pxy().getEmployee())
1424
                                .where()
1425
                                .clauseIf(true, c.pxy().getName())
1426
                                .condition(new Like("Google"))
1427
                                .and()
1428
                                .openPar()
1429
                                        .clauseIf(false, c.pxy().getName())
1430
                                        .condition(new Like("Oracle"))
1431
                                .closePar()
1432
                                .or()
1433
                                .clauseIf(true, c.pxy().getName())
1434
                                .condition(new Like("Oracle"))
1435
                                .executeQuery().size());
1436
 
1437
                assertEquals(0, builder
1438
                                .select(p, e, c)
1439
                                .from(p)
1440
                                .leftJoin(c).pkOf(c).in(p)
1441
                                        .inProperty(p.pxy().getCompany())
1442
                                .leftJoin(e).pkOf(e).in(p)
1443
                                        .inProperty(p.pxy().getEmployee())
1444
                                .where()
1445
                                .clauseIf(true, c.pxy().getName())
1446
                                .condition(new Like("Google"))
1447
                                .and()
1448
                                .openPar()
1449
                                        .openPar()
1450
                                                .clauseIf(false, c.pxy().getName())
1451
                                                .condition(new Like("Oracle"))
1452
                                        .closePar()
1453
                                        .or()
1454
                                        .clauseIf(true, c.pxy().getName())
1455
                                        .condition(new Like("Oracle"))
1456
                                .closePar()
1457
                                .executeQuery().size());
1458
 
1459
                assertEquals(6, builder
182 erico 1460
                                .selectDistinct(p, e, c)
163 erico 1461
                                .from(p)
1462
                                .leftJoin(c).pkOf(c).in(p)
1463
                                        .inProperty(p.pxy().getCompany())
1464
                                .leftJoin(e).pkOf(e).in(p)
1465
                                        .inProperty(p.pxy().getEmployee())
1466
                                .where()
1467
                                .openPar()
182 erico 1468
                                .clauseIf(false, c.pxy().getName())
163 erico 1469
                                .condition(new Like("Google"))
1470
                                .or()
182 erico 1471
                                .clauseIf(false, c.pxy().getName())
163 erico 1472
                                .condition(new Like("Oracle"))
1473
                                .closePar()
1474
                                .and()
182 erico 1475
                                .clauseIf(false, e.pxy().getName())
163 erico 1476
                                .condition(new Like("%"))
1477
                                .executeQuery().size());
1478
 
182 erico 1479
                assertEquals(6, builder
1480
                                .selectDistinct(p, e, c)
163 erico 1481
                                .from(p)
1482
                                .leftJoin(c).pkOf(c).in(p)
1483
                                .inProperty(p.pxy().getCompany())
1484
                                .leftJoin(e).pkOf(e).in(p)
1485
                                .inProperty(p.pxy().getEmployee())
1486
                                .where()
1487
                                .openPar()
182 erico 1488
                                .clauseIf(true, c.pxy().getName())
163 erico 1489
                                .condition(new Like("Google"))
1490
                                .or()
182 erico 1491
                                .clauseIf(true, c.pxy().getName())
163 erico 1492
                                .condition(new Like("Oracle"))
1493
                                .closePar()
1494
                                .and()
182 erico 1495
                                .clauseIf(true, e.pxy().getName())
163 erico 1496
                                .condition(new Like("%"))
1497
                                .executeQuery().size());
1498
 
182 erico 1499
                assertEquals(4, builder
163 erico 1500
                                .select(p, e, c)
1501
                                .from(p)
1502
                                .leftJoin(c).pkOf(c).in(p)
1503
                                .inProperty(p.pxy().getCompany())
1504
                                .leftJoin(e).pkOf(e).in(p)
1505
                                .inProperty(p.pxy().getEmployee())
1506
                                .where()
1507
                                .openPar()
1508
                                        .openPar()
182 erico 1509
                                                .clauseIf(true, c.pxy().getName())
163 erico 1510
                                                .condition(new Like("Google"))
1511
                                        .closePar()
1512
                                        .and()
1513
                                        .openPar()
182 erico 1514
                                                .clauseIf(false, c.pxy().getName())
163 erico 1515
                                                .condition(new Like("Oracle"))
1516
                                                .or()
1517
                                                .openPar()
182 erico 1518
                                                        .clauseIf(true, c.pxy().getId())
163 erico 1519
                                                        .condition(new NotEquals(null))
1520
                                                .closePar()
1521
                                        .closePar()
1522
                                .closePar()
1523
                                .and()
182 erico 1524
                                .clauseIf(false, e.pxy().getName())
163 erico 1525
                                .condition(new Like("%"))
1526
                                .limit(6)
1527
                                .executeQuery().size());
1528
 
1529
        }
1530
 
182 erico 1531
        @Test
1532
        public void limitNumberTest() {
1533
 
1534
                QueryBuilder builder = session.buildQuery();
1535
                Alias<Company> c = builder.aliasTo(Company.class, "c");
1536
                Alias<Employee> e = builder.aliasTo(Employee.class, "e");
1537
                Alias<Post> p = builder.aliasTo(Post.class, "p");
1538
 
1539
                assertEquals(6, builder
1540
                                .selectDistinct(p, e, c)
1541
                                .from(p)
1542
                                .leftJoin(c).pkOf(c).in(p)
1543
                                        .inProperty(p.pxy().getCompany())
1544
                                .leftJoin(e).pkOf(e).in(p)
1545
                                        .inProperty(p.pxy().getEmployee())
1546
                                .where()
1547
                                .openPar()
1548
                                .clauseIf(false, c.pxy().getName())
1549
                                .condition(new Like("Google"))
1550
                                .or()
1551
                                .clauseIf(false, c.pxy().getName())
1552
                                .condition(new Like("Oracle"))
1553
                                .closePar()
1554
                                .limit(0)
1555
                                .executeQuery().size());
1556
 
1557
                assertEquals(3, builder
1558
                                .select(p, e, c)
1559
                                .from(p)
1560
                                .leftJoin(c).pkOf(c).in(p)
1561
                                .inProperty(p.pxy().getCompany())
1562
                                .leftJoin(e).pkOf(e).in(p)
1563
                                .inProperty(p.pxy().getEmployee())
1564
                                .where()
1565
                                .openPar()
1566
                                .clauseIf(false, c.pxy().getName())
1567
                                .condition(new Like("Google"))
1568
                                .or()
1569
                                .clauseIf(false, c.pxy().getName())
1570
                                .condition(new Like("Oracle"))
1571
                                .closePar()
1572
                                .limit(3)
1573
                                .executeQuery().size());
1574
        }
1575
 
1576
        @Test
1577
        public void paramHandlerTest() {
1578
 
1579
                QueryBuilder builder = session.buildQuery();
1580
                Alias<Company> c = builder.aliasTo(Company.class, "c");
1581
                Alias<Post> p = builder.aliasTo(Post.class, "p");
1582
 
1583
                ParamHandler paramHandler = new DefaultParamHandler();
1584
                Param found;
1585
 
1586
                found = paramHandler.findBetter(builder, 3);
1587
                Assert.assertTrue(found instanceof ParamValue);
1588
 
1589
                found = paramHandler.findBetter(builder, null);
1590
                Assert.assertTrue(found instanceof ParamValue);
1591
 
1592
                found = paramHandler.findBetter(builder, builder.subQuery().selectFrom(c));
1593
                Assert.assertTrue(found instanceof ParamSubQuery);
1594
 
1595
                builder.selectFrom(c).where().clause(c.pxy().getName()).condition(new NotEquals(null)).executeQuery();
1596
 
1597
                found = paramHandler.findBetter(builder, c.pxy().getName());
1598
                Assert.assertTrue(found instanceof ParamField);
1599
 
1600
                builder = builder.subQuery();
1601
 
1602
                builder.select(c, p)
1603
                        .from(c)
1604
                        .join(p).pkOf(c).in(p)
1605
                        .where().clause(p.pxy().getDescription())
1606
                        .condition(new NotEquals("aaaaaaaa"))
1607
                        .and()
1608
                        .clause(c.pxy().getName())
1609
                        .condition(new NotEquals("aaaaaaaaa"))
1610
                        .executeQuery();
1611
 
1612
                found = paramHandler.findBetter(builder, p.pxy().getDescription());
1613
                Assert.assertTrue(found instanceof ParamField);
1614
 
1615
                found = paramHandler.findBetter(builder, c.pxy().getId());
1616
                Assert.assertTrue(found instanceof ParamField);
1617
 
1618
                found = paramHandler.findBetter(builder, new Avg(null));
1619
                Assert.assertTrue(found instanceof ParamFunction);     
1620
        }
1621
 
149 erico 1622
}