1. Concepto y Aplicación de Índices

1.1 ¿Qué es un Índice?

Un índice es una estructura de datos utilizada en un sistema de gestión de bases de datos para acelerar las operaciones de recuperación de datos. Puede ser considerado como un "directorio" en la base de datos, permitiendo la rápida localización de datos en una tabla de datos, evitando exploraciones completas de la tabla y mejorando significativamente la eficiencia de las consultas. En aplicaciones prácticas, el uso correcto de índices puede mejorar considerablemente el rendimiento de una base de datos.

1.2 Tipos de Índices

Existen varios tipos de índices, cada uno con su propio diseño y optimización para diferentes escenarios de aplicación:

  • Índice de Campo Único: Un índice que incluye solo un campo, adecuado para escenarios que dependen de una sola condición para consultas rápidas.
  • Índice Compuesto: Un índice que incluye múltiples campos, optimizando consultas que contienen estos campos.
  • Índice Único: Garantiza la unicidad de los campos de índice, prohibiendo la existencia de valores duplicados. Los índices únicos pueden ser de campo único o compuestos.

2. Definición de Índices

2.1 Definición de Índice de Campo

Crear un índice de campo único implica establecer un índice en una columna específica de una tabla de datos, lo cual se puede lograr utilizando el método Fields. El siguiente ejemplo muestra cómo crear un índice en el campo phone de la entidad User.

func (User) Fields() []ent.Field {
    return []ent.Field{
        field.String("phone"),
    }
}
func (User) Indexes() []ent.Index {
    // Crear un índice de campo único.
    return []ent.Index{
        index.Fields("phone"),
    }
}

En este fragmento de código, se indexa el campo phone, lo que permite al sistema utilizar el índice para búsquedas más rápidas al consultar el campo phone.

2.2 Definición de Índice Único

Un índice único garantiza la unicidad de los datos en las columnas indexadas. Se puede crear agregando el método Unique al campo. Los siguientes ejemplos ilustran la creación de índices únicos para campos individuales y múltiples.

Crear un índice único para un campo único:

func (User) Fields() []ent.Field {
    return []ent.Field{
        field.String("email").Unique(),
    }
}

En este ejemplo, se especifica que el campo email es único, garantizando que el email de cada usuario sea único en la base de datos.

Crear un índice único para una combinación de múltiples campos:

func (User) Indexes() []ent.Index {
    return []ent.Index{
        // Crear un índice único para múltiples campos.
        index.Fields("first_name", "last_name").Unique(),
    }
}

Este código define un índice único compuesto para la combinación de los campos first_name y last_name, evitando la presencia de registros con los mismos valores en ambos campos.

2.3 Definición de Índice Compuesto

Cuando las condiciones de consulta involucran múltiples campos, puede ser útil un índice compuesto. El índice compuesto almacena datos en el orden definido en el índice. El orden del índice tiene un impacto significativo en el rendimiento de la consulta, por lo que al definir un índice compuesto, el orden de los campos debe determinarse en función del patrón de consulta.

Aquí hay un ejemplo de creación de un índice compuesto:

func (User) Indexes() []ent.Index {
    return []ent.Index{
        // Crear un índice compuesto con múltiples campos.
        index.Fields("country", "city"),
    }
}

En este ejemplo, se crea un índice compuesto en los campos country y city. Esto significa que al realizar operaciones de consulta que involucran estos dos campos, la base de datos puede ubicar rápidamente los datos que cumplen con las condiciones.

Un índice compuesto no solo acelera el rendimiento de consulta, sino que también admite operaciones de ordenación basadas en el índice, proporcionando un rendimiento de recuperación de datos más eficiente. Al diseñar un índice compuesto, es común colocar los campos con mayor selectividad al principio del índice para que el optimizador de la base de datos pueda utilizar mejor el índice.

3. Índices de Borde

En el framework ent, los índices de borde son una forma de definir índices a través de bordes (relaciones). Este mecanismo se utiliza típicamente para asegurar la unicidad de campos bajo relaciones específicas. Por ejemplo, si tu modelo de base de datos incluye ciudades y calles, y cada nombre de calle bajo una ciudad necesita ser único, se pueden utilizar índices de borde para lograr esto.

