jsonpath-rust

The library provides the basic functionality to find the set of the data according to the filtering query. The idea comes from XPath for XML structures. The details can be found there Therefore JsonPath is a query language for JSON, similar to XPath for XML. The JsonPath query is a set of assertions to specify the JSON fields that need to be verified.

Python bindings (jsonpath-rust-bindings) are available on pypi:

pip install jsonpath-rust-bindings

Simple examples

Let's suppose we have a following json:

{
  "shop": {
    "orders": [
      {
        "id": 1,
        "active": true
      },
      {
        "id": 2
      },
      {
        "id": 3
      },
      {
        "id": 4,
        "active": true
      }
    ]
  }
}

And we pursue to find all orders id having the field 'active'. We can construct the jsonpath instance like that $.shop.orders[?(@.active)].id and get the result [1,4]

The jsonpath description

Functions

Size

A function length() transforms the output of the filtered expression into a size of this element It works with arrays, therefore it returns a length of a given array, otherwise null.

$.some_field.length()

To use it for objects, the operator [*] can be used. $.object.[*].length()

Operators

Filter expressions

The expressions appear in the filter operator like that [?(@.len > 0)]. The expression in general consists of the following elements:

• Left and right operands, that is ,in turn, can be a static value,representing as a primitive type like a number, string value 'value', array of them or another json path instance.
• Expression sign, denoting what action can be performed

Filter expressions can be chained using || and && (logical or and logical and correspondingly) in the following way:

{
  "key": [
    {
      "city": "London",
      "capital": true,
      "size": "big"
    },
    {
      "city": "Berlin",
      "capital": true,
      "size": "big"
    },
    {
      "city": "Tokyo",
      "capital": true,
      "size": "big"
    },
    {
      "city": "Moscow",
      "capital": true,
      "size": "big"
    },
    {
      "city": "Athlon",
      "capital": false,
      "size": "small"
    },
    {
      "city": "Dortmund",
      "capital": false,
      "size": "big"
    },
    {
      "city": "Dublin",
      "capital": true,
      "size": "small"
    }
  ]
}

The path $.key[?(@.capital == false || @size == 'small')].city will give the following result:

[
  "Athlon",
  "Dublin",
  "Dortmund"
]

And the path $.key[?(@.capital == false && @size != 'small')].city ,in its turn, will give the following result:

[
  "Dortmund"
]

By default, the operators have the different priority so && has a higher priority so to change it the brackets can be used. $.[?((@.f == 0 || @.f == 1) && ($.x == 15))].city

Examples

Given the json

{
 "store": {
   "book": [
     {
       "category": "reference",
       "author": "Nigel Rees",
       "title": "Sayings of the Century",
       "price": 8.95
     },
     {
       "category": "fiction",
       "author": "Evelyn Waugh",
       "title": "Sword of Honour",
       "price": 12.99
     },
     {
       "category": "fiction",
       "author": "Herman Melville",
       "title": "Moby Dick",
       "isbn": "0-553-21311-3",
       "price": 8.99
     },
     {
       "category": "fiction",
       "author": "J. R. R. Tolkien",
       "title": "The Lord of the Rings",
       "isbn": "0-395-19395-8",
       "price": 22.99
     }
   ],
   "bicycle": {
     "color": "red",
     "price": 19.95
   }
 },
 "expensive": 10
}

Library Usage

The library intends to provide the basic functionality for ability to find the slices of data using the syntax, saying above. The dependency can be found as following: jsonpath-rust = *

The basic example is the following one:

The library returns a json path value as a result. This is enum type which represents:

• Slice - a point to the passed original json
• NewValue - a new json data that has been generated during the path( for instance length operator)
• NoValue - indicates there is no match between given json and jsonpath in the most cases due to absent fields or inconsistent data.

To extract data there are two methods, provided on the value:

let v:JsonPathValue<Value> =...
v.to_data();
v.slice_or( & some_dafault_value)

Find

there are 4 different functions to find data inside a value. All take references, to increase reusability. Especially json parsing and jsonpath parsing can take significant time, compared to a simple find.

The methods find, find_as_path, find_slice and find_slice_ptr take the same inputs, but handle them differently depending on your usecase. They are further described in the docs.

use jsonpath_rust::{JsonPath, JsonPathValue};
use serde_json::json;
use std::str::FromStr;

fn main() {
    let data = json!({"first":{"second":[{"active":1},{"passive":1}]}});
    let path = JsonPath::from_str("$.first.second[?(@.active)]").unwrap();
    let slice_of_data = path.find_slice(&data);

    let expected_value = json!({"active":1});
    let expected_path = "$.['first'].['second'][0]".to_string();

    assert_eq!(
        slice_of_data,
        vec![JsonPathValue::Slice(&expected_value, expected_path)]
    );
}

The structure

The internal structure of the JsonPath can be found here: https://docs.rs/jsonpath-rust/latest/jsonpath_rust/parser/model/enum.JsonPath.html

The internal structure of the JsonPathIndex can be found here: https://docs.rs/jsonpath-rust/latest/jsonpath_rust/parser/model/enum.JsonPathIndex.html

JsonLike

The library provides a trait JsonLike that can be implemented for any type. This allows you to use the JsonPath methods on your own types.

How to contribute

TBD

How to update version

• update files
• commit them
• add tag git tag -a v<Version> -m "message"
• git push origin <tag_name>