001: package org.geotools.filter.text.cql2;
002:
003: import java.text.DateFormat;
004: import java.text.ParseException;
005: import java.text.SimpleDateFormat;
006: import java.util.Calendar;
007: import java.util.Date;
008: import java.util.HashMap;
009: import java.util.Map;
010:
011: import org.geotools.factory.CommonFactoryFinder;
012: import org.geotools.factory.Hints;
013: import org.opengis.filter.And;
014: import org.opengis.filter.Filter;
015: import org.opengis.filter.FilterFactory;
016: import org.opengis.filter.Not;
017: import org.opengis.filter.Or;
018: import org.opengis.filter.PropertyIsBetween;
019: import org.opengis.filter.PropertyIsEqualTo;
020: import org.opengis.filter.PropertyIsLessThan;
021: import org.opengis.filter.PropertyIsLike;
022: import org.opengis.filter.expression.Expression;
023: import org.opengis.filter.expression.Function;
024: import org.opengis.filter.expression.Literal;
025: import org.opengis.filter.expression.PropertyName;
026:
027: /**
028: *
029: * Filter Sample Factory
030: *
031: * <p>
032: * Provide samples of filters
033: * </p>
034: *
035: * @author Mauricio Pazos - Axios Engineering
036: * @author Gabriel Roldan - Axios Engineering
037: * @since 2.4
038: *
039: */
040: public class FilterSample {
041:
042: private static final FilterFactory FACTORY = CommonFactoryFinder
043: .getFilterFactory((Hints) null);
044: private static final DateFormat DATE_TIME_FORMATTER = new SimpleDateFormat(
045: "yyyy-MM-dd'T'HH:mm:ss'Z'");
046: private static final Calendar CALENDAR = Calendar.getInstance();
047: public static final String LESS_FILTER_SAMPLE = "ATTR1 < 1";
048: public static final String LESS_EQ_FILTER_SAMPLE = "ATTR1 <= 1";
049: public static final String NOT_EQ_FILTER = "ATTR1 <> 1";
050: public static final String FILTER_WITH_PAREN_ROUNDTRIP_EXPR = "ATTR1 > ((1 + 2) / 3)";
051: public static final String FILTER_WITH_NESTED_PAREN_EXPR = "ATTR1 < (1 + ((2 / 3) * 4))";
052: public static final String FILTER_SIMPLE_EXPR = "ATTR1 > 1 + 2";
053: public static final String FILTER_WITH_BRACKET_ROUNDTRIP_EXPR = "ATTR1 > [[1 + 2] / 3]";
054: public static final String PROPERTY_IS_NULL = "ATTR1 IS NULL";
055: public static final String PROPERTY_IS_NOT_NULL = "ATTR1 IS NOT NULL";
056: private static final String FIRST_DATE = "2006-11-30T01:30:00Z";
057: private static final String LAST_DATE = "2006-12-31T01:30:00Z";
058: public static final String FILTER_BEFORE_DATE = "ATTR1 BEFORE "
059: + FIRST_DATE;
060: public static final String FILTER_BEFORE_PERIOD_BETWEEN_DATES = "ATTR1 BEFORE "
061: + FIRST_DATE + "/" + LAST_DATE;
062: public static final String FILTER_BEFORE_PERIOD_DATE_AND_DAYS = "ATTR1 BEFORE "
063: + FIRST_DATE + "/" + "P30D";
064: public static final String FILTER_BEFORE_PERIOD_DATE_AND_YEARS = "ATTR1 BEFORE "
065: + FIRST_DATE + "/P1Y";
066: public static final String FILTER_BEFORE_PERIOD_DATE_AND_MONTHS = "ATTR1 BEFORE "
067: + FIRST_DATE + "/P12M";
068: public static final String FILTER_AFTER_DATE = "ATTR1 AFTER "
069: + LAST_DATE;
070: public static final String FILTER_AFTER_PERIOD_BETWEEN_DATES = "ATTR1 AFTER "
071: + FIRST_DATE + "/" + LAST_DATE;
072: private static final String DURATION_DATE = "10";
073: public static final String FILTER_AFTER_PERIOD_DATE_DAYS = "ATTR1 AFTER "
074: + FIRST_DATE + "/P" + DURATION_DATE + "D";
075: public static final String FILTER_AFTER_PERIOD_DATE_MONTH = "ATTR1 AFTER "
076: + FIRST_DATE + "/P" + DURATION_DATE + "M";
077: public static final String FILTER_AFTER_PERIOD_DATE_YEARS = "ATTR1 AFTER "
078: + FIRST_DATE + "/P" + DURATION_DATE + "Y";
079: public static final String FILTER_AFTER_PERIOD_DATE_YEARS_MONTH = "ATTR1 AFTER "
080: + FIRST_DATE
081: + "/P"
082: + DURATION_DATE
083: + "Y"
084: + DURATION_DATE
085: + "M";
086: private static final String DURATION_TIME = "5";
087: public static final String FILTER_AFTER_PERIOD_DATE_HOURS = "ATTR1 AFTER "
088: + FIRST_DATE + "/T" + DURATION_TIME + "H";
089: public static final String FILTER_AFTER_PERIOD_DATE_MINUTES = "ATTR1 AFTER "
090: + FIRST_DATE + "/T" + DURATION_TIME + "M";
091: public static final String FILTER_AFTER_PERIOD_DATE_SECONDS = "ATTR1 AFTER "
092: + FIRST_DATE + "/T" + DURATION_TIME + "S";
093: public static final String FILTER_AFTER_PERIOD_DATE_YMD_HMS = "ATTR1 AFTER "
094: + FIRST_DATE
095: + "/P"
096: + DURATION_DATE
097: + "Y"
098: + DURATION_DATE
099: + "M"
100: + DURATION_DATE
101: + "D"
102: + "T"
103: + DURATION_TIME
104: + "H"
105: + DURATION_TIME + "M" + DURATION_TIME + "S";
106: public static final String FILTER_DURING_PERIOD_BETWEEN_DATES = "ATTR1 DURING "
107: + FIRST_DATE + "/" + LAST_DATE;
108: public static final String FILTER_DURING_PERIOD_DATE_YMD_HMS = "ATTR1 DURING "
109: + FIRST_DATE
110: + "/P"
111: + DURATION_DATE
112: + "Y"
113: + DURATION_DATE
114: + "M"
115: + DURATION_DATE
116: + "D"
117: + "T"
118: + DURATION_TIME
119: + "H"
120: + DURATION_TIME + "M" + DURATION_TIME + "S";
121: public static final String FILTER_DURING_PERIOD_YMD_HMS_DATE = "ATTR1 DURING "
122: + "P"
123: + DURATION_DATE
124: + "Y"
125: + DURATION_DATE
126: + "M"
127: + DURATION_DATE
128: + "D"
129: + "T"
130: + DURATION_TIME
131: + "H"
132: + DURATION_TIME
133: + "M"
134: + DURATION_TIME
135: + "S"
136: + "/"
137: + LAST_DATE;
138: public static final String FILTER_BEFORE_PERIOD_YMD_HMS_DATE = "ATTR1 BEFORE "
139: + "P"
140: + DURATION_DATE
141: + "Y"
142: + DURATION_DATE
143: + "M"
144: + DURATION_DATE
145: + "D"
146: + "T"
147: + DURATION_TIME
148: + "H"
149: + DURATION_TIME
150: + "M"
151: + DURATION_TIME
152: + "S"
153: + "/"
154: + LAST_DATE;
155: public static final String FILTER_BEFORE_OR_DURING_PERIOD_BETWEEN_DATES = "ATTR1 BEFORE OR DURING "
156: + FIRST_DATE + "/" + LAST_DATE;
157: public static final String FILTER_BEFORE_OR_DURING_PERIOD_YMD_HMS_DATE = "ATTR1 BEFORE OR DURING "
158: + "P"
159: + DURATION_DATE
160: + "Y"
161: + DURATION_DATE
162: + "M"
163: + DURATION_DATE
164: + "D"
165: + "T"
166: + DURATION_TIME
167: + "H"
168: + DURATION_TIME
169: + "M"
170: + DURATION_TIME
171: + "S"
172: + "/"
173: + LAST_DATE;
174: public static final String FILTER_BEFORE_OR_DURING_PERIOD_DATE_YMD_HMS = "ATTR1 BEFORE OR DURING "
175: + FIRST_DATE
176: + "/"
177: + "P"
178: + DURATION_DATE
179: + "Y"
180: + DURATION_DATE
181: + "M"
182: + DURATION_DATE
183: + "D"
184: + "T"
185: + DURATION_TIME
186: + "H"
187: + DURATION_TIME
188: + "M"
189: + DURATION_TIME
190: + "S";
191: public static final String FILTER_DURING_OR_AFTER_PERIOD_BETWEEN_DATES = "ATTR1 DURING OR AFTER "
192: + FIRST_DATE + "/" + LAST_DATE;
193: public static final String FILTER_DURING_OR_AFTER_PERIOD_YMD_HMS_DATE = "ATTR1 DURING OR AFTER "
194: + "P"
195: + DURATION_DATE
196: + "Y"
197: + DURATION_DATE
198: + "M"
199: + DURATION_DATE
200: + "D"
201: + "T"
202: + DURATION_TIME
203: + "H"
204: + DURATION_TIME
205: + "M"
206: + DURATION_TIME
207: + "S"
208: + "/"
209: + LAST_DATE;
210: public static final String FILTER_DURING_OR_AFTER_PERIOD_DATE_YMD_HMS = "ATTR1 DURING OR AFTER "
211: + FIRST_DATE
212: + "/"
213: + "P"
214: + DURATION_DATE
215: + "Y"
216: + DURATION_DATE
217: + "M"
218: + DURATION_DATE
219: + "D"
220: + "T"
221: + DURATION_TIME
222: + "H"
223: + DURATION_TIME
224: + "M"
225: + DURATION_TIME
226: + "S";
227: public static final String ATTRIBUTE_NAME_EXISTS = "ATTR1 EXISTS";
228: public static final String ATTRIBUTE_NAME_DOES_NOT_EXIST = "ATTR1 DOES-NOT-EXIST";
229: public static final String FILTER_AND = "ATTR1 < 10 AND ATTR2 < 2";
230: public static final String FILTER_OR = "ATTR1 > 10 OR ATTR2 < 2";
231: public static final String FILTER_OR_AND = "ATTR1 < 10 AND ATTR2 < 2 OR ATTR3 > 10";
232: public static final String FILTER_OR_AND_PARENTHESIS = "ATTR3 < 4 AND (ATTR1 > 10 OR ATTR2 < 2)";
233: public static final String FILTER_AND_NOT_AND = "ATTR3 < 4 AND (NOT( ATTR1 < 10 AND ATTR2 < 2))";
234: public static final String FILTER_AND_NOT_COMPARASION = "ATTR1 < 1 AND (NOT (ATTR2 < 2)) AND ATTR3 < 3";
235: public static final String FILTER_WITH_FUNCTION_ABS = "ATTR1 < abs(10)";
236: public static final String FILTER__WITH_FUNCTION_STR_CONCAT = "ATTR1 = strConcat(A, '1')";
237: public static final String LIKE_FILTER = "ATTR1 LIKE 'abc%'";
238: public static final String NOT_LIKE_FILTER = "ATTR1 NOT LIKE 'abc%'";
239: public static final String BETWEEN_FILTER = "ATTR1 BETWEEN 10 AND 20";
240: public static final String NOT_BETWEEN_FILTER = "ATTR1 NOT BETWEEN 10 AND 20";
241:
242: /** Catalog of samples */
243: public static Map SAMPLES = new HashMap();
244:
245: static {
246: // Samples initialization
247: {
248: Filter filter;
249:
250: // ---------------------------------------
251: filter = FACTORY.less(FACTORY.property("ATTR1"), FACTORY
252: .literal(1));
253: SAMPLES.put(LESS_FILTER_SAMPLE, filter);
254:
255: // ---------------------------------------
256: filter = FACTORY.lessOrEqual(FACTORY.property("ATTR1"),
257: FACTORY.literal(1));
258: SAMPLES.put(LESS_EQ_FILTER_SAMPLE, filter);
259:
260: // ---------------------------------------
261: filter = FACTORY.not(FACTORY.equals(FACTORY
262: .property("ATTR1"), FACTORY.literal(1)));
263: SAMPLES.put(NOT_EQ_FILTER, filter);
264:
265: // ---------------------------------------
266: filter = FACTORY.greater(FACTORY.property("ATTR1"), FACTORY
267: .divide(FACTORY.add(FACTORY.literal(1), FACTORY
268: .literal(2)), FACTORY.literal(3)));
269: SAMPLES.put(FILTER_WITH_PAREN_ROUNDTRIP_EXPR, filter);
270:
271: // ---------------------------------------
272: filter = FACTORY.greater(FACTORY.property("ATTR1"), FACTORY
273: .divide(FACTORY.add(FACTORY.literal(1), FACTORY
274: .literal(2)), FACTORY.literal(3)));
275: SAMPLES.put(FILTER_WITH_BRACKET_ROUNDTRIP_EXPR, filter);
276:
277: // ---------------------------------------
278: // ATTR1 < (1 + ((2 / 3) * 4))
279: filter = FACTORY.less(FACTORY.property("ATTR1"), FACTORY
280: .add(FACTORY.literal(1), FACTORY.multiply(FACTORY
281: .divide(FACTORY.literal(2), FACTORY
282: .literal(3)), FACTORY.literal(4))));
283: SAMPLES.put(FILTER_WITH_NESTED_PAREN_EXPR, filter);
284: // ---------------------------------------
285: filter = FACTORY.greater(FACTORY.property("ATTR1"), FACTORY
286: .add(FACTORY.literal(1), FACTORY.literal(2)));
287: SAMPLES.put(FILTER_SIMPLE_EXPR, filter);
288: }
289:
290: {
291: // ---------------------------------------
292: // ATTR1 IS NULL
293: Filter nullFilter = FACTORY.isNull(FACTORY
294: .property("ATTR1"));
295:
296: SAMPLES.put(PROPERTY_IS_NULL, nullFilter);
297:
298: // ---------------------------------------
299: // ATTR1 IS NOT NULL
300: Filter notNullFilter = FACTORY.not(FACTORY.isNull(FACTORY
301: .property("ATTR1")));
302:
303: SAMPLES.put(PROPERTY_IS_NOT_NULL, notNullFilter);
304: }
305:
306: {
307: // ---------------------------------------
308: // Result filter for BEFORE tests
309: Filter beforeFilter = null;
310:
311: try {
312: Date dateTime = DATE_TIME_FORMATTER.parse(FIRST_DATE);
313: beforeFilter = FACTORY.less(FACTORY.property("ATTR1"),
314: FACTORY.literal(dateTime));
315: } catch (ParseException e) {
316: e.printStackTrace();
317: }
318:
319: // ATTR1 BEFORE 2006-12-31T01:30:00Z
320: SAMPLES.put(FILTER_BEFORE_DATE, beforeFilter);
321:
322: // ATTR1 BEFORE 2006-11-30T01:30:00Z/2006-12-30T01:30:00Z
323: SAMPLES.put(FILTER_BEFORE_PERIOD_BETWEEN_DATES,
324: beforeFilter);
325:
326: // "ATTR1 BEFORE 2006-11-31T01:30:00Z/P30D"
327: SAMPLES.put(FILTER_BEFORE_PERIOD_DATE_AND_DAYS,
328: beforeFilter);
329:
330: // "ATTR1 BEFORE 2006-11-31T01:30:00Z/P1Y"
331: SAMPLES.put(FILTER_BEFORE_PERIOD_DATE_AND_YEARS,
332: beforeFilter);
333:
334: // "ATTR1 BEFORE 2006-11-31T01:30:00Z/P12M"
335: SAMPLES.put(FILTER_BEFORE_PERIOD_DATE_AND_MONTHS,
336: beforeFilter);
337:
338: {
339: // create during whith period during and date
340: Filter duringFilter = null;
341:
342: Date lastDate = null;
343:
344: try {
345: lastDate = DATE_TIME_FORMATTER.parse(LAST_DATE);
346:
347: Date firstDate = subtractDuration(lastDate);
348:
349: // creates an And filter firstDate <= prop <= lastDate
350: final String propName = "ATTR1";
351:
352: duringFilter = FACTORY.less(FACTORY
353: .property(propName), FACTORY
354: .literal(firstDate));
355:
356: SAMPLES.put(FILTER_BEFORE_PERIOD_YMD_HMS_DATE,
357: duringFilter);
358: } catch (ParseException e) {
359: e.printStackTrace();
360: }
361: }
362: }
363:
364: {
365: // ---------------------------------------
366: // Result filter for AFTER tests
367: Filter afterFilter = null;
368:
369: try {
370: Date dateTime = DATE_TIME_FORMATTER.parse(LAST_DATE);
371: afterFilter = FACTORY.greater(
372: FACTORY.property("ATTR1"), FACTORY
373: .literal(dateTime));
374: } catch (ParseException e) {
375: e.printStackTrace();
376: }
377:
378: SAMPLES.put(FILTER_AFTER_DATE, afterFilter);
379:
380: SAMPLES.put(FILTER_AFTER_PERIOD_BETWEEN_DATES, afterFilter);
381:
382: // sample for period with date and duration
383: try {
384: Date lastDate;
385:
386: Date firstDate = DATE_TIME_FORMATTER.parse(FIRST_DATE);
387:
388: // Days
389: CALENDAR.setTime(firstDate);
390:
391: int days = Integer.parseInt(DURATION_DATE);
392: CALENDAR.add(Calendar.DATE, days);
393: lastDate = CALENDAR.getTime();
394:
395: afterFilter = FACTORY.greater(
396: FACTORY.property("ATTR1"), FACTORY
397: .literal(lastDate));
398:
399: SAMPLES.put(FILTER_AFTER_PERIOD_DATE_DAYS, afterFilter);
400:
401: // Years
402: int years = Integer.parseInt(DURATION_DATE);
403: CALENDAR.setTime(firstDate);
404: CALENDAR.add(Calendar.YEAR, years);
405: lastDate = CALENDAR.getTime();
406: afterFilter = FACTORY.greater(
407: FACTORY.property("ATTR1"), FACTORY
408: .literal(lastDate));
409:
410: SAMPLES
411: .put(FILTER_AFTER_PERIOD_DATE_YEARS,
412: afterFilter);
413:
414: // Months
415: CALENDAR.setTime(firstDate);
416:
417: int months = Integer.parseInt(DURATION_DATE);
418: CALENDAR.add(Calendar.MONTH, months);
419: lastDate = CALENDAR.getTime();
420: afterFilter = FACTORY.greater(
421: FACTORY.property("ATTR1"), FACTORY
422: .literal(lastDate));
423:
424: SAMPLES
425: .put(FILTER_AFTER_PERIOD_DATE_MONTH,
426: afterFilter);
427:
428: // years and months
429: CALENDAR.setTime(firstDate);
430:
431: int duration = Integer.parseInt(DURATION_DATE);
432:
433: CALENDAR.add(Calendar.YEAR, duration);
434: CALENDAR.add(Calendar.MONTH, duration);
435: lastDate = CALENDAR.getTime();
436: afterFilter = FACTORY.greater(
437: FACTORY.property("ATTR1"), FACTORY
438: .literal(lastDate));
439:
440: SAMPLES.put(FILTER_AFTER_PERIOD_DATE_YEARS_MONTH,
441: afterFilter);
442:
443: // date and duration hours
444: CALENDAR.setTime(firstDate);
445:
446: int hours = Integer.parseInt(DURATION_TIME);
447: CALENDAR.add(Calendar.HOUR, hours);
448: lastDate = CALENDAR.getTime();
449:
450: afterFilter = FACTORY.greater(
451: FACTORY.property("ATTR1"), FACTORY
452: .literal(lastDate));
453:
454: SAMPLES
455: .put(FILTER_AFTER_PERIOD_DATE_HOURS,
456: afterFilter);
457:
458: // date and duration minutes
459: CALENDAR.setTime(firstDate);
460:
461: int minutes = Integer.parseInt(DURATION_TIME);
462: CALENDAR.add(Calendar.MINUTE, minutes);
463: lastDate = CALENDAR.getTime();
464:
465: afterFilter = FACTORY.greater(
466: FACTORY.property("ATTR1"), FACTORY
467: .literal(lastDate));
468:
469: SAMPLES.put(FILTER_AFTER_PERIOD_DATE_MINUTES,
470: afterFilter);
471:
472: // date and duration seconds
473: CALENDAR.setTime(firstDate);
474:
475: int seconds = Integer.parseInt(DURATION_TIME);
476: CALENDAR.add(Calendar.SECOND, seconds);
477: lastDate = CALENDAR.getTime();
478:
479: afterFilter = FACTORY.greater(
480: FACTORY.property("ATTR1"), FACTORY
481: .literal(lastDate));
482:
483: SAMPLES.put(FILTER_AFTER_PERIOD_DATE_SECONDS,
484: afterFilter);
485:
486: // date and duration YMD_HMS
487: lastDate = addDuration(firstDate);
488:
489: afterFilter = FACTORY.greater(
490: FACTORY.property("ATTR1"), FACTORY
491: .literal(lastDate));
492:
493: SAMPLES.put(FILTER_AFTER_PERIOD_DATE_YMD_HMS,
494: afterFilter);
495: } catch (ParseException e) {
496: e.printStackTrace();
497: }
498: }
499:
500: // ---------------------------------------
501: // Result filter for DURING tests
502: try {
503: // During with period between dates
504: Filter duringFilter = null;
505:
506: final Date firstDate = DATE_TIME_FORMATTER
507: .parse(FIRST_DATE);
508: final Date lastDate = DATE_TIME_FORMATTER.parse(LAST_DATE);
509: final String propName = "ATTR1";
510:
511: duringFilter = FACTORY.and(FACTORY.lessOrEqual(FACTORY
512: .literal(firstDate), FACTORY.property(propName)),
513: FACTORY.lessOrEqual(FACTORY.property(propName),
514: FACTORY.literal(lastDate)));
515:
516: SAMPLES.put(FILTER_DURING_PERIOD_BETWEEN_DATES,
517: duringFilter);
518: } catch (ParseException e) {
519: e.printStackTrace();
520: }
521:
522: try {
523: // creates during with period between date and duration
524: {
525: Filter duringFilter = null;
526:
527: final Date firstDate = DATE_TIME_FORMATTER
528: .parse(FIRST_DATE);
529:
530: // date and duration YMD_HMS
531: Date lastDate = addDuration(firstDate);
532:
533: // creates an And filter firstDate <= prop <= lastDate
534: final String propName = "ATTR1";
535:
536: duringFilter = FACTORY.and(FACTORY
537: .lessOrEqual(FACTORY.literal(firstDate),
538: FACTORY.property(propName)), FACTORY
539: .lessOrEqual(FACTORY.property(propName),
540: FACTORY.literal(lastDate)));
541:
542: SAMPLES.put(FILTER_DURING_PERIOD_DATE_YMD_HMS,
543: duringFilter);
544: }
545:
546: {
547: // create during whith period during and date
548: Filter duringFilter = null;
549:
550: final Date lastDate = DATE_TIME_FORMATTER
551: .parse(LAST_DATE);
552:
553: Date firstDate = subtractDuration(lastDate);
554:
555: // creates an And filter firstDate <= prop <= lastDate
556: final String propName = "ATTR1";
557:
558: duringFilter = FACTORY.and(FACTORY
559: .lessOrEqual(FACTORY.literal(firstDate),
560: FACTORY.property(propName)), FACTORY
561: .lessOrEqual(FACTORY.property(propName),
562: FACTORY.literal(lastDate)));
563:
564: SAMPLES.put(FILTER_DURING_PERIOD_YMD_HMS_DATE,
565: duringFilter);
566: }
567: } catch (Exception e) {
568: e.printStackTrace();
569: }
570:
571: // ------------------------------------------------
572: // result filter for Before or During test
573: try {
574: Filter filter = null;
575:
576: final Date lastDate = DATE_TIME_FORMATTER.parse(LAST_DATE);
577: final String propName = "ATTR1";
578:
579: filter = FACTORY.lessOrEqual(FACTORY.property(propName),
580: FACTORY.literal(lastDate));
581: SAMPLES.put(FILTER_BEFORE_OR_DURING_PERIOD_BETWEEN_DATES,
582: filter);
583: } catch (ParseException e) {
584: e.printStackTrace();
585: }
586:
587: try {
588: Filter filter = null;
589:
590: final Date lastDate = DATE_TIME_FORMATTER.parse(LAST_DATE);
591:
592: // creates a filter prop <= lastDate
593: final String propName = "ATTR1";
594:
595: filter = FACTORY.lessOrEqual(FACTORY.property(propName),
596: FACTORY.literal(lastDate));
597:
598: SAMPLES.put(FILTER_BEFORE_OR_DURING_PERIOD_YMD_HMS_DATE,
599: filter);
600: } catch (ParseException e) {
601: e.printStackTrace();
602: }
603:
604: try {
605: Filter filter = null;
606:
607: final Date firstDate = DATE_TIME_FORMATTER
608: .parse(FIRST_DATE);
609:
610: Date lastDate = addDuration(firstDate);
611:
612: // creates a filter prop <= lastDate
613: final String propName = "ATTR1";
614:
615: filter = FACTORY.lessOrEqual(FACTORY.property(propName),
616: FACTORY.literal(lastDate));
617:
618: SAMPLES.put(FILTER_BEFORE_OR_DURING_PERIOD_DATE_YMD_HMS,
619: filter);
620: } catch (ParseException e) {
621: e.printStackTrace();
622: }
623:
624: // ---------------------------------------
625: // DURING OR AFTER samples
626: try {
627: // period: first date / last date
628: Filter filter = null;
629:
630: final Date firstDate = DATE_TIME_FORMATTER
631: .parse(FIRST_DATE);
632: final String propName = "ATTR1";
633:
634: filter = FACTORY.greaterOrEqual(FACTORY.property(propName),
635: FACTORY.literal(firstDate));
636: SAMPLES.put(FILTER_DURING_OR_AFTER_PERIOD_BETWEEN_DATES,
637: filter);
638: } catch (ParseException e) {
639: e.printStackTrace();
640: }
641:
642: try {
643: // period: duration / last date
644: Filter filter = null;
645:
646: final Date lastDate = DATE_TIME_FORMATTER.parse(LAST_DATE);
647: Date firstDate = subtractDuration(lastDate);
648:
649: final String propName = "ATTR1";
650:
651: filter = FACTORY.greaterOrEqual(FACTORY.property(propName),
652: FACTORY.literal(firstDate));
653: SAMPLES.put(FILTER_DURING_OR_AFTER_PERIOD_YMD_HMS_DATE,
654: filter);
655: } catch (ParseException e) {
656: e.printStackTrace();
657: }
658:
659: try {
660: // period: first date / duration
661: Filter filter = null;
662:
663: final Date firstDate = DATE_TIME_FORMATTER
664: .parse(FIRST_DATE);
665:
666: final String propName = "ATTR1";
667:
668: filter = FACTORY.greaterOrEqual(FACTORY.property(propName),
669: FACTORY.literal(firstDate));
670: SAMPLES.put(FILTER_DURING_OR_AFTER_PERIOD_DATE_YMD_HMS,
671: filter);
672: } catch (ParseException e) {
673: e.printStackTrace();
674: }
675:
676: // ---------------------------------------
677: // Existence predicate samples
678: try {
679: // EXISTS sample
680: Expression[] args = new Expression[1];
681: args[0] = FACTORY.literal("ATTR1");
682:
683: Function function = FACTORY
684: .function("PropertyExists", args);
685: Literal literalTrue = FACTORY.literal(Boolean.TRUE);
686:
687: PropertyIsEqualTo propExists = FACTORY.equals(function,
688: literalTrue);
689:
690: SAMPLES.put(ATTRIBUTE_NAME_EXISTS, propExists);
691:
692: // DOES NOT EXIST sample
693: Not notEq = FACTORY.not(propExists);
694: SAMPLES.put(ATTRIBUTE_NAME_DOES_NOT_EXIST, notEq);
695: } catch (Exception e) {
696: e.printStackTrace();
697: }
698:
699: // ---------------------------------------
700: // boolean value expression
701: try {
702: PropertyName attr1 = FACTORY.property("ATTR1");
703: PropertyName attr2 = FACTORY.property("ATTR2");
704: PropertyName attr3 = FACTORY.property("ATTR3");
705:
706: // "ATT1 < 10 AND ATT2 < 2";
707: And andFilter = FACTORY.and(FACTORY.less(attr1, FACTORY
708: .literal(10)), FACTORY.less(attr2, FACTORY
709: .literal(2)));
710:
711: SAMPLES.put(FILTER_AND, andFilter);
712:
713: // "ATT1 > 10 OR ATT2 < 2";
714: Or orFilter = FACTORY.or(FACTORY.greater(attr1, FACTORY
715: .literal(10)), FACTORY.less(attr2, FACTORY
716: .literal(2)));
717:
718: SAMPLES.put(FILTER_OR, orFilter);
719:
720: // ATTR1 < 10 AND ATTR2 < 2 OR ATTR3 > 10
721: Or orAndFilter = FACTORY.or(andFilter, FACTORY.greater(
722: attr3, FACTORY.literal(10)));
723:
724: SAMPLES.put(FILTER_OR_AND, orAndFilter);
725:
726: // ATTR3 < 4 AND (ATTR1 > 10 OR ATTR2 < 2)
727: And parenthesisFilter = FACTORY.and(FACTORY.less(attr3,
728: FACTORY.literal(4)), orFilter);
729:
730: SAMPLES.put(FILTER_OR_AND_PARENTHESIS, parenthesisFilter);
731:
732: // ATTR3 < 4 AND (NOT( ATTR1 < 10 AND ATTR2 < 2))
733: And andNotAnd = FACTORY.and(FACTORY.less(attr3, FACTORY
734: .literal(4)), FACTORY.not(FACTORY.and(FACTORY.less(
735: attr1, FACTORY.literal(10)), FACTORY.less(attr2,
736: FACTORY.literal(2)))));
737:
738: SAMPLES.put(FILTER_AND_NOT_AND, andNotAnd);
739:
740: // ATTR1 < 1 AND (NOT (ATTR2 < 2)) AND ATTR3 < 3
741: And andNotComparasion = FACTORY.and(FACTORY.and(FACTORY
742: .less(attr1, FACTORY.literal(1)), FACTORY
743: .not(FACTORY.less(attr2, FACTORY.literal(2)))),
744: FACTORY.less(attr3, FACTORY.literal(3)));
745:
746: SAMPLES.put(FILTER_AND_NOT_COMPARASION, andNotComparasion);
747: } catch (Exception e) {
748: e.printStackTrace();
749: }
750:
751: // Unary Expression sampel
752: try {
753: // User defined Function Sample
754: Expression[] absArgs = new Expression[1];
755: absArgs[0] = FACTORY.literal(10);
756: Function abs = FACTORY.function("abs", absArgs);
757:
758: PropertyIsLessThan lessFilter = FACTORY.less(FACTORY
759: .property("ATTR1"), abs);
760:
761: SAMPLES.put(FILTER_WITH_FUNCTION_ABS, lessFilter);
762:
763: // builds ATTR1 = strConcat(A, '1')
764: Expression[] strConcatArgs = new Expression[2];
765: strConcatArgs[0] = FACTORY.literal("A");
766: strConcatArgs[1] = FACTORY.literal("1");
767: Function strConcat = FACTORY.function("strConcat",
768: strConcatArgs);
769:
770: PropertyIsEqualTo eqFilter = FACTORY.equals(FACTORY
771: .property("ATTR1"), strConcat);
772:
773: SAMPLES.put(FILTER__WITH_FUNCTION_STR_CONCAT, eqFilter);
774:
775: } catch (Exception e) {
776: e.printStackTrace();
777: }
778:
779: // Like filter
780: try {
781: final String WC_MULTI = "%";
782: final String WC_SINGLE = "_";
783: final String ESCAPE = "\\";
784:
785: PropertyName property = FACTORY.property("ATTR1");
786:
787: PropertyIsLike likeFilter = FACTORY.like(property, "abc"
788: + WC_MULTI, WC_MULTI, WC_SINGLE, ESCAPE);
789:
790: SAMPLES.put(LIKE_FILTER, likeFilter);
791:
792: Not notLikeFileter = FACTORY.not(likeFilter);
793: SAMPLES.put(NOT_LIKE_FILTER, notLikeFileter);
794: } catch (Exception e) {
795: e.printStackTrace();
796: }
797:
798: // bettween filter
799: try {
800: PropertyName property = FACTORY.property("ATTR1");
801: Literal inf = FACTORY.literal(10);
802: Literal sup = FACTORY.literal(20);
803:
804: PropertyIsBetween betweenFilter = FACTORY.between(property,
805: inf, sup);
806:
807: SAMPLES.put(BETWEEN_FILTER, betweenFilter);
808:
809: Not notBetweenFileter = FACTORY.not(betweenFilter);
810: SAMPLES.put(NOT_BETWEEN_FILTER, notBetweenFileter);
811: } catch (Exception e) {
812: e.printStackTrace();
813: }
814: } // end static initialization
815:
816: protected FilterSample() {
817: // factory class
818: }
819:
820: /**
821: * Add duration to date
822: *
823: * @param firstDate
824: * @return
825: * @throws NumberFormatException
826: */
827: private static Date addDuration(final Date date) {
828: CALENDAR.setTime(date);
829:
830: int durDate = Integer.parseInt(DURATION_DATE);
831: CALENDAR.add(Calendar.YEAR, durDate);
832: CALENDAR.add(Calendar.MONTH, durDate);
833: CALENDAR.add(Calendar.DATE, durDate);
834:
835: int durTime = Integer.parseInt(DURATION_TIME);
836: CALENDAR.add(Calendar.HOUR, durTime);
837: CALENDAR.add(Calendar.MINUTE, durTime);
838: CALENDAR.add(Calendar.SECOND, durTime);
839:
840: Date lastDate = CALENDAR.getTime();
841:
842: return lastDate;
843: }
844:
845: /**
846: * Substract duration to date
847: *
848: * @param lastDate
849: * a Date
850: * @return Date
851: */
852: private static Date subtractDuration(final Date lastDate) {
853: CALENDAR.setTime(lastDate);
854:
855: int durDate = -1 * Integer.parseInt(DURATION_DATE);
856: CALENDAR.add(Calendar.YEAR, durDate);
857: CALENDAR.add(Calendar.MONTH, durDate);
858: CALENDAR.add(Calendar.DATE, durDate);
859:
860: int durTime = -1 * Integer.parseInt(DURATION_TIME);
861: CALENDAR.add(Calendar.HOUR, durTime);
862: CALENDAR.add(Calendar.MINUTE, durTime);
863: CALENDAR.add(Calendar.SECOND, durTime);
864:
865: Date firstDate = CALENDAR.getTime();
866:
867: return firstDate;
868: }
869:
870: public static Filter getSample(final String sampleRequested) {
871: Filter sample = (Filter) SAMPLES.get(sampleRequested);
872:
873: if (sample == null) {
874: throw new IllegalArgumentException(
875: "There is not a sample for " + sampleRequested);
876: }
877:
878: return sample;
879: }
880:
881: }
|