Merge two or more []map[string]interface{} types into one in Golang

I'm using Golang and for some reason, I need to merge results from different database queries, all of which return me a []map[string]interface{}
I'm thinking of Append but its just not clear enough if this is even possible.
What is the final datatype I'm looking at?

Clearly, an array of maps of interfaces with keys as strings should be able to simply 'attach' (concat, if you may) to another array of maps of interfaces with keys as strings!

So what is the mechanism to achieve this?

Even the answer is already given in the comments above i will post a short example how this can be achieved.

package main

import (
	"fmt"
)

func main() {
	result := []map[string]interface{}{}
	
	mp1 := map[string]interface{}{
		"one" : 1, 
		"two" : 2,
	}
	
	mp2 := map[string]interface{}{
		"three" : 3,
		"four" : 4,
	}
	
	mp3 := make(map[string]interface{})
	for k, v := range mp1 {
		if _, ok := mp1[k]; ok {
			mp3[k] = v			
		}
	}
	
	for k, v := range mp2 {
		if _, ok := mp2[k]; ok {
			mp3[k] = v
		}
	}

	result = append(result, mp1, mp2)
	fmt.Println(result)
}

The output will be:

[map[one:1 two:2] map[three:3 four:4]]

Playground example

The other answer is correct. You could also write a helper function to avoid repetitive map merges.

// overwriting duplicate keys, you should handle that if there is a need
func mergeMaps(maps ...map[string]interface{}) map[string]interface{} {
	result := make(map[string]interface{})
	for _, m := range maps {
		for k, v := range m {
			result[k] = v
		}
	}
	return result
}

func main() {
	log.Println(`started`)

	v := []map[string]interface{}{
		map[string]interface{}{
			`one`: 1,
			`two`: 2,
		},
		map[string]interface{}{
			`one`:   `I`,
			`three`: 3,
			`other`: `NAN`,
		},
		map[string]interface{}{
			`name`: `Bob`,
			`age`:  300,
		},
	}

	m := mergeMaps(v...)
	log.Println(m, len(m))
}

The above solutions suggested by Endre and Kaveh both works, but it is much simpler, handy, and more optimized to use mergo when one wants to merge Go structs and maps which covers vast scenarios apart from merging map[string]interface{}

package main

import (
    "fmt"
    "github.com/imdario/mergo"
)

func main() {
    mp1 := map[string]interface{}{
        "one" : 1, 
        "two" : 2,
    }

    mp2 := map[string]interface{}{
        "three" : 3,
        "four" : 4,
    }

    mergo.Merge(&mp1, mp2) //mergo.Merge(&dest,src)
   
    fmt.Println(mp1)
}

Output:

map[four:4 one:1 three:3 two:2]

P.S. - In Golang there is no order-preserving. Actually, iterating a map in Go is always in random order. So don't rely on a map's keys order.