Теория: Установка и подключение к базе

Любая работа с GORM начинается с подключения к базе данных. Пока соединение не установлено, невозможно выполнить ни одну операцию: нельзя создать таблицу, сохранить запись или прочитать данные. Поэтому первым шагом становится установка самой библиотеки и драйвера для выбранной СУБД. В примерах удобно использовать PostgreSQL: эта база хорошо поддерживается GORM и часто встречается в реальных проектах, но тот же подход работает и для MySQL, SQLite и других систем.

GORM устроен как набор модулей. Основной пакет gorm.io/gorm содержит логику ORM: создание и миграцию таблиц, построение запросов, работу с хуками и транзакциями. Подключение к конкретной базе выполняет отдельный драйвер. Для PostgreSQL используется пакет gorm.io/driver``/postgres. Такая архитектура позволяет сохранять единый API и просто менять драйвер под нужную СУБД, не переписывая остальной код.

Установка выполняется стандартной командой Go. Достаточно добавить библиотеку и драйвер в зависимости проекта:

go get gorm.io/gorm
go get gorm.io/driver/postgres

После выполнения этих команд пакеты попадут в go.mod, а приложение сможет импортировать их и использовать в исходном коде. С этого момента GORM готов к подключению к базе.

Простейшее подключение к PostgreSQL можно оформить в отдельном файле main.go. Код будет выглядеть так:

package main

import (
	"log"

	"gorm.io/driver/postgres"
	"gorm.io/gorm"
)

func main() {
	// Строка подключения (DSN) с параметрами PostgreSQL
	dsn := "host=localhost user=postgres password=postgres dbname=testdb port=5432 sslmode=disable"

	// Открытие соединения через драйвер postgres и GORM
	db, err := gorm.Open(postgres.Open(dsn), &gorm.Config{})
	if err != nil {
		// Логирование ошибки подключения и завершение программы
		log.Fatalf("ошибка подключения к базе: %v", err)
	}

	// Если err == nil, соединение успешно установлено
	log.Println("Соединение с базой установлено")

	_ = db // объект *gorm.DB используется для всех дальнейших операций
}

В строке dsn (Data Source Name) задаются параметры подключения: хост, порт, пользователь, пароль, имя базы и режим SSL. Функция gorm.Open() открывает подключение через драйвер postgres и возвращает объект *gorm.DB. Этот объект становится основным входом в GORM: через него создаются таблицы, выполняются запросы и управляются транзакции.

После подключения сразу можно создать таблицу по структуре модели. GORM использует механизм миграций AutoMigrate() и по описанию структуры строит подходящую схему:

type User struct {
	ID   uint   // первичный ключ
	Name string // имя пользователя
}

func main() {
	dsn := "host=localhost user=postgres password=postgres dbname=testdb port=5432 sslmode=disable"

	db, err := gorm.Open(postgres.Open(dsn), &gorm.Config{})
	if err != nil {
		log.Fatalf("ошибка подключения к базе: %v", err)
	}

	// AutoMigrate создаёт таблицу users, если её ещё нет,
	// и обновляет схему при изменении структуры
	if err := db.AutoMigrate(&User{}); err != nil {
		log.Fatalf("ошибка миграции схемы: %v", err)
	}

	log.Println("Таблица users готова к работе")
}

В этом примере AutoMigrate() считывает поля структуры User и создаёт таблицу users с колонками id и name. При изменении структуры (например, при добавлении нового поля) GORM попытается аккуратно обновить схему. Такой механизм удобен на ранних этапах разработки, когда модель данных ещё активно меняется.

Чтобы понимать, какие запросы GORM выполняет на самом деле, важно включить логирование. Для этого используется пакет gorm.io/gorm/logger. Он выводит SQL, параметры, ошибки и время выполнения запросов. Пример настройки логгера через конфигурацию GORM выглядит так:

package main

import (
	"log"
	"time"

	"gorm.io/driver/postgres"
	"gorm.io/gorm"
	"gorm.io/gorm/logger"
)

