Cara menggunakan _id null mongodb

Question

Document didalam MongoDB dapat dianggap sebagai "JSON" karena secara konseptual mirip dengan object pada JavaScript. Perlu untuk diketahui bahwa JSON memiliki keterbatasan dalam hal dukungan tipe data yang diantaranya hanyalah: null, boolean, numeric, string, array, dan object.

Table of Contents Show

A.57.1. Persiapan
A.57.2. Insert Data
A.57.3. Membaca Data
A.57.5. Menghapus Data
A.57.6. Aggregate Data

Dalam hal ini, MongoDB tersedia dengan dukungan tambahan terhadap tipe data dengan tetap membawa sifat dasar dari JSON itu sendiri. Berikut ini daftar tipe data yang umum dalam merepresentasikan sebuah document dalam MongoDB yaitu:

null

Null dapat digunakan untuk merepresentasikan sebuah nilai null dan nonexistent field:

{"x" : null}

boolean

Tipe data boolean dapat digunakan nilai dengan kondisi true dan false:

{"x" : true}

number

Dalam shell MongoDB secara default menggunakan 64-bit floating point numbers. Jadi, nomor berikut ini akan terlihat

normal dalam shell:

{"x" : 3.14} OR {"x" : 3}

Untuk Integer, bisa menggunakan class numberInt() atau numberLong():

{"x" : NumberInt("3")}
{"x" : NumberLong("3")}

String

Untuk setiap yang dari karakter UTF-8 bisa direpresentasikan dengan tipe string:

{"x" : "foobar"}

Date

Tipe data date disimpan sebagai milliseconds since the epoch (saya tidak tahu arti yang tepat dalam bahasa indonesia),
dan time zone sendiri tidak tersimpan:

{"x" : new Date()}

regular expression

Mungkin bisa dibilang tipe data ini menarik karena menggunakan sintak regular expression JavaScript dan tentunya
berfungsi dengan baik:

{"x" : /foobar/i}

array

Membuat field yang mengandung daftar atau kumpulan suatu nilai bisa menggunakan tipe data array:

{"x" : ["a", "b", "c"]}

embedded document

Document dapat juga mengandung nilai yang berupa documents dan tipe data dari embedded document itu
akan menyesuaikan:

{"x" : {"foo" : "bar"}}

object id

Sebelumnya kita tahu pada part sebelumnya saat proses insert secara otomatis field _id akan muncul dengan tipe data
object id. Object id sendiri ialah sebuah 12-byte ID untuk document (detailnya akan saya jelaskan pada part berikutnya):

{"x" : ObjectId()}

code

Query dan document dalam MongoDB juga dapat memuat nilai arbitrary JavaScript code:

{"x" : function() { /* ... */ }}

Itulah penjelasan mengenai tipe data yang umum ditemukan dalam penggunaan database MongoDB. Mungkin penjelasan diatas belum begitu detail, jadi jika ada yang ingin ditanyakan bisa langsung mengisi kolom komentar dibawah, dan jangan lupa terus kunjungi blog saya untuk part selanjutnya.

Go tidak menyediakan interface generic untuk NoSQL, jadi implementasi driver tiap brand NoSQL di Go biasanya berbeda satu dengan lainnya.

Pada chapter ini kita akan belajar cara berkomunikasi dengan NoSQL MongoDB server menggunakan official driver untuk go, yaitu mongo-go-driver.

A.57.1. Persiapan

Ada beberapa hal yang perlu disiapkan sebelum mulai masuk ke bagian coding.

Instal mongo-go-driver menggunakan

package main

import (
    "context"
    "fmt"
    "log"
    "time"

    "go.mongodb.org/mongo-driver/mongo"
    "go.mongodb.org/mongo-driver/mongo/options"
    "go.mongodb.org/mongo-driver/bson"
)

0.

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

