Chapter 3. Developer Reference

// get QueryManager

QueryManager queryManager = workspace.getQueryManager();

// make SQL query

Query query = queryManager.createQuery("SELECT * FROM nt:base ", Query.SQL);

// execute query

QueryResult result = query.execute();

Query result processing

// get QueryManager

QueryManager queryManager = workspace.getQueryManager();

// make XPath query

Query query = queryManager.createQuery("//element(*,nt:base)", Query.XPATH);

// execute query

QueryResult result = query.execute();

// fetch query result

    QueryResult result = query.execute();

Now you can get results in an iterator of nodes:

NodeIterator it = result.getNodes();

Or, get the result in a table:

// get column names

    String[] columnNames = result.getColumnNames();

    // get column rows

    RowIterator rowIterator = result.getRows();

    while(rowIterator.hasNext()){

    // get next row

    Row row = rowIterator.nextRow();

    // get all values of row

    Value[] values = row.getValues();

    }

Scoring

The result returns a score for each row in the result set. The score contains a value that indicates a rating of how well the result node matches the query. A high value means a better matching than a low value. This score can be used for ordering the result.

eXo JCR Scoring is a mapping of Lucene scoring. For more in-depth understanding, see Lucene documentation.

jcr:score is counted in the next way - (lucene score)*1000f.

Score may be increased for specified nodes, see Index boost value.

Also, see an example Order by score.

Query usecases

The section shows you the different usecases of query. Through these usercases, you will know how the repository structure is, and how to create and execute a query, how to iterate over the result set and according to the query what kind of results you will get.

Query result settings

SetOffset and SetLimit

Select all nodes with the 'nt:unstructured' primary type and returns only 3 nodes starting with the second node in the list.

Common info: The QueryImpl class has two methods: one to indicate how many results shall be returned at most, and another to fix the starting position.
- setOffset(long offset): Set the start offset of the result set.
- setLimit(long position): Set the maximum size of the result set.
Repository structure: Repository contains mix:title nodes where jcr:title has different values.
- root

Only those nodes are found to which the session has READ permission. See also Access Control.

SQL

// make SQL query

QueryManager queryManager = workspace.getQueryManager();

// create query

String sqlStatement = "SELECT * FROM nt:unstructured";

QueryImpl query = (QueryImpl)queryManager.createQuery(sqlStatement, Query.SQL);

//return starting with second result

query.setOffset(1);

// return 3 results

query.setLimit(3);

// execute query and fetch result

QueryResult result = query.execute();

Fetching result
Let's get nodes:
```
NodeIterator it = result.getNodes();


if(it.hasNext())

{

   Node findedNode = it.nextNode();

}
```
In usual case (without using the setOffset and setLimit methods), Node iterator returns all nodes (node1...node6). But in this case, NodeIterator will return "node2","node3" and "node4".
\[node1 node2 node3 node4 node5 node6\]

Type constraints

Find all nodes

Repository contains many different nodes.

root
- folder1 (nt:folder)
  - document1 (nt:file)
  - folder2 (nt:folder)
    document2 (nt:unstructured)
    document3 (nt:folder)

// make SQL query

        QueryManager queryManager = workspace.getQueryManager();

        // create query

        String sqlStatement = "SELECT * FROM nt:base";

        Query query = queryManager.createQuery(sqlStatement, Query.SQL);

        // execute query and fetch result

        QueryResult result = query.execute();

// make XPath query

QueryManager queryManager = workspace.getQueryManager();

// create query

String xpathStatement = "//element(*,nt:base)";

Query query = queryManager.createQuery(xpathStatement, Query.XPATH);

// execute query and fetch result

QueryResult result = query.execute();

NodeIterator will return "folder1", "folder2","document1","document2","document3", and another nodes in workspace if they are here.

NodeIterator it = result.getNodes();


if(it.hasNext())

{

   Node findedNode = it.nextNode();

}

String[] columnNames = result.getColumnNames();

RowIterator rit = result.getRows();

while (rit.hasNext())

{

   Row row = rit.nextRow();

   // get values of the row

   Value[] values = row.getValues();

}

Find all nodes whose primary type is "nt:file".

jcr:path	jcr:score
/folder1	1000
/folder1/document1	1000
/folder1/folder2	1000
/folder1/folder2/document2	1000
/folder1/folder2/document3	1000
...	...

Find all nodes by primary type

The repository contains nodes with different primary types and mixin types.

root

// make SQL query

QueryManager queryManager = workspace.getQueryManager();

// create query

String sqlStatement = "SELECT * FROM nt:file";

Query query = queryManager.createQuery(sqlStatement, Query.SQL);

// execute query and fetch result

QueryResult result = query.execute();

// make XPath query

QueryManager queryManager = workspace.getQueryManager();

// create query

String xpathStatement = "//element(*,nt:file)";

Query query = queryManager.createQuery(xpathStatement, Query.XPATH);

// execute query and fetch result

QueryResult result = query.execute();

NodeIterator will return "document2" and "document3".

NodeIterator it = result.getNodes();


if(it.hasNext())

{

   Node findedNode = it.nextNode();

}

String[] columnNames = result.getColumnNames();

RowIterator rit = result.getRows();

while (rit.hasNext())

{

   Row row = rit.nextRow();

   // get values of the row

   Value[] values = row.getValues();

}

Find all nodes in repository that contains a "mix:title" mixin type.

jcr:path	jcr:score
/document2	2674
/document3	2674

Find all nodes by mixin type

The repository contains nodes with different primary types and mixin types.

root

// make SQL query

QueryManager queryManager = workspace.getQueryManager();

// create query

String sqlStatement = "SELECT * FROM mix:title";

Query query = queryManager.createQuery(sqlStatement, Query.SQL);

// execute query and fetch result

QueryResult result = query.execute();

// make XPath query

QueryManager queryManager = workspace.getQueryManager();

// create query

String xpathStatement = "//element(*,mix:title)";

Query query = queryManager.createQuery(xpathStatement, Query.XPATH);

// execute query and fetch result

QueryResult result = query.execute();

The NodeIterator will return "document1" and "document3".

NodeIterator it = result.getNodes();


if(it.hasNext())

{

   Node findedNode = it.nextNode();

}

String[] columnNames = result.getColumnNames();

RowIterator rit = result.getRows();

while (rit.hasNext())

{

   Row row = rit.nextRow();

   // get values of the row

   Value[] values = row.getValues();

}

Find all nodes with the 'mix:title' mixin type where the 'prop_pagecount' property contains a value less than 90. Only select the title of each node.

jcr:title	...	jcr:path	jcr:score
First document	...	/document1	2674
Second document	...	/document3	2674

Property constraints

Property comparison

Repository contains several mix:title nodes, where each prop_pagecount contains a different value.

root

// make SQL query

QueryManager queryManager = workspace.getQueryManager();

// create query

String sqlStatement = "SELECT jcr:title FROM mix:title WHERE prop_pagecount < 90";

Query query = queryManager.createQuery(sqlStatement, Query.SQL);

// execute query and fetch result

QueryResult result = query.execute();

// make XPath query

QueryManager queryManager = workspace.getQueryManager();

