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
commit 86c2885e3bf2ae8a018f6e4885ce7464d6ea450e Author: Rob Vesse <[email protected]> AuthorDate: Mon Nov 9 10:44:03 2026 +0000 Consolidate SPARQL Limits into central location Adds new SparqlLimits, which replaces previously introduced MathLimits, as a central location for configuring relevant limit controls and generic enforcement functions. Also simplifies some test case names as requested --- .../MathLimits.java => SparqlLimits.java} | 95 ++++++++++++++++++++-- .../optimize/TransformPathFlattenAlgebra.java | 7 +- .../org/apache/jena/sparql/expr/RegexEngine.java | 33 ++------ .../jena/sparql/function/library/Math_exp.java | 4 +- .../jena/sparql/function/library/Math_exp10.java | 6 +- .../jena/sparql/function/library/Math_pow.java | 6 +- .../function/library/leviathan/cartesian.java | 12 +-- .../sparql/function/library/leviathan/cube.java | 8 +- .../function/library/leviathan/factorial.java | 4 +- .../sparql/function/library/leviathan/pow.java | 4 +- .../function/library/leviathan/pythagoras.java | 6 +- .../sparql/function/library/leviathan/root.java | 4 +- .../jena/sparql/function/library/leviathan/sq.java | 8 +- .../org/apache/jena/sparql/path/PathCompiler.java | 35 +------- .../jena/sparql/pfunction/library/strSplit.java | 4 +- .../test/java/org/apache/jena/sparql/TC_ARQ.java | 3 + .../TestMathLimits.java => TestSparqlLimits.java} | 13 ++- .../algebra/optimize/TestTransformPathFlatten.java | 9 +- .../org/apache/jena/sparql/expr/TestRegex.java | 22 +++-- .../function/library/TS_LibraryFunctions.java | 2 +- .../sparql/pfunction/library/TestStrSplit.java | 18 ++-- 21 files changed, 174 insertions(+), 129 deletions(-) diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/function/MathLimits.java b/jena-arq/src/main/java/org/apache/jena/sparql/SparqlLimits.java similarity index 55% rename from jena-arq/src/main/java/org/apache/jena/sparql/function/MathLimits.java rename to jena-arq/src/main/java/org/apache/jena/sparql/SparqlLimits.java index 07edcc67a5..09a6d49e05 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/function/MathLimits.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/SparqlLimits.java @@ -19,32 +19,54 @@ * SPDX-License-Identifier: Apache-2.0 */ -package org.apache.jena.sparql.function; +package org.apache.jena.sparql; import org.apache.jena.sparql.expr.ExprEvalException; import java.math.BigInteger; +import java.text.CharacterIterator; /** - * Static limits that control what's permitted for some math computations accessible via the various SPARQL function - * libraries + * Static limits that control what's permitted for some SPARQL compilation, optimisation and expression evaluation + * <p> + * These are protective controls that allow a system operator to set limits on some potentially problematic aspects of + * SPARQL behaviour. The following limits are currently exposed: + * </p> + * <ul> + * <li>{@link #MAX_EXPONENT_DIGITS}</li> + * <li>{@link #MAX_FACTORIAL_DIGITS}</li> + * <li>{@link #MAX_LENGTH_PATH_FOR_REDUCTION}</li> + * <li>{@link #MAX_REGEX_EVALUATION_TIME}</li> + * </ul> */ -public class MathLimits { - - private MathLimits() { +public class SparqlLimits { + private SparqlLimits() { } + // Mathematical computation related limits + // These are specifically around exponentiation and factorials + /** * Default maximum digits used for {@link #MAX_EXPONENT_DIGITS} and {@link #MAX_FACTORIAL_DIGITS} */ public static final int DEFAULT_MAX_DIGITS = 64; /** * Configurable maximum number of digits for an exponent calculation + * <p> + * Any mathematical function that involves exponentiation can require large amounts of computation, and potentially + * produce an output vastly larger than its inputs. By restricting the maximum number of digits such computations + * may produce we avoid excessive computation. + * </p> */ public static int MAX_EXPONENT_DIGITS = DEFAULT_MAX_DIGITS; /** * Configurable maximum number of digits for a factorial calculation + * <p> + * A factorial computation may involve many calculations and depending on input produce a vastly larger output than + * the input. By restricting the maximum number of digits such computations may produce we avoid excessive + * computation. + * </p> */ public static int MAX_FACTORIAL_DIGITS = DEFAULT_MAX_DIGITS; @@ -141,4 +163,65 @@ public class MathLimits { throw new ExprEvalException("Calculating this factorial would produce too many digits"); } } + + // Path Compilation related limits + + /** + * Default maximum length value used for the {@link #MAX_LENGTH_PATH_FOR_REDUCTION} control + */ + public static final int DEFAULT_MAX_PATH_REDUCTION_LENGTH = 5; + /** + * Specifies the maximum length (inclusive) of a path that will be reduced by expanding it into individual + * invocations of the path expression linked by intermediate variables. Defaults to + * {@value #DEFAULT_MAX_PATH_REDUCTION_LENGTH}. + * <p> + * This control prevents a query using a path like {@code :x :p{N} :y} with a large value of {@code N} being + * expanded into a massive algebra tree that yields no performance benefits. + * </p> + * + * @see #isReducibleLength(long) + */ + public static int MAX_LENGTH_PATH_FOR_REDUCTION = DEFAULT_MAX_PATH_REDUCTION_LENGTH; + + /** + * Checks whether a given length of path is considered reducible + * <p> + * Only paths that are non-zero length and less than, or equal to, the configured + * {@link #MAX_LENGTH_PATH_FOR_REDUCTION} (default {@value #DEFAULT_MAX_PATH_REDUCTION_LENGTH}) are considered + * reducible. Anything else is left as-is as either reduction would change semantics (for zero-length paths), or + * could lead to very large algebra trees which would negatively impact performance. + * </p> + * + * @param N Path length + * @return True if reducible, false otherwise + */ + public static boolean isReducibleLength(long N) { + return N > 0 && N <= MAX_LENGTH_PATH_FOR_REDUCTION; + } + + // Regular Expression related limits + + /** + * Default maximum permitted regular expression evaluation time + * + * @see #MAX_REGEX_EVALUATION_TIME + */ + public static final long DEFAULT_MAX_REGEX_EVALUATION_TIME = 250; + /** + * Maximum permitted regular expression evaluation time, defaults to {@link #DEFAULT_MAX_REGEX_EVALUATION_TIME} + * <p> + * For some regular expression patterns the evaluation time can be excessive, especially if a pattern, or the + * pattern combined with the data leads to catastrophic backtracking. Therefore, we bound the evaluation time by + * using a special {@link CharSequence}/{@link CharacterIterator} wrapper that enforces a time limit. If the limit + * is exceeded then an {@link ExprEvalException} is thrown. This does impose a small performance penalty though + * this is negligible and considered an acceptable trade-off for the protection it provides. + * </p> + * <p> + * If an application makes extensive use of complex regular expressions, and you are certain that those are not + * subject to catastrophic backtracking you can either increase the limit appropriately. Or you can set to a + * zero/negative value to disable the limit entirely. + * </p> + */ + public static long MAX_REGEX_EVALUATION_TIME = DEFAULT_MAX_REGEX_EVALUATION_TIME; + } diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/algebra/optimize/TransformPathFlattenAlgebra.java b/jena-arq/src/main/java/org/apache/jena/sparql/algebra/optimize/TransformPathFlattenAlgebra.java index 7ca46df3a5..26394e28fa 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/algebra/optimize/TransformPathFlattenAlgebra.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/algebra/optimize/TransformPathFlattenAlgebra.java @@ -28,6 +28,7 @@ import org.apache.jena.graph.Node ; import org.apache.jena.graph.Triple ; import org.apache.jena.sparql.ARQConstants ; import org.apache.jena.sparql.ARQException ; +import org.apache.jena.sparql.SparqlLimits; import org.apache.jena.sparql.algebra.Op ; import org.apache.jena.sparql.algebra.TransformCopy ; import org.apache.jena.sparql.algebra.op.*; @@ -175,7 +176,7 @@ public class TransformPathFlattenAlgebra extends TransformCopy { @Override public void visit(P_Mod pathMod) { if (pathMod.isFixedLength()) { - if (PathCompiler.isReducibleLength(pathMod.getFixedLength())) { + if (SparqlLimits.isReducibleLength(pathMod.getFixedLength())) { // Treat as a fixed length path and convert that way instead Path p = PathFactory.pathFixedLength(pathMod.getSubPath(), pathMod.getFixedLength()); Op op = transformPath(null, subject, p, object); @@ -223,7 +224,7 @@ public class TransformPathFlattenAlgebra extends TransformCopy { // If the max length is very large the reduction is unlikely to benefit performance and just generates an // unnecessarily large algebra tree - if (!PathCompiler.isReducibleLength(pathMod.getMax())) { + if (!SparqlLimits.isReducibleLength(pathMod.getMax())) { result = null; return; } @@ -239,7 +240,7 @@ public class TransformPathFlattenAlgebra extends TransformCopy { @Override public void visit(P_FixedLength pFixedLength) { - if (!PathCompiler.isReducibleLength(pFixedLength.getCount())) { + if (!SparqlLimits.isReducibleLength(pFixedLength.getCount())) { // Don't transform zero length or too long paths result = null; return; diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/expr/RegexEngine.java b/jena-arq/src/main/java/org/apache/jena/sparql/expr/RegexEngine.java index 96812f5eae..6e0780ef38 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/expr/RegexEngine.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/expr/RegexEngine.java @@ -33,6 +33,7 @@ import org.apache.jena.ext.xerces_regex.RegexParseException; import org.apache.jena.ext.xerces_regex.RegularExpression; import org.apache.jena.query.ARQ; import org.apache.jena.sparql.ARQConstants; +import org.apache.jena.sparql.SparqlLimits; import org.apache.jena.sparql.util.Context; import org.apache.jena.sparql.util.Symbol; @@ -49,28 +50,6 @@ import org.apache.jena.sparql.util.Symbol; */ public abstract class RegexEngine { - /** - * Default maximum permitted regular expression evaluation time - * @see #MAX_REGEX_EVALUATION_TIME - */ - public static final long DEFAULT_MAX_REGEX_EVALUATION_TIME = 250; - /** - * Maximum permitted regular expression evaluation time, defaults to {@link #DEFAULT_MAX_REGEX_EVALUATION_TIME} - * <p> - * For some regular expression patterns the evaluation time can be excessive, especially if a pattern, or the - * pattern combined with the data leads to catastrophic backtracking. Therefore, we bound the evaluation time by - * using a special {@link CharSequence}/{@link CharacterIterator} wrapper that enforces a time limit. If the limit - * is exceeded then an {@link ExprEvalException} is thrown. This does impose a small performance penalty though - * this generally should be negligible. - * </p> - * <p> - * If an application makes extensive use of complex regular expressions, and you are certain that those are not - * subject to catastrophic backtracking you can either increase the limit appropriately. Or you can set to a - * zero/negative value to disable the limit entirely. - * </p> - */ - public static long MAX_REGEX_EVALUATION_TIME = DEFAULT_MAX_REGEX_EVALUATION_TIME; - public abstract boolean match(String string); // ---- ---- @@ -174,8 +153,8 @@ public abstract class RegexEngine { @Override public boolean match(String s) { - if (MAX_REGEX_EVALUATION_TIME > 0) { - return regexPattern.matches(new TimeBoundedCharSequence(s, MAX_REGEX_EVALUATION_TIME)); + if (SparqlLimits.MAX_REGEX_EVALUATION_TIME > 0) { + return regexPattern.matches(new TimeBoundedCharSequence(s, SparqlLimits.MAX_REGEX_EVALUATION_TIME)); } else { return regexPattern.matches(s); } @@ -206,7 +185,7 @@ public abstract class RegexEngine { /** * Returns a potentially time-bounded character sequence * <p> - * If {@link #MAX_REGEX_EVALUATION_TIME} is set to a positive non-zero value then a time-bounded + * If {@link SparqlLimits#MAX_REGEX_EVALUATION_TIME} is set to a positive non-zero value then a time-bounded * {@link CharSequence} is returned to prevent regular expression evaluation taking too long. If it's set to * anything else then the original character sequence is returned. * </p> @@ -217,8 +196,8 @@ public abstract class RegexEngine { if (charSequence == null) { return null; } - if (RegexEngine.MAX_REGEX_EVALUATION_TIME > 0) { - return new TimeBoundedCharSequence(charSequence, RegexEngine.MAX_REGEX_EVALUATION_TIME); + if (SparqlLimits.MAX_REGEX_EVALUATION_TIME > 0) { + return new TimeBoundedCharSequence(charSequence, SparqlLimits.MAX_REGEX_EVALUATION_TIME); } else { return charSequence; } diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/function/library/Math_exp.java b/jena-arq/src/main/java/org/apache/jena/sparql/function/library/Math_exp.java index 9352c754da..5e35d62ef6 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/function/library/Math_exp.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/function/library/Math_exp.java @@ -23,7 +23,7 @@ package org.apache.jena.sparql.function.library; import org.apache.jena.sparql.expr.NodeValue; import org.apache.jena.sparql.function.FunctionBase1; -import org.apache.jena.sparql.function.MathLimits; +import org.apache.jena.sparql.SparqlLimits; // Returns the value of e^x. public class Math_exp extends FunctionBase1 { @@ -42,7 +42,7 @@ public class Math_exp extends FunctionBase1 { } // Otherwise pre-validate exponent calculation before proceeding to calculate it - MathLimits.preValidateExponentCalculation(Math.E, d); + SparqlLimits.preValidateExponentCalculation(Math.E, d); return NodeValue.makeDouble(Math.exp(d)); } diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/function/library/Math_exp10.java b/jena-arq/src/main/java/org/apache/jena/sparql/function/library/Math_exp10.java index c9270157b2..9f15a343c0 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/function/library/Math_exp10.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/function/library/Math_exp10.java @@ -27,7 +27,7 @@ import org.apache.jena.sparql.ARQInternalErrorException; import org.apache.jena.sparql.expr.NodeValue; import org.apache.jena.sparql.expr.nodevalue.XSDFuncOp; import org.apache.jena.sparql.function.FunctionBase1; -import org.apache.jena.sparql.function.MathLimits; +import org.apache.jena.sparql.SparqlLimits; // Returns the value of natural log(x) public class Math_exp10 extends FunctionBase1 { @@ -39,7 +39,7 @@ public class Math_exp10 extends FunctionBase1 { case OP_INTEGER: int x = v.getInteger().intValue(); if ( x >= 0 ) { - MathLimits.preValidateExponentCalculation(BigInteger.TEN, v.getInteger()); + SparqlLimits.preValidateExponentCalculation(BigInteger.TEN, v.getInteger()); return NodeValue.makeInteger(BigInteger.TEN.pow(x)); } // Anything else -> double @@ -47,7 +47,7 @@ public class Math_exp10 extends FunctionBase1 { case OP_DECIMAL: case OP_FLOAT: case OP_DOUBLE: - MathLimits.preValidateExponentCalculation(10, v.getDouble()); + SparqlLimits.preValidateExponentCalculation(10, v.getDouble()); return NodeValue.makeDouble(Math.pow(10, v.getDouble())); default: throw new ARQInternalErrorException("Unrecognized numeric operation : "+ v); diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/function/library/Math_pow.java b/jena-arq/src/main/java/org/apache/jena/sparql/function/library/Math_pow.java index 95b3ca44e8..ef385aeb10 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/function/library/Math_pow.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/function/library/Math_pow.java @@ -27,7 +27,7 @@ import org.apache.jena.sparql.ARQInternalErrorException; import org.apache.jena.sparql.expr.NodeValue; import org.apache.jena.sparql.expr.nodevalue.XSDFuncOp; import org.apache.jena.sparql.function.FunctionBase2; -import org.apache.jena.sparql.function.MathLimits; +import org.apache.jena.sparql.SparqlLimits; // math:pow($x as xs:double?, $y as xs:numeric) as xs:double? // except pow(integer,+ve integer) is an integer @@ -40,7 +40,7 @@ public class Math_pow extends FunctionBase2 { BigInteger x = v1.getInteger(); int y = v2.getInteger().intValue(); if (y >= 0) { - MathLimits.preValidateExponentCalculation(x, v2.getInteger()); + SparqlLimits.preValidateExponentCalculation(x, v2.getInteger()); return NodeValue.makeInteger(x.pow(y)); } // Anything else -> double @@ -77,7 +77,7 @@ public class Math_pow extends FunctionBase2 { // If we get this far pre-validate that calculating the power won't require too many digits and if not // actually calculate - MathLimits.preValidateExponentCalculation(d1, d2); + SparqlLimits.preValidateExponentCalculation(d1, d2); return NodeValue.makeDouble(Math.pow(v1.getDouble(), v2.getDouble())); default: throw new ARQInternalErrorException("Unrecognized numeric operation : " + v1); diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/function/library/leviathan/cartesian.java b/jena-arq/src/main/java/org/apache/jena/sparql/function/library/leviathan/cartesian.java index e63cb4f366..bd2fc22c19 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/function/library/leviathan/cartesian.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/function/library/leviathan/cartesian.java @@ -29,7 +29,7 @@ import org.apache.jena.sparql.expr.ExprEvalException; import org.apache.jena.sparql.expr.ExprList; import org.apache.jena.sparql.expr.NodeValue; import org.apache.jena.sparql.function.FunctionBase; -import org.apache.jena.sparql.function.MathLimits; +import org.apache.jena.sparql.SparqlLimits; public class cartesian extends FunctionBase { @@ -43,8 +43,8 @@ public class cartesian extends FunctionBase { double dX = args.get(0).getDouble() - args.get(2).getDouble(); double dY = args.get(1).getDouble() - args.get(3).getDouble(); - MathLimits.preValidateExponentCalculation(dX, 2); - MathLimits.preValidateExponentCalculation(dY, 2); + SparqlLimits.preValidateExponentCalculation(dX, 2); + SparqlLimits.preValidateExponentCalculation(dY, 2); return NodeValue.makeDouble(Math.sqrt(Math.pow(dX, 2) + Math.pow(dY, 2))); } case 6: { @@ -52,9 +52,9 @@ public class cartesian extends FunctionBase { double dY = args.get(1).getDouble() - args.get(4).getDouble(); double dZ = args.get(2).getDouble() - args.get(5).getDouble(); - MathLimits.preValidateExponentCalculation(dX, 2); - MathLimits.preValidateExponentCalculation(dY, 2); - MathLimits.preValidateExponentCalculation(dZ, 2); + SparqlLimits.preValidateExponentCalculation(dX, 2); + SparqlLimits.preValidateExponentCalculation(dY, 2); + SparqlLimits.preValidateExponentCalculation(dZ, 2); return NodeValue.makeDouble(Math.sqrt(Math.pow(dX, 2) + Math.pow(dY, 2) + Math.pow(dZ, 2))); } default: diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/function/library/leviathan/cube.java b/jena-arq/src/main/java/org/apache/jena/sparql/function/library/leviathan/cube.java index 136afa9d7d..0a4c9dd92e 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/function/library/leviathan/cube.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/function/library/leviathan/cube.java @@ -27,7 +27,7 @@ import org.apache.jena.sparql.ARQInternalErrorException; import org.apache.jena.sparql.expr.NodeValue; import org.apache.jena.sparql.expr.nodevalue.XSDFuncOp; import org.apache.jena.sparql.function.FunctionBase1; -import org.apache.jena.sparql.function.MathLimits; +import org.apache.jena.sparql.SparqlLimits; public class cube extends FunctionBase1 { @@ -37,15 +37,15 @@ public class cube extends FunctionBase1 { { case OP_INTEGER: BigInteger i = v.getInteger(); - MathLimits.preValidateExponentCalculation(i, BigInteger.valueOf(3)); + SparqlLimits.preValidateExponentCalculation(i, BigInteger.valueOf(3)); return NodeValue.makeInteger( i.pow(3) ); case OP_DECIMAL: double dec = v.getDecimal().doubleValue(); - MathLimits.preValidateExponentCalculation(dec, 3d); + SparqlLimits.preValidateExponentCalculation(dec, 3d); return NodeValue.makeDecimal( Math.pow(dec, 3d)); case OP_FLOAT: case OP_DOUBLE: - MathLimits.preValidateExponentCalculation(v.getDouble(), 3d); + SparqlLimits.preValidateExponentCalculation(v.getDouble(), 3d); return NodeValue.makeDouble( Math.pow(v.getDouble(), 3d) ); default: throw new ARQInternalErrorException("Unrecognized numeric operation : "+v); diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/function/library/leviathan/factorial.java b/jena-arq/src/main/java/org/apache/jena/sparql/function/library/leviathan/factorial.java index 17935d498b..9de244df2b 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/function/library/leviathan/factorial.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/function/library/leviathan/factorial.java @@ -26,7 +26,7 @@ import java.math.BigInteger; import org.apache.jena.sparql.expr.ExprEvalException; import org.apache.jena.sparql.expr.NodeValue; import org.apache.jena.sparql.function.FunctionBase1; -import org.apache.jena.sparql.function.MathLimits; +import org.apache.jena.sparql.SparqlLimits; public class factorial extends FunctionBase1 { @@ -44,7 +44,7 @@ public class factorial extends FunctionBase1 { case 1: BigInteger res = i.add(BigInteger.ZERO); i = i.subtract(BigInteger.ONE); - MathLimits.preValidateFactorial(i); + SparqlLimits.preValidateFactorial(i); while (i.compareTo(BigInteger.ZERO) != 0) { res = res.multiply(i); i = i.subtract(BigInteger.ONE); diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/function/library/leviathan/pow.java b/jena-arq/src/main/java/org/apache/jena/sparql/function/library/leviathan/pow.java index f56d0415b1..f68a894f8f 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/function/library/leviathan/pow.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/function/library/leviathan/pow.java @@ -25,7 +25,7 @@ import org.apache.jena.sparql.ARQInternalErrorException; import org.apache.jena.sparql.expr.NodeValue; import org.apache.jena.sparql.expr.nodevalue.XSDFuncOp; import org.apache.jena.sparql.function.FunctionBase2; -import org.apache.jena.sparql.function.MathLimits; +import org.apache.jena.sparql.SparqlLimits; import org.apache.jena.sparql.function.library.Math_pow; public class pow extends FunctionBase2 { @@ -38,7 +38,7 @@ public class pow extends FunctionBase2 { { case OP_DECIMAL: double dec = v1.getDecimal().doubleValue(); - MathLimits.preValidateExponentCalculation(dec, v2.getDouble()); + SparqlLimits.preValidateExponentCalculation(dec, v2.getDouble()); return NodeValue.makeDecimal( Math.pow(dec, v2.getDouble())); case OP_INTEGER: case OP_FLOAT: diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/function/library/leviathan/pythagoras.java b/jena-arq/src/main/java/org/apache/jena/sparql/function/library/leviathan/pythagoras.java index 044419ed9f..d9899d61ea 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/function/library/leviathan/pythagoras.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/function/library/leviathan/pythagoras.java @@ -23,7 +23,7 @@ package org.apache.jena.sparql.function.library.leviathan; import org.apache.jena.sparql.expr.NodeValue; import org.apache.jena.sparql.function.FunctionBase2; -import org.apache.jena.sparql.function.MathLimits; +import org.apache.jena.sparql.SparqlLimits; public class pythagoras extends FunctionBase2 { @@ -32,8 +32,8 @@ public class pythagoras extends FunctionBase2 { double a = v1.getDouble(); double b = v2.getDouble(); - MathLimits.preValidateExponentCalculation(a, 2); - MathLimits.preValidateExponentCalculation(b, 2); + SparqlLimits.preValidateExponentCalculation(a, 2); + SparqlLimits.preValidateExponentCalculation(b, 2); return NodeValue.makeDouble(Math.sqrt(Math.pow(a, 2) + Math.pow(b, 2))); } diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/function/library/leviathan/root.java b/jena-arq/src/main/java/org/apache/jena/sparql/function/library/leviathan/root.java index 71636461f6..c57ca71780 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/function/library/leviathan/root.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/function/library/leviathan/root.java @@ -23,7 +23,7 @@ package org.apache.jena.sparql.function.library.leviathan; import org.apache.jena.sparql.expr.NodeValue; import org.apache.jena.sparql.function.FunctionBase2; -import org.apache.jena.sparql.function.MathLimits; +import org.apache.jena.sparql.SparqlLimits; public class root extends FunctionBase2 { @@ -32,7 +32,7 @@ public class root extends FunctionBase2 { double value = v1.getDouble(); double root = v2.getDouble(); - MathLimits.preValidateExponentCalculation(value, 1d / root); + SparqlLimits.preValidateExponentCalculation(value, 1d / root); return NodeValue.makeDouble(Math.pow(value, 1d / root)); } diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/function/library/leviathan/sq.java b/jena-arq/src/main/java/org/apache/jena/sparql/function/library/leviathan/sq.java index d318869112..4a0bcf3ac2 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/function/library/leviathan/sq.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/function/library/leviathan/sq.java @@ -27,7 +27,7 @@ import org.apache.jena.sparql.ARQInternalErrorException; import org.apache.jena.sparql.expr.NodeValue; import org.apache.jena.sparql.expr.nodevalue.XSDFuncOp; import org.apache.jena.sparql.function.FunctionBase1; -import org.apache.jena.sparql.function.MathLimits; +import org.apache.jena.sparql.SparqlLimits; public class sq extends FunctionBase1 { @@ -37,15 +37,15 @@ public class sq extends FunctionBase1 { { case OP_INTEGER: BigInteger i = v.getInteger(); - MathLimits.preValidateExponentCalculation(i, BigInteger.valueOf(2)); + SparqlLimits.preValidateExponentCalculation(i, BigInteger.valueOf(2)); return NodeValue.makeInteger( i.pow(2) ); case OP_DECIMAL: double dec = v.getDecimal().doubleValue(); - MathLimits.preValidateExponentCalculation(dec, 2d); + SparqlLimits.preValidateExponentCalculation(dec, 2d); return NodeValue.makeDecimal( Math.pow(dec, 2d)); case OP_FLOAT: case OP_DOUBLE: - MathLimits.preValidateExponentCalculation(v.getDouble(), 2d); + SparqlLimits.preValidateExponentCalculation(v.getDouble(), 2d); return NodeValue.makeDouble( Math.pow(v.getDouble(), 2d) ); default: throw new ARQInternalErrorException("Unrecognized numeric operation : "+v); diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/path/PathCompiler.java b/jena-arq/src/main/java/org/apache/jena/sparql/path/PathCompiler.java index 4d2e31318a..94e35b89e9 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/path/PathCompiler.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/path/PathCompiler.java @@ -25,6 +25,7 @@ import org.apache.jena.graph.Node; import org.apache.jena.graph.Triple; import org.apache.jena.sparql.ARQConstants; import org.apache.jena.sparql.ARQException; +import org.apache.jena.sparql.SparqlLimits; import org.apache.jena.sparql.algebra.optimize.TransformPathFlattenAlgebra; import org.apache.jena.sparql.algebra.optimize.TransformPathFlatten; import org.apache.jena.sparql.core.PathBlock; @@ -33,20 +34,6 @@ import org.apache.jena.sparql.core.Var; import org.apache.jena.sparql.core.VarAlloc; public class PathCompiler { - /** - * Default maximum length value used for the {@link #MAX_LENGTH_PATH_FOR_REDUCTION} control - */ - public static final int DEFAULT_MAX_LENGTH = 5; - /** - * Specifies the maximum length (inclusive) of a path that will be reduced by expanding it into individual - * invocations of the path expression linked by intermediate variables. Defaults to {@value #DEFAULT_MAX_LENGTH}. - * <p> - * This control prevents a query using a path like {@code :x :p{N} :y} with a large value of {@code N} being - * expanded into a massive algebra tree that yields no performance benefits. - * </p> - * @see #isReducibleLength(long) - */ - public static int MAX_LENGTH_PATH_FOR_REDUCTION = DEFAULT_MAX_LENGTH; // Convert to work on OpPath. // Need pre (and post) BGPs. @@ -141,7 +128,7 @@ public class PathCompiler { if ( path instanceof P_FixedLength pFixedLen ) { long N = pFixedLen.getCount(); - if (isReducibleLength(N)) { + if (SparqlLimits.isReducibleLength(N)) { // Don't do {0} // Also if the path is too long the reduction won't generate any performance benefits reduceFixedLength(x, varAlloc, startNode, endNode, N, pFixedLen.getSubPath()); @@ -152,7 +139,7 @@ public class PathCompiler { if ( path instanceof P_Mod pMod ) { if ( pMod.isFixedLength() && pMod.getFixedLength() > 0 ) { long N = pMod.getFixedLength(); - if (isReducibleLength(N)) { + if (SparqlLimits.isReducibleLength(N)) { reduceFixedLength(x, varAlloc, startNode, endNode, N, pMod.getSubPath()); return; } @@ -202,21 +189,6 @@ public class PathCompiler { x.add(new TriplePath(startNode, path, endNode)); } - /** - * Checks whether a given length of path is considered reducible - * <p> - * Only paths that are non-zero length and less than, or equal to, the configured - * {@link #MAX_LENGTH_PATH_FOR_REDUCTION} (default {@value #DEFAULT_MAX_LENGTH}) are considered reducible. Anything - * else is left as-is as either reduction would change semantics (for zero-length paths), or could lead to very - * large algebra tree which would negatively impact performance. - * </p> - * @param N Path length - * @return True if reducible, false otherwise - */ - public static boolean isReducibleLength(long N) { - return N > 0 && N <= MAX_LENGTH_PATH_FOR_REDUCTION; - } - /** * Reduces a fixed length path by expanding the {@code n} steps into individual path invocations with intermediate * variables. @@ -226,6 +198,7 @@ public class PathCompiler { * @param endNode End node * @param n Fixed path length * @param subPath Sub path to use in each expanded step + * @see SparqlLimits#isReducibleLength(long) */ private static void reduceFixedLength(PathBlock x, VarAlloc varAlloc, Node startNode, Node endNode, long n, Path subPath) { diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/pfunction/library/strSplit.java b/jena-arq/src/main/java/org/apache/jena/sparql/pfunction/library/strSplit.java index d123dbb6c1..089bd86d26 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/pfunction/library/strSplit.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/pfunction/library/strSplit.java @@ -32,13 +32,13 @@ import org.apache.jena.graph.Node ; import org.apache.jena.graph.NodeFactory ; import org.apache.jena.query.QueryBuildException; import org.apache.jena.rdf.model.impl.Util ; +import org.apache.jena.sparql.SparqlLimits; import org.apache.jena.sparql.core.Var ; import org.apache.jena.sparql.engine.ExecutionContext ; import org.apache.jena.sparql.engine.QueryIterator ; import org.apache.jena.sparql.engine.binding.Binding ; import org.apache.jena.sparql.engine.binding.BindingFactory ; import org.apache.jena.sparql.engine.iterator.QueryIterPlainWrapper ; -import org.apache.jena.sparql.expr.ExprEvalException; import org.apache.jena.sparql.expr.RegexEngine; import org.apache.jena.sparql.pfunction.PFuncSimpleAndList ; import org.apache.jena.sparql.pfunction.PropFuncArg ; @@ -77,7 +77,7 @@ public class strSplit extends PFuncSimpleAndList // StrUtils will also trim whitespace List<String> tokens; - if (RegexEngine.MAX_REGEX_EVALUATION_TIME > 0) { + if (SparqlLimits.MAX_REGEX_EVALUATION_TIME > 0) { Pattern pattern = Pattern.compile(regex); tokens = Arrays.stream(pattern.split(RegexEngine.timeBounded(s), 0)) .map(String::trim) diff --git a/jena-arq/src/test/java/org/apache/jena/sparql/TC_ARQ.java b/jena-arq/src/test/java/org/apache/jena/sparql/TC_ARQ.java index 6b28a0a5bb..c947fcf67e 100644 --- a/jena-arq/src/test/java/org/apache/jena/sparql/TC_ARQ.java +++ b/jena-arq/src/test/java/org/apache/jena/sparql/TC_ARQ.java @@ -85,6 +85,9 @@ import org.apache.jena.sparql.syntax.TS_Syntax; , TS_Update.class , TS_SparqlLib.class + // SPARQL Limits + , TestSparqlLimits.class + // Outside org.apache.jena.sparql , TS_Query.class diff --git a/jena-arq/src/test/java/org/apache/jena/sparql/function/library/TestMathLimits.java b/jena-arq/src/test/java/org/apache/jena/sparql/TestSparqlLimits.java similarity index 84% rename from jena-arq/src/test/java/org/apache/jena/sparql/function/library/TestMathLimits.java rename to jena-arq/src/test/java/org/apache/jena/sparql/TestSparqlLimits.java index c33f02eb1d..6a5cdd7d8c 100644 --- a/jena-arq/src/test/java/org/apache/jena/sparql/function/library/TestMathLimits.java +++ b/jena-arq/src/test/java/org/apache/jena/sparql/TestSparqlLimits.java @@ -19,10 +19,9 @@ * SPDX-License-Identifier: Apache-2.0 */ -package org.apache.jena.sparql.function.library; +package org.apache.jena.sparql; import org.apache.jena.sparql.expr.ExprEvalException; -import org.apache.jena.sparql.function.MathLimits; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.Arguments; import org.junit.jupiter.params.provider.MethodSource; @@ -32,7 +31,7 @@ import java.util.stream.Stream; import static org.junit.jupiter.api.Assertions.assertThrows; -public class TestMathLimits { +public class TestSparqlLimits { public static Stream<Arguments> bigIntegerExponents() { return Stream.of(Arguments.of(BigInteger.valueOf(2), BigInteger.valueOf(16), true), @@ -45,9 +44,9 @@ public class TestMathLimits { @MethodSource("bigIntegerExponents") public void givenBigIntegers_whenPreValidatingExponent_thenAsExpected(BigInteger a, BigInteger b, boolean valid) { if (valid) { - MathLimits.preValidateExponentCalculation(a, b); + SparqlLimits.preValidateExponentCalculation(a, b); } else { - assertThrows(ExprEvalException.class, () -> MathLimits.preValidateExponentCalculation(a, b)); + assertThrows(ExprEvalException.class, () -> SparqlLimits.preValidateExponentCalculation(a, b)); } } @@ -61,9 +60,9 @@ public class TestMathLimits { @MethodSource("factorials") public void givenFactorialInputs_whenPreValidating_thenAsExpected(BigInteger n, boolean valid) { if (valid) { - MathLimits.preValidateFactorial(n); + SparqlLimits.preValidateFactorial(n); } else { - assertThrows(ExprEvalException.class, () -> MathLimits.preValidateFactorial(n)); + assertThrows(ExprEvalException.class, () -> SparqlLimits.preValidateFactorial(n)); } } } diff --git a/jena-arq/src/test/java/org/apache/jena/sparql/algebra/optimize/TestTransformPathFlatten.java b/jena-arq/src/test/java/org/apache/jena/sparql/algebra/optimize/TestTransformPathFlatten.java index daa0fe29d8..6b6a63f538 100644 --- a/jena-arq/src/test/java/org/apache/jena/sparql/algebra/optimize/TestTransformPathFlatten.java +++ b/jena-arq/src/test/java/org/apache/jena/sparql/algebra/optimize/TestTransformPathFlatten.java @@ -26,6 +26,7 @@ import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertThrows; import static org.junit.jupiter.api.Assertions.assertThrowsExactly; +import org.apache.jena.sparql.SparqlLimits; import org.junit.jupiter.api.BeforeAll; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -501,11 +502,11 @@ public class TestTransformPathFlatten { try { // Reconfiguring the maximum permitted path length for reduction should prevent this query from being // optimised - PathCompiler.MAX_LENGTH_PATH_FOR_REDUCTION = 3; + SparqlLimits.MAX_LENGTH_PATH_FOR_REDUCTION = 3; Op op1 = path("?x", ":p{5}", ":T1"); testDefaultTransform(op1, null); } finally { - PathCompiler.MAX_LENGTH_PATH_FOR_REDUCTION = PathCompiler.DEFAULT_MAX_LENGTH; + SparqlLimits.MAX_LENGTH_PATH_FOR_REDUCTION = SparqlLimits.DEFAULT_MAX_PATH_REDUCTION_LENGTH; } } @@ -513,11 +514,11 @@ public class TestTransformPathFlatten { try { // Reconfiguring the maximum permitted path length for reduction should prevent this query from being // optimised - PathCompiler.MAX_LENGTH_PATH_FOR_REDUCTION = 3; + SparqlLimits.MAX_LENGTH_PATH_FOR_REDUCTION = 3; Op op1 = path("?x", ":p{5}", ":T1"); testAlgebraTransform(op1, null); } finally { - PathCompiler.MAX_LENGTH_PATH_FOR_REDUCTION = PathCompiler.DEFAULT_MAX_LENGTH; + SparqlLimits.MAX_LENGTH_PATH_FOR_REDUCTION = SparqlLimits.DEFAULT_MAX_PATH_REDUCTION_LENGTH; } } diff --git a/jena-arq/src/test/java/org/apache/jena/sparql/expr/TestRegex.java b/jena-arq/src/test/java/org/apache/jena/sparql/expr/TestRegex.java index 2412d1b1bf..66622c6c20 100644 --- a/jena-arq/src/test/java/org/apache/jena/sparql/expr/TestRegex.java +++ b/jena-arq/src/test/java/org/apache/jena/sparql/expr/TestRegex.java @@ -27,6 +27,7 @@ import static org.junit.jupiter.api.Assertions.fail; import java.util.List; import java.util.stream.Stream; +import org.apache.jena.sparql.SparqlLimits; import org.apache.logging.log4j.util.Strings; import org.junit.jupiter.api.AfterAll; import org.junit.jupiter.api.BeforeAll; @@ -44,6 +45,11 @@ import org.apache.jena.sparql.engine.binding.BindingFactory; public class TestRegex { + /** + * Example data used for some early catastrophic backtracking testing, unfortunately this example exhibited very + * different runtime characteristics on the different regex engines making it unusable as a reliable test case + */ + @SuppressWarnings("unused") protected static final String ALPHABET_CSV = "a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,z,"; private static Stream<Arguments> provideArgs() { @@ -134,30 +140,30 @@ public class TestRegex @ParameterizedTest(name = "{1}") @MethodSource("backtrackingRegex") - public void givenBacktrackingRegex_whenEvaluatingRegexWithoutTimeLimit_thenEventuallyCompletes(String input, String pattern, String flags, boolean shouldMatch) { + public void backtrackingRegexWithTimeLimitDisabledEventuallyCompletes(String input, String pattern, String flags, boolean shouldMatch) { // Given, When and Then - long existingMax = RegexEngine.MAX_REGEX_EVALUATION_TIME; + long existingMax = SparqlLimits.MAX_REGEX_EVALUATION_TIME; try { - RegexEngine.MAX_REGEX_EVALUATION_TIME = -1; + SparqlLimits.MAX_REGEX_EVALUATION_TIME = -1; regexTest(input, pattern, flags, shouldMatch); } finally { - RegexEngine.MAX_REGEX_EVALUATION_TIME = existingMax; + SparqlLimits.MAX_REGEX_EVALUATION_TIME = existingMax; } } @ParameterizedTest(name = "{1}") @MethodSource("backtrackingRegex") - public void givenBacktrackingRegex_whenEvaluatingRegexWithTimeLimit_thenFails(String input, String pattern, String flags, boolean shouldMatch) { + public void backtrackingRegexWithTimeLimitFails(String input, String pattern, String flags, boolean shouldMatch) { // Given, When and Then - long existingMax = RegexEngine.MAX_REGEX_EVALUATION_TIME; + long existingMax = SparqlLimits.MAX_REGEX_EVALUATION_TIME; try { // Intentionally minimal evaluation time so should fail near immediately, while we could set a more // realistic limit for the test the reality is that the different regex engines evaluate at different speed // so it's hard to pick a limit that reliably fails other than a trivially small one - RegexEngine.MAX_REGEX_EVALUATION_TIME = 1; + SparqlLimits.MAX_REGEX_EVALUATION_TIME = 1; assertThrows(ExprEvalException.class, () -> regexTest(input, pattern, flags, shouldMatch)); } finally { - RegexEngine.MAX_REGEX_EVALUATION_TIME = existingMax; + SparqlLimits.MAX_REGEX_EVALUATION_TIME = existingMax; } } } diff --git a/jena-arq/src/test/java/org/apache/jena/sparql/function/library/TS_LibraryFunctions.java b/jena-arq/src/test/java/org/apache/jena/sparql/function/library/TS_LibraryFunctions.java index b6eb8c7a12..6561dc23ae 100644 --- a/jena-arq/src/test/java/org/apache/jena/sparql/function/library/TS_LibraryFunctions.java +++ b/jena-arq/src/test/java/org/apache/jena/sparql/function/library/TS_LibraryFunctions.java @@ -21,6 +21,7 @@ package org.apache.jena.sparql.function.library; +import org.apache.jena.sparql.TestSparqlLimits; import org.junit.jupiter.api.AfterAll; import org.junit.jupiter.api.BeforeAll; import org.junit.platform.suite.api.SelectClasses; @@ -38,7 +39,6 @@ import org.apache.jena.sparql.expr.NodeValue; , TestFnFunctionsOther.class , TestFnFunctionsFormat.class , TestFnFunctionsCollation.class - , TestMathLimits.class }) public class TS_LibraryFunctions { // Expected warnings off. diff --git a/jena-arq/src/test/java/org/apache/jena/sparql/pfunction/library/TestStrSplit.java b/jena-arq/src/test/java/org/apache/jena/sparql/pfunction/library/TestStrSplit.java index 5e0b299acb..26c41b7e7d 100644 --- a/jena-arq/src/test/java/org/apache/jena/sparql/pfunction/library/TestStrSplit.java +++ b/jena-arq/src/test/java/org/apache/jena/sparql/pfunction/library/TestStrSplit.java @@ -28,8 +28,8 @@ import java.util.stream.Stream; import org.apache.commons.lang3.StringUtils; import org.apache.commons.lang3.Strings; import org.apache.jena.query.*; +import org.apache.jena.sparql.SparqlLimits; import org.apache.jena.sparql.expr.ExprEvalException; -import org.apache.jena.sparql.expr.RegexEngine; import org.junit.jupiter.api.Test; import org.apache.jena.graph.Node; @@ -130,10 +130,10 @@ public class TestStrSplit { @ParameterizedTest(name = "{1}") @MethodSource("slowSplits") - public void givenSlowRegex_whenSplittingWithTimeLimit_thenFails(String data, String pattern, int expectedResultCount) { - long existingLimit = RegexEngine.MAX_REGEX_EVALUATION_TIME; + public void slowRegexWithTimeLimitShouldFail(String data, String pattern, int expectedResultCount) { + long existingLimit = SparqlLimits.MAX_REGEX_EVALUATION_TIME; try { - RegexEngine.MAX_REGEX_EVALUATION_TIME = 1; + SparqlLimits.MAX_REGEX_EVALUATION_TIME = 1; query("SELECT ?x WHERE { ?x apf:strSplit ('" + data + "' '" + pattern + "') }"); long start = System.currentTimeMillis(); ExprEvalException e = assertThrows(ExprEvalException.class, () -> qe.execSelect().hasNext()); @@ -141,23 +141,23 @@ public class TestStrSplit { assertTrue(elapsed <= 250, "Elapsed time was " + elapsed); assertTrue(Strings.CI.contains(e.getMessage(), "time limit exceeded")); } finally { - RegexEngine.MAX_REGEX_EVALUATION_TIME = existingLimit; + SparqlLimits.MAX_REGEX_EVALUATION_TIME = existingLimit; } } @ParameterizedTest(name = "{1}") @MethodSource("slowSplits") - public void givenSlowRegex_whenSplittingWithNoTimeLimit_thenEventuallySucceeds(String data, String pattern, int expectedResultCount) { - long existingLimit = RegexEngine.MAX_REGEX_EVALUATION_TIME; + public void slowRegexWithDisabledTimeLimitEventuallySucceeds(String data, String pattern, int expectedResultCount) { + long existingLimit = SparqlLimits.MAX_REGEX_EVALUATION_TIME; try { // Given query("SELECT ?x WHERE { ?x apf:strSplit ('" + data + "' '" + pattern + "') }"); // When and Then - RegexEngine.MAX_REGEX_EVALUATION_TIME = -1; + SparqlLimits.MAX_REGEX_EVALUATION_TIME = -1; assertEquals(expectedResultCount, ResultSetFormatter.consume(qe.execSelect())); } finally { - RegexEngine.MAX_REGEX_EVALUATION_TIME = existingLimit; + SparqlLimits.MAX_REGEX_EVALUATION_TIME = existingLimit; } }
