Cara menggunakan bahasa Go untuk mencipta pembahagian berbilang dimensi berprestasi tinggi bagi data MySQL

Dalam pangkalan data MySQL berskala besar, pembahagian data adalah salah satu teknologi yang sangat penting. Dengan membahagikan data kepada beberapa bahagian kecil, kami boleh memastikan prestasi tinggi dan kebolehskalaan pangkalan data, di samping meningkatkan keselamatan data.

Dalam artikel ini, kami akan memperkenalkan cara menggunakan bahasa Go untuk mencipta segmentasi berbilang dimensi berprestasi tinggi bagi data MySQL, menjadikan pangkalan data anda lebih cekap dan fleksibel.

1 Pilih strategi pemecahan data

Pemecahan data adalah untuk membahagikan sejumlah besar data kepada beberapa bahagian kecil untuk mengoptimumkan prestasi dan kebolehskalaan pangkalan data. Dalam MySQL, terdapat tiga strategi segmentasi:

1. Segmentasi menegak: segmentasi menegak berdasarkan data perniagaan. Ini bermakna jadual data yang berbeza diasingkan pada pelayan fizikal yang berbeza untuk memastikan setiap pelayan dikhaskan untuk memproses data yang berkaitan dengannya.
2. Pecahan mendatar: Pisahkan jadual mengikut peraturan tertentu, kemudian simpan data pecahan pada pelayan berbeza. Strategi ini terutamanya menyelesaikan masalah volum data yang berlebihan dalam satu jadual, seperti jadual pengguna, jadual pesanan, dll.
3. Penghirisan Hibrid: Gunakan gabungan penghirisan menegak dan mendatar untuk mendapatkan yang terbaik daripada kedua-dua strategi.

Memilih strategi sharding yang paling sesuai dengan pangkalan data anda ialah keputusan yang sangat penting yang perlu mengambil kira banyak faktor seperti jenis pangkalan data, keperluan perniagaan dan volum data.

2. Gunakan bahasa Go untuk menyambung ke MySQL

Bahasa Go menyediakan pakej pangkalan data/sql untuk menyambung ke pelbagai pangkalan data, termasuk MySQL. Di sini kami menggunakan contoh kod untuk menggambarkan cara menggunakan bahasa Go untuk menyambung ke MySQL:

import (
    "database/sql"
    "fmt"
    _ "github.com/go-sql-driver/mysql"
)

func main() {
    db, err := sql.Open("mysql", "user:password@tcp(127.0.0.1:3306)/database_name")
    if err != nil {
        fmt.Println(err)
    }
    defer db.Close()
    
    // 进行数据库操作
}

Dalam kod di atas, fungsi sql.Open digunakan untuk menyambung ke pangkalan data MySQL, di mana pengguna, kata laluan dan nama_pangkalan data memerlukan digantikan dengan nilai sebenar. Operasi pangkalan data boleh dilakukan selepas sambungan berjaya.

3. Gunakan bahasa Go untuk pembahagian mendatar

Dalam bahagian ini, kami akan menggunakan bahasa Go untuk pembahagian mendatar. Dengan membahagikan jadual data yang besar, kami boleh menyebarkannya merentas contoh pangkalan data yang berbeza, dengan itu meningkatkan prestasi pertanyaan.

Berikut ialah contoh:

import (
    "database/sql"
    "fmt"
    _ "github.com/go-sql-driver/mysql"
)

func main() {
    db1, err := sql.Open("mysql", "user:password@tcp(127.0.0.1:3306)/database_name1")
    if err != nil {
        fmt.Println(err)
    }
    defer db1.Close()
    
    db2, err := sql.Open("mysql", "user:password@tcp(127.0.0.1:3306)/database_name2")
    if err != nil {
        fmt.Println(err)
    }
    defer db2.Close()
    
    // 进行数据库操作，比如创建数据表、插入数据等
    // 通过db1进行操作表A，通过db2进行操作表B
}

Kod di atas mencipta dua objek db yang disambungkan kepada kejadian pangkalan data yang berbeza. Kita boleh menggunakan dua objek ini mengikut keperluan, contohnya, db1 digunakan untuk mengendalikan jadual A dan db2 digunakan untuk mengendalikan jadual B. Kelebihan ini ialah walaupun data jadual berubah, kita boleh memindahkan beberapa jadual ke contoh pangkalan data lain dengan mengubah suai maklumat sambungan.

4. Gunakan bahasa Go untuk pembahagian menegak

Dalam bahagian ini, kami akan menggunakan bahasa Go untuk pembahagian menegak. Sharding menegak membahagikan jenis data yang sama dalam satu jadual ke dalam jadual yang berbeza dan kemudian menyimpannya pada contoh pangkalan data yang berbeza.

