Query and Mutation

    Let’s create a Todo in our testable example. We do it by adding the following code to :

    Running go test should pass successfully.

    As you can see, our Todos are too boring as they contain only the ID field. Let’s improve this example by adding multiple fields to the schema in todo/ent/schema/todo.go:

    1. func (Todo) Fields() []ent.Field {
    2.     return []ent.Field{
    3.         field.Text("text").
    4.             NotEmpty(),
    5.         field.Time("created_at").
    6.             Default(time.Now).
    7.             Immutable(),
    8.         field.Enum("status").
    9.             Values("in_progress", "completed").
    10.             Default("in_progress"),
    11.         field.Int("priority").
    12.             Default(0),
    13.     }
    14. }
    1. go generate ./ent

    As you may notice, all fields have a default value on creation except the text field, which must be provided by the user. Let’s change our example_test.go to follow these changes:

    Wonderful! We created a schema in the database with 5 columns (id, text, created_at, status, priority) and created 2 items in our todo list, by inserting 2 rows to the table.

    Let’s change our schema again in todo/ent/schema/todo.go:

    1. func (Todo) Edges() []ent.Edge {
    2.         edge.To("parent", Todo.Type).
    3.             Unique().
    4.             From("children"),
    5.     }
    6. }

    After adding these edges, we need to run the code-generation as before:

    1. go generate ./ent

    We continue our edges example, by updating the 2 todo items we just created. We define that item-2 (“Add Tracing Example”) depends on item-1 (“Add GraphQL Example”).

    After connecting item-2 to item-1, we’re ready to start querying our todo list.

    Query all todo items:

    1. func Example_Todo() {
    2.     // ...
    4.     // Query all todo items.
    5.     items, err := client.Todo.Query().All(ctx)
    6.     if err != nil {
    7.         log.Fatalf("failed querying todos: %v", err)
    8.     }
    9.     for _, t := range items {
    10.         fmt.Printf("%d: %q\n", t.ID, t.Text)
    11.     }
    12.     // Output:
    13.     // 1: "Add GraphQL Example"
    14.     // 2: "Add Tracing Example"
    15. }

    Query all todo items that depend on other items:

    1. func Example_Todo() {
    2.     // ...
    4.     // Query all todo items that depend on other items.
    5.     if err != nil {
    6.         log.Fatalf("failed querying todos: %v", err)
    7.     }
    8.     for _, t := range items {
    9.         fmt.Printf("%d: %q\n", t.ID, t.Text)
    10.     }
    11.     // Output:
    12.     // 2: "Add Tracing Example"
    13. }

    Query all todo items that don’t depend on other items and have items that depend on them:

    Query parent through its children:

    1. func Example_Todo() {
    2.     // ...
    4.     // Get a parent item through its children and expect the
    5.     // query to return exactly one item.
    6.     parent, err := client.Todo.Query(). // Query all todos.
    7.         Where(todo.HasParent()).        // Filter only those with parents.
    8.         QueryParent().                  // Continue traversals to the parents.
    9.         Only(ctx)                       // Expect exactly one item.
    10.     if err != nil {
    11.         log.Fatalf("failed querying todos: %v", err)
    12.     }
    13.     fmt.Printf("%d: %q\n", parent.ID, parent.Text)
    14.     // Output:
    15.     // 1: "Add GraphQL Example"