// create query

String xpathStatement = "//element(*,mix:title)[@prop_pagecount < 90]/@jcr:title";

Query query = queryManager.createQuery(xpathStatement, Query.XPATH);

// execute query and fetch result

QueryResult result = query.execute();

The NodeIterator will return "document3".

NodeIterator it = result.getNodes();


if(it.hasNext())

{

   Node findedNode = it.nextNode();

}

String[] columnNames = result.getColumnNames();

RowIterator rit = result.getRows();

while (rit.hasNext())

{

   Row row = rit.nextRow();

   // get values of the row

   Value[] values = row.getValues();

}

Find all nodes with the 'mix:title' mixin type and where the 'jcr:title' property starts with 'P'.

jcr:title	jcr:path	jcr:score
Puss in Boots	/document3	1725

LIKE constraint

Note

The repository contains 3 mix:title nodes, where each jcr:title has a different value.

root

// make SQL query

QueryManager queryManager = workspace.getQueryManager();

// create query

String sqlStatement = "SELECT * FROM mix:title WHERE jcr:title LIKE 'P%'";

Query query = queryManager.createQuery(sqlStatement, Query.SQL);

// execute query and fetch result

QueryResult result = query.execute();

// make XPath query

QueryManager queryManager = workspace.getQueryManager();

// create query

String xpathStatement = "//element(*,mix:title)[jcr:like(@jcr:title, 'P%')]";

Query query = queryManager.createQuery(xpathStatement, Query.XPATH);

// execute query and fetch result

QueryResult result = query.execute();

The NodeIterator will return "document2" and "document3".

NodeIterator it = result.getNodes();


if(it.hasNext())

{

   Node findedNode = it.nextNode();

}

String[] columnNames = result.getColumnNames();

RowIterator rit = result.getRows();

while (rit.hasNext())

{

   Row row = rit.nextRow();

   // get values of the row

   Value[] values = row.getValues();

}

Find all nodes with the 'mix:title' mixin type and whose 'jcr:title' property starts with 'P%ri'.

jcr:title	jcr:description	jcr:path	jcr:score
Prison break	Run, Forest, run ))	/document2	4713
Panopticum	It's imagine film	/document3	5150

Escaping in LIKE statements

As you see "P%rison break" contains the symbol '%'. This symbol is reserved for LIKE comparisons.

Within the LIKE pattern, literal instances of percent ("%") or underscore ("_") must be escaped. The SQL ESCAPE clause allows the definition of an arbitrary escape character within the context of a single LIKE statement. The following example defines the backslash ' \' as escape character:

SELECT * FROM mytype WHERE a LIKE 'foo\%' ESCAPE '\'

XPath does not have any specification for defining escape symbols, so you must use the default escape character (' \').

The repository contains mix:title nodes, where jcr:title can have different values.

root

// make SQL query

QueryManager queryManager = workspace.getQueryManager();

// create query

String sqlStatement = "SELECT * FROM mix:title WHERE jcr:title LIKE 'P#%ri%' ESCAPE '#'";

Query query = queryManager.createQuery(sqlStatement, Query.SQL);

// execute query and fetch result

QueryResult result = query.execute();

// make XPath query

QueryManager queryManager = workspace.getQueryManager();

// create query

String xpathStatement = "//element(*,mix:title)[jcr:like(@jcr:title, 'P\\%ri%')]";

Query query = queryManager.createQuery(xpathStatement, Query.XPATH);

// execute query and fetch result

QueryResult result = query.execute();

NodeIterator will return "document2".

NodeIterator it = result.getNodes();


if(it.hasNext())

{

   Node findedNode = it.nextNode();

}

String[] columnNames = result.getColumnNames();

RowIterator rit = result.getRows();

while (rit.hasNext())

{

   Row row = rit.nextRow();

   // get values of the row

   Value[] values = row.getValues();

}

Find all nodes with a 'mix:title' mixin type and where the 'jcr:title' property does NOT start with a 'P' symbol.

jcr:title	jcr:description	jcr:path	jcr:score
P%rison break	Run, Forest, run ))	/document2	7452

NOT constraint

The repository contains a mix:title node where the jcr:title has different values.

root

// make SQL query

QueryManager queryManager = workspace.getQueryManager();

// create query

String sqlStatement = "SELECT * FROM mix:title WHERE NOT jcr:title LIKE 'P%'";

Query query = queryManager.createQuery(sqlStatement, Query.SQL);

// execute query and fetch result

QueryResult result = query.execute();

// make XPath query

QueryManager queryManager = workspace.getQueryManager();

// create query

String xpathStatement = "//element(*,mix:title)[not(jcr:like(@jcr:title, 'P%'))]";

Query query = queryManager.createQuery(xpathStatement, Query.XPATH);

// execute query and fetch result

QueryResult result = query.execute();

NodeIterator will return "document1".

Let's get the nodes:

NodeIterator it = result.getNodes();


if(it.hasNext())

{

   Node findedNode = it.nextNode();

}

String[] columnNames = result.getColumnNames();

RowIterator rit = result.getRows();

while (rit.hasNext())

{

   Row row = rit.nextRow();

   // get values of the row

   Value[] values = row.getValues();

}

Find all "fairytales" with a page count more than 90 pages.

jcr:title	jcr:description	jcr:path	jcr:score
Star wars	Dart rules!!	/document1	4713

AND constraint

How does it sound in JCR terms - Find all nodes with the 'mix:title' mixin type where the 'jcr:description' property equals "fairytale" and whose "prop_pagecount" property value is less than 90.

Note

The repository contains "mix:title" nodes, where "prop_pagecount" has different values.

root

// make SQL query

QueryManager queryManager = workspace.getQueryManager();

// create query

String sqlStatement = "SELECT * FROM mix:title WHERE jcr:description = 'fairytale' AND prop_pagecount > 90";

Query query = queryManager.createQuery(sqlStatement, Query.SQL);

// execute query and fetch result

QueryResult result = query.execute();

// make XPath query

QueryManager queryManager = workspace.getQueryManager();

// create query

String xpathStatement = "//element(*,mix:title)[@jcr:description='fairytale' and @prop_pagecount > 90]";

Query query = queryManager.createQuery(xpathStatement, Query.XPATH);

// execute query and fetch result

QueryResult result = query.execute();

NodeIterator will return "document2".

NodeIterator it = result.getNodes();


if(it.hasNext())

{

   Node findedNode = it.nextNode();

}

String[] columnNames = result.getColumnNames();

RowIterator rit = result.getRows();

while (rit.hasNext())

{

   Row row = rit.nextRow();

   // get values of the row

   Value[] values = row.getValues();

}

Find all documents whose title is 'Cinderella' or whose description is 'novel'.

jcr:title	jcr:description	prop_pagecount	jcr:path	jcr:score
Cinderella	fairytale	100	/document2	7086

OR constraint

How does it sound in jcr terms? - Find all nodes with the 'mix:title' mixin type whose 'jcr:title' property equals "Cinderella" or whose "jcr:description" property value is "novel".

The repository contains mix:title nodes, where jcr:title and jcr:description have different values.

root

// make SQL query

