PostgreSQL Performance & Query Optimization · Lección

Cuándo y cómo crear índices

Aprenda las prácticas recomendadas para decidir qué columnas indexar y evitar un exceso de índices.

Cuándo y cómo crear índices es una lección gratuita de PostgreSQL Performance & Query Optimization en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de PostgreSQL Performance & Query Optimization, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de PostgreSQL Performance & Query Optimization incluye 4 lecciones en total.

Partes de esta lección aún no han sido traducidas y se muestran en inglés.

Smart Indexing Starts Here

Indexes are powerful tools for speeding up PostgreSQL queries. But they aren't magic, and blindly adding them can actually hurt performance!

In this lesson, we'll learn the art of smart indexing: when to create indexes, what types to use, and how to avoid common pitfalls like over-indexing.

Indexing Your WHERE Clause

The most common reason to create an index is to speed up searches in your WHERE clauses. If you frequently filter data based on a specific column, an index on that column can dramatically reduce query time.

Think of it like an alphabetical index in a book. Instead of scanning every page, you go straight to the relevant section.

CREATE TABLE users (
  id SERIAL PRIMARY KEY,
  email VARCHAR(255) UNIQUE,
  name VARCHAR(255)
);
INSERT INTO users (email, name) VALUES
('alice@example.com', 'Alice'),
('bob@example.com', 'Bob'),
('charlie@example.com', 'Charlie');

-- To make this query fast, index 'email'
-- CREATE INDEX idx_users_email ON users (email);
SELECT * FROM users WHERE email = 'alice@example.com';

Indexes for JOINs and ORDER BY

Indexes don't just help with filtering; they're also crucial for efficient JOIN operations and sorting results with ORDER BY. When joining two tables, an index on the join columns helps PostgreSQL quickly match rows.

Similarly, an index on columns used in ORDER BY can allow PostgreSQL to retrieve sorted data directly, avoiding a costly sort operation.

CREATE TABLE customers (
  id SERIAL PRIMARY KEY,
  name VARCHAR(255)
);
CREATE TABLE orders (
  id SERIAL PRIMARY KEY,
  customer_id INT,
  order_date DATE
);
INSERT INTO customers (name) VALUES ('Alice'), ('Bob');
INSERT INTO orders (customer_id, order_date) VALUES
(1, '2023-01-01'), (2, '2023-01-02'), (1, '2023-01-05');

-- To speed up this query, index customer_id and order_date
-- CREATE INDEX idx_orders_customer_id ON orders (customer_id);
-- CREATE INDEX idx_orders_order_date ON orders (order_date);
SELECT c.name, o.order_date
FROM orders o
JOIN customers c ON o.customer_id = c.id
ORDER BY o.order_date DESC;

Cardinality: More Unique Values, Better

Cardinality refers to the number of unique values in a column. Columns with high cardinality (many unique values, like user_id or email) are generally excellent candidates for indexing.

An index on a low cardinality column (few unique values, like a boolean flag or gender) is often less effective because the database might still have to scan a large portion of the table.

Multi-Column Indexes: Order Matters

Sometimes, your queries filter or sort on multiple columns. A multi-column (or composite) index can cover these cases. The order of columns in a composite index is crucial due to the "left-most prefix" rule.

An index on (A, B, C) can help queries on A, (A, B), or (A, B, C).
It generally won't help queries only on B, C, or (B, C).

CREATE TABLE products (
  id SERIAL PRIMARY KEY,
  category VARCHAR(50),
  price DECIMAL(10, 2),
  color VARCHAR(20)
);
INSERT INTO products (category, price, color) VALUES
('Electronics', 599.99, 'Black'),
('Books', 25.00, 'Red'),
('Electronics', 120.00, 'Silver');

-- Create a multi-column index
CREATE INDEX idx_prod_cat_price ON products (category, price);

-- This query uses the index efficiently
SELECT * FROM products
WHERE category = 'Electronics' AND price > 100;

Partial Indexes: Targeting Subsets