Pastikan sudah terinstal MongoDB di komputer anda, dan jangan lupa untuk menjalankan daemon-nya. Jika belum, download dan install terlebih dahulu.
Instal juga MongoDB GUI untuk mempermudah browsing data. Bisa menggunakan MongoChef, Robomongo, atau lainnya.

A.57.2. Insert Data

Cara insert data ke mongodb via Go tidak terlalu sulit. Kita akan mempelajarinya dengan cara praktek langsung. Pertama-tama silakan import package yang dibutuhkan.

package main

import (
    "context"
    "fmt"
    "log"
    "time"

    "go.mongodb.org/mongo-driver/mongo"
    "go.mongodb.org/mongo-driver/mongo/options"
    "go.mongodb.org/mongo-driver/bson"
)

Siapkan satu object context dan struct

package main

import (
    "context"
    "fmt"
    "log"
    "time"

    "go.mongodb.org/mongo-driver/mongo"
    "go.mongodb.org/mongo-driver/mongo/options"
    "go.mongodb.org/mongo-driver/bson"
)

1. Rencananya satu buah document kita buat sebagai satu buah objek

package main

import (
    "context"
    "fmt"
    "log"
    "time"

    "go.mongodb.org/mongo-driver/mongo"
    "go.mongodb.org/mongo-driver/mongo/options"
    "go.mongodb.org/mongo-driver/bson"
)

1.

Perlu diketahui bahwa pada chapter ini tidak dijelaskan tentang apa itu context. Silakan merujuk ke D.2. Google API Search Dengan Timeout untuk mempelajarinya. Menggunakan satu context background untuk semua operasi sangat tidak dianjurkan, tapi pada chapter ini kita terapkan demikian agar tidak menambah kebingungan pembaca yang masih proses belajar. Context sendiri fungsinya sangat banyak, untuk kasus sejenis biasanya digunakan untuk handle operation timeout atau lainnya.

var ctx = context.Background()

type student struct {
    Name  string `bson:"name"`
    Grade int    `bson:"Grade"`
}

Tag

package main

import (
    "context"
    "fmt"
    "log"
    "time"

    "go.mongodb.org/mongo-driver/mongo"
    "go.mongodb.org/mongo-driver/mongo/options"
    "go.mongodb.org/mongo-driver/bson"
)

3 pada property struct digunakan sebagai penentu nama field ketika data disimpan ke dalam collection. Jika sebuah property tidak memiliki tag bson, secara default nama field adalah sama dengan nama property hanya saja lowercase. Untuk customize nama field, gunakan tag

package main

import (
    "context"
    "fmt"
    "log"
    "time"

    "go.mongodb.org/mongo-driver/mongo"
    "go.mongodb.org/mongo-driver/mongo/options"
    "go.mongodb.org/mongo-driver/bson"
)

3.

Pada contoh di atas, property

package main

import (
    "context"
    "fmt"
    "log"
    "time"

    "go.mongodb.org/mongo-driver/mongo"
    "go.mongodb.org/mongo-driver/mongo/options"
    "go.mongodb.org/mongo-driver/bson"
)

5 ditentukan nama field mongo-nya sebagai

package main

import (
    "context"
    "fmt"
    "log"
    "time"

    "go.mongodb.org/mongo-driver/mongo"
    "go.mongodb.org/mongo-driver/mongo/options"
    "go.mongodb.org/mongo-driver/bson"
)

6, dan

package main

import (
    "context"
    "fmt"
    "log"
    "time"

    "go.mongodb.org/mongo-driver/mongo"
    "go.mongodb.org/mongo-driver/mongo/options"
    "go.mongodb.org/mongo-driver/bson"
)

7 sebagai

package main

import (
    "context"
    "fmt"
    "log"
    "time"

    "go.mongodb.org/mongo-driver/mongo"
    "go.mongodb.org/mongo-driver/mongo/options"
    "go.mongodb.org/mongo-driver/bson"
)

7.

Selanjutnya siapkan fungsi untuk membuat satu buah mongo connection. Dari objek connection diambil object database, kemudian dijadikan sebagai nilai balik fungsi.

