Lucene4 Plug-in (deprecated)

{toc}

h2. Description/Motivation

The Lucene4 plug-in for GraphDB provides very fast facet (aggregation) searches, which are normally available through external Apache Solr services, but have the additional benefit to stay automatically up-to-date with the GraphDB repository data.

h2. Features

* maintain a Lucene index that is always synced with the data
* multiple indexes per repository with independent settings. Index options supported:
** stripping the \*ML tags in literals (*false* by default);
** index auto-update (*true* by default);
** specifying a Lucene analyzer (the default is the Lucene's *StandardAnalyzer*);
** a white list of predicates whose values to be indexed;
** a white list of entities rdf:type-s to be indexed (the default is *ALL*);
** a white list of languages to index (the default is *ALL*);
** a white list of predicates whose values to add to the facets index;
* full Lucene syntax for search;
* simple molecules - only literals reachable through zero hops (i.e. a single predicate of an entity);
* snippet extraction - retrieving snippets with highlighted search terms from the search result;
* search flags:
** results paging through _offset_ and _limit_ parameters;
** specifying snippet size per query;
** specifying facets to aggregate.

h2. Differences with Lucene2

h3. Architecture

Lucene2 indexes each relevant statement (triple) as a single Lucene document. This feature is very beneficial for maintaining an index up-to-date, but leads to a few undesirable effects such as returning a single entity more than once for a given search (because more than one literal matches the query) and inability to sort by specific predicates. The Lucene4 plugin creates a single Lucene document per entire entity, which has a field for each of the predicates listed in the index configuration. This leads to slower update times, but solves the two main problems posed above. These decisions have some other minor implications described below. Another significant feature of Lucene4 is the facets support (which is built in Apache Lucene 4.x.x).

h3. Index options

h5. Predicates

The {{predicates}} index option is now mandatory and must not be empty. Indexing all predicates for a given entity is not supported.

h5. Additional joins

The {{additionalJoins}} index options from Lucene2 have been removed in Lucene4. It can be emulated though. Consider the following Lucene2 index creation:
{code}
# Lucene2 snippet - create index with an additional join
luc2:my-index-name luc2:createIndex "predicates=...; additionalJoins=urn:join,joinValue"
{code}
In order to do this in Lucene4, create the same index, but add {{urn:join}} to {{predicates}} instead of {{additionalJoins}}:
{code}
# Lucene4 snippet - create index with the join predicate actually indexed
luc4:my-index-name luc4:createIndex "predicates=...,urn:join"
{code}
The filtering itself is done through searching. Since Lucene4 creates Lucene document field for each predicate and the field name is exactly the predicate URI, you can utilize that through the Lucene query syntax:
{code}
# Lucene4 snippet - search: equivalent to ?entity luc2:my-index-name "query"
?entity luc4:my-index-name "+(query) +urn\\:join:joinValue"
{code}

The {{optionalJoins}} parameter is still present in Lucene4. Entities that have the specified predicate values OR lack predicates completely are indexed, while the rest of the entities are not. The optional joins predicate values are indexed as the other predicates in a Lucene field per predicate, which allows to search for specific values, as described above in the Additional joins section.

For example, if you create the following index:
{code}
luc4:my-index-name luc4:createIndex "predicates=urn:label;optionalJoins=urn:join,ok"
{code}
and then insert some entities:
{code}
# the entity bellow will be indexed because it has a matching value for <urn:join>
<entity:will-be-indexed> <urn:label> "this entity will be indexed"
<entity:will-be-indexed> <urn:join> "ok"

# the entity below will be indexed because it lacks the predicate completely
<entity:will-be-indexed-too> <urn:label> "this entity will be indexed too"

# the entity below will not be indexed - different <urn:join> value
<entity:will-not-be-indexed> <urn:join> "cancel"
{code}

Querying on urn:join is possible as in the additional joins, in the example above:
{code}
# will return only the entities that have this specific value for the optional join predicate
?entity luc4:my-index-name "words... +urn\\:join:ok"

To specify different default values for _<urn:join>_, create such an index:
{code}
luc4:my-index-name luc4:createIndex "predicates=urn:label;optionalJoins=urn:join,ok;optionalJoinDefaults=urn:join,newdefault"
{code}

Optional join predicate values are indexed, but not tokenised, which means that queries for them should match exactly.

h3. Search options

* The {{return.entities}} parameter is removed. Lucene4 always acts as Lucene2 with {{return.entities=dedup}}.
* The {{order.by}} parameter is added to allow specifying predicates to sort.

h2. User's Guide

h3. Creating an index

To create an index, issue the following SPARQL update query

{code}
PREFIX luc4:<http://www.ontotext.com/owlim/lucene4#>
INSERT DATA {
luc4:my-index-name luc4:createIndex "<index-options>" .
}
{code}

where *<index-options>* can be a combination of the following options, separated by a semicolon ';':
* {{stripMarkup=true\|false}} \- specifying whether to strip tags from HTML/XML literals (*false* by default);
* {{autoUpdate=true\|false}} \- specifying whether to keep the index automatically up-to-date (*true* by default);
* {{enableSnippets=true\|false}} \- specifying whether to enable snippets in this index. (As of 2013-12-15, this is a dummy flag and snippets are *always enabled*. You should generally pass a meaningful value here, in case we optimise our implementation later.)
* {{analyzer=<analyzer-class-name>}} \- specifying which Lucene analyzer to use when indexing literals in this index. There are two options here:
** directly specifying the Lucene analyzer class name - in this case, the analyzer should either have a default constructor or a constructor accepting a single {{org.apache.lucene.util.Version}} parameter. If you specify an analyzer that does not have one of these constructors, the index will not be created.
** specifying a class derived from {{com.ontotext.trree.plugin.lucene4.AnalyzerFactory}}
* {{predicates=<comma-separated-list-of-URIs>}} \- if specified, only triples with these predicates will be listed;
* {{languages=<comma-separated-languages>}} \- if specified, only literals tagged with the listed languages will be indexed;

{code}
PREFIX luc4:<http://www.ontotext.com/owlim/lucene4#>
INSERT DATA {
# creates an index, only indexing rdfs:comment-s with snippets enabled
luc4:my-index-name luc4:createIndex "predicates=http://www.w3.org/2000/01/rdf-schema#comment;enableSnippets=true" .
}
{code}

{code}
PREFIX luc4:<http://www.ontotext.com/owlim/lucene4#>
INSERT DATA {
# creates an index, only indexing entities with rdf:type that's either http://example.com/Type1 or http://example.com/Type2; and only indexing rdfs:label-s
luc4:my-index-name luc4:createIndex "types=http://example.com/Type1,http://example.com/Type2; predicates=http://www.w3.org/2000/01/rdf-schema#label" .
}
{code}

{code}
PREFIX luc4:<http://www.ontotext.com/owlim/lucene4#>
INSERT DATA {
# creates an index, only indexing @en literals or literals without a language tag, use Lucene's EnglishAnalyzer
luc4:my-index-name luc4:createIndex "languages=en,;analyzer=org.apache.lucene.analysis.en.EnglishAnalyzer" .
}
{code}

h3. Drop an index

Example:
{code}
PREFIX luc4:<http://www.ontotext.com/owlim/lucene4#>
INSERT DATA {
# drops an index uniquely specified by its URI
?indexUri luc4:dropIndex ""
}
{code}

h3. List all indices

Example:
{code}
PREFIX luc4:<http://www.ontotext.com/owlim/lucene4#>
SELECT ?uri ?name WHERE {
?uri luc4:list ?name
}
{code}

h3. Query indices health

Indices might become corrupt due to disk failure or other issues. The {{luc4:healthCheck}} predicate returns a list of indices along with their health status. In the example below, ?uri will bind to

{code}
PREFIX luc4:<http://www.ontotext.com/owlim/lucene4#>
SELECT ?uri ?health WHERE {
?uri luc4:healthCheck ?health .
}
{code}

| limit \\ | int \\ | 2^31-1 \\ | Lucene query limit - the maximum number of results which to return. \\ |
| snippet.size \\ | int \\ | 250 | The size of the returned snippets. \\ |
| class \\ | string \\ | none | Hit highlights are represented with {{<span>}}. This optional parameter provides the class, i.e. {{<span class="xxx">}} \\ |

SELECT ?entity ?score ?snippet ?facetPredicate ?facetValue ?facetCount WHERE {
?r lucene4:basicFacets ( "query-string" "facets=urn:facet1,urn:facet2" ) . # ?r now contains dummy blank node
{
?r lucene4:entities ?entity . # ?entity will bind to the URIs of all entities that matched the query
?entity lucene4:score ?score . # ?score will bind to the Lucene score of the corresponding ?entity for this search
?entity lucene4:snippet ?snippet . # ?snippet will bind to a relevant snippet of the corresponding ?entity for this search
} UNION {
?r lucene4:facets ?facet . # ?facet will bind to all facet results. ?facet itself will be dummy blank node, use the special predicates below to extract information
?facet lucene4:facetPredicate ?facetPredicate . # a predicate for this facet, will be either urn:facet1 or urn:facet2 in this example
?facet lucene4:facetValue ?facetValue . # the facet predicate value for the current facet
?facet lucene4:facetCount ?facetCount . # the number of entities that matched the query having ?facetValue as value for their ?facetPredicate
}

* ?entity [http://www.ontotext.com/lucene4#score] ?score - binds ?score to the score of the result.
* ?entity [http://www.ontotext.com/lucene4#snippet] ?snippet - binds ?snippet to the extracted snippet, with highlights.

h4. Additional predicates allowed on bound facets results

* ?facet [http://www.ontotext.com/lucene4#facetPredicate] ?predicate - binds ?predicate to the URI of the current facet predicate.
* ?facet [http://www.ontotext.com/lucene4#facetValue] ?value - binds ?value to a value of the ?predicate (and up to {{facets.limit}} values of ?predicate, ordered by the aggregate count in the result set).
* ?facet [http://www.ontotext.com/lucene4#facetCount] ?count - binds ?count to the number of entities in the result set that have ?value as value of ?predicate.

?entity luc4:index-name "query string"

SELECT ?entity WHERE {
?entity luc4:index-name ("query string" "limit=10;snippet.size=20")

SELECT ?entity WHERE {
?entity luc4:index-name ("query string" "limit=10;offset=10;order.by=http://www.w3.org/2000/01/rdf-schema#label")
}
{code}

PREFIX luc4:<http://www.ontotext.com/owlim/lucene4#>
INSERT DATA {
<http://www.ontotext.com/owlim/lucene4#sampleIndex> luc4:createIndex "languages=en,;analyzer=org.apache.lucene.analysis.en.EnglishAnalyzer;predicates=http://www.w3.org/2000/01/rdf-schema#label;enableSnippets=true" .
}
{code}

Now that the index is created, you can run the following query to obtain the top 20 entries that start with "a" and snippet where the literal occurs, including the Lucene score.
{code}
PREFIX luc4:<http://www.ontotext.com/owlim/lucene4#>
SELECT * WHERE {
?entity luc4:sampleIndex ("a*" "return.entities=true;limit=20") .
?entity luc4:snippet ?snippet .
?entity luc4:score ?score .
}
{code}

h3. Facets example

Consider, the following RDF data (in turtle format)
{code}
@prefix rdf:<http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
@prefix rdfs:<http://www.w3.org/2000/01/rdf-schema#> .

<urn:a>
rdf:type <urn:Type1> ;
<test:facet> "facet-value-1" ;
rdfs:comment "this is instance a of Type1, hello world" .

<urn:b>
rdf:type <urn:Type2> ;
rdfs:comment "this is instance b of Type2, hello world" .

<urn:c>
rdf:type <urn:Type1> ;
<test:facet> "facet-value-2" ;
rdfs:comment "this is instance c of Type1, hello world" .

<urn:d>
rdf:type <urn:Type1> ;
<test:facet> "facet-value-1" ;
rdfs:comment "this is instance d of Type1, hello world" .
{code}

Now create an index, using rdf:type and test:facet as facet predicates, indexing rdfs:comment and having no type restriction:
{code}
PREFIX luc4:<http://www.ontotext.com/owlim/lucene4#>
INSERT DATA {
<http://www.ontotext.com/owlim/lucene4#sampleIndex> luc4:createIndex "predicates=http://www.w3.org/2000/01/rdf-schema#comment;facets=http://www.w3.org/1999/02/22-rdf-syntax-ns#type,test:facet" .

SELECT ?entity ?score ?facetPredicate ?facetValue ?facetCount WHERE {
# note empty query string is allowed and will just match all documents
?r lucene4:sampleIndex ( "" "facets=test:facet,http://www.w3.org/1999/02/22-rdf-syntax-ns#type" ) .
{
?r lucene4:entities ?entity .
?entity lucene4:score ?score .
} UNION {
?r lucene4:facets ?facet .
?facet lucene4:facetPredicate ?facetPredicate .
?facet lucene4:facetValue ?facetValue .
?facet lucene4:facetCount ?facetCount .
}

| 1.0 | urn:b | | | |
| 1.0 | urn:c | | | |
| 1.0 | urn:d | | | |
| | | facet-value-1 | 2.0 | test:facet |
| | | facet-value-2 | 1.0 | test:facet |
| | | urn:Type1 | 3.0 | [http://www.w3.org/1999/02/22-rdf-syntax-ns#type] |
| | | urn:Type2 | 1.0 | [http://www.w3.org/1999/02/22-rdf-syntax-ns#type] |

h2. FAQ

h3. How to use UNION with Lucene4?

*A:* Just like in a normal query. Consider the following example:
{code}
PREFIX luc4:<http://www.ontotext.com/owlim/lucene4#>
SELECT ?c WHERE {
?s luc4:content ("query string" "limit=10;snippet.size=200") .
{
?s rdf:type <http://data.ontotext.com/ontologies/ontology1/Type1> .
bind (?s as ?c) .
}
UNION
{
?s rdf:type <http://data.ontotext.com/ontologies/ontology2/Type2> .
?c <http://data.ontotext.com/ontologies/ontology2/Predicate1> ?s .
}

SELECT ?c ?snippet WHERE {
?c rdf:type <http://data.ontotext.com/ontologies/ontology1/Type1> .

# LUCENE QUERY
{
?c luc4:content ("gold" "return.entities=true;limit=10;snippet.size=200") .
?c luc4:snippet ?snippet .
?c luc4:score ?score .
}
UNION
{
?annotation rdf:type <http://data.ontotext.com/ontologies/ontology2/Type2> .
?annotation luc4:annotations ("gold" "return.entities=true;limit=10;snippet.size=200") .
?annotation luc4:snippet ?snippet .
?annotation luc4:score ?score .
?c <http://data.ontotext.com/ontologies/ontology2/Predicate1> ?annotation .
}

{code}
PREFIX luc4:<http://www.ontotext.com/owlim/lucene4#>
INSERT {
?indexUri luc4:dropIndex "" .
} WHERE {
?indexUri luc4:list "myIndex" .
};
{code}

SELECT ?entity WHERE {
?entity luc4:index-name ('''"City of Manchester"''' "return.entities=true;limit=10;snippet.size=200")

Yes, you can. Go for it\!