double Soprano::Index::CLuceneIndex::getScore( const Soprano::Node& resource, lucene::search::Query* query )
{
QMutexLocker lock( &d->mutex );
clearError();
try {
// rewrite the query
lucene::index::Term queryTerm( idFieldName().data(), TString( d->getId( resource ) ).data() );
lucene::search::TermQuery idQuery( &queryTerm );
lucene::search::BooleanQuery combinedQuery;
combinedQuery.add( &idQuery, true, false );
combinedQuery.add( query, true, false );
// fetch the score when the URI matches the original query
lucene::search::TopDocs* docs = static_cast<lucene::search::Searchable*>( d->getIndexSearcher() )->_search( &combinedQuery, 0, 1 );
double r = -1.0;
if ( docs->totalHits > 0 ) {
#ifdef CL_VERSION_19_OR_GREATER
r = docs->scoreDocs[0].score;
#else
r = docs->scoreDocs[0]->score;
#endif
}
_CLDELETE( docs );
return r;
}
catch( CLuceneError& err ) {
qDebug() << "search failed: " << err.what();
setError( exceptionToError( err ) );
return 0.0;
}
}
void Soprano::Index::CLuceneIndex::dump( QTextStream& s ) const
{
QMutexLocker lock( &d->mutex );
clearError();
try {
lucene::index::IndexReader* reader = d->getIndexReader();
for ( int i = 0; i < reader->numDocs(); ++i ) {
lucene::document::Document* doc = reader->document( i );
s << "Document " << i << endl
<< "====================" << endl;
lucene::document::DocumentFieldEnumeration* e = doc->fields();
while ( e->hasMoreElements() ) {
lucene::document::Field* field = e->nextElement();
s << TString( field->name(), true ).toQString() << ": "
<< TString( field->stringValue(), true ).toQString()
<< endl;
}
s << endl;
_CLDELETE( e );
_CLDELETE( doc );
}
s << flush;
}
catch( CLuceneError& err ) {
qDebug() << "(Soprano::Index::CLuceneIndex) failed to dump index.";
setError( exceptionToError( err ) );
}
}
Soprano::Iterator<Soprano::Index::QueryHit> Soprano::Index::CLuceneIndex::search( const QString& query )
{
clearError();
try {
lucene::queryParser::QueryParser parser( textFieldName().data(), d->queryAnalyzer ? d->queryAnalyzer : d->analyzer );
lucene::search::Query* q = parser.parse( TString( query ).data() );
if ( !q ) {
setError( QString( "Failed to parse CLucene query: '%1'" ).arg( query ) );
return Iterator<QueryHit>();
}
else {
Iterator<QueryHit> hits = search( q );
// FIXME: is it possible to use the CLucene ref counting here?
if ( !hits.isValid() ) {
delete q;
}
return hits;
}
}
catch( CLuceneError& err ) {
qDebug() << "search" << query << "failed: " << err.what();
setError( exceptionToError( err ) );
return Iterator<QueryHit>();
}
}
Soprano::Iterator<Soprano::Index::QueryHit> Soprano::Index::CLuceneIndex::search( lucene::search::Query* query )
{
QMutexLocker lock( &d->mutex );
if ( query ) {
clearError();
try {
lucene::search::Hits* hits = d->getIndexSearcher()->search( query );
if ( hits ) {
return new QueryHitIteratorBackend( hits, query );
}
else {
return Iterator<QueryHit>();
}
}
catch( CLuceneError& err ) {
qDebug() << "search failed: " << err.what();
setError( exceptionToError( err ) );
return Iterator<QueryHit>();
}
}
else {
setError( "Invalid CLucene query" );
return Iterator<QueryHit>();
}
}
bool Soprano::Index::CLuceneIndex::closeTransaction( int id )
{
// qDebug() << "CLuceneIndex::closeTransaction in thread " << QThread::currentThreadId();
QMutexLocker lock( &d->mutex );
if ( id == d->transactionID && id > 0 ) {
clearError();
try {
d->commit();
}
catch( CLuceneError& err ) {
setError( exceptionToError( err ) );
// qDebug() << "CLuceneIndex::closeTransaction done in thread " << QThread::currentThreadId();
return false;
}
d->transactionID = 0;
// qDebug() << "CLuceneIndex::closeTransaction done in thread " << QThread::currentThreadId();
return true;
}
else {
setError( QString( "Invalid transaction ID: %1" ).arg( id ) );
// qDebug() << "CLuceneIndex::closeTransaction done in thread " << QThread::currentThreadId();
return false;
}
}
void Soprano::Index::CLuceneIndex::clear()
{
if ( d->indexPresent() ) {
try {
int numDocs = d->getIndexReader()->maxDoc();
for ( int i = 0; i < numDocs; ++i ) {
d->getIndexReader()->deleteDocument( i );
}
d->closeReader();
}
catch( CLuceneError& err ) {
setError( exceptionToError( err ) );
}
}
}
double Soprano::Index::CLuceneIndex::getScore( const Soprano::Node& resource, const QString& query )
{
clearError();
try {
lucene::search::Query* q = lucene::queryParser::QueryParser::parse( TString( query ).data(), textFieldName().data(), d->analyzer );
double score = getScore( resource, q );
delete( q );
return score;
}
catch( CLuceneError& err ) {
qDebug() << "search failed: " << err.what();
setError( exceptionToError( err ) );
return 0.0;
}
}
int Soprano::Index::CLuceneIndex::resourceCount() const
{
QMutexLocker lock( &d->mutex );
clearError();
try {
lucene::index::IndexReader* reader = d->getIndexReader();
return reader->numDocs();
}
catch( CLuceneError& err ) {
qDebug() << "(Soprano::Index::CLuceneIndex) failed to dump index.";
setError( exceptionToError( err ) );
return -1;
}
}
Soprano::Error::ErrorCode Soprano::Index::CLuceneIndex::removeStatement( const Soprano::Statement& statement )
{
// qDebug() << "CLuceneIndex::removeStatement in thread " << QThread::currentThreadId();
QMutexLocker lock( &d->mutex );
clearError();
// just for speed
if ( !d->indexPresent() ) {
// qDebug() << "CLuceneIndex::removeStatement done in thread " << QThread::currentThreadId();
return Error::ErrorNone;
}
bool success = false;
QString field = QString::fromLatin1( statement.predicate().uri().toEncoded() );
QString text = statement.object().isResource()
? QString::fromLatin1( statement.object().uri().toEncoded() )
: statement.object().toString();
if( text.isEmpty() ) {
return Error::ErrorNone;
}
try {
lucene::document::Document* document = d->getDocument( statement.subject() );
if ( document ) {
CLuceneDocumentWrapper docWrapper( document );
docWrapper.removeProperty( field, text, statement.object().isResource() );
if ( d->transactionID == 0 ) {
d->commit();
}
success = true;
}
}
catch( CLuceneError& err ) {
qDebug() << "(Soprano::Index::CLuceneIndex::removeStatement) Exception occurred: " << err.what();
setError( exceptionToError( err ) );
success = false;
}
// qDebug() << "CLuceneIndex::removeStatement done in thread " << QThread::currentThreadId();
return success ? Error::ErrorNone : Error::ErrorUnknown;
}
Soprano::Error::ErrorCode Soprano::Index::CLuceneIndex::addStatement( const Soprano::Statement& statement )
{
// qDebug() << "CLuceneIndex::addStatement in thread " << QThread::currentThreadId();
QMutexLocker lock( &d->mutex );
clearError();
QString field = QString::fromLatin1( statement.predicate().uri().toEncoded() );
QString text = statement.object().isResource()
? QString::fromLatin1( statement.object().uri().toEncoded() )
: statement.object().toString();
if( text.isEmpty() ) {
setError( "Cannot index object nodes that convert to an empty string." );
// qDebug() << "CLuceneIndex::addStatement done in thread " << QThread::currentThreadId();
return Error::ErrorUnknown;
}
bool success = true;
try {
lucene::document::Document* document = d->getDocument( statement.subject() );
if ( document ) {
CLuceneDocumentWrapper docWrapper( document );
docWrapper.addProperty( field, text, statement.object().isResource() );
if ( d->transactionID == 0 ) {
d->commit();
}
success = true;
}
else {
// error already set in documentForResource
success = false;
}
}
catch( CLuceneError& err ) {
setError( exceptionToError( err ) );
success = false;
}
// qDebug() << "CLuceneIndex::addStatement done in thread " << QThread::currentThreadId();
return success ? Error::ErrorNone : Error::ErrorUnknown;
}
lucene::document::Document* Soprano::Index::CLuceneIndex::documentForResource( const Node& resource )
{
QMutexLocker lock( &d->mutex );
clearError();
if ( d->transactionID == 0 ) {
setError( "No transaction started." );
return 0;
}
try {
return d->getDocument( resource );
}
catch( CLuceneError& err ) {
qDebug() << "(Soprano::Index::CLuceneIndex) Exception occurred: " << err.what();
setError( exceptionToError( err ) );
return 0;
}
}
bool Soprano::Index::CLuceneIndex::open( const QString& folder, bool force )
{
// qDebug() << "CLuceneIndex::open in thread " << QThread::currentThreadId();
close();
clearError();
QMutexLocker lock( &d->mutex );
try {
d->indexDir = lucene::store::FSDirectory::getDirectory( QFile::encodeName( folder ).data(), !QFile::exists( folder ) );
}
catch( CLuceneError& err ) {
qDebug() << "(Soprano::Index::CLuceneIndex) failed to open index folder " << folder << " (" << err.what() << ")";
setError( exceptionToError( err ) );
return false;
}
if ( !d->indexDir ) {
return false;
}
// get rid of any locks that may have been left by previous (crashed)
// sessions
if ( lucene::index::IndexReader::isLocked( d->indexDir ) ) {
if ( force ) {
qDebug() << "(Soprano::Index::CLuceneIndex::open) unlocking directory " << folder;
lucene::index::IndexReader::unlock( d->indexDir );
}
else {
qDebug() << "(Soprano::Index::CLuceneIndex::open) index folder is locked! Make sure no other clucene processes work on the same data." << folder;
setError( QString( "Index folder '%1' is locked." ).arg( folder ) );
return false;
}
}
// qDebug() << "CLuceneIndex::open done in thread " << QThread::currentThreadId();
return true;
}
QVariant QDeclarativeExpressionPrivate::evalQtScript(QObject *secondaryScope, bool *isUndefined)
{
QDeclarativeExpressionData *data = this->data;
QDeclarativeEngine *engine = data->context()->engine;
QDeclarativeEnginePrivate *ep = QDeclarativeEnginePrivate::get(engine);
QScriptEngine *scriptEngine = QDeclarativeEnginePrivate::getScriptEngine(engine);
if (!data->expressionFunctionValid) {
QScriptContext *scriptContext = QScriptDeclarativeClass::pushCleanContext(scriptEngine);
data->expressionContext = ep->contextClass->newContext(data->context(), data->me);
scriptContext->pushScope(data->expressionContext);
scriptContext->pushScope(ep->globalClass->globalObject());
if (data->expressionRewritten) {
data->expressionFunction = scriptEngine->evaluate(data->expression,
data->url, data->line);
} else {
QDeclarativeRewrite::RewriteBinding rewriteBinding;
bool ok = true;
const QString code = rewriteBinding(data->expression, &ok);
if (!ok) {
scriptEngine->popContext();
return QVariant();
}
data->expressionFunction = scriptEngine->evaluate(code, data->url, data->line);
}
scriptEngine->popContext();
data->expressionFunctionValid = true;
}
QDeclarativeContextData *oldSharedContext = 0;
QObject *oldSharedScope = 0;
QObject *oldOverride = 0;
if (data->isShared) {
oldSharedContext = ep->sharedContext;
oldSharedScope = ep->sharedScope;
ep->sharedContext = data->context();
ep->sharedScope = data->me;
} else {
oldOverride = ep->contextClass->setOverrideObject(data->expressionContext, secondaryScope);
}
QScriptValue svalue = data->expressionFunction.call();
if (data->isShared) {
ep->sharedContext = oldSharedContext;
ep->sharedScope = oldSharedScope;
} else {
ep->contextClass->setOverrideObject(data->expressionContext, oldOverride);
}
if (isUndefined)
*isUndefined = svalue.isUndefined() || scriptEngine->hasUncaughtException();
// Handle exception
if (scriptEngine->hasUncaughtException()) {
exceptionToError(scriptEngine, data->error);
scriptEngine->clearExceptions();
return QVariant();
} else {
data->error = QDeclarativeError();
}
QVariant rv;
if (svalue.isArray()) {
int length = svalue.property(QLatin1String("length")).toInt32();
if (length && svalue.property(0).isObject()) {
QList<QObject *> list;
for (int ii = 0; ii < length; ++ii) {
QScriptValue arrayItem = svalue.property(ii);
QObject *d = arrayItem.toQObject();
list << d;
}
rv = QVariant::fromValue(list);
}
} else if (svalue.isObject() &&
ep->objectClass->scriptClass(svalue) == ep->objectClass) {
QObject *o = svalue.toQObject();
int type = QMetaType::QObjectStar;
// If the object is null, we extract the predicted type. While this isn't
// 100% reliable, in many cases it gives us better error messages if we
// assign this null-object to an incompatible property
if (!o) type = ep->objectClass->objectType(svalue);
return QVariant(type, &o);
}
if (rv.isNull())
rv = svalue.toVariant();
return rv;
}
