Лекція 13. Взаємодія з реляційними СУБД та технології ORM

postgres://username:password@hostname:port/database?параметри

postgres://appuser:secretpass@localhost:5432/myapp_db?sslmode=disable

package main

import (
    "database/sql"
    "fmt"
    "log"
    
    _ "github.com/jackc/pgx/v5/stdlib" // Реєстрація драйвера
)

func main() {
    // Рядок підключення (DSN)
    dsn := "postgres://appuser:secretpass@localhost:5432/myapp_db?sslmode=disable"
    
    // Відкриття пулу з'єднань
    db, err := sql.Open("pgx", dsn)
    if err != nil {
        log.Fatalf("Не вдалося відкрити базу даних: %v", err)
    }
    defer db.Close()
    
    // Перевірка з'єднання
    if err := db.Ping(); err != nil {
        log.Fatalf("Не вдалося під'єднатися до бази даних: %v", err)
    }
    
    fmt.Println("✅ Успішне підключення до PostgreSQL")
}

// Максимальна кількість відкритих з'єднань (включно з активними та неактивними)
db.SetMaxOpenConns(25)

// Максимальна кількість неактивних (idle) з'єднань у пулі
db.SetMaxIdleConns(10)

// Максимальний час життя з'єднання (після закінчення з'єднання буде закрите)
db.SetConnMaxLifetime(5 * time.Minute)

// Максимальний час простою з'єднання (неактивні з'єднання будуть закриті)
db.SetConnMaxIdleTime(2 * time.Minute)

func createTable(db *sql.DB) error {
    query := `
    CREATE TABLE IF NOT EXISTS users (
        id SERIAL PRIMARY KEY,
        email VARCHAR(255) UNIQUE NOT NULL,
        password_hash VARCHAR(255) NOT NULL,
        full_name VARCHAR(255) NOT NULL,
        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
    );
    `
    
    _, err := db.Exec(query)
    if err != nil {
        return fmt.Errorf("не вдалося створити таблицю: %w", err)
    }
    
    fmt.Println("✅ Таблиця users створена")
    return nil
}

result, err := db.Exec("INSERT INTO users ...")
if err != nil {
    return err
}

lastID, _ := result.LastInsertId() // Останній згенерований ID (не для всіх СУБД)
rowsAffected, _ := result.RowsAffected() // Кількість змінених рядків

package repository

import (
    "context"
    "database/sql"
    "fmt"
)

type User struct {
    ID           int
    Email        string
    PasswordHash string
    FullName     string
}

type UserRepository struct {
    db *sql.DB
}

func NewUserRepository(db *sql.DB) *UserRepository {
    return &UserRepository{db: db}
}

func (r *UserRepository) Create(ctx context.Context, user *User) error {
    query := `
        INSERT INTO users (email, password_hash, full_name)
        VALUES ($1, $2, $3)
        RETURNING id
    `
    
    // QueryRow виконує запит та очікує рівно один рядок результату
    err := r.db.QueryRowContext(ctx, query,
        user.Email,
        user.PasswordHash,
        user.FullName,
    ).Scan(&user.ID)
    
    if err != nil {
        return fmt.Errorf("помилка створення користувача: %w", err)
    }
    
    return nil
}

func (r *UserRepository) GetByID(ctx context.Context, id int) (*User, error) {
    query := `
        SELECT id, email, password_hash, full_name
        FROM users
        WHERE id = $1
    `
    
    user := &User{}
    err := r.db.QueryRowContext(ctx, query, id).Scan(
        &user.ID,
        &user.Email,
        &user.PasswordHash,
        &user.FullName,
    )
    
    if err == sql.ErrNoRows {
        return nil, fmt.Errorf("користувача з ID %d не знайдено", id)
    }
    if err != nil {
        return nil, fmt.Errorf("помилка читання користувача: %w", err)
    }
    
    return user, nil
}

func (r *UserRepository) GetAll(ctx context.Context) ([]*User, error) {
    query := `SELECT id, email, password_hash, full_name FROM users ORDER BY id`
    
    rows, err := r.db.QueryContext(ctx, query)
    if err != nil {
        return nil, fmt.Errorf("помилка виконання запиту: %w", err)
    }
    defer rows.Close() // Обов'язково закрити курсор!
    
    var users []*User
    for rows.Next() {
        user := &User{}
        if err := rows.Scan(&user.ID, &user.Email, &user.PasswordHash, &user.FullName); err != nil {
            return nil, fmt.Errorf("помилка сканування рядка: %w", err)
        }
        users = append(users, user)
    }
    
    // Перевірка помилок, які могли виникнути під час ітерації
    if err := rows.Err(); err != nil {
        return nil, fmt.Errorf("помилка ітерації рядків: %w", err)
    }
    
    return users, nil
}

