أنماط قواعد البيانات

أنماط قواعد البيانات — Database Patterns

بعد تعلم الأساسيات، حان وقت الأنماط الاحترافية التي تُنظّم كودك وتجعله قابلاً للصيانة والاختبار.

نمط Repository

يفصل منطق الوصول للبيانات عن منطق الأعمال. بدلاً من كتابة SQL في كل مكان، تُغلّفه في طبقة واحدة:

main.go

package main

import (
    "errors"
    "fmt"
)

// النموذج — Model
type User struct {
    ID    int
    Name  string
    Email string
    Age   int
}

// واجهة Repository — Repository interface
type UserRepository interface {
    Create(user *User) error
    GetByID(id int) (*User, error)
    GetAll() ([]User, error)
    Update(user *User) error
    Delete(id int) error
}

// تنفيذ في الذاكرة — In-memory implementation
type InMemoryUserRepo struct {
    users  map[int]*User
    nextID int
}

func NewInMemoryUserRepo() *InMemoryUserRepo {
    return &InMemoryUserRepo{
        users:  make(map[int]*User),
        nextID: 1,
    }
}

var ErrUserNotFound = errors.New("المستخدم غير موجود")

func (r *InMemoryUserRepo) Create(user *User) error {
    user.ID = r.nextID
    r.nextID++
    r.users[user.ID] = user
    return nil
}

func (r *InMemoryUserRepo) GetByID(id int) (*User, error) {
    user, ok := r.users[id]
    if !ok {
        return nil, ErrUserNotFound
    }
    return user, nil
}

func (r *InMemoryUserRepo) GetAll() ([]User, error) {
    result := make([]User, 0, len(r.users))
    for _, u := range r.users {
        result = append(result, *u)
    }
    return result, nil
}

func (r *InMemoryUserRepo) Update(user *User) error {
    if _, ok := r.users[user.ID]; !ok {
        return ErrUserNotFound
    }
    r.users[user.ID] = user
    return nil
}

func (r *InMemoryUserRepo) Delete(id int) error {
    if _, ok := r.users[id]; !ok {
        return ErrUserNotFound
    }
    delete(r.users, id)
    return nil
}

// خدمة الأعمال — Business service
type UserService struct {
    repo UserRepository
}

func (s *UserService) RegisterUser(name, email string, age int) (*User, error) {
    if name == "" || email == "" {
        return nil, fmt.Errorf("الاسم والبريد مطلوبان")
    }
    user := &User{Name: name, Email: email, Age: age}
    if err := s.repo.Create(user); err != nil {
        return nil, fmt.Errorf("فشل التسجيل: %w", err)
    }
    return user, nil
}

func main() {
    // إنشاء الطبقات — Create layers
    repo := NewInMemoryUserRepo()
    service := &UserService{repo: repo}

    // استخدام الخدمة — Use service
    u1, _ := service.RegisterUser("أحمد", "ahmed@example.com", 28)
    u2, _ := service.RegisterUser("فاطمة", "fatima@example.com", 24)
    fmt.Printf("تسجيل: %s (ID: %d)\n", u1.Name, u1.ID)
    fmt.Printf("تسجيل: %s (ID: %d)\n", u2.Name, u2.ID)

    // قراءة — Read
    user, err := repo.GetByID(1)
    if err != nil {
        fmt.Println("خطأ:", err)
    } else {
        fmt.Printf("البحث: %s — %s\n", user.Name, user.Email)
    }

    // قائمة — List
    all, _ := repo.GetAll()
    fmt.Printf("المجموع: %d مستخدمين\n", len(all))
}

Output:

لماذا Repository مهم:

الاختبار — استبدل التنفيذ الحقيقي بتنفيذ وهمي (mock)
المرونة — بدّل من PostgreSQL لـ MySQL بتغيير التنفيذ فقط
الفصل — منطق الأعمال لا يعرف شيئاً عن SQL

مسح البنيات — Struct Scanning

database/sql يتطلب مسح كل حقل يدوياً. هذا مُرهق مع بنيات كبيرة:

main.go

package main

import "fmt"

