MongoDB

MongoDB adalah basis data dokumen, di mana unit data dasarnya adalah dokumen, dengan format penyimpanan BSON (Binary JSON), sebuah struktur yang mirip dengan JSON. Struktur yang longgar ini memungkinkan penyimpanan berbagai jenis data, yang lebih fleksibel dibandingkan dengan basis data relasional, dan menggunakan js sebagai bahasa skrip, memungkinkan operasi gabungan melalui skrip. Artikel ini terutama memperkenalkan penggunaan driver resmi mongo untuk mengoperasikan basis data mongodb dalam Go, bukan tutorial mongodb. Jika Anda tidak memiliki dasar mongodb, silakan pelajari terlebih dahulu.

Dokumentasi mongodb: Introduction to MongoDB — MongoDB Manual

Driver

Pustaka untuk mongodb dalam Go relatif sedikit. Beberapa pustaka yang dikelola komunitas sebelumnya telah berhenti pemeliharaannya, namun driver resmi mongo sudah cukup untuk digunakan.

Repositori sumber terbuka: mongodb/mongo-go-driver: The Official Golang driver for MongoDB (github.com)

Alamat dokumentasi: mongodb/mongo-go-driver: The Official Golang driver for MongoDB (github.com)

Instalasi

Untuk mengunduh dependensi, gunakan alamat berikut.

$ go get go.mongodb.org/mongo-driver/mongo

Koneksi

Berikut adalah contoh sederhana tentang bagaimana klien mongo membuat koneksi dengan server.

package main

import (
   "context"
   "fmt"
   "go.mongodb.org/mongo-driver/mongo"
   "go.mongodb.org/mongo-driver/mongo/options"
   "go.mongodb.org/mongo-driver/mongo/readpref"
   "log"
)

func main() {
   ctx := context.Background()
   // Membuat koneksi menggunakan URI
   client, err := mongo.Connect(ctx, options.Client().ApplyURI("mongodb://admin:123456@192.168.48.138:27017/"))
   if err != nil {
      log.Panicln(err)
   }
   // Menutup koneksi
   defer client.Disconnect(ctx)
   // Menguji koneksi dengan ping
   fmt.Println(client.Ping(ctx, readpref.Primary()))
}

bson

MongoDB menggunakan beberapa tipe berikut dalam Go untuk memetakan dokumen dalam basis data, yang terletak di bson/bson.go

// Representasi terurut dari dokumen BSON
type D = primitive.D

// Pasangan kunci-nilai, unit dasar representasi terurut dari dokumen BSON
type E = primitive.E

// Representasi tidak terurut dari dokumen BSON
type M = primitive.M

// Representasi terurut dari data BSON
type A = primitive.A

Tipe aktualnya adalah sebagai berikut

// Representasi terurut dari dokumen BSON
type D []E

// Pasangan kunci-nilai, unit dasar representasi terurut dari dokumen BSON
type E struct {
  Key   string
  Value interface{}
}

// Representasi tidak terurut dari dokumen BSON
type M map[string]interface{}

// Representasi terurut dari data BSON
type A []interface{}

Dengan beberapa tipe di atas, Anda dapat membuat query SQL atau memetakan data.

TIP

Direktori examples driver memiliki banyak contoh penggunaan.官方 telah mendemonstrasikan cara menggunakan keempat tipe tersebut dengan sangat detail.

Alamat: mongo-go-driver/examples/documentation_examples/examples.go at master · mongodb/mongo-go-driver (github.com)

Query Dokumen

Contoh query resmi: mongo-go-driver/examples/documentation_examples/examples.go at master · mongodb/mongo-go-driver (github.com)

Pertama, buat basis data user, dan sisipkan data berikut ke dalam koleksi users

> use user
> db.users.insertMany([
    {
        name: "mike",
        age: 12,

    },
    {
        name: "jenny",
        age: 14,

    },
    {
        name: "jack",
        age: 18,
        address: "usa"
    }
])

Query Tunggal

type User struct {
    Name    string `bson:"name"`
    Age     int    `bson:"age"`
    Address string `bson:"address"`
}

var user User

result := client.Database("user"). // Memilih basis data
                    Collection("users").                     // Memilih koleksi
                    FindOne(ctx, bson.D{{"address", "usa"}}) // Kondisi filter

// Deserialisasi
if err := result.Decode(&user); err != nil {
    log.Panicln(err)
}

fmt.Printf("%+v\n", user)

Kode query di atas setara dengan

db.users.findOne({
    address: "usa"
})

Output hasil

{Name:jack Age:18 Address:usa}

Query Banyak

type User struct {
   Name    string `bson:"name"`
   Age     int    `bson:"age"`
   Address string `bson:"address"`
}

var users []User

cursor, err := client.Database("user"). // Memilih basis data
               Collection("users"). // Memilih koleksi
               Find(ctx, bson.D{})  // Kondisi filter

if err != nil {
   log.Panicln(err)
}

if err := cursor.All(ctx, &users); err != nil {
   log.Panicln(err)
}

fmt.Printf("%+v\n", users)

Setara dengan

db.users.find({})

Output

[{Name:jack Age:18 Address:usa} {Name:mike Age:12 Address:} {Name:jenny Age:14 Address:}]

Saat membuat kondisi query, Anda juga dapat menggunakan options

type User struct {
    Name    string `bson:"name"`
    Age     int    `bson:"age"`
    Address string `bson:"address"`
}

var users []User

find := options.Find()
find.SetSort(bson.M{"age": 1})
find.SetLimit(1)

cursor, err := client.Database("user"). // Memilih basis data
                    Collection("users").      // Memilih koleksi
                    Find(ctx, bson.D{}, find) // Kondisi filter

