You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@pinot.apache.org by xi...@apache.org on 2026/08/12 19:50:18 UTC
(pinot) 01/01: Benchmark Fory JSON function counterparts
This is an automated email from the ASF dual-hosted git repository.
xiangfu0 pushed a commit to branch agent/experimental-fory-json-functions
in repository https://gitbox.apache.org/repos/asf/pinot.git
commit 62c2db4b670153709edc03eb98bf70fcb53b5880
Author: Xiang Fu <xi...@Xiang-mac-mtv-2.local>
AuthorDate: Wed Aug 12 12:50:01 2026 -0700
Benchmark Fory JSON function counterparts
---
.../common/function/FastJsonPathExtractorTest.java | 1 +
.../JsonExtractScalarTransformFunction.java | 6 +-
.../core/data/function/JsonFunctionsTest.java | 9 +
.../perf/BenchmarkJsonExtractScalarQuery.java | 198 +++++++++++++++++----
.../pinot/perf/BenchmarkJsonPathExtraction.java | 141 +++++++++++++--
5 files changed, 302 insertions(+), 53 deletions(-)
diff --git a/pinot-common/src/test/java/org/apache/pinot/common/function/FastJsonPathExtractorTest.java b/pinot-common/src/test/java/org/apache/pinot/common/function/FastJsonPathExtractorTest.java
index 3212b705d1b..f4677acb672 100644
--- a/pinot-common/src/test/java/org/apache/pinot/common/function/FastJsonPathExtractorTest.java
+++ b/pinot-common/src/test/java/org/apache/pinot/common/function/FastJsonPathExtractorTest.java
@@ -397,6 +397,7 @@ public class FastJsonPathExtractorTest {
assertEquals(invoke("jsonPathStringFast", json, "$.user.country", "DEFAULT"), "US");
assertEquals(invoke("jsonPathStringFirstMatch", json, "$.user.country", "DEFAULT"), "US");
assertEquals(invoke("jsonPathStringFast", json, "$.missing", "DEFAULT"), "DEFAULT");
+ assertEquals(invoke("jsonPathLongFast", json, "$.user.age", -7L), 41L);
assertEquals(invoke("jsonPathLongFirstMatch", json, "$.user.age", -7L), 41L);
assertEquals(invoke("jsonPathDoubleFast", json, "$.user.score", -7.5d), 9.5d);
/// A complex path must still resolve through the function by falling back to Jayway, i.e. produce exactly
diff --git a/pinot-core/src/main/java/org/apache/pinot/core/operator/transform/function/JsonExtractScalarTransformFunction.java b/pinot-core/src/main/java/org/apache/pinot/core/operator/transform/function/JsonExtractScalarTransformFunction.java
index 43df67fa1f5..a16e73990d0 100644
--- a/pinot-core/src/main/java/org/apache/pinot/core/operator/transform/function/JsonExtractScalarTransformFunction.java
+++ b/pinot-core/src/main/java/org/apache/pinot/core/operator/transform/function/JsonExtractScalarTransformFunction.java
@@ -75,9 +75,9 @@ import org.roaringbitmap.RoaringBitmap;
/// only for well-formed, duplicate-free JSON. `Fast` scans the full root value and retains Jayway's last-key-wins
/// and malformed-document behavior; see [FastJsonPathExtractor] for one documented unaddressed-value edge case.
/// `jsonExtractScalarFory` is experimental and must be selected explicitly. It accelerates simple paths over
-/// `STRING` input for scalar result types other than `STRING` and `BIG_DECIMAL`. `BYTES` input, complex paths,
-/// containers / array result types, precision-sensitive results, deeply nested documents, and Fory failures use
-/// Jayway. Its name, supported envelope, and implementation can change while the integration is evaluated.
+/// `STRING` input for scalar result types other than `STRING`, `JSON`, and `BIG_DECIMAL`. `BYTES` input, complex
+/// paths, containers / array result types, precision-sensitive results, deeply nested documents, and Fory failures
+/// use Jayway. Its name, supported envelope, and implementation can change while the integration is evaluated.
///
/// **Arguments:**
/// - `jsonField` — single-value `STRING` or `BYTES` column / transform expression containing JSON.
diff --git a/pinot-core/src/test/java/org/apache/pinot/core/data/function/JsonFunctionsTest.java b/pinot-core/src/test/java/org/apache/pinot/core/data/function/JsonFunctionsTest.java
index df97c4b2926..bbaed22658a 100644
--- a/pinot-core/src/test/java/org/apache/pinot/core/data/function/JsonFunctionsTest.java
+++ b/pinot-core/src/test/java/org/apache/pinot/core/data/function/JsonFunctionsTest.java
@@ -147,6 +147,15 @@ public class JsonFunctionsTest {
inputs.add(new Object[]{
"json_path_double_fory(json, '$.ratio', -1.0)", Lists.newArrayList("json"), row12, 1.25
});
+ inputs.add(new Object[]{
+ "json_path_string_fast(json, '$.text', 'DEFAULT')", Lists.newArrayList("json"), row12, "value"
+ });
+ inputs.add(new Object[]{
+ "json_path_long_fast(json, '$.count', -1)", Lists.newArrayList("json"), row12, 10L
+ });
+ inputs.add(new Object[]{
+ "json_path_double_fast(json, '$.ratio', -1.0)", Lists.newArrayList("json"), row12, 1.25
+ });
return inputs.toArray(new Object[0][]);
}
diff --git a/pinot-perf/src/main/java/org/apache/pinot/perf/BenchmarkJsonExtractScalarQuery.java b/pinot-perf/src/main/java/org/apache/pinot/perf/BenchmarkJsonExtractScalarQuery.java
index 47fb9787b5f..a89f77aedca 100644
--- a/pinot-perf/src/main/java/org/apache/pinot/perf/BenchmarkJsonExtractScalarQuery.java
+++ b/pinot-perf/src/main/java/org/apache/pinot/perf/BenchmarkJsonExtractScalarQuery.java
@@ -21,7 +21,10 @@ package org.apache.pinot.perf;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
+import java.util.Objects;
import java.util.concurrent.TimeUnit;
+import org.apache.pinot.common.function.ForyJsonPathExtractor;
+import org.apache.pinot.common.function.SimpleJsonPath;
import org.apache.pinot.common.request.context.ExpressionContext;
import org.apache.pinot.common.request.context.LiteralContext;
import org.apache.pinot.core.common.BlockValSet;
@@ -53,6 +56,9 @@ import org.openjdk.jmh.runner.options.OptionsBuilder;
/// Measures the actual query-side `jsonExtractScalar*` ValueBlock loop. Each invocation processes a 128-row block;
/// JMH normalizes throughput and allocation to one row via [OperationsPerInvocation]. Input projection is represented
/// by a pre-materialized String array so the comparison isolates JSON extraction, type coercion, and result writing.
+/// Result dispatch is selected once during setup, outside the measured per-row loop. The type-specific JSON literals
+/// have equal encoded lengths and occupy the same early/late field locations so STRING, LONG, and DOUBLE comparisons
+/// do not accidentally measure different document layouts.
@BenchmarkMode(Mode.Throughput)
@OutputTimeUnit(TimeUnit.SECONDS)
@Fork(1)
@@ -63,8 +69,8 @@ public class BenchmarkJsonExtractScalarQuery {
private static final int BLOCK_ROWS = 128;
private static final TransformResultMetadata STRING_METADATA =
new TransformResultMetadata(DataType.STRING, true, false);
- private static final String BASE_JSON = "{"
- + "\"earlyMetric\":17,"
+ private static final String BASE_JSON_FORMAT = "{"
+ + "\"earlyValue\":%s,"
+ "\"user\":{\"id\":\"u-19283\",\"country\":\"US\",\"tier\":\"gold\",\"age\":41},"
+ "\"event\":{\"name\":\"checkout\",\"cart\":[{\"sku\":\"A1\",\"qty\":2,\"price\":19.99},"
+ "{\"sku\":\"B7\",\"qty\":1,\"price\":129.0},{\"sku\":\"C3\",\"qty\":4,\"price\":3.5}],"
@@ -75,7 +81,8 @@ public class BenchmarkJsonExtractScalarQuery {
+ "\"coordinates\":[-122.4194,37.7749]},"
+ "\"attributes\":{\"campaign\":\"summer-sale\",\"referrer\":\"search\",\"experiment\":\"checkout-v2\"},"
+ "\"flags\":[\"returning\",\"subscribed\",\"beta\"],"
- + "\"lateMetric\":19} ";
+ + "\"lateValue\":%s} ";
+ private static final String LATE_FIELD_MARKER = "\"lateValue\":";
@Param({"early", "late"})
private String _fieldPosition;
@@ -83,6 +90,15 @@ public class BenchmarkJsonExtractScalarQuery {
@Param({"700", "8192", "65536"})
private int _documentBytes;
+ /// STRING is an intentional Jayway fallback for precision-safe coercion. Add `-p _resultType=STRING` explicitly to
+ /// characterize that public-function fallback; default trials cover only actual Fory streaming.
+ @Param({"LONG", "DOUBLE"})
+ private DataType _resultType;
+
+ /// Use `-p _pathResult=missing` to measure explicit defaults without multiplying the default suite.
+ @Param({"hit"})
+ private String _pathResult;
+
private ValueBlock _valueBlock;
private JsonExtractScalarTransformFunction _jayway;
private JsonExtractScalarTransformFunction _fast;
@@ -91,67 +107,181 @@ public class BenchmarkJsonExtractScalarQuery {
@Setup
public void setUp() {
- String json = buildJson(_documentBytes);
+ if (_resultType != DataType.STRING && !ForyJsonPathExtractor.isAvailable()) {
+ throw new IllegalStateException("Fory JSON is unavailable; refusing to publish fallback results as Fory");
+ }
+ String json = buildJson(_documentBytes, _resultType);
String[] jsonRows = new String[BLOCK_ROWS];
Arrays.fill(jsonRows, json);
TransformFunction input = new StringArrayTransformFunction(jsonRows);
- String path = "early".equals(_fieldPosition) ? "$.earlyMetric" : "$.lateMetric";
- List<TransformFunction> arguments = List.of(input, literal(path), literal("LONG"));
+ boolean early = "early".equals(_fieldPosition);
+ boolean hit = "hit".equals(_pathResult);
+ String path = "$." + (early ? "early" : "late") + (hit ? "Value" : "Ghost");
+ Object defaultValue = defaultValue(_resultType);
+ List<TransformFunction> arguments = List.of(input, literal(DataType.STRING, path),
+ literal(DataType.STRING, _resultType.name()), literal(_resultType, defaultValue));
_valueBlock = new FixedValueBlock(BLOCK_ROWS);
- _jayway = new JsonExtractScalarTransformFunction();
- _fast = new JsonExtractScalarTransformFunction.Fast();
- _firstMatch = new JsonExtractScalarTransformFunction.FirstMatch();
- _fory = new JsonExtractScalarTransformFunction.Fory();
- for (JsonExtractScalarTransformFunction function : List.of(_jayway, _fast, _firstMatch, _fory)) {
- function.init(arguments, Map.<String, ColumnContext>of(), false);
- long expected = "early".equals(_fieldPosition) ? 17L : 19L;
- long[] values = function.transformToLongValuesSV(_valueBlock);
- if (values.length < BLOCK_ROWS || values[0] != expected || values[BLOCK_ROWS - 1] != expected) {
- throw new IllegalStateException(function.getName() + " produced an unexpected query result");
+ if (_resultType != DataType.STRING) {
+ Object directForyResult = ForyJsonPathExtractor.extract(json, SimpleJsonPath.compile(path));
+ Object expectedForyResult = hit ? hitValue(_resultType, early) : null;
+ if (!Objects.equals(directForyResult, expectedForyResult)) {
+ throw new IllegalStateException("Direct Fory extraction produced an unexpected " + _resultType + " result");
}
}
+ _jayway = initialize(new JsonExtractScalarTransformFunction(), arguments);
+ _fast = initialize(new JsonExtractScalarTransformFunction.Fast(), arguments);
+ _firstMatch = initialize(new JsonExtractScalarTransformFunction.FirstMatch(), arguments);
+ _fory = initialize(new JsonExtractScalarTransformFunction.Fory(), arguments);
+
+ Object expectedRows = expectedRows(_resultType, hit ? hitValue(_resultType, early) : defaultValue);
+ Object jaywayRows = apply(_jayway);
+ assertResultsEqual("jsonExtractScalar", expectedRows, jaywayRows);
+ assertResultsEqual("jsonExtractScalarFast", jaywayRows, apply(_fast));
+ assertResultsEqual("jsonExtractScalarFirstMatch", jaywayRows, apply(_firstMatch));
+ assertResultsEqual("jsonExtractScalarFory", jaywayRows, apply(_fory));
}
- private static LiteralTransformFunction literal(String value) {
- return new LiteralTransformFunction(new LiteralContext(DataType.STRING, value));
+ private JsonExtractScalarTransformFunction initialize(JsonExtractScalarTransformFunction function,
+ List<TransformFunction> arguments) {
+ function.init(arguments, Map.<String, ColumnContext>of(), false);
+ return function;
}
- private static String buildJson(int targetBytes) {
- if (BASE_JSON.length() >= targetBytes) {
- return BASE_JSON;
+ private Object apply(JsonExtractScalarTransformFunction function) {
+ switch (_resultType) {
+ case STRING:
+ return function.transformToStringValuesSV(_valueBlock);
+ case LONG:
+ return function.transformToLongValuesSV(_valueBlock);
+ case DOUBLE:
+ return function.transformToDoubleValuesSV(_valueBlock);
+ default:
+ throw new IllegalStateException("Unsupported benchmark result type: " + _resultType);
}
- String marker = "\"lateMetric\":";
- int markerOffset = BASE_JSON.indexOf(marker);
+ }
+
+ private static LiteralTransformFunction literal(DataType dataType, Object value) {
+ return new LiteralTransformFunction(new LiteralContext(dataType, value));
+ }
+
+ private static String buildJson(int targetBytes, DataType resultType) {
+ String baseJson = String.format(BASE_JSON_FORMAT, jsonLiteral(resultType, true), jsonLiteral(resultType, false));
+ if (baseJson.length() >= targetBytes) {
+ return baseJson;
+ }
+ int markerOffset = baseJson.indexOf(LATE_FIELD_MARKER);
String paddingPrefix = "\"padding\":\"";
String paddingSuffix = "\",";
- int paddingLength = targetBytes - BASE_JSON.length() - paddingPrefix.length() - paddingSuffix.length();
- return BASE_JSON.substring(0, markerOffset) + paddingPrefix + "x".repeat(paddingLength) + paddingSuffix
- + BASE_JSON.substring(markerOffset);
+ int paddingLength = targetBytes - baseJson.length() - paddingPrefix.length() - paddingSuffix.length();
+ return baseJson.substring(0, markerOffset) + paddingPrefix + "x".repeat(paddingLength) + paddingSuffix
+ + baseJson.substring(markerOffset);
+ }
+
+ private static String jsonLiteral(DataType resultType, boolean early) {
+ switch (resultType) {
+ case STRING:
+ return early ? "\"S\"" : "\"T\"";
+ case LONG:
+ return early ? "170" : "190";
+ case DOUBLE:
+ return early ? "1.7" : "1.9";
+ default:
+ throw new IllegalStateException("Unsupported benchmark result type: " + resultType);
+ }
+ }
+
+ private static Object hitValue(DataType resultType, boolean early) {
+ switch (resultType) {
+ case STRING:
+ return early ? "S" : "T";
+ case LONG:
+ return early ? 170L : 190L;
+ case DOUBLE:
+ return early ? 1.7d : 1.9d;
+ default:
+ throw new IllegalStateException("Unsupported benchmark result type: " + resultType);
+ }
+ }
+
+ private static Object defaultValue(DataType resultType) {
+ switch (resultType) {
+ case STRING:
+ return "DEFAULT";
+ case LONG:
+ return -1L;
+ case DOUBLE:
+ return -1d;
+ default:
+ throw new IllegalStateException("Unsupported benchmark result type: " + resultType);
+ }
+ }
+
+ private static Object expectedRows(DataType resultType, Object expectedValue) {
+ switch (resultType) {
+ case STRING:
+ String[] stringValues = new String[BLOCK_ROWS];
+ Arrays.fill(stringValues, (String) expectedValue);
+ return stringValues;
+ case LONG:
+ long[] longValues = new long[BLOCK_ROWS];
+ Arrays.fill(longValues, (Long) expectedValue);
+ return longValues;
+ case DOUBLE:
+ double[] doubleValues = new double[BLOCK_ROWS];
+ Arrays.fill(doubleValues, (Double) expectedValue);
+ return doubleValues;
+ default:
+ throw new IllegalStateException("Unsupported benchmark result type: " + resultType);
+ }
+ }
+
+ private void assertResultsEqual(String functionName, Object expected, Object actual) {
+ boolean equal;
+ switch (_resultType) {
+ case STRING:
+ equal = Arrays.equals((String[]) expected, (String[]) actual);
+ break;
+ case LONG:
+ equal = Arrays.equals((long[]) expected, (long[]) actual);
+ break;
+ case DOUBLE:
+ equal = Arrays.equals((double[]) expected, (double[]) actual);
+ break;
+ default:
+ throw new IllegalStateException("Unsupported benchmark result type: " + _resultType);
+ }
+ if (!equal) {
+ throw new IllegalStateException(functionName + " produced an unexpected " + _resultType + " result for "
+ + _fieldPosition + '/' + _pathResult);
+ }
}
@Benchmark
@OperationsPerInvocation(BLOCK_ROWS)
- public long[] queryJayway() {
- return _jayway.transformToLongValuesSV(_valueBlock);
+ public Object queryJayway() {
+ return apply(_jayway);
}
@Benchmark
@OperationsPerInvocation(BLOCK_ROWS)
- public long[] queryFast() {
- return _fast.transformToLongValuesSV(_valueBlock);
+ public Object queryFast() {
+ return apply(_fast);
}
+ /// Auxiliary comparator: unlike the primary parity-preserving variants, FirstMatch intentionally has weaker
+ /// duplicate-key and malformed-tail semantics.
@Benchmark
@OperationsPerInvocation(BLOCK_ROWS)
- public long[] queryFirstMatch() {
- return _firstMatch.transformToLongValuesSV(_valueBlock);
+ public Object queryFirstMatch() {
+ return apply(_firstMatch);
}
+ /// For STRING, this measures the production Fory function's intentional Jayway fallback rather than Fory parsing.
@Benchmark
@OperationsPerInvocation(BLOCK_ROWS)
- public long[] queryFory() {
- return _fory.transformToLongValuesSV(_valueBlock);
+ public Object queryFory() {
+ return apply(_fory);
}
public static void main(String[] arguments)
diff --git a/pinot-perf/src/main/java/org/apache/pinot/perf/BenchmarkJsonPathExtraction.java b/pinot-perf/src/main/java/org/apache/pinot/perf/BenchmarkJsonPathExtraction.java
index 185e92635d1..2e1b8fa6d84 100644
--- a/pinot-perf/src/main/java/org/apache/pinot/perf/BenchmarkJsonPathExtraction.java
+++ b/pinot-perf/src/main/java/org/apache/pinot/perf/BenchmarkJsonPathExtraction.java
@@ -29,6 +29,7 @@ import com.jayway.jsonpath.spi.mapper.JacksonMappingProvider;
import java.util.concurrent.TimeUnit;
import org.apache.fory.json.ForyJson;
import org.apache.pinot.common.function.FastJsonPathExtractor;
+import org.apache.pinot.common.function.ForyJsonPathExtractor;
import org.apache.pinot.common.function.SimpleJsonPath;
import org.apache.pinot.common.function.scalar.JsonFunctions;
import org.openjdk.jmh.annotations.Benchmark;
@@ -55,9 +56,9 @@ import org.openjdk.jmh.runner.options.OptionsBuilder;
/// nested event payload, because that is what decides whether early exit can pay off. `documentBytes` pads the
/// payload immediately before the late field so parser scaling is visible without changing the addressed values.
///
-/// The single-column benchmarks are also the per-row cost of `jsonExtractScalar`: that transform function
-/// does exactly `parseContext.parse(row).read(jsonPath)` per row, so measuring the extraction in isolation
-/// measures it without the surrounding `ValueBlock` scaffolding.
+/// The scalar-function methods measure the production `jsonPath*` ingestion wrappers. The lower-level single-column
+/// methods isolate parser/traversal strategies; [BenchmarkJsonExtractScalarQuery] is the authoritative query-transform
+/// measurement.
@BenchmarkMode(Mode.Throughput)
@OutputTimeUnit(TimeUnit.SECONDS)
@Fork(1)
@@ -67,6 +68,9 @@ import org.openjdk.jmh.runner.options.OptionsBuilder;
public class BenchmarkJsonPathExtraction {
private static final Predicate[] NO_PREDICATES = new Predicate[0];
private static final ForyJson FORY_JSON = ForyJson.builder().build();
+ private static final String STRING_DEFAULT = "DEFAULT";
+ private static final long LONG_DEFAULT = -1L;
+ private static final double DOUBLE_DEFAULT = -1.25d;
/// Exactly the context `JsonExtractScalarTransformFunction` and `JsonFunctions` use.
private static final ParseContext PARSE_CONTEXT = JsonPath.using(
@@ -75,7 +79,7 @@ public class BenchmarkJsonPathExtraction {
private static final String BASE_JSON = "{"
+ "\"ts\":1719878400123,"
- + "\"user\":{\"id\":\"u-19283\",\"country\":\"US\",\"tier\":\"gold\",\"age\":41},"
+ + "\"user\":{\"id\":\"u-19283\",\"country\":\"US\",\"score\":17.25,\"age\":41},"
+ "\"event\":{\"name\":\"checkout\",\"cart\":[{\"sku\":\"A1\",\"qty\":2,\"price\":19.99},"
+ "{\"sku\":\"B7\",\"qty\":1,\"price\":149.5},{\"sku\":\"C3\",\"qty\":5,\"price\":3.25}],"
+ "\"total\":352.73,\"currency\":\"USD\"},"
@@ -85,7 +89,7 @@ public class BenchmarkJsonPathExtraction {
+ "\"tags\":[\"mobile\",\"ios\",\"returning\",\"promo-eligible\",\"newsletter\"],"
+ "\"session\":{\"id\":\"s-aaaabbbbccccdddd\",\"start\":1719878300000,\"pages\":14,\"referrer\":"
+ "\"https://example.com/landing?utm_source=x&utm_medium=y\"},"
- + "\"trailer\":{\"country\":\"DE\",\"note\":\"last field in the document\"}"
+ + "\"trailer\":{\"country\":\"DE\",\"double\":19.25,\"long\":19}"
+ "}";
/// Four derived columns, spread through the document, as an ingestion `transformConfigs` would pull.
@@ -98,9 +102,17 @@ public class BenchmarkJsonPathExtraction {
@Param({"700", "8192", "65536"})
private int _documentBytes;
+ /// Use `-p _valueCase=missing` to measure the explicit-default path without doubling the default benchmark suite.
+ @Param({"hit"})
+ private String _valueCase;
+
private String _json;
private String _path;
+ private String _longPath;
+ private String _doublePath;
private SimpleJsonPath _simplePath;
+ private SimpleJsonPath _simpleLongPath;
+ private SimpleJsonPath _simpleDoublePath;
private SimpleJsonPath[] _simpleFourPaths;
private Object[] _fourResults;
@@ -113,19 +125,44 @@ public class BenchmarkJsonPathExtraction {
@Setup(Level.Trial)
public void setUp() {
+ if (!ForyJsonPathExtractor.isAvailable()) {
+ throw new IllegalStateException("Fory JSON is unavailable; refusing to publish fallback results as Fory");
+ }
_json = buildJson(_documentBytes);
- _path = "early".equals(_fieldPosition) ? "$.user.country" : "$.trailer.country";
+ boolean missing;
+ if ("hit".equals(_valueCase)) {
+ missing = false;
+ } else if ("missing".equals(_valueCase)) {
+ missing = true;
+ } else {
+ throw new IllegalArgumentException("Unsupported value case: " + _valueCase);
+ }
+ if (missing) {
+ _path = "$.missing";
+ _longPath = _path;
+ _doublePath = _path;
+ } else if ("early".equals(_fieldPosition)) {
+ _path = "$.user.country";
+ _longPath = "$.user.age";
+ _doublePath = "$.user.score";
+ } else {
+ _path = "$.trailer.country";
+ _longPath = "$.trailer.long";
+ _doublePath = "$.trailer.double";
+ }
_simplePath = SimpleJsonPath.compile(_path);
+ _simpleLongPath = SimpleJsonPath.compile(_longPath);
+ _simpleDoublePath = SimpleJsonPath.compile(_doublePath);
_simpleFourPaths = new SimpleJsonPath[FOUR_PATHS.length];
for (int i = 0; i < FOUR_PATHS.length; i++) {
_simpleFourPaths[i] = SimpleJsonPath.compile(FOUR_PATHS[i]);
}
_fourResults = new Object[FOUR_PATHS.length];
- String expected = "early".equals(_fieldPosition) ? "US" : "DE";
- if (!expected.equals(JsonFunctions.jsonPathStringFory(_json, _path, ""))) {
- throw new IllegalStateException("Fory result does not match the expected value for " + _path);
- }
+ String expectedString = missing ? STRING_DEFAULT : "early".equals(_fieldPosition) ? "US" : "DE";
+ long expectedLong = missing ? LONG_DEFAULT : "early".equals(_fieldPosition) ? 41L : 19L;
+ double expectedDouble = missing ? DOUBLE_DEFAULT : "early".equals(_fieldPosition) ? 17.25d : 19.25d;
+ verifyScalarFunctions(expectedString, expectedLong, expectedDouble);
for (String path : FOUR_PATHS) {
String jayway = JsonFunctions.jsonPathString(_json, path, "");
String fory = JsonFunctions.jsonPathStringFory(_json, path, "");
@@ -139,6 +176,42 @@ public class BenchmarkJsonPathExtraction {
}
}
+ private void verifyScalarFunctions(String expectedString, long expectedLong, double expectedDouble) {
+ Object extractedString = ForyJsonPathExtractor.extract(_json, _simplePath);
+ Object extractedLong = ForyJsonPathExtractor.extract(_json, _simpleLongPath);
+ Object extractedDouble = ForyJsonPathExtractor.extract(_json, _simpleDoublePath);
+ if ("missing".equals(_valueCase)) {
+ if (extractedString != null || extractedLong != null || extractedDouble != null) {
+ throw new IllegalStateException("Fory returned a value for a missing benchmark path");
+ }
+ } else if (!expectedString.equals(extractedString) || ((Number) extractedLong).longValue() != expectedLong
+ || Double.compare(((Number) extractedDouble).doubleValue(), expectedDouble) != 0) {
+ throw new IllegalStateException("Direct Fory extraction produced an unexpected benchmark result");
+ }
+
+ String jaywayString = JsonFunctions.jsonPathString(_json, _path, STRING_DEFAULT);
+ String fastString = JsonFunctions.jsonPathStringFast(_json, _path, STRING_DEFAULT);
+ String foryString = JsonFunctions.jsonPathStringFory(_json, _path, STRING_DEFAULT);
+ if (!expectedString.equals(jaywayString) || !jaywayString.equals(fastString) || !jaywayString.equals(foryString)) {
+ throw new IllegalStateException("JSON string extractors disagree for " + _path);
+ }
+
+ long jaywayLong = JsonFunctions.jsonPathLong(_json, _longPath, LONG_DEFAULT);
+ long fastLong = JsonFunctions.jsonPathLongFast(_json, _longPath, LONG_DEFAULT);
+ long foryLong = JsonFunctions.jsonPathLongFory(_json, _longPath, LONG_DEFAULT);
+ if (jaywayLong != expectedLong || fastLong != jaywayLong || foryLong != jaywayLong) {
+ throw new IllegalStateException("JSON long extractors disagree for " + _longPath);
+ }
+
+ double jaywayDouble = JsonFunctions.jsonPathDouble(_json, _doublePath, DOUBLE_DEFAULT);
+ double fastDouble = JsonFunctions.jsonPathDoubleFast(_json, _doublePath, DOUBLE_DEFAULT);
+ double foryDouble = JsonFunctions.jsonPathDoubleFory(_json, _doublePath, DOUBLE_DEFAULT);
+ if (Double.compare(jaywayDouble, expectedDouble) != 0 || Double.compare(fastDouble, jaywayDouble) != 0
+ || Double.compare(foryDouble, jaywayDouble) != 0) {
+ throw new IllegalStateException("JSON double extractors disagree for " + _doublePath);
+ }
+ }
+
private static String buildJson(int targetBytes) {
if (BASE_JSON.length() >= targetBytes) {
return BASE_JSON;
@@ -160,7 +233,7 @@ public class BenchmarkJsonPathExtraction {
return PARSE_CONTEXT.parse(_json).read(_path, NO_PREDICATES);
}
- /// Fory parse plus the same Jayway tree traversal used by the production wrapper.
+ /// Fory dynamic-tree parsing plus Jayway traversal, retained as a non-production comparison baseline.
@Benchmark
public Object foryOneColumn() {
Object root = FORY_JSON.fromJson(_json, Object.class);
@@ -180,25 +253,61 @@ public class BenchmarkJsonPathExtraction {
/// The existing Jayway scalar function (applicability check + String coercion).
@Benchmark
public String jsonPathStringJayway() {
- return JsonFunctions.jsonPathString(_json, _path, "");
+ return JsonFunctions.jsonPathString(_json, _path, STRING_DEFAULT);
}
/// The production Fory scalar function (applicability check + String coercion).
@Benchmark
public String jsonPathStringFory() {
- return JsonFunctions.jsonPathStringFory(_json, _path, "");
+ return JsonFunctions.jsonPathStringFory(_json, _path, STRING_DEFAULT);
}
- /// The opt-in fast scalar function, full scan (exact parity).
+ /// The opt-in fast scalar function, full scan with fallback for unsupported or failed extraction.
@Benchmark
public String jsonPathStringFast() {
- return JsonFunctions.jsonPathStringFast(_json, _path, "");
+ return JsonFunctions.jsonPathStringFast(_json, _path, STRING_DEFAULT);
}
/// The opt-in fast scalar function, early exit / first match.
@Benchmark
public String jsonPathStringFirstMatch() {
- return JsonFunctions.jsonPathStringFirstMatch(_json, _path, "");
+ return JsonFunctions.jsonPathStringFirstMatch(_json, _path, STRING_DEFAULT);
+ }
+
+ /// The existing Jayway scalar function (applicability check + long coercion).
+ @Benchmark
+ public long jsonPathLongJayway() {
+ return JsonFunctions.jsonPathLong(_json, _longPath, LONG_DEFAULT);
+ }
+
+ /// The opt-in fast scalar function, full scan with fallback for unsupported or failed extraction.
+ @Benchmark
+ public long jsonPathLongFast() {
+ return JsonFunctions.jsonPathLongFast(_json, _longPath, LONG_DEFAULT);
+ }
+
+ /// The production Fory scalar function (applicability check + long coercion).
+ @Benchmark
+ public long jsonPathLongFory() {
+ return JsonFunctions.jsonPathLongFory(_json, _longPath, LONG_DEFAULT);
+ }
+
+ /// The existing Jayway scalar function (applicability check + double coercion).
+ @Benchmark
+ public double jsonPathDoubleJayway() {
+ return JsonFunctions.jsonPathDouble(_json, _doublePath, DOUBLE_DEFAULT);
+ }
+
+ /// The opt-in fast scalar function, full scan with fallback for unsupported or failed extraction.
+ @Benchmark
+ public double jsonPathDoubleFast() {
+ return JsonFunctions.jsonPathDoubleFast(_json, _doublePath, DOUBLE_DEFAULT);
+ }
+
+ /// The production Fory scalar function (applicability check + double coercion).
+ @Benchmark
+ public double jsonPathDoubleFory() {
+ return JsonFunctions.jsonPathDoubleFory(_json, _doublePath, DOUBLE_DEFAULT);
}
@Benchmark
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@pinot.apache.org
For additional commands, e-mail: commits-help@pinot.apache.org