func main() {
    fmt.Println("=== مقارنة طرق المسح ===\n")

    fmt.Println("1️⃣ database/sql (يدوي):")
    fmt.Println(`   var u User
   err := row.Scan(&u.ID, &u.Name, &u.Email, &u.Age, &u.CreatedAt)
   // كل حقل يدوياً! — Each field manually!`)

    fmt.Println("\n2️⃣ sqlx (تلقائي):")
    fmt.Println(`   var u User
   err := row.StructScan(&u)  // يمسح حسب وسوم db — Scans by db tags`)

    fmt.Println("\n3️⃣ GORM (ORM كامل):")
    fmt.Println(`   var u User
   db.First(&u, 1)  // يُنشئ SQL تلقائياً — Generates SQL automatically`)

    fmt.Println("\n=== متى تستخدم ماذا؟ ===")
    fmt.Println("database/sql → تحكم كامل، مشاريع صغيرة/متوسطة")
    fmt.Println("sqlx         → database/sql + راحة إضافية (الأشهر)")
    fmt.Println("GORM         → مشاريع كبيرة، تحتاج ORM كامل")
}

Output:

مفهوم الترحيل — Migrations

الترحيلات تُدير تطور بنية قاعدة البيانات مع الوقت:

main.go

package main

import "fmt"

func main() {
    fmt.Println("=== ترحيلات قاعدة البيانات ===\n")

    fmt.Println("الفكرة: كل تغيير في البنية يُحفظ كملف ترحيل")
    fmt.Println()

    migrations := []struct {
        version string
        up      string
        down    string
    }{
        {
            "001",
            "CREATE TABLE users (id SERIAL PRIMARY KEY, name TEXT NOT NULL);",
            "DROP TABLE users;",
        },
        {
            "002",
            "ALTER TABLE users ADD COLUMN email TEXT;",
            "ALTER TABLE users DROP COLUMN email;",
        },
        {
            "003",
            "CREATE INDEX idx_users_email ON users(email);",
            "DROP INDEX idx_users_email;",
        },
    }

    for _, m := range migrations {
        fmt.Printf("📄 migration_%s:\n", m.version)
        fmt.Printf("   ⬆️  UP:   %s\n", m.up)
        fmt.Printf("   ⬇️  DOWN: %s\n\n", m.down)
    }

    fmt.Println("أدوات شائعة:")
    fmt.Println("  golang-migrate/migrate — الأشهر")
    fmt.Println("  pressly/goose — بسيط وفعال")
    fmt.Println("  atlas — حديث ومتقدم")
}

Output:

مقارنة الأدوات

الأداة	النوع	المستوى	الاستخدام
`database/sql`	قياسي	منخفض	تحكم كامل
`sqlx`	مكتبة مساعدة	متوسط	database/sql + راحة
`GORM`	ORM كامل	عالي	تطوير سريع
`sqlc`	مولّد كود	متوسط	SQL → Go code

نصيحة أخيرة

ابدأ بـ database/sql لفهم الأساسيات، ثم انتقل لـ sqlx للمشاريع الحقيقية. GORM مناسب إذا كنت تأتي من عالم ORM (Django, Laravel) وتريد نفس التجربة.

تحدي — Challenge

package main

import "fmt"

type User struct {
    ID   int
    Name string
}

type Repo struct {
    data   map[int]User
    nextID int
}

// أكمل Create لتضيف مستخدم وتزيد nextID
func (r *Repo) Create(name string) User {
    // اكتب الكود هنا
    return User{}
}

// أكمل Get لتجلب مستخدم بمعرّفه
func (r *Repo) Get(id int) (User, bool) {
    // اكتب الكود هنا
    return User{}, false
}

func main() {
    repo := &Repo{data: make(map[int]User), nextID: 1}

    u1 := repo.Create("علي")
    u2 := repo.Create("سارة")
    fmt.Printf("✅ إنشاء: %s (ID: %d)\n", u1.Name, u1.ID)
    fmt.Printf("✅ إنشاء: %s (ID: %d)\n", u2.Name, u2.ID)

    if u, ok := repo.Get(1); ok {
        fmt.Printf("📖 البحث: %s\n", u.Name)
    }
    fmt.Printf("📝 الكل: %d مستخدمين\n", len(repo.data))
}