// El archivo ent/schema/street.go define el esquema de la entidad Street.
type Street struct {
    ent.Schema
}

func (Street) Fields() []ent.Field {
    // Define campos
    return []ent.Field{
        field.String("name"),
    }
}

func (Street) Edges() []ent.Edge {
    // Define la relación de borde con City, donde Street pertenece a una City.
    return []ent.Edge{
        edge.From("city", City.Type).
            Ref("streets").
            Unique(),
    }
}

func (Street) Indexes() []ent.Index {
    // Crea un índice único a través del borde para asegurar la unicidad de los nombres de calles dentro de la misma ciudad.
    return []ent.Index{
        index.Fields("name").
            Edges("city").
            Unique(),
    }
}

En este ejemplo, creamos una entidad Street y la asociamos con la entidad City. Al definir un índice de borde en el método Indexes de la entidad Street, nos aseguramos de que el nombre de cada calle bajo una ciudad sea único.

Capítulo 5: Opciones Avanzadas de Índices

5.1 Índices de Texto Completo y de Hash

El índice de texto completo y el índice de hash son dos tipos de índices únicos en MySQL y PostgreSQL, y se utilizan para diferentes escenarios de optimización de consultas.

El índice de texto completo se usa comúnmente para buscar datos de texto, especialmente cuando necesitas realizar búsquedas complejas, como búsquedas de coincidencias de palabras. Tanto las bases de datos MySQL como PostgreSQL admiten indexación de texto completo. Por ejemplo, en MySQL, puedes definir un índice de texto completo así:

// El archivo ent/schema/user.go define el esquema de la entidad User
func (User) Indexes() []ent.Index {
    // Crea un índice de texto completo usando la categoría FULLTEXT en MySQL
    return []ent.Index{
        index.Fields("description").
            Annotations(entsql.IndexTypes(map[string]string{
                dialect.MySQL: "FULLTEXT",
            })),
    }
}

El índice de hash es particularmente adecuado para consultas de igualdad y no admite ordenación ni consultas de rango. En PostgreSQL, puedes usar un índice de hash así:

func (User) Indexes() []ent.Index {
    // Define un índice de tipo HASH
    return []ent.Index{
        index.Fields("c4").
            Annotations(entsql.IndexType("HASH")),
    }
}

5.2 Índices Parciales y Prefijos de Índices

El índice parcial es un tipo de índice que indexa solo las filas en una tabla que cumplen condiciones específicas. En SQLite y PostgreSQL, puedes usar la cláusula WHERE para crear índices parciales.

Por ejemplo, define un índice parcial en PostgreSQL:

func (User) Indexes() []ent.Index {
    // Crea un índice parcial en el campo "nickname", que contiene solo filas donde "active" es true
    return []ent.Index{
        index.Fields("nickname").
            Annotations(
                entsql.IndexWhere("active"),
            ),
    }
}

El prefijo del índice es especialmente útil para campos de texto, especialmente en MySQL. Puede acortar el tiempo de creación del índice, reducir el espacio ocupado por el índice y también proporcionar un buen rendimiento. Como se muestra a continuación, para MySQL, puedes definir un índice con un prefijo:

func (User) Indexes() []ent.Index {
    // Crea un índice usando prefijo de índice
    return []ent.Index{
        index.Fields("description").
            Annotations(entsql.Prefix(128)),
    }
}

5.3 Anotaciones e Personalización de Índices

En ent, Annotations es una característica que permite a los desarrolladores personalizar los índices. Puedes definir el tipo de índice, establecer reglas de ordenación y más.

Por ejemplo, el siguiente código demuestra cómo especificar las reglas de ordenación de columnas en un índice:

func (User) Indexes() []ent.Index {
    return []ent.Index{
        // Usa anotaciones para definir las reglas de ordenación de columnas del índice
        index.Fields("c1", "c2", "c3").
            Annotations(entsql.DescColumns("c1", "c2")),
    }
}

Con la función de anotaciones, los desarrolladores pueden personalizar índices de forma flexible para optimizar el rendimiento y la estructura de la base de datos.