001    /**
002     * Copyright (c) 2000-2013 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.lucene;
016    
017    import com.liferay.portal.kernel.cluster.Address;
018    import com.liferay.portal.kernel.exception.SystemException;
019    import com.liferay.portal.kernel.search.BooleanClauseOccur;
020    import com.liferay.portal.kernel.util.GetterUtil;
021    import com.liferay.portal.kernel.util.StringPool;
022    
023    import java.io.IOException;
024    import java.io.InputStream;
025    import java.io.OutputStream;
026    
027    import java.util.Date;
028    import java.util.Set;
029    
030    import org.apache.lucene.analysis.Analyzer;
031    import org.apache.lucene.document.Document;
032    import org.apache.lucene.index.Term;
033    import org.apache.lucene.search.BooleanQuery;
034    import org.apache.lucene.search.IndexSearcher;
035    import org.apache.lucene.search.Query;
036    import org.apache.lucene.search.highlight.Formatter;
037    import org.apache.lucene.search.highlight.SimpleHTMLFormatter;
038    import org.apache.lucene.util.Version;
039    
040    /**
041     * @author Brian Wing Shun Chan
042     * @author Harry Mark
043     * @author Bruno Farache
044     * @author Shuyang Zhou
045     * @author Andrea Di Giorgi
046     */
047    public class LuceneHelperUtil {
048    
049            public static void addDate(Document doc, String field, Date value) {
050                    doc.add(LuceneFields.getDate(field, value));
051            }
052    
053            public static void addDocument(long companyId, Document document)
054                    throws IOException {
055    
056                    getLuceneHelper().addDocument(companyId, document);
057            }
058    
059            public static void addExactTerm(
060                    BooleanQuery booleanQuery, String field, boolean value) {
061    
062                    addExactTerm(booleanQuery, field, String.valueOf(value));
063            }
064    
065            public static void addExactTerm(
066                    BooleanQuery booleanQuery, String field, double value) {
067    
068                    addExactTerm(booleanQuery, field, String.valueOf(value));
069            }
070    
071            public static void addExactTerm(
072                    BooleanQuery booleanQuery, String field, int value) {
073    
074                    addExactTerm(booleanQuery, field, String.valueOf(value));
075            }
076    
077            public static void addExactTerm(
078                    BooleanQuery booleanQuery, String field, long value) {
079    
080                    addExactTerm(booleanQuery, field, String.valueOf(value));
081            }
082    
083            public static void addExactTerm(
084                    BooleanQuery booleanQuery, String field, short value) {
085    
086                    addExactTerm(booleanQuery, field, String.valueOf(value));
087            }
088    
089            public static void addExactTerm(
090                    BooleanQuery booleanQuery, String field, String value) {
091    
092                    getLuceneHelper().addExactTerm(booleanQuery, field, value);
093            }
094    
095            public static void addNumericRangeTerm(
096                    BooleanQuery booleanQuery, String field, int startValue, int endValue) {
097    
098                    getLuceneHelper().addNumericRangeTerm(
099                            booleanQuery, field, startValue, endValue);
100            }
101    
102            public static void addNumericRangeTerm(
103                    BooleanQuery booleanQuery, String field, Integer startValue,
104                    Integer endValue) {
105    
106                    getLuceneHelper().addNumericRangeTerm(
107                            booleanQuery, field, startValue, endValue);
108            }
109    
110            public static void addNumericRangeTerm(
111                    BooleanQuery booleanQuery, String field, long startValue,
112                    long endValue) {
113    
114                    getLuceneHelper().addNumericRangeTerm(
115                            booleanQuery, field, startValue, endValue);
116            }
117    
118            public static void addNumericRangeTerm(
119                    BooleanQuery booleanQuery, String field, Long startValue,
120                    Long endValue) {
121    
122                    getLuceneHelper().addNumericRangeTerm(
123                            booleanQuery, field, startValue, endValue);
124            }
125    
126            public static void addNumericRangeTerm(
127                    BooleanQuery booleanQuery, String field, short startValue,
128                    short endValue) {
129    
130                    getLuceneHelper().addNumericRangeTerm(
131                            booleanQuery, field, (long)startValue, (long)endValue);
132            }
133    
134            public static void addNumericRangeTerm(
135                    BooleanQuery booleanQuery, String field, Short startValue,
136                    Short endValue) {
137    
138                    getLuceneHelper().addNumericRangeTerm(
139                            booleanQuery, field, GetterUtil.getLong(startValue),
140                            GetterUtil.getLong(endValue));
141            }
142    
143            public static void addRangeTerm(
144                    BooleanQuery booleanQuery, String field, int startValue, int endValue) {
145    
146                    getLuceneHelper().addRangeTerm(
147                            booleanQuery, field, String.valueOf(startValue),
148                            String.valueOf(endValue));
149            }
150    
151            public static void addRangeTerm(
152                    BooleanQuery booleanQuery, String field, Integer startValue,
153                    Integer endValue) {
154    
155                    getLuceneHelper().addRangeTerm(
156                            booleanQuery, field, String.valueOf(startValue),
157                            String.valueOf(endValue));
158            }
159    
160            public static void addRangeTerm(
161                    BooleanQuery booleanQuery, String field, long startValue,
162                    long endValue) {
163    
164                    getLuceneHelper().addRangeTerm(
165                            booleanQuery, field, String.valueOf(startValue),
166                            String.valueOf(endValue));
167            }
168    
169            public static void addRangeTerm(
170                    BooleanQuery booleanQuery, String field, Long startValue,
171                    Long endValue) {
172    
173                    getLuceneHelper().addRangeTerm(
174                            booleanQuery, field, String.valueOf(startValue),
175                            String.valueOf(endValue));
176            }
177    
178            public static void addRangeTerm(
179                    BooleanQuery booleanQuery, String field, short startValue,
180                    short endValue) {
181    
182                    getLuceneHelper().addRangeTerm(
183                            booleanQuery, field, String.valueOf(startValue),
184                            String.valueOf(endValue));
185            }
186    
187            public static void addRangeTerm(
188                    BooleanQuery booleanQuery, String field, Short startValue,
189                    Short endValue) {
190    
191                    getLuceneHelper().addRangeTerm(
192                            booleanQuery, field, String.valueOf(startValue),
193                            String.valueOf(endValue));
194            }
195    
196            public static void addRangeTerm(
197                    BooleanQuery booleanQuery, String field, String startValue,
198                    String endValue) {
199    
200                    getLuceneHelper().addRangeTerm(
201                            booleanQuery, field, startValue, endValue);
202            }
203    
204            public static void addRequiredTerm(
205                    BooleanQuery booleanQuery, String field, boolean value) {
206    
207                    addRequiredTerm(booleanQuery, field, String.valueOf(value));
208            }
209    
210            public static void addRequiredTerm(
211                    BooleanQuery booleanQuery, String field, double value) {
212    
213                    addRequiredTerm(booleanQuery, field, String.valueOf(value));
214            }
215    
216            public static void addRequiredTerm(
217                    BooleanQuery booleanQuery, String field, int value) {
218    
219                    addRequiredTerm(booleanQuery, field, String.valueOf(value));
220            }
221    
222            public static void addRequiredTerm(
223                    BooleanQuery booleanQuery, String field, long value) {
224    
225                    addRequiredTerm(booleanQuery, field, String.valueOf(value));
226            }
227    
228            public static void addRequiredTerm(
229                    BooleanQuery booleanQuery, String field, short value) {
230    
231                    addRequiredTerm(booleanQuery, field, String.valueOf(value));
232            }
233    
234            public static void addRequiredTerm(
235                    BooleanQuery booleanQuery, String field, String value) {
236    
237                    addRequiredTerm(booleanQuery, field, value, false);
238            }
239    
240            public static void addRequiredTerm(
241                    BooleanQuery booleanQuery, String field, String value, boolean like) {
242    
243                    getLuceneHelper().addRequiredTerm(booleanQuery, field, value, like);
244            }
245    
246            public static void addRequiredTerm(
247                    BooleanQuery booleanQuery, String field, String[] values,
248                    boolean like) {
249    
250                    getLuceneHelper().addRequiredTerm(booleanQuery, field, values, like);
251            }
252    
253            public static void addTerm(
254                    BooleanQuery booleanQuery, String field, long value) {
255    
256                    addTerm(booleanQuery, field, String.valueOf(value));
257            }
258    
259            public static void addTerm(
260                    BooleanQuery booleanQuery, String field, String value) {
261    
262                    addTerm(booleanQuery, field, value, false);
263            }
264    
265            public static void addTerm(
266                    BooleanQuery booleanQuery, String field, String value, boolean like) {
267    
268                    getLuceneHelper().addTerm(booleanQuery, field, value, like);
269            }
270    
271            public static void addTerm(
272                    BooleanQuery booleanQuery, String field, String value, boolean like,
273                    BooleanClauseOccur booleanClauseOccur) {
274    
275                    getLuceneHelper().addTerm(
276                            booleanQuery, field, value, like, booleanClauseOccur);
277            }
278    
279            public static void addTerm(
280                    BooleanQuery booleanQuery, String field, String[] values,
281                    boolean like) {
282    
283                    getLuceneHelper().addTerm(booleanQuery, field, values, like);
284            }
285    
286            /**
287             * @deprecated As of 7.0.0, replaced by {@link #releaseIndexSearcher(long,
288             *             IndexSearcher)}
289             */
290            @Deprecated
291            public static void cleanUp(IndexSearcher indexSearcher) {
292                    getLuceneHelper().cleanUp(indexSearcher);
293            }
294    
295            public static int countScoredFieldNames(Query query, String[] fieldNames) {
296                    return getLuceneHelper().countScoredFieldNames(query, fieldNames);
297            }
298    
299            public static void delete(long companyId) {
300                    getLuceneHelper().delete(companyId);
301            }
302    
303            public static void deleteDocuments(long companyId, Term term)
304                    throws IOException {
305    
306                    getLuceneHelper().deleteDocuments(companyId, term);
307            }
308    
309            public static void dumpIndex(long companyId, OutputStream outputStream)
310                    throws IOException {
311    
312                    getLuceneHelper().dumpIndex(companyId, outputStream);
313            }
314    
315            public static Analyzer getAnalyzer() {
316                    return getLuceneHelper().getAnalyzer();
317            }
318    
319            public static IndexAccessor getIndexAccessor(long companyId) {
320                    return getLuceneHelper().getIndexAccessor(companyId);
321            }
322    
323            public static IndexSearcher getIndexSearcher(long companyId)
324                    throws IOException {
325    
326                    return getLuceneHelper().getIndexSearcher(companyId);
327            }
328    
329            public static long getLastGeneration(long companyId) {
330                    return getLuceneHelper().getLastGeneration(companyId);
331            }
332    
333            public static InputStream getLoadIndexesInputStreamFromCluster(
334                            long companyId, Address bootupAddress)
335                    throws SystemException {
336    
337                    return getLuceneHelper().getLoadIndexesInputStreamFromCluster(
338                            companyId, bootupAddress);
339            }
340    
341            public static LuceneHelper getLuceneHelper() {
342                    return _luceneHelper;
343            }
344    
345            public static Set<String> getQueryTerms(Query query) {
346                    return getLuceneHelper().getQueryTerms(query);
347            }
348    
349            /**
350             * @deprecated As of 7.0.0, replaced by {@link #getIndexSearcher(long)}
351             */
352            @Deprecated
353            public static IndexSearcher getSearcher(long companyId, boolean readOnly)
354                    throws IOException {
355    
356                    return getLuceneHelper().getSearcher(companyId, readOnly);
357            }
358    
359            public static String getSnippet(Query query, String field, String s)
360                    throws IOException {
361    
362                    Formatter formatter = new SimpleHTMLFormatter(
363                            StringPool.BLANK, StringPool.BLANK);
364    
365                    return getSnippet(query, field, s, formatter);
366            }
367    
368            public static String getSnippet(
369                            Query query, String field, String s, Formatter formatter)
370                    throws IOException {
371    
372                    return getSnippet(query, field, s, 3, 80, "...", formatter);
373            }
374    
375            public static String getSnippet(
376                            Query query, String field, String s, int maxNumFragments,
377                            int fragmentLength, String fragmentSuffix, Formatter formatter)
378                    throws IOException {
379    
380                    return getLuceneHelper().getSnippet(
381                            query, field, s, maxNumFragments, fragmentLength, fragmentSuffix,
382                            formatter);
383            }
384    
385            public static Version getVersion() {
386                    return getLuceneHelper().getVersion();
387            }
388    
389            public static boolean isLoadIndexFromClusterEnabled() {
390                    return getLuceneHelper().isLoadIndexFromClusterEnabled();
391            }
392    
393            public static void loadIndex(long companyId, InputStream inputStream)
394                    throws IOException {
395    
396                    getLuceneHelper().loadIndex(companyId, inputStream);
397            }
398    
399            public static void loadIndexesFromCluster(long companyId)
400                    throws SystemException {
401    
402                    getLuceneHelper().loadIndexesFromCluster(companyId);
403            }
404    
405            public static void releaseIndexSearcher(
406                            long companyId, IndexSearcher indexSearcher)
407                    throws IOException {
408    
409                    getLuceneHelper().releaseIndexSearcher(companyId, indexSearcher);
410            }
411    
412            public static void shutdown() {
413                    getLuceneHelper().shutdown();
414            }
415    
416            public static void shutdown(long companyId) {
417                    getLuceneHelper().shutdown(companyId);
418            }
419    
420            public static void startup(long companyId) {
421                    getLuceneHelper().startup(companyId);
422            }
423    
424            public static void updateDocument(
425                            long companyId, Term term, Document document)
426                    throws IOException {
427    
428                    getLuceneHelper().updateDocument(companyId, term, document);
429            }
430    
431            public void setLuceneHelper(LuceneHelper luceneHelper) {
432                    _luceneHelper = luceneHelper;
433            }
434    
435            private static LuceneHelper _luceneHelper;
436    
437    }