Transações ACID multidocumento no MongoDB com Go

1
type Episode struct {
2
    ID          primitive.ObjectID `bson:"_id,omitempty"`
3
    Podcast     primitive.ObjectID `bson:"podcast,omitempty"`
4
    Title       string             `bson:"title,omitempty"`
5
    Description string             `bson:"description,omitempty"`
6
    Duration    int32              `bson:"duration,omitempty"`
7
}

1
{
2
    "$jsonSchema": {
3
        "additionalProperties": true,
4
        "properties": {
5
            "duration": {
6
                "bsonType": "int",
7
                "minimum": 2
8
            }
9
        }
10
    }
11
}

1
package main
2
3
import (
4
    "context"
5
    "fmt"
6
    "os"
7
8
    "go.mongodb.org/mongo-driver/bson/primitive"
9
    "go.mongodb.org/mongo-driver/mongo"
10
    "go.mongodb.org/mongo-driver/mongo/options"
11
)
12
13
// Episode represents the schema for the "Episodes" collection
14
type Episode struct {
15
    ID          primitive.ObjectID `bson:"_id,omitempty"`
16
    Podcast     primitive.ObjectID `bson:"podcast,omitempty"`
17
    Title       string             `bson:"title,omitempty"`
18
    Description string             `bson:"description,omitempty"`
19
    Duration    int32              `bson:"duration,omitempty"`
20
}
21
22
func main() {
23
    client, err := mongo.Connect(context.TODO(), options.Client().ApplyURI(os.Getenv("ATLAS_URI")))
24
    if err != nil {
25
        panic(err)
26
    }
27
    defer client.Disconnect(context.TODO())
28
29
    database := client.Database("quickstart")
30
    episodesCollection := database.Collection("episodes")
31
32
    database.RunCommand(context.TODO(), bson.D{{"create", "episodes"}})
33
}

1
// ...
2
3
func main() {
4
    // ...
5
6
    wc := writeconcern.New(writeconcern.WMajority())
7
    rc := readconcern.Snapshot()
8
    txnOpts := options.Transaction().SetWriteConcern(wc).SetReadConcern(rc)
9
10
    session, err := client.StartSession()
11
    if err != nil {
12
        panic(err)
13
    }
14
    defer session.EndSession(context.Background())
15
16
    err = mongo.WithSession(context.Background(), session, func(sessionContext mongo.SessionContext) error {
17
        if err = session.StartTransaction(txnOpts); err != nil {
18
            return err
19
        }
20
        result, err := episodesCollection.InsertOne(
21
            sessionContext,
22
            Episode{
23
                Title:    "A Transaction Episode for the Ages",
24
                Duration: 15,
25
            },
26
        )
27
        if err != nil {
28
            return err
29
        }
30
        fmt.Println(result.InsertedID)
31
        result, err = episodesCollection.InsertOne(
32
            sessionContext,
33
            Episode{
34
                Title:    "Transactions for All",
35
                Duration: 1,
36
            },
37
        )
38
        if err != nil {
39
            return err
40
        }
41
        if err = session.CommitTransaction(sessionContext); err != nil {
42
            return err
43
        }
44
        fmt.Println(result.InsertedID)
45
        return nil
46
    })
47
    if err != nil {
48
        if abortErr := session.AbortTransaction(context.Background()); abortErr != nil {
49
            panic(abortErr)
50
        }
51
        panic(err)
52
    }
53
}

1
// ...
2
3
func main() {
4
    // ...
5
6
    wc := writeconcern.New(writeconcern.WMajority())
7
    rc := readconcern.Snapshot()
8
    txnOpts := options.Transaction().SetWriteConcern(wc).SetReadConcern(rc)
9
10
    session, err := client.StartSession()
11
    if err != nil {
12
        panic(err)
13
    }
14
    defer session.EndSession(context.Background())
15
16
    callback := func(sessionContext mongo.SessionContext) (interface{}, error) {
17
        result, err := episodesCollection.InsertOne(
18
            sessionContext,
19
            Episode{
20
                Title:    "A Transaction Episode for the Ages",
21
                Duration: 15,
22
            },
23
        )
24
        if err != nil {
25
            return nil, err
26
        }
27
        result, err = episodesCollection.InsertOne(
28
            sessionContext,
29
            Episode{
30
                Title:    "Transactions for All",
31
                Duration: 2,
32
            },
33
        )
34
        if err != nil {
35
            return nil, err
36
        }
37
        return result, err
38
    }
39
40
    _, err = session.WithTransaction(context.Background(), callback, txnOpts)
41
    if err != nil {
42
        panic(err)
43
    }
44
}