This project has retired. For details please refer to its
Attic page.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 package org.apache.chemistry.opencmis.inmemory.query;
20
21 import static org.apache.chemistry.opencmis.inmemory.UnitTestTypeSystemCreator.COMPLEX_TYPE;
22 import static org.apache.chemistry.opencmis.inmemory.UnitTestTypeSystemCreator.PROP_ID_BOOLEAN;
23 import static org.apache.chemistry.opencmis.inmemory.UnitTestTypeSystemCreator.PROP_ID_DATETIME;
24 import static org.apache.chemistry.opencmis.inmemory.UnitTestTypeSystemCreator.PROP_ID_DECIMAL;
25 import static org.apache.chemistry.opencmis.inmemory.UnitTestTypeSystemCreator.PROP_ID_INT;
26 import static org.junit.Assert.assertEquals;
27 import static org.junit.Assert.assertFalse;
28 import static org.junit.Assert.assertNotNull;
29 import static org.junit.Assert.assertTrue;
30 import static org.junit.Assert.fail;
31
32 import org.apache.chemistry.opencmis.commons.PropertyIds;
33 import org.apache.chemistry.opencmis.commons.data.ObjectData;
34 import org.apache.chemistry.opencmis.commons.data.ObjectList;
35 import org.apache.chemistry.opencmis.commons.enums.IncludeRelationships;
36 import org.apache.chemistry.opencmis.inmemory.AbstractServiceTest;
37 import org.apache.chemistry.opencmis.inmemory.UnitTestTypeSystemCreator;
38 import org.apache.commons.logging.Log;
39 import org.apache.commons.logging.LogFactory;
40 import org.junit.After;
41 import org.junit.Before;
42 import org.junit.Test;
43
44 public class EvalQueryTest extends AbstractServiceTest {
45
46 private static final Log log = LogFactory.getLog(EvalQueryTest.class);
47 private QueryTestDataCreator dataCreator;
48
49 @Override
50 @Before
51 public void setUp() {
52
53
54 super.setTypeCreatorClass(UnitTestTypeSystemCreator.class.getName());
55 super.setUp();
56
57 dataCreator = new QueryTestDataCreator(fRepositoryId, fRootFolderId, fObjSvc, fVerSvc);
58 dataCreator.createBasicTestData();
59 }
60
61 @Override
62 @After
63 public void tearDown() {
64 super.tearDown();
65 }
66
67 @Test
68 public void testAll() {
69 String statement = "SELECT * FROM cmis:document";
70 ObjectList res = doQuery(statement);
71 assertEquals(5, res.getObjects().size());
72 assertTrue(resultContains("alpha", res));
73 assertFalse(resultContains("jens", res));
74 }
75
76
77
78
79 @Test
80 public void testBooleanEquals() {
81 String statement = "SELECT * FROM " + COMPLEX_TYPE + " WHERE " + PROP_ID_BOOLEAN + "= true";
82 ObjectList res = doQuery(statement);
83 assertEquals(3, res.getObjects().size());
84 assertTrue(resultContains("alpha", res));
85 assertTrue(resultContains("gamma", res));
86 assertTrue(resultContains("delta", res));
87 }
88
89 @Test
90 public void testBooleanNotEquals() {
91 String statement = "SELECT * FROM " + COMPLEX_TYPE + " WHERE " + PROP_ID_BOOLEAN + "= false";
92 ObjectList res = doQuery(statement);
93 assertEquals(2, res.getObjects().size());
94 assertTrue(resultContains("beta", res));
95 assertTrue(resultContains("epsilon", res));
96 }
97
98
99
100
101 @Test
102 public void testIntegerEquals() {
103 String statement = "SELECT * FROM " + COMPLEX_TYPE + " WHERE " + PROP_ID_INT + "= 100";
104 ObjectList res = doQuery(statement);
105 assertEquals(1, res.getObjects().size());
106 assertTrue(resultContains("epsilon", res));
107 }
108
109 @Test
110 public void testIntegerNotEquals() {
111 String statement = "SELECT * FROM " + COMPLEX_TYPE + " WHERE " + PROP_ID_INT + "<> 100";
112 ObjectList res = doQuery(statement);
113 assertEquals(4, res.getObjects().size());
114 assertTrue(resultContains("alpha", res));
115 assertTrue(resultContains("beta", res));
116 assertTrue(resultContains("gamma", res));
117 assertTrue(resultContains("delta", res));
118 }
119
120 @Test
121 public void testIntegerLess() {
122 String statement = "SELECT * FROM " + COMPLEX_TYPE + " WHERE " + PROP_ID_INT + "< 0";
123 ObjectList res = doQuery(statement);
124 assertEquals(2, res.getObjects().size());
125 assertTrue(resultContains("alpha", res));
126 assertTrue(resultContains("beta", res));
127 }
128
129 @Test
130 public void testIntegerLessOrEqual() {
131 String statement = "SELECT * FROM " + COMPLEX_TYPE + " WHERE " + PROP_ID_INT + "<= 0";
132 ObjectList res = doQuery(statement);
133 assertEquals(3, res.getObjects().size());
134 assertTrue(resultContains("alpha", res));
135 assertTrue(resultContains("beta", res));
136 assertTrue(resultContains("gamma", res));
137 }
138
139 @Test
140 public void testIntegerGreater() {
141 String statement = "SELECT * FROM " + COMPLEX_TYPE + " WHERE " + PROP_ID_INT + "> 0";
142 ObjectList res = doQuery(statement);
143 assertEquals(2, res.getObjects().size());
144 assertTrue(resultContains("delta", res));
145 assertTrue(resultContains("epsilon", res));
146 }
147
148 @Test
149 public void testIntegerGreaterOrEqual() {
150 String statement = "SELECT * FROM " + COMPLEX_TYPE + " WHERE " + PROP_ID_INT + ">= 0";
151 ObjectList res = doQuery(statement);
152 assertEquals(3, res.getObjects().size());
153 assertTrue(resultContains("gamma", res));
154 assertTrue(resultContains("delta", res));
155 assertTrue(resultContains("epsilon", res));
156 }
157
158
159
160
161 @Test
162 public void testDecimalEquals() {
163 String statement = "SELECT * FROM " + COMPLEX_TYPE + " WHERE " + PROP_ID_DECIMAL + "= 1.23456E-6";
164 ObjectList res = doQuery(statement);
165 assertEquals(1, res.getObjects().size());
166 assertTrue(resultContains("delta", res));
167 }
168
169 @Test
170 public void testDecimalNotEquals() {
171 String statement = "SELECT * FROM " + COMPLEX_TYPE + " WHERE " + PROP_ID_DECIMAL + "<> 1.23456E-6";
172 ObjectList res = doQuery(statement);
173 assertEquals(4, res.getObjects().size());
174 assertTrue(resultContains("alpha", res));
175 assertTrue(resultContains("beta", res));
176 assertTrue(resultContains("gamma", res));
177 assertTrue(resultContains("epsilon", res));
178 }
179
180 @Test
181 public void testDecimalLess() {
182 String statement = "SELECT * FROM " + COMPLEX_TYPE + " WHERE " + PROP_ID_DECIMAL + "< 1.23456E-6";
183 ObjectList res = doQuery(statement);
184 assertEquals(2, res.getObjects().size());
185 assertTrue(resultContains("alpha", res));
186 assertTrue(resultContains("beta", res));
187 }
188
189 @Test
190 public void testDecimalLessOrEqual() {
191 String statement = "SELECT * FROM " + COMPLEX_TYPE + " WHERE " + PROP_ID_DECIMAL + "<= 1.23456E-6";
192 ObjectList res = doQuery(statement);
193 assertEquals(3, res.getObjects().size());
194 assertTrue(resultContains("alpha", res));
195 assertTrue(resultContains("beta", res));
196 assertTrue(resultContains("delta", res));
197 }
198
199 @Test
200 public void testDecimalGreater() {
201 String statement = "SELECT * FROM " + COMPLEX_TYPE + " WHERE " + PROP_ID_DECIMAL + "> 1.23456E-6";
202 ObjectList res = doQuery(statement);
203 assertEquals(2, res.getObjects().size());
204 assertTrue(resultContains("gamma", res));
205 assertTrue(resultContains("epsilon", res));
206 }
207
208 @Test
209 public void testDecimalGreaterOrEqual() {
210 String statement = "SELECT * FROM " + COMPLEX_TYPE + " WHERE " + PROP_ID_DECIMAL + ">= 1.23456E-6";
211 ObjectList res = doQuery(statement);
212 assertEquals(3, res.getObjects().size());
213 assertTrue(resultContains("gamma", res));
214 assertTrue(resultContains("delta", res));
215 assertTrue(resultContains("epsilon", res));
216 }
217
218
219
220
221 @Test
222 public void testDateEquals() {
223 String statement = "SELECT * FROM " + COMPLEX_TYPE + " WHERE " + PROP_ID_DATETIME + "= TIMESTAMP '2038-01-20T00:00:00.000Z'";
224 ObjectList res = doQuery(statement);
225 assertEquals(1, res.getObjects().size());
226 assertTrue(resultContains("delta", res));
227 }
228
229 @Test
230 public void testDateNotEquals() {
231 String statement = "SELECT * FROM " + COMPLEX_TYPE + " WHERE " + PROP_ID_DATETIME + "<> TIMESTAMP '2038-01-20T00:00:00.000Z'";
232 ObjectList res = doQuery(statement);
233 assertEquals(4, res.getObjects().size());
234 assertTrue(resultContains("alpha", res));
235 assertTrue(resultContains("beta", res));
236 assertTrue(resultContains("gamma", res));
237 assertTrue(resultContains("epsilon", res));
238 }
239
240 @Test
241 public void testDateLess() {
242 String statement = "SELECT * FROM " + COMPLEX_TYPE + " WHERE " + PROP_ID_DATETIME + "< TIMESTAMP '2038-01-20T00:00:00.000Z'";
243 ObjectList res = doQuery(statement);
244 assertEquals(3, res.getObjects().size());
245 assertTrue(resultContains("alpha", res));
246 assertTrue(resultContains("beta", res));
247 assertTrue(resultContains("gamma", res));
248 }
249
250 @Test
251 public void testDateLessOrEquals() {
252 String statement = "SELECT * FROM " + COMPLEX_TYPE + " WHERE " + PROP_ID_DATETIME + "<= TIMESTAMP '2038-01-20T00:00:00.000Z'";
253 ObjectList res = doQuery(statement);
254 assertEquals(4, res.getObjects().size());
255 assertTrue(resultContains("alpha", res));
256 assertTrue(resultContains("beta", res));
257 assertTrue(resultContains("gamma", res));
258 assertTrue(resultContains("delta", res));
259 }
260
261 @Test
262 public void testDategreater() {
263 String statement = "SELECT * FROM " + COMPLEX_TYPE + " WHERE " + PROP_ID_DATETIME + "> TIMESTAMP '2038-01-20T00:00:00.000Z'";
264 ObjectList res = doQuery(statement);
265 assertEquals(1, res.getObjects().size());
266 assertTrue(resultContains("epsilon", res));
267 }
268
269
270 public void testDateGreaterOrEqual() {
271 String statement = "SELECT * FROM " + COMPLEX_TYPE + " WHERE " + PROP_ID_DATETIME + ">= TIMESTAMP '2038-01-20T00:00:00.000Z'";
272 ObjectList res = doQuery(statement);
273 assertEquals(2, res.getObjects().size());
274 assertTrue(resultContains("delta", res));
275 assertTrue(resultContains("epsilon", res));
276 }
277
278
279
280
281 @Test
282 public void testStringEquals() {
283 String statement = "SELECT * FROM " + COMPLEX_TYPE + " WHERE " + UnitTestTypeSystemCreator.PROP_ID_STRING + "= 'Alpha'";
284 ObjectList res = doQuery(statement);
285 assertEquals(1, res.getObjects().size());
286 assertTrue(resultContains("alpha", res));
287 }
288
289 @Test
290 public void testStringNotEquals() {
291 String statement = "SELECT * FROM " + COMPLEX_TYPE + " WHERE " + UnitTestTypeSystemCreator.PROP_ID_STRING + "<> 'Gamma'";
292 ObjectList res = doQuery(statement);
293 assertEquals(4, res.getObjects().size());
294 assertTrue(resultContains("alpha", res));
295 assertTrue(resultContains("beta", res));
296 assertTrue(resultContains("delta", res));
297 assertTrue(resultContains("epsilon", res));
298 }
299
300 @Test
301 public void testStringLess() {
302 String statement = "SELECT * FROM " + COMPLEX_TYPE + " WHERE " + UnitTestTypeSystemCreator.PROP_ID_STRING + "< 'Delta'";
303 ObjectList res = doQuery(statement);
304 assertEquals(2, res.getObjects().size());
305 assertTrue(resultContains("alpha", res));
306 assertTrue(resultContains("beta", res));
307 }
308
309 @Test
310 public void testStringLessOrEquals() {
311 String statement = "SELECT * FROM " + COMPLEX_TYPE + " WHERE " + UnitTestTypeSystemCreator.PROP_ID_STRING + "<= 'Delta'";
312 ObjectList res = doQuery(statement);
313 assertEquals(3, res.getObjects().size());
314 assertTrue(resultContains("alpha", res));
315 assertTrue(resultContains("beta", res));
316 assertTrue(resultContains("delta", res));
317 }
318
319 @Test
320 public void testStringGreater() {
321 String statement = "SELECT * FROM " + COMPLEX_TYPE + " WHERE " + UnitTestTypeSystemCreator.PROP_ID_STRING + "> 'Delta'";
322 ObjectList res = doQuery(statement);
323 assertEquals(2, res.getObjects().size());
324 assertTrue(resultContains("gamma", res));
325 assertTrue(resultContains("epsilon", res));
326 }
327
328 @Test
329 public void testStringGreaterOrEquals() {
330 String statement = "SELECT * FROM " + COMPLEX_TYPE + " WHERE " + UnitTestTypeSystemCreator.PROP_ID_STRING + ">= 'Delta'";
331 ObjectList res = doQuery(statement);
332 assertEquals(3, res.getObjects().size());
333 assertTrue(resultContains("gamma", res));
334 assertTrue(resultContains("delta", res));
335 assertTrue(resultContains("epsilon", res));
336 }
337
338
339
340
341 @Test
342 public void testAnd() {
343 String statement = "SELECT * FROM " + COMPLEX_TYPE + " WHERE " + PROP_ID_INT + "= 50 AND " + PROP_ID_BOOLEAN + "= true";
344 ObjectList res = doQuery(statement);
345 assertEquals(1, res.getObjects().size());
346 assertTrue(resultContains("delta", res));
347
348 statement = "SELECT * FROM " + COMPLEX_TYPE + " WHERE " + PROP_ID_INT + "= 50 AND " + PROP_ID_BOOLEAN + "= false";
349 res = doQuery(statement);
350 assertEquals(0, res.getObjects().size());
351 }
352
353 @Test
354 public void testOr() {
355 String statement = "SELECT * FROM " + COMPLEX_TYPE + " WHERE " + PROP_ID_INT + "= -50 OR " + PROP_ID_BOOLEAN + "= false";
356 ObjectList res = doQuery(statement);
357 assertEquals(2, res.getObjects().size());
358 assertTrue(resultContains("beta", res));
359 assertTrue(resultContains("epsilon", res));
360 }
361
362 @Test
363 public void testNot() {
364 String statement = "SELECT * FROM " + COMPLEX_TYPE + " WHERE NOT " + PROP_ID_INT + "= 50";
365 ObjectList res = doQuery(statement);
366 assertEquals(4, res.getObjects().size());
367 assertTrue(resultContains("alpha", res));
368 assertTrue(resultContains("beta", res));
369 assertTrue(resultContains("gamma", res));
370 assertTrue(resultContains("epsilon", res));
371 }
372
373 @Test
374 public void testOrderByString() {
375 String statement = "SELECT * FROM " + COMPLEX_TYPE + " ORDER BY " + UnitTestTypeSystemCreator.PROP_ID_STRING;
376 ObjectList res = doQuery(statement);
377 assertEquals(5, res.getObjects().size());
378 assertTrue(resultContainsAtPos("alpha", 0, res));
379 assertTrue(resultContainsAtPos("beta", 1, res));
380 assertTrue(resultContainsAtPos("delta", 2, res));
381 assertTrue(resultContainsAtPos("epsilon", 3, res));
382 assertTrue(resultContainsAtPos("gamma", 4, res));
383
384 statement = "SELECT * FROM " + COMPLEX_TYPE + " ORDER BY " + UnitTestTypeSystemCreator.PROP_ID_STRING + " DESC";
385 res = doQuery(statement);
386 assertEquals(5, res.getObjects().size());
387 assertTrue(resultContainsAtPos("alpha", 4, res));
388 assertTrue(resultContainsAtPos("beta", 3, res));
389 assertTrue(resultContainsAtPos("delta", 2, res));
390 assertTrue(resultContainsAtPos("epsilon", 1, res));
391 assertTrue(resultContainsAtPos("gamma", 0, res));
392 }
393
394 @Test
395 public void testOrderByInteger() {
396 String statement = "SELECT * FROM " + COMPLEX_TYPE + " ORDER BY " + PROP_ID_INT;
397 ObjectList res = doQuery(statement);
398 assertEquals(5, res.getObjects().size());
399 assertTrue(resultContainsAtPos("alpha", 0, res));
400 assertTrue(resultContainsAtPos("beta", 1, res));
401 assertTrue(resultContainsAtPos("gamma", 2, res));
402 assertTrue(resultContainsAtPos("delta", 3, res));
403 assertTrue(resultContainsAtPos("epsilon", 4, res));
404
405 statement = "SELECT * FROM " + COMPLEX_TYPE + " ORDER BY " + PROP_ID_INT + " DESC";
406 res = doQuery(statement);
407 assertEquals(5, res.getObjects().size());
408 assertTrue(resultContainsAtPos("alpha", 4, res));
409 assertTrue(resultContainsAtPos("beta", 3, res));
410 assertTrue(resultContainsAtPos("gamma", 2, res));
411 assertTrue(resultContainsAtPos("delta", 1, res));
412 assertTrue(resultContainsAtPos("epsilon", 0, res));
413 }
414
415 @Test
416 public void testOrderByDecimal() {
417 String statement = "SELECT * FROM " + COMPLEX_TYPE + " ORDER BY " + PROP_ID_DECIMAL;
418 ObjectList res = doQuery(statement);
419 assertEquals(5, res.getObjects().size());
420 assertTrue(resultContainsAtPos("alpha", 0, res));
421 assertTrue(resultContainsAtPos("beta", 1, res));
422 assertTrue(resultContainsAtPos("delta", 2, res));
423 assertTrue(resultContainsAtPos("gamma", 3, res));
424 assertTrue(resultContainsAtPos("epsilon", 4, res));
425
426 statement = "SELECT * FROM " + COMPLEX_TYPE + " ORDER BY " + PROP_ID_DECIMAL + " DESC";
427 res = doQuery(statement);
428 assertEquals(5, res.getObjects().size());
429 assertTrue(resultContainsAtPos("alpha", 4, res));
430 assertTrue(resultContainsAtPos("beta", 3, res));
431 assertTrue(resultContainsAtPos("delta", 2, res));
432 assertTrue(resultContainsAtPos("gamma", 1, res));
433 assertTrue(resultContainsAtPos("epsilon", 0, res));
434 }
435
436 @Test
437 public void testOrderByDate() {
438 String statement = "SELECT * FROM " + COMPLEX_TYPE + " ORDER BY " + PROP_ID_DATETIME;
439 ObjectList res = doQuery(statement);
440 assertEquals(5, res.getObjects().size());
441 assertTrue(resultContainsAtPos("beta", 0, res));
442 assertTrue(resultContainsAtPos("alpha", 1, res));
443 assertTrue(resultContainsAtPos("gamma", 2, res));
444 assertTrue(resultContainsAtPos("delta", 3, res));
445 assertTrue(resultContainsAtPos("epsilon", 4, res));
446
447 statement = "SELECT * FROM " + COMPLEX_TYPE + " ORDER BY " + PROP_ID_DATETIME + " DESC";
448 res = doQuery(statement);
449 assertEquals(5, res.getObjects().size());
450 assertTrue(resultContainsAtPos("beta", 4, res));
451 assertTrue(resultContainsAtPos("alpha", 3, res));
452 assertTrue(resultContainsAtPos("gamma", 2, res));
453 assertTrue(resultContainsAtPos("delta", 1, res));
454 assertTrue(resultContainsAtPos("epsilon", 0, res));
455 }
456
457 @Test
458 public void testOrderByBool() {
459 String statement = "SELECT * FROM " + COMPLEX_TYPE + " ORDER BY " + PROP_ID_BOOLEAN;
460 ObjectList res = doQuery(statement);
461 assertEquals(5, res.getObjects().size());
462 assertTrue(resultContainsAtPos("beta", 0, res) || resultContainsAtPos("beta", 1, res));
463 assertTrue(resultContainsAtPos("epsilon", 0, res) || resultContainsAtPos("epsilon", 1, res));
464 assertTrue(resultContainsAtPos("alpha", 2, res) || resultContainsAtPos("alpha", 3, res) || resultContainsAtPos("alpha", 4, res));
465 assertTrue(resultContainsAtPos("gamma", 2, res) || resultContainsAtPos("gamma", 3, res) || resultContainsAtPos("gamma", 4, res));
466 assertTrue(resultContainsAtPos("delta", 2, res) || resultContainsAtPos("delta", 3, res) || resultContainsAtPos("delta", 4, res));
467
468 statement = "SELECT * FROM " + COMPLEX_TYPE + " ORDER BY " + PROP_ID_BOOLEAN + " DESC";
469 res = doQuery(statement);
470 assertEquals(5, res.getObjects().size());
471 assertTrue(resultContainsAtPos("beta", 3, res) || resultContainsAtPos("beta", 4, res));
472 assertTrue(resultContainsAtPos("epsilon", 3, res) || resultContainsAtPos("epsilon", 4, res));
473 assertTrue(resultContainsAtPos("alpha", 2, res) || resultContainsAtPos("alpha", 1, res) || resultContainsAtPos("alpha", 0, res));
474 assertTrue(resultContainsAtPos("gamma", 2, res) || resultContainsAtPos("gamma", 1, res) || resultContainsAtPos("gamma", 0, res));
475 assertTrue(resultContainsAtPos("delta", 2, res) || resultContainsAtPos("delta", 1, res) || resultContainsAtPos("delta", 0, res));
476 }
477
478
479 @Test
480 public void testOrderBySystemProperties() {
481 String statement = "SELECT * from cmis:document ORDER BY "+ PropertyIds.NAME;
482 ObjectList res = doQuery(statement);
483 assertEquals(5, res.getObjects().size());
484 statement = "SELECT * from cmis:document ORDER BY " + PropertyIds.CREATION_DATE + " ASC";
485 assertEquals(5, res.getObjects().size());
486 statement = "SELECT * from cmis:document ORDER BY " + PropertyIds.LAST_MODIFICATION_DATE + " DESC";
487 assertEquals(5, res.getObjects().size());
488 }
489
490 @Test
491 public void testIsNull() {
492 dataCreator.createNullTestDocument();
493 String statement = "SELECT * FROM " + COMPLEX_TYPE + " WHERE " + PROP_ID_INT + " IS NULL";
494 ObjectList res = doQuery(statement);
495 assertEquals(1, res.getObjects().size());
496 assertTrue(resultContains("nulldoc", res));
497 }
498
499 @Test
500 public void testIsNotNull() {
501 dataCreator.createNullTestDocument();
502 String statement = "SELECT * FROM " + COMPLEX_TYPE + " WHERE " + PROP_ID_INT + " IS NOT NULL";
503 ObjectList res = doQuery(statement);
504 assertEquals(5, res.getObjects().size());
505 assertTrue(resultContains("alpha", res));
506 assertTrue(resultContains("beta", res));
507 assertTrue(resultContains("gamma", res));
508 assertTrue(resultContains("delta", res));
509 assertTrue(resultContains("epsilon", res));
510 }
511
512 @Test
513 public void patternTest() {
514 String res = InMemoryQueryProcessor.translatePattern("ABC%def");
515 assertEquals("ABC.*def", res);
516 res = InMemoryQueryProcessor.translatePattern("%abc");
517 assertEquals(".*abc", res);
518 res = InMemoryQueryProcessor.translatePattern("abc%");
519 assertEquals("abc.*", res);
520 res = InMemoryQueryProcessor.translatePattern("ABC\\%def");
521 assertEquals("ABC\\%def", res);
522 res = InMemoryQueryProcessor.translatePattern("\\%abc");
523 assertEquals("\\%abc", res);
524 res = InMemoryQueryProcessor.translatePattern("abc%def%ghi");
525 assertEquals("abc.*def.*ghi", res);
526 res = InMemoryQueryProcessor.translatePattern("abc%def\\%ghi%jkl");
527 assertEquals("abc.*def\\%ghi.*jkl", res);
528
529 res = InMemoryQueryProcessor.translatePattern("ABC_def");
530 assertEquals("ABC.def", res);
531 res = InMemoryQueryProcessor.translatePattern("_abc");
532 assertEquals(".abc", res);
533 res = InMemoryQueryProcessor.translatePattern("abc_");
534 assertEquals("abc.", res);
535 res = InMemoryQueryProcessor.translatePattern("ABC\\_def");
536 assertEquals("ABC\\_def", res);
537 res = InMemoryQueryProcessor.translatePattern("\\_abc");
538 assertEquals("\\_abc", res);
539 res = InMemoryQueryProcessor.translatePattern("abc_def_ghi");
540 assertEquals("abc.def.ghi", res);
541 res = InMemoryQueryProcessor.translatePattern("abc_def\\_ghi_jkl");
542 assertEquals("abc.def\\_ghi.jkl", res);
543 }
544
545 @Test
546 public void testLike() {
547 dataCreator.createLikeTestDocuments(fRootFolderId);
548 String statement = "SELECT * FROM " + COMPLEX_TYPE + " WHERE " + UnitTestTypeSystemCreator.PROP_ID_STRING + " LIKE 'ABC%'";
549 ObjectList res = doQuery(statement);
550 assertEquals(2, res.getObjects().size());
551 assertTrue(resultContains("likedoc1", res));
552 assertTrue(resultContains("likedoc2", res));
553
554 statement = "SELECT * FROM " + COMPLEX_TYPE + " WHERE " + UnitTestTypeSystemCreator.PROP_ID_STRING + " LIKE '%ABC'";
555 res = doQuery(statement);
556 assertEquals(1, res.getObjects().size());
557 assertTrue(resultContains("likedoc3", res));
558
559 statement = "SELECT * FROM " + COMPLEX_TYPE + " WHERE " + UnitTestTypeSystemCreator.PROP_ID_STRING + " LIKE '%ABC%'";
560 res = doQuery(statement);
561 assertEquals(3, res.getObjects().size());
562 assertTrue(resultContains("likedoc1", res));
563 assertTrue(resultContains("likedoc2", res));
564 assertTrue(resultContains("likedoc3", res));
565
566 statement = "SELECT * FROM " + COMPLEX_TYPE + " WHERE " + UnitTestTypeSystemCreator.PROP_ID_STRING + " LIKE 'AB_DEF'";
567 res = doQuery(statement);
568 assertEquals(1, res.getObjects().size());
569 assertTrue(resultContains("likedoc1", res));
570 }
571
572 @Test
573 public void testNotLike() {
574 dataCreator.createLikeTestDocuments(fRootFolderId);
575 String statement = "SELECT * FROM " + COMPLEX_TYPE + " WHERE " + UnitTestTypeSystemCreator.PROP_ID_STRING + " NOT LIKE 'ABC%'";
576 ObjectList res = doQuery(statement);
577 assertEquals(6, res.getObjects().size());
578 assertTrue(resultContains("likedoc3", res));
579
580 statement = "SELECT * FROM " + COMPLEX_TYPE + " WHERE " + UnitTestTypeSystemCreator.PROP_ID_STRING + " NOT LIKE '%a'";
581 res = doQuery(statement);
582 assertEquals(4, res.getObjects().size());
583 assertTrue(resultContains("likedoc1", res));
584 assertTrue(resultContains("likedoc1", res));
585 assertTrue(resultContains("likedoc3", res));
586 assertTrue(resultContains("epsilon", res));
587 }
588
589 @Test
590 public void testInFolder() {
591 String statement = "SELECT * FROM " + COMPLEX_TYPE + " WHERE IN_FOLDER('" + fRootFolderId + "')";
592 ObjectList res = doQuery(statement);
593 assertEquals(5, res.getObjects().size());
594 assertTrue(resultContains("alpha", res));
595 assertTrue(resultContains("beta", res));
596 assertTrue(resultContains("gamma", res));
597 assertTrue(resultContains("delta", res));
598 assertTrue(resultContains("epsilon", res));
599
600 statement = "SELECT * FROM " + COMPLEX_TYPE + " WHERE IN_FOLDER('" + dataCreator.getFolder1() + "')";
601 res = doQuery(statement);
602 assertEquals(0, res.getObjects().size());
603
604 statement = "SELECT * FROM " + COMPLEX_TYPE + " WHERE IN_FOLDER(" + COMPLEX_TYPE + ", '" + fRootFolderId + "')";
605 res = doQuery(statement);
606 assertEquals(5, res.getObjects().size());
607 assertTrue(resultContains("alpha", res));
608 assertTrue(resultContains("beta", res));
609 assertTrue(resultContains("gamma", res));
610 assertTrue(resultContains("delta", res));
611 assertTrue(resultContains("epsilon", res));
612
613 statement = "SELECT * FROM " + COMPLEX_TYPE + " WHERE IN_FOLDER(UnknownType, '" + dataCreator.getFolder2() + "')";
614 try {
615 res = doQuery(statement);
616 fail("Unknown type in folder should throw exception");
617 } catch (Exception e) {
618 assertTrue(e.toString().contains("is neither a type query name nor an alias"));
619 log.debug("expected Exception: " + e);
620 }
621 }
622
623 @Test
624 public void testInTree() {
625 dataCreator.createLikeTestDocuments(dataCreator.getFolder11());
626
627 String statement = "SELECT * FROM " + COMPLEX_TYPE + " WHERE IN_TREE(" + COMPLEX_TYPE + ", '" + dataCreator.getFolder1() + "')";
628 ObjectList res = doQuery(statement);
629 assertEquals(3, res.getObjects().size());
630 assertTrue(resultContains("likedoc1", res));
631 assertTrue(resultContains("likedoc2", res));
632 assertTrue(resultContains("likedoc3", res));
633
634 statement = "SELECT * FROM " + COMPLEX_TYPE + " WHERE IN_FOLDER('" + dataCreator.getFolder1() + "')";
635 res = doQuery(statement);
636 assertEquals(0, res.getObjects().size());
637
638 statement = "SELECT * FROM " + COMPLEX_TYPE + " WHERE IN_TREE('" + dataCreator.getFolder2() + "')";
639 res = doQuery(statement);
640 assertEquals(0, res.getObjects().size());
641
642 statement = "SELECT * FROM " + COMPLEX_TYPE + " WHERE IN_TREE(UnknownType, '" + dataCreator.getFolder2() + "')";
643 try {
644 res = doQuery(statement);
645 fail("Unknown type in folder should throw exception");
646 } catch (Exception e) {
647 assertTrue(e.toString().contains("is neither a type query name nor an alias"));
648 log.debug("expected Exception: " + e);
649 }
650 }
651
652 @Test
653 public void testIn() {
654 String statement = "SELECT * FROM " + COMPLEX_TYPE + " WHERE " + UnitTestTypeSystemCreator.PROP_ID_STRING + " IN ('Alpha', 'Beta', 'Gamma')";
655 ObjectList res = doQuery(statement);
656 assertEquals(3, res.getObjects().size());
657 assertTrue(resultContains("alpha", res));
658 assertTrue(resultContains("beta", res));
659 assertTrue(resultContains("gamma", res));
660
661 statement = "SELECT * FROM " + COMPLEX_TYPE + " WHERE " + UnitTestTypeSystemCreator.PROP_ID_STRING + " IN ('Theta', 'Pi', 'Rho')";
662 res = doQuery(statement);
663 assertEquals(0, res.getObjects().size());
664 }
665
666 @Test
667 public void testNotIn() {
668 String statement = "SELECT * FROM " + COMPLEX_TYPE + " WHERE " + UnitTestTypeSystemCreator.PROP_ID_STRING + " NOT IN ('Alpha', 'Beta', 'Gamma')";
669 ObjectList res = doQuery(statement);
670 assertEquals(2, res.getObjects().size());
671 assertTrue(resultContains("delta", res));
672 assertTrue(resultContains("epsilon", res));
673
674 statement = "SELECT * FROM " + COMPLEX_TYPE + " WHERE " + UnitTestTypeSystemCreator.PROP_ID_STRING + " NOT IN ('Theta', 'Pi', 'Rho')";
675 res = doQuery(statement);
676 assertEquals(5, res.getObjects().size());
677 assertTrue(resultContains("alpha", res));
678 assertTrue(resultContains("beta", res));
679 assertTrue(resultContains("gamma", res));
680 assertTrue(resultContains("delta", res));
681 assertTrue(resultContains("epsilon", res));
682 }
683
684 @Test
685 public void testMultiValueInAny() {
686 dataCreator.createMultiValueDocuments();
687
688 String statement = "SELECT * FROM " + COMPLEX_TYPE + " WHERE ANY " + UnitTestTypeSystemCreator.PROP_ID_STRING_MULTI_VALUE + " IN ('red', 'black', 'grey')";
689 ObjectList res = doQuery(statement);
690 assertEquals(2, res.getObjects().size());
691 assertTrue(resultContains("mv-alpha", res));
692 assertTrue(resultContains("mv-beta", res));
693
694 statement = "SELECT * FROM " + COMPLEX_TYPE + " WHERE ANY " + UnitTestTypeSystemCreator.PROP_ID_STRING_MULTI_VALUE + " IN ('green', 'black', 'grey')";
695 res = doQuery(statement);
696 assertEquals(1, res.getObjects().size());
697 assertTrue(resultContains("mv-alpha", res));
698
699 statement = "SELECT * FROM " + COMPLEX_TYPE + " WHERE ANY " + UnitTestTypeSystemCreator.PROP_ID_STRING_MULTI_VALUE + " IN ('white', 'black', 'grey')";
700 res = doQuery(statement);
701 assertEquals(0, res.getObjects().size());
702 }
703
704 @Test
705 public void testMultiValueNotInAny() {
706 dataCreator.createMultiValueDocuments();
707
708 String statement = "SELECT * FROM " + COMPLEX_TYPE + " WHERE ANY " + UnitTestTypeSystemCreator.PROP_ID_STRING_MULTI_VALUE + " NOT IN ('red', 'black', 'grey')";
709 ObjectList res = doQuery(statement);
710 assertEquals(0, res.getObjects().size());
711
712 statement = "SELECT * FROM " + COMPLEX_TYPE + " WHERE ANY " + UnitTestTypeSystemCreator.PROP_ID_STRING_MULTI_VALUE + " NOT IN ('green', 'black', 'grey')";
713 res = doQuery(statement);
714 assertEquals(1, res.getObjects().size());
715 assertTrue(resultContains("mv-beta", res));
716
717 statement = "SELECT * FROM " + COMPLEX_TYPE + " WHERE ANY " + UnitTestTypeSystemCreator.PROP_ID_STRING_MULTI_VALUE + " NOT IN ('white', 'black', 'grey')";
718 res = doQuery(statement);
719 assertEquals(2, res.getObjects().size());
720 assertTrue(resultContains("mv-alpha", res));
721 assertTrue(resultContains("mv-beta", res));
722 }
723
724 @Test
725 public void testMultiValueEqAny() {
726 dataCreator.createMultiValueDocuments();
727
728 String statement = "SELECT * FROM " + COMPLEX_TYPE + " WHERE 'red' = ANY " + UnitTestTypeSystemCreator.PROP_ID_STRING_MULTI_VALUE ;
729 ObjectList res = doQuery(statement);
730 assertEquals(2, res.getObjects().size());
731 assertTrue(resultContains("mv-alpha", res));
732 assertTrue(resultContains("mv-beta", res));
733
734 statement = "SELECT * FROM " + COMPLEX_TYPE + " WHERE 'black' = ANY " + UnitTestTypeSystemCreator.PROP_ID_STRING_MULTI_VALUE ;
735 res = doQuery(statement);
736 assertEquals(0, res.getObjects().size());
737
738 statement = "SELECT * FROM " + COMPLEX_TYPE + " WHERE 'black' = ANY " + UnitTestTypeSystemCreator.PROP_ID_STRING;
739 try {
740 doQuery(statement);
741 fail("Unknown = ANY with single value prop should throw exception");
742 } catch (Exception e) {
743 assertTrue(e.toString().contains("only is allowed on multi-value properties"));
744 log.debug("expected Exception: " + e);
745 }
746 }
747
748 @Test
749 public void testVersionsWithQuery() {
750 String id = dataCreator.createVersionedDocument();
751 assertNotNull(id);
752 String statement = "SELECT * FROM " + UnitTestTypeSystemCreator.VERSIONED_TYPE;
753 ObjectList res = doQueryAllVersions(statement);
754 assertEquals(2, res.getObjects().size());
755 assertTrue(resultContains("ver123", UnitTestTypeSystemCreator.VERSION_PROPERTY_ID, res));
756 assertTrue(resultContains("ver456", UnitTestTypeSystemCreator.VERSION_PROPERTY_ID, res));
757 assertTrue(resultContains("V 1.0", PropertyIds.VERSION_LABEL, res));
758 assertTrue(resultContains("V 2.0", PropertyIds.VERSION_LABEL, res));
759
760 res = doQuery(statement);
761 assertEquals(1, res.getObjects().size());
762 assertFalse(resultContains("V 1.0", PropertyIds.VERSION_LABEL, res));
763 assertTrue(resultContains("V 2.0", PropertyIds.VERSION_LABEL, res));
764 }
765
766 @Test
767 public void testLastestVersionsWithQuery() {
768 String id = dataCreator.createVersionedDocument();
769 assertNotNull(id);
770 String statement = "SELECT * FROM " + UnitTestTypeSystemCreator.VERSIONED_TYPE;
771 ObjectList res = doQuery(statement);
772 assertEquals(1, res.getObjects().size());
773 assertTrue(resultContains("ver456", UnitTestTypeSystemCreator.VERSION_PROPERTY_ID, res));
774 assertTrue(resultContains("V 2.0", PropertyIds.VERSION_LABEL, res));
775
776 res = doQuery(statement);
777 assertEquals(1, res.getObjects().size());
778 assertFalse(resultContains("V 1.0", PropertyIds.VERSION_LABEL, res));
779 assertTrue(resultContains("V 2.0", PropertyIds.VERSION_LABEL, res));
780 }
781
782 @Test
783 public void testContainsWord() {
784 String statement = "SELECT * FROM " + COMPLEX_TYPE + " WHERE CONTAINS('cat')";
785 ObjectList res = doQuery(statement);
786 assertEquals(3, res.getObjects().size());
787 assertTrue(resultContains("alpha", res));
788 assertTrue(resultContains("beta", res));
789 assertTrue(resultContains("delta", res));
790 }
791
792 @Test
793 public void testContainsPhrase() {
794 String statement = "SELECT * FROM " + COMPLEX_TYPE + " WHERE CONTAINS('\\'Kitty Katty\\'')";
795 ObjectList res = doQuery(statement);
796 assertEquals(1, res.getObjects().size());
797 assertTrue(resultContains("beta", res));
798 }
799
800 @Test
801 public void testContainsNot() {
802 String statement = "SELECT * FROM " + COMPLEX_TYPE + " WHERE CONTAINS('-cat')";
803 ObjectList res = doQuery(statement);
804 assertEquals(2, res.getObjects().size());
805 assertTrue(resultContains("gamma", res));
806 assertTrue(resultContains("epsilon", res));
807 }
808
809 @Test
810 public void testContainsOr() {
811 String statement = "SELECT * FROM " + COMPLEX_TYPE + " WHERE CONTAINS('cat OR dog')";
812 ObjectList res = doQuery(statement);
813 assertEquals(4, res.getObjects().size());
814 assertTrue(resultContains("alpha", res));
815 assertTrue(resultContains("beta", res));
816 assertTrue(resultContains("gamma", res));
817 assertTrue(resultContains("delta", res));
818 }
819
820 @Test
821 public void testContainsAnd() {
822 String statement = "SELECT * FROM " + COMPLEX_TYPE + " WHERE CONTAINS('cat dog')";
823 ObjectList res = doQuery(statement);
824 assertEquals(1, res.getObjects().size());
825 assertTrue(resultContains("delta", res));
826 }
827
828 private ObjectList doQuery(String queryString) {
829 log.debug("\nExecuting query: " + queryString);
830 ObjectList res = fDiscSvc.query(fRepositoryId, queryString, false, false,
831 IncludeRelationships.NONE, null, null, null, null);
832 log.debug("Query result, number of matching objects: " + res.getNumItems());
833 for (ObjectData od : res.getObjects()) {
834 log.debug("Found matching object: " + od.getProperties().getProperties().get(PropertyIds.NAME).getFirstValue());
835 }
836 return res;
837 }
838
839 private ObjectList doQueryAllVersions(String queryString) {
840 log.debug("\nExecuting query: " + queryString);
841 ObjectList res = fDiscSvc.query(fRepositoryId, queryString, true, false,
842 IncludeRelationships.NONE, null, null, null, null);
843 log.debug("Query result, number of matching objects: " + res.getNumItems());
844 for (ObjectData od : res.getObjects()) {
845 log.debug("Found matching object: " + od.getProperties().getProperties().get(PropertyIds.NAME).getFirstValue());
846 }
847 return res;
848 }
849
850 private static boolean resultContains(String name, String propId, ObjectList results) {
851 for (ObjectData od : results.getObjects()) {
852 String nameProp = (String) od.getProperties().getProperties().get(propId).getFirstValue();
853 if (name.equals(nameProp)) {
854 return true;
855 }
856 }
857 return false;
858 }
859
860 private static boolean resultContains(String name, ObjectList results) {
861 return resultContains(name, PropertyIds.NAME, results);
862 }
863
864 private static boolean resultContainsAtPos(String name, int index, ObjectList results) {
865 String nameProp = (String) results.getObjects().get(index).getProperties().getProperties().get(PropertyIds.NAME).getFirstValue();
866 return name.equals(nameProp);
867 }
868 }