Benchmark: JSON Query Libraries Comparison

HTML Preparation code:

<script type="text/javascript" language="javascript" src="https://cdn.jsdelivr.net/npm/jsonata@1.5.4/jsonata-es5.min.js"></script>
<script type="text/javascript" language="javascript" src="https://cdn.jsdelivr.net/npm/jspath@0.4.0/jspath.min.js"></script>
<script type="text/javascript" language="javascript" src="https://cdnjs.cloudflare.com/ajax/libs/jmespath/0.15.0/jmespath.min.js"></script>
<script type="text/javascript" language="javascript" src="https://prototype.imin.co/eventseries-sample.js"></script>
<script type="text/javascript" language="javascript" src="http://meta.imin.co/v2.js"></script>

Script Preparation code:

var get = p => o =>
    p.reduce((xs, x) => {
        if (Array.isArray(xs)) {
            return xs.map(get([x])).filter(y => y !== null).flat();
        } else {
            return (xs && xs[x]) ? xs[x] : null;
        }
    }, o);

function flattenCollection(collectionIndex) {
    if (collectionIndex.type === 'imin:CollectionIndex') {
        return Object.entries(collectionIndex['imin:index']).reduce(function(map, [k, v]) {
            map[k] = flattenCollection(v);
            return map;
        }, {});
    } else if (collectionIndex.type === 'imin:Collection') {
        return collectionIndex['imin:item'].reduce(function(map, item) {
            map[item.id] = item;
            return map;
        }, {});
    } else {
        return collectionIndex;
    }
}

var result = {
    subEvent: [
      {
        offers: [
          {
              acceptedPaymentMethod: [
                'one',
                'two',
                'three',
            ],
      	  },
                    {
              acceptedPaymentMethod: [
                'four',
                'five',
                'six',
            ],
      	  },
        ]
      },
       {
        offers: [
          {
              acceptedPaymentMethod: [
                'seven',
                'eight',
                'nine',
            ],
      	  },
                    {
              acceptedPaymentMethod: [
                'ten',
                'eleven',
                'twelve',
            ],
      	  },
        ]
      },
    ]
};

Tests:

jsonata
var jsonataResult = jsonata('subEvent.offers.acceptedPaymentMethod').evaluate(result).join(' ');
simple
var simpleResult = get(['subEvent','offers','acceptedPaymentMethod'])(result).join(' ');
jspath
var jsPathResult = JSPath.apply('.subEvent.offers.acceptedPaymentMethod', result).join(' ');
jmespath
var jmespathResult = jmespath.search(result, 'subEvent[].offers[].acceptedPaymentMethod[]').join(' ');
control
result.subEvent.map(s => s.offers.map(o => o.acceptedPaymentMethod)).flat(2).join(' ')
jspath+predicates
var jsPathResult = JSPath.apply('."imin:aggregateOffer".publicAdult{.price > 0 && .priceCurrency > "."}[-1]', result);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
jsonata
simple
jspath
jmespath
control
jspath+predicates

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 10 months ago)

User agent: Mozilla/5.0 (iPad; CPU OS 18_5_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) CriOS/137.0.7151.107 Mobile/15E148 Safari/604.1

Browser/OS: Chrome Mobile iOS 137 on iOS 18.5.0

View result in a separate tab

Test name	Executions per second
jsonata	58908.4 Ops/sec
simple	1647345.5 Ops/sec
jspath	1651438.1 Ops/sec
jmespath	320793.1 Ops/sec
control	2262911.0 Ops/sec
jspath+predicates	11028303.0 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated one year ago):

LLMs can make mistakes. Check important info.

Measuring the performance of different JSON querying libraries is essential in various applications, such as data processing and analysis. The provided benchmark compares four popular JSON query libraries: jsonata, simple, jspath, and jmespath.

**What are tested?**

The following options are compared:

1.  **jsonata**: A JavaScript library that allows you to write queries against JSON data.
2.  **simple**: A lightweight, pure-JavaScript implementation of JSON querying.
3.  **jspath**: A JavaScript library for working with JSON Path expressions, which provide a more structured way of navigating nested JSON data.
4.  **jmespath**: Another JavaScript library that provides an expressive query language for JSON data.

**Pros and Cons:**

*   **jsonata**: Pros:

*   Easy to learn and use
    *   Fast execution performance
    *   Supports a wide range of data types, including nested objects and arrays

Cons:

*   May require more code to achieve the same result as other libraries
*   **simple**: Pros:

*   Lightweight and easy to integrate into applications
    *   Fast execution performance

Cons:

*   Limited support for advanced JSON querying features
*   **jspath**: Pros:

*   Provides a structured way of navigating nested JSON data, making it easier to manage complex queries
    *   Supports predicates (conditions) to filter results

Cons:

*   Steeper learning curve due to the use of JSON Path expressions
*   **jmespath**: Pros:

*   Provides an expressive query language for JSON data
    *   Supports a wide range of data types, including nested objects and arrays
    *   Fast execution performance

Cons:

*   May require more code to achieve the same result as other libraries

**Benchmark Results:**

The latest benchmark results show that **jspath+predicates** outperforms all other options in terms of executions per second. This is likely due to the optimized implementation of JSON Path expressions and the use of predicates to filter results.

The results also indicate that **jmespath**, while not as fast as jspath, still provides good performance and a competitive execution rate.

**Conclusion:**

When choosing a JSON querying library for your application, consider factors such as ease of use, performance, and feature set. Based on the benchmark results, if you need high-performance querying capabilities and are willing to invest time in learning a new query language, **jspath+predicates** might be the best choice.

However, if you prioritize lightweight integration and fast execution, **simple** or **jsonata** could be suitable options. Ultimately, the selection of a library depends on your specific use case and performance requirements.

Related benchmarks:

JSON Query Libraries Comparison (version: 0)

Comparison of various JSON Querying libraries

Comparing performance of: jsonata vs simple vs jspath vs jmespath vs control vs jspath+predicates

Created: 3 years ago by: Guest

Jump to the latest result

jsonata

simple

jspath

jmespath

control

jspath+predicates

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated one year ago):