examples/async_db/src/db.rs

use actix::prelude::*;
use failure::Error;
use r2d2;
use r2d2_sqlite;
use std::{thread::sleep, time::Duration};

pub type Pool = r2d2::Pool<r2d2_sqlite::SqliteConnectionManager>;
pub type Connection = r2d2::PooledConnection<r2d2_sqlite::SqliteConnectionManager>;

pub struct DbExecutor(pub Pool);
impl Actor for DbExecutor {
    type Context = SyncContext<Self>;
}

#[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 struct GetTopTenHottestYears;
impl Message for Queries {
    type Result = Result<Vec<WeatherAgg>, Error>;
}
impl Handler<Queries> for DbExecutor {
    type Result = Result<Vec<WeatherAgg>, Error>;

    fn handle(&mut self, msg: Queries, _: &mut Self::Context) -> Self::Result {
        let conn: Connection = self.0.get()?;

        match msg {
            Queries::GetTopTenHottestYears => get_hottest_years(conn),
            Queries::GetTopTenColdestYears => get_coldest_years(conn),
            Queries::GetTopTenHottestMonths => get_hottest_months(conn),
            Queries::GetTopTenColdestMonths => get_coldest_months(conn),
        }
    }
}

fn get_hottest_years(conn: Connection) -> Result<Vec<WeatherAgg>, Error> {
    let stmt = "
    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;";

    let mut prep_stmt = conn.prepare(stmt)?;
    let annuals = prep_stmt
        .query_map(&[], |row| WeatherAgg::AnnualAgg {
            year: row.get(0),
            total: row.get(1),
        })
        .and_then(|mapped_rows| {
            Ok(mapped_rows
                .map(|row| row.unwrap())
                .collect::<Vec<WeatherAgg>>())
        })?;

    sleep(Duration::from_secs(2));

    Ok(annuals)
}

fn get_coldest_years(conn: Connection) -> Result<Vec<WeatherAgg>, Error> {
    let stmt = "
        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;";

    let mut prep_stmt = conn.prepare(stmt)?;
    let annuals = prep_stmt
        .query_map(&[], |row| WeatherAgg::AnnualAgg {
            year: row.get(0),
            total: row.get(1),
        })
        .and_then(|mapped_rows| {
            Ok(mapped_rows
                .map(|row| row.unwrap())
                .collect::<Vec<WeatherAgg>>())
        })?;

    sleep(Duration::from_secs(2));

    Ok(annuals)
}

fn get_hottest_months(conn: Connection) -> Result<Vec<WeatherAgg>, Error> {
    let stmt = "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;";

    let mut prep_stmt = conn.prepare(stmt)?;
    let annuals = prep_stmt
        .query_map(&[], |row| WeatherAgg::MonthAgg {
            year: row.get(0),
            month: row.get(1),
            total: row.get(2),
        })
        .and_then(|mapped_rows| {
            Ok(mapped_rows
                .map(|row| row.unwrap())
                .collect::<Vec<WeatherAgg>>())
        })?;

    sleep(Duration::from_secs(2));
    Ok(annuals)
}

fn get_coldest_months(conn: Connection) -> Result<Vec<WeatherAgg>, Error> {
    let stmt = "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;";

    let mut prep_stmt = conn.prepare(stmt)?;
    let annuals = prep_stmt
        .query_map(&[], |row| WeatherAgg::MonthAgg {
            year: row.get(0),
            month: row.get(1),
            total: row.get(2),
        })
        .and_then(|mapped_rows| {
            Ok(mapped_rows
                .map(|row| row.unwrap())
                .collect::<Vec<WeatherAgg>>())
        })?;

    sleep(Duration::from_secs(2));
    Ok(annuals)
}