Index: src/test/java/org/apache/jackrabbit/core/query/OrderByTest.java =================================================================== --- src/test/java/org/apache/jackrabbit/core/query/OrderByTest.java (revision 1207039) +++ src/test/java/org/apache/jackrabbit/core/query/OrderByTest.java (working copy) @@ -60,6 +60,34 @@ checkResult(result, 3); } + /** + * Test for JCR-2906 + */ + public void testOrderByMVP() throws RepositoryException { + Node n1 = testRootNode.addNode("node1"); + Node n2 = testRootNode.addNode("node2"); + Node n3 = testRootNode.addNode("node3"); + Node n4 = testRootNode.addNode("node4"); + Node n5 = testRootNode.addNode("node5"); + + n1.setProperty("extra", new String[] { "12345" }); + n1.setProperty("text", new String[] { "ccc" }); + + n2.setProperty("text", new String[] { "eee", "bbb" }); + n3.setProperty("text", new String[] { "aaa" }); + n4.setProperty("text", new String[] { "bbb", "aaa" }); + n5.setProperty("text", new String[] { "eee", "aaa" }); + + testRootNode.getSession().save(); + + String sql = "SELECT value FROM nt:unstructured WHERE " + + "jcr:path LIKE '" + testRoot + "/%' ORDER BY text"; + checkResultSequence(executeQuery(sql).getRows(), new Node[] { n3, n4, n1, n5, n2 }); + + String xpath = "/" + testRoot + "/*[@jcr:primaryType='nt:unstructured'] order by jcr:score(), @text"; + checkResultSequence(executeQuery(xpath).getRows(), new Node[] { n3, n4, n1, n5, n2 }); + } + public void testOrderByUpperCase() throws RepositoryException { Node n1 = testRootNode.addNode("node1"); Node n2 = testRootNode.addNode("node2"); Index: src/test/java/org/apache/jackrabbit/core/query/SQL2OrderByTest.java =================================================================== --- src/test/java/org/apache/jackrabbit/core/query/SQL2OrderByTest.java (revision 1207039) +++ src/test/java/org/apache/jackrabbit/core/query/SQL2OrderByTest.java (working copy) @@ -73,6 +73,30 @@ } + /** + * SQL2 Test for JCR-2906 + */ + public void testOrderByMVP() throws RepositoryException { + Node n1 = testRootNode.addNode("node1"); + Node n2 = testRootNode.addNode("node2"); + Node n3 = testRootNode.addNode("node3"); + Node n4 = testRootNode.addNode("node4"); + Node n5 = testRootNode.addNode("node5"); + + n1.setProperty("text", new String[] { "ccc" }); + n2.setProperty("text", new String[] { "eee", "bbb" }); + n3.setProperty("text", new String[] { "aaa" }); + n4.setProperty("text", new String[] { "bbb", "aaa" }); + n5.setProperty("text", new String[] { "eee", "aaa" }); + + testRootNode.getSession().save(); + + String sql = "SELECT value FROM [nt:unstructured] WHERE ISCHILDNODE([" + + testRoot + "]) ORDER BY text"; + + checkSeq(executeSQL2Query(sql), new Node[] { n3, n4, n1, n5, n2 }); + } + public void testOrderByVal() throws RepositoryException { Node n1 = testRootNode.addNode("node1"); Index: src/main/java/org/apache/jackrabbit/core/query/lucene/Util.java =================================================================== --- src/main/java/org/apache/jackrabbit/core/query/lucene/Util.java (revision 1207039) +++ src/main/java/org/apache/jackrabbit/core/query/lucene/Util.java (working copy) @@ -236,6 +236,25 @@ } /** + * Compares two arrays of comparables. + */ + public static int compare(Comparable[] c1, Comparable[] c2) { + if (c1 == null) { + return -1; + } + if (c2 == null) { + return 1; + } + for (int i = 0; i < c1.length && i < c2.length; i++) { + int d = compare(c1[i], c2[i]); + if (d != 0) { + return d; + } + } + return c1.length - c2.length; + } + + /** * Compares the two values. If the values have differing types, then an * attempt is made to convert the second value into the type of the first * value. Index: src/main/java/org/apache/jackrabbit/core/query/lucene/SharedFieldCache.java =================================================================== --- src/main/java/org/apache/jackrabbit/core/query/lucene/SharedFieldCache.java (revision 1207039) +++ src/main/java/org/apache/jackrabbit/core/query/lucene/SharedFieldCache.java (working copy) @@ -17,6 +17,7 @@ package org.apache.jackrabbit.core.query.lucene; import java.io.IOException; +import java.util.Arrays; import java.util.HashMap; import java.util.Map; import java.util.WeakHashMap; @@ -112,6 +113,70 @@ } } + private static class ComparableArray implements Comparable { + + private int offset = 0; + + private Comparable[] c = new Comparable[0]; + + public ComparableArray(Comparable item, int index) { + insert(item, index); + } + + public int compareTo(ComparableArray o) { + return Util.compare(c, o.c); + } + + public ComparableArray insert(Comparable item, int index) { + // optimize for most common scenario + if (c.length == 0) { + offset = index; + c = new Comparable[] { item }; + return this; + } + + // inside + if (index >= offset && index <= offset + c.length) { + c[index - offset] = item; + return this; + } + + // before + if (index < offset) { + int relativeOffset = offset - index; + Comparable[] newC = new Comparable[relativeOffset + c.length]; + newC[0] = item; + System.arraycopy(c, 0, newC, relativeOffset, c.length); + c = newC; + offset = index; + return this; + } + + // after + if (index > offset + c.length) { + int extraOffset = index - offset + c.length; + Arrays.copyOf(c, c.length + extraOffset); + c[index - offset] = item; + return this; + } + return this; + } + + /* + * This is needed by {@link UpperCaseSortComparator} and {@link LowerCaseSortComparator} + */ + @Override + public String toString() { + if (c == null) { + return null; + } + if (c.length == 1) { + return c[0].toString(); + } + return Arrays.toString(c); + } + } + /** * Reference to the single instance of SharedFieldCache. */ @@ -152,9 +217,10 @@ field = field.intern(); ValueIndex ret = lookup(reader, field, prefix); if (ret == null) { - Comparable[] retArray = new Comparable[reader.maxDoc()]; + final int maxDocs = reader.maxDoc(); + ComparableArray[] retArray = new ComparableArray[maxDocs]; int setValues = 0; - if (retArray.length > 0) { + if (maxDocs > 0) { IndexFormatVersion version = IndexFormatVersion.getVersion(reader); boolean hasPayloads = version.isAtLeast(IndexFormatVersion.V3); TermDocs termDocs; @@ -167,8 +233,6 @@ termDocs = reader.termDocs(); } TermEnum termEnum = reader.terms(new Term(field, prefix)); - - char[] tmp = new char[16]; try { if (termEnum.term() == null) { throw new RuntimeException("no terms in field " + field); @@ -178,30 +242,28 @@ if (term.field() != field || !term.text().startsWith(prefix)) { break; } - - // make sure term is compacted - String text = term.text(); - int len = text.length() - prefix.length(); - if (tmp.length < len) { - // grow tmp - tmp = new char[len]; - } - text.getChars(prefix.length(), text.length(), tmp, 0); - String value = new String(tmp, 0, len); - - termDocs.seek(termEnum); + final String value = termValueAsString(term, prefix); + termDocs.seek(term); while (termDocs.next()) { + int termPosition = 0; type = PropertyType.UNDEFINED; if (hasPayloads) { TermPositions termPos = (TermPositions) termDocs; - termPos.nextPosition(); + termPosition = termPos.nextPosition(); if (termPos.isPayloadAvailable()) { payload = termPos.getPayload(payload, 0); type = PropertyMetaData.fromByteArray(payload).getPropertyType(); } } setValues++; - retArray[termDocs.doc()] = getValue(value, type); + Comparable v = getValue(value, type); + int doc = termDocs.doc(); + ComparableArray ca = retArray[doc]; + if (ca == null) { + retArray[doc] = new ComparableArray(v, termPosition); + } else { + retArray[doc] = ca.insert(v, termPosition); + } } } while (termEnum.next()); } finally { @@ -217,6 +279,22 @@ } /** + * Extracts the value from a given Term as a String + * + * @param term + * @param prefix + * @return string value contained in the term + */ + private static String termValueAsString(Term term, String prefix) { + // make sure term is compacted + String text = term.text(); + int length = text.length() - prefix.length(); + char[] tmp = new char[length]; + text.getChars(prefix.length(), text.length(), tmp, 0); + return new String(tmp, 0, length); + } + + /** * See if a ValueIndex object is in the cache. */ ValueIndex lookup(IndexReader reader, String field, String prefix) {