sudo apt-get install mongodb

# MongoDB示例
 
# 連接到MongoDB數(shù)據(jù)庫
from pymongo import MongoClient
client = MongoClient('mongodb://localhost:27017/')
 
# 獲取數(shù)據(jù)庫和集合對象
db = client['mydb']
collection = db['mycollection']
 
# 插入一條文檔
data = {'name': 'John', 'age': 25}
collection.insert_one(data)
 
# 查詢文檔
result = collection.find_one({'name': 'John'})
print(result)
 
# 關(guān)閉連接
client.close()

-- MySQL示例
 
-- 連接到MySQL數(shù)據(jù)庫
import mysql.connector
cnx = mysql.connector.connect(user='root', password='password', host='localhost', database='mydb')
 
-- 獲取游標(biāo)
cursor = cnx.cursor()
 
-- 插入一條記錄
sql = "INSERT INTO mytable (name, age) VALUES (%s, %s)"
values = ('John', 25)
cursor.execute(sql, values)
cnx.commit()
 
-- 查詢記錄
sql = "SELECT * FROM mytable WHERE name = 'John'"
cursor.execute(sql)
result = cursor.fetchone()
print(result)
 
-- 關(guān)閉連接
cursor.close()
cnx.close()

Usage:                                                                           
  goctl model mongo [flags]                                                      
                                                                                 