func connect() (*mongo.Database, error) {
    clientOptions := options.Client()
    clientOptions.ApplyURI("mongodb://localhost:27017")
    client, err := mongo.NewClient(clientOptions)
    if err != nil {
        return nil, err
    }

    err = client.Connect(ctx)
    if err != nil {
        return nil, err
    }

    return client.Database("belajar_golang"), nil
}

Fungsi

package main

import (
    "context"
    "fmt"
    "log"
    "time"

    "go.mongodb.org/mongo-driver/mongo"
    "go.mongodb.org/mongo-driver/mongo/options"
    "go.mongodb.org/mongo-driver/bson"
)

9 digunakan untuk meng-inisialisasi koneksi database dari client ke server. Fungsi tersebut memerlukan parameter bertipe

var ctx = context.Background()

type student struct {
    Name  string `bson:"name"`
    Grade int    `bson:"Grade"`
}

0. Pada client options mongo connection string perlu di set (lewat method

var ctx = context.Background()

type student struct {
    Name  string `bson:"name"`
    Grade int    `bson:"Grade"`
}

1).

Silakan sesuaikan connection string dengan mongo db server yang dipergunakan. Lebih jelasnya silakan merujuk ke MongoDB Documentation: Connection String URI Format.

Dari object client, panggil method

var ctx = context.Background()

type student struct {
    Name  string `bson:"name"`
    Grade int    `bson:"Grade"`
}

2 untuk inisialisasi koneksi ke db server. Setelah itu panggil method

var ctx = context.Background()

type student struct {
    Name  string `bson:"name"`
    Grade int    `bson:"Grade"`
}

3 untuk set database yang aktif.

Lanjut buat fungsi yang di dalamnya berisikan kode untuk insert data ke mongodb, lalu panggil fungsi tersebut di

var ctx = context.Background()

type student struct {
    Name  string `bson:"name"`
    Grade int    `bson:"Grade"`
}

4.

func insert() {
    db, err := connect()
    if err != nil {
        log.Fatal(err.Error())
    }

    _, err = db.Collection("student").InsertOne(ctx, student{"Wick", 2})
    if err != nil {
        log.Fatal(err.Error())
    }

    _, err = db.Collection("student").InsertOne(ctx, student{"Ethan", 2})
    if err != nil {
        log.Fatal(err.Error())
    }

    fmt.Println("Insert success!")
}

func main() {
    insert()
}

Fungsi

var ctx = context.Background()

type student struct {
    Name  string `bson:"name"`
    Grade int    `bson:"Grade"`
}

5 mengembalikan objek bertipe

var ctx = context.Background()

type student struct {
    Name  string `bson:"name"`
    Grade int    `bson:"Grade"`
}

6. Dari objek tersebut akses method

var ctx = context.Background()

type student struct {
    Name  string `bson:"name"`
    Grade int    `bson:"Grade"`
}

7 lalu chain dengan method lainnya untuk melakukan operasi database, kurang lebih skema statement-nya sama seperti operasi mongodb.

Sebagai contoh, pada kode di atas

var ctx = context.Background()

type student struct {
    Name  string `bson:"name"`
    Grade int    `bson:"Grade"`
}

8 digunakan untuk insert satu data ke database. Perbandingannya kurang lebih seperti berikut:

Perlu diketahui, bahwa di mongo-go-driver setiap operasi biasanya membutuhkan objek context untuk disisipkan sebagai parameter pertama. Pada contoh di atas kita gunakan variabel

var ctx = context.Background()

type student struct {
    Name  string `bson:"name"`
    Grade int    `bson:"Grade"`
}

9 yang sudah dideklarasikan sebelumnya.

A.57.3. Membaca Data

Method

