This is an automated email from the ASF dual-hosted git repository.
afs pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/jena.git
The following commit(s) were added to refs/heads/main by this push:
new 9ca22498cc GH-4365: Use codepoint compare systematically; handle
rdf:dirLangStr
9ca22498cc is described below
commit 9ca22498ccc470818399bafc4f7266a7731b4cf3
Author: Andy Seaborne <[email protected]>
AuthorDate: Sat Oct 31 14:11:58 2026 +0000
GH-4365: Use codepoint compare systematically; handle rdf:dirLangStr
---
.../org/apache/jena/sparql/expr/NVCompare.java | 33 +++---
.../org/apache/jena/sparql/expr/NodeValue.java | 2 +-
.../jena/sparql/expr/nodevalue/XSDFuncOp.java | 67 +++--------
.../java/org/apache/jena/sparql/util/NodeCmp.java | 131 +++++++++++++++------
.../org/apache/jena/sparql/util/NodeUtils.java | 4 +-
.../jena/sparql/expr/TestCompareLangString.java | 37 ++++++
.../org/apache/jena/sparql/expr/TestOrdering.java | 80 +++++++++----
.../java/org/apache/jena/atlas/lib/StrUtils.java | 51 ++++++++
.../org/apache/jena/atlas/lib/TestStrUtils.java | 45 +++++++
9 files changed, 316 insertions(+), 134 deletions(-)
diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/expr/NVCompare.java
b/jena-arq/src/main/java/org/apache/jena/sparql/expr/NVCompare.java
index 6f6a6af3c9..6b7dd38a98 100644
--- a/jena-arq/src/main/java/org/apache/jena/sparql/expr/NVCompare.java
+++ b/jena-arq/src/main/java/org/apache/jena/sparql/expr/NVCompare.java
@@ -307,18 +307,31 @@ class NVCompare {
// Different lang tags - sorting
return x;
}
-
// same lang tag (case insensitive)
+ // Check BaseDirection. If different,
+ if ( ! Objects.equals(node1.getLiteralBaseDirection(),
node2.getLiteralBaseDirection()) ) {
+ if ( !sortOrderingCompare )
+ raise(new ExprNotComparableException("Can't compare
(different base direction) " + nv1 + " and " + nv2));
+ if ( node1.getLiteralBaseDirection() == null )
+ return CMP_LESS;
+ if ( node2.getLiteralBaseDirection() == null )
+ return CMP_GREATER;
+ // ASCII compare.
+ return
StrUtils.strCompare(node1.getLiteralBaseDirection().direction(),
+
node2.getLiteralBaseDirection().direction());
+ }
+ // same lang tag (case insensitive) and same base direction.
x = XSDFuncOp.compareString(nv1, nv2);
if ( x != CMP_EQUAL )
return x;
// Same lexical forms, same lang tag by value
// Try to split by syntactic lang tags.
+ // Language tags are ASCII.
x = StrUtils.strCompare(node1.getLiteralLanguage(),
node2.getLiteralLanguage());
// Maybe they are the same after all!
// Should be node.equals by now.
if ( x == CMP_EQUAL && ! NodeFunctions.sameTerm(node1, node2)
)
- throw new ARQInternalErrorException("Looks like the same
(lang tags) but not node equals");
+ throw new ARQInternalErrorException("Looks like the same
term but not node equals");
return x;
}
@@ -427,7 +440,8 @@ class NVCompare {
*/
private static int compareRepresentations(String string1, String string2,
boolean sortOrderingCompare) {
if ( sortOrderingCompare )
- return strcompare(string1, string2);
+ return XSDFuncOp.compareString(string1, string2);
+ // Not for sorting.
if ( string1.equals(string2) )
return Expr.CMP_EQUAL;
return Expr.CMP_UNEQUAL;
@@ -524,17 +538,4 @@ class NVCompare {
else
return compareByValue(nv1, nv2);
}
-
- private static int strcompare(String string1, String string2) {
- // StrUtils.strCompare(string1, string2);
- return result(string1.compareTo(string2));
- }
-
- /**
- * Return of comparision - always -1,0 or +1
- */
- private static int result(int x) {
- return ( x == 0 ) ? Expr.CMP_EQUAL
- : ( ( x > 0 ) ? Expr.CMP_GREATER : Expr.CMP_LESS );
- }
}
diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/expr/NodeValue.java
b/jena-arq/src/main/java/org/apache/jena/sparql/expr/NodeValue.java
index 94a58f251c..cea75e1d5a 100644
--- a/jena-arq/src/main/java/org/apache/jena/sparql/expr/NodeValue.java
+++ b/jena-arq/src/main/java/org/apache/jena/sparql/expr/NodeValue.java
@@ -497,7 +497,7 @@ public abstract class NodeValue extends ExprNode
public boolean isBoolean() { return false; }
public boolean isString() { return false; }
- public boolean isLangString() { return false; } // xsd:rdfLangString
and rdf:dirLangString
+ public boolean isLangString() { return false; } // rdf:langString and
rdf:dirLangString
public boolean isSortKey() { return false; }
public boolean isNumber() { return false; }
diff --git
a/jena-arq/src/main/java/org/apache/jena/sparql/expr/nodevalue/XSDFuncOp.java
b/jena-arq/src/main/java/org/apache/jena/sparql/expr/nodevalue/XSDFuncOp.java
index fb06d8a5ce..11517e3009 100644
---
a/jena-arq/src/main/java/org/apache/jena/sparql/expr/nodevalue/XSDFuncOp.java
+++
b/jena-arq/src/main/java/org/apache/jena/sparql/expr/nodevalue/XSDFuncOp.java
@@ -44,6 +44,7 @@ import java.util.regex.Matcher;
import java.util.regex.Pattern;
import javax.xml.datatype.DatatypeConstants;
+import javax.xml.datatype.DatatypeConstants.Field;
import javax.xml.datatype.Duration;
import javax.xml.datatype.XMLGregorianCalendar;
@@ -1110,27 +1111,18 @@ public class XSDFuncOp
// --------------------------------
// Comparisons operations
// Do not confuse with sameValueAs/notSamevalueAs
-
- private static int calcReturn(int x) {
- if ( x < 0 )
- return Expr.CMP_LESS;
- if ( x > 0 )
- return Expr.CMP_GREATER;
- return Expr.CMP_EQUAL;
- }
-
public static int compareNumeric(NodeValue nv1, NodeValue nv2) {
NumericType opType = classifyNumeric("compareNumeric", nv1, nv2);
switch (opType) {
case OP_INTEGER :
- return
calcReturn(nv1.getInteger().compareTo(nv2.getInteger()));
+ return nv1.getInteger().compareTo(nv2.getInteger());
case OP_DECIMAL :
- return
calcReturn(nv1.getDecimal().compareTo(nv2.getDecimal()));
+ return nv1.getDecimal().compareTo(nv2.getDecimal());
case OP_FLOAT :
- return calcReturn(Float.compare(nv1.getFloat(),
nv2.getFloat()));
+ return Float.compare(nv1.getFloat(), nv2.getFloat());
case OP_DOUBLE :
- return calcReturn(Double.compare(nv1.getDouble(),
nv2.getDouble()));
+ return Double.compare(nv1.getDouble(), nv2.getDouble());
default :
throw new ARQInternalErrorException("Unrecognized numeric
operation : (" + nv1 + " ," + nv2 + ")");
}
@@ -1151,45 +1143,16 @@ public class XSDFuncOp
public static int compareString(NodeValue nv1, NodeValue nv2) {
String s1 = nv1.getString();
String s2 = nv2.getString();
- int len1 = s1.length();
- int len2 = s2.length();
- int probeLimit = Math.min(Math.min(len1, len2), 4);
- // Most unequal strings differ near the start. Decode only at that
difference.
- for ( int i = 0; i < probeLimit; i++ ) {
- char c1 = s1.charAt(i);
- char c2 = s2.charAt(i);
- if ( c1 != c2 ) {
- int j = i;
- // A shared high surrogate may combine with only one of these
chars.
- if ( i > 0 && Character.isHighSurrogate(s1.charAt(i - 1))
- && (Character.isLowSurrogate(c1) ||
Character.isLowSurrogate(c2)) )
- j = i - 1;
- return calcReturn(Integer.compare(s1.codePointAt(j),
s2.codePointAt(j)));
- }
- }
- if ( Math.min(len1, len2) <= probeLimit )
- return calcReturn(Integer.compare(len1, len2));
-
- int utf16Order = s1.compareTo(s2);
- // Without surrogate pairs, UTF-16 order is code point order. String
comparison
- // can handle a long common prefix more efficiently than decoding each
code point.
- if ( utf16Order == 0 || (s1.codePointCount(0, len1) == len1
- && s2.codePointCount(0, len2) == len2) )
- return calcReturn(utf16Order);
-
- int i1 = 0;
- int i2 = 0;
- // SPARQL uses Unicode code point order, not UTF-16 code unit order.
- while ( i1 < s1.length() && i2 < s2.length() ) {
- int cp1 = s1.codePointAt(i1);
- int cp2 = s2.codePointAt(i2);
- if ( cp1 != cp2 )
- return calcReturn(Integer.compare(cp1, cp2));
- i1 += Character.charCount(cp1);
- i2 += Character.charCount(cp2);
- }
- // A remaining suffix sorts after its matching prefix.
- return calcReturn(Integer.compare(s1.length() - i1, s2.length() - i2));
+ return compareString(s1, s2);
+ }
+
+ /*
+ * Do a codepoint compare of two strings.
+ * This is not a duplicate of {@code String.compateTo} which compares
+ * UTF-16 code units (i.e. surrogates as characters).
+ */
+ public static int compareString(String s1, String s2) {
+ return StrUtils.strCompareCodePoint(s1, s2);
}
// --------------------------------
diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/util/NodeCmp.java
b/jena-arq/src/main/java/org/apache/jena/sparql/util/NodeCmp.java
index b609e824f0..a5d55d0ba5 100644
--- a/jena-arq/src/main/java/org/apache/jena/sparql/util/NodeCmp.java
+++ b/jena-arq/src/main/java/org/apache/jena/sparql/util/NodeCmp.java
@@ -56,7 +56,7 @@ public class NodeCmp {
//-- Variables
if ( node1.isVariable() ) {
if ( node2.isVariable() ) {
- return StrUtils.strCompare(node1.getName(), node2.getName());
+ return StrUtils.strCompareCodePoint(node1.getName(),
node2.getName());
}
// Variables before anything else
return Expr.CMP_LESS;
@@ -72,7 +72,7 @@ public class NodeCmp {
if ( node2.isBlank() ) {
String s1 = node1.getBlankNodeLabel();
String s2 = node2.getBlankNodeLabel();
- return StrUtils.strCompare(s1, s2);
+ return StrUtils.strCompareCodePoint(s1, s2);
}
// bNodes before anything but variables
return Expr.CMP_LESS;
@@ -89,7 +89,7 @@ public class NodeCmp {
if ( node2.isURI() ) {
String s1 = node1.getURI();
String s2 = node2.getURI();
- return StrUtils.strCompare(s1, s2);
+ return StrUtils.strCompareCodePoint(s1, s2);
}
return Expr.CMP_LESS;
}
@@ -156,13 +156,13 @@ public class NodeCmp {
return Expr.CMP_EQUAL;
// ** Rewrite as a classifier.??
- // simple < lang < datatype
+ // simple < lang < langdir < datatype
// Both simple? (xsd:string in RDF 1.1)
if ( isSimpleString(node1) && isSimpleString(node2) ) {
String lex1 = node1.getLiteralLexicalForm();
String lex2 = node2.getLiteralLexicalForm();
- return StrUtils.strCompare(lex1, lex2);
+ return StrUtils.strCompareCodePoint(lex1, lex2);
}
// Any simple string?
@@ -171,39 +171,24 @@ public class NodeCmp {
if ( isSimpleString(node2) )
return Expr.CMP_GREATER;
- // No simple string from here on.
-
+ // No simple strings from here on.
{
- int x = compareRDFLangTerms(node1, node2);
- if ( x != Expr.CMP_INDETERMINATE )
- return x;
+ int x1 = compareRDFDirLangTerms(node1, node2);
+ if ( x1 != Expr.CMP_INDETERMINATE )
+ return x1;
+ // No simple string, no dirlang from here on.
+ int x2 = compareRDFLangOnlyTerms(node1, node2);
+ if ( x2 != Expr.CMP_INDETERMINATE )
+ return x2;
}
- // No simple strings, no lang strings.
- // Compare by datatype then lexical form.
-
- // Switch for old world (Jena 4.5.0 and before)
- // Affects ordering for datatypes (not simple or lang strings).
- // false - old world.
- final boolean byDatatype = false;
- if ( byDatatype ) {
- String dt1 = node1.getLiteralDatatypeURI();
- String dt2 = node2.getLiteralDatatypeURI();
-
- int x = StrUtils.strCompare(dt1, dt2);
- if ( x != Expr.CMP_EQUAL )
- return x;
- // Same datatype
- String lex1 = node1.getLiteralLexicalForm();
- String lex2 = node2.getLiteralLexicalForm();
- return StrUtils.strCompare(lex1, lex2);
- }
+ // No simple strings, no lang strings, no langdir strings
- // Old Jena 4.5.0 : lexical form before datatype.
+ // Compare lexical form before datatype (the long-time choice).
String lex1 = node1.getLiteralLexicalForm();
String lex2 = node2.getLiteralLexicalForm();
- int x = StrUtils.strCompare(lex1, lex2);
+ int x = StrUtils.strCompareCodePoint(lex1, lex2);
if ( x != Expr.CMP_EQUAL )
return x;
@@ -211,39 +196,111 @@ public class NodeCmp {
String dt1 = node1.getLiteralDatatypeURI();
String dt2 = node2.getLiteralDatatypeURI();
// Two datatypes.
- return StrUtils.strCompare(dt1, dt2);
+ return StrUtils.strCompareCodePoint(dt1, dt2);
+
+// // Compare by datatype then lexical form.
+// String dt1 = node1.getLiteralDatatypeURI();
+// String dt2 = node2.getLiteralDatatypeURI();
+//
+// int x = StrUtils.strCompareCodePoint(dt1, dt2);
+// if ( x != Expr.CMP_EQUAL )
+// return x;
+// // Same datatype
+// String lex1 = node1.getLiteralLexicalForm();
+// String lex2 = node2.getLiteralLexicalForm();
+// return StrUtils.strCompareCodePoint(lex1, lex2);
}
- /** May return {@link Expr#CMP_INDETERMINATE} */
- private static int compareRDFLangTerms(Node node1, Node node2) {
+ /** Compare by language direction only - may return {@link
Expr#CMP_INDETERMINATE} */
+ private static int compareRDFDirLangTerms(Node node1, Node node2) {
+ if ( isDirLangString(node1) && isDirLangString(node2) ) {
+ String dir1 = node1.getLiteralBaseDirection().direction();
+ String dir2 = node2.getLiteralBaseDirection().direction();
+ int x1 = StrUtils.strCompareIgnoreCase(dir1, dir2);
+ if ( x1 != Expr.CMP_EQUAL )
+ return x1;
+ // Same direction.
+ return compareByLangThenLex(node1, node2);
+ }
+
+ // Any language direction?
+ // lang < dirlang < datatype
+
+ if ( isDirLangString(node1) ) {
+ if ( isLangString(node2) )
+ // dirLang > lang
+ return Expr.CMP_GREATER;
+ // dirLAng < lang or datatype.
+ return Expr.CMP_LESS;
+ }
+ if ( isDirLangString(node2) ) {
+ if ( isLangString(node1) )
+ // lang < dirLang
+ return Expr.CMP_LESS;
+ // datatype > dirLang
+ return Expr.CMP_GREATER;
+ }
+ return Expr.CMP_INDETERMINATE;
+ }
+
+ /**
+ * Compare by language only - may return {@link Expr#CMP_INDETERMINATE}.
+ * DirLang checking has been done.
+ */
+ private static int compareRDFLangOnlyTerms(Node node1, Node node2) {
if ( isLangString(node1) && isLangString(node2) ) {
String lang1 = node1.getLiteralLanguage();
String lang2 = node2.getLiteralLanguage();
int x = StrUtils.strCompareIgnoreCase(lang1, lang2);
if ( x != Expr.CMP_EQUAL )
return x;
+
// Two langs, same lang tag => lexical form.
String lex1 = node1.getLiteralLexicalForm();
String lex2 = node2.getLiteralLexicalForm();
- x = StrUtils.strCompare(lex1, lex2);
+ x = StrUtils.strCompareCodePoint(lex1, lex2);
if ( x != Expr.CMP_EQUAL )
return x;
// Same (case insensitive) lang, same lexical for - can be split
them?
+ // ASCII comparision.
x = StrUtils.strCompare(lang1, lang2);
if ( x != Expr.CMP_EQUAL )
return x;
throw new ARQInternalErrorException("Same lang tag (inc case, same
lexical form but not node.equals");
}
-
// Any lang string?
if ( isLangString(node1) )
- // lang < datatype
+ // lang < dirlang < datatype
return Expr.CMP_LESS;
if ( isLangString(node2) )
return Expr.CMP_GREATER;
+
+
+
+
return Expr.CMP_INDETERMINATE;
}
+
+
+ // Compare two nodes that are known to have a language tag and are the
same kind (both rdf:langsString or both rdf:dirLangString)
+ // Do not mix rdf:langsString and rdf:dirLangString
+ private static int compareByLangThenLex(Node node1, Node node2) {
+ String lang1 = node1.getLiteralLanguage();
+ String lang2 = node2.getLiteralLanguage();
+ int x = StrUtils.strCompareIgnoreCase(lang1, lang2);
+ if ( x != Expr.CMP_EQUAL )
+ return x;
+ // Two langs, same lang tag => lexical form.
+ String lex1 = node1.getLiteralLexicalForm();
+ String lex2 = node2.getLiteralLexicalForm();
+ x = StrUtils.strCompareCodePoint(lex1, lex2);
+ if ( x != Expr.CMP_EQUAL )
+ return x;
+ // Same except by language case (which should have been canicalized)
+ x = StrUtils.strCompare(lang1, lang2);
+ return x;
+ }
}
diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/util/NodeUtils.java
b/jena-arq/src/main/java/org/apache/jena/sparql/util/NodeUtils.java
index 74f5b9c40c..24c3796c7a 100644
--- a/jena-arq/src/main/java/org/apache/jena/sparql/util/NodeUtils.java
+++ b/jena-arq/src/main/java/org/apache/jena/sparql/util/NodeUtils.java
@@ -206,8 +206,8 @@ public class NodeUtils
public static boolean isLangString(Node n) { return Util.isLangString(n); }
/**
- * A Node is a language string if it has a language tag.
- * (RDF 1.0 and RDF 1.1)
+ * A Node is a dirLangString if it has a language tag and a base direction
+ * (RDF 1.2)
*/
public static boolean isDirLangString(Node n) { return
Util.isDirLangString(n); }
diff --git
a/jena-arq/src/test/java/org/apache/jena/sparql/expr/TestCompareLangString.java
b/jena-arq/src/test/java/org/apache/jena/sparql/expr/TestCompareLangString.java
index 6c4cd603b2..e311112a28 100644
---
a/jena-arq/src/test/java/org/apache/jena/sparql/expr/TestCompareLangString.java
+++
b/jena-arq/src/test/java/org/apache/jena/sparql/expr/TestCompareLangString.java
@@ -20,6 +20,7 @@
package org.apache.jena.sparql.expr;
+import static org.apache.jena.graph.TextDirection.*;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
@@ -29,11 +30,15 @@ import java.util.List;
import org.junit.jupiter.api.Test;
+import org.apache.jena.graph.TextDirection;
import org.apache.jena.query.DatasetFactory;
import org.apache.jena.query.QueryExecution;
import org.apache.jena.query.QueryExecutionFactory;
import org.apache.jena.query.ResultSet;
+/**
+ * Codepoint comparision: rdf:langString and rdf:dirLangString
+ */
public class TestCompareLangString {
private static final String BMP = Character.toString(0xFFE0);
private static final String ASTRAL = Character.toString(0x1D11E);
@@ -42,6 +47,11 @@ public class TestCompareLangString {
return "'" + value + "'@" + tag;
}
+ private static String literal(String value, String tag, TextDirection
textDir) {
+ return "'" + value + "'@" + tag + "--" + textDir.direction();
+ }
+
+
private static boolean expression(String expression) {
String query = "PREFIX xsd: <http://www.w3.org/2001/XMLSchema#> SELECT
(" + expression + " AS ?result) WHERE {}";
try (QueryExecution exec = QueryExecutionFactory.create(query,
DatasetFactory.empty())) {
@@ -57,6 +67,22 @@ public class TestCompareLangString {
assertTrue(expression(literal(ASTRAL, "en") + " > " + literal(BMP,
"en")));
}
+ @Test public void sameLangDirLessThan() {
+ assertTrue(expression(literal(BMP, "en", LTR) + " < " +
literal(ASTRAL, "en", LTR)));
+ }
+
+ @Test public void sameLangDirGreaterThan() {
+ assertTrue(expression(literal(ASTRAL, "en", LTR) + " > " +
literal(BMP, "en", LTR)));
+ }
+
+ @Test public void differentLangDir() {
+ assertTrue(expression(literal("AAAA", "en", LTR) + " != " +
literal("AAAA", "en", RTL)));
+ }
+
+ @Test public void differentLangSameLangDir() {
+ assertTrue(expression(literal("AAAA", "fr", LTR) + " != " +
literal("AAAA", "en", LTR)));
+ }
+
@Test public void sameLanguageOrderBy() {
String query = "SELECT ?v WHERE { VALUES ?v { " + literal(ASTRAL,
"en") + " " + literal(BMP, "en") + " } } ORDER BY ?v";
List<String> actual = new ArrayList<>();
@@ -68,6 +94,17 @@ public class TestCompareLangString {
assertEquals(List.of(BMP, ASTRAL), actual);
}
+ @Test public void sameDirLangOrderBy() {
+ String query = "SELECT ?v WHERE { VALUES ?v { " + literal(ASTRAL,
"en", LTR) + " " + literal(BMP, "en", LTR) + " } } ORDER BY ?v";
+ List<String> actual = new ArrayList<>();
+ try (QueryExecution exec = QueryExecutionFactory.create(query,
DatasetFactory.empty())) {
+ ResultSet results = exec.execSelect();
+ while (results.hasNext())
+ actual.add(results.next().getLiteral("v").getLexicalForm());
+ }
+ assertEquals(List.of(BMP, ASTRAL), actual);
+ }
+
@Test public void equalityAndMembership() {
assertTrue(expression(literal(BMP, "en") + " = " + literal(BMP,
"EN")));
assertTrue(expression(literal(BMP, "en") + " != " + literal(ASTRAL,
"en")));
diff --git
a/jena-arq/src/test/java/org/apache/jena/sparql/expr/TestOrdering.java
b/jena-arq/src/test/java/org/apache/jena/sparql/expr/TestOrdering.java
index 997f702dd4..1510552b27 100644
--- a/jena-arq/src/test/java/org/apache/jena/sparql/expr/TestOrdering.java
+++ b/jena-arq/src/test/java/org/apache/jena/sparql/expr/TestOrdering.java
@@ -21,6 +21,7 @@
package org.apache.jena.sparql.expr;
+import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import org.junit.jupiter.api.Test;
@@ -28,39 +29,47 @@ import org.junit.jupiter.api.Test;
import org.apache.jena.datatypes.xsd.XSDDatatype;
import org.apache.jena.graph.Node;
import org.apache.jena.graph.NodeFactory;
+import org.apache.jena.graph.TextDirection;
import org.apache.jena.sparql.sse.SSE;
+//import org.apache.jena.sparql.util.NodeCmp;
import org.apache.jena.sparql.util.NodeCmp;
/**
* See also {@link TestComparison} and {@link TestSortOrdering}.
*/
public class TestOrdering {
- private NodeValue nvInt2 = NodeValue.makeNodeInteger(2);
- private NodeValue nvInt3 = NodeValue.makeNodeInteger("3");
- private NodeValue nvInt03 = NodeValue.makeNodeInteger("03");
- private NodeValue nvStr3 = NodeValue.makeNodeString("3");
- private NodeValue nvStr03 = NodeValue.makeNodeString("03");
-
- private NodeValue nvInt9 = NodeValue.makeNodeInteger(9);
- private NodeValue nvPosInt9 = NodeValue.makeNode("9",
XSDDatatype.XSDpositiveInteger);
- private NodeValue nvInt10 = NodeValue.makeNodeInteger(10);
- private NodeValue nvDouble9 = NodeValue.makeNodeDouble(9.0);
- private NodeValue nvFloat8 = NodeValue.makeNode("8.0",
XSDDatatype.XSDfloat);
-
- private NodeValue nvByte10 = NodeValue.makeNode("10", XSDDatatype.XSDbyte);
-
- private Node nInt2 = nvInt2.getNode();
- private Node nInt3 = nvInt3.getNode();
- private Node nInt03 = nvInt03.getNode();
- private Node nStr3 = nvStr3.getNode();
- private Node nStr03 = nvStr03.getNode();
-
- private Node nInt9 = nvInt9.getNode();
- private Node nPosInt9 = nvPosInt9.getNode();
- private Node nInt10 = nvInt10.getNode();
- private Node nDouble9 = nvDouble9.getNode();
- private Node nFloat8 = nvFloat8.getNode();
- private Node nByte10 = nvByte10.getNode();
+ private static NodeValue nvInt2 = NodeValue.makeNodeInteger(2);
+ private static NodeValue nvInt3 = NodeValue.makeNodeInteger("3");
+ private static NodeValue nvInt03 = NodeValue.makeNodeInteger("03");
+ private static NodeValue nvStr3 = NodeValue.makeNodeString("3");
+ private static NodeValue nvStr03 = NodeValue.makeNodeString("03");
+
+ private static NodeValue nvInt9 = NodeValue.makeNodeInteger(9);
+ private static NodeValue nvPosInt9 = NodeValue.makeNode("9",
XSDDatatype.XSDpositiveInteger);
+ private static NodeValue nvInt10 = NodeValue.makeNodeInteger(10);
+ private static NodeValue nvDouble9 = NodeValue.makeNodeDouble(9.0);
+ private static NodeValue nvFloat8 = NodeValue.makeNode("8.0",
XSDDatatype.XSDfloat);
+
+ private static NodeValue nvByte10 = NodeValue.makeNode("10",
XSDDatatype.XSDbyte);
+
+ private static Node nInt2 = nvInt2.getNode();
+ private static Node nInt3 = nvInt3.getNode();
+ private static Node nInt03 = nvInt03.getNode();
+ private static Node nStr3 = nvStr3.getNode();
+ private static Node nStr03 = nvStr03.getNode();
+
+ private static Node nInt9 = nvInt9.getNode();
+ private static Node nPosInt9 = nvPosInt9.getNode();
+ private static Node nInt10 = nvInt10.getNode();
+ private static Node nDouble9 = nvDouble9.getNode();
+ private static Node nFloat8 = nvFloat8.getNode();
+ private static Node nByte10 = nvByte10.getNode();
+
+ private static Node nStrDirLang = NodeFactory.createLiteralDirLang("ABCD",
"en", TextDirection.LTR);
+ private static Node nStrLang = NodeFactory.createLiteralLang("ABCD",
"en");
+ private static Node nStr = NodeFactory.createLiteralString("ABCD");
+
+ // Syntax and value tests
@Test
public void testComp_2_3() {
@@ -88,6 +97,25 @@ public class TestOrdering {
assertTrue(Expr.CMP_GREATER == y, ()->"03 should be syntactic-less
than to \"3\"");
}
+ // Syntax: string, lang and dirlang
+ @Test
+ public void testComp_string_types_01() {
+ int x = NodeCmp.compareRDFTerms(nStr, nStrDirLang);
+ assertEquals(Expr.CMP_LESS, x, "string is not less than
rdf:strDirLang");
+ }
+
+ @Test
+ public void testComp_string_types_02() {
+ int x = NodeCmp.compareRDFTerms(nStr, nStrLang);
+ assertEquals(Expr.CMP_LESS, x, "string is not less than rdf:strLang");
+ }
+
+ @Test
+ public void testComp_string_types_03() {
+ int x = NodeCmp.compareRDFTerms(nStrLang, nStrDirLang);
+ assertEquals(Expr.CMP_LESS, x, "rdf:strLang is not less than
rdf:strDirLang");
+ }
+
// Compare things of different types.
@Test
public void testComp_int_double_1() {
diff --git a/jena-base/src/main/java/org/apache/jena/atlas/lib/StrUtils.java
b/jena-base/src/main/java/org/apache/jena/atlas/lib/StrUtils.java
index f7706bf152..dab1bfe933 100644
--- a/jena-base/src/main/java/org/apache/jena/atlas/lib/StrUtils.java
+++ b/jena-base/src/main/java/org/apache/jena/atlas/lib/StrUtils.java
@@ -61,6 +61,10 @@ public class StrUtils //extends StringUtils
public static final int CMP_UNEQUAL = -9 ;
public static final int CMP_INDETERMINATE = 2 ;
+ /**
+ * Compare using Java String.compareTo, which is code unit/UTF16-sensitive
+ * See {@link #strCompareCodePoint(String, String)} for a code point
comparision.
+ */
public static int strCompare(String s1, String s2) {
// Value is the difference of the first differing chars
int x = s1.compareTo(s2) ;
@@ -70,6 +74,53 @@ public class StrUtils //extends StringUtils
throw new InternalErrorException("String comparison failure") ;
}
+ /**
+ * Compare string by codepoint.
+ * This is in contrast to {@link #strCompare(String, String)} which uses
{@code Java String.compareTo}, which is code unit/UTF16-sensitive
+ * @see #strCompare(String, String)
+ */
+ public static int strCompareCodePoint(String s1, String s2) {
+ int len1 = s1.length();
+ int len2 = s2.length();
+ int probeLimit = Math.min(Math.min(len1, len2), 4);
+ // Most unequal strings differ near the start. Decode only at that
difference.
+ for ( int i = 0; i < probeLimit; i++ ) {
+ char c1 = s1.charAt(i);
+ char c2 = s2.charAt(i);
+ if ( c1 != c2 ) {
+ int j = i;
+ // A shared high surrogate may combine with only one of these
chars.
+ if ( i > 0 && Character.isHighSurrogate(s1.charAt(i - 1))
+ && (Character.isLowSurrogate(c1) ||
Character.isLowSurrogate(c2)) )
+ j = i - 1;
+ return Integer.compare(s1.codePointAt(j), s2.codePointAt(j));
+ }
+ }
+ if ( Math.min(len1, len2) <= probeLimit )
+ return Integer.compare(len1, len2);
+
+ int utf16Order = s1.compareTo(s2);
+ // Without surrogate pairs, UTF-16 order is code point order. String
comparison
+ // can handle a long common prefix more efficiently than decoding each
code point.
+ if ( utf16Order == 0 || (s1.codePointCount(0, len1) == len1
+ && s2.codePointCount(0, len2) == len2) )
+ return Integer.signum(utf16Order);
+
+ int i1 = 0;
+ int i2 = 0;
+ // SPARQL uses Unicode code point order, not UTF-16 code unit order.
+ while ( i1 < s1.length() && i2 < s2.length() ) {
+ int cp1 = s1.codePointAt(i1);
+ int cp2 = s2.codePointAt(i2);
+ if ( cp1 != cp2 )
+ return Integer.compare(cp1, cp2);
+ i1 += Character.charCount(cp1);
+ i2 += Character.charCount(cp2);
+ }
+ // A remaining suffix sorts after its matching prefix.
+ return Integer.compare(s1.length() - i1, s2.length() - i2);
+ }
+
public static int strCompareIgnoreCase(String s1, String s2) {
// x is the difference of the first differing chars
int x = s1.compareToIgnoreCase(s2) ;
diff --git
a/jena-base/src/test/java/org/apache/jena/atlas/lib/TestStrUtils.java
b/jena-base/src/test/java/org/apache/jena/atlas/lib/TestStrUtils.java
index 89c237884a..edcaae24de 100644
--- a/jena-base/src/test/java/org/apache/jena/atlas/lib/TestStrUtils.java
+++ b/jena-base/src/test/java/org/apache/jena/atlas/lib/TestStrUtils.java
@@ -52,6 +52,51 @@ public class TestStrUtils
assertEquals(expected, x2);
}
+ // -- Codepoints
+
+ // For codepoint comparision testing.
+ private static final String BMP = Character.toString(0xFFE0);
+ private static final String SUPPLEMENTARY = Character.toString(0x1D11E);
+ private static final String LATER_SUPPLEMENTARY =
Character.toString(0x1F600);
+
+ private static void compareByCodepoint(String left, String right, int
expected) {
+ assertEquals(expected, StrUtils.strCompareCodePoint(left, right));
+ assertEquals(-expected, StrUtils.strCompareCodePoint(right, left));
+ }
+
+ @Test public void codepoint_bmpBeforeSupplementary() {
+ // UTF-16 code unit order gives the opposite result to Java for this
pair.
+ compareByCodepoint(BMP, SUPPLEMENTARY, -1);
+ compareByCodepoint(SUPPLEMENTARY, BMP, +1);
+ compareByCodepoint("a" + BMP, "a" + SUPPLEMENTARY, -1);
+ // Cross-check: Java UTF-16/surrogates
+ assertEquals(+1, Integer.signum(BMP.compareTo(SUPPLEMENTARY)));
+ }
+
+ @Test public void codepoint_supplementaryCodePoints() {
+ compareByCodepoint(SUPPLEMENTARY, LATER_SUPPLEMENTARY, -1);
+ compareByCodepoint("a" + SUPPLEMENTARY + "a", "a" + SUPPLEMENTARY +
"b", -1);
+ }
+
+ @Test public void codepoint_equalStrings() {
+ compareByCodepoint("", "", 0);
+ compareByCodepoint(SUPPLEMENTARY + BMP, SUPPLEMENTARY + BMP, 0);
+ }
+
+ @Test public void codepoint_prefixesAndEmptyStrings() {
+ compareByCodepoint("", SUPPLEMENTARY, -1);
+ compareByCodepoint(SUPPLEMENTARY, SUPPLEMENTARY + BMP, -1);
+ compareByCodepoint("a" + SUPPLEMENTARY, "a" + SUPPLEMENTARY + "b", -1);
+ }
+
+ @Test public void codepoint_longCommonPrefix() {
+ String prefix =
"http://example.org/resource/with/a/long/shared/prefix/";
+ compareByCodepoint(prefix + "a", prefix + "b", -1);
+ compareByCodepoint(prefix + BMP, prefix + SUPPLEMENTARY, -1);
+ }
+
+ // -- Codepoints
+
@Test public void enc01() { testEnc("abc") ; }
@Test public void enc02() { testEnc("") ; }
@Test public void enc03() { testEnc("_", "_5F" ) ; }