Restructure folders (#411)

database_interactions/basic/src/db.rs

@@ -0,0 +1,122 @@
+use actix_web::{web, Error as AWError};
+use failure::Error;
+use futures::{Future, TryFutureExt};
+use rusqlite::{Statement, NO_PARAMS};
+use serde::{Deserialize, Serialize};
+use std::{thread::sleep, time::Duration};
+
+pub type Pool = r2d2::Pool<r2d2_sqlite::SqliteConnectionManager>;
+pub type Connection = r2d2::PooledConnection<r2d2_sqlite::SqliteConnectionManager>;
+type WeatherAggResult = Result<Vec<WeatherAgg>, rusqlite::Error>;
+
+#[derive(Debug, Serialize, Deserialize)]
+pub enum WeatherAgg {
+    AnnualAgg { year: i32, total: f64 },
+    MonthAgg { year: i32, month: i32, total: f64 },
+}
+
+pub enum Queries {
+    GetTopTenHottestYears,
+    GetTopTenColdestYears,
+    GetTopTenHottestMonths,
+    GetTopTenColdestMonths,
+}
+
+pub fn execute(
+    pool: &Pool,
+    query: Queries,
+) -> impl Future<Output = Result<Vec<WeatherAgg>, AWError>> {
+    let pool = pool.clone();
+    web::block(move || {
+        // simulate an expensive query, see comments at top of main.rs
+        sleep(Duration::from_secs(2));
+
+        let result = match query {
+            Queries::GetTopTenHottestYears => get_hottest_years(pool.get()?),
+            Queries::GetTopTenColdestYears => get_coldest_years(pool.get()?),
+            Queries::GetTopTenHottestMonths => get_hottest_months(pool.get()?),
+            Queries::GetTopTenColdestMonths => get_coldest_months(pool.get()?),
+        };
+        result.map_err(Error::from)
+    })
+    .map_err(AWError::from)
+}
+
+fn get_hottest_years(conn: Connection) -> WeatherAggResult {
+    let stmt = conn.prepare(
+        "
+    SELECT cast(strftime('%Y', date) as int) as theyear,
+            sum(tmax) as total
+        FROM nyc_weather
+        WHERE tmax <> 'TMAX'
+        GROUP BY theyear
+        ORDER BY total DESC LIMIT 10",
+    )?;
+
+    get_rows_as_annual_agg(stmt)
+}
+
+fn get_coldest_years(conn: Connection) -> WeatherAggResult {
+    let stmt = conn.prepare(
+        "
+        SELECT cast(strftime('%Y', date) as int) as theyear,
+                sum(tmax) as total
+        FROM nyc_weather
+        WHERE tmax <> 'TMAX'
+        GROUP BY theyear
+        ORDER BY total ASC LIMIT 10",
+    )?;
+
+    get_rows_as_annual_agg(stmt)
+}
+
+fn get_rows_as_annual_agg(mut statement: Statement) -> WeatherAggResult {
+    statement
+        .query_map(NO_PARAMS, |row| {
+            Ok(WeatherAgg::AnnualAgg {
+                year: row.get(0)?,
+                total: row.get(1)?,
+            })
+        })
+        .and_then(Iterator::collect)
+}
+
+fn get_hottest_months(conn: Connection) -> WeatherAggResult {
+    let stmt = conn.prepare(
+        "SELECT cast(strftime('%Y', date) as int) as theyear,
+                cast(strftime('%m', date) as int) as themonth,
+                sum(tmax) as total
+        FROM nyc_weather
+        WHERE tmax <> 'TMAX'
+        GROUP BY theyear, themonth
+        ORDER BY total DESC LIMIT 10",
+    )?;
+
+    get_rows_as_month_agg(stmt)
+}
+
+fn get_coldest_months(conn: Connection) -> WeatherAggResult {
+    let stmt = conn.prepare(
+        "SELECT cast(strftime('%Y', date) as int) as theyear,
+                cast(strftime('%m', date) as int) as themonth,
+                sum(tmax) as total
+        FROM nyc_weather
+        WHERE tmax <> 'TMAX'
+        GROUP BY theyear, themonth
+        ORDER BY total ASC LIMIT 10",
+    )?;
+
+    get_rows_as_month_agg(stmt)
+}
+
+fn get_rows_as_month_agg(mut statement: Statement) -> WeatherAggResult {
+    statement
+        .query_map(NO_PARAMS, |row| {
+            Ok(WeatherAgg::MonthAgg {
+                year: row.get(0)?,
+                month: row.get(1)?,
+                total: row.get(2)?,
+            })
+        })
+        .and_then(Iterator::collect)
+}

database_interactions/basic/src/main.rs

@@ -0,0 +1,77 @@
+/* Actix-Web Asynchronous Database Example
+
+This project illustrates expensive and blocking database requests that runs
+in a thread-pool using `web::block` with two examples:
+
+    1. An asynchronous handler that executes 4 queries in *sequential order*,
+       collecting the results and returning them as a single serialized json object
+
+    2. An asynchronous handler that executes 4 queries in *parallel*,
+       collecting the results and returning them as a single serialized json object
+
+    Note: The use of sleep(Duration::from_secs(2)); in db.rs is to make performance
+          improvement with parallelism more obvious.
+ */
+use std::io;
+
+use actix_web::{middleware, web, App, Error as AWError, HttpResponse, HttpServer};
+use futures::future::join_all;
+use r2d2_sqlite::{self, SqliteConnectionManager};
+
+mod db;
+use db::{Pool, Queries};
+
+/// Version 1: Calls 4 queries in sequential order, as an asynchronous handler
+#[allow(clippy::eval_order_dependence)] // it's FP?
+async fn asyncio_weather(db: web::Data<Pool>) -> Result<HttpResponse, AWError> {
+    let result = vec![
+        db::execute(&db, Queries::GetTopTenHottestYears).await?,
+        db::execute(&db, Queries::GetTopTenColdestYears).await?,
+        db::execute(&db, Queries::GetTopTenHottestMonths).await?,
+        db::execute(&db, Queries::GetTopTenColdestMonths).await?,
+    ];
+
+    Ok(HttpResponse::Ok().json(result))
+}
+
+/// Version 2: Calls 4 queries in parallel, as an asynchronous handler
+/// Returning Error types turn into None values in the response
+async fn parallel_weather(db: web::Data<Pool>) -> Result<HttpResponse, AWError> {
+    let fut_result = vec![
+        Box::pin(db::execute(&db, Queries::GetTopTenHottestYears)),
+        Box::pin(db::execute(&db, Queries::GetTopTenColdestYears)),
+        Box::pin(db::execute(&db, Queries::GetTopTenHottestMonths)),
+        Box::pin(db::execute(&db, Queries::GetTopTenColdestMonths)),
+    ];
+    let result: Result<Vec<_>, _> = join_all(fut_result).await.into_iter().collect();
+
+    Ok(HttpResponse::Ok().json(result.map_err(AWError::from)?))
+}
+
+#[actix_web::main]
+async fn main() -> io::Result<()> {
+    std::env::set_var("RUST_LOG", "actix_web=info");
+    env_logger::init();
+
+    // Start N db executor actors (N = number of cores avail)
+    let manager = SqliteConnectionManager::file("weather.db");
+    let pool = Pool::new(manager).unwrap();
+
+    // Start http server
+    HttpServer::new(move || {
+        App::new()
+            // store db pool as Data object
+            .data(pool.clone())
+            .wrap(middleware::Logger::default())
+            .service(
+                web::resource("/asyncio_weather").route(web::get().to(asyncio_weather)),
+            )
+            .service(
+                web::resource("/parallel_weather")
+                    .route(web::get().to(parallel_weather)),
+            )
+    })
+    .bind("127.0.0.1:8080")?
+    .run()
+    .await
+}