server/game/game_cluster/nodes/tool/migrate.go

package main

import (
	"context"
	"database/sql"
	"encoding/json"
	"fmt"
	_ "github.com/go-sql-driver/mysql"
	"github.com/mhaya/game/game_cluster/internal/mdb/models"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
	"log"
	"time"
)

// MySQL结构体
type MySQLUser struct {
	Username      string  `json:"username"`
	Nickname      string  `json:"nickname"`
	Pid           string  `json:"pid"`
	Level         int     `json:"level"`
	Money         float64 `json:"money"`
	Score         int     `json:"score"`
	Roll          int     `json:"roll"`
	Invite        int     `json:"invite"`
	AllRoll       int     `json:"allroll"`
	RollDay       int     `json:"rollday"`
	RollNums      int     `json:"rollnums"`
	RollDays      int     `json:"rolldays"`
	TonWall       string  `json:"tonwall"`
	DrawsNumber   int     `json:"drawsnumber"`
	DayLimit      int     `json:"daylimit"`
	Jump          int     `json:"jump"`
	DayRoll       int     `json:"dayroll"`
	DayInvite     int     `json:"dayinvite"`
	DatScore      int     `json:"datscore"`
	WallTon       string  `json:"wallton"`
	WallU         string  `json:"wallu"`
	RollOneStatus int     `json:"rollonestatus"`
	FirstReward   int     `json:"firsteward"`
}

// MySQL 数据读取
func readFromMySQL() ([]MySQLUser, error) {
	db, err := sql.Open("mysql", "root:123456@tcp(127.0.0.1:3306)/dbname")
	if err != nil {
		return nil, err
	}
	defer db.Close()

	rows, err := db.Query("SELECT * FROM users")
	if err != nil {
		return nil, err
	}
	defer rows.Close()

	var users []MySQLUser
	for rows.Next() {
		var user MySQLUser
		err := rows.Scan(
			&user.Username,
			&user.Nickname,
			&user.Pid,
			&user.Level,
			&user.Money,
			&user.Score,
			&user.Roll,
			&user.Invite,
			&user.AllRoll,
			&user.RollDay,
			&user.RollNums,
			&user.RollDays,
			&user.TonWall,
			&user.DrawsNumber,
			&user.DayLimit,
			&user.Jump,
			&user.DayRoll,
			&user.DayInvite,
			&user.DatScore,
			&user.WallTon,
			&user.WallU,
			&user.RollOneStatus,
			&user.FirstReward,
		)
		if err != nil {
			return nil, err
		}
		users = append(users, user)
	}

	return users, nil
}

// 数据转换
func convertToMongo(user MySQLUser) (models.Player, error) {
	var mongoUser models.Player
	err := json.Unmarshal([]byte(fmt.Sprintf(`%v`, user)), &mongoUser)
	if err != nil {
		return mongoUser, err
	}

	// 填充其他字段
	mongoUser.UserName = user.Username
	mongoUser.NickName = user.Nickname
	mongoUser.Pid = user.Pid
	mongoUser.Level = user.Level
	mongoUser.Exp = user.Score // 假设Exp和Score相同
	mongoUser.CreateTime = time.Now().Unix()
	mongoUser.UpdateTime = time.Now().Unix()
	mongoUser.DailyRefreshTime = time.Now().Unix()
	mongoUser.WeeklyRefreshTime = time.Now().Unix()
	//mongoUser.RollDay = user.RollDay
	mongoUser.Status = 1 // 默认状态
	mongoUser.Index = 1  // 默认索引
	mongoUser.TonWall = user.TonWall
	mongoUser.JoinTime = time.Now().Unix()
	mongoUser.JoinIP = "127.0.0.1"

	// 初始化其他结构体
	//mongoUser.Roll = &models.Roll{}
	//mongoUser.Share = &models.RShare{}
	//mongoUser.Item = models.RItemBasePack{}
	//mongoUser.SinIn = models.RSignIn{}
	//mongoUser.DailyTask = models.RDailyTask{}
	//mongoUser.AchieveTask = models.RAchieveTask{}
	//mongoUser.RankReward = models.RRankReward{}
	//mongoUser.Invite = models.RInvite{}
	//mongoUser.InviteReward = &models.RInviteReward{}
	//mongoUser.PlayerReward = make(map[int]*models.RPlayerRewardBase)

	return mongoUser, nil
}

// 插入MongoDB
func insertIntoMongo(users []MySQLUser) error {
	clientOptions := options.Client().ApplyURI("mongodb://localhost:27017")
	client, err := mongo.Connect(context.TODO(), clientOptions)
	if err != nil {
		return err
	}
	defer client.Disconnect(context.TODO())

	collection := client.Database("game").Collection("players")

	for _, user := range users {
		mongoUser, err := convertToMongo(user)
		if err != nil {
			return err
		}

		_, err = collection.InsertOne(context.TODO(), mongoUser)
		if err != nil {
			return err
		}
	}

	return nil
}

// 主函数
func main() {
	users, err := readFromMySQL()
	if err != nil {
		log.Fatal(err)
	}

	err = insertIntoMongo(users)
	if err != nil {
		log.Fatal(err)
	}

	log.Println("Data migration completed successfully.")
}