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