001    /**
002     * Copyright (c) 2000-2012 Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portal.search.generic;
016    
017    import com.liferay.portal.kernel.log.Log;
018    import com.liferay.portal.kernel.log.LogFactoryUtil;
019    import com.liferay.portal.kernel.search.BaseBooleanQueryImpl;
020    import com.liferay.portal.kernel.search.BooleanClause;
021    import com.liferay.portal.kernel.search.BooleanClauseOccur;
022    import com.liferay.portal.kernel.search.BooleanClauseOccurImpl;
023    import com.liferay.portal.kernel.search.BooleanQuery;
024    import com.liferay.portal.kernel.search.ParseException;
025    import com.liferay.portal.kernel.search.Query;
026    import com.liferay.portal.kernel.search.QueryTerm;
027    import com.liferay.portal.kernel.search.TermRangeQuery;
028    import com.liferay.portal.kernel.util.StringPool;
029    import com.liferay.portal.kernel.util.StringUtil;
030    
031    import java.util.ArrayList;
032    import java.util.Collections;
033    import java.util.List;
034    
035    /**
036     * @author Michael C. Han
037     * @author Hugo Huijser
038     */
039    public class BooleanQueryImpl extends BaseBooleanQueryImpl {
040    
041            public void add(Query query, BooleanClauseOccur booleanClauseOccur) {
042                    _booleanClauses.add(new BooleanClauseImpl(query, booleanClauseOccur));
043            }
044    
045            public void add(Query query, String occur) {
046                    BooleanClauseOccur booleanClauseOccur = new BooleanClauseOccurImpl(
047                            occur);
048    
049                    add(query, booleanClauseOccur);
050            }
051    
052            public void addExactTerm(String field, boolean value) {
053                    addExactTerm(field, String.valueOf(value));
054            }
055    
056            public void addExactTerm(String field, Boolean value) {
057                    addExactTerm(field, String.valueOf(value));
058            }
059    
060            public void addExactTerm(String field, double value) {
061                    addExactTerm(field, String.valueOf(value));
062            }
063    
064            public void addExactTerm(String field, Double value) {
065                    addExactTerm(field, String.valueOf(value));
066            }
067    
068            public void addExactTerm(String field, int value) {
069                    addExactTerm(field, String.valueOf(value));
070            }
071    
072            public void addExactTerm(String field, Integer value) {
073                    addExactTerm(field, String.valueOf(value));
074            }
075    
076            public void addExactTerm(String field, long value) {
077                    addExactTerm(field, String.valueOf(value));
078            }
079    
080            public void addExactTerm(String field, Long value) {
081                    addExactTerm(field, String.valueOf(value));
082            }
083    
084            public void addExactTerm(String field, short value) {
085                    addExactTerm(field, String.valueOf(value));
086            }
087    
088            public void addExactTerm(String field, Short value) {
089                    addExactTerm(field, String.valueOf(value));
090            }
091    
092            public void addExactTerm(String field, String value) {
093                    TermQueryImpl termQuery = new TermQueryImpl(
094                            new QueryTermImpl(field, String.valueOf(value)));
095    
096                    add(termQuery, BooleanClauseOccur.SHOULD);
097            }
098    
099            public void addNumericRangeTerm(
100                    String field, int startValue, int endValue) {
101    
102                    for (int i = startValue; i <= endValue; i++) {
103                            addExactTerm(field, i);
104                    }
105            }
106    
107            public void addNumericRangeTerm(
108                    String field, Integer startValue, Integer endValue) {
109    
110                    addNumericRangeTerm(field, startValue.intValue(), endValue.intValue());
111            }
112    
113            public void addNumericRangeTerm(
114                    String field, long startValue, long endValue) {
115    
116                    for (long i = startValue; i <= endValue; i++) {
117                            addExactTerm(field, i);
118                    }
119            }
120    
121            public void addNumericRangeTerm(
122                    String field, Long startValue, Long endValue) {
123    
124                    addNumericRangeTerm(
125                            field, startValue.longValue(), endValue.longValue());
126            }
127    
128            public void addNumericRangeTerm(
129                    String field, short startValue, short endValue) {
130    
131                    for (short i = startValue; i <= endValue; i++) {
132                            addExactTerm(field, i);
133                    }
134            }
135    
136            public void addNumericRangeTerm(
137                    String field, Short startValue, Short endValue) {
138    
139                    addNumericRangeTerm(
140                            field, startValue.shortValue(), endValue.shortValue());
141            }
142    
143            public void addRangeTerm(String field, int startValue, int endValue) {
144                    TermRangeQuery termRangeQuery = new TermRangeQueryImpl(
145                            field, String.valueOf(startValue), String.valueOf(endValue), true,
146                            true);
147    
148                    add(termRangeQuery, BooleanClauseOccur.SHOULD);
149            }
150    
151            public void addRangeTerm(
152                    String field, Integer startValue, Integer endValue) {
153    
154                    addRangeTerm(field, startValue.intValue(), endValue.intValue());
155            }
156    
157            public void addRangeTerm(String field, long startValue, long endValue) {
158                    TermRangeQuery termRangeQuery = new TermRangeQueryImpl(
159                            field, String.valueOf(startValue), String.valueOf(endValue), true,
160                            true);
161    
162                    add(termRangeQuery, BooleanClauseOccur.SHOULD);
163            }
164    
165            public void addRangeTerm(String field, Long startValue, Long endValue) {
166                    addRangeTerm(field, startValue.longValue(), endValue.longValue());
167            }
168    
169            public void addRangeTerm(String field, short startValue, short endValue) {
170                    TermRangeQuery termRangeQuery = new TermRangeQueryImpl(
171                            field, String.valueOf(startValue), String.valueOf(endValue), true,
172                            true);
173    
174                    add(termRangeQuery, BooleanClauseOccur.SHOULD);
175            }
176    
177            public void addRangeTerm(String field, Short startValue, Short endValue) {
178                    addRangeTerm(field, startValue.shortValue(), endValue.shortValue());
179            }
180    
181            public void addRangeTerm(String field, String startValue, String endValue) {
182                    TermRangeQuery termRangeQuery = new TermRangeQueryImpl(
183                            field, startValue, endValue, true, true);
184    
185                    add(termRangeQuery, BooleanClauseOccur.SHOULD);
186            }
187    
188            public void addRequiredTerm(String field, boolean value) {
189                    addRequiredTerm(field, String.valueOf(value), false);
190            }
191    
192            public void addRequiredTerm(String field, Boolean value) {
193                    addRequiredTerm(field, String.valueOf(value), false);
194            }
195    
196            public void addRequiredTerm(String field, double value) {
197                    addRequiredTerm(field, String.valueOf(value), false);
198            }
199    
200            public void addRequiredTerm(String field, Double value) {
201                    addRequiredTerm(field, String.valueOf(value), false);
202            }
203    
204            public void addRequiredTerm(String field, int value) {
205                    addRequiredTerm(field, String.valueOf(value), false);
206            }
207    
208            public void addRequiredTerm(String field, Integer value) {
209                    addRequiredTerm(field, String.valueOf(value), false);
210            }
211    
212            public void addRequiredTerm(String field, long value) {
213                    addRequiredTerm(field, String.valueOf(value), false);
214            }
215    
216            public void addRequiredTerm(String field, Long value) {
217                    addRequiredTerm(field, String.valueOf(value), false);
218            }
219    
220            public void addRequiredTerm(String field, short value) {
221                    addRequiredTerm(field, String.valueOf(value), false);
222            }
223    
224            public void addRequiredTerm(String field, Short value) {
225                    addRequiredTerm(field, String.valueOf(value), false);
226            }
227    
228            public void addRequiredTerm(String field, String value) {
229                    addRequiredTerm(field, value, false);
230            }
231    
232            public void addRequiredTerm(String field, String value, boolean like) {
233                    addRequiredTerm(field, value, like, false);
234            }
235    
236            public void addRequiredTerm(
237                    String field, String value, boolean like, boolean parseKeywords) {
238    
239                    if (like) {
240                            value = StringUtil.replace(
241                                    value, StringPool.PERCENT, StringPool.BLANK);
242                    }
243    
244                    String[] values = null;
245    
246                    if (parseKeywords) {
247                            values = parseKeywords(value);
248                    }
249                    else {
250                            values = new String[] {value};
251                    }
252    
253                    BooleanQuery booleanQuery = new BooleanQueryImpl();
254    
255                    for (String curValue : values) {
256                            QueryTerm queryTerm = new QueryTermImpl(
257                                    field, String.valueOf(curValue));
258    
259                            Query query = null;
260    
261                            if (like) {
262                                    query = new WildcardQueryImpl(queryTerm);
263                            }
264                            else {
265                                    query = new TermQueryImpl(queryTerm);
266                            }
267    
268                            try {
269                                    booleanQuery.add(query, BooleanClauseOccur.SHOULD);
270                            }
271                            catch (ParseException pe) {
272                                    if (_log.isDebugEnabled()) {
273                                            _log.debug("ParseException thrown, skipping query", pe);
274                                    }
275                            }
276                    }
277    
278                    add(booleanQuery, BooleanClauseOccur.MUST);
279            }
280    
281            public void addTerm(String field, long value) {
282                    addTerm(field, String.valueOf(value), false);
283            }
284    
285            public void addTerm(String field, String value) {
286                    addTerm(field, value, false);
287            }
288    
289            public void addTerm(String field, String value, boolean like) {
290                    addTerm(field, value, like, BooleanClauseOccur.SHOULD);
291            }
292    
293            public void addTerm(
294                    String field, String value, boolean like, boolean parseKeywords) {
295    
296                    if (like) {
297                            value = StringUtil.replace(
298                                    value, StringPool.PERCENT, StringPool.BLANK);
299                    }
300    
301                    if (parseKeywords) {
302                            String[] keywords = parseKeywords(value);
303    
304                            for (String keyword : keywords) {
305                                    addTerm(field, keyword, like);
306                            }
307                    }
308                    else {
309                            addTerm(field, value, like);
310                    }
311            }
312    
313            public void addTerm(
314                    String field, String value, boolean like,
315                    BooleanClauseOccur booleanClauseOccur) {
316    
317                    Query query = null;
318    
319                    if (like) {
320                            query = new WildcardQueryImpl(
321                                    new QueryTermImpl(field, String.valueOf(value)));
322                    }
323                    else {
324                            query = new TermQueryImpl(
325                                    new QueryTermImpl(field, String.valueOf(value)));
326                    }
327    
328                    add(query, booleanClauseOccur);
329            }
330    
331            public List<BooleanClause> clauses() {
332                    return Collections.unmodifiableList(_booleanClauses);
333            }
334    
335            @Override
336            public Object getWrappedQuery() {
337                    return this;
338            }
339    
340            public boolean hasClauses() {
341                    return !_booleanClauses.isEmpty();
342            }
343    
344            private static Log _log = LogFactoryUtil.getLog(BooleanQueryImpl.class);
345    
346            private List<BooleanClause> _booleanClauses =
347                    new ArrayList<BooleanClause>();
348    
349    }