QueryManager queryManager = workspace.getQueryManager();

// create query

String sqlStatement = "SELECT * FROM mix:title WHERE jcr:title = 'Cinderella' OR jcr:description = 'novel'";

Query query = queryManager.createQuery(sqlStatement, Query.SQL);

// execute query and fetch result

QueryResult result = query.execute();

// make XPath query

QueryManager queryManager = workspace.getQueryManager();

// create query

String xpathStatement = "//element(*,mix:title)[@jcr:title='Cinderella' or @jcr:description = 'novel']";

Query query = queryManager.createQuery(xpathStatement, Query.XPATH);

// execute query and fetch result

QueryResult result = query.execute();

NodeIterator will return "document1" and "document2".

NodeIterator it = result.getNodes();


if(it.hasNext())

{

   Node findedNode = it.nextNode();

}

String[] columnNames = result.getColumnNames();

RowIterator rit = result.getRows();

while (rit.hasNext())

{

   Row row = rit.nextRow();

   // get values of the row

   Value[] values = row.getValues();

}

Find all nodes with the 'mix:title' mixin type where the 'jcr:description' property does not exist (is null).

jcr:title	jcr:description	jcr:path	jcr:score
War and peace	novel	/document1	3806
Cinderella	fairytale	/document2	3806

Property existence constraint

The repository contains mix:title nodes, in one of these nodes the jcr:description property is null.

root

// make SQL query

QueryManager queryManager = workspace.getQueryManager();

// create query

String sqlStatement = "SELECT * FROM mix:title WHERE jcr:description IS NULL";

Query query = queryManager.createQuery(sqlStatement, Query.SQL);

// execute query and fetch result

QueryResult result = query.execute();

// make XPath query

QueryManager queryManager = workspace.getQueryManager();

// create query

String xpathStatement = ""//element(*,mix:title)[not(@jcr:description)]"";

Query query = queryManager.createQuery(xpathStatement, Query.XPATH);

// execute query and fetch result

QueryResult result = query.execute();

NodeIterator will return "document3".

NodeIterator it = result.getNodes();


if(it.hasNext())

{

   Node findedNode = it.nextNode();

}

String[] columnNames = result.getColumnNames();

RowIterator rit = result.getRows();

while (rit.hasNext())

{

   Row row = rit.nextRow();

   // get values of the row

   Value[] values = row.getValues();

}

Find all nodes with the 'mix:title' mixin type and where the 'jcr:title' property equals 'casesensitive' in lower or upper case.

jcr:title	jcr:description	jcr:path	jcr:score
Titanic	null	/document3	1947

Find nodes in a case-insensitive way

The repository contains mix:title nodes, whose jcr:title properties have different values.

root

UPPER case

// make SQL query

QueryManager queryManager = workspace.getQueryManager();

// create query

String sqlStatement = "SELECT * FROM mix:title WHERE UPPER(jcr:title) = 'CASESENSITIVE'";

Query query = queryManager.createQuery(sqlStatement, Query.SQL);

// execute query and fetch result

QueryResult result = query.execute();

// make XPath query

QueryManager queryManager = workspace.getQueryManager();

// create query

String xpathStatement = "//element(*,mix:title)[fn:upper-case(@jcr:title)='CASESENSITIVE']";

Query query = queryManager.createQuery(xpathStatement, Query.XPATH);

// execute query and fetch result

QueryResult result = query.execute();

LOWER case

// make SQL query

            QueryManager queryManager = workspace.getQueryManager();

            // create query

            String sqlStatement = "SELECT * FROM mix:title WHERE LOWER(jcr:title) = 'casesensitive'";

            Query query = queryManager.createQuery(sqlStatement, Query.SQL);

            // execute query and fetch result

            QueryResult result = query.execute();

// make XPath query

            QueryManager queryManager = workspace.getQueryManager();

            // create query

            String xpathStatement = "//element(*,mix:title)[fn:lower-case(@jcr:title)='casesensitive']";

            Query query = queryManager.createQuery(xpathStatement, Query.XPATH);

            // execute query and fetch result

            QueryResult result = query.execute();

NodeIterator will return "document1", "document2" and "document3" (in all examples).

NodeIterator it = result.getNodes();


if(it.hasNext())

{

   Node findedNode = it.nextNode();

}

String[] columnNames = result.getColumnNames();

RowIterator rit = result.getRows();

while (rit.hasNext())

{

   Row row = rit.nextRow();

   // get values of the row

   Value[] values = row.getValues();

}

Find all nodes of the "nt:resource" primary type whose "jcr:lastModified" property value is greater than 2006-06-04 and less than 2008-06-04.

jcr:title	...	jcr:path
CaseSensitive	...	/document1
casesensitive	...	/document2
caseSENSITIVE	...	/document3

Date property comparison

Repository contains "nt:resource" nodes with different values of the "jcr:lastModified" property

root

