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    
028    import org.apache.lucene.analysis.Analyzer;
029    import org.apache.lucene.document.Document;
030    import org.apache.lucene.index.Term;
031    import org.apache.lucene.search.BooleanQuery;
032    import org.apache.lucene.search.IndexSearcher;
033    import org.apache.lucene.search.Query;
034    import org.apache.lucene.util.Version;
035    
036    /**
037     * @author Brian Wing Shun Chan
038     * @author Harry Mark
039     * @author Bruno Farache
040     * @author Shuyang Zhou
041     */
042    public class LuceneHelperUtil {
043    
044            public static void addDate(Document doc, String field, Date value) {
045                    doc.add(LuceneFields.getDate(field, value));
046            }
047    
048            public static void addDocument(long companyId, Document document)
049                    throws IOException {
050    
051                    getLuceneHelper().addDocument(companyId, document);
052            }
053    
054            public static void addExactTerm(
055                    BooleanQuery booleanQuery, String field, boolean value) {
056    
057                    addExactTerm(booleanQuery, field, String.valueOf(value));
058            }
059    
060            public static void addExactTerm(
061                    BooleanQuery booleanQuery, String field, double value) {
062    
063                    addExactTerm(booleanQuery, field, String.valueOf(value));
064            }
065    
066            public static void addExactTerm(
067                    BooleanQuery booleanQuery, String field, int value) {
068    
069                    addExactTerm(booleanQuery, field, String.valueOf(value));
070            }
071    
072            public static void addExactTerm(
073                    BooleanQuery booleanQuery, String field, long value) {
074    
075                    addExactTerm(booleanQuery, field, String.valueOf(value));
076            }
077    
078            public static void addExactTerm(
079                    BooleanQuery booleanQuery, String field, short value) {
080    
081                    addExactTerm(booleanQuery, field, String.valueOf(value));
082            }
083    
084            public static void addExactTerm(
085                    BooleanQuery booleanQuery, String field, String value) {
086    
087                    getLuceneHelper().addExactTerm(booleanQuery, field, value);
088            }
089    
090            public static void addNumericRangeTerm(
091                    BooleanQuery booleanQuery, String field, int startValue, int endValue) {
092    
093                    getLuceneHelper().addNumericRangeTerm(
094                            booleanQuery, field, String.valueOf(startValue),
095                            String.valueOf(endValue));
096            }
097    
098            public static void addNumericRangeTerm(
099                    BooleanQuery booleanQuery, String field, Integer startValue,
100                    Integer endValue) {
101    
102                    getLuceneHelper().addNumericRangeTerm(
103                            booleanQuery, field, String.valueOf(startValue),
104                            String.valueOf(endValue));
105            }
106    
107            public static void addNumericRangeTerm(
108                    BooleanQuery booleanQuery, String field, long startValue,
109                    long endValue) {
110    
111                    getLuceneHelper().addNumericRangeTerm(
112                            booleanQuery, field, String.valueOf(startValue),
113                            String.valueOf(endValue));
114            }
115    
116            public static void addNumericRangeTerm(
117                    BooleanQuery booleanQuery, String field, Long startValue,
118                    Long endValue) {
119    
120                    getLuceneHelper().addNumericRangeTerm(
121                            booleanQuery, field, String.valueOf(startValue),
122                            String.valueOf(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, String.valueOf(startValue),
131                            String.valueOf(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, String.valueOf(startValue),
140                            String.valueOf(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 int countScoredFieldNames(Query query, String[] fieldNames) {
287                    return getLuceneHelper().countScoredFieldNames(query, fieldNames);
288            }
289    
290            public static void delete(long companyId) {
291                    getLuceneHelper().delete(companyId);
292            }
293    
294            public static void deleteDocuments(long companyId, Term term)
295                    throws IOException {
296    
297                    getLuceneHelper().deleteDocuments(companyId, term);
298            }
299    
300            public static void dumpIndex(long companyId, OutputStream outputStream)
301                    throws IOException {
302    
303                    getLuceneHelper().dumpIndex(companyId, outputStream);
304            }
305    
306            public static Analyzer getAnalyzer() {
307                    return getLuceneHelper().getAnalyzer();
308            }
309    
310            public static long getLastGeneration(long companyId) {
311                    return getLuceneHelper().getLastGeneration(companyId);
312            }
313    
314            public static InputStream getLoadIndexesInputStreamFromCluster(
315                            long companyId, Address bootupAddress)
316                    throws SystemException {
317    
318                    return getLuceneHelper().getLoadIndexesInputStreamFromCluster(
319                            companyId, bootupAddress);
320            }
321    
322            public static LuceneHelper getLuceneHelper() {
323                    return _luceneHelper;
324            }
325    
326            public static String[] getQueryTerms(Query query) {
327                    return getLuceneHelper().getQueryTerms(query);
328            }
329    
330            public static IndexSearcher getSearcher(long companyId, boolean readOnly)
331                    throws IOException {
332    
333                    return getLuceneHelper().getSearcher(companyId, readOnly);
334            }
335    
336            public static String getSnippet(Query query, String field, String s)
337                    throws IOException {
338    
339                    return getSnippet(
340                            query, field, s, 3, 80, "...", StringPool.BLANK, StringPool.BLANK);
341            }
342    
343            public static String getSnippet(
344                            Query query, String field, String s, int maxNumFragments,
345                            int fragmentLength, String fragmentSuffix, String preTag,
346                            String postTag)
347                    throws IOException {
348    
349                    return getLuceneHelper().getSnippet(
350                            query, field, s, maxNumFragments, fragmentLength, fragmentSuffix,
351                            preTag, postTag);
352            }
353    
354            public static Version getVersion() {
355                    return getLuceneHelper().getVersion();
356            }
357    
358            public static boolean isLoadIndexFromClusterEnabled() {
359                    return getLuceneHelper().isLoadIndexFromClusterEnabled();
360            }
361    
362            public static void loadIndex(long companyId, InputStream inputStream)
363                    throws IOException {
364    
365                    getLuceneHelper().loadIndex(companyId, inputStream);
366            }
367    
368            public static void loadIndexesFromCluster(long companyId)
369                    throws SystemException {
370    
371                    getLuceneHelper().loadIndexesFromCluster(companyId);
372            }
373    
374            public static void shutdown() {
375                    getLuceneHelper().shutdown();
376            }
377    
378            public static void startup(long companyId) {
379                    getLuceneHelper().startup(companyId);
380            }
381    
382            public static void updateDocument(
383                            long companyId, Term term, Document document)
384                    throws IOException {
385    
386                    getLuceneHelper().updateDocument(companyId, term, document);
387            }
388    
389            public void setLuceneHelper(LuceneHelper luceneHelper) {
390                    _luceneHelper = luceneHelper;
391            }
392    
393            private static LuceneHelper _luceneHelper;
394    
395    }