From 12a62afb246ffd197153081bbd59480c4be5aa2a Mon Sep 17 00:00:00 2001 From: Ariel Mashraki Date: Tue, 27 Apr 2021 19:11:03 +0300 Subject: [PATCH] entc/integration: add example for edgefield indexes --- entc/integration/edgefield/ent/card.go | 12 ++ entc/integration/edgefield/ent/card/card.go | 3 + entc/integration/edgefield/ent/card/where.go | 132 ++++++++++++++++++ entc/integration/edgefield/ent/card_create.go | 22 +++ entc/integration/edgefield/ent/card_query.go | 8 +- entc/integration/edgefield/ent/card_update.go | 66 +++++++++ .../edgefield/ent/migrate/schema.go | 17 ++- entc/integration/edgefield/ent/mutation.go | 75 +++++++++- entc/integration/edgefield/ent/schema/card.go | 10 ++ entc/integration/edgefield/ent/schema/post.go | 8 ++ 10 files changed, 347 insertions(+), 6 deletions(-) diff --git a/entc/integration/edgefield/ent/card.go b/entc/integration/edgefield/ent/card.go index aea7b4fdb..0d89ba3e8 100644 --- a/entc/integration/edgefield/ent/card.go +++ b/entc/integration/edgefield/ent/card.go @@ -20,6 +20,8 @@ type Card struct { config `json:"-"` // ID of the ent. ID int `json:"id,omitempty"` + // Number holds the value of the "number" field. + Number string `json:"number,omitempty"` // OwnerID holds the value of the "owner_id" field. OwnerID int `json:"owner_id,omitempty"` // Edges holds the relations/edges for other nodes in the graph. @@ -57,6 +59,8 @@ func (*Card) scanValues(columns []string) ([]interface{}, error) { switch columns[i] { case card.FieldID, card.FieldOwnerID: values[i] = new(sql.NullInt64) + case card.FieldNumber: + values[i] = new(sql.NullString) default: return nil, fmt.Errorf("unexpected column %q for type Card", columns[i]) } @@ -78,6 +82,12 @@ func (c *Card) assignValues(columns []string, values []interface{}) error { return fmt.Errorf("unexpected type %T for field id", value) } c.ID = int(value.Int64) + case card.FieldNumber: + if value, ok := values[i].(*sql.NullString); !ok { + return fmt.Errorf("unexpected type %T for field number", values[i]) + } else if value.Valid { + c.Number = value.String + } case card.FieldOwnerID: if value, ok := values[i].(*sql.NullInt64); !ok { return fmt.Errorf("unexpected type %T for field owner_id", values[i]) @@ -117,6 +127,8 @@ func (c *Card) String() string { var builder strings.Builder builder.WriteString("Card(") builder.WriteString(fmt.Sprintf("id=%v", c.ID)) + builder.WriteString(", number=") + builder.WriteString(c.Number) builder.WriteString(", owner_id=") builder.WriteString(fmt.Sprintf("%v", c.OwnerID)) builder.WriteByte(')') diff --git a/entc/integration/edgefield/ent/card/card.go b/entc/integration/edgefield/ent/card/card.go index 7bfb1d0d4..bae6bd11b 100644 --- a/entc/integration/edgefield/ent/card/card.go +++ b/entc/integration/edgefield/ent/card/card.go @@ -11,6 +11,8 @@ const ( Label = "card" // FieldID holds the string denoting the id field in the database. FieldID = "id" + // FieldNumber holds the string denoting the number field in the database. + FieldNumber = "number" // FieldOwnerID holds the string denoting the owner_id field in the database. FieldOwnerID = "owner_id" // EdgeOwner holds the string denoting the owner edge name in mutations. @@ -29,6 +31,7 @@ const ( // Columns holds all SQL columns for card fields. var Columns = []string{ FieldID, + FieldNumber, FieldOwnerID, } diff --git a/entc/integration/edgefield/ent/card/where.go b/entc/integration/edgefield/ent/card/where.go index 4d592a006..be08e01a2 100644 --- a/entc/integration/edgefield/ent/card/where.go +++ b/entc/integration/edgefield/ent/card/where.go @@ -95,6 +95,13 @@ func IDLTE(id int) predicate.Card { }) } +// Number applies equality check predicate on the "number" field. It's identical to NumberEQ. +func Number(v string) predicate.Card { + return predicate.Card(func(s *sql.Selector) { + s.Where(sql.EQ(s.C(FieldNumber), v)) + }) +} + // OwnerID applies equality check predicate on the "owner_id" field. It's identical to OwnerIDEQ. func OwnerID(v int) predicate.Card { return predicate.Card(func(s *sql.Selector) { @@ -102,6 +109,131 @@ func OwnerID(v int) predicate.Card { }) } +// NumberEQ applies the EQ predicate on the "number" field. +func NumberEQ(v string) predicate.Card { + return predicate.Card(func(s *sql.Selector) { + s.Where(sql.EQ(s.C(FieldNumber), v)) + }) +} + +// NumberNEQ applies the NEQ predicate on the "number" field. +func NumberNEQ(v string) predicate.Card { + return predicate.Card(func(s *sql.Selector) { + s.Where(sql.NEQ(s.C(FieldNumber), v)) + }) +} + +// NumberIn applies the In predicate on the "number" field. +func NumberIn(vs ...string) predicate.Card { + v := make([]interface{}, len(vs)) + for i := range v { + v[i] = vs[i] + } + return predicate.Card(func(s *sql.Selector) { + // if not arguments were provided, append the FALSE constants, + // since we can't apply "IN ()". This will make this predicate falsy. + if len(v) == 0 { + s.Where(sql.False()) + return + } + s.Where(sql.In(s.C(FieldNumber), v...)) + }) +} + +// NumberNotIn applies the NotIn predicate on the "number" field. +func NumberNotIn(vs ...string) predicate.Card { + v := make([]interface{}, len(vs)) + for i := range v { + v[i] = vs[i] + } + return predicate.Card(func(s *sql.Selector) { + // if not arguments were provided, append the FALSE constants, + // since we can't apply "IN ()". This will make this predicate falsy. + if len(v) == 0 { + s.Where(sql.False()) + return + } + s.Where(sql.NotIn(s.C(FieldNumber), v...)) + }) +} + +// NumberGT applies the GT predicate on the "number" field. +func NumberGT(v string) predicate.Card { + return predicate.Card(func(s *sql.Selector) { + s.Where(sql.GT(s.C(FieldNumber), v)) + }) +} + +// NumberGTE applies the GTE predicate on the "number" field. +func NumberGTE(v string) predicate.Card { + return predicate.Card(func(s *sql.Selector) { + s.Where(sql.GTE(s.C(FieldNumber), v)) + }) +} + +// NumberLT applies the LT predicate on the "number" field. +func NumberLT(v string) predicate.Card { + return predicate.Card(func(s *sql.Selector) { + s.Where(sql.LT(s.C(FieldNumber), v)) + }) +} + +// NumberLTE applies the LTE predicate on the "number" field. +func NumberLTE(v string) predicate.Card { + return predicate.Card(func(s *sql.Selector) { + s.Where(sql.LTE(s.C(FieldNumber), v)) + }) +} + +// NumberContains applies the Contains predicate on the "number" field. +func NumberContains(v string) predicate.Card { + return predicate.Card(func(s *sql.Selector) { + s.Where(sql.Contains(s.C(FieldNumber), v)) + }) +} + +// NumberHasPrefix applies the HasPrefix predicate on the "number" field. +func NumberHasPrefix(v string) predicate.Card { + return predicate.Card(func(s *sql.Selector) { + s.Where(sql.HasPrefix(s.C(FieldNumber), v)) + }) +} + +// NumberHasSuffix applies the HasSuffix predicate on the "number" field. +func NumberHasSuffix(v string) predicate.Card { + return predicate.Card(func(s *sql.Selector) { + s.Where(sql.HasSuffix(s.C(FieldNumber), v)) + }) +} + +// NumberIsNil applies the IsNil predicate on the "number" field. +func NumberIsNil() predicate.Card { + return predicate.Card(func(s *sql.Selector) { + s.Where(sql.IsNull(s.C(FieldNumber))) + }) +} + +// NumberNotNil applies the NotNil predicate on the "number" field. +func NumberNotNil() predicate.Card { + return predicate.Card(func(s *sql.Selector) { + s.Where(sql.NotNull(s.C(FieldNumber))) + }) +} + +// NumberEqualFold applies the EqualFold predicate on the "number" field. +func NumberEqualFold(v string) predicate.Card { + return predicate.Card(func(s *sql.Selector) { + s.Where(sql.EqualFold(s.C(FieldNumber), v)) + }) +} + +// NumberContainsFold applies the ContainsFold predicate on the "number" field. +func NumberContainsFold(v string) predicate.Card { + return predicate.Card(func(s *sql.Selector) { + s.Where(sql.ContainsFold(s.C(FieldNumber), v)) + }) +} + // OwnerIDEQ applies the EQ predicate on the "owner_id" field. func OwnerIDEQ(v int) predicate.Card { return predicate.Card(func(s *sql.Selector) { diff --git a/entc/integration/edgefield/ent/card_create.go b/entc/integration/edgefield/ent/card_create.go index 4e2a54dde..7386b7240 100644 --- a/entc/integration/edgefield/ent/card_create.go +++ b/entc/integration/edgefield/ent/card_create.go @@ -23,6 +23,20 @@ type CardCreate struct { hooks []Hook } +// SetNumber sets the "number" field. +func (cc *CardCreate) SetNumber(s string) *CardCreate { + cc.mutation.SetNumber(s) + return cc +} + +// SetNillableNumber sets the "number" field if the given value is not nil. +func (cc *CardCreate) SetNillableNumber(s *string) *CardCreate { + if s != nil { + cc.SetNumber(*s) + } + return cc +} + // SetOwnerID sets the "owner_id" field. func (cc *CardCreate) SetOwnerID(i int) *CardCreate { cc.mutation.SetOwnerID(i) @@ -120,6 +134,14 @@ func (cc *CardCreate) createSpec() (*Card, *sqlgraph.CreateSpec) { }, } ) + if value, ok := cc.mutation.Number(); ok { + _spec.Fields = append(_spec.Fields, &sqlgraph.FieldSpec{ + Type: field.TypeString, + Value: value, + Column: card.FieldNumber, + }) + _node.Number = value + } if nodes := cc.mutation.OwnerIDs(); len(nodes) > 0 { edge := &sqlgraph.EdgeSpec{ Rel: sqlgraph.O2O, diff --git a/entc/integration/edgefield/ent/card_query.go b/entc/integration/edgefield/ent/card_query.go index 0a5a4a605..1bd2a4fb7 100644 --- a/entc/integration/edgefield/ent/card_query.go +++ b/entc/integration/edgefield/ent/card_query.go @@ -294,12 +294,12 @@ func (cq *CardQuery) WithOwner(opts ...func(*UserQuery)) *CardQuery { // Example: // // var v []struct { -// OwnerID int `json:"owner_id,omitempty"` +// Number string `json:"number,omitempty"` // Count int `json:"count,omitempty"` // } // // client.Card.Query(). -// GroupBy(card.FieldOwnerID). +// GroupBy(card.FieldNumber). // Aggregate(ent.Count()). // Scan(ctx, &v) // @@ -321,11 +321,11 @@ func (cq *CardQuery) GroupBy(field string, fields ...string) *CardGroupBy { // Example: // // var v []struct { -// OwnerID int `json:"owner_id,omitempty"` +// Number string `json:"number,omitempty"` // } // // client.Card.Query(). -// Select(card.FieldOwnerID). +// Select(card.FieldNumber). // Scan(ctx, &v) // func (cq *CardQuery) Select(field string, fields ...string) *CardSelect { diff --git a/entc/integration/edgefield/ent/card_update.go b/entc/integration/edgefield/ent/card_update.go index 1bbde79ce..70729a886 100644 --- a/entc/integration/edgefield/ent/card_update.go +++ b/entc/integration/edgefield/ent/card_update.go @@ -31,6 +31,26 @@ func (cu *CardUpdate) Where(ps ...predicate.Card) *CardUpdate { return cu } +// SetNumber sets the "number" field. +func (cu *CardUpdate) SetNumber(s string) *CardUpdate { + cu.mutation.SetNumber(s) + return cu +} + +// SetNillableNumber sets the "number" field if the given value is not nil. +func (cu *CardUpdate) SetNillableNumber(s *string) *CardUpdate { + if s != nil { + cu.SetNumber(*s) + } + return cu +} + +// ClearNumber clears the value of the "number" field. +func (cu *CardUpdate) ClearNumber() *CardUpdate { + cu.mutation.ClearNumber() + return cu +} + // SetOwnerID sets the "owner_id" field. func (cu *CardUpdate) SetOwnerID(i int) *CardUpdate { cu.mutation.ResetOwnerID() @@ -137,6 +157,19 @@ func (cu *CardUpdate) sqlSave(ctx context.Context) (n int, err error) { } } } + if value, ok := cu.mutation.Number(); ok { + _spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{ + Type: field.TypeString, + Value: value, + Column: card.FieldNumber, + }) + } + if cu.mutation.NumberCleared() { + _spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{ + Type: field.TypeString, + Column: card.FieldNumber, + }) + } if cu.mutation.OwnerCleared() { edge := &sqlgraph.EdgeSpec{ Rel: sqlgraph.O2O, @@ -191,6 +224,26 @@ type CardUpdateOne struct { mutation *CardMutation } +// SetNumber sets the "number" field. +func (cuo *CardUpdateOne) SetNumber(s string) *CardUpdateOne { + cuo.mutation.SetNumber(s) + return cuo +} + +// SetNillableNumber sets the "number" field if the given value is not nil. +func (cuo *CardUpdateOne) SetNillableNumber(s *string) *CardUpdateOne { + if s != nil { + cuo.SetNumber(*s) + } + return cuo +} + +// ClearNumber clears the value of the "number" field. +func (cuo *CardUpdateOne) ClearNumber() *CardUpdateOne { + cuo.mutation.ClearNumber() + return cuo +} + // SetOwnerID sets the "owner_id" field. func (cuo *CardUpdateOne) SetOwnerID(i int) *CardUpdateOne { cuo.mutation.ResetOwnerID() @@ -321,6 +374,19 @@ func (cuo *CardUpdateOne) sqlSave(ctx context.Context) (_node *Card, err error) } } } + if value, ok := cuo.mutation.Number(); ok { + _spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{ + Type: field.TypeString, + Value: value, + Column: card.FieldNumber, + }) + } + if cuo.mutation.NumberCleared() { + _spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{ + Type: field.TypeString, + Column: card.FieldNumber, + }) + } if cuo.mutation.OwnerCleared() { edge := &sqlgraph.EdgeSpec{ Rel: sqlgraph.O2O, diff --git a/entc/integration/edgefield/ent/migrate/schema.go b/entc/integration/edgefield/ent/migrate/schema.go index 76c230040..a308a5e3c 100644 --- a/entc/integration/edgefield/ent/migrate/schema.go +++ b/entc/integration/edgefield/ent/migrate/schema.go @@ -15,6 +15,7 @@ var ( // CardsColumns holds the columns for the "cards" table. CardsColumns = []*schema.Column{ {Name: "id", Type: field.TypeInt, Increment: true}, + {Name: "number", Type: field.TypeString, Nullable: true}, {Name: "owner_id", Type: field.TypeInt, Unique: true, Nullable: true}, } // CardsTable holds the schema information for the "cards" table. @@ -25,11 +26,18 @@ var ( ForeignKeys: []*schema.ForeignKey{ { Symbol: "cards_users_card", - Columns: []*schema.Column{CardsColumns[1]}, + Columns: []*schema.Column{CardsColumns[2]}, RefColumns: []*schema.Column{UsersColumns[0]}, OnDelete: schema.SetNull, }, }, + Indexes: []*schema.Index{ + { + Name: "card_number_owner_id", + Unique: false, + Columns: []*schema.Column{CardsColumns[1], CardsColumns[2]}, + }, + }, } // InfosColumns holds the columns for the "infos" table. InfosColumns = []*schema.Column{ @@ -107,6 +115,13 @@ var ( OnDelete: schema.SetNull, }, }, + Indexes: []*schema.Index{ + { + Name: "post_author_id_text", + Unique: false, + Columns: []*schema.Column{PostsColumns[2], PostsColumns[1]}, + }, + }, } // UsersColumns holds the columns for the "users" table. UsersColumns = []*schema.Column{ diff --git a/entc/integration/edgefield/ent/mutation.go b/entc/integration/edgefield/ent/mutation.go index 51ad54209..65a3e5f4f 100644 --- a/entc/integration/edgefield/ent/mutation.go +++ b/entc/integration/edgefield/ent/mutation.go @@ -46,6 +46,7 @@ type CardMutation struct { op Op typ string id *int + number *string clearedFields map[string]struct{} owner *int clearedowner bool @@ -133,6 +134,55 @@ func (m *CardMutation) ID() (id int, exists bool) { return *m.id, true } +// SetNumber sets the "number" field. +func (m *CardMutation) SetNumber(s string) { + m.number = &s +} + +// Number returns the value of the "number" field in the mutation. +func (m *CardMutation) Number() (r string, exists bool) { + v := m.number + if v == nil { + return + } + return *v, true +} + +// OldNumber returns the old "number" field's value of the Card entity. +// If the Card object wasn't provided to the builder, the object is fetched from the database. +// An error is returned if the mutation operation is not UpdateOne, or the database query fails. +func (m *CardMutation) OldNumber(ctx context.Context) (v string, err error) { + if !m.op.Is(OpUpdateOne) { + return v, fmt.Errorf("OldNumber is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, fmt.Errorf("OldNumber requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldNumber: %w", err) + } + return oldValue.Number, nil +} + +// ClearNumber clears the value of the "number" field. +func (m *CardMutation) ClearNumber() { + m.number = nil + m.clearedFields[card.FieldNumber] = struct{}{} +} + +// NumberCleared returns if the "number" field was cleared in this mutation. +func (m *CardMutation) NumberCleared() bool { + _, ok := m.clearedFields[card.FieldNumber] + return ok +} + +// ResetNumber resets all changes to the "number" field. +func (m *CardMutation) ResetNumber() { + m.number = nil + delete(m.clearedFields, card.FieldNumber) +} + // SetOwnerID sets the "owner_id" field. func (m *CardMutation) SetOwnerID(i int) { m.owner = &i @@ -222,7 +272,10 @@ func (m *CardMutation) Type() string { // order to get all numeric fields that were incremented/decremented, call // AddedFields(). func (m *CardMutation) Fields() []string { - fields := make([]string, 0, 1) + fields := make([]string, 0, 2) + if m.number != nil { + fields = append(fields, card.FieldNumber) + } if m.owner != nil { fields = append(fields, card.FieldOwnerID) } @@ -234,6 +287,8 @@ func (m *CardMutation) Fields() []string { // schema. func (m *CardMutation) Field(name string) (ent.Value, bool) { switch name { + case card.FieldNumber: + return m.Number() case card.FieldOwnerID: return m.OwnerID() } @@ -245,6 +300,8 @@ func (m *CardMutation) Field(name string) (ent.Value, bool) { // database failed. func (m *CardMutation) OldField(ctx context.Context, name string) (ent.Value, error) { switch name { + case card.FieldNumber: + return m.OldNumber(ctx) case card.FieldOwnerID: return m.OldOwnerID(ctx) } @@ -256,6 +313,13 @@ func (m *CardMutation) OldField(ctx context.Context, name string) (ent.Value, er // type. func (m *CardMutation) SetField(name string, value ent.Value) error { switch name { + case card.FieldNumber: + v, ok := value.(string) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetNumber(v) + return nil case card.FieldOwnerID: v, ok := value.(int) if !ok { @@ -296,6 +360,9 @@ func (m *CardMutation) AddField(name string, value ent.Value) error { // mutation. func (m *CardMutation) ClearedFields() []string { var fields []string + if m.FieldCleared(card.FieldNumber) { + fields = append(fields, card.FieldNumber) + } if m.FieldCleared(card.FieldOwnerID) { fields = append(fields, card.FieldOwnerID) } @@ -313,6 +380,9 @@ func (m *CardMutation) FieldCleared(name string) bool { // error if the field is not defined in the schema. func (m *CardMutation) ClearField(name string) error { switch name { + case card.FieldNumber: + m.ClearNumber() + return nil case card.FieldOwnerID: m.ClearOwnerID() return nil @@ -324,6 +394,9 @@ func (m *CardMutation) ClearField(name string) error { // It returns an error if the field is not defined in the schema. func (m *CardMutation) ResetField(name string) error { switch name { + case card.FieldNumber: + m.ResetNumber() + return nil case card.FieldOwnerID: m.ResetOwnerID() return nil diff --git a/entc/integration/edgefield/ent/schema/card.go b/entc/integration/edgefield/ent/schema/card.go index fea4659c0..066899281 100644 --- a/entc/integration/edgefield/ent/schema/card.go +++ b/entc/integration/edgefield/ent/schema/card.go @@ -8,6 +8,7 @@ import ( "entgo.io/ent" "entgo.io/ent/schema/edge" "entgo.io/ent/schema/field" + "entgo.io/ent/schema/index" ) // Card holds the schema definition for the Card entity. @@ -18,6 +19,8 @@ type Card struct { // Fields of the Card. func (Card) Fields() []ent.Field { return []ent.Field{ + field.String("number"). + Optional(), field.Int("owner_id"). Optional(), } @@ -32,3 +35,10 @@ func (Card) Edges() []ent.Edge { Unique(), } } + +// Indexes of the Card. +func (Card) Indexes() []ent.Index { + return []ent.Index{ + index.Fields("number", "owner_id"), + } +} diff --git a/entc/integration/edgefield/ent/schema/post.go b/entc/integration/edgefield/ent/schema/post.go index 7c5fab8db..e8ed5069f 100644 --- a/entc/integration/edgefield/ent/schema/post.go +++ b/entc/integration/edgefield/ent/schema/post.go @@ -8,6 +8,7 @@ import ( "entgo.io/ent" "entgo.io/ent/schema/edge" "entgo.io/ent/schema/field" + "entgo.io/ent/schema/index" ) // Post holds the schema definition for the Post entity. @@ -33,3 +34,10 @@ func (Post) Edges() []ent.Edge { Unique(), } } + +// Indexes of the Post. +func (Post) Indexes() []ent.Index { + return []ent.Index{ + index.Fields("author_id", "text"), + } +}