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