Berikut ialah satu contoh:

import (
    "database/sql"
    "fmt"
    _ "github.com/go-sql-driver/mysql"
)

func main() {
    db1, err := sql.Open("mysql", "user:password@tcp(127.0.0.1:3306)/database_name1")
    if err != nil {
        fmt.Println(err)
    }
    defer db1.Close()
    
    db2, err := sql.Open("mysql", "user:password@tcp(127.0.0.1:3306)/database_name2")
    if err != nil {
        fmt.Println(err)
    }
    defer db2.Close()
    
    // 创建数据表
    _, err = db1.Exec(`CREATE TABLE table1 (
        id INT(11) NOT NULL AUTO_INCREMENT PRIMARY KEY,
        name VARCHAR(20) NOT NULL
    )`)
    if err != nil {
        fmt.Println(err)
    }
    
    _, err = db2.Exec(`CREATE TABLE table2 (
        id INT(11) NOT NULL AUTO_INCREMENT PRIMARY KEY,
        email VARCHAR(20) NOT NULL
    )`)
    if err != nil {
        fmt.Println(err)
    }
    
    // 插入数据
    _, err = db1.Exec(`INSERT INTO table1 (name) VALUES ("Tom")`)
    if err != nil {
        fmt.Println(err)
    }
    
    _, err = db2.Exec(`INSERT INTO table2 (email) VALUES ("tom@example.com")`)
    if err != nil {
        fmt.Println(err)
    }
    
    // 查询数据
    rows1, err := db1.Query(`SELECT * FROM table1`)
    if err != nil {
        fmt.Println(err)
    }
    defer rows1.Close()
    
    for rows1.Next() {
        var id int
        var name string
        if err := rows1.Scan(&id, &name); err != nil {
            fmt.Println(err)
            continue
        }
        fmt.Printf("id: %d, name: %s
", id, name)
    }
    
    rows2, err := db2.Query(`SELECT * FROM table2`)
    if err != nil {
        fmt.Println(err)
    }
    defer rows2.Close()
    
    for rows2.Next() {
        var id int
        var email string
        if err := rows2.Scan(&id, &email); err != nil {
            fmt.Println(err)
            continue
        }
        fmt.Printf("id: %d, email: %s
", id, email)
    }
}

Contoh ini mencipta dua jadual data yang mengandungi jenis data berbeza dan menyimpannya ke tika pangkalan data yang berbeza. Kemudian, masukkan baris data ke dalam dua jadual data dan tanya data.

5 Gunakan bahasa Go untuk segmentasi hibrid

Dalam bahagian ini, kami akan menggunakan bahasa Go untuk segmentasi hibrid. Sharding hibrid menggabungkan sharding menegak dan sharding mendatar untuk mengoptimumkan prestasi pangkalan data dan kebolehskalaan.

Berikut ialah contoh pembahagian hibrid:

import (
    "database/sql"
    "fmt"
    _ "github.com/go-sql-driver/mysql"
)

func main() {
    db1, err := sql.Open("mysql", "user:password@tcp(127.0.0.1:3306)/database_name1")
    if err != nil {
        fmt.Println(err)
    }
    defer db1.Close()
    
    db2, err := sql.Open("mysql", "user:password@tcp(127.0.0.1:3306)/database_name2")
    if err != nil {
        fmt.Println(err)
    }
    defer db2.Close()
    
    table1_name := "table1"
    table2_name := "table2"
    
    // 进行水平切分
    _, err = db1.Exec(fmt.Sprintf(`
        CREATE TABLE %s_%d (
            id INT(11) NOT NULL AUTO_INCREMENT PRIMARY KEY,
            name VARCHAR(20) NOT NULL
        ) ENGINE=InnoDB
    `, table1_name, shard_id))
    
    if err != nil {
        fmt.Println(err)
    }
    
    _, err = db2.Exec(fmt.Sprintf(`
        CREATE TABLE %s_%d (
            id INT(11) NOT NULL AUTO_INCREMENT PRIMARY KEY,
            email VARCHAR(20) NOT NULL
        ) ENGINE=InnoDB
    `, table2_name, shard_id))
    
    if err != nil {
        fmt.Println(err)
    }
    
    // 进行垂直切分
    _, err = db1.Exec(fmt.Sprintf(`
        CREATE TABLE %s_name_%d (
            id INT(11) NOT NULL,
            name VARCHAR(20) NOT NULL,
            PRIMARY KEY(id)
        ) ENGINE=InnoDB
    `, table1_name, shard_id))
    
    if err != nil {
        fmt.Println(err)
    }
    
    _, err = db2.Exec(fmt.Sprintf(`
        CREATE TABLE %s_email_%d (
            id INT(11) NOT NULL,
            email VARCHAR(20) NOT NULL,
            PRIMARY KEY(id)
        ) ENGINE=InnoDB
    `, table2_name, shard_id))
    
    if err != nil {
        fmt.Println(err)
    }
    
    // 插入数据
    tx1, _ := db1.Begin()
    stmt1, _ := tx1.Prepare(fmt.Sprintf(`
        INSERT INTO %s_%d (name) values (?)
    `, table1_name, shard_id))
    stmt2, _ := db1.Prepare(fmt.Sprintf(`
        INSERT INTO %s_name_%d (id, name) values (?, ?)
    `, table1_name, shard_id))
    
    stmt1.Exec("Tom")
    stmt2.Exec(1, "Tom")
    
    tx1.Commit()
    
    tx2, _ := db2.Begin()
    stmt3, _ := tx2.Prepare(fmt.Sprintf(`
        INSERT INTO %s_%d (email) values (?)
    `, table2_name, shard_id))
    stmt4, _ := db2.Prepare(fmt.Sprintf(`
        INSERT INTO %s_email_%d (id, email) values (?, ?)
    `, table2_name, shard_id))
    
    stmt3.Exec("tom@example.com")
    stmt4.Exec(1, "tom@example.com")
    
    tx2.Commit()
    
    // 查询数据
    rows1, err := db1.Query(fmt.Sprintf(`
        SELECT * FROM %s_%d
    `, table1_name, shard_id))
    
    if err != nil {
        fmt.Println(err)
    }
    defer rows1.Close()
    
    for rows1.Next() {
        var id int
        var name string
        if err := rows1.Scan(&id, &name); err != nil {
            fmt.Println(err)
            continue
        }
        fmt.Printf("id: %d, name: %s
", id, name)
    }
    
    rows2, err := db2.Query(fmt.Sprintf(`
        SELECT * FROM %s_%d
    `, table2_name, shard_id))
    
    if err != nil {
        fmt.Println(err)
    }
    defer rows2.Close()
    
    for rows2.Next() {
        var id int
        var email string
        if err := rows2.Scan(&id, &email); err != nil {
            fmt.Println(err)
            continue
        }
        fmt.Printf("id: %d, email: %s
", id, email)
    }
    
    rows3, err := db1.Query(fmt.Sprintf(`
        SELECT * FROM %s_name_%d WHERE id=1
    `, table1_name, shard_id))
    
    if err != nil {
        fmt.Println(err)
    }
    defer rows3.Close()
    
    for rows3.Next() {
        var id int
        var name string
        if err := rows3.Scan(&id, &name); err != nil {
            fmt.Println(err)
            continue
        }
        fmt.Printf("id: %d, name: %s
", id, name)
    }
    
    rows4, err := db2.Query(fmt.Sprintf(`
        SELECT * FROM %s_email_%d WHERE id=1
    `, table2_name, shard_id))
    
    if err != nil {
        fmt.Println(err)
    }
    defer rows4.Close()
    
    for rows4.Next() {
        var id int
        var email string
        if err := rows4.Scan(&id, &email); err != nil {
            fmt.Println(err)
            continue
        }
        fmt.Printf("id: %d, email: %s
", id, email)
    }
}

Contoh ini menggabungkan pembahagian mendatar dan pembahagian menegak data, membahagikan jadual A dan jadual B kepada berbilang jadual kecil (seperti A_0 , A_1, B_0, B_1, dsb.) dan simpannya ke contoh pangkalan data yang berbeza. Kaedah sharding hibrid ini membolehkan kami mengurus pangkalan data dengan lebih fleksibel sambil meningkatkan prestasi pertanyaan dan kebolehskalaan.

6. Ringkasan

Melalui kajian artikel ini, kami telah mempelajari cara menggunakan bahasa Go untuk mencipta segmentasi berbilang dimensi berprestasi tinggi bagi data MySQL. Strategi segmentasi yang berbeza mempunyai kelebihan unik dan senario aplikasi, dan kita perlu memilih mengikut situasi sebenar.

Sama ada pembahagian mendatar atau pembahagian menegak, pakej pangkalan data/sql bahasa Go menyediakan kaedah operasi yang mudah. Gunakan kaedah ini untuk menyambung dengan cepat ke pangkalan data MySQL dan mengendalikan data.

Saya harap artikel ini bermanfaat kepada anda Jika anda mempunyai sebarang pertanyaan atau cadangan, sila tinggalkan mesej di ruangan komen.

Atas ialah kandungan terperinci Cara menggunakan bahasa Go untuk mencipta pembahagian berbilang dimensi berprestasi tinggi bagi data MySQL. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!