Editando los registros

Curso de Backend con Rust: Bases de Datos, Controladores y Templates

Bienvenida al curso

Desarrollo Web Avanzado con Rust: Crea un Gestor de Blog

Gestión de modelos en el backend con el ORM Diesel

Uso de ORM Diesel en Aplicaciones Web para Blogs

Errores Comunes al Instalar y Usar Diesel en Rust

Instalación de Diesel y configuración de base de datos en Rust

Creación de Modelos y Migraciones en Rust con Diesel

Inserción de Datos en Bases de Datos con Diesel

Consultas SQL: Cómo Filtrar y Ordenar Datos Específicos

Edición de Registros en Bases de Datos con Diesel

Eliminación de Registros en Bases de Datos con Diesel

Actix web framework (controlador)

Configuración de Actix Web Framework en Rust

Configuración de Actix y conexión con bases de datos en Rust

Uso de Match Case en Rust para Control de Flujo

Mostrar datos de la base de datos en navegador con Actix

Creación de API RESTful para Blog con Postman y Rust

Quiz: Actix web framework (controlador)

Tera templates (vistas)

Instalación y uso de Tera para plantillas en proyectos ROS

Integración de Tera y Creación de Templates en Proyectos Rust

Creación de Templates Dinámicos con Tera en Rust

Plantillas Tera y Bootstrap para Frontend Web

Quiz: Tera templates (vistas)

Despliegue del proyecto

Despliegue de Aplicaciones Rust en Heroku con Docker

Implementación de GitHub Actions para Despliegue en Heroku

Quiz: Despliegue del proyecto

Continúa tu aprendizaje

Despliegue de Aplicaciones Web con Rust

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Si ya tienes una cuenta,

Recursos

Una operación muy importante en toda base de datos es la actualización de los campos de un registro. Puedes utilizarlo para almacenar inmediatamente el registro actualizado en una variable y continuar trabajando con esos datos actualizados. Si no lo necesitas, simplemente conviene no declarar esa variable.

Cómo actualizar los datos con Diesel

La actualización de uno o más campos de un registro es bastante sencilla. Observemos algunos ejemplos de la sintaxis que debes utilizar:

// Actualización de un registro
diesel::update(posts.filter(id.eq(2)))
    .set(title.eq("Nuevo título"))
    .get_result::<Post>(&conn)
    .expect("Error en el update");

// Actualización de varios campos a la vez
diesel::update(posts.filter(id.eq(2)))
    .set((body.eq("Nuevo body"), title.eq("Nuevo título")))
    .get_result::<Post>(&conn)
    .expect("Error en el update");

Primero indicas el registro que quieres actualizar dentro del update() y luego en el .set() los campos a modificar con los nuevos valores. La consulta devuelve como resultado el registro actualizado que puedes guardar en una variable para que puedas continuar con la lógica de tu aplicación sin necesidad de realizar otra consulta adicional y obtenerlo.

De esta sencilla forma, ya puedes actualizar los datos de tus registros en la base de datos.

Contribución creada por: Kevin Fiorentino.

Aportes 3

Preguntas 3

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

william andres rodriguez borja

hace un año

Mi ejercicio para actualizar. ```java pub fn update_post(conn: &mut PgConnection, post: &Post) -> Result<(), diesel::result::Error> { diesel::update(dsl.find(post.id)) .set(posts::title.eq("Updated")) .returning(Post::as_returning()) .get_result(conn)?; Ok(()) } ```

Juan Bosco

hace 3 años

El uso de la variable para actualizar puede ser omitido.

diesel::update(posts.filter(id.eq(2)))
        .set(slug.eq("second-blogpost"))
        .get_result::<Post>(&conn)
        .expect("Error updating record");

Carlos Alberto García Rosales

hace un mes

En caso lo estén haciendo con SQLite: diesel::update(posts.filter(id.eq(2))) .set(title.eq("Nuevo título")) .execute(connection) .expect("Error en el update"); let updated\_post = posts .filter(id.eq(2)) .first::\<Post>(connection) .expect("Error al obtener el post actualizado");