In SQL you have to use the keyword TIMESTAMP for date comparisons. Otherwise, the date would be interpreted as a string. The date has to be surrounded by single quotes (TIMESTAMP 'datetime') and in the ISO standard format: YYYY-MM-DDThh:mm:ss.sTZD ( http://en.wikipedia.org/wiki/ISO_8601 and well explained in a W3C note http://www.w3.org/TR/NOTE-datetime).

You will see that it can be a date only (YYYY-MM-DD) but also a complete date and time with a timezone designator (TZD).

// make SQL query

QueryManager queryManager = workspace.getQueryManager();

// create query

StringBuffer sb = new StringBuffer();

sb.append("select * from nt:resource where ");

sb.append("( jcr:lastModified >= TIMESTAMP '");

sb.append("2006-06-04T15:34:15.917+02:00");

sb.append("' )");

sb.append(" and ");

sb.append("( jcr:lastModified <= TIMESTAMP '");

sb.append("2008-06-04T15:34:15.917+02:00");

sb.append("' )");

String sqlStatement = sb.toString();

Query query = queryManager.createQuery(sqlStatement, Query.SQL);

// execute query and fetch result

QueryResult result = query.execute();

XPath

Compared to the SQL format, you have to use the keyword xs:dateTime and surround the datetime by extra brackets: xs:dateTime('datetime'). The actual format of the datetime also conforms with the ISO date standard.

// make XPath query

QueryManager queryManager = workspace.getQueryManager();

// create query

StringBuffer sb = new StringBuffer();

sb.append("//element(*,nt:resource)");

sb.append("[");

sb.append("@jcr:lastModified >= xs:dateTime('2006-08-19T10:11:38.281+02:00')");

sb.append(" and ");

sb.append("@jcr:lastModified <= xs:dateTime('2008-06-04T15:34:15.917+02:00')");

sb.append("]");

String xpathStatement = sb.toString();

Query query = queryManager.createQuery(xpathStatement, Query.XPATH);

// execute query and fetch result

QueryResult result = query.execute();

NodeIterator will return "/document3/jcr:content".

NodeIterator it = result.getNodes();


if(it.hasNext())

{

   Node foundNode = it.nextNode();

}

String[] columnNames = result.getColumnNames();

RowIterator rit = result.getRows();

while (rit.hasNext())

{

   Row row = rit.nextRow();

   // get values of the row

   Value[] values = row.getValues();

}

Find all nodes with the 'nt:file' primary type whose node name is 'document'. The node name is accessible by a function called "fn:name()".

jcr:lastModified	...	jcr:path
2007-01-19T15:34:15.917+02:00	...	/document3/jcr:content

Node name constraint

Note

"fn:name()" can be used ONLY with an equal('=') comparison.

The repository contains nt:file nodes with different names.

root

// make SQL query

QueryManager queryManager = workspace.getQueryManager();

// create query

String sqlStatement = "SELECT * FROM nt:file WHERE fn:name() = 'document'";

Query query = queryManager.createQuery(sqlStatement, Query.SQL);

// execute query and fetch result

QueryResult result = query.execute();

// make XPath query

QueryManager queryManager = workspace.getQueryManager();

// create query

String xpathStatement = "//element(*,nt:file)[fn:name() = 'document']";

Query query = queryManager.createQuery(xpathStatement, Query.XPATH);

// execute query and fetch result

QueryResult result = query.execute();

The NodeIterator will return the node whose fn:name equals "document".

NodeIterator it = result.getNodes();


if(it.hasNext())

{

   Node findedNode = it.nextNode();

}

String[] columnNames = result.getColumnNames();

RowIterator rit = result.getRows();

while (rit.hasNext())

{

   Row row = rit.nextRow();

   // get values of the row

   Value[] values = row.getValues();

}

Find all nodes with the 'nt:unstructured' primary type whose property 'multiprop' contains both values "one" and "two".

jcr:path	jcr:score
/document1	3575

Multivalue property comparison

The repository contains "nt:unstructured" nodes with different 'multiprop' properties.

root

// make SQL query

QueryManager queryManager = workspace.getQueryManager();

// create query

String sqlStatement = "SELECT * FROM nt:unstructured WHERE multiprop = 'one' AND multiprop = 'two'";

Query query = queryManager.createQuery(sqlStatement, Query.SQL);

// execute query and fetch result

QueryResult result = query.execute();

// make XPath query

QueryManager queryManager = workspace.getQueryManager();

// create query

String xpathStatement = "//element(*,nt:unstructured)[@multiprop = 'one' and @multiprop = 'two']";

Query query = queryManager.createQuery(xpathStatement, Query.XPATH);

// execute query and fetch result

QueryResult result = query.execute();

The NodeIterator will return "node1" and "node2".

NodeIterator it = result.getNodes();


if(it.hasNext())

{

   Node findedNode = it.nextNode();

}

String[] columnNames = result.getColumnNames();

RowIterator rit = result.getRows();

while (rit.hasNext())

{

   Row row = rit.nextRow();

   // get values of the row

   Value[] values = row.getValues();

}

Find a node with the 'nt:file' primary type that is located on the "/folder1/folder2/document1" exact path.

jcr:primarytyp	jcr:path	jcr:score
nt:unstructured	/node1	3806
nt:unstructured	/node2	3806

Path constraints

Exact path constraint

Repository filled by different nodes. There are several folders which contain other folders and files.

root
- folder1 (nt:folder)
  - folder2 (nt:folder)
    document1 (nt:file) // This document we want to find
    folder3 (nt:folder)
    document1 (nt:file)

// make SQL query

QueryManager queryManager = workspace.getQueryManager();

// we want find 'document1'

String sqlStatement = "SELECT * FROM nt:file WHERE jcr:path = '/folder1/folder2/document1'";

// create query

Query query = queryManager.createQuery(sqlStatement, Query.SQL);

// execute query and fetch result

QueryResult result = query.execute();

Remark: The indexes [1] are used in order to get the same result as the SQL statement. SQL by default only returns the first node, whereas XPath fetches by default all nodes.

// make SQL query

QueryManager queryManager = workspace.getQueryManager();

// we want to find 'document1'

String xpathStatement = "/jcr:root/folder1[1]/folder2[1]/element(document1,nt:file)[1]";

// create query

Query query = queryManager.createQuery(xpathStatement, Query.XPATH);

// execute query and fetch result

QueryResult result = query.execute();

NodeIterator will return expected "document1".

NodeIterator it = result.getNodes();


if(it.hasNext())

{

   Node findedNode = it.nextNode();

}

String[] columnNames = result.getColumnNames();

RowIterator rit = result.getRows();

while (rit.hasNext())

{

   Row row = rit.nextRow();

   // get values of the row

   Value[] values = row.getValues();

}

Find all nodes with the primary type 'nt:folder' that are children of node by the "/root1/root2" path. Only find children, do not find further descendants.

jcr:path	jcr:score
/folder1/folder2/document1	1030

Child node constraint

The repository is filled by "nt:folder" nodes. The nodes are placed in a multilayer tree.

root
- folder1 (nt:folder)
  - folder2 (nt:folder)
    folder3 (nt:folder) // This node we want to find
    folder4 (nt:folder) // This node is not child but a descendant of '/folder1/folder2/'.
    folder5 (nt:folder) // This node we want to find

The use of "%" in the LIKE statement includes any string, therefore there is a second LIKE statement that excludes the string which contains "/". In this way, child nodes are included but descendant nodes are excluded.

// make SQL query

QueryManager queryManager = workspace.getQueryManager();

// create query

String sqlStatement = "SELECT * FROM nt:folder WHERE jcr:path LIKE '/folder1/folder2/%' AND NOT jcr:path LIKE '/folder1/folder2/%/%'";

Query query = queryManager.createQuery(sqlStatement, Query.SQL);

// execute query and fetch result

QueryResult result = query.execute();

// make XPath query

QueryManager queryManager = workspace.getQueryManager();

// create query

String xpathStatement = "/jcr:root/folder1[1]/folder2[1]/element(*,nt:folder)";

Query query = queryManager.createQuery(xpathStatement, Query.XPATH);

// execute query and fetch result

QueryResult result = query.execute();

The NodeIterator will return "folder3" and "folder5".

NodeIterator it = result.getNodes();


if(it.hasNext())

{

   Node findedNode = it.nextNode();

}

String[] columnNames = result.getColumnNames();

RowIterator rit = result.getRows();

while (rit.hasNext())

{

   Row row = rit.nextRow();

   // get values of the row

   Value[] values = row.getValues();

}

Find all nodes with the 'nt:folder' primary type that are descendants of the "/folder1/folder2" node.

jcr:path	jcr:score
/folder1/folder2/folder3	1707
/folder1/folder2/folder5	1707

Find all descendant nodes

The repository contains "nt:folder" nodes. The nodes are placed in a multilayer tree.

root
- folder1 (nt:folder)
  - folder2 (nt:folder)
    folder3 (nt:folder) // This node we want to find
    folder4 (nt:folder) // This node we want to find
    folder5 (nt:folder) // This node we want to find

// make SQL query

QueryManager queryManager = workspace.getQueryManager();

// create query

String sqlStatement = "SELECT * FROM nt:folder WHERE jcr:path LIKE '/folder1/folder2/%'";

Query query = queryManager.createQuery(sqlStatement, Query.SQL);

// execute query and fetch result

QueryResult result = query.execute();

// make XPath query

QueryManager queryManager = workspace.getQueryManager();

// create query

String xpathStatement = "/jcr:root/folder1[1]/folder2[1]//element(*,nt:folder)";

Query query = queryManager.createQuery(xpathStatement, Query.XPATH);

// execute query and fetch result

QueryResult result = query.execute();

The NodeIterator will return "folder3", "folder4" and "folder5" nodes.

NodeIterator it = result.getNodes();


if(it.hasNext())

{

   Node findedNode = it.nextNode();

}

String[] columnNames = result.getColumnNames();

RowIterator rit = result.getRows();

while (rit.hasNext())

{

   Row row = rit.nextRow();

   // get values of the row

   Value[] values = row.getValues();

}

Select all nodes with the 'mix:title' mixin type and order them by the 'prop_pagecount' property.

jcr:path	jcr:score
/folder1/folder2/folder3	1000
/folder1/folder2/folder3/folder4	1000
/folder1/folder2/folder5	1000

Ordering specifying

Order by property

The repository contains several mix:title nodes, where 'prop_pagecount' has different values.

root

// make SQL query

QueryManager queryManager = workspace.getQueryManager();

// create query

String sqlStatement = "SELECT * FROM mix:title ORDER BY prop_pagecount ASC";

Query query = queryManager.createQuery(sqlStatement, Query.SQL);

// execute query and fetch result

QueryResult result = query.execute();

// make XPath query

QueryManager queryManager = workspace.getQueryManager();

// create query

String xpathStatement = "//element(*,mix:title) order by @prop_pagecount ascending";

Query query = queryManager.createQuery(xpathStatement, Query.XPATH);

// execute query and fetch result

QueryResult result = query.execute();

The NodeIterator will return nodes in the following order "document3", "document1", "document2".

NodeIterator it = result.getNodes();


if(it.hasNext())

{

   Node findedNode = it.nextNode();

}

String[] columnNames = result.getColumnNames();

RowIterator rit = result.getRows();

while (rit.hasNext())

{

   Row row = rit.nextRow();

   // get values of the row

   Value[] values = row.getValues();

}

Find all nodes with the 'nt:unstructured' primary type and sort them by the property value of descendant nodes with the relative path '/a/b'.

jcr:title	jcr:description	prop_pagecount	jcr:path	jcr:score
Puss in Boots	fairytale	1	/document3	1405
War and peace	roman	4	/document1	1405
Cinderella	fairytale	7	/document2	1405

Order by descendant node property

Note

This ORDER BY construction only works in XPath.

root

// make XPath query

QueryManager queryManager = workspace.getQueryManager();

// create query

String xpathStatement = "/jcr:root/* order by a/b/c/@prop descending;

Query query = queryManager.createQuery(xpathStatement, Query.XPATH);

// execute query and fetch result

QueryResult result = query.execute();

NodeIterator will return nodes in the following order - "node3","node2" and "node1".

NodeIterator it = result.getNodes();


if(it.hasNext())

{

   Node findedNode = it.nextNode();

}

String[] columnNames = result.getColumnNames();

RowIterator rit = result.getRows();

while (rit.hasNext())

{

   Row row = rit.nextRow();

   // get values of the row

   Value[] values = row.getValues();

}

Select all nodes with the mixin type 'mix:title' containing any word from the set {'brown','fox','jumps'}. Then, sort result by the score in ascending node. This way nodes that match better the query statement are ordered at the last positions in the result list.

jcr:primaryType	jcr:path	jcr:score
nt:unstructured	/testroot/node3	1000
nt:unstructured	/testroot/node2	1000
nt:unstructured	/testroot/node1	1000

Order by score

Info

SQL and XPath queries support both score constructions: jcr:score and jcr:score().

SELECT * FROM nt:base ORDER BY jcr:score [ASC|DESC]
SELECT * FROM nt:base ORDER BY jcr:score()[ASC|DESC]

//element(*,nt:base) order by jcr:score() [descending]
//element(*,nt:base) order by @jcr:score [descending]

Do not use "ascending" combined with jcr:score in XPath. The following XPath statement may throw an exception:

... order by jcr:score() ascending

Do not set any ordering specifier - ascending is default:

... order by jcr:score()

The repository contains mix:title nodes, where the jcr:description has different values.

root

// make SQL query

QueryManager queryManager = workspace.getQueryManager();

// create query

String sqlStatement = "SELECT * FROM mix:title WHERE CONTAINS(*, 'brown OR fox OR jumps') ORDER BY jcr:score() ASC";

Query query = queryManager.createQuery(sqlStatement, Query.SQL);

// execute query and fetch result

      QueryResult result = query.execute();

// make XPath query

QueryManager queryManager = workspace.getQueryManager();

// create query

String xpathStatement = "//element(*,mix:title)[jcr:contains(., 'brown OR fox OR jumps')] order by jcr:score()";

Query query = queryManager.createQuery(xpathStatement, Query.XPATH);

// execute query and fetch result

QueryResult result = query.execute();

NodeIterator will return nodes in the following order: "document3", "document2", "document1".

Let's get nodes

NodeIterator it = result.getNodes();


if(it.hasNext())

{

   Node findedNode = it.nextNode();

}

String[] columnNames = result.getColumnNames();

RowIterator rit = result.getRows();

while (rit.hasNext())

{

   Row row = rit.nextRow();

   // get values of the row

   Value[] values = row.getValues();

}

Ordering by jcr:path or jcr:name does not supported.

jcr:description	...	jcr:path	jcr:score
The fox is a nice animal.	...	/document3	2512
The brown fox lives in the forest.	...	/document2	3595
The quick brown fox jumps over the lazy dog.	...	/document1	5017

Order by path or name

Warning

There are two ways to order results, when path may be used as criteria:

Order by property with the NAME or PATH value type (JCR supports it)
Order by jcr:path or jcr:name - sort by the exact path or name of node (JCR does not support it).

If no order specification is supplied in the query statement, implementations may support document order on the result nodes (see the 6.6.4.2 Document Order section of JSR-170), and it is sorted by order number.

By default, (if query does not contain any ordering statements) result nodes are sorted by document order.

SELECT * FROM nt:unstructured WHERE jcr:path LIKE 'testRoot/%'

Fulltext search

Fulltext search by property

Find all nodes containing a 'mix:title' mixin type and whose 'jcr:description' contains "forest" string.

The repository is filled with nodes of the 'mix:title' mixin type and different values of the 'jcr:description' property.

root

// make SQL query

QueryManager queryManager = workspace.getQueryManager();

// we want find document which contains "forest" word

String sqlStatement = "SELECT \* FROM mix:title WHERE CONTAINS(jcr:description, 'forest')";

// create query

Query query = queryManager.createQuery(sqlStatement, Query.SQL);

// execute query and fetch result

QueryResult result = query.execute();

// make SQL query

QueryManager queryManager = workspace.getQueryManager();

// we want find document which contains "forest" word

String xpathStatement = "//element(*,mix:title)[jcr:contains(@jcr:description, 'forest')]";

// create query

Query query = queryManager.createQuery(xpathStatement, Query.XPATH);

// execute query and fetch result

QueryResult result = query.execute();

NodeIterator will return "document2".

NodeIterator it = result.getNodes();


if(it.hasNext())

{

   Node findedNode = it.nextNode();

}

String[] columnNames = result.getColumnNames();

RowIterator rit = result.getRows();

while (rit.hasNext())

{

   Row row = rit.nextRow();

   // get values of the row

   Value[] values = row.getValues();

}

Find nodes with the 'mix:title' mixin type where any property contains the 'break' string.

jcr:description	...	jcr:path
The brown fox lives in forest.	...	/document2

Fulltext search by all properties

Repository filled with different nodes with the 'mix:title' mixin type and different values of 'jcr:title' and 'jcr:description' properties.

root

// make SQL query

QueryManager queryManager = workspace.getQueryManager();

String sqlStatement = "SELECT * FROM mix:title WHERE CONTAINS(*,'break')";

// create query

Query query = queryManager.createQuery(sqlStatement, Query.SQL);

// execute query and fetch result

QueryResult result = query.execute();

// make SQL query

QueryManager queryManager = workspace.getQueryManager();

// we want find 'document1'

String xpathStatement = "//element(*,mix:title)[jcr:contains(.,'break')]";

// create query

Query query = queryManager.createQuery(xpathStatement, Query.XPATH);

// execute query and fetch result

QueryResult result = query.execute();

NodeIterator will return "document1" and "document2".

NodeIterator it = result.getNodes();


while(it.hasNext())

{

   Node findedNode = it.nextNode();

}

String[] columnNames = result.getColumnNames();

RowIterator rit = result.getRows();

while (rit.hasNext())

{

   Row row = rit.nextRow();

   // get values of the row

   Value[] values = row.getValues();

}

The nt:file node type represents a file. It requires a single child node called jcr:content. This node type represents images and other binary content in a JCRWiki entry. The node type of jcr:content is nt:resource which represents the actual content of a file.

jcr:title	jcr:description	...	jcr:path
Prison break.	Run, Forest, run ))	...	/document2
Titanic	An iceberg breaks a ship.	...	/document3

