กลไกการมิเกรท

1. ภาพรวมของกลไกการย้ายถ่าย

1.1 แนวคิดและบทบาทของการย้ายถ่าย

การย้ายฐานข้อมูลคือกระบวนการที่การปรับปรุงโมเดลของข้อมูลให้สอดคล้องกับโครงสร้างของฐานข้อมูลที่สำคัญสำหรับความต่อเนื่องของข้อมูล ภายในการพัฒนาแอปพลิเคชันเวอร์ชันใหม่ ๆ โมเดลข้อมูลโดยทั่วไปจะปรับเปลี่ยน เช่น เพิ่มหรือลบฟิลด์ หรือแก้ไขดัชนี การย้ายถ่ายช่วยให้นักพัฒนาสามารถจัดการกับการเปลี่ยนแปลงเหล่านี้ในรูปแบบที่ถูกดำเนินการเวอร์ชันและระบบ เพื่อให้มั่นใจว่าโครงสร้างของฐานข้อมูลและโมเดลข้อมูลสอดคล้องกันไป

ในการพัฒนาเว็บที่ทันสมัย กลไกการย้ายถ่ายนี้มอบให้ประโยชน์ต่อต่อไปนี้:

1. การควบคุมเวอร์ชัน: แฟ้มย้ายสามารถติดตามประวัติการเปลี่ยนแปลงของโครงสร้างของฐานข้อมูลทำให้สะดวกสำหรับการย้อนกลับและเข้าใจการเปลี่ยนแปลงในแต่ละเวอร์ชัน
2. การประยุกต์ใช้อัตโนมัติ: ผ่านประโยชน์ของกลไกการย้ายถ่าย การประยุกต์ฐานข้อมูลและการอัปเดตสามารถทำได้อัตโนมัติลดความเป็นไปได้ของการแทรกรด้วยตนเองและความเสี่ยงของข้อผิดพลาด
3. การทำงานร่วมกันของทีม: แฟ้มย้ายรองรับให้ทีมสมาชิกใช้โครงสร้างของฐานข้อมูลที่สะท้อนเป็นอย่างดีในสภาพแวดล้อมการพัฒนาที่แตกต่างกันทำให้การพัฒนาร่วมกันง่ายขึ้น

1.2 คุณสมบัติการย้ายถ่ายของเฟรมเวิร์ค ent

การบูรณาการของเฟรมเวิร์ค ent กับกลไกการย้ายถ่าย มอบให้มีคุณสมบัติต่อไปนี้:

1. การเขียนอะคลารราตีฟ: นักพัฒนาจำเป็นต้องเน้นที่การเขียนของอิทธีมองของเอนติตี้ซึ่งเฟเรมเวิร์คเอ็นท์จะจัดการการแปลงเอนติตี้ไปสู่ตารางฐานข้อมูล
2. การย้ายถ่ายอัตโนมัติ: เอ็นท์สามารถสร้างและอัพเดทโครงสร้างของตารางฐานข้อมูลโดยอัตโนมัติโดยไม่จำเป็นต้องเขียนคำสั่ง DDL ด้วยตนเอง
3. การควบคุมอย่างยืดหยุ่น: เอ็นท์มีตัวเลือกการกำหนดแบบสนับสนุนความต้องการของการย้ายถ่ายที่แตกต่างกันเช่น แบบเป็นหรือไม่เป็นข้อจำกัดกุญแจต่างๆ และการสร้างหรือไม่สร้างสำหรับรหัสไอดีที่เป็นสิ่งหลักในระดับสากล

2. การนำเสนอการย้ายถ่ายอัตโนมัติ

2.1 หลักการพื้นฐานของการย้ายถ่ายอัตโนมัติ

คุณสมบัติการย้ายถ่ายอัตโนมัติของเฟรมเวิร์ค ent อ้างอิงถึงแฟ้มนิยามสเคีม่า ไฟล์(ที่พบได้โดยทั่วไปในไดเรคทอรี ent/schema) เพื่อสร้างโครงสร้างของฐานข้อมูล หลังจากพัฒนาเอนทิตี้และความสัมพันธ์ ent จะตรวจสอบโครงสร้างที่มีอยู่ในฐานข้อมูลและสร้างการดำเนินการที่สอดคล้องกันเช่น สร้างตาราง เพิ่มหรือแก้ไขคอลัมน์ สร้างดัชนี ฯลฯ

