source: branches/vendor/trolltech/qt/current/tools/assistant/lib/qhelpsearchindexreader_clucene.cpp @ 2

Last change on this file since 2 was 2, checked in by Dmitry A. Kuminov, 13 years ago

Initially imported qt-all-opensource-src-4.5.1 from Trolltech.

File size: 14.9 KB
Line 
1/****************************************************************************
2**
3** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
4** Contact: Qt Software Information (qt-info@nokia.com)
5**
6** This file is part of the Qt Assistant of the Qt Toolkit.
7**
8** $QT_BEGIN_LICENSE:LGPL$
9** Commercial Usage
10** Licensees holding valid Qt Commercial licenses may use this file in
11** accordance with the Qt Commercial License Agreement provided with the
12** Software or, alternatively, in accordance with the terms contained in
13** a written agreement between you and Nokia.
14**
15** GNU Lesser General Public License Usage
16** Alternatively, this file may be used under the terms of the GNU Lesser
17** General Public License version 2.1 as published by the Free Software
18** Foundation and appearing in the file LICENSE.LGPL included in the
19** packaging of this file.  Please review the following information to
20** ensure the GNU Lesser General Public License version 2.1 requirements
21** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
22**
23** In addition, as a special exception, Nokia gives you certain
24** additional rights. These rights are described in the Nokia Qt LGPL
25** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
26** package.
27**
28** GNU General Public License Usage
29** Alternatively, this file may be used under the terms of the GNU
30** General Public License version 3.0 as published by the Free Software
31** Foundation and appearing in the file LICENSE.GPL included in the
32** packaging of this file.  Please review the following information to
33** ensure the GNU General Public License version 3.0 requirements will be
34** met: http://www.gnu.org/copyleft/gpl.html.
35**
36** If you are unsure which license is appropriate for your use, please
37** contact the sales department at qt-sales@nokia.com.
38** $QT_END_LICENSE$
39**
40****************************************************************************/
41
42#include "qhelpenginecore.h"
43#include "fulltextsearch/qsearchable_p.h"
44#include "fulltextsearch/qqueryparser_p.h"
45#include "fulltextsearch/qindexreader_p.h"
46#include "qhelpsearchindexreader_clucene_p.h"
47
48#include <QtCore/QDir>
49#include <QtCore/QSet>
50#include <QtCore/QString>
51#include <QtCore/QFileInfo>
52#include <QtCore/QStringList>
53#include <QtCore/QTextStream>
54#include <QtCore/QMutexLocker>
55
56QT_BEGIN_NAMESPACE
57
58namespace qt {
59    namespace fulltextsearch {
60        namespace clucene {
61
62QHelpSearchIndexReader::QHelpSearchIndexReader()
63    : QThread()
64    , m_cancel(false)
65{
66    // nothing todo
67}
68
69QHelpSearchIndexReader::~QHelpSearchIndexReader()
70{
71    mutex.lock();
72    this->m_cancel = true;
73    waitCondition.wakeOne();
74    mutex.unlock();
75
76    wait();
77}
78
79void QHelpSearchIndexReader::cancelSearching()
80{
81    mutex.lock();
82    this->m_cancel = true;
83    mutex.unlock();
84}
85
86void QHelpSearchIndexReader::search(const QString &collectionFile, const QString &indexFilesFolder,
87    const QList<QHelpSearchQuery> &queryList)
88{
89    QMutexLocker lock(&mutex);
90
91    this->hitList.clear();
92    this->m_cancel = false;
93    this->m_query = queryList;
94    this->m_collectionFile = collectionFile;
95    this->m_indexFilesFolder = indexFilesFolder;
96
97    start(QThread::NormalPriority);
98}
99
100int QHelpSearchIndexReader::hitsCount() const
101{
102    return hitList.count();
103}
104
105QHelpSearchEngine::SearchHit QHelpSearchIndexReader::hit(int index) const
106{
107    return hitList.at(index);
108}
109
110void QHelpSearchIndexReader::run()
111{
112    mutex.lock();
113
114    if (m_cancel) {
115        mutex.unlock();
116        return;
117    }
118
119    const QString collectionFile(this->m_collectionFile);
120    const QList<QHelpSearchQuery> &queryList = this->m_query;
121    const QString indexPath(m_indexFilesFolder);
122
123    mutex.unlock();
124
125    QHelpEngineCore engine(collectionFile, 0);
126    if (!engine.setupData())
127        return;
128
129    QFileInfo fInfo(indexPath);
130    if (fInfo.exists() && !fInfo.isWritable()) {
131        qWarning("Full Text Search, could not read index (missing permissions).");
132        return;
133    }
134
135    if(QCLuceneIndexReader::indexExists(indexPath)) {
136        mutex.lock();
137        if (m_cancel) {
138            mutex.unlock();
139            return;
140        }
141        mutex.unlock();
142
143        emit searchingStarted();
144
145#if !defined(QT_NO_EXCEPTIONS)
146        try {
147#endif
148            QCLuceneBooleanQuery booleanQuery;
149            QCLuceneStandardAnalyzer analyzer;
150            if (!buildQuery(booleanQuery, queryList, analyzer)) {
151                emit searchingFinished(0);
152                return;
153            }
154
155            const QStringList attribList = engine.filterAttributes(engine.currentFilter());
156            if (!attribList.isEmpty()) {
157                QCLuceneQuery* query = QCLuceneQueryParser::parse(QLatin1String("+")
158                    + attribList.join(QLatin1String(" +")), QLatin1String("attribute"), analyzer);
159
160                if (!query) {
161                    emit searchingFinished(0);
162                    return;
163                }
164                booleanQuery.add(query, true, true, false);
165            }
166
167            QCLuceneIndexSearcher indexSearcher(indexPath);
168            QCLuceneHits hits = indexSearcher.search(booleanQuery);
169
170            bool boost = true;
171            QCLuceneBooleanQuery tryHarderQuery;
172            if (hits.length() == 0) {
173                if (buildTryHarderQuery(tryHarderQuery, queryList, analyzer)) {
174                    if (!attribList.isEmpty()) {
175                        QCLuceneQuery* query = QCLuceneQueryParser::parse(QLatin1String("+")
176                            + attribList.join(QLatin1String(" +")), QLatin1String("attribute"),
177                            analyzer);
178                        tryHarderQuery.add(query, true, true, false);
179                    }
180                    hits = indexSearcher.search(tryHarderQuery);
181                    boost = (hits.length() == 0);
182                }
183            }
184
185            QSet<QString> pathSet;
186            QCLuceneDocument document;
187            const QStringList namespaceList = engine.registeredDocumentations();
188
189            for (qint32 i = 0; i < hits.length(); i++) {
190                document = hits.document(i);
191                const QString path = document.get(QLatin1String("path"));
192                if (!pathSet.contains(path) && namespaceList.contains(
193                    document.get(QLatin1String("namespace")), Qt::CaseInsensitive)) {
194                    pathSet.insert(path);
195                    hitList.append(qMakePair(path, document.get(QLatin1String("title"))));
196                }
197                document.clear();
198
199                mutex.lock();
200                if (m_cancel) {
201                    mutex.unlock();
202                    emit searchingFinished(0);
203                    return;
204                }
205                mutex.unlock();
206            }
207
208            indexSearcher.close();
209            const int count = hitList.count();
210            if ((count > 0) && boost)
211                boostSearchHits(engine, hitList, queryList);
212            emit searchingFinished(hitList.count());
213
214#if !defined(QT_NO_EXCEPTIONS)
215        } catch(...) {
216            hitList.clear();
217            emit searchingFinished(0);
218        }
219#endif
220    }
221}
222
223bool QHelpSearchIndexReader::defaultQuery(const QString &term, QCLuceneBooleanQuery &booleanQuery,
224    QCLuceneStandardAnalyzer &analyzer)
225{
226    const QLatin1String c("content");
227    const QLatin1String t("titleTokenized");
228
229    QCLuceneQuery *query = QCLuceneQueryParser::parse(term, c, analyzer);
230    QCLuceneQuery *query2 = QCLuceneQueryParser::parse(term, t, analyzer);
231    if (query && query2) {
232        booleanQuery.add(query, true, false, false);
233        booleanQuery.add(query2, true, false, false);
234        return true;
235    }
236
237    return false;
238}
239
240bool QHelpSearchIndexReader::buildQuery(QCLuceneBooleanQuery &booleanQuery,
241    const QList<QHelpSearchQuery> &queryList, QCLuceneStandardAnalyzer &analyzer)
242{
243    foreach (const QHelpSearchQuery query, queryList) {
244        switch (query.fieldName) {
245            case QHelpSearchQuery::FUZZY: {
246                const QLatin1String fuzzy("~");
247                foreach (const QString &term, query.wordList) {
248                    if (term.isEmpty()
249                        || !defaultQuery(term.toLower() + fuzzy, booleanQuery, analyzer)) {
250                        return false;
251                    }
252                }
253            }   break;
254
255            case QHelpSearchQuery::WITHOUT: {
256                QStringList stopWords = QCLuceneStopAnalyzer().englishStopWords();
257                foreach (const QString &term, query.wordList) {
258                    if (stopWords.contains(term, Qt::CaseInsensitive))
259                        continue;
260
261                    QCLuceneQuery *query = new QCLuceneTermQuery(QCLuceneTerm(
262                        QLatin1String("content"), term.toLower()));
263                    QCLuceneQuery *query2 = new QCLuceneTermQuery(QCLuceneTerm(
264                        QLatin1String("titleTokenized"), term.toLower()));
265
266                    if (query && query2) {
267                        booleanQuery.add(query, true, false, true);
268                        booleanQuery.add(query2, true, false, true);
269                    } else {
270                        return false;
271                    }
272                }
273            }   break;
274
275            case QHelpSearchQuery::PHRASE: {
276                const QString &term = query.wordList.at(0).toLower();
277                if (term.contains(QLatin1Char(' '))) {
278                    QStringList termList = term.split(QLatin1String(" "));
279                    QCLucenePhraseQuery *q = new QCLucenePhraseQuery();
280                    QStringList stopWords = QCLuceneStopAnalyzer().englishStopWords();
281                    foreach (const QString &term, termList) {
282                        if (!stopWords.contains(term, Qt::CaseInsensitive))
283                            q->addTerm(QCLuceneTerm(QLatin1String("content"), term.toLower()));
284                    }
285                    booleanQuery.add(q, true, true, false);
286                } else {
287                    QCLuceneQuery *query = new QCLuceneTermQuery(QCLuceneTerm(
288                        QLatin1String("content"), term.toLower()));
289                    QCLuceneQuery *query2 = new QCLuceneTermQuery(QCLuceneTerm(
290                        QLatin1String("titleTokenized"), term.toLower()));
291
292                    if (query && query2) {
293                        booleanQuery.add(query, true, true, false);
294                        booleanQuery.add(query2, true, false, false);
295                    } else {
296                        return false;
297                    }
298                }
299            }   break;
300
301            case QHelpSearchQuery::ALL: {
302                QStringList stopWords = QCLuceneStopAnalyzer().englishStopWords();
303                foreach (const QString &term, query.wordList) {
304                    if (stopWords.contains(term, Qt::CaseInsensitive))
305                        continue;
306
307                    QCLuceneQuery *query = new QCLuceneTermQuery(QCLuceneTerm(
308                        QLatin1String("content"), term.toLower()));
309
310                    if (query) {
311                        booleanQuery.add(query, true, true, false);
312                    } else {
313                        return false;
314                    }
315                }
316            }   break;
317
318            case QHelpSearchQuery::DEFAULT: {
319                foreach (const QString &term, query.wordList) {
320                    QCLuceneQuery *query = QCLuceneQueryParser::parse(term.toLower(),
321                        QLatin1String("content"), analyzer);
322
323                    if (query)
324                        booleanQuery.add(query, true, true, false);
325                }
326            }   break;
327
328            case QHelpSearchQuery::ATLEAST: {
329                foreach (const QString &term, query.wordList) {
330                    if (term.isEmpty() || !defaultQuery(term.toLower(), booleanQuery, analyzer))
331                        return false;
332                }
333            }
334        }
335    }
336
337    return true;
338}
339
340bool QHelpSearchIndexReader::buildTryHarderQuery(QCLuceneBooleanQuery &booleanQuery,
341    const QList<QHelpSearchQuery> &queryList, QCLuceneStandardAnalyzer &analyzer)
342{
343    bool retVal = false;
344    foreach (const QHelpSearchQuery query, queryList) {
345        switch (query.fieldName) {
346            default:    break;
347            case QHelpSearchQuery::DEFAULT: {
348                foreach (const QString &term, query.wordList) {
349                    QCLuceneQuery *query = QCLuceneQueryParser::parse(term.toLower(),
350                        QLatin1String("content"), analyzer);
351
352                    if (query) {
353                        retVal = true;
354                        booleanQuery.add(query, true, false, false);
355                    }
356                }
357            }   break;
358        }
359    }
360    return retVal;
361}
362
363void QHelpSearchIndexReader::boostSearchHits(const QHelpEngineCore &engine,
364    QList<QHelpSearchEngine::SearchHit> &hitList, const QList<QHelpSearchQuery> &queryList)
365{
366    foreach (const QHelpSearchQuery query, queryList) {
367        if (query.fieldName != QHelpSearchQuery::DEFAULT)
368            continue;
369
370        QString joinedQuery = query.wordList.join(QLatin1String(" "));
371
372        QCLuceneStandardAnalyzer analyzer;
373        QCLuceneQuery *parsedQuery = QCLuceneQueryParser::parse(
374            joinedQuery, QLatin1String("content"), analyzer);
375
376        if (parsedQuery) {
377            joinedQuery = parsedQuery->toString();
378            delete parsedQuery;
379        }
380
381        int length = QString(QLatin1String("content:")).length();
382        int index = joinedQuery.indexOf(QLatin1String("content:"));
383
384        QString term;
385        int nextIndex = 0;
386        QStringList searchTerms;
387        while (index != -1) {
388            nextIndex = joinedQuery.indexOf(QLatin1String("content:"), index + 1);
389            term = joinedQuery.mid(index + length, nextIndex - (length + index)).simplified();
390            if (term.startsWith(QLatin1String("\""))
391                && term.endsWith(QLatin1String("\""))) {
392                searchTerms.append(term.remove(QLatin1String("\"")));
393            } else {
394                searchTerms += term.split(QLatin1Char(' '));
395            }
396            index = nextIndex;
397        }
398        searchTerms.removeDuplicates();
399
400        int count = qMin(75, hitList.count());
401        QMap<int, QHelpSearchEngine::SearchHit> hitMap;
402        for (int i = 0; i < count; ++i) {
403            const QHelpSearchEngine::SearchHit &hit = hitList.at(i);
404            QString data = QString::fromUtf8(engine.fileData(hit.first));
405
406            int counter = 0;
407            foreach (const QString &term, searchTerms)
408                counter += data.count(term, Qt::CaseInsensitive);
409            hitMap.insertMulti(counter, hit);
410        }
411
412        QList<QHelpSearchEngine::SearchHit> boostedList;
413        QMap<int, QHelpSearchEngine::SearchHit>::const_iterator it = hitMap.constEnd();
414        do {
415            --it;
416            boostedList.append(it.value());
417        } while (it != hitMap.constBegin());
418        boostedList += hitList.mid(count, hitList.count());
419
420        hitList = boostedList;
421    }
422}
423
424        }   // namespace clucene
425    }   // namespace fulltextsearch
426}   // namespace qt
427
428QT_END_NAMESPACE
Note: See TracBrowser for help on using the repository browser.