Effecient way to find if a key from a list of maps exists within another list of maps

I have two lists of maps. We'll call them A, which exists within a database, and B, which is live results from a sensor.

A shares Key/Values From B

Example looks like:

A = [
    {
        "created_at": "2020-09-19T17:25:29.547354",
        "id": 1,
        "ip_address": "192.168.1.1",
        "mac_address": "xx:xx:xx:xx:xx:xx",
    },
    {
        "created_at": "2020-09-19T17:25:29.564472",
        "id": 2,
        "ip_address": "192.168.1.2",
        "mac_address": "xx:xx:xx:xx:xx:xx",
    },
    {
        "created_at": "2020-09-19T17:25:29.564472",
        "id": 3,
        "ip_address": "192.168.1.3",
        "mac_address": "xx:xx:xx:xx:xx:xx",
    }
]

B = [
    {
        'mac_address': 'xx:xx:xx:xx:xx:xx',
        'ip_address': '192.168.1.1',
        'status': True
    },
    {
        'mac_address': 'xx:xx:xx:xx:xx:xx',
        'ip_address': '192.168.1.2',
        'status': True
    }
]

What's the best way way to find out any missing maps from B compared to A by the Value ip_address.

For example, we can tell by looking at the above that the map which contains the ip_address "192.168.1.3" doesn't exist within B. The aim is to try and find a list of values which don't exist between the two, if any.

The expected output is a list like: ["192.168.1.3"]

I come up with semi efficient solution:

package main
import (
"fmt"
)
func main() {
a := []map[string]interface{}{
{
"created_at":  "2020-09-19T17:25:29.547354",
"id":          1,
"ip_address":  "192.168.1.1",
"mac_address": "xx:xx:xx:xx:xx:xx",
},
{
"created_at":  "2020-09-19T17:25:29.564472",
"id":          2,
"ip_address":  "192.168.1.2",
"mac_address": "xx:xx:xx:xx:xx:xx",
},
{
"created_at":  "2020-09-19T17:25:29.564472",
"id":          3,
"ip_address":  "192.168.1.3",
"mac_address": "xx:xx:xx:xx:xx:xx",
},
}
b := []map[string]interface{}{
{
"mac_address": "xx:xx:xx:xx:xx:xx",
"ip_address":  "192.168.1.1",
"status":      true,
},
{
"mac_address": "xx:xx:xx:xx:xx:xx",
"ip_address":  "192.168.1.2",
"status":      true,
},
}
c, d := collectIpAddresses(a), collectIpAddresses(b)
var missing []string
for k := range c {
if !d[k] {
missing = append(missing, k)
}
}
for k := range d {
if !c[k] {
missing = append(missing, k)
}
}
fmt.Println(missing)
}
// stores data in more efficient data-structure for searching
func collectIpAddresses(a []map[string]interface{}) map[string]bool {
b := make(map[string]bool, len(a))
for _, v := range a {
b[v["ip_address"].(string)] = true
}
return b
}

This is a good solution because it provides O(m+n) complexity (where m is len(a) and n is len(b)).

In contrary, that solution which uses a loop within a loop will have a complexity of O(m*n). That complexity will dramatically reduce the performance of the algorithm on larger datasets.

Although, because allocating is extremely slow, on a dataset as provided by OP, the last solution will provide better results. This might be a catch depending the size of the dataset to iterate.