A partial index is an index created on a subset of rows in a table, defined by a WHERE clause. This can make the index smaller, faster to maintain, and more efficient for queries that only target that specific subset of data.

It's perfect for tables where only a small percentage of rows are frequently queried in a specific way (e.g., "active" users, "pending" tasks).

CREATE TABLE tasks (
  id SERIAL PRIMARY KEY,
  status VARCHAR(20),
  due_date DATE
);
INSERT INTO tasks (status, due_date) VALUES
('pending', '2023-12-31'),
('completed', '2023-11-15'),
('pending', '2024-01-31'),
('archived', '2023-10-01');

-- Index only pending tasks, smaller and faster
CREATE INDEX idx_pending_tasks ON tasks (due_date) WHERE status = 'pending';

-- This query uses the partial index
SELECT * FROM tasks WHERE status = 'pending' AND due_date < '2024-01-01';

Expression Indexes: Computed Values

An expression index allows you to create an index on the result of a function or expression, rather than just a raw column value. This is incredibly useful for queries that transform data before comparison.

Common uses include case-insensitive searches (using LOWER() or UPPER()) or indexing parts of a string or date.

CREATE TABLE contacts (
  id SERIAL PRIMARY KEY,
  email VARCHAR(255)
);
INSERT INTO contacts (email) VALUES
('JOHN.DOE@example.com'),
('jane.doe@example.com'),
('peter.smith@example.com');

-- Index for case-insensitive email searches
CREATE INDEX idx_email_lower ON contacts (LOWER(email));

-- This query uses the expression index
SELECT * FROM contacts WHERE LOWER(email) = 'john.doe@example.com';

When NOT to Index: The Pitfalls

Not every column needs an index. Here are some scenarios where indexes might not help, or even hurt performance:

Low Cardinality: Columns with very few unique values (e.g., a boolean is_active flag) often don't benefit much.
Small Tables: For tables with only a few hundred rows, a full table scan is often faster than an index lookup.
Infrequently Queried Columns: If a column is rarely used in WHERE, JOIN, or ORDER BY clauses, an index is probably unnecessary.

Avoiding Over-Indexing

It's tempting to index everything, but over-indexing is a real problem. Each index comes with overhead:

Write Performance: Every INSERT, UPDATE, or DELETE operation must also update all relevant indexes, slowing down writes.
Disk Space: Indexes consume disk space, sometimes significantly.
Query Planner Overhead: Too many indexes can confuse the query planner, making it harder for PostgreSQL to choose the optimal plan.

Aim for a balanced approach: index what's truly needed.

Index Best Practices

Which of the following scenarios are generally good candidates for creating an index in PostgreSQL?

Recap: Indexing Wisely

You've learned that indexing isn't about indexing everything, but about making strategic choices. Indexes are vital for speeding up WHERE, JOIN, and ORDER BY clauses, especially on columns with high cardinality.

Remember to consider partial and expression indexes for specific needs, and always be mindful of the costs of over-indexing. The goal is to optimize reads without unduly sacrificing write performance or consuming excessive resources.

Preguntas frecuentes

¿La lección «Cuándo y cómo crear índices» es gratis?

Sí — el texto completo de «Cuándo y cómo crear índices» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de PostgreSQL Performance & Query Optimization, actualiza a CoddyKit PRO. El curso de PostgreSQL Performance & Query Optimization incluye 4 lecciones en total.

¿Qué aprenderé en «Cuándo y cómo crear índices»?

Aprenda las prácticas recomendadas para decidir qué columnas indexar y evitar un exceso de índices. Practicas PostgreSQL Performance & Query Optimization con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar PostgreSQL Performance & Query Optimization?

No se requiere experiencia previa. PostgreSQL Performance & Query Optimization en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.

¿Cuánto tiempo toma la lección «Cuándo y cómo crear índices»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de PostgreSQL Performance & Query Optimization?

Sí. Cada lección de PostgreSQL Performance & Query Optimization incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a PostgreSQL Performance & Query Optimization