Flags:                                                                           
      --branch string   The branch of the remote repo, it does work with --remote
  -c, --cache           Generate code with cache [optional]                      
  -d, --dir string      The target dir
  -e, --easy            Generate code with auto generated CollectionName for easy declare [optional]
  -h, --help            help for mongo
      --home string     The goctl home path of the template, --home and --remote cannot be set at the same time, if they are, --remote has higher priority
      --remote string   The remote git repo of the template, --home and --remote cannot be set at the same time, if they are, --remote has higher priority
                        The git repo directory must be consistent with the https://github.com/zeromicro/go-zero-template directory structure
      --style string    The file naming format, see [https://github.com/zeromicro/go-zero/tree/master/tools/goctl/config/readme.md]
  -t, --type strings    Specified model type name

goctl model mongo -t User -dir model/user

# enter user home
$ cd ~
 
# make dir named demo 
$ mkdir demo && cd demo
 
# generate mongo code by goctl
$ goctl model mongo --type User --dir cache --cache
 
# view layout
$ tree
.
└── cache
    ├── error.go
    ├── usermodel.go
    ├── usermodelgen.go
    └── usertypes.go
 
1 directory, 4 files

package main
 
import (
	"context"
	"time"
 
	"github.com/globalsign/mgo/bson"
	"github.com/zeromicro/go-zero/core/stores/mon"
	"go.mongodb.org/mongo-driver/bson/primitive"
)
 
type Roster struct {
	Id          primitive.ObjectID `bson:"_id"`
	CreateTime  time.Time          `bson:"createTime"`
	DisplayName string             `bson:"displayName"`
}
 
func main() {
	model := mon.MustNewModel("mongodb://root:example@127.0.0.1:27017", "db", "user")
 
	r := &Roster{
		Id:          primitive.NewObjectID(),
		CreateTime:  time.Now(),
		DisplayName: "Hello",
	}
	ctx := context.Background()
	_, err := model.InsertOne(ctx, r)
	if err != nil {
		panic(err)
	}
 
	update := bson.M{"$set": bson.M{
		"displayName": "Hello world",
		"createTime":  time.Now(),
	}}
	_, err = model.UpdateByID(ctx, r.Id, update)
	if err != nil {
		panic(err)
	}
 
	r.DisplayName = "Hello world!"
	_, err = model.ReplaceOne(ctx, bson.M{"_id": r.Id}, r)
	if err != nil {
		panic(err)
	}
 
	var tr Roster
	err = model.FindOne(ctx, &tr, bson.M{"_id": r.Id})
	if err != nil {
		panic(err)
	}
}

package main
 
import (
    "context"
    "log"
 
    "go.mongodb.org/mongo-driver/bson"
    "go.mongodb.org/mongo-driver/mongo"
    "go.mongodb.org/mongo-driver/mongo/options"
)
 
func main() {
    clientOptions := options.Client().ApplyURI("mongodb://localhost:27017")
    client, err := mongo.Connect(context.Background(), clientOptions)
    if err != nil {
        log.Fatal(err)
    }
    defer client.Disconnect(context.Background())
 
    coll := client.Database("your_db_name").Collection("user")
 
    // 插入數(shù)據(jù)
    doc := &user.User{
        Id:    "1",
        Name:  "Alice",
        Email: "alice@example.com",
    }
    _, err = coll.InsertOne(context.TODO(), doc)
    if err != nil {
        log.Fatal(err)
    }
 
    // 查詢數(shù)據(jù)
    var result user.User
    err = coll.FindOne(context.TODO(), bson.M{"_id": "1"}).Decode(&result)
    if err != nil {
        log.Fatal(err)
    }
    log.Printf("Found user: %+v", result)
 
    // 更新數(shù)據(jù)
    updateResult, err := coll.UpdateOne(
        context.TODO(),
        bson.M{"_id": "1"},
        bson.D{{"$set", bson.D{{"email", "alice.updated@example.com"}}}},
    )
    if err != nil {
        log.Fatal(err)
    }
    log.Printf("Modified count: %v", updateResult.ModifiedCount)
 
    // 刪除數(shù)據(jù)
    deleteResult, err := coll.DeleteOne(context.TODO(), bson.M{"_id": "1"})
    if err != nil {
        log.Fatal(err)
    }
    log.Printf("Deleted count: %v", deleteResult.DeletedCount)
}

package main
 
import (
	"context"
	"fmt"
	"log"
  "time"
 
	//"go.mongodb.org/mongo-driver/bson/primitive"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
	"go.mongodb.org/mongo-driver/bson"
)
 
type User struct {
	Name  string `json:"name"`
	Email string `json:"email"`
  Age   int    `bson:"Agg"`
}
// ... 上面User結(jié)構(gòu)體定義 ...
 
func main() {
	// 連接MongoDB
	clientOptions := options.Client().ApplyURI("mongodb://test1:111111@localhost:27017/?tls=false&authSource=test1")
	client, err := mongo.Connect(context.Background(), clientOptions)
	if err != nil {
		log.Fatal(err)
	}
	defer func() {
		if err = client.Disconnect(context.Background()); err != nil {
			log.Fatal(err)
		}
	}()
 
	// 解析JSON字符串到User結(jié)構(gòu)體（假設(shè)已經(jīng)完成）
	user := User{Name: "Alice", Email: "alice@example.com",Age:22}
 
	// 選擇數(shù)據(jù)庫和集合
	collection := client.Database("test1").Collection("users")
 
	// 插入文檔
	insertResult, err := collection.InsertOne(context.TODO(), user)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println("Inserted ID:", insertResult.InsertedID)
 
	// 插入文檔
	doc := bson.D{{"name", "Alice1"}, {"age", 30}, {"createdAt", time.Now()}}
	insertResult, err = collection.InsertOne(context.TODO(), doc)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println("Inserted ID:", insertResult.InsertedID)
 
	// 更新文檔
	filter := bson.D{{"name", "Alice1"}}
	update := bson.D{{"$set", bson.D{{"age", 31}}}}
	updateResult, err := collection.UpdateOne(context.TODO(), filter, update)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println("Modified Count:", updateResult.ModifiedCount)
 
	// 刪除文檔
  filter = bson.D{{"age", 22}}
	deleteResult, err := collection.DeleteOne(context.TODO(), filter)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println("Deleted Count:", deleteResult.DeletedCount)
 
	// 查找單個文檔
	var singleResult bson.M
	err = collection.FindOne(context.TODO(), bson.D{}).Decode(&singleResult)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println("Single Document:", singleResult)
 
	// 查找所有文檔
	cursor, err := collection.Find(context.TODO(), bson.D{})
	if err != nil {
		log.Fatal(err)
	}
	defer cursor.Close(context.TODO())
 
	for cursor.Next(context.TODO()) {
		var result bson.M
		err := cursor.Decode(&result)
		if err != nil {
			log.Fatal(err)
		}
		fmt.Println("Document:", result)
	}
 
	// 過濾查找
	filteredCursor, err := collection.Find(context.TODO(), bson.D{{"age", bson.D{{"$gt", 31}}}})
	if err != nil {
		log.Fatal(err)
	}
	defer filteredCursor.Close(context.TODO())
 
	for filteredCursor.Next(context.TODO()) {
		var filteredDoc bson.M
		err := filteredCursor.Decode(&filteredDoc)
		if err != nil {
			log.Fatal(err)
		}
		fmt.Println("Filtered Document:", filteredDoc)
	}
}

query := bson.M{"name": "Alice", "age": bson.M{"$gt": 30}}

package svc
 
import "myprj/internal/config"
 
//手動代碼
import "myprj/rpc/model"
 
type ServiceContext struct {
	Config config.Config
	Model  model.NewUserModel// 手動代碼
}
 
func NewServiceContext(c config.Config) *ServiceContext {
	return &ServiceContext{
		Config: c,
		Model:  model.NewUserModel(c.DataSource, c.Cache), // 手動代碼
	}
}