Find nt:file document by content of child jcr:content node

Find node with the primary type is 'nt:file' and which whose 'jcr:content' child node contains "cats".

Normally, you cannot find nodes (in this case) using just JCR SQL or XPath queries. But you can configure indexing so that nt:file aggregates jcr:content child node.

So, change indexing-configuration.xml:


<?xml version="1.0"?>

<!DOCTYPE configuration SYSTEM "http://www.exoplatform.org/dtd/indexing-configuration-1.2.dtd">

<configuration xmlns:jcr="http://www.jcp.org/jcr/1.0"

               xmlns:nt="http://www.jcp.org/jcr/nt/1.0">

    <aggregate primaryType="nt:file">

        <include>jcr:content</include>

        <include>jcr:content/*</include>

        <include-property>jcr:content/jcr:lastModified</include-property>

    </aggregate>

</configuration>

Now the content of 'nt:file' and 'jcr:content' ('nt:resource') nodes are concatenated in a single Lucene document. Then, you can make a fulltext search query by content of 'nt:file'. This search includes the content of 'jcr:content' child node.

Repository contains different nt:file nodes.

root

// make SQL query

QueryManager queryManager = workspace.getQueryManager();

// create query

String sqlStatement = "SELECT * FROM nt:file WHERE CONTAINS(*,'cats')";

Query query = queryManager.createQuery(sqlStatement, Query.SQL);

// execute query and fetch result

QueryResult result = query.execute();

// make XPath query

QueryManager queryManager = workspace.getQueryManager();

// create query

String xpathStatement = "//element(*,nt:file)[jcr:contains(.,'cats')]";

Query query = queryManager.createQuery(xpathStatement, Query.XPATH);

// execute query and fetch result

QueryResult result = query.execute();

NodeIterator will return "document2" and "document3".

NodeIterator it = result.getNodes();


if(it.hasNext())

{

   Node findedNode = it.nextNode();

}

String[] columnNames = result.getColumnNames();

RowIterator rit = result.getRows();

while (rit.hasNext())

{

   Row row = rit.nextRow();

   // get values of the row

   Value[] values = row.getValues();

}

In this example, you will create a new Analyzer, set it in the QueryHandler configuration, and make query to check it.

jcr:path	jcr:score
/document2	1030
/document3	1030

Set new analyzer and ignore accent symbols

Standard analyzer does not normalize accents like é,è,à; therefore, a word like 'tréma' will be stored to index as 'tréma'. In case you want to normalize such symbols and want to store 'tréma' word as 'trema', you can do it.

There are two ways of setting up new Analyzer:

The first way: Create a descendant class of SearchIndex with a new Analyzer (see Search configuration);

There is only one way to create a new Analyzer (if there is no previously created and accepted for your needs) and set it in Search index.

The second way: Register a new Analyzer in the QueryHandler configuration;

You will use the last one:

Create a new MyAnalyzer.

public class MyAnalyzer extends Analyzer

{

   @Override

   public TokenStream tokenStream(String fieldName, Reader reader)

   {

      StandardTokenizer tokenStream = new StandardTokenizer(reader);

      // process all text with standard filter

      // removes 's (as 's in "Peter's") from the end of words and removes dots from acronyms.

      TokenStream result = new StandardFilter(tokenStream);

      // this filter normalizes token text to lower case

      result = new LowerCaseFilter(result);

      // this one replaces accented characters in the ISO Latin 1 character set (ISO-8859-1) by their unaccented equivalents

      result = new ISOLatin1AccentFilter(result);

      // and finally return token stream

      return result;

   }

}


<workspace name="ws">

   ...

   <query-handler class="org.exoplatform.services.jcr.impl.core.query.lucene.SearchIndex">

      <properties>

         <property name="analyzer" value="org.exoplatform.services.jcr.impl.core.MyAnalyzer"/>

         ...

      </properties>

   </query-handler>

   ...

</workspace>

Check it with query:
Find nodes with the 'mix:title' mixin type where 'jcr:title' contains the "tréma" and "naïve" strings.

Repository filled by nodes with the 'mix:title' mixin type and different values of the 'jcr:title' property.

root
- node1 (mix:title) jcr:title = "tréma blabla naïve"
- node2 (mix:title) jcr:description = "trema come text naive"

// make SQL query

QueryManager queryManager = workspace.getQueryManager();

// create query

String sqlStatement = "SELECT * FROM mix:title WHERE CONTAINS(jcr:title, 'tr\u00E8ma na\u00EFve')";

Query query = queryManager.createQuery(sqlStatement, Query.SQL);

// execute query and fetch result

QueryResult result = query.execute();

// make SQL query

QueryManager queryManager = workspace.getQueryManager();

// create query

String xpathStatement = "//element(*,mix:title)[jcr:contains(@jcr:title, 'tr\u00E8ma na\u00EFve')]";

Query query = queryManager.createQuery(xpathStatement, Query.XPATH);

// execute query and fetch result

QueryResult result = query.execute();

NodeIterator will return "node1" and "node2". How is it possible? Remember that the MyAnalyzer transforms 'tréma' word to 'trema', so node2 accepts the constraints too.

NodeIterator it = result.getNodes();


if(it.hasNext())

{

   Node findedNode = it.nextNode();

}

String[] columnNames = result.getColumnNames();

RowIterator rit = result.getRows();

while (rit.hasNext())

{

   Row row = rit.nextRow();

   // get values of the row

   Value[] values = row.getValues();

}

High-lighting is not the default feature so you must set it in jcr-config.xml, also excerpt provider must be defined:

cr:title	...	cr:path
trèma blabla naïve	...	/node1
trema come text naive	...	/node2

Indexing rules and additional features

Search result highlighting

It is also called "Excerpt" (see Excerpt configuration in the Search Configuration section and in the Searching Repository).

The goal of this query is to find words "eXo" and "implementation" with fulltext search and high-light these words in the result value.

Basic info


<query-handler class="org.exoplatform.services.jcr.impl.core.query.lucene.SearchIndex">

   <properties>

      ...

      <property name="support-highlighting" value="true" />

      <property name="excerptprovider-class" value="org.exoplatform.services.jcr.impl.core.query.lucene.WeightedHTMLExcerpt"/>

      ...

   <properties>

</query-handler>

Also, remember that you can make indexing rules as in the example below:

Write rules for all nodes with the 'nt:unstructed' primary node type where 'rule' property equals to the "excerpt" string. For those nodes, you will exclude the "title" property from high-lighting and set the "text" property as highlightable. Indexing-configuration.xml must contain the next rule:


<index-rule nodeType="nt:unstructured" condition="@rule='excerpt'">

   <property useInExcerpt="false">title</property>

   <property>text</property>

</index-rule>

You have a single node with the 'nt:unstructured' primary type.

document (nt:unstructured)

// make SQL query

QueryManager queryManager = workspace.getQueryManager();

// create query

String sqlStatement = "SELECT rep:excerpt() FROM nt:unstructured WHERE CONTAINS(*, 'eXo implementation')";

Query query = queryManager.createQuery(sqlStatement, Query.SQL);

// execute query and fetch result

QueryResult result = query.execute();

// make XPath query

QueryManager queryManager = workspace.getQueryManager();

// create query

String xpathStatement = "//element(*,nt:unstructured)[jcr:contains(., 'eXo implementation')]/rep:excerpt(.)";

Query query = queryManager.createQuery(xpathStatement, Query.XPATH);

// execute query and fetch result

QueryResult result = query.execute();

Now, see on the result table:

String[] columnNames = result.getColumnNames();

RowIterator rit = result.getRows();

while (rit.hasNext())

{

   Row row = rit.nextRow();

   // get values of the row

   Value[] values = row.getValues();

}

Table content is

rep:excerpt()	jcr:path	jcr:score
<div><span><strong>eXo<strong>is JCR<strong>implementation<strong><span><div>	/testroot/node1	335

As you see, words "eXo" and "implementation" are highlighted.

Also, you can get exactly the "rep:excerpt" value:

RowIterator rows = result.getRows();

Value excerpt = rows.nextRow().getValue("rep:excerpt(.)");

// excerpt will be equal to "<div><span\><strong>eXo</strong> is a JCR <strong>implementation</strong></span></div>"

Index boost value

In this example, you will set different boost values for predefined nodes, and check effect by selecting those nodes and order them by jcr:score.

The default boost value is 1.0. Higher boost values (a reasonable range is 1.0 - 5.0) will yield a higher score value and appear as more relevant.

Note

See Search configuration.

Indexing configuration

In the indexing-config.xml, set boost values for nt:ustructured nodes 'text' property.


<!-- 

This rule actualy do nothing. 'text' property has default boost value.

-->

<index-rule nodeType="nt:unstructured" condition="@rule='boost1'">

   <!-- default boost: 1.0 -->

   <property>text</property>

</index-rule>



<!-- 

Set boost value as 2.0 for 'text' property in nt:unstructured nodes where property 'rule' equal to 'boost2'

-->

<index-rule nodeType="nt:unstructured" condition="@rule='boost2'">

   <!-- boost: 2.0 -->

   <property boost="2.0">text</property>

</index-rule>



<!-- 

Set boost value as 3.0 for 'text' property in nt:unstructured nodes where property 'rule' equal to 'boost3'

-->

<index-rule nodeType="nt:unstructured" condition="@rule='boost3'">

   <!-- boost: 3.0 -->

   <property boost="3.0">text</property>

</index-rule>

Repository contains many nodes with the "nt:unstructured" primary type. Each node contains the 'text' property and the 'rule' property with different values.

root

// make SQL query

QueryManager queryManager = workspace.getQueryManager();

// create query

String sqlStatement = "SELECT * FROM nt:unstructured WHERE CONTAINS(text, 'quick') ORDER BY jcr:score() DESC";

Query query = queryManager.createQuery(sqlStatement, Query.SQL);

// execute query and fetch result

QueryResult result = query.execute();

// make XPath query

QueryManager queryManager = workspace.getQueryManager();

// create query

String xpathStatement = "//element(*,nt:unstructured)[jcr:contains(@text, 'quick')] order by @jcr:score descending";

Query query = queryManager.createQuery(xpathStatement, Query.XPATH);

// execute query and fetch result

QueryResult result = query.execute();

NodeIterator will return nodes in next order "node3", "node2", "node1".

NodeIterator it = result.getNodes();


if(it.hasNext())

{

   Node findedNode = it.nextNode();

}

Exclusion from node scope index

This example will exclude some 'text' property of the nt:unstructured node from indexing. Therefore, node will not be found by the content of this property, even if it accepts all constraints.

First of all, add rules to the indexing-configuration.xml file:


<index-rule nodeType="nt:unstructured" condition="@rule='nsiTrue'">

    <!-- default value for nodeScopeIndex is true -->

    <property>text</property>

</index-rule>



<index-rule nodeType="nt:unstructured" condition="@rule='nsiFalse'">

    <!-- do not include text in node scope index -->

    <property nodeScopeIndex="false">text</property>

</index-rule>

Note

See Search configuration.

Repository contains the "nt:unstructured" nodes with the same 'text' property and different 'rule' properties (even null).

root

// make SQL query

QueryManager queryManager = workspace.getQueryManager();

// create query

String sqlStatement = "SELECT * FROM nt:unstructured WHERE CONTAINS(*,'quick')";

Query query = queryManager.createQuery(sqlStatement, Query.SQL);

// execute query and fetch result

QueryResult result = query.execute();

// make XPath query

QueryManager queryManager = workspace.getQueryManager();

// create query

String xpathStatement = "//element(*,nt:unstructured)[jcr:contains(., 'quick')]";

Query query = queryManager.createQuery(xpathStatement, Query.XPATH);

// execute query and fetch result

QueryResult result = query.execute();

NodeIterator will return "node1" and "node3". Node2, as you see, is not in result set.

Get nodes:

NodeIterator it = result.getNodes();


if(it.hasNext())

{

   Node findedNode = it.nextNode();

}

String[] columnNames = result.getColumnNames();

RowIterator rit = result.getRows();

while (rit.hasNext())

{

   Row row = rit.nextRow();

   // get values of the row

   Value[] values = row.getValues();

}

This example explains how to configure indexing in the next way. All properties of nt:unstructured nodes must be excluded from search, except properties whoes names end with the 'Text' string. First of all, add rules to the indexing-configuration.xml file:

jcr:primarytype	jcr:path	jcr:score
nt:unstructured	/node1	3806
nt:unstructured	/node3	3806

Regular expressions as property name in indexing rule


<index-rule nodeType="nt:unstructured"">

   <property isRegexp="true">.*Text</property>

</index-rule>

Note

See Search Configuration.

Now, check this rule with a simple query by selecting all nodes with the 'nt:unstructured' primary type and with the 'quick' string (fulltext search by full node).

Repository contains the "nt:unstructured" nodes with different 'text'-like named properties.

root

// make SQL query

QueryManager queryManager = workspace.getQueryManager();

// create query

String sqlStatement = "SELECT * FROM nt:unstructured WHERE CONTAINS(*,'quick')";

Query query = queryManager.createQuery(sqlStatement, Query.SQL);

// execute query and fetch result

QueryResult result = query.execute();

// make XPath query

QueryManager queryManager = workspace.getQueryManager();

// create query

String xpathStatement = "//element(*,nt:unstructured)[jcr:contains(., 'quick')]";

Query query = queryManager.createQuery(xpathStatement, Query.XPATH);

// execute query and fetch result

QueryResult result = query.execute();

NodeIterator will return "node1" and "node2". "node3", as you see, is not in result set.

Get nodes:

NodeIterator it = result.getNodes();


if(it.hasNext())

{

   Node findedNode = it.nextNode();

}

String[] columnNames = result.getColumnNames();

RowIterator rit = result.getRows();

while (rit.hasNext())

{

   Row row = rit.nextRow();

   // get values of the row

   Value[] values = row.getValues();

}

Find all mix:title nodes where title contains synonyms to 'fast' word.

jcr:primarytype	jcr:path	jcr:score
nt:unstructured	/node1	3806
nt:unstructured	/node2	3806

Synonym provider

Note

The synonym provider must be configured in the indexing-configuration.xml file:


<query-handler class="org.exoplatform.services.jcr.impl.core.query.lucene.SearchIndex">

   <properties>

      ...

      <property name="synonymprovider-class" value="org.exoplatform.services.jcr.impl.core.query.lucene.PropertiesSynonymProvider" />

      <property name="synonymprovider-config-path" value="../../synonyms.properties" />

      ...

   </properties>

</query-handler>

The synonym.properties file contains the next synonyms list:

ASF=Apache Software Foundation
quick=fast
sluggish=lazy

Repository contains mix:title nodes, where jcr:title has different values.

root
- document1 (mix:title) jcr:title="The quick brown fox jumps over the lazy dog."

// make SQL query

QueryManager queryManager = workspace.getQueryManager();

// create query

String sqlStatement = "SELECT * FROM mix:title WHERE CONTAINS(jcr:title, '~fast')";

Query query = queryManager.createQuery(sqlStatement, Query.SQL);

// execute query and fetch result

QueryResult result = query.execute();

// make XPath query

QueryManager queryManager = workspace.getQueryManager();

// create query

String xpathStatement = "//element(*,mix:title)[jcr:contains(@jcr:title, '~fast')]";

Query query = queryManager.createQuery(xpathStatement, Query.XPATH);

// execute query and fetch result

QueryResult result = query.execute();

NodeIterator will return expected document1. This is a purpose of synonym providers. Find by a specified word, but return by all synonyms.

Get nodes:

NodeIterator it = result.getNodes();


if(it.hasNext())

{

   Node findedNode = it.nextNode();

}

Spell checking

Check the correct spelling of phrase 'quik OR (-foo bar)' according to data already stored in index.

Note

SpellChecker must be settled in query-handler config.

See the test-jcr-config.xml file as below:


<query-handler class="org.exoplatform.services.jcr.impl.core.query.lucene.SearchIndex">

   <properties>

      ...

   <property name="spellchecker-class" value="org.exoplatform.services.jcr.impl.core.query.lucene.spell.LuceneSpellChecker$FiveSecondsRefreshInterval" />

      ...

   </properties>

</query-handler>

Repository contains node with the "The quick brown fox jumps over the lazy dog" string property.

root
- node1 property="The quick brown fox jumps over the lazy dog."

Query looks for the root node only, because spell checker looks for suggestions by full index. So complicated query is redundant.

// make SQL query

QueryManager queryManager = workspace.getQueryManager();

// create query

String sqlStatement = "SELECT rep:spellcheck() FROM nt:base WHERE jcr:path = '/' AND SPELLCHECK('quik OR (-foo bar)')";

Query query = queryManager.createQuery(sqlStatement, Query.SQL);

// execute query and fetch result

QueryResult result = query.execute();

// make XPath query

QueryManager queryManager = workspace.getQueryManager();

// create query

String xpathStatement = "/jcr:root[rep:spellcheck('quik OR (-foo bar)')]/(rep:spellcheck())";

Query query = queryManager.createQuery(xpathStatement, Query.XPATH);

// execute query and fetch result

QueryResult result = query.execute();

Get suggestion of the correct spelling as follows:

RowIterator it = result.getRows();

Row r = rows.nextRow();

Value v = r.getValue("rep:spellcheck()");

String correctPhrase = v.getString();

So, correct spelling for phrase "quik OR (-foo bar)" is "quick OR (-fox bar)".

Find similar nodes

In this example, the baseFile node will contain text where "terms" word happens many times. That is a reason why the existence of this word will be used as a criteria of node similarity (for the baseFile node).

Note

Highlighting support must be added to the test-jcr-config.xml configuration file:

<query-handler class="org.exoplatform.services.jcr.impl.core.query.lucene.SearchIndex">

   <properties>

      ...

      <property name="support-highlighting" value="true" />

      ...

   </properties>

</query-handler>

Repository contains many "nt:file" nodes:

root

// make SQL query

QueryManager queryManager = workspace.getQueryManager();

// create query

String sqlStatement = "SELECT * FROM nt:resource WHERE SIMILAR(.,'/baseFile/jcr:content')";

Query query = queryManager.createQuery(sqlStatement, Query.SQL);

// execute query and fetch result

QueryResult result = query.execute();

// make XPath query

QueryManager queryManager = workspace.getQueryManager();

// create query

String xpathStatement = "//element(*, nt:resource)[rep:similar(., '/testroot/baseFile/jcr:content')]";

Query query = queryManager.createQuery(xpathStatement, Query.XPATH);

// execute query and fetch result

QueryResult result = query.execute();

NodeIterator will return "/baseFile/jcr:content","/target1/jcr:content" and "/target3/jcr:content".

NodeIterator it = result.getNodes();


if(it.hasNext())

{

   Node findedNode = it.nextNode();

}

As you see the base node is also in the result set.

String[] columnNames = result.getColumnNames();

RowIterator rit = result.getRows();

while (rit.hasNext())

{

   Row row = rit.nextRow();

   // get values of the row

   Value[] values = row.getValues();

}