func (r *UserRepository) Update(ctx context.Context, user *User) error {
    query := `
        UPDATE users
        SET email = $1, full_name = $2
        WHERE id = $3
    `
    
    result, err := r.db.ExecContext(ctx, query,
        user.Email,
        user.FullName,
        user.ID,
    )
    if err != nil {
        return fmt.Errorf("помилка оновлення користувача: %w", err)
    }
    
    rowsAffected, err := result.RowsAffected()
    if err != nil {
        return fmt.Errorf("помилка отримання кількості змінених рядків: %w", err)
    }
    
    if rowsAffected == 0 {
        return fmt.Errorf("користувача з ID %d не знайдено", user.ID)
    }
    
    return nil
}

func (r *UserRepository) Delete(ctx context.Context, id int) error {
    query := `DELETE FROM users WHERE id = $1`
    
    result, err := r.db.ExecContext(ctx, query, id)
    if err != nil {
        return fmt.Errorf("помилка видалення користувача: %w", err)
    }
    
    rowsAffected, err := result.RowsAffected()
    if err != nil {
        return fmt.Errorf("помилка отримання кількості змінених рядків: %w", err)
    }
    
    if rowsAffected == 0 {
        return fmt.Errorf("користувача з ID %d не знайдено", id)
    }
    
    return nil
}

package main

import (
    "log"
    
    "github.com/jmoiron/sqlx"
    _ "github.com/jackc/pgx/v5/stdlib"
)

func main() {
    dsn := "postgres://appuser:secretpass@localhost:5432/myapp_db?sslmode=disable"
    
    // sqlx.Open повертає *sqlx.DB замість *sql.DB
    db, err := sqlx.Open("pgx", dsn)
    if err != nil {
        log.Fatalf("Помилка підключення: %v", err)
    }
    defer db.Close()
    
    if err := db.Ping(); err != nil {
        log.Fatalf("База недоступна: %v", err)
    }
    
    log.Println("✅ Підключення через sqlx успішне")
}

type User struct {
    ID           int       `db:"id"`
    Email        string    `db:"email"`
    PasswordHash string    `db:"password_hash"`
    FullName     string    `db:"full_name"`
    CreatedAt    time.Time `db:"created_at"`
}

func (r *UserRepository) GetByID(ctx context.Context, id int) (*User, error) {
    user := &User{}
    query := `SELECT id, email, password_hash, full_name, created_at FROM users WHERE id = $1`
    
    // Автоматичне сканування у структуру
    err := r.db.GetContext(ctx, user, query, id)
    if err == sql.ErrNoRows {
        return nil, fmt.Errorf("користувача не знайдено")
    }
    if err != nil {
        return nil, fmt.Errorf("помилка запиту: %w", err)
    }
    
    return user, nil
}

// database/sql — потрібно явно вказати кожне поле
err := db.QueryRow(query, id).Scan(
    &user.ID,
    &user.Email,
    &user.PasswordHash,
    &user.FullName,
    &user.CreatedAt,
)

// sqlx — автоматичне відображення за тегами db
err := db.Get(user, query, id)

func (r *UserRepository) GetAll(ctx context.Context) ([]*User, error) {
    var users []*User
    query := `SELECT id, email, password_hash, full_name, created_at FROM users ORDER BY id`
    
    // Автоматичне заповнення слайсу
    if err := r.db.SelectContext(ctx, &users, query); err != nil {
        return nil, fmt.Errorf("помилка запиту: %w", err)
    }
    
    return users, nil
}

type UserFilter struct {
    MinAge int    `db:"min_age"`
    City   string `db:"city"`
}

filter := UserFilter{MinAge: 18, City: "Київ"}

var users []User
query := `SELECT * FROM users WHERE age >= :min_age AND city = :city`

// Іменовані параметри замість $1, $2
err := db.NamedQuery(query, filter)

