Eliminación de Registros en Bases de Datos con Diesel

Clase 9 de 21 • Curso de Backend con Rust: Bases de Datos, Controladores y Templates

Resumen

Crear datos, actualizarlos y obtenerlos son las operaciones básicas de cualquier base de datos. La cuarta y última operación es la eliminación de datos de nuestra base.

Eliminar registro con Diesel

Por lo general, los registros se borran utilizando si ID o con algún que sabemos que es único en la base de datos para ese registro.

// Eliminar registro por ID
diesel::delete(posts.filter(id.eq(1)))
    .execute(&conn)
    .expect("Error en el delete.");

Las operaciones del tipo DELETE devuelven un número entero que puedes almacenar en una variable que corresponde a la cantidad de registros que fueron afectados (eliminados) de tu base de datos. Puedes usar este número entero para continuar con la lógica de tu aplicación.

Eliminar muchos registros a la vez

Una forma de eliminar varios registros a la vez, es utilizando el operador de SQL llamado LIKE y un patrón, similar a una expresión regular, para eliminar los registros que coincidan con la búsqueda.

// Eliminar registros con REGEX
diesel::delete(posts.filter(slug.like("%-post%")))
    .execute(&conn)
    .expect("Error en el delete.");

También puedes utilizar LIKE para obtener datos y actualizar. Es un operador realmente muy utilizado en SQL.

Ya tienes los conocimientos básicos para desarrollar todo un CRUD (Create, Read, Update, Delete) entre Rust, Diesel y SQL. ¡Felicidades!

Contribución creada por: Kevin Fiorentino.

Kevin Fiorentino

student•

Las operaciones del tipo DELETE devuelven un número entero con la cantidad de registros afectados por la consulta.