if err != nil {
    log.Panicln(err)
}

if err := cursor.All(ctx, &users); err != nil {
    log.Panicln(err)
}

fmt.Printf("%+v\n", users)

Setara dengan

db.users.find({}).sort({age:1}).limit(1)

Output

[{Name:mike Age:12 Address:}]

Membuat Dokumen

Contoh pembuatan resmi: mongo-go-driver/examples/documentation_examples/examples.go at master · mongodb/mongo-go-driver (github.com)

Berikut adalah contoh membuat satu dokumen

one, err := client.Database("user").Collection("users").InsertOne(ctx, User{
    Name:    "lili",
    Age:     20,
    Address: "china",
})
if err != nil {
    log.Panicln(err)
}
fmt.Println(one.InsertedID)

Setelah berhasil dibuat, ObjectID dokumen akan dikembalikan

ObjectID("64c60fa01e2548d9e4de6cf4")

Berikut adalah contoh membuat banyak dokumen

users := []any{User{
    Name:    "john",
    Age:     10,
    Address: "usa",
}, User{
    Name:    "pop",
    Age:     30,
    Address: "uk",
}}

one, err := client.Database("user").Collection("users").InsertMany(ctx, users)
if err != nil {
    log.Panicln(err)
}
fmt.Println(one.InsertedIDs)

Setelah berhasil dibuat, sekumpulan ObjectID akan dikembalikan

[ObjectID("64c610d5aec2618d6ca0b515") ObjectID("64c610d5aec2618d6ca0b516")]

Dua kode di atas setara dengan db.users.insertOne dan db.users.insertMany.

Memperbarui Dokumen

Contoh pembaruan resmi: mongo-go-driver/examples/documentation_examples/examples.go at master · mongodb/mongo-go-driver (github.com)

Berikut adalah contoh memperbarui satu dokumen, mengubah nama lili menjadi mark

upres, err := client.Database("user").Collection("users").UpdateOne(ctx, bson.D{
    {"name", "mark"},
},
    bson.D{
       {"$set", bson.D{
          {"name", "lili"},
       }},
    })
if err != nil {
    log.Panicln(err)
}
fmt.Printf("%+v", upres)

Setara dengan

db.users.updateOne({
    name: "lili"
}, {
    $set: {
        name: "mark"
    },
})

Output

&{MatchedCount:1 ModifiedCount:1 UpsertedCount:0 UpsertedID:<nil>}

Berikut adalah contoh memperbarui banyak dokumen, mengubah alamat orang dengan usia 10 menjadi cn

upres, err := client.Database("user").Collection("users").UpdateMany(ctx, bson.D{
    {"age", 10},
},
    bson.D{
        {"$set", bson.D{
            {"address", "cn"},
        }},
    })
if err != nil {
    log.Panicln(err)
}
fmt.Printf("%+v", upres)

Selain menggunakan Update, mongo juga menyediakan Replace. Perbedaan keduanya adalah yang pertama memperbarui bidang dokumen, sedangkan yang terakhir mengganti dokumen secara langsung. Misalnya, kode berikut tidak memerlukan operator lagi.

upres, err := client.Database("user").Collection("users").ReplaceOne(ctx, bson.D{
    {"age", 10},
},
    bson.D{
       {"address", "cn"},
    })
if err != nil {
    log.Panicln(err)
}
fmt.Printf("%+v", upres)

Mongo juga menyediakan FindOneAndUpdate dan FindOneAndReplace untuk mendapatkan dan memperbarui dokumen. Seperti berikut

res := client.Database("user").Collection("users").FindOneAndReplace(ctx, bson.D{
    {"address", "cn"},
},
    bson.D{
       {"address", "uk"},
    })
if err := res.Err(); err != nil {
    log.Panicln(err)
}

var user User

res.Decode(&user)

fmt.Printf("%+v", user)

Output

Name: Age:0 Address:cn}

Operasi ini akan query dokumen terlebih dahulu, lalu memodifikasi dokumen.

Menghapus Dokumen

Contoh penghapusan resmi: mongo-go-driver/examples/documentation_examples/examples.go at master · mongodb/mongo-go-driver (github.com)

Berikut adalah contoh menghapus satu dokumen

result, err := client.Database("user").Collection("users").DeleteOne(ctx, bson.D{
    {"name", "jack"},
})
if err != nil {
    log.Panicln(err)
}
fmt.Println(result.DeletedCount)

Berikut adalah contoh menghapus banyak dokumen

result, err := client.Database("user").Collection("users").DeleteMany(ctx, bson.D{
    {"age", "10"},
})
if err != nil {
    log.Panicln(err)
}
fmt.Println(result.DeletedCount)

Agregasi

Contoh agregasi resmi: mongo-go-driver/examples/documentation_examples/examples.go at master · mongodb/mongo-go-driver (github.com)

Operasi agregasi menggunakan tipe mongo.Pipeline, yang pada dasarnya adalah []bson.D

type Pipeline []bson.D

pipline := mongo.Pipeline{
    {
       {"$match", bson.D{
          {"address", "uk"},
       }},
    },
    {
       {"$sort", bson.D{
          {"age", 1},
       }},
    },
}
aggregate, err := client.Database("user").Collection("users").Aggregate(ctx, pipline)
if err != nil {
    log.Panicln(err)
}
var users []User
if err := aggregate.All(ctx, &users); err != nil {
    log.Panicln(err)
}
log.Println(users)

Output

[{lili 20 uk} {kak 30 uk}]

Operasi agregasi ini mencocokkan semua pengguna dengan address uk, lalu mengurutkannya berdasarkan usia.