Індекс на колонці email:
─────────────────────────────────────
| Email                 | Row ID    |
|----------------------|-----------|
| admin@example.com    | Row 42    |
| john@example.com     | Row 1     |
| user@example.com     | Row 15    |
| zara@example.com     | Row 89    |
─────────────────────────────────────

-- Без індексу: Sequential Scan (повільно)
SELECT * FROM users WHERE email = 'user@example.com';
-- Читає всі рядки таблиці

-- З індексом на email: Index Scan (швидко)
-- Використовує індекс для прямого переходу до потрібного рядка

-- Foreign key posts.author_id має індекс автоматично
SELECT * FROM posts
JOIN users ON posts.author_id = users.id
WHERE users.email = 'user@example.com';
-- Індекс на author_id прискорює JOIN

-- З індексом на created_at: дані вже відсортовані
SELECT * FROM posts ORDER BY created_at DESC LIMIT 10;
-- БД читає з індексу вже відсортовані записи

INSERT INTO users (email, name) VALUES ('new@example.com', 'New User');

UPDATE users SET email = 'updated@example.com' WHERE id = 1;

DELETE FROM users WHERE id = 1;

@Index()
@Column()
email: string;
// Створює B-Tree індекс

CREATE INDEX idx_users_email ON users USING BTREE (email);

CREATE INDEX idx_users_email_hash ON users USING HASH (email);

CREATE INDEX idx_locations_geo ON locations USING GIST (coordinates);

@Index('idx_posts_search', { synchronize: false }) // Створюється вручну через міграцію
@Column({ type: 'tsvector' })
searchVector: string;

CREATE INDEX idx_posts_search ON posts USING GIN (to_tsvector('english', title || ' ' || content));

import { Entity, PrimaryGeneratedColumn, Column, Index } from 'typeorm';

@Entity('users')
export class User {
  @PrimaryGeneratedColumn()
  id: number;

  @Index() // ✅ Створює індекс на колонці email
  @Column()
  email: string;

  @Index() // ✅ Створює індекс на колонці created_at
  @Column()
  createdAt: Date;
}

CREATE INDEX "IDX_users_email" ON "users" ("email");
CREATE INDEX "IDX_users_createdAt" ON "users" ("created_at");

@Index('idx_user_email') // Кастомна назва
@Column()
email: string;

CREATE INDEX "idx_user_email" ON "users" ("email");

@Entity('users')
@Index('idx_users_email_name', ['email', 'name']) // Складений індекс
@Index('idx_users_active', ['isActive']) // Простий індекс
export class User {
  @PrimaryGeneratedColumn()
  id: number;

  @Column()
  email: string;

  @Column()
  name: string;

  @Column()
  isActive: boolean;
}

CREATE INDEX "idx_users_email_name" ON "users" ("email", "name");
CREATE INDEX "idx_users_active" ON "users" ("is_active");

@Index()
@Column()
email: string;

@Entity('posts')
export class Post {
  @PrimaryGeneratedColumn()
  id: number;

  @ManyToOne(() => User, (user) => user.posts)
  @JoinColumn({ name: 'author_id' })
  author: User;
  // TypeORM автоматично створить індекс на author_id
}

CREATE TABLE posts (
    id SERIAL PRIMARY KEY,
    author_id INTEGER NOT NULL,
    CONSTRAINT fk_posts_author FOREIGN KEY (author_id) REFERENCES users(id)
);

CREATE INDEX "IDX_posts_author_id" ON "posts" ("author_id"); -- Автоматично

@Entity('users')
@Unique(['email']) // Унікальний constraint на email
export class User {
  @PrimaryGeneratedColumn()
  id: number;

  @Column()
  email: string;
}

ALTER TABLE "users" ADD CONSTRAINT "UQ_users_email" UNIQUE ("email");

@Column({ unique: true })
email: string;

ALTER TABLE "users" ADD CONSTRAINT "UQ_users_email" UNIQUE ("email");

@Entity('enrollments')
@Unique(['studentId', 'courseId']) // Студент не може зареєструватися на курс двічі
export class Enrollment {
  @PrimaryGeneratedColumn()
  id: number;

  @Column()
  studentId: number;

  @Column()
  courseId: number;

  @Column()
  grade: number;
}

ALTER TABLE "enrollments" ADD CONSTRAINT "UQ_enrollments_studentId_courseId" UNIQUE ("student_id", "course_id");

// Перша реєстрація — OK
await enrollmentRepository.save({ studentId: 1, courseId: 5, grade: null });

// Друга реєстрація на той самий курс — ERROR
await enrollmentRepository.save({ studentId: 1, courseId: 5, grade: null });
// QueryFailedError: duplicate key value violates unique constraint "UQ_enrollments_studentId_courseId"

@Entity('posts')
@Index('idx_posts_author_status', ['authorId', 'status'])
export class Post {
  @PrimaryGeneratedColumn()
  id: number;

  @Column()
  authorId: number;

  @Column()
  status: string; // 'draft', 'published', 'archived'

  @Column()
  title: string;
}

CREATE INDEX "idx_posts_author_status" ON "posts" ("author_id", "status");

-- ✅ Використовує індекс (обидві колонки)
SELECT * FROM posts WHERE author_id = 1 AND status = 'published';

-- ✅ Використовує індекс (тільки author_id)
SELECT * FROM posts WHERE author_id = 1;

-- ❌ НЕ використовує індекс (тільки status)
SELECT * FROM posts WHERE status = 'published';

@Index('idx_orders_user_status_date', ['userId', 'status', 'createdAt'])

-- ✅ Використовує індекс
WHERE userId = 1
WHERE userId = 1 AND status = 'pending'
WHERE userId = 1 AND status = 'pending' AND createdAt > '2026-01-01'

