Data

JSON Data types can be defined as set $Data$:

where:

• $Constant$

  $$Constant=\{null,true,false\}$$

  Constant values represented with literals null, true and false.

• $Number$

  $$Number=ℝ$$

  Real numbers (JSON doesn't distinguish between integers and floating point values).

• $String$

  $$String=(c_1,...,c_n),n\ge 0,c_i\in \text{Unicode characters}$$

  Sequence of zero or more Unicode characters including additional escaped sequences.

• $Array$

  $$Array=(a_1,...,a_n),n\ge 0,a_i\in Data$$

  Ordered set of zero or more elements which are themselves JSON Data.

• $Object$

  $$Object=\{(k_1,v_1),...,(k_n,v_n)\},n\ge 0,k_i\in String,v_i\in Data$$

  Associative sequence of key/value pairs where keys are strings and values are one of JSON Data

Path

JSON Path is reference to part of composite JSON data. It is itself represented as JSON Data and can be defined as set $Path$:

where:

In following definitions, we will use operator $\&$ as reference to data and operator $*$ as value of referenced data.

Algorithm, used as basis for resolving path references, can be represented with function $ref$:

where:

Usage of different data types as paths, enables one to reference data in different data structures:

• $path\in Integer$

  $$re{f}_{int}(data,path)=\{\begin{array}{ll}\&a_{path+1}& data\in Array,data=(a_1,...,a_n),path<n\\ \&null& \text{otherwise}\end{array}$$

  Integer paths are used for referencing elements of array. If referenced element doesn't exist or provided data is not an array, neutral null element is referenced.

• $path\in String$

  $$re{f}_{str}(data,path)=\{\begin{array}{ll}\&v_i& data\in Object,data=\{(k_1,v_1),...,(k_n,v_n)\},path=k_i\\ \&null& \text{otherwise}\end{array}$$

  String paths reference object entries based on object's key values. If referenced key doesn't exist or provided data is not an object, neutral null element is referenced.

• $path\in PArray$

  $$re{f}_{arr}(data,path)=\{\begin{array}{ll}\&data& path=\varnothing \\ ref(*ref(data,a_1),(a_2,...,a_n))& path=(a_1,...,a_n)\end{array}$$

  Array paths are used for composition of other paths. Array elements are used for recursive path application on result of previous path application.

Normalization

Each path can be normalized - represented as array of strings and integers:

Path normalization is defined as function $norm$:

When used as argument to $ref$ function, normalized path is equivalent to its original non-normalized form:

These property of normalized path is useful in case of path functions' implementations. By normalizing path prior to its usage, implementation or $ref$ can be based on sequential reduction of provided data instead of recursive application.

Functions

• $get$

  $$\begin{array}{cc}& get:Data\times Path\to Data\\ & get(data,path)=value\end{array}$$

  Function $get$ is used for obtaining part of $data$ structure referenced by $path$.

  Examples:

  data = {"a": [1, 2, {"b": true}, []]}
  
  get(data, []) = {"a": [1, 2, {"b": true}, []]}
  get(data, "a") = [1, 2, {"b": true}, []]
  get(data, ["a", 0]) = 1
  get(data, ["a", 2, "b"]) = true
  get(data, ["a", [2, ["b"]]]) = true
  get(data, [[], [[]]]) = {"a": [1, 2, {"b": true}, []]}
  get(data, 0) = null
  get(data, "b") = null
  get(data, ["a", 4]) = null

• $set$

  $$\begin{array}{cc}& set:Data\times Path\times Data\to Data\\ & set(data,path,value)=data\text{'}\end{array}$$

  Function $set$ is used for creating new data structure $data\text{'}$. Difference, between $data$ and $data\text{'}$, is in part of data structure referenced by $path$. In $data\text{'}$ this part is replaced with $value$.

  Edge cases:

  • array index out of bound

    If integer path references array with length less than path, additional null elements are created so that referenced array element can be set to provided value.

  • object key not available

    If string path references object which doesn't contain entry with key equal to path, new entry is created.

  • path type doesn't match data type

    If integer path references data which is not array, data is replaced with empty array and previously described array index out of bound edge case is applied.

    If string path references data which is not object, data is replaced with empty object and previously described object key not available edge case is applied.

    Examples:

    data = {"a": [1, 2, {"b": true}, []]}
    
    set(data, ["a", 2, "b"], false) = {"a": [1, 2, {"b": false}, []]}
    set(data, "a", 42) = {"a": 42}
    set(data, ["a", [3], 0], 42) = {"a": [1, 2, {"b": true}, [42]]}
    set(data, ["a", [3], 1], 42) = {"a": [1, 2, {"b": true}, [null, 42]]}
    set(data, [], 42) = 42
    set(null, [1, "a", 2], 42) = [null, {"a": [null, null, 42]}]

• $remove$

  $$\begin{array}{cc}& remove:Data\times Path\to Data\\ & remove(data,path)=data\text{'}\end{array}$$

  Function $remove$ is used for creating new data structure $data\text{'}$ based on provided $data$. Difference, between $data$ and $data\text{'}$, is in part of data structure referenced by $path$. In $data\text{'}$ this part is omitted.

  In edge cases:

  • array index out of bound

  • object key not available

  • path type doesn't match data type

  $data\text{'}$ is same as $data$.

  Examples:

  data = {"a": [1, 2, {"b": true}, []]}
  
  delete(data, ["a", 1]) = {"a": [1, {"b": true}, []]}
  delete(data, []) = null
  delete(data, ["a", 2, "b"]) = {"a": [1, 2, {}, []]}
  delete(data, "b") = {"a": [1, 2, {"b": true}, []]}

With this basic functions, other specialized functions can be defined. Example of commonly used derived function is $change$:

where $f$ is arbitrary data transformation function:

It should be noted that all of these functions are "pure functions" that shouldn't make in-place changes of provided data arguments. Implementations usually take this into account by optimizing re usability of shared data.