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.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 int countScoredFieldNames(Query query, String[] fieldNames) {
290                    return getLuceneHelper().countScoredFieldNames(query, fieldNames);
291            }
292    
293            public static void delete(long companyId) {
294                    getLuceneHelper().delete(companyId);
295            }
296    
297            public static void deleteDocuments(long companyId, Term term)
298                    throws IOException {
299    
300                    getLuceneHelper().deleteDocuments(companyId, term);
301            }
302    
303            public static void dumpIndex(long companyId, OutputStream outputStream)
304                    throws IOException {
305    
306                    getLuceneHelper().dumpIndex(companyId, outputStream);
307            }
308    
309            public static Analyzer getAnalyzer() {
310                    return getLuceneHelper().getAnalyzer();
311            }
312    
313            public static long getLastGeneration(long companyId) {
314                    return getLuceneHelper().getLastGeneration(companyId);
315            }
316    
317            public static InputStream getLoadIndexesInputStreamFromCluster(
318                            long companyId, Address bootupAddress)
319                    throws SystemException {
320    
321                    return getLuceneHelper().getLoadIndexesInputStreamFromCluster(
322                            companyId, bootupAddress);
323            }
324    
325            public static LuceneHelper getLuceneHelper() {
326                    return _luceneHelper;
327            }
328    
329            public static Set<String> getQueryTerms(Query query) {
330                    return getLuceneHelper().getQueryTerms(query);
331            }
332    
333            public static IndexSearcher getSearcher(long companyId, boolean readOnly)
334                    throws IOException {
335    
336                    return getLuceneHelper().getSearcher(companyId, readOnly);
337            }
338    
339            public static String getSnippet(Query query, String field, String s)
340                    throws IOException {
341    
342                    Formatter formatter = new SimpleHTMLFormatter(
343                            StringPool.BLANK, StringPool.BLANK);
344    
345                    return getSnippet(query, field, s, formatter);
346            }
347    
348            public static String getSnippet(
349                            Query query, String field, String s, Formatter formatter)
350                    throws IOException {
351    
352                    return getSnippet(query, field, s, 3, 80, "...", formatter);
353            }
354    
355            public static String getSnippet(
356                            Query query, String field, String s, int maxNumFragments,
357                            int fragmentLength, String fragmentSuffix, Formatter formatter)
358                    throws IOException {
359    
360                    return getLuceneHelper().getSnippet(
361                            query, field, s, maxNumFragments, fragmentLength, fragmentSuffix,
362                            formatter);
363            }
364    
365            public static Version getVersion() {
366                    return getLuceneHelper().getVersion();
367            }
368    
369            public static boolean isLoadIndexFromClusterEnabled() {
370                    return getLuceneHelper().isLoadIndexFromClusterEnabled();
371            }
372    
373            public static void loadIndex(long companyId, InputStream inputStream)
374                    throws IOException {
375    
376                    getLuceneHelper().loadIndex(companyId, inputStream);
377            }
378    
379            public static void loadIndexesFromCluster(long companyId)
380                    throws SystemException {
381    
382                    getLuceneHelper().loadIndexesFromCluster(companyId);
383            }
384    
385            public static void shutdown() {
386                    getLuceneHelper().shutdown();
387            }
388    
389            public static void startup(long companyId) {
390                    getLuceneHelper().startup(companyId);
391            }
392    
393            public static void updateDocument(
394                            long companyId, Term term, Document document)
395                    throws IOException {
396    
397                    getLuceneHelper().updateDocument(companyId, term, document);
398            }
399    
400            public void setLuceneHelper(LuceneHelper luceneHelper) {
401                    _luceneHelper = luceneHelper;
402            }
403    
404            private static LuceneHelper _luceneHelper;
405    
406    }