func (r *UserRepository) TransferBalance(ctx context.Context, fromID, toID int, amount float64) error {
    // Початок транзакції
    tx, err := r.db.BeginTx(ctx, nil)
    if err != nil {
        return fmt.Errorf("не вдалося почати транзакцію: %w", err)
    }
    
    // Відкат транзакції у разі помилки
    defer func() {
        if p := recover(); p != nil {
            tx.Rollback()
            panic(p) // Повторно викинути panic після відкату
        } else if err != nil {
            tx.Rollback()
        }
    }()
    
    // Крок 1: Зняти гроші з рахунку fromID
    _, err = tx.ExecContext(ctx,
        "UPDATE accounts SET balance = balance - $1 WHERE user_id = $2",
        amount, fromID,
    )
    if err != nil {
        return fmt.Errorf("помилка зняття коштів: %w", err)
    }
    
    // Крок 2: Додати гроші на рахунок toID
    _, err = tx.ExecContext(ctx,
        "UPDATE accounts SET balance = balance + $1 WHERE user_id = $2",
        amount, toID,
    )
    if err != nil {
        return fmt.Errorf("помилка додавання коштів: %w", err)
    }
    
    // Підтвердження транзакції
    if err = tx.Commit(); err != nil {
        return fmt.Errorf("помилка підтвердження транзакції: %w", err)
    }
    
    return nil
}

func (r *Repository) DoSomethingTransactional(ctx context.Context) (err error) {
    tx, err := r.db.BeginTx(ctx, nil)
    if err != nil {
        return err
    }
    
    // Відкочуємо транзакцію у разі помилки
    defer func() {
        if err != nil {
            tx.Rollback()
        }
    }()
    
    // Виконуємо операції через tx
    if err = r.step1(ctx, tx); err != nil {
        return err
    }
    
    if err = r.step2(ctx, tx); err != nil {
        return err
    }
    
    // Підтверджуємо транзакцію
    return tx.Commit()
}

migrate create -ext sql -dir migrations -seq create_users_table

migrations/
├── 000001_create_users_table.up.sql
└── 000001_create_users_table.down.sql