และกับหลักการงานอัตโนมัติของ ent ทำงานใน "โหมดการเพิ่มเติม" โดยค่าเริ่มต้นเฉพาะอยากอัพเดตช่องงใหม่ ให้ถูก เพิ่มดัชนีใหม่ หรือเพิ่มคอลัมน์ในตาราง และไม่ลบตารางหรือคอลัมน์ที่มีอยู่ การออกแบบนี้เป็นประโยชน์บรรทัดการข้อมูลที่เสี่ยงแพลดด้วยตนเอง และทำให้ง่ายในการขยายโครงสร้างฐานข้อมูลในรูปแบบการดำเนินงาน

2.2 การใช้การย้ายถ่ายอัตโนมัติ

ขั้นตอนพื้นฐานในการใช้การย้ายถ่ายอัตโนมัติของ ent คือดังนี้:

package main

import (
    "context"
    "log"
    "ent"
)

func main() {
    client, err := ent.Open("mysql", "root:pass@tcp(localhost:3306)/test")
    if err != nil {
        log.Fatalf("Failed to connect to MySQL: %v", err)
    }
    defer client.Close()
    ctx := context.Background()

    // ทำการย้ายไปสร้างหรืออัพเดตโครงสร้างฐานข้อมูล
    if err := client.Schema.Create(ctx); err != nil {
        log.Fatalf("Failed to create database schema: %v", err)
    }
}

ในโค้ดข้างต้น ent.Open ทำหน้าที่ในการเชื่อมต่อกับฐานข้อมูลและการส่งกลับอินสแตนซ์ลูกค้าในขณะที่ client.Schema.Create ดำเนินการย้ายอัตโนมัติจริง

3. การใช้การย้ายถ่ายในลักษณะของอัพพลิเคชันอย่างประสูติน

3.1 การลบคอลัมน์และดัชนี

เป็นที่บางกรณี เราอาจจะต้องการลบคอลัมน์หรือดัชนีที่ไม่จำเป็นอยู่จากโครงสร้างฐานข้อมูล ในขณะนั้น เราสามารถใช้ตัวเลือก WithDropColumn และ WithDropIndex ตัวอย่างเช่น:

// เรียกกิจกรรมย้ายร่วมกับตัวเลือกที่จะดรอปคอลัมน์และดัชนี
err = client.Schema.Create(
    ctx,
    migrate.WithDropIndex(true),
    migrate.WithDropColumn(true),
)

ตัวอย่างโค้ดด้านบนเปิดใช้การตั้งค่าให้ลบคอลัมน์และดัชนี ตอนการทำการย้ายถ่ายอัตโนมัติ ent จะลบคอลัมน์และดัชนีที่ไม่มีอยู่ในข้อจำกัดของรูปนิยามเมื่อดำเนินการย้าย

3.2 รหัสไอดีที่เป็นสิ่งหลักในระดับสายละกับ

โดยค่าเริ่มต้น คีย์หลักในฐานข้อมูล SQL จะเริ่มต้นจาก 1 สำหรับแต่ละตาราง และประเภทอิทธ์ต่าง ๆ อาจจะมีการใช้ขงดเดียร้าไอดี่ที่เดียวกัน เกินนี้เช่นใช้กับกราฟคิวแอล อาจจะจำเป็นต้องมีความจำเป็นของความเป็นเอกลักษณ์สำหรับไอดีของออปเจ็คของพิกัลตันอิทธต์ที่แตกต่างกัน ใน ent สามารถกำหนดค่าได้โดยใช้ตัวเลือก WithGlobalUniqueID:

// ทำการย้ายโดยมีการจัดหาค่าไอดีสำหรับแต่ละอีนทิตี้
if err := client.Schema.Create(ctx, migrate.WithGlobalUniqueID(true)); err != nil {
    log.Fatalf("Failed to create the database schema: %v", err)
}

หลังจากเปิดใช้ ตัวเลือก WithGlobalUniqueID ent จะมอบหมายรหัสรัศมีขนาด 2^32 ให้กับแต่ละอิทธต์ในตารางที่มีชื่อว่า ent_types เพื่อให้เกิดความเป็นเอกลักษณ์สำหรับแต่ละอีนทิตี้อย่างโลกเสมอ

3.3 โหมดออฟไลน์

โหมดออฟไลน์ช่วยให้สามารถเขียนการเปลี่ยนแปลงแบบ schema ลงใน io.Writer แทนการทำงานโดยตรงบนฐานข้อมูล มันเป็นประโยชน์สำหรับการทดสอบคำสั่ง SQL ก่อนที่การเปลี่ยนแปลงจะมีผล หรือสำหรับสร้างสคริปต์ SQL เพื่อทำการประมวลผลด้วยตนเอง ตัวอย่างเช่น:

