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. }

    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:

    ent/schema/city.go

    ent/schema/street.go

    1. // Street holds the schema definition for the Street entity.
    2. type Street struct {
    3.     ent.Schema
    4. }
    7. // Fields of the Street.
    8. func (Street) Fields() []ent.Field {
    9.     return []ent.Field{
    10.         field.String("name"),
    11.     }
    12. }
    16.     return []ent.Edge{
    17.         edge.From("city", City.Type).
    18.             Ref("streets").
    19.             Unique(),
    20.     }
    21. }
    24. // Indexes of the Street.
    25. func (Street) Indexes() []ent.Index {
    26.     return []ent.Index{
    27.         index.Fields("name").
    28.             Edges("city").
    29.             Unique(),
    30.     }
    31. }

    example.go

    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 {
    8.             Optional(),
    9.         field.Int("owner_id").
    10.             Optional(),
    11.     }
    12. }
    13. // Edges of the Card.
    14. func (Card) Edges() []ent.Edge {
    15.     return []ent.Edge{
    16.         edge.From("owner", User.Type).
    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. }

    Indexes currently support only SQL dialects, and do not support Gremlin. Dialect specific features are allowed using . For example, in order to use index prefixes in MySQL, use the following configuration:

    The code above generates the following SQL statements:

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