001    /**
002     * Copyright (c) 2000-2011 Liferay, Inc. All rights reserved.
003     *
004     * The contents of this file are subject to the terms of the Liferay Enterprise
005     * Subscription License ("License"). You may not use this file except in
006     * compliance with the License. You can obtain a copy of the License by
007     * contacting Liferay, Inc. See the License for the specific language governing
008     * permissions and limitations under the License, including but not limited to
009     * distribution rights of the Software.
010     *
011     *
012     *
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.util.StringPool;
020    
021    import java.io.IOException;
022    import java.io.InputStream;
023    import java.io.OutputStream;
024    
025    import java.util.Date;
026    
027    import org.apache.lucene.analysis.Analyzer;
028    import org.apache.lucene.document.Document;
029    import org.apache.lucene.index.Term;
030    import org.apache.lucene.search.BooleanQuery;
031    import org.apache.lucene.search.IndexSearcher;
032    import org.apache.lucene.search.Query;
033    import org.apache.lucene.util.Version;
034    
035    /**
036     * @author Brian Wing Shun Chan
037     * @author Harry Mark
038     * @author Bruno Farache
039     * @author Shuyang Zhou
040     */
041    public class LuceneHelperUtil {
042    
043            public static void addDate(Document doc, String field, Date value) {
044                    doc.add(LuceneFields.getDate(field, value));
045            }
046    
047            public static void addDocument(long companyId, Document document)
048                    throws IOException {
049    
050                    getLuceneHelper().addDocument(companyId, document);
051            }
052    
053            public static void addExactTerm(
054                    BooleanQuery booleanQuery, String field, boolean value) {
055    
056                    addExactTerm(booleanQuery, field, String.valueOf(value));
057            }
058    
059            public static void addExactTerm(
060                    BooleanQuery booleanQuery, String field, double value) {
061    
062                    addExactTerm(booleanQuery, field, String.valueOf(value));
063            }
064    
065            public static void addExactTerm(
066                    BooleanQuery booleanQuery, String field, int value) {
067    
068                    addExactTerm(booleanQuery, field, String.valueOf(value));
069            }
070    
071            public static void addExactTerm(
072                    BooleanQuery booleanQuery, String field, long value) {
073    
074                    addExactTerm(booleanQuery, field, String.valueOf(value));
075            }
076    
077            public static void addExactTerm(
078                    BooleanQuery booleanQuery, String field, short value) {
079    
080                    addExactTerm(booleanQuery, field, String.valueOf(value));
081            }
082    
083            public static void addExactTerm(
084                    BooleanQuery booleanQuery, String field, String value) {
085    
086                    getLuceneHelper().addExactTerm(booleanQuery, field, value);
087            }
088    
089            public static void addNumericRangeTerm(
090                    BooleanQuery booleanQuery, String field, int startValue, int endValue) {
091    
092                    getLuceneHelper().addNumericRangeTerm(
093                            booleanQuery, field, String.valueOf(startValue),
094                            String.valueOf(endValue));
095            }
096    
097            public static void addNumericRangeTerm(
098                    BooleanQuery booleanQuery, String field, Integer startValue,
099                    Integer endValue) {
100    
101                    getLuceneHelper().addNumericRangeTerm(
102                            booleanQuery, field, String.valueOf(startValue),
103                            String.valueOf(endValue));
104            }
105    
106            public static void addNumericRangeTerm(
107                    BooleanQuery booleanQuery, String field, long startValue,
108                    long endValue) {
109    
110                    getLuceneHelper().addNumericRangeTerm(
111                            booleanQuery, field, String.valueOf(startValue),
112                            String.valueOf(endValue));
113            }
114    
115            public static void addNumericRangeTerm(
116                    BooleanQuery booleanQuery, String field, Long startValue,
117                    Long endValue) {
118    
119                    getLuceneHelper().addNumericRangeTerm(
120                            booleanQuery, field, String.valueOf(startValue),
121                            String.valueOf(endValue));
122            }
123    
124            public static void addNumericRangeTerm(
125                    BooleanQuery booleanQuery, String field, short startValue,
126                    short endValue) {
127    
128                    getLuceneHelper().addNumericRangeTerm(
129                            booleanQuery, field, String.valueOf(startValue),
130                            String.valueOf(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, String.valueOf(startValue),
139                            String.valueOf(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[] values,
272                    boolean like) {
273    
274                    getLuceneHelper().addTerm(booleanQuery, field, values, like);
275            }
276    
277            public static int countScoredFieldNames(Query query, String[] fieldNames) {
278                    return getLuceneHelper().countScoredFieldNames(query, fieldNames);
279            }
280    
281            public static void delete(long companyId) {
282                    getLuceneHelper().delete(companyId);
283            }
284    
285            public static void deleteDocuments(long companyId, Term term)
286                    throws IOException {
287    
288                    getLuceneHelper().deleteDocuments(companyId, term);
289            }
290    
291            public static void dumpIndex(long companyId, OutputStream outputStream)
292                    throws IOException {
293    
294                    getLuceneHelper().dumpIndex(companyId, outputStream);
295            }
296    
297            public static Analyzer getAnalyzer() {
298                    return getLuceneHelper().getAnalyzer();
299            }
300    
301            public static long getLastGeneration(long companyId) {
302                    return getLuceneHelper().getLastGeneration(companyId);
303            }
304    
305            public static InputStream getLoadIndexesInputStreamFromCluster(
306                            long companyId, Address bootupAddress)
307                    throws SystemException {
308    
309                    return getLuceneHelper().getLoadIndexesInputStreamFromCluster(
310                            companyId, bootupAddress);
311            }
312    
313            public static LuceneHelper getLuceneHelper() {
314                    return _luceneHelper;
315            }
316    
317            public static String[] getQueryTerms(Query query) {
318                    return getLuceneHelper().getQueryTerms(query);
319            }
320    
321            public static IndexSearcher getSearcher(long companyId, boolean readOnly)
322                    throws IOException {
323    
324                    return getLuceneHelper().getSearcher(companyId, readOnly);
325            }
326    
327            public static String getSnippet(Query query, String field, String s)
328                    throws IOException {
329    
330                    return getSnippet(
331                            query, field, s, 3, 80, "...", StringPool.BLANK, StringPool.BLANK);
332            }
333    
334            public static String getSnippet(
335                            Query query, String field, String s, int maxNumFragments,
336                            int fragmentLength, String fragmentSuffix, String preTag,
337                            String postTag)
338                    throws IOException {
339    
340                    return getLuceneHelper().getSnippet(
341                            query, field, s, maxNumFragments, fragmentLength, fragmentSuffix,
342                            preTag, postTag);
343            }
344    
345            public static Version getVersion() {
346                    return getLuceneHelper().getVersion();
347            }
348    
349            public static boolean isLoadIndexFromClusterEnabled() {
350                    return getLuceneHelper().isLoadIndexFromClusterEnabled();
351            }
352    
353            public static void loadIndex(long companyId, InputStream inputStream)
354                    throws IOException {
355    
356                    getLuceneHelper().loadIndex(companyId, inputStream);
357            }
358    
359            public static Address selectBootupClusterAddress(
360                            long companyId, long localLastGeneration)
361                    throws SystemException {
362    
363                    return getLuceneHelper().selectBootupClusterAddress(
364                            companyId, localLastGeneration);
365            }
366    
367            public static void shutdown() {
368                    getLuceneHelper().shutdown();
369            }
370    
371            public static void startup(long companyId) {
372                    getLuceneHelper().startup(companyId);
373            }
374    
375            public static void updateDocument(
376                            long companyId, Term term, Document document)
377                    throws IOException {
378    
379                    getLuceneHelper().updateDocument(companyId, term, document);
380            }
381    
382            public void setLuceneHelper(LuceneHelper luceneHelper) {
383                    _luceneHelper = luceneHelper;
384            }
385    
386            private static LuceneHelper _luceneHelper;
387    
388    }