```rust
// Eliminar registro por ID
let cant_posts_eliminados = diesel::delete(posts.filter(id.eq(1)))
    .execute(&conn)
    .expect("Error en el delete.");

Eber Laurente Lliuyacc

student•

¿Por qué cuando volví a crear registros, el ID no volvió al valor 1, sino que continuó agregándose?

En mi caso, previamente había creado 5 registros, los eliminé con el ejercicio de la clase, pero cuando volví a crear los nuevos registros iniciaron en 6 y no en 1

Hecot Pulido

student•

Así funcionan los auto-incrementales de las bases de datos relacionales

Luis Carlos Carrillo Tovar

student•

La palabra "de el" no existe lo correcto es escribir "del" de el --> del

hackerman Jimenez

student•

Bueno respectivamente con el desarrollo del curso, mi comprension y entendimiento me dio como resultado esto.

<#[macro_use] //Para usar las macro creada
extern crate diesel; //Extendible de diesel


pub mod schema; //Usando los datos del squema 
pub mod models; //Usando los datos de los modelos   

use std::env;
use dotenv::dotenv; // Import the dotenv library

use diesel::prelude::*; // Import the Diesel prelude
use diesel::pg::PgConnection; // Import the Diesel postgres connection


//Funcion conectar a la base de datos
fn conectar_bd() -> PgConnection {
    dotenv().ok(); //Load the .env file
    let database_url = env::var("DATABASE_URL").expect("DATABASE_URL must be set"); //Get the DATABASE_URL environment variable
    PgConnection::establish(&database_url).expect(&format!("Error connecting to {}", database_url))
}


//Funcion leer la url de la base datos
fn query_select_all(){
    println!("Query Select All Initial");
    let conn =  conectar_bd(); //Conectamos a la base de datos
    use self::models::Post;
    use self::schema::posts::dsl::*;

    //Select * from posts
    let posts_result = posts.order(id).load::<Post>(&conn).expect("Error al ejecutar la query");
    for post in posts_result {
        println!("
        Id:{} 
        Title:{} 
        Bode:{} 
        Published:{}",
        post.id, 
        post.title, 
        post.body,
        post.published);
    }
}

fn query_select_title(_title:&str){
    println!("Query Select Title Initial");
    let conn =  conectar_bd(); //Conectamos a la base de datos
    use self::models::Post;
    use self::schema::posts::dsl::*;
    //Select * from posts where title = "First Post"
    let post_result = posts.filter(title.eq(_title)).load::<Post>(&conn).expect("Error al ejecutar la query");
    for post in post_result {
        println!("
        Id:{} 
        Title:{} 
        Bode:{} 
        Published:{}",
        post.id, 
        post.title, 
        post.body,
        post.published);
    }
}


//Funcion insertar un nuevo post
fn query_insert(_title :&str, _body:&str, _published:bool){
    println!("Query Insert Initial");
    let conn = conectar_bd();
    use self::models::{Post,NewPost};
    use self::schema::posts;
    use self::schema::posts::dsl::*;

    let new_post = NewPost {
        title: _title,
        body: _body,
        published: _published,
    };

    let _post: Post = diesel::insert_into(posts::table)
        .values(&new_post)
        .get_result(&conn)
        .expect("Error al insertar el post");

    let  post_result =  posts.limit(1)
        .load::<Post>(&conn)
        .expect("Error al ejecutar la query");

        
    for post in post_result {
        println!("
        Id:{} 
        Title:{} 
        Bode:{} 
        Published:{}",
        post.id, 
        post.title, 
        post.body,
        post.published);
    }
    
}

fn query_update_or_edit(_id:i32,_title:&str, _body:&str ,_published:bool){
    println!("Query Update or Edit Initial");
    let conn = conectar_bd();
    use self::models::{Post};
    use self::schema::posts::dsl::*;
    let  _post:Post = diesel::update(posts.filter(id.eq(_id)))
        .set((title.eq(_title),body.eq(_body),published.eq(_published)))
        .get_result(&conn)
        .expect("Error al ejecutar la query");
    
        println!("
        Id:{}
        Title:{}",
        _post.id,
        _post.title);
}

fn query_delete(_id:i32){
    println!("Query Delete Initial");
    let conn = conectar_bd();
    use self::models::Post;
    use self::schema::posts::dsl::*;
    let _post: Post = diesel::delete(posts.filter(id.eq(_id)))
        .get_result(&conn)
        .expect("Error al ejecutar la query");

    println!("Post Delete: {}", _post.id);

}




fn control_querys(){
    //Control query
    //let insert = query_insert();
    //println!("{:?}", insert);
    /*
        let insert = query_insert("My query 5 insert","My blog juan 5 ", true);
    println!("Insert End* 1:{:?}", insert);
    */

    //let select = query_select_all();
    //println!("Select All End:{:?}", select);

    //let select_title = query_select_title("2 Blog de juan editado");
    //println!("Select Title End:{:?}", select_title);

    //let edit = query_update_or_edit(3,"3 Blog post", "3 Mi primer blogpost editado", true);
    //println!("Update or Edit End:{:?}", edit);
    
    let select = query_select_all();
    println!("Select All End:{:?}", select);

    //let delete = query_delete(1);
    //println!("Delete End:{:?}", delete);

}



//Funcion  principal
fn main() {
    //-Iniciar control query
    control_querys();
}
>

Salida de la consola

<    Finished dev [unoptimized + debuginfo] target(s) in 0.80s
     Running `target/debug/blog-juan`
Query Update or Edit Initial

        Id:3
        Title:3 Blog post
Update or Edit End:()
Query Update or Edit Initial

        Id:4
        Title:4 Blog post
Update or Edit End:()
Query Update or Edit Initial

        Id:5
        Title:5 Blog post
Update or Edit End:()
Query Select All Initial

        Id:1 
        Title:1 Blog post 
        Bode:1 Mi primer blogpost editado 
        Published:true

        Id:2 
        Title:2 Blog de juan editado 
        Bode:2 Mi primer blogpost editado 
        Published:false

        Id:3 
        Title:3 Blog post 
        Bode:3 Mi primer blogpost editado 
        Published:true

        Id:4 
        Title:4 Blog post 
        Bode:4 Mi primer blogpost editado 
        Published:true

        Id:5 
        Title:5 Blog post 
        Bode:5 Mi primer blogpost editado 
        Published:true
Select All End:()>

Emilian Harastasan

student•

En caso que alguien necesite repoblar la DB adjunto el codigo aqui:


    use self::schema::posts;
    use self::schema::posts::dsl::*;
    use self::models::{Post, NewPost};
    let new_post = NewPost {
        title: "Third post",
        body: "Lorem ipsum",
        slug: "third-post"
    };

    diesel::insert_into(posts::table)
        .values(new_post)
        .get_result::<Post>(&db_conn)
        .expect("ERROR:> Failed to insert data into DB");