func connect() (*mongo.Database, error) {
    clientOptions := options.Client()
    clientOptions.ApplyURI("mongodb://localhost:27017")
    client, err := mongo.NewClient(clientOptions)
    if err != nil {
        return nil, err
    }

    err = client.Connect(ctx)
    if err != nil {
        return nil, err
    }

    return client.Database("belajar_golang"), nil
}

0 digunakan untuk membaca atau mencari data. Method ini mengembalikan objek cursor, objek ini harus digunakan dalam perulangan untuk mengambil data yang ditemukan.

Dalam pencarian, sisipkan query atau filter sebagai parameter ke-dua method

func connect() (*mongo.Database, error) {
    clientOptions := options.Client()
    clientOptions.ApplyURI("mongodb://localhost:27017")
    client, err := mongo.NewClient(clientOptions)
    if err != nil {
        return nil, err
    }

    err = client.Connect(ctx)
    if err != nil {
        return nil, err
    }

    return client.Database("belajar_golang"), nil
}

0.

func find() {
    db, err := connect()
    if err != nil {
        log.Fatal(err.Error())
    }

    csr, err := db.Collection("student").Find(ctx, bson.M{"name": "Wick"})
    if err != nil {
        log.Fatal(err.Error())
    }
    defer csr.Close(ctx)

    result := make([]student, 0)
    for csr.Next(ctx) {
        var row student
        err := csr.Decode(&row)
        if err != nil {
            log.Fatal(err.Error())
        }

        result = append(result, row)
    }

    if len(result) > 0 {
        fmt.Println("Name  :", result[0].Name)
        fmt.Println("Grade :", result[0].Grade)
    }
}

func main() {
    find()
}

Query selector ditulis dalam tipe

func connect() (*mongo.Database, error) {
    clientOptions := options.Client()
    clientOptions.ApplyURI("mongodb://localhost:27017")
    client, err := mongo.NewClient(clientOptions)
    if err != nil {
        return nil, err
    }

    err = client.Connect(ctx)
    if err != nil {
        return nil, err
    }

    return client.Database("belajar_golang"), nil
}

2. Tipe ini sebenarnya adalah alias dari

func connect() (*mongo.Database, error) {
    clientOptions := options.Client()
    clientOptions.ApplyURI("mongodb://localhost:27017")
    client, err := mongo.NewClient(clientOptions)
    if err != nil {
        return nil, err
    }

    err = client.Connect(ctx)
    if err != nil {
        return nil, err
    }

    return client.Database("belajar_golang"), nil
}

3.

Cara untuk mendapatkan semua rows hasil pencarian kursor adalah dengan mengiterasi method

func connect() (*mongo.Database, error) {
    clientOptions := options.Client()
    clientOptions.ApplyURI("mongodb://localhost:27017")
    client, err := mongo.NewClient(clientOptions)
    if err != nil {
        return nil, err
    }

    err = client.Connect(ctx)
    if err != nil {
        return nil, err
    }

    return client.Database("belajar_golang"), nil
}

4 dengan di dalamnya method

func connect() (*mongo.Database, error) {
    clientOptions := options.Client()
    clientOptions.ApplyURI("mongodb://localhost:27017")
    client, err := mongo.NewClient(clientOptions)
    if err != nil {
        return nil, err
    }

    err = client.Connect(ctx)
    if err != nil {
        return nil, err
    }

    return client.Database("belajar_golang"), nil
}

5 dipanggil untuk retrieve datanya. Setelah itu data yang sudah terampil di-append ke slice.

Selain method

func connect() (*mongo.Database, error) {
    clientOptions := options.Client()
    clientOptions.ApplyURI("mongodb://localhost:27017")
    client, err := mongo.NewClient(clientOptions)
    if err != nil {
        return nil, err
    }

    err = client.Connect(ctx)
    if err != nil {
        return nil, err
    }

    return client.Database("belajar_golang"), nil
}

0 ada juga