CREATE TABLE users (
    id SERIAL PRIMARY KEY,
    email VARCHAR(255) UNIQUE NOT NULL,
    password_hash VARCHAR(255) NOT NULL,
    full_name VARCHAR(255) NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

CREATE INDEX idx_users_email ON users(email);

DROP INDEX IF EXISTS idx_users_email;
DROP TABLE IF EXISTS users;

migrate -path migrations \
  -database "postgres://appuser:secretpass@localhost:5432/myapp_db?sslmode=disable" \
  up

000001_create_users_table.up.sql ... OK (25ms)

SELECT * FROM schema_migrations;

migrate -path migrations \
  -database "..." \
  down 1

migrate -path migrations -database "..." down

package main

import (
    "database/sql"
    "embed"
    "log"
    
    "github.com/golang-migrate/migrate/v4"
    "github.com/golang-migrate/migrate/v4/database/postgres"
    "github.com/golang-migrate/migrate/v4/source/iofs"
    _ "github.com/jackc/pgx/v5/stdlib"
)

//go:embed migrations/*.sql
var migrationsFS embed.FS

func runMigrations(db *sql.DB) error {
    driver, err := postgres.WithInstance(db, &postgres.Config{})
    if err != nil {
        return err
    }
    
    source, err := iofs.New(migrationsFS, "migrations")
    if err != nil {
        return err
    }
    
    m, err := migrate.NewWithInstance("iofs", source, "postgres", driver)
    if err != nil {
        return err
    }
    
    if err := m.Up(); err != nil && err != migrate.ErrNoChange {
        return err
    }
    
    log.Println("✅ Міграції застосовано")
    return nil
}

query := "INSERT INTO users (email, full_name) VALUES ($1, $2) RETURNING id"
err := db.QueryRow(query, user.Email, user.FullName).Scan(&user.ID)

db.Create(&user) // Автоматично генерує INSERT та присвоює ID

package main

import (
    "log"
    
    "gorm.io/driver/postgres"
    "gorm.io/gorm"
)

func main() {
    dsn := "host=localhost user=appuser password=secretpass dbname=myapp_db port=5432 sslmode=disable"
    
    db, err := gorm.Open(postgres.Open(dsn), &gorm.Config{})
    if err != nil {
        log.Fatalf("Не вдалося підключитися до бази даних: %v", err)
    }
    
    log.Println("✅ Підключення до PostgreSQL через GORM успішне")
}

package model

import (
    "time"
    "gorm.io/gorm"
)

type User struct {
    ID           uint           `gorm:"primaryKey"`
    Email        string         `gorm:"uniqueIndex;not null"`
    PasswordHash string         `gorm:"not null"`
    FullName     string         `gorm:"not null"`
    CreatedAt    time.Time
    UpdatedAt    time.Time
    DeletedAt    gorm.DeletedAt `gorm:"index"` // Soft Delete
}

// TableName перевизначає назву таблиці (за замовчуванням: "users")
func (User) TableName() string {
    return "users"
}

func main() {
    db, _ := gorm.Open(postgres.Open(dsn), &gorm.Config{})
    
    // Автоматично створити/оновити таблицю users
    if err := db.AutoMigrate(&model.User{}); err != nil {
        log.Fatalf("Помилка міграції: %v", err)
    }
    
    log.Println("✅ Міграція виконана")
}

user := model.User{
    Email:        "alice@example.com",
    PasswordHash: "hashed_password",
    FullName:     "Alice Johnson",
}

result := db.Create(&user)

if result.Error != nil {
    log.Printf("Помилка створення користувача: %v", result.Error)
} else {
    log.Printf("✅ Створено користувача з ID: %d", user.ID)
}

var user model.User
result := db.First(&user, 1) // WHERE id = 1

if result.Error == gorm.ErrRecordNotFound {
    log.Println("Користувача не знайдено")
} else if result.Error != nil {
    log.Printf("Помилка запиту: %v", result.Error)
} else {
    log.Printf("Знайдено: %s (%s)", user.FullName, user.Email)
}

var user model.User
db.Where("email = ?", "alice@example.com").First(&user)

var users []model.User
db.Find(&users)

for _, u := range users {
    log.Printf("ID: %d, Email: %s", u.ID, u.Email)
}

var users []model.User
db.Where("created_at > ?", time.Now().AddDate(0, -1, 0)).
   Order("created_at DESC").
   Limit(10).
   Find(&users)

user.FullName = "Alice Smith"
db.Save(&user) // UPDATE users SET full_name = ..., updated_at = ... WHERE id = ...

db.Model(&user).Update("full_name", "Alice Cooper")

// Або кілька полів:
db.Model(&user).Updates(map[string]interface{}{
    "full_name": "Alice Cooper",
    "email":     "alice.cooper@example.com",
})

db.Delete(&user) // DELETE FROM users WHERE id = ...

db.Delete(&user) // UPDATE users SET deleted_at = NOW() WHERE id = ...

db.Find(&users) // Не включає записи з непустим deleted_at

db.Unscoped().Find(&users) // Включає видалені

type User struct {
    ID      uint
    Email   string
    Profile Profile // Зв'язок 1:1
}

type Profile struct {
    ID      uint
    UserID  uint   // Зовнішній ключ
    Bio     string
    AvatarURL string
}

// Завантаження користувача з профілем:
var user User
db.Preload("Profile").First(&user, 1)
log.Println(user.Profile.Bio)

type User struct {
    ID    uint
    Email string
    Posts []Post // Зв'язок 1:N
}

type Post struct {
    ID     uint
    UserID uint
    Title  string
    Body   string
}

// Завантаження користувача з усіма постами:
var user User
db.Preload("Posts").First(&user, 1)

for _, post := range user.Posts {
    log.Println(post.Title)
}

type Student struct {
    ID      uint
    Name    string
    Courses []Course `gorm:"many2many:student_courses;"` // Зв'язок N:M
}

type Course struct {
    ID       uint
    Title    string
    Students []Student `gorm:"many2many:student_courses;"` // Зворотний зв'язок
}

// GORM автоматично створить проміжну таблицю student_courses:
// CREATE TABLE student_courses (
//     student_id INTEGER,
//     course_id INTEGER,
//     PRIMARY KEY (student_id, course_id)
// );

// Створення студента з курсами:
student := Student{
    Name: "Іван Петренко",
    Courses: []Course{
        {Title: "Бази даних"},
        {Title: "Алгоритми"},
    },
}
db.Create(&student)

// Завантаження студента з усіма курсами:
var loadedStudent Student
db.Preload("Courses").First(&loadedStudent, student.ID)

for _, course := range loadedStudent.Courses {
    log.Println(course.Title)
}

// Додавання студента до існуючого курсу:
var course Course
db.First(&course, 1)
db.Model(&course).Association("Students").Append(&student)

type User struct {
    ID           uint
    Email        string
    Password     string `gorm:"-"` // Не зберігати у БД
    PasswordHash string
}

// BeforeCreate викликається перед INSERT
func (u *User) BeforeCreate(tx *gorm.DB) error {
    if u.Password == "" {
        return fmt.Errorf("пароль не може бути порожнім")
    }
    
    hash, err := bcrypt.GenerateFromPassword([]byte(u.Password), bcrypt.DefaultCost)
    if err != nil {
        return err
    }
    
    u.PasswordHash = string(hash)
    u.Password = "" // Очищаємо відкритий пароль
    
    return nil
}

// BeforeUpdate викликається перед UPDATE
func (u *User) BeforeUpdate(tx *gorm.DB) error {
    // Якщо пароль змінено, перехешуємо
    if u.Password != "" {
        hash, err := bcrypt.GenerateFromPassword([]byte(u.Password), bcrypt.DefaultCost)
        if err != nil {
            return err
        }
        u.PasswordHash = string(hash)
        u.Password = ""
    }
    return nil
}

// Використання:
user := User{
    Email:    "john@example.com",
    Password: "mySecretPassword",
}

db.Create(&user) // BeforeCreate автоматично хешує пароль

type Article struct {
    ID        uint
    Title     string
    Content   string
    UpdatedBy string
}

func (a *Article) AfterUpdate(tx *gorm.DB) error {
    log.Printf("📝 Стаття '%s' оновлена користувачем %s", a.Title, a.UpdatedBy)
    
    // Можна записати у таблицю аудиту:
    audit := AuditLog{
        EntityType: "Article",
        EntityID:   a.ID,
        Action:     "UPDATE",
        ChangedBy:  a.UpdatedBy,
        ChangedAt:  time.Now(),
    }
    return tx.Create(&audit).Error
}

type Model struct {
    Field Type `gorm:"тег1:значення;тег2:значення;тег3"`
}

type User struct {
    // Первинний ключ
    ID uint `gorm:"primaryKey"`
    
    // Композитний первинний ключ
    // ID   uint   `gorm:"primaryKey"`
    // Code string `gorm:"primaryKey"`
    
    // Автоінкремент (за замовчуванням для primaryKey)
    ID uint `gorm:"primaryKey;autoIncrement"`
    
    // Відключення автоінкременту
    UUID string `gorm:"primaryKey;autoIncrement:false"`
}

type Order struct {
    ID     uint
    UserID uint `gorm:"index"` // Створити індекс
    User   User `gorm:"foreignKey:UserID;references:ID"`
    // foreignKey вказує поле у Order, references — поле у User
}

type User struct {
    Email    string `gorm:"not null;unique"`           // NOT NULL + UNIQUE
    Username string `gorm:"not null;uniqueIndex"`      // NOT NULL + унікальний індекс
    Age      int    `gorm:"check:age >= 18"`           // CHECK обмеження
    Status   string `gorm:"default:'active'"`          // Значення за замовчуванням
    Role     string `gorm:"default:'user';not null"`   // Комбінація тегів
    
    // Іменований індекс
    Email2   string `gorm:"uniqueIndex:idx_email"`
    
    // Композитний індекс
    FirstName string `gorm:"index:idx_name,priority:1"` // Перше поле у індексі
    LastName  string `gorm:"index:idx_name,priority:2"` // Друге поле у індексі
}

type User struct {
    // Лише для читання (ігнорується при Create/Update)
    CreatedAt time.Time `gorm:"<-:false"`
    
    // Лише для запису (не повертається при запитах)
    Password string `gorm:"->:false;<-:create"` // Тільки при створенні
    
    // Повне ігнорування (не відображається на БД)
    TempField string `gorm:"-"`
    
    // Ігнорування при читанні, але запис дозволено
    APIKey string `gorm:"->;-:migration"` // - при міграції, -> для читання
    
    // Лише для створення
    InitialPassword string `gorm:"<-:create"`
    
    // Лише для оновлення
    UpdateToken string `gorm:"<-:update"`
}

type Model struct {
    // Автоматичне заповнення при створенні
    CreatedAt time.Time `gorm:"autoCreateTime"`
    
    // Автоматичне оновлення при Create/Update
    UpdatedAt time.Time `gorm:"autoUpdateTime"`
    
    // Unix timestamp замість time.Time
    CreatedUnix int64 `gorm:"autoCreateTime:nano"` // Наносекунди
    UpdatedUnix int64 `gorm:"autoUpdateTime:milli"` // Мілісекунди
    
    // Soft Delete
    DeletedAt gorm.DeletedAt `gorm:"index"`
}

type User struct {
    Name  string `gorm:"comment:Повне ім'я користувача"`
    Email string `gorm:"comment:Email адреса для зв'язку"`
    Age   int    `gorm:"comment:Вік користувача в роках"`
}

// У PostgreSQL згенерує:
// COMMENT ON COLUMN users.name IS 'Повне ім''я користувача';

type User struct {
    Name       string
    Attributes map[string]interface{} `gorm:"serializer:json"` // Зберігається як JSON
    Metadata   Metadata              `gorm:"serializer:json"`
}

type Metadata struct {
    Theme    string
    Language string
}

// При збереженні:
user := User{
    Name: "Alice",
    Attributes: map[string]interface{}{
        "age": 25,
        "city": "Київ",
    },
    Metadata: Metadata{Theme: "dark", Language: "uk"},
}
db.Create(&user)
// У БД: attributes = '{"age":25,"city":"Київ"}'

type BaseModel struct {
    ID        uint `gorm:"primaryKey"`
    CreatedAt time.Time
    UpdatedAt time.Time
}

type User struct {
    BaseModel        // Вбудована структура (усі поля стають полями User)
    Email     string `gorm:"unique"`
    Name      string
}

type Article struct {
    BaseModel
    Title   string
    Content string
}

// У БД створяться таблиці:
// users: id, created_at, updated_at, email, name
// articles: id, created_at, updated_at, title, content

type Address struct {
    Street  string
    City    string
    ZipCode string
}

type User struct {
    ID              uint
    Name            string
    HomeAddress     Address `gorm:"embedded;embeddedPrefix:home_"`
    WorkAddress     Address `gorm:"embedded;embeddedPrefix:work_"`
}

// У БД таблиця users міститиме:
// id, name,
// home_street, home_city, home_zip_code,
// work_street, work_city, work_zip_code

type User struct {
    ID      uint
    Name    string
    Address Address `gorm:"embedded"` // Без префіксу
}

// У БД: id, name, street, city, zip_code

type Timestamps struct {
    CreatedAt time.Time
    UpdatedAt time.Time
}

type User struct {
    ID         uint
    Email      string
    Timestamps // Автоматично вбудовується
}

// Еквівалентно:
type User struct {
    ID        uint
    Email     string
    CreatedAt time.Time
    UpdatedAt time.Time
}

type Audit struct {
    CreatedBy uint
    UpdatedBy uint
}

type Timestamps struct {
    CreatedAt time.Time
    UpdatedAt time.Time
    Audit     // Вкладене вбудовування
}

type Article struct {
    ID         uint
    Title      string
    Timestamps // Усі поля Audit та Timestamps стають полями Article
}

// У БД: id, title, created_at, updated_at, created_by, updated_by

type User struct {
    ID   uint
    Name string
}

func (User) TableName() string {
    return "app_users" // Таблиця називатиметься app_users
}

type ShardedUser struct {
    ID   uint
    Name string
}

func (u ShardedUser) TableName() string {
    // Шардування за ID
    shard := u.ID % 10
    return fmt.Sprintf("users_shard_%d", shard)
}

// Використання:
user := ShardedUser{ID: 42, Name: "Alice"}
db.Table(user.TableName()).Create(&user)
// INSERT INTO users_shard_2 ...

db, err := gorm.Open(postgres.Open(dsn), &gorm.Config{
    NamingStrategy: schema.NamingStrategy{
        TablePrefix:   "app_",           // Префікс для всіх таблиць
        SingularTable: true,             // Не використовувати множину
        NoLowerCase:   false,            // Використовувати CamelCase замість snake_case
    },
})

// User → app_user (замість users)
// BlogPost → app_blogpost (замість blog_posts)

internal/
├── domain/
│   └── user.go          # Доменна модель (без залежностей від БД)
├── repository/
│   ├── interface.go     # Інтерфейс репозиторію
│   ├── postgres/
│   │   └── user_repository.go  # Реалізація через pgx
│   └── gorm/
│       └── user_repository.go  # Реалізація через GORM
└── usecase/
    └── user_service.go   # Бізнес-логіка (використовує інтерфейс)

package repository

import (
    "context"
    "myapp/internal/domain"
)

type UserRepository interface {
    Create(ctx context.Context, user *domain.User) error
    GetByID(ctx context.Context, id int) (*domain.User, error)
    GetByEmail(ctx context.Context, email string) (*domain.User, error)
    Update(ctx context.Context, user *domain.User) error
    Delete(ctx context.Context, id int) error
    List(ctx context.Context, limit, offset int) ([]*domain.User, error)
}

package postgres

import (
    "context"
    "database/sql"
    "myapp/internal/domain"
    "myapp/internal/repository"
)

type userRepository struct {
    db *sql.DB
}

func NewUserRepository(db *sql.DB) repository.UserRepository {
    return &userRepository{db: db}
}

func (r *userRepository) Create(ctx context.Context, user *domain.User) error {
    query := `INSERT INTO users (email, password_hash, full_name) 
              VALUES ($1, $2, $3) RETURNING id`
    return r.db.QueryRowContext(ctx, query,
        user.Email, user.PasswordHash, user.FullName,
    ).Scan(&user.ID)
}

// ... інші методи

package gormrepo

import (
    "context"
    "myapp/internal/domain"
    "myapp/internal/repository"
    "gorm.io/gorm"
)

type userRepository struct {
    db *gorm.DB
}

func NewUserRepository(db *gorm.DB) repository.UserRepository {
    return &userRepository{db: db}
}

func (r *userRepository) Create(ctx context.Context, user *domain.User) error {
    return r.db.WithContext(ctx).Create(user).Error
}

// ... інші методи

package usecase

import (
    "context"
    "myapp/internal/domain"
    "myapp/internal/repository"
)

type UserService struct {
    repo repository.UserRepository
}

func NewUserService(repo repository.UserRepository) *UserService {
    return &UserService{repo: repo}
}

func (s *UserService) RegisterUser(ctx context.Context, email, password, fullName string) (*domain.User, error) {
    // Перевірка, чи користувач вже існує
    existing, _ := s.repo.GetByEmail(ctx, email)
    if existing != nil {
        return nil, errors.New("користувач з таким email вже існує")
    }
    
    // Хешування пароля
    hash, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
    if err != nil {
        return nil, err
    }
    
    // Створення користувача
    user := &domain.User{
        Email:        email,
        PasswordHash: string(hash),
        FullName:     fullName,
    }
    
    if err := s.repo.Create(ctx, user); err != nil {
        return nil, err
    }
    
    return user, nil
}

// Одна умова
db.Where("email = ?", "alice@example.com").First(&user)
// SELECT * FROM users WHERE email = 'alice@example.com' LIMIT 1

// Кілька параметрів
db.Where("age > ? AND city = ?", 18, "Київ").Find(&users)
// SELECT * FROM users WHERE age > 18 AND city = 'Київ'

// IN умова
db.Where("status IN ?", []string{"active", "pending"}).Find(&users)
// SELECT * FROM users WHERE status IN ('active', 'pending')

// LIKE пошук
db.Where("name LIKE ?", "%Іван%").Find(&users)
// SELECT * FROM users WHERE name LIKE '%Іван%'

// BETWEEN
db.Where("created_at BETWEEN ? AND ?", startDate, endDate).Find(&orders)

// Рівність (лише ненульові поля)
db.Where(&User{Name: "Alice", Age: 25}).Find(&users)
// SELECT * FROM users WHERE name = 'Alice' AND age = 25

// Нульові значення ігноруються!
db.Where(&User{Name: "Alice", Age: 0}).Find(&users)
// SELECT * FROM users WHERE name = 'Alice'
// Age = 0 не включено у запит

// Map дозволяє шукати за нульовими значеннями
db.Where(map[string]interface{}{
    "name": "Alice",
    "age":  0, // Нуль враховується!
}).Find(&users)
// SELECT * FROM users WHERE name = 'Alice' AND age = 0