func main() {
	dsn := "host=localhost user=postgres password=postgres dbname=testdb port=5432 sslmode=disable"

	// Создание нового логгера с настройками
	newLogger := logger.New(
		log.New(log.Writer(), "\r\n", log.LstdFlags), // базовый вывод в консоль
		logger.Config{
			SlowThreshold: time.Second, // порог для медленных запросов
			LogLevel:      logger.Info, // подробный уровень логирования
			Colorful:      true,        // цветной вывод для удобства
		},
	)

	// Подключение к базе с учётом настроенного логгера
	db, err := gorm.Open(postgres.Open(dsn), &gorm.Config{
		Logger: newLogger,
	})
	if err != nil {
		log.Fatalf("ошибка подключения к базе: %v", err)
	}

	log.Println("Подключение установлено, логгер активен")

	_ = db
}

В таком режиме при каждом запросе GORM будет печатать текст SQL, количество затронутых строк и время выполнения. Это помогает увидеть реальную картину нагрузки, найти медленные места и понять, как ORM строит запросы под капотом.

Помимо логирования, важную роль играет настройка пула соединений. GORM использует стандартный пакет database/sql и создаёт пул подключений к базе. Управление этим пулом выполняется через метод DB() объекта *gorm.DB:

sqlDB, err := db.DB()
if err != nil {
	log.Fatalf("ошибка доступа к пулу соединений: %v", err)
}

// Ping проверяет, что соединение живое и база отвечает
if err := sqlDB.Ping(); err != nil {
	log.Fatalf("ошибка пинга базы: %v", err)
}

// Максимальное число открытых соединений к базе
sqlDB.SetMaxOpenConns(10)

// Максимальное число простаивающих (неиспользуемых) соединений в пуле
sqlDB.SetMaxIdleConns(5)

// Максимальное время жизни соединения
sqlDB.SetConnMaxLifetime(time.Hour)

log.Println("Пул соединений настроен и готов к работе")

Такая настройка помогает удерживать баланс между производительностью и нагрузкой на базу. Пул не открывает бесконечное количество соединений и не держит их пожизненно, а работает по заданным ограничениям. В продакшене это особенно важно: правильные значения параметров позволяют выдерживать нагрузку и не исчерпывать ресурсы СУБД.

Дополнительные параметры GORM задаются через gorm.Config. Они позволяют тонко настроить поведение ORM. Например, можно отключить обёртку каждой операции в транзакцию и включить кэш подготовленных выражений:

db, err := gorm.Open(postgres.Open(dsn), &gorm.Config{
	SkipDefaultTransaction: true, // операции без автоматической транзакции
	PrepareStmt:            true, // кэширование подготовленных выражений
})
if err != nil {
	log.Fatalf("ошибка подключения к базе: %v", err)
}

SkipDefaultTransaction() ускоряет типовые операции, если транзакции контролируются на более высоком уровне. PrepareStmt() полезен в сервисах с повторяющимися запросами: подготовленные выражения переиспользуются, и база тратит меньше времени на разбор SQL.

Для проверки того, какой запрос GORM сформирует без реального выполнения, можно использовать сессию с параметром DryRun(). В этом режиме ORM строит SQL, но не отправляет его в базу:

type User struct {
	ID   uint
	Name string
}

tx := db.Session(&gorm.Session{
	DryRun: true, // режим генерации SQL без выполнения
})

// Формирование SELECT-запроса без обращения к базе
stmt := tx.First(&User{}, 1).Statement

// Вывод текста запроса
log.Println("Сформированный SQL:", stmt.SQL.String())

DryRun() подходит для отладки сложных цепочек запросов и помогает убедиться, что GORM строит именно тот SQL, который ожидается, ещё до взаимодействия с реальной базой.

В итоге для запуска GORM достаточно двух пакетов: основного gorm.io/gorm и драйвера для СУБД, например gorm.io/driver/postgres. Далее подключение к базе сводится к строке DSN и вызову gorm.Open(), логгер делает работу ORM прозрачной, а настройки пула соединений и конфигурации gorm.Config помогают держать поведение под контролем. Такой набор шагов создаёт надёжную основу, на которой уже можно строить модели, миграции и бизнес-логику.