// บันทึกการเปลี่ยนแปลงการโยกย้ายไปยังไฟล์
f, err := os.Create("migrate.sql")
if err != nil {
    log.Fatalf("ล้มเหลวในการสร้างไฟล์การโยกย้าย: %v", err)
}
defer f.Close()
if err := client.Schema.WriteTo(ctx, f); err != nil {
    log.Fatalf("ล้มเหลวในการพิมพ์การเปลี่ยนแปลงของ schema ในฐานข้อมูล: %v", err)
}

โค้ดนี้จะเขียนการเปลี่ยนแปลงการโยกย้ายไปยังไฟล์ที่ชื่อ migrate.sql ในการปฏิบัติของนักพัฒนา สามารถเลือกที่จะพิมพ์โดยตรงไปยังการเอาออกมามองหรือเขียนไปยังไฟล์เพื่อสำรองไว้หรือเก็บบันทึกได้โดยตรง

4. การสนับสนุนคีย์ลูกศรภายนอกและการเชื่อมต่อกำหนดเอง

4.1 เปิดหรือปิดคีย์ลูกศรภายนอก

ใน Ent, คีย์ลูกศรภายนอกถูกนำมาใช้โดยการกำหนดความสัมพันธ์ (edges) ระหว่าง entities, และความสัมพันธ์คีย์ลูกศรภายนอกนี้ถูกสร้างอัตโนมัติที่ระดับฐานข้อมูลเพื่อให้ความสมบูรณ์และคงวิธีการข้อมูล อย่างไรก็ตาม ในสถานการณ์บางส่วน เช่น เพื่อปรับปรุงประสิทธิภาพหรือเมื่อฐานข้อมูลไม่รองรับคีย์ลูกศรภายนอก คุณอาจเลือกที่จะปิดการใช้งาน

เพื่อเปิดหรือปิดการใช้งานคำสั่งตรวจสอบคีย์ลูกศรภายนอกในการโยกย้าย คุณสามารถควบคุมได้ผ่านตัวเลือกการกำหนด WithForeignKeys ดังนี้:

// เปิดใช้งานคีย์ลูกศรภายนอก
err = client.Schema.Create(
    ctx,
    migrate.WithForeignKeys(true), 
)
if err != nil {
    log.Fatalf("ล้มเหลวในการสร้างทรัพยากรของ schema ด้วยคีย์ลูกศรภายนอก: %v", err)
}

// ปิดการใช้งานคีย์ลูกศรภายนอก
err = client.Schema.Create(
    ctx,
    migrate.WithForeignKeys(false), 
)
if err != nil {
    log.Fatalf("ล้มเหลวในการสร้างทรัพยากรของ schema โดยไม่มีคีย์ลูกศรภายนอก: %v", err)
}

ตัวเลือกการกำหนดนี้จะต้องถูกส่งผ่านเมื่อเรียกใช้ Schema.Create และมันกำหนดว่าจะรวมเงื่อนไขคีย์ลูกศรภายนอกใน DDL ที่ได้รับการสร้างโดยการกำหนดค่าที่ระบุ

4.2 การประยุกต์ใช้ก็อกของการโยกย้าย

ก็อกของการโยกย้ายคือตรรกะที่นำมาเอาและประมวลผลในขั้นตอนต่าง ๆ ของการปฏิบัติการโยกย้าย มันเป็นอย่างมากสำหรับการปฏิบัติโลจิกที่เฉพาะเจาะจงที่ฐานข้อมูลก่อนหลังการโยกย้าย เช่น การตรวจสอบผลลัพธ์การโยกย้าย และการเติมข้อมูลล่วงหน้าในการตัวอย่างง่าย ๆ ของการประยุกต์ก็อกการโยกย้าย:

func customHook(next schema.Creator) schema.Creator {
    return schema.CreateFunc(func(ctx context.Context, tables ...*schema.Table) error {
        // โลจิกที่ปรับการปฏิบัติก่อนการโยกย้าย
        // เช่น การบันทึก, ตรวจสอบเงื่อนไขบางอย่าง เป็นต้น
        log.Println("โลจิกก่อนการโยกย้าย")

        // เรียกใช้ก็อกถัดไปหรือโลจิกโยกย้ายเริ่มต้น
        err := next.Create(ctx, tables...)
        if err != nil {
            return err
        }

        // โลจิกที่ปรับการปฏิบัติหลังการโยกย้าย
        // เช่น การทำความสะอาด, การเติมข้อมูล, การตรวจสอบความปลอดภัย เป็นต้น
        log.Println("โลจิกหลังการโยกย้าย")
        return nil
    })
}

// การใช้ก็อกของการโยกย้ายที่ปรับการโยกย้าย
err := client.Schema.Create(
    ctx,
    schema.WithHooks(customHook),
)
if err != nil {
    log.Fatalf("ข้อผิดพลาดในการประยุกต์ใช้ก็อกการโยกย้ายกำหนดเอง: %v", err)
}

