Indexes

    Note that for setting a single field as unique, use the method on the field builder as follows:

    1. func (User) Fields() []ent.Field {
    2.     return []ent.Field{
    3.         field.String("phone").
    4.             Unique(),
    5.     }
    6. }

    Index On Edges

    Indexes can be configured on composition of fields and edges. The main use-case is setting uniqueness on fields under a specific relation. Let’s take an example:

    In the example above, we have a City with many Streets, and we want to set the street name to be unique under each city.

    1. // City holds the schema definition for the City entity.
    2. type City struct {
    3.     ent.Schema
    4. }
    6. // Fields of the City.
    7. func (City) Fields() []ent.Field {
    8.     return []ent.Field{
    9.         field.String("name"),
    10.     }
    11. }
    13. // Edges of the City.
    14. func (City) Edges() []ent.Edge {
    15.     return []ent.Edge{
    16.         edge.To("streets", Street.Type),
    17.     }
    18. }

    ent/schema/street.go

    example.go

    1. func Do(ctx context.Context, client *ent.Client) error {
    2.     // Unlike `Save`, `SaveX` panics if an error occurs.
    3.     tlv := client.City.
    4.         Create().
    5.         SetName("TLV").
    6.         SaveX(ctx)
    7.     nyc := client.City.
    8.         Create().
    9.         SetName("NYC").
    11.     client.Street.
    12.         Create().
    13.         SetName("ST").
    14.         SetCity(tlv).
    15.         SaveX(ctx)
    16.     // This operation fails because "ST"
    17.     // was already created under "TLV".
    18.     if err := client.Street.
    19.         Create().
    20.         SetName("ST").
    21.         SetCity(tlv).
    22.         Exec(ctx); err == nil {
    23.         return fmt.Errorf("expecting creation to fail")
    24.     }
    25.     // Add a street "ST" to "NYC".
    26.     client.Street.
    27.         Create().
    28.         SetName("ST").
    29.         SetCity(nyc).
    30.         SaveX(ctx)
    31.     return nil
    32. }

    The full example exists in .

    Currently Edges columns are always added after Fields columns. However, some indexes require these columns to come first in order to achieve specific optimizations. You can work around this problem by making use of Edge Fields.

    1. // Card holds the schema definition for the Card entity.
    2. type Card struct {
    3.     ent.Schema
    4. }
    5. // Fields of the Card.
    6. func (Card) Fields() []ent.Field {
    7.     return []ent.Field{
    8.         field.String("number").
    9.             Optional(),
    10.         field.Int("owner_id").
    11.             Optional(),
    12.     }
    13. }
    14. // Edges of the Card.
    15. func (Card) Edges() []ent.Edge {
    17.             Ref("card").
    18.             Field("owner_id").
    19.             Unique(),
    20.     }
    21. }
    22. // Indexes of the Card.
    23. func (Card) Indexes() []ent.Index {
    24.     return []ent.Index{
    25.         index.Fields("owner_id", "number"),
    26.     }
    27. }

    Dialect Support

    The code above generates the following SQL statements:

    1. CREATE INDEX `users_description` ON `users`(`description`(128))
    3. CREATE INDEX `users_c1_c2_c3` ON `users`(`c1`(100), `c2`(200), `c3`)

    Starting with v0.10, Ent supports running migration with Atlas. This option provides more control on indexes such as, configuring their types or define indexes in a reverse order.

    1. func (User) Indexes() []ent.Index {
    2.     return []ent.Index{
    3.         index.Fields("c1").
    4.             Annotations(entsql.Desc()),
    5.         index.Fields("c1", "c2", "c3").
    6.             Annotation(entsql.DescColumns("c1", "c2")),
    7.         index.Fields("c4").
    8.             Annotations(entsql.IndexType("HASH")),
    9.         // Enable FULLTEXT search on MySQL,
    10.         // and GIN on PostgreSQL.
    11.         index.Fields("c5").
    12.             Annotations(
    13.                 entsql.IndexTypes(map[string]string{
    14.                     dialect.MySQL:    "FULLTEXT",
    15.                     dialect.Postgres: "GIN",
    16.                 }),
    17.             ),
    18.     }
    19. }

    The code above generates the following SQL statements:

    Storage Key

    Like Fields, custom index name can be configured using the StorageKey method. It’s mapped to a index name in SQL dialects.

    1. func (User) Indexes() []ent.Index {
    2.     return []ent.Index{
    3.         index.Fields("field1", "field2").
    4.             StorageKey("custom_index"),
    6. }