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