|
1
27
28 package org.objectweb.speedo.runtime.query;
29
30 import java.util.ArrayList  ;
31 import java.util.Arrays ;
32 import java.util.Collection ;
33 import java.util.Collections ;
34 import java.util.HashMap ;
35 import java.util.HashSet ;
36 import java.util.Iterator ;
37 import java.util.List ;
38 import java.util.Map ;
39 import java.util.NoSuchElementException ;
40
41 import javax.jdo.Extent;
42 import javax.jdo.JDOException;
43 import javax.jdo.PersistenceManager;
44 import javax.jdo.Query;
45
46 import junit.framework.Assert;
47
48 import org.objectweb.speedo.SpeedoTestHelper;
49 import org.objectweb.speedo.api.ExceptionHelper;
50 import org.objectweb.speedo.pobjects.basic.BasicA;
51 import org.objectweb.speedo.pobjects.basic.Product;
52 import org.objectweb.speedo.pobjects.collection.AMMB;
53 import org.objectweb.speedo.pobjects.collection.BMMB;
54 import org.objectweb.speedo.pobjects.collection.Group;
55 import org.objectweb.speedo.pobjects.collection.Ref2Ref2AMMB;
56 import org.objectweb.speedo.pobjects.collection.User;
57 import org.objectweb.speedo.pobjects.inheritance.query.GroupUser;
58 import org.objectweb.speedo.pobjects.inheritance.query.MailingList;
59 import org.objectweb.speedo.pobjects.inheritance.query.NewsGroup;
60 import org.objectweb.speedo.pobjects.inheritance.userCache.Litem;
61 import org.objectweb.speedo.pobjects.ref.Department;
62 import org.objectweb.speedo.pobjects.ref.Employee;
63 import org.objectweb.speedo.pobjects.ref.GeoRef;
64 import org.objectweb.speedo.pobjects.userid.AutoIncFieldId;
65 import org.objectweb.speedo.pobjects.userid.Ref2AutoIncFieldId;
66 import org.objectweb.util.monolog.api.BasicLevel;
67
68
73 public class TestQueries extends SpeedoTestHelper {
74
75 public TestQueries(String name) {
76 super(name);
77 }
78
79 protected String getLoggerName() {
80 return LOG_NAME + ".rt.query.TestQueries";
81 }
82
83 public void test0Parameter() {
84 logger.log(BasicLevel.DEBUG, "test0Parameter");
85 PersistenceManager pm = pmf.getPersistenceManager();
86 try {
87 Class empClass = Employee.class;
88 Query query = pm.newQuery(empClass);
89 Collection col = (Collection ) query.execute();
90 Iterator it = col.iterator();
91 while(it.hasNext()) {
92 Employee e = (Employee) it.next();
93 Assert.assertNotNull("null element in the query result", e);
94 Assert.assertNotNull("null name of a element in the query result", e.getName());
95 }
96 query.close(col);
97 } catch (JDOException e) {
98 Exception ie = ExceptionHelper.getNested(e);
99 logger.log(BasicLevel.ERROR, "", ie);
100 fail(ie.getMessage());
101 } finally {
102 pm.close();
103 }
104 }
105
106 public void test10rder() {
107 logger.log(BasicLevel.DEBUG, "test10rder");
108 PersistenceManager pm = pmf.getPersistenceManager();
109 try {
110 Class empClass = Employee.class;
111 Query query = pm.newQuery(empClass);
112 query.setOrdering("name ascending");
113 Collection col = (Collection ) query.execute();
114 Iterator it = col.iterator();
115 int i=0;
116 while(it.hasNext()) {
117 assertTrue("More result than expected ", i<POBuilder.nameOrder.length);
118 Employee e = (Employee) it.next();
119 Assert.assertNotNull("null element in the query result", e);
120 try {
121 Assert.assertEquals("Bad order (" + i + ")",
122 POBuilder.names[POBuilder.nameOrder[i]],e.getName());
123 } catch (Throwable e1) {
124 e1.printStackTrace();
125 }
126 i++;
127 }
128 assertEquals("Not enough result", POBuilder.nameOrder.length, i);
129 query.close(col);
130 } catch (JDOException e) {
131 Exception ie = ExceptionHelper.getNested(e);
132 logger.log(BasicLevel.ERROR, "", ie);
133 fail(ie.getMessage());
134 } finally {
135 pm.close();
136 }
137 }
138
139 public void test20rder() {
140 logger.log(BasicLevel.DEBUG, "test20rder");
141 PersistenceManager pm = pmf.getPersistenceManager();
142 Class empClass = Employee.class;
143 Query query = pm.newQuery(empClass);
144 Collection col = null;
145 try {
146 query.setOrdering("salary descending, name ascending");
147 col = (Collection ) query.execute();
148 Iterator it = col.iterator();
149 int i=0;
150 while(it.hasNext()) {
151 assertTrue("More result than expected ", i<POBuilder.salariesOrder.length);
152 Assert.assertTrue("No enough values in the result", it.hasNext());
153 Employee e = (Employee) it.next();
154 Assert.assertNotNull("null element in the query result", e);
155 try {
156 Assert.assertEquals("Bad order (" + i + ")",
157 POBuilder.names[POBuilder.salariesOrder[i]],e.getName());
158 } catch (Throwable e1) {
159 e1.printStackTrace();
160 }
161 i++;
162 }
163 assertEquals("Not enough result", POBuilder.salariesOrder.length, i);
164 } catch (JDOException e) {
165 Exception ie = ExceptionHelper.getNested(e);
166 logger.log(BasicLevel.ERROR, "", ie);
167 fail(ie.getMessage());
168 } finally {
169 try {
170 query.closeAll();
171 } finally {
172 pm.close();
173 }
174 }
175 }
176
177 public void test1Parameter() {
178 logger.log(BasicLevel.DEBUG, "test1Parameter");
179 PersistenceManager pm = pmf.getPersistenceManager();
180 try {
181 Class empClass = Employee.class;
182 Query query = pm.newQuery(empClass);
183 query.declareParameters("String aName");
184 query.setFilter("(name == aName)");
185 Collection col = (Collection ) query.execute(POBuilder.names[1]);
186 Iterator iter = col.iterator();
187 Assert.assertTrue("The query result is empty", iter.hasNext());
188 Employee e = (Employee) iter.next();
189 Assert.assertNotNull("Null collection element", e);
190 Assert.assertEquals("Bad employee name", POBuilder.names[1], e.getName());
191 Assert.assertTrue("More than one element in the query result", !iter.hasNext());
192 Assert.assertEquals("Bad query result size", 1, col.size());
193 query.close(col);
194 } catch (JDOException e) {
195 Exception ie = ExceptionHelper.getNested(e);
196 logger.log(BasicLevel.ERROR, "", ie);
197 fail(ie.getMessage());
198 } finally {
199 pm.close();
200 }
201 }
202
203 public void test1ParameterBis() {
204 logger.log(BasicLevel.DEBUG, "test1ParameterBis");
205 PersistenceManager pm = pmf.getPersistenceManager();
206 try {
207 Class empClass = Employee.class;
208 Query query = pm.newQuery(empClass);
209 query.declareParameters("float sal");
210 query.setFilter("(salary > sal)");
211 Collection col = (Collection ) query.execute(new Float (POBuilder.salaries[2]));
212 Iterator iter = col.iterator();
213 HashSet s = new HashSet ();
214 while(iter.hasNext()) {
215 Employee e = (Employee) iter.next();
216 s.add(e.getName());
217 }
218 query.close(col);
219 assertSameCollection("Bad query result",
220 Arrays.asList(new String []{POBuilder.names[0],POBuilder.names[1],POBuilder.names[3]}),
221 s);
222 } catch (JDOException e) {
223 Exception ie = ExceptionHelper.getNested(e);
224 logger.log(BasicLevel.ERROR, "", ie);
225 fail(ie.getMessage());
226 } finally {
227 pm.close();
228 }
229 }
230
231 public void testFieldParameter() {
232 logger.log(BasicLevel.DEBUG, "testFieldParameter");
233 PersistenceManager pm = pmf.getPersistenceManager();
234 try {
235 Class empClass = Employee.class;
236 Query query = pm.newQuery(empClass);
237
238 String filterFieldParameter = "((salary == mysalary) && (name == myname))";
239 String param = "String myname, Float mysalary";
240
241 query.declareParameters(param);
242 query.setFilter(filterFieldParameter);
243
244 Collection col = (Collection )
245 query.execute(POBuilder.names[1], new Float (3000.0));
246 Iterator iter = col.iterator();
247 Assert.assertTrue("The query result is empty", iter.hasNext());
248 Employee e = (Employee) iter.next();
249 Assert.assertNotNull("Null collection element", e);
250 Assert.assertEquals("Bad employee name", POBuilder.names[1], e.getName());
251 Assert.assertEquals("Bad employee salary", new Float (3000.0), new Float (e.getSalary()));
252 Assert.assertTrue("More than one element in the query result", !iter.hasNext());
253 Assert.assertEquals("Bad query result size", 1, col.size());
254 query.close(col);
255 } catch (JDOException e) {
256 Exception ie = ExceptionHelper.getNested(e);
257 logger.log(BasicLevel.ERROR, "", ie);
258 fail(ie.getMessage());
259 } finally {
260 pm.close();
261 }
262 }
263
264 public void testMatches() {
265 logger.log(BasicLevel.DEBUG, "testMatches");
266 PersistenceManager pm = pmf.getPersistenceManager();
267 try {
268 Query query = pm.newQuery(Employee.class);
269 String filterFieldParameter = "((name.toUpperCase().matches(\"%IE\")) && (name.length()>2))";
270 query.setFilter(filterFieldParameter);
271 ArrayList col = new ArrayList ((Collection ) query.execute());
272 query.closeAll();
273 for(int i=0; i<col.size(); i++) {
274 col.add(i, ((Employee) col.remove(i)).getName());
275 }
276 assertSameCollection("Bad result of the testMatches method",
277 Arrays.asList(new String []{ POBuilder.names[2], POBuilder.names[3]}),
278 col);
279 } catch (JDOException e) {
280 Exception ie = ExceptionHelper.getNested(e);
281 logger.log(BasicLevel.ERROR, "", ie);
282 fail(ie.getMessage());
283 } finally {
284 pm.close();
285 }
286 }
287
288 public void testStartsWith() {
289 logger.log(BasicLevel.DEBUG, "testStartsWith");
290 PersistenceManager pm = pmf.getPersistenceManager();
291 try {
292 Query query = pm.newQuery(Employee.class);
293 String filterFieldParameter = "(name.toUpperCase().startsWith(\"JOH\"))";
294 query.setFilter(filterFieldParameter);
295 ArrayList col = new ArrayList ((Collection ) query.execute());
296 query.closeAll();
297 for(int i=0; i<col.size(); i++) {
298 col.add(i, ((Employee) col.remove(i)).getName());
299 }
300 assertSameCollection("Bad result of the testStartsWith method",
301 Arrays.asList(new String []{ POBuilder.names[0]}),
302 col);
303 } catch (JDOException e) {
304 Exception ie = ExceptionHelper.getNested(e);
305 logger.log(BasicLevel.ERROR, "", ie);
306 fail(ie.getMessage());
307 } finally {
308 pm.close();
309 }
310 }
311
312 public void _testSubString() {
313 logger.log(BasicLevel.DEBUG, "testMatches");
315 PersistenceManager pm = pmf.getPersistenceManager();
316 try {
317 Query query = pm.newQuery(Employee.class);
318 String filterFieldParameter = "(name.substring(0 2).matches(\"%ie\"))";
319 query.setFilter(filterFieldParameter);
320 ArrayList col = new ArrayList ((Collection ) query.execute());
321 query.closeAll();
322 for(int i=0; i<col.size(); i++) {
323 col.add(i, ((Employee) col.remove(i)).getName());
324 }
325 assertSameCollection("Bad result of the testMatches method",
326 Arrays.asList(new String []{ POBuilder.names[2], POBuilder.names[3]}),
327 col);
328 } catch (JDOException e) {
329 Exception ie = ExceptionHelper.getNested(e);
330 logger.log(BasicLevel.ERROR, "", ie);
331 fail(ie.getMessage());
332 } finally {
333 pm.close();
334 }
335 }
336
337 public void testUpper() {
338 logger.log(BasicLevel.DEBUG, "testMatches");
339 PersistenceManager pm = pmf.getPersistenceManager();
340 try {
341 Query query = pm.newQuery(Employee.class);
342 String filterFieldParameter = "(name.toUpperCase().matches(\"%IE\"))";
343 query.setFilter(filterFieldParameter);
344 ArrayList col = new ArrayList ((Collection ) query.execute());
345 query.closeAll();
346 for(int i=0; i<col.size(); i++) {
347 col.add(i, ((Employee) col.remove(i)).getName());
348 }
349 assertSameCollection("Bad result of the testMatches method",
350 Arrays.asList(new String []{ POBuilder.names[2], POBuilder.names[3]}),
351 col);
352 } catch (JDOException e) {
353 Exception ie = ExceptionHelper.getNested(e);
354 logger.log(BasicLevel.ERROR, "", ie);
355 fail(ie.getMessage());
356 } finally {
357 pm.close();
358 }
359 }
360
361 public void test2Parameters() {
362 logger.log(BasicLevel.DEBUG, "test2Parameters");
363 PersistenceManager pm = pmf.getPersistenceManager();
364 try {
365 Class empClass = Employee.class;
366 Query query = pm.newQuery(empClass);
367 query.declareParameters("String aName, String anotherName");
368 query.setFilter("((name == aName) || (name == anotherName))");
369 Collection col = (Collection )
370 query.execute(POBuilder.names[1], POBuilder.names[2]);
371 Iterator iter = col.iterator();
372 Assert.assertTrue("The query result is empty", iter.hasNext());
373 Employee e1 = (Employee) iter.next();
374 Assert.assertNotNull("Null collection element 1", e1);
375 Assert.assertTrue("Only one element in the query result", iter.hasNext());
376 Employee e2 = (Employee) iter.next();
377 Assert.assertNotNull("Null collection element 2", e2);
378 Assert.assertTrue("More than one element in the query result", !iter.hasNext());
379 Assert.assertEquals("Bad query result size", 2, col.size());
380 query.close(col);
381
382 if (POBuilder.names[1].equals(e1.getName())) {
383 Assert.assertEquals("Bad employee name", POBuilder.names[2], e2.getName());
384 } else if (POBuilder.names[1].equals(e2.getName())) {
385 Assert.assertEquals("Bad employee name", POBuilder.names[2], e1.getName());
386 } else {
387 fail("Bad employee name");
388 }
389 } catch (JDOException e) {
390 Exception ie = ExceptionHelper.getNested(e);
391 logger.log(BasicLevel.ERROR, "", ie);
392 fail(ie.getMessage());
393 } finally {
394 pm.close();
395 }
396 }
397
398 public void test3Parameters() {
399 logger.log(BasicLevel.DEBUG, "test3Parameters");
400 PersistenceManager pm = pmf.getPersistenceManager();
401 try {
402 Class empClass = Employee.class;
403 Query query = pm.newQuery(empClass);
404 String filter = "(name == aName) | (name == anotherName) | (name == thirdName)";
405 String param = "String aName, String anotherName, String thirdName";
406 query.declareParameters(param);
407 query.setFilter(filter);
408 Collection col = (Collection ) query.execute(POBuilder.names[1],
409 POBuilder.names[2],
410 POBuilder.names[3]);
411 Iterator iter = col.iterator();
412 Collection expectedNames = new ArrayList (3);
413 Collection foundNames = new ArrayList (3);
414 expectedNames.add(POBuilder.names[1]);
415 expectedNames.add(POBuilder.names[2]);
416 expectedNames.add(POBuilder.names[3]);
417 Assert.assertTrue("The query result is empty", iter.hasNext());
418 Employee e = (Employee) iter.next();
419 Assert.assertNotNull("Null collection element 1", e);
420 foundNames.add(e.getName());
421 Assert.assertTrue("Only one element in the query result", iter.hasNext());
422 e = (Employee) iter.next();
423 Assert.assertNotNull("Null collection element 2", e);
424 foundNames.add(e.getName());
425 e = (Employee) iter.next();
426 Assert.assertNotNull("Null collection element 3", e);
427 foundNames.add(e.getName());
428 Assert.assertTrue("More than one element in the query result", !iter.hasNext());
429 Assert.assertEquals("Bad query result size", expectedNames.size(), col.size());
430 query.close(col);
431
432 Assert.assertTrue("Bad Employee names, expected:"
433 + expectedNames + " / found: " + foundNames,
434 expectedNames.containsAll(foundNames)
435 && foundNames.containsAll(expectedNames));
436 } catch (JDOException e) {
437 Exception ie = ExceptionHelper.getNested(e);
438 logger.log(BasicLevel.ERROR, "", ie);
439 fail(ie.getMessage());
440 } finally {
441 pm.close();
442 }
443 }
444
445 public void testMapParameters() {
446 logger.log(BasicLevel.DEBUG, "testMapParameters");
447 PersistenceManager pm = pmf.getPersistenceManager();
448 try {
449 Class empClass = Employee.class;
450 Query query = pm.newQuery(empClass);
451
452 String filter = "((name == aName) || (name == anotherName))";
453 String param = "String aName, String anotherName";
454
455 query.declareParameters(param);
456 query.setFilter(filter);
457
458 Map map = new HashMap ();
459 map.put("aName", POBuilder.names[1]);
460 map.put("anotherName", POBuilder.names[2]);
461
462 Collection col = (Collection ) query.executeWithMap(map);
463 Iterator iter = col.iterator();
464 Collection foundNames = new ArrayList (2);
465 Collection expectedNames = map.values();
466
467 Assert.assertTrue("The query result is empty", iter.hasNext());
468 Employee e = (Employee) iter.next();
469 Assert.assertNotNull("Null collection element 1", e);
470 foundNames.add(e.getName());
471 Assert.assertTrue("Only one element in the query result", iter.hasNext());
472 e = (Employee) iter.next();
473 Assert.assertNotNull("Null collection element 2", e);
474 foundNames.add(e.getName());
475 Assert.assertTrue("More than one element in the query result", !iter.hasNext());
476 Assert.assertEquals("Bad query result size", expectedNames.size(), col.size());
477 query.close(col);
478
479 Assert.assertTrue("Bad Employee names, expected:"
480 + expectedNames + " / found: " + foundNames,
481 expectedNames.containsAll(foundNames)
482 && foundNames.containsAll(expectedNames));
483 } catch (JDOException e) {
484 Exception ie = ExceptionHelper.getNested(e);
485 logger.log(BasicLevel.ERROR, "", ie);
486 fail(ie.getMessage());
487 } finally {
488 pm.close();
489 }
490 }
491
492 public void testArrayParameters() {
493 logger.log(BasicLevel.DEBUG, "testArrayParameters");
494 PersistenceManager pm = pmf.getPersistenceManager();
495 try {
496 Class empClass = Employee.class;
497 Query query = pm.newQuery(empClass);
498
499 String filter = "((name == aName) | (name == anotherName))";
500 String param = "String aName, String anotherName";
501
502 query.declareParameters(param);
503 query.setFilter(filter);
504
505 Collection expectedNames = new ArrayList (2);
506 expectedNames.add(POBuilder.names[1]);
507 expectedNames.add(POBuilder.names[2]);
508 Collection col = (Collection ) query.executeWithArray(expectedNames.toArray());
509 Iterator iter = col.iterator();
510
511 Collection foundNames = new ArrayList (2);
512 Assert.assertTrue("The query result is empty", iter.hasNext());
513 Employee e = (Employee) iter.next();
514 Assert.assertNotNull("Null collection element 1", e);
515 foundNames.add(e.getName());
516 Assert.assertTrue("Only one element in the query result", iter.hasNext());
517 e = (Employee) iter.next();
518 Assert.assertNotNull("Null collection element 2", e);
519 foundNames.add(e.getName());
520 Assert.assertTrue("More than one element in the query result", !iter.hasNext());
521 Assert.assertEquals("Bad query result size", expectedNames.size(), col.size());
522 query.close(col);
523
524 Assert.assertTrue("Bad Employee names, expected:"
525 + expectedNames + " / found: " + foundNames,
526 expectedNames.containsAll(foundNames)
527 && foundNames.containsAll(expectedNames));
528 } catch (JDOException e) {
529 Exception ie = ExceptionHelper.getNested(e);
530 logger.log(BasicLevel.ERROR, "", ie);
531 fail(ie.getMessage());
532 } finally {
533 pm.close();
534 }
535 }
536
537 public void testFieldRef() {
538 logger.log(BasicLevel.DEBUG, "testFieldRef");
539 PersistenceManager pm = pmf.getPersistenceManager();
540 try {
541 Class empClass = Employee.class;
542 Query query = pm.newQuery(empClass);
543 String filterFieldRef = "((dept.name == depName) && (name == \""
544 + POBuilder.names[0] + "\"))";
545 String param = "String depName";
546
547 query.declareParameters(param);
548 query.setFilter(filterFieldRef);
549
550 Collection col = (Collection ) query.execute("RD");
551 Iterator iter = col.iterator();
552 Assert.assertTrue("The query result is empty", iter.hasNext());
553 Employee e = (Employee) iter.next();
554 Assert.assertNotNull("Null collection element", e);
555 Assert.assertEquals("Bad employee name", POBuilder.names[0], e.getName());
556 Assert.assertTrue("More than one element in the query result", !iter.hasNext());
557 Assert.assertEquals("Bad query result size", 1, col.size());
558
559 iter = col.iterator();
560 Assert.assertTrue("The query result is empty", iter.hasNext());
561 e = (Employee) iter.next();
562 Assert.assertNotNull("Null collection element", e);
563 Assert.assertEquals("Bad employee name", POBuilder.names[0], e.getName());
564 Assert.assertTrue("More than one element in the query result", !iter.hasNext());
565
566 query.close(col);
567 } catch (Exception e) {
568 Exception ie = ExceptionHelper.getNested(e);
569 logger.log(BasicLevel.ERROR, "", ie);
570 fail(ie.getMessage());
571 } finally {
572 pm.close();
573 }
574 }
575
576 public void testFieldRefNull() {
577 logger.log(BasicLevel.DEBUG, "testFieldRef");
578 PersistenceManager pm = pmf.getPersistenceManager();
579 final int nbEmp = 5;
580 Object [] oid = new Object [nbEmp];
581 for(int i=0; i<nbEmp; i++) {
582 Employee e = new Employee("testFieldRefNull" + i, null);
583 pm.makePersistent(e);
584 oid[i] = pm.getObjectId(e);
585 }
586 pm.close();
587 try {
588 pm = pmf.getPersistenceManager();
589 Query query = pm.newQuery(Employee.class);
590 query.declareParameters("Department d");
591 query.setFilter("(dept == d)");
592 Collection col = (Collection ) query.execute(null);
593 int size = col.size();
594 query.close(col);
595 assertEquals("Bad number of employee without department", nbEmp, size);
596 } catch (Exception e) {
597 Exception ie = ExceptionHelper.getNested(e);
598 logger.log(BasicLevel.ERROR, "", ie);
599 fail(ie.getMessage());
600 } finally {
601 pm.currentTransaction().begin();
602 for(int i=0; i<nbEmp; i++) {
603 Employee e = (Employee) pm.getObjectById(oid[i], false);
604 pm.deletePersistent(e);
605 }
606 pm.currentTransaction().commit();
607 pm.close();
608 }
609 }
610
611 public void testThis() {
612 logger.log(BasicLevel.DEBUG, "testThis");
613 PersistenceManager pm = pmf.getPersistenceManager();
614 try {
615 Class empClass = Employee.class;
616 Query query = pm.newQuery(empClass);
617
618 String filter = "(this.name == aName)";
619 String param = "String aName";
620
621 query.declareParameters(param);
622 query.setFilter(filter);
623
624 Collection col = (Collection ) query.execute(POBuilder.names[1]);
625 Iterator iter = col.iterator();
626 Assert.assertTrue("The query result is empty", iter.hasNext());
627 Employee e = (Employee) iter.next();
628 Assert.assertNotNull("Null collection element", e);
629 Assert.assertEquals("Bad employee name", POBuilder.names[1], e.getName()); |
Java API By Example, From Geeks To Geeks.