Adding complete support for JSON path to velox

[bikramSingh91]

Objective:

Support Json Path syntax to match coverage with Presto Java

Background:

JSONPath syntax is used for selecting and extracting JSON values from a given JSON value. The syntax was introduced in 2007 by Goessner which left some of it to interpretation. Therefore, without a complete standardized syntax many implementations adopted their own interpretations which caused them to vary in many cases. Fortunately, a standardization was introduced very recently RFC (feb 2024) but none of the existing implementations completely conform to it.

Presto Java uses Jayway library to provide JSONPath support which has its own set of differences from the standard. However, since we want to present Presto CPP as a drop in replacement we would have to match Presto Java as viable.

There is no equivalent in CPP for Jayway however there is a library that seems to have complete coverage Jsoncons. However, it does have its own set of differences compared to Jayway.

How implementations differ:

Presto Java VS Velox (SIMDJson based implementation)

• Velox has very limited support:

$      	- the root element
. or []  - child operator
*          - wildcard (all objects/elements regardless of their names). selects all children of a node

• Reason: We internally use SIMDJson for parsing which is extremely fast for parsing but only supports the root and child operators. We built a custom implementation for supporting wildcard operator on top where we see drop in performance when compared to the basic operators
• Operations we are missing entirely

Array Slice ( $[1:3] )
Union ( $[0]['c','d'] )
Recursive_descent ( $..* )
Filter Expr ( $[?(@.key)] )
Script expression (uses () ) ($[(@.length-1)] ~ $[-1])
Current element/node ( @.a )

Presto Java VS Jsoncons

• Jsoncons returns all results in an array/list, even for those paths that are “definite”.
  • A definite path is something that can only return one or less values. A path is indefinite if it contains:

* - wildcard
.. - a deep scan operator
?(<expression>) - an expression
[<number>, <number> (, <number>)] - multiple array indexes

• Also, there are many differences between the interpretation of paths which is a deliberate choice by each library.

Jsoncons VS Velox(current)

• Apart from the correctness differences between the two, there can be differences in performance as Velox uses SIMDJson which is much faster, albeit only for the very simple cases. See the “Presto Java VS Velox” section that talks about the microbenchmark

Solution:

Hybrid SIMDJson and jsoncons

• Use existing SIMDJson based implementation for paths currently supported (super fast and should be the most common usecase)
• Jsoncons for more complex paths
• Can leverage the parser in Jsoncons to quickly re-route the execution to the correct implementation
• Incrementally add support to the SIMDJson based implementation for usecases that are performance sensitive and widely used
• RISK: We would need to make sure that Jsoncons has the same behavior as SIMDJson for the functionalities shared between them