Consultas y Mutaciones

[Traducción Beta No Oficial]

Esta página fue traducida por PageTurner AI (beta). No está respaldada oficialmente por el proyecto. ¿Encontraste un error? Reportar problema →

Tras configurar nuestro proyecto, estamos listos para crear nuestra lista Todo y consultarla.

Crear un Todo

Creemos un Todo en nuestro ejemplo testable. Añadimos este código a example_test.go:

func Example_Todo() {
    // ...
    task1, err := client.Todo.Create().Save(ctx)
    if err != nil {
        log.Fatalf("failed creating a todo: %v", err)
    }
    fmt.Println(task1)
    // Output:
    // Todo(id=1)
}

Ejecutar go test debería completarse con éxito.

Añadir Campos al Esquema

Como ves, nuestros Todos son demasiado básicos pues solo contienen el campo ID. Mejoremos el ejemplo añadiendo múltiples campos al esquema en todo/ent/schema/todo.go:

func (Todo) Fields() []ent.Field {
    return []ent.Field{
        field.Text("text").
            NotEmpty(),
        field.Time("created_at").
            Default(time.Now).
            Immutable(),
        field.Enum("status").
            NamedValues(
                "InProgress", "IN_PROGRESS",
                "Completed", "COMPLETED",
            ).
            Default("IN_PROGRESS"),
        field.Int("priority").
            Default(0),
    }
}

Tras añadir estos campos, debemos ejecutar la generación de código como antes:

go generate ./ent

Como habrás notado, todos los campos tienen un valor predeterminado al crearse excepto text, que debe ser proporcionado por el usuario. Actualicemos example_test.go según estos cambios:

func Example_Todo() {
    // ...
    task1, err := client.Todo.Create().SetText("Add GraphQL Example").Save(ctx)
    if err != nil {
        log.Fatalf("failed creating a todo: %v", err)
    }
    fmt.Printf("%d: %q\n", task1.ID, task1.Text)
    task2, err := client.Todo.Create().SetText("Add Tracing Example").Save(ctx)
    if err != nil {
        log.Fatalf("failed creating a todo: %v", err)
    }
    fmt.Printf("%d: %q\n", task2.ID, task2.Text)
    // Output:
    // 1: "Add GraphQL Example"
    // 2: "Add Tracing Example"
}

¡Excelente! Creamos un esquema en la base de datos con 5 columnas (id, text, created_at, status, priority) e insertamos 2 elementos en nuestra lista Todo añadiendo dos filas a la tabla.

Añadir Relaciones al Esquema

Imaginemos que queremos diseñar nuestra lista Todo para que un elemento pueda depender de otro. Para ello, añadiremos una relación parent a cada elemento Todo para obtener el elemento del que depende, y una relación inversa llamada children para obtener todos los elementos que dependen de él.

Modifiquemos nuevamente nuestro esquema en todo/ent/schema/todo.go:

func (Todo) Edges() []ent.Edge {
    return []ent.Edge{
        edge.To("parent", Todo.Type).
            Unique().
            From("children"),
    }
}

Tras añadir estas relaciones, ejecutamos la generación de código como antes:

go generate ./ent

Conectar 2 Todos

Continuamos con el ejemplo de relaciones actualizando los 2 elementos Todo creados. Definimos que el elemento-2 ("Añadir ejemplo de Tracing") depende del elemento-1 ("Añadir ejemplo de GraphQL").

func Example_Todo() {
    // ...
    if err := task2.Update().SetParent(task1).Exec(ctx); err != nil {
        log.Fatalf("failed connecting todo2 to its parent: %v", err)
    }
    // Output:
    // 1: "Add GraphQL Example"
    // 2: "Add Tracing Example"
}

Consultar Todos

Tras conectar el elemento-2 al elemento-1, estamos listos para consultar nuestra lista Todo.

Consultar todos los elementos Todo:

func Example_Todo() {
    // ...

    // Query all todo items.
    items, err := client.Todo.Query().All(ctx)
    if err != nil {
        log.Fatalf("failed querying todos: %v", err)
    }
    for _, t := range items {
        fmt.Printf("%d: %q\n", t.ID, t.Text)
    }
    // Output:
    // 1: "Add GraphQL Example"
    // 2: "Add Tracing Example"
}

Consultar elementos Todo que dependen de otros:

func Example_Todo() {
    // ...

    // Query all todo items that depend on other items.
    items, err := client.Todo.Query().Where(todo.HasParent()).All(ctx)
    if err != nil {
        log.Fatalf("failed querying todos: %v", err)
    }
    for _, t := range items {
        fmt.Printf("%d: %q\n", t.ID, t.Text)
    }
    // Output:
    // 2: "Add Tracing Example"
}

Consultar elementos Todo que no dependen de otros y tienen elementos dependientes:

func Example_Todo() {
    // ...

    // Query all todo items that don't depend on other items and have items that depend them.
    items, err := client.Todo.Query().
        Where(
            todo.Not(
                todo.HasParent(),
            ),
            todo.HasChildren(),
        ).
        All(ctx)
    if err != nil {
        log.Fatalf("failed querying todos: %v", err)
    }
    for _, t := range items {
        fmt.Printf("%d: %q\n", t.ID, t.Text)
    }
    // Output:
    // 1: "Add GraphQL Example"
}

Consultar el padre a través de sus hijos:

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