001    /**
002     * Copyright (c) 2000-present 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.kernel.search.generic;
016    
017    import com.liferay.portal.kernel.search.BaseBooleanQueryImpl;
018    import com.liferay.portal.kernel.search.BooleanClause;
019    import com.liferay.portal.kernel.search.BooleanClauseOccur;
020    import com.liferay.portal.kernel.search.BooleanClauseOccurImpl;
021    import com.liferay.portal.kernel.search.Query;
022    import com.liferay.portal.kernel.search.TermRangeQuery;
023    import com.liferay.portal.kernel.search.query.FieldQueryFactoryUtil;
024    import com.liferay.portal.kernel.search.query.QueryVisitor;
025    
026    import java.util.ArrayList;
027    import java.util.Collection;
028    import java.util.Collections;
029    import java.util.List;
030    
031    /**
032     * @author Michael C. Han
033     * @author Hugo Huijser
034     */
035    public class BooleanQueryImpl extends BaseBooleanQueryImpl {
036    
037            @Override
038            public <T> T accept(QueryVisitor<T> queryVisitor) {
039                    return queryVisitor.visitQuery(this);
040            }
041    
042            @Override
043            public Query add(Query query, BooleanClauseOccur booleanClauseOccur) {
044                    if (query == null) {
045                            throw new IllegalArgumentException("Query is null");
046                    }
047    
048                    _booleanClauses.add(new BooleanClauseImpl<>(query, booleanClauseOccur));
049    
050                    return query;
051            }
052    
053            @Override
054            public Query add(Query query, String occur) {
055                    BooleanClauseOccur booleanClauseOccur = new BooleanClauseOccurImpl(
056                            occur);
057    
058                    add(query, booleanClauseOccur);
059    
060                    return query;
061            }
062    
063            @Override
064            public Query addExactTerm(String field, boolean value) {
065                    return addExactTerm(field, String.valueOf(value));
066            }
067    
068            @Override
069            public Query addExactTerm(String field, Boolean value) {
070                    return addExactTerm(field, String.valueOf(value));
071            }
072    
073            @Override
074            public Query addExactTerm(String field, double value) {
075                    return addExactTerm(field, String.valueOf(value));
076            }
077    
078            @Override
079            public Query addExactTerm(String field, Double value) {
080                    return addExactTerm(field, String.valueOf(value));
081            }
082    
083            @Override
084            public Query addExactTerm(String field, int value) {
085                    return addExactTerm(field, String.valueOf(value));
086            }
087    
088            @Override
089            public Query addExactTerm(String field, Integer value) {
090                    return addExactTerm(field, String.valueOf(value));
091            }
092    
093            @Override
094            public Query addExactTerm(String field, long value) {
095                    return addExactTerm(field, String.valueOf(value));
096            }
097    
098            @Override
099            public Query addExactTerm(String field, Long value) {
100                    return addExactTerm(field, String.valueOf(value));
101            }
102    
103            @Override
104            public Query addExactTerm(String field, short value) {
105                    return addExactTerm(field, String.valueOf(value));
106            }
107    
108            @Override
109            public Query addExactTerm(String field, Short value) {
110                    return addExactTerm(field, String.valueOf(value));
111            }
112    
113            @Override
114            public Query addExactTerm(String field, String value) {
115                    TermQueryImpl termQuery = new TermQueryImpl(
116                            new QueryTermImpl(field, String.valueOf(value)));
117    
118                    return add(termQuery, BooleanClauseOccur.SHOULD);
119            }
120    
121            @Override
122            public Collection<Query> addNumericRangeTerm(
123                    String field, int startValue, int endValue) {
124    
125                    List<Query> queries = new ArrayList<>();
126    
127                    for (int i = startValue; i <= endValue; i++) {
128                            Query query = addExactTerm(field, i);
129    
130                            queries.add(query);
131                    }
132    
133                    return queries;
134            }
135    
136            @Override
137            public Collection<Query> addNumericRangeTerm(
138                    String field, Integer startValue, Integer endValue) {
139    
140                    return addNumericRangeTerm(
141                            field, startValue.intValue(), endValue.intValue());
142            }
143    
144            @Override
145            public Collection<Query> addNumericRangeTerm(
146                    String field, long startValue, long endValue) {
147    
148                    List<Query> queries = new ArrayList<>();
149    
150                    for (long i = startValue; i <= endValue; i++) {
151                            Query query = addExactTerm(field, i);
152    
153                            queries.add(query);
154                    }
155    
156                    return queries;
157            }
158    
159            @Override
160            public Collection<Query> addNumericRangeTerm(
161                    String field, Long startValue, Long endValue) {
162    
163                    return addNumericRangeTerm(
164                            field, startValue.longValue(), endValue.longValue());
165            }
166    
167            @Override
168            public Collection<Query> addNumericRangeTerm(
169                    String field, short startValue, short endValue) {
170    
171                    List<Query> queries = new ArrayList<>();
172    
173                    for (short i = startValue; i <= endValue; i++) {
174                            Query query = addExactTerm(field, i);
175    
176                            queries.add(query);
177                    }
178    
179                    return queries;
180            }
181    
182            @Override
183            public Collection<Query> addNumericRangeTerm(
184                    String field, Short startValue, Short endValue) {
185    
186                    return addNumericRangeTerm(
187                            field, startValue.shortValue(), endValue.shortValue());
188            }
189    
190            @Override
191            public Query addRangeTerm(String field, int startValue, int endValue) {
192                    TermRangeQuery termRangeQuery = new TermRangeQueryImpl(
193                            field, String.valueOf(startValue), String.valueOf(endValue), true,
194                            true);
195    
196                    return add(termRangeQuery, BooleanClauseOccur.SHOULD);
197            }
198    
199            @Override
200            public Query addRangeTerm(
201                    String field, Integer startValue, Integer endValue) {
202    
203                    return addRangeTerm(field, startValue.intValue(), endValue.intValue());
204            }
205    
206            @Override
207            public Query addRangeTerm(String field, long startValue, long endValue) {
208                    TermRangeQuery termRangeQuery = new TermRangeQueryImpl(
209                            field, String.valueOf(startValue), String.valueOf(endValue), true,
210                            true);
211    
212                    return add(termRangeQuery, BooleanClauseOccur.SHOULD);
213            }
214    
215            @Override
216            public Query addRangeTerm(String field, Long startValue, Long endValue) {
217                    return addRangeTerm(
218                            field, startValue.longValue(), endValue.longValue());
219            }
220    
221            @Override
222            public Query addRangeTerm(String field, short startValue, short endValue) {
223                    TermRangeQuery termRangeQuery = new TermRangeQueryImpl(
224                            field, String.valueOf(startValue), String.valueOf(endValue), true,
225                            true);
226    
227                    return add(termRangeQuery, BooleanClauseOccur.SHOULD);
228            }
229    
230            @Override
231            public Query addRangeTerm(String field, Short startValue, Short endValue) {
232                    return addRangeTerm(
233                            field, startValue.shortValue(), endValue.shortValue());
234            }
235    
236            @Override
237            public Query addRangeTerm(
238                    String field, String startValue, String endValue) {
239    
240                    TermRangeQuery termRangeQuery = new TermRangeQueryImpl(
241                            field, startValue, endValue, true, true);
242    
243                    return add(termRangeQuery, BooleanClauseOccur.SHOULD);
244            }
245    
246            @Override
247            public Query addRequiredTerm(String field, boolean value) {
248                    return addRequiredTerm(field, String.valueOf(value), false);
249            }
250    
251            @Override
252            public Query addRequiredTerm(String field, Boolean value) {
253                    return addRequiredTerm(field, String.valueOf(value), false);
254            }
255    
256            @Override
257            public Query addRequiredTerm(String field, double value) {
258                    return addRequiredTerm(field, String.valueOf(value), false);
259            }
260    
261            @Override
262            public Query addRequiredTerm(String field, Double value) {
263                    return addRequiredTerm(field, String.valueOf(value), false);
264            }
265    
266            @Override
267            public Query addRequiredTerm(String field, int value) {
268                    return addRequiredTerm(field, String.valueOf(value), false);
269            }
270    
271            @Override
272            public Query addRequiredTerm(String field, Integer value) {
273                    return addRequiredTerm(field, String.valueOf(value), false);
274            }
275    
276            @Override
277            public Query addRequiredTerm(String field, long value) {
278                    return addRequiredTerm(field, String.valueOf(value), false);
279            }
280    
281            @Override
282            public Query addRequiredTerm(String field, Long value) {
283                    return addRequiredTerm(field, String.valueOf(value), false);
284            }
285    
286            @Override
287            public Query addRequiredTerm(String field, short value) {
288                    return addRequiredTerm(field, String.valueOf(value), false);
289            }
290    
291            @Override
292            public Query addRequiredTerm(String field, Short value) {
293                    return addRequiredTerm(field, String.valueOf(value), false);
294            }
295    
296            @Override
297            public Query addRequiredTerm(String field, String value) {
298                    return addRequiredTerm(field, value, false);
299            }
300    
301            @Override
302            public Query addRequiredTerm(String field, String value, boolean like) {
303                    return addRequiredTerm(field, value, like, false);
304            }
305    
306            public Query addRequiredTerm(
307                    String field, String value, boolean like, boolean parseKeywords) {
308    
309                    Query query = FieldQueryFactoryUtil.createQuery(
310                            field, value, like, parseKeywords);
311    
312                    return add(query, BooleanClauseOccur.MUST);
313            }
314    
315            @Override
316            public Query addTerm(String field, long value) {
317                    return addTerm(field, String.valueOf(value), false);
318            }
319    
320            @Override
321            public Query addTerm(String field, String value) {
322                    return addTerm(field, value, false);
323            }
324    
325            @Override
326            public Query addTerm(String field, String value, boolean like) {
327                    return addTerm(field, value, like, BooleanClauseOccur.SHOULD);
328            }
329    
330            public Query addTerm(
331                    String field, String value, boolean like, boolean parseKeywords) {
332    
333                    Query query = FieldQueryFactoryUtil.createQuery(
334                            field, value, like, parseKeywords);
335    
336                    return add(query, BooleanClauseOccur.SHOULD);
337            }
338    
339            @Override
340            public Query addTerm(
341                    String field, String value, boolean like,
342                    BooleanClauseOccur booleanClauseOccur) {
343    
344                    Query query = FieldQueryFactoryUtil.createQuery(
345                            field, value, like, false);
346    
347                    return add(query, booleanClauseOccur);
348            }
349    
350            @Override
351            public List<BooleanClause<Query>> clauses() {
352                    return Collections.unmodifiableList(_booleanClauses);
353            }
354    
355            @Override
356            public boolean hasChildren() {
357                    return hasClauses();
358            }
359    
360            @Override
361            public boolean hasClauses() {
362                    return !_booleanClauses.isEmpty();
363            }
364    
365            private final List<BooleanClause<Query>> _booleanClauses =
366                    new ArrayList<>();
367    
368    }