func connect() (*mongo.Database, error) {
    clientOptions := options.Client()
    clientOptions.ApplyURI("mongodb://localhost:27017")
    client, err := mongo.NewClient(clientOptions)
    if err != nil {
        return nil, err
    }

    err = client.Connect(ctx)
    if err != nil {
        return nil, err
    }

    return client.Database("belajar_golang"), nil
}

7, silakan cek dokumentasi lebih jelasnya.

Berikut adalah skema perbandingan contoh operasi get data menggunakan mongo query vs mongo-go-driver:

Method

func connect() (*mongo.Database, error) {
    clientOptions := options.Client()
    clientOptions.ApplyURI("mongodb://localhost:27017")
    client, err := mongo.NewClient(clientOptions)
    if err != nil {
        return nil, err
    }

    err = client.Connect(ctx)
    if err != nil {
        return nil, err
    }

    return client.Database("belajar_golang"), nil
}

8 digunakan untuk update data (jika update hanya diinginkan untuk berlaku pada 1 dokumen saja, maka gunakan

func connect() (*mongo.Database, error) {
    clientOptions := options.Client()
    clientOptions.ApplyURI("mongodb://localhost:27017")
    client, err := mongo.NewClient(clientOptions)
    if err != nil {
        return nil, err
    }

    err = client.Connect(ctx)
    if err != nil {
        return nil, err
    }

    return client.Database("belajar_golang"), nil
}

9). Method

func connect() (*mongo.Database, error) {
    clientOptions := options.Client()
    clientOptions.ApplyURI("mongodb://localhost:27017")
    client, err := mongo.NewClient(clientOptions)
    if err != nil {
        return nil, err
    }

    err = client.Connect(ctx)
    if err != nil {
        return nil, err
    }

    return client.Database("belajar_golang"), nil
}

8 memerlukan 3 buah parameter dalam pemanggilannya.

Parameter pertama, objek context
Parameter kedua adalah query kondisi yang mengacu ke data mana yang ingin di update
Parameter ketiga adalah perubahan datanya.

Di bawah ini adalah contok implementasi method

func insert() {
    db, err := connect()
    if err != nil {
        log.Fatal(err.Error())
    }

    _, err = db.Collection("student").InsertOne(ctx, student{"Wick", 2})
    if err != nil {
        log.Fatal(err.Error())
    }

    _, err = db.Collection("student").InsertOne(ctx, student{"Ethan", 2})
    if err != nil {
        log.Fatal(err.Error())
    }

    fmt.Println("Insert success!")
}

func main() {
    insert()
}

1.

func update() {
    db, err := connect()
    if err != nil {
        log.Fatal(err.Error())
    }

    var selector = bson.M{"name": "Wick"}
    var changes = student{"John Wick", 2}
    _, err = db.Collection("student").UpdateOne(ctx, selector, bson.M{"$set": changes})
    if err != nil {
        log.Fatal(err.Error())
    }

    fmt.Println("Update success!")
}

func main() {
    update()
}

Jalankan kode di atas, lalu cek lewat Mongo GUI apakah data berubah.

Berikut adalah skema perbandingan query vs mongo-go-driver dari operasi di atas.

Selain method

func connect() (*mongo.Database, error) {
    clientOptions := options.Client()
    clientOptions.ApplyURI("mongodb://localhost:27017")
    client, err := mongo.NewClient(clientOptions)
    if err != nil {
        return nil, err
    }

    err = client.Connect(ctx)
    if err != nil {
        return nil, err
    }

    return client.Database("belajar_golang"), nil
}

9 ada juga method

func insert() {
    db, err := connect()
    if err != nil {
        log.Fatal(err.Error())
    }

    _, err = db.Collection("student").InsertOne(ctx, student{"Wick", 2})
    if err != nil {
        log.Fatal(err.Error())
    }

    _, err = db.Collection("student").InsertOne(ctx, student{"Ethan", 2})
    if err != nil {
        log.Fatal(err.Error())
    }

    fmt.Println("Insert success!")
}

func main() {
    insert()
}

3, kegunaan masing-masing bisa dilihat dari nama fungsinya.

A.57.5. Menghapus Data

Untuk menghapus data gunakan method

func insert() {
    db, err := connect()
    if err != nil {
        log.Fatal(err.Error())
    }

    _, err = db.Collection("student").InsertOne(ctx, student{"Wick", 2})
    if err != nil {
        log.Fatal(err.Error())
    }

    _, err = db.Collection("student").InsertOne(ctx, student{"Ethan", 2})
    if err != nil {
        log.Fatal(err.Error())
    }

    fmt.Println("Insert success!")
}

func main() {
    insert()
}

4 atau

func insert() {
    db, err := connect()
    if err != nil {
        log.Fatal(err.Error())
    }

    _, err = db.Collection("student").InsertOne(ctx, student{"Wick", 2})
    if err != nil {
        log.Fatal(err.Error())
    }

    _, err = db.Collection("student").InsertOne(ctx, student{"Ethan", 2})
    if err != nil {
        log.Fatal(err.Error())
    }

    fmt.Println("Insert success!")
}

func main() {
    insert()
}

5.

func remove() {
    db, err := connect()
    if err != nil {
        log.Fatal(err.Error())
    }

    var selector = bson.M{"name": "John Wick"}
    _, err = db.Collection("student").DeleteOne(ctx, selector)
    if err != nil {
        log.Fatal(err.Error())
    }

    fmt.Println("Remove success!")
}

func main() {
    remove()
}

Hasil dari kode di atas, 2 data yang sebelumnya sudah di-insert kini tinggal satu saja.

Berikut adalah skema perbandingan query vs mongo-go-driver dari operasi di atas.

A.57.6. Aggregate Data

Agregasi data menggunakan driver ini juga cukup mudah, caranya tinggal gunakan method

func insert() {
    db, err := connect()
    if err != nil {
        log.Fatal(err.Error())
    }

    _, err = db.Collection("student").InsertOne(ctx, student{"Wick", 2})
    if err != nil {
        log.Fatal(err.Error())
    }

    _, err = db.Collection("student").InsertOne(ctx, student{"Ethan", 2})
    if err != nil {
        log.Fatal(err.Error())
    }

    fmt.Println("Insert success!")
}

func main() {
    insert()
}

6 dan sisipkan pipeline query sebagai argument ke-2 pemanggilan method. Eksekusi method tersebut mengembalikan objek cursor. Selebihnya capture result dengan cara yang sama seperti capture cursor operasi

func connect() (*mongo.Database, error) {
    clientOptions := options.Client()
    clientOptions.ApplyURI("mongodb://localhost:27017")
    client, err := mongo.NewClient(clientOptions)
    if err != nil {
        return nil, err
    }

    err = client.Connect(ctx)
    if err != nil {
        return nil, err
    }

    return client.Database("belajar_golang"), nil
}

0.

Pipeline sendiri bisa dituliskan langsung dalam

func insert() {
    db, err := connect()
    if err != nil {
        log.Fatal(err.Error())
    }

    _, err = db.Collection("student").InsertOne(ctx, student{"Wick", 2})
    if err != nil {
        log.Fatal(err.Error())
    }

    _, err = db.Collection("student").InsertOne(ctx, student{"Ethan", 2})
    if err != nil {
        log.Fatal(err.Error())
    }

    fmt.Println("Insert success!")
}

func main() {
    insert()
}

8, atau bisa tulis dalam bentuk string dan unmarshal ke

func insert() {
    db, err := connect()
    if err != nil {
        log.Fatal(err.Error())
    }

    _, err = db.Collection("student").InsertOne(ctx, student{"Wick", 2})
    if err != nil {
        log.Fatal(err.Error())
    }

    _, err = db.Collection("student").InsertOne(ctx, student{"Ethan", 2})
    if err != nil {
        log.Fatal(err.Error())
    }

    fmt.Println("Insert success!")
}

func main() {
    insert()
}

8.

kode mongodb