-- ❌ НЕ використовує індекс
WHERE status = 'pending'
WHERE createdAt > '2026-01-01'
WHERE status = 'pending' AND createdAt > '2026-01-01'

// Частий запит
const activeUsers = await userRepository.find({
  where: { isActive: true },
});

// Рішення: створити індекс
@Index()
@Column()
isActive: boolean;

// JOIN на email
const posts = await postRepository
  .createQueryBuilder('post')
  .leftJoin('post.author', 'author', 'author.email = :email', { email: 'user@example.com' })
  .getMany();

// Рішення: індекс на email
@Index()
@Column()
email: string;

// Запит з сортуванням
const recentPosts = await postRepository.find({
  order: { createdAt: 'DESC' },
  take: 10,
});

// Рішення: індекс на createdAt
@Index()
@Column()
createdAt: Date;

@ManyToOne(() => User)
@JoinColumn({ name: 'author_id' })
author: User;
// Індекс на author_id створюється автоматично

// Топ-3 найчастіші запити (з логів):
// 1. SELECT * FROM users WHERE email = ?
// 2. SELECT * FROM posts WHERE status = 'published' AND author_id = ?
// 3. SELECT * FROM orders WHERE user_id = ? ORDER BY created_at DESC

// Рішення:
@Index() email: string;
@Index(['status', 'authorId']) // Composite
@Index(['userId', 'createdAt']) // Composite для ORDER BY

// Таблиця roles має лише 5 рядків ('admin', 'editor', 'viewer', 'guest', 'superadmin')
@Entity('roles')
export class Role {
  @PrimaryGeneratedColumn()
  id: number;

  @Column() // ❌ Індекс не потрібен — таблиця мала
  name: string;
}

@Column()
gender: 'male' | 'female' | 'other'; // Лише 3 можливі значення
// ❌ Індекс майже не дасть ефекту

@Index('idx_posts_author', ['authorId']) // Індекс 1
@Index('idx_posts_author_status', ['authorId', 'status']) // Індекс 2

EXPLAIN SELECT * FROM users WHERE email = 'user@example.com';

Seq Scan on users  (cost=0.00..18.50 rows=1 width=100)
  Filter: (email = 'user@example.com'::text)

EXPLAIN ANALYZE SELECT * FROM users WHERE email = 'user@example.com';

Index Scan using idx_users_email on users  (cost=0.29..8.31 rows=1 width=100) (actual time=0.025..0.026 rows=1 loops=1)
  Index Cond: (email = 'user@example.com'::text)
Planning Time: 0.102 ms
Execution Time: 0.045 ms

-- Sequential Scan (погано)
Seq Scan on posts  (cost=0.00..1500.00 rows=50000 width=200)
  Filter: (status = 'published')

-- Index Scan (добре)
Index Scan using idx_posts_status on posts  (cost=0.42..100.00 rows=5000 width=200)
  Index Cond: (status = 'published')

const result = await dataSource.query(`
  EXPLAIN ANALYZE
  SELECT * FROM posts WHERE status = 'published'
`);
console.log(result);

Seq Scan  (cost=0.00..1500.00)  ❌ Повільно
Index Scan (cost=0.42..100.00) ✅ Швидко

actual time=0.025..0.026 rows=1 loops=1

// ❌ ПОГАНО: N+1 Problem
const users = await userRepository.find(); // 1 запит: SELECT * FROM users

for (const user of users) {
  const posts = await postRepository.find({ where: { authorId: user.id } }); // N запитів!
  console.log(`${user.name} має ${posts.length} постів`);
}

// Якщо users.length = 100, виконається 101 запит!

-- Запит 1
SELECT * FROM users;

-- Запит 2 (для user 1)
SELECT * FROM posts WHERE author_id = 1;

-- Запит 3 (для user 2)
SELECT * FROM posts WHERE author_id = 2;

-- ... ще 98 запитів

// ✅ ДОБРЕ: Один запит з JOIN
const users = await userRepository.find({
  relations: ['posts'],
});

for (const user of users) {
  console.log(`${user.name} має ${user.posts.length} постів`);
}

SELECT u.*, p.*
FROM users u
LEFT JOIN posts p ON p.author_id = u.id;

const users = await userRepository
  .createQueryBuilder('user')
  .leftJoinAndSelect('user.posts', 'post')
  .getMany();

// Завантажити користувачів лише з опублікованими постами
const users = await userRepository
  .createQueryBuilder('user')
  .leftJoinAndSelect('user.posts', 'post', 'post.status = :status', { status: 'published' })
  .getMany();

// ❌ ПОГАНО: Завантажує всі колонки (включно з великими TEXT полями)
const users = await userRepository.find();

// ✅ ДОБРЕ: Вибір лише потрібних полів
const users = await userRepository
  .createQueryBuilder('user')
  .select(['user.id', 'user.email', 'user.name'])
  .getMany();

const page = 1;
const limit = 20;

const [items, total] = await postRepository.findAndCount({
  skip: (page - 1) * limit,
  take: limit,
  order: { createdAt: 'DESC' },
});

return {
  items,
  total,
  page,
  pageCount: Math.ceil(total / limit),
};

// Entity екземпляри (повільно)
const users = await userRepository.find();

// Raw об'єкти (швидше)
const users = await userRepository
  .createQueryBuilder('user')
  .select(['user.id', 'user.name'])
  .getRawMany();

for (const post of posts) {
  await postRepository.update({ id: post.id }, { views: post.views + 1 });
}
// N запитів UPDATE

const ids = posts.map(p => p.id);
await postRepository.increment({ id: In(ids) }, 'views', 1);
// Один запит UPDATE WHERE id IN (...)