Gain insights into using Rust for building scalable, high-performance websites. Learn about Rust fundamentals and advanced web development, including databases and full-stack skills through practical projects.

dockerfile.tar.gz

cargo_run_actix

cargo_complete

cargo_complete_test

yew_complete

yew_complete_test

yew_with_actix_web_list

for_command_line

In this course, you will learn how to use Rust to build scalable websites that are highly performant. 

More specifically, you will learn the fundamentals of Rust for web development including types, ownership, macros, and more. Later on this course, you will move onto more advanced web development concepts like working with databases, backend architecture, as well as frontend, giving you the opportunity to develop your full-stack skills.

Throughout each chapter, you will have the chance to work on building out a real project which can be used in your portfolio and shown to employers. 

By the end of this course, you will be able to build websites with scalability in mind.

Scalable Web Development in Rust

Updating a resource might be a bit tricky, so we’re going to need a few helper structs. We’ll use the annotation `AsChangeset` for the `struct` we directly modify in the database.


We have the option to refactor the structs used for inserting, but in our case, we’ll create new ones for this purpose.


#[derive(Insertable, Queryable, AsChangeset, Debug, Clone, Serialize, Deserialize)]
#[table_name="variants"]
pub struct FormVariant {
    pub id: Option<i32>,
    pub name: String
}

#[derive(Insertable, Debug, AsChangeset)]
#[table_name="products_variants"]
pub struct FormProductVariant {
    pub id: Option<i32>,
    pub variant_id: Option<i32>,
    pub product_id: i32,
    pub value: Option<String>
}

pub struct FormProductVariantComplete {
    pub variant: Option<FormVariant>,
    pub product_variant: FormProductVariant,
}

pub struct FormProduct {
    pub product: NewProduct,
    pub variants: Vec<FormProductVariantComplete>
}


Next, it’s time for the code to update the product.


#[macro_use]
extern crate diesel;

use diesel::{SqliteConnection, Connection, QueryDsl, RunQueryDsl};
use anyhow::Result;
use ::shoe_store::models::FormProduct;
no_arg_sql_function!(last_insert_rowid, diesel::sql_types::Integer);

fn update_product(product_id: i32, form_product: FormProduct, conn: &SqliteConnection) -> Result<i32> {
    use ::shoe_store::schema::products::dsl::products;
    use ::shoe_store::schema::variants;
    use ::shoe_store::schema::products_variants::dsl::products_variants;

    // We begin a transaction, just to make sure everything runs successfully
    conn.transaction(|| {
        diesel::update(products.find(product_id))
            .set(&form_product.product)
            .execute(conn)?;

        // We just loop through all variants available
        for mut form_product_variant in form_product.variants {
            // If there's no variant id, we probably need to insert a new one.
            if form_product_variant.product_variant.variant_id.is_none() {
                diesel::insert_into(variants::dsl::variants)
                    .values(form_product_variant.variant)
                    .execute(conn)?;

                let last_variant_id: i32 =
                        diesel::select(last_insert_rowid).first(conn)?;

                form_product_variant.product_variant.variant_id = Some(last_variant_id);            
            }
            // We have an id, so we should update the variant product.
            if let Some(product_variant_id) = form_product_variant.product_variant.id {
                diesel::update(products_variants.find(product_variant_id))
                    .set(&form_product_variant.product_variant)
                    .execute(conn)?;
            }
        }

        Ok(product_id)
    })
}

We start updating the product, then loop through the variants and check if the field `variant_id` from `product_variant` is none. If so, it means we have a new variant, so we create and get the `id`. We add `mut` in the loop because we need to change the object later.

We check if `product_variant` has an `id` so we can find out if we need to update a found record or create a new one.

We’re ready for our test.


Learn to update and delete a resource in Diesel.


11. Update and Delete Resources

Learn to update and delete a resource in Diesel.

Introduction to Rust

Databases

Database Assignment

Back End

Back-end Assignment

Front End

Final Project

Appendix

Update and Delete Resources

Update