MentaBean

Rev

Rev 182 | Rev 205 | Go to most recent revision | Only display areas with differences | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

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