How can I merge two JSON objects with Rust?

Question

I have two JSON files:

JSON 1

{
  "title": "This is a title",
  "person" : {
    "firstName" : "John",
    "lastName" : "Doe"
  },
  "cities":[ "london", "paris" ]
}

JSON 2

{
  "title": "This is another title",
  "person" : {
    "firstName" : "Jane"
  },
  "cities":[ "colombo" ]
}

I want to merge #2 into #1 where #2 overrides #1, producing following output:

{
  "title": "This is another title",
  "person" : {
    "firstName" : "Jane",
    "lastName" : "Doe"
  },
  "cities":[ "colombo" ]
}

I checked out the crate json-patch which does this but it does not compile against stable Rust. Is it possible to do something similar with something like serde_json and stable Rust?

score 8 · Answer 1 · edited Oct 07 '21 at 08:46

Since you wanted to use json-patch, I assume you were looking specifically for a JSON Merge Patch (RFC 7396) implementation since that is what that crate implements. In that case, merging an object should unset those keys whose corresponding value in the patch is null, which the code samples in the other answers do not implement.

The code that accounts for that is below. I modified the patch to delete the person.lastName key by setting it to null as a demonstration. It also does not need to unwrap() the Option returned by as_object_mut(), unlike one of the other answers.

use serde_json::{json, Value};

fn merge(a: &mut Value, b: Value) {
    if let Value::Object(a) = a {
        if let Value::Object(b) = b {
            for (k, v) in b {
                if v.is_null() {
                    a.remove(&k);
                }
                else {
                    merge(a.entry(k).or_insert(Value::Null), v);
                }
            } 

            return;
        }
    }

    *a = b;
}

fn main() {
    let mut a = json!({
        "title": "This is a title",
        "person" : {
            "firstName" : "John",
            "lastName" : "Doe"
        },
        "cities":[ "london", "paris" ]
    });

    let b = json!({
        "title": "This is another title",
        "person" : {
            "firstName" : "Jane",
            "lastName": null
        },
        "cities":[ "colombo" ]
    });

    merge(&mut a, b);
    println!("{:#}", a);
}

The expected output is

{
  "cities": [
    "colombo"
  ],
  "person": {
    "firstName": "Jane"
  },
  "title": "This is another title"
}

Notice person.lastName has been unset.

score 5 · Accepted Answer · answered Nov 06 '17 at 17:02

Placing the answer suggested by Shepmaster below

#[macro_use]
extern crate serde_json;

use serde_json::Value;

fn merge(a: &mut Value, b: Value) {
    match (a, b) {
        (a @ &mut Value::Object(_), Value::Object(b)) => {
            let a = a.as_object_mut().unwrap();
            for (k, v) in b {
                merge(a.entry(k).or_insert(Value::Null), v);
            }
        }
        (a, b) => *a = b,
    }
}

fn main() {
    let mut a = json!({
        "title": "This is a title",
        "person" : {
            "firstName" : "John",
            "lastName" : "Doe"
        },
        "cities":[ "london", "paris" ]
    });

    let b = json!({
        "title": "This is another title",
        "person" : {
            "firstName" : "Jane"
        },
        "cities":[ "colombo" ]
    });

    merge(&mut a, b);
    println!("{:#}", a);
}

This algorithm is not correct since it does not delete keys whose value is null in the patch. `v.is_null()` needs to be checked before the recursive call to `merge` — Arnavion, Jan 09 '19 at 00:19

score 1 · Answer 3 · answered Nov 03 '17 at 19:26

1

This worked for me

#[macro_use]
extern crate serde_json;

use serde_json::Value;

fn merge(a: &mut Value, b: &Value) {
    match (a, b) {
        (&mut Value::Object(ref mut a), &Value::Object(ref b)) => {
            for (k, v) in b {
                merge(a.entry(k.clone()).or_insert(Value::Null), v);
            }
        }
        (a, b) => {
            *a = b.clone();
        }
    }
}

fn main() {
    let mut a = json!({
        "title": "This is a title",
        "person" : {
            "firstName" : "John",
            "lastName" : "Doe"
        },
        "cities":[ "london", "paris" ]
    });

    let b = json!({
        "title": "This is another title",
        "person" : {
            "firstName" : "Jane"
        },
        "cities":[ "colombo" ]
    });

    merge(&mut a, &b);
    println!("{:#}", a);
}

answered Nov 03 '17 at 19:26

Harindaka

4,658
8
43
62

1

Seems like if you changed to `fn merge(a: Value, b: Value) -> Value` you could avoid the cloning. – Shepmaster Nov 03 '17 at 19:33
@Shepmaster Could you add an answer here incorporating your suggestion above? I'm new to Rust and do not quite get what you are saying yet. I'll accept your answer if you do. – Harindaka Nov 05 '17 at 07:20
1

[Something like this](https://play.integer32.com/?gist=33b53122f260532bdea5a0f76a5da152&version=stable), although I'm a little sad that the `unwrap` is needed. – Shepmaster Nov 05 '17 at 14:11
Is there a way to take two immutable references and return a new json object? – Michael Pacheco Dec 30 '22 at 23:54

How can I merge two JSON objects with Rust?

3 Answers3

Linked