บั้งอาจารย์เป็นเครื่องมือที่มีพลังและจำเป็นสำหรับการโยกย้ายที่ซับซ้อน ซึ่งจะให้คุณความสามารถในการควบคุมพฤติกรรมการโยกย้ายฐานข้อมูลโดยตรงเมื่อจำเป็น

5. การโยกย้ายเวอร์ชัน

5.1 การแนะนำในการโยกย้ายเวอร์ชัน

การโยกย้ายเวอร์ชันเป็นแนวแกนสำหรับการจัดการการโยกย้ายฐานข้อมูล ทำให้นักพัฒนาสามารถแบ่งการเปลี่ยนแปลงโครงสร้างฐานข้อมูลเป็นหลายเวอร์ชัน แต่ละเวอร์ชันมีคำสั่งปรับเปลี่ยนฐานข้อมูลเฉพาะของมัน ต่อมายิ่ง Auto Migration, การโยกย้ายเวอร์ชันให้ควบคุมแม่นยำมากขึ้น แน่นอนทำให้การเปลี่ยนแปลงโครงสร้างฐานข้อมูลสามารถติดตามและทำกลับได้

ข้อได้เปรียบหลักของการโยกย้ายเวอร์ชันคือการสนับสนุนการโยกย้ายไปข้างหน้าและข้างหลัง (เช่น อัพเกรดหรือดาวน์เกรด) ทำให้นักพัฒนาสามารถใช้, ย้อนกลับหรือข้ามคำสั่งเฉพาะตามที่ต้องการ เมื่อทำงานร่วมกับทีม, การโยกย้ายเวอร์ชันทำให้แน่ใจว่าแต่ละสมาชิกทำงานกับโครงสร้างฐานข้อมูลเดียวกัน ลดปัญหาที่เกิดขึ้นจากความไม่สอดคล้องกัน

Auto migration มักจะไม่สามารถทำกลับ สร้างและประมวลผลคำสั่ง SQL เพื่อเข้ากับสถานะล่าสุดของ entities โดยส่วนใหญ่ถูกนำมาใช้อย่างไม่สมบูรณ์ในขั้นตอนการพัฒนาหรือโครงการขนาดเล็ก

5.2 การใช้การโยกย้ายเวอร์ชัน

1. การติดตั้งเครื่องมือ Atlas

ก่อนใช้งานการย้ายข้อมูลเวอร์ชัน คุณจำเป็นต้องติดตั้งเครื่องมือ Atlas ลงในระบบของคุณ Atlas เป็นเครื่องมือสำหรับการย้ายข้อมูลที่รองรับระบบฐานข้อมูลหลายระบบ มีคุณลักษณะที่มีประสิทธิภาพสำหรับการจัดการการเปลี่ยนแปลงโครงสร้างฐานข้อมูล

macOS + Linux

curl -sSf https://atlasgo.sh | sh

Homebrew

brew install ariga/tap/atlas

Docker

docker pull arigaio/atlas
docker run --rm arigaio/atlas --help

Windows

https://release.ariga.io/atlas/atlas-windows-amd64-latest.exe

2. สร้างไฟล์ย้ายข้อมูลโดยใช้นิยาม Entity ปัจจุบัน

atlas migrate diff migration_name \
  --dir "file://ent/migrate/migrations" \
  --to "ent://ent/schema" \
  --dev-url "docker://mysql/8/ent"

3. ไฟล์ย้ายข้อมูลแอปพลิเคชัน

เมื่อไฟล์ย้ายข้อมูลถูกสร้างขึ้นแล้ว สามารถนำไปใช้กับระบบพัฒนา ทดสอบ หรือการผลิตได้ โดยทั่วไปแล้ว คุณจะใช้ไฟล์ย้ายข้อมูลเหล่านี้กับฐานข้อมูลระบบพัฒนาหรือการทดสอบเพื่อให้แน่ใจว่าพวกเขาทำงานตามที่คาดหวัง จากนั้น ขั้นตอนย้ายข้อมูลเดียวกันจะถูกดำเนินการในสภาพแวดล้อมการผลิต

atlas migrate apply \
  --dir "file://ent/migrate/migrations" \
  --url "mysql://root:pass@localhost:3306/example"

ใช้คำสั่ง atlas migrate apply ระบุไดเรกทอรีไฟล์ย้ายข้อมูล (--dir) และ URL ของฐานข้อมูลเป้าหมาย (--url) เพื่อนำไฟล์ย้ายข้อมูลไปใช้งาน