Cara menggunakan mongodb aggregate define variable

Sometimes your data source does not contain a field (or column) that you need for your analysis. For example, your data source might contain fields with values for Sales and Profit, but not for Profit Ratio. If this is the case, you can create a calculated field for Profit Ratio using data from the Sales and Profit fields.

This topic demonstrates how to create a simple calculated field using an example.

Step 1: Create the calculated field

1. In a worksheet in Tableau, select Analysis > Create Calculated Field.

2. In the Calculation Editor that opens, give the calculated field a name.

   In this example, the calculated field is called Profit Ratio.

Step 2: Enter a formula

1. In the Calculation Editor, enter a formula.

   This example uses the following formula:

   SUM([Profit])/SUM([Sales])

   Formulas use a combination of functions, fields, and operators. To learn more about creating formulas in Tableau, see Formatting Calculations in Tableau(Link opens in a new window) and Functions in Tableau(Link opens in a new window).

2. When finished, click OK.

   The new calculated field is added to the Data pane. If the new field computes quantitative data, it is added to Measures. If it computes qualitative data, it is added to Dimensions.

   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.

   1. 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
      

   2. Pastikan sudah terinstal MongoDB di komputer anda, dan jangan lupa untuk menjalankan daemon-nya. Jika belum, download dan install terlebih dahulu.

   3. 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.
   1. Parameter pertama, objek context
   2. Parameter kedua adalah query kondisi yang mengacu ke data mana yang ingin di update
   3. 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.