rename category -> bucket

27 files changed, 470 insertions, 470 deletions

diff --git a/schist_core/schist_fakes/src/bucket_transfer.rs b/schist_core/schist_fakes/src/bucket_transfer.rs
new file mode 100644
index 0000000..9bc1f80
--- /dev/null
+++ b/schist_core/schist_fakes/src/bucket_transfer.rs
@@ -0,0 +1,16 @@
+use schist_models::bucket_transfer::{BucketTransfer, BucketTransferBuilder};
+
+pub fn make_fake_bucket_transfer(id: i32) -> BucketTransfer {
+    make_fake_bucket_transfer_builder(id).build().unwrap()
+}
+
+pub fn make_fake_bucket_transfer_builder(id: i32) -> BucketTransferBuilder {
+    let mut builder = BucketTransferBuilder::default();
+    builder
+        .id(id)
+        .description(String::from("Fake bucket transfer"))
+        .quantity(0)
+        .from_bucket_id(0)
+        .to_bucket_id(1);
+    builder
+}
diff --git a/schist_core/schist_fakes/src/budget_drip.rs b/schist_core/schist_fakes/src/budget_drip.rs
index f653565..498dd76 100644
--- a/schist_core/schist_fakes/src/budget_drip.rs
+++ b/schist_core/schist_fakes/src/budget_drip.rs
@@ -9,7 +9,7 @@ pub fn make_fake_budget_drip_builder(id: i32) -> BudgetDripBuilder {
     let mut builder = BudgetDripBuilder::default();
     builder
         .id(id)
-        .category_id(0)
+        .bucket_id(0)
         .date(DateUtc::now())
         .quantity(0);
     builder
diff --git a/schist_core/schist_fakes/src/category_transfer.rs b/schist_core/schist_fakes/src/category_transfer.rs
deleted file mode 100644
index a16d238..0000000
--- a/schist_core/schist_fakes/src/category_transfer.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-use schist_models::bucket_transfer::{BucketTransfer, BucketTransferBuilder};
-
-pub fn make_fake_category_transfer(id: i32) -> BucketTransfer {
-    make_fake_category_transfer_builder(id).build().unwrap()
-}
-
-pub fn make_fake_category_transfer_builder(id: i32) -> BucketTransferBuilder {
-    let mut builder = BucketTransferBuilder::default();
-    builder
-        .id(id)
-        .description(String::from("Fake category transfer"))
-        .quantity(0)
-        .from_category_id(0)
-        .to_category_id(1);
-    builder
-}
diff --git a/schist_core/schist_fakes/src/lib.rs b/schist_core/schist_fakes/src/lib.rs
index 4a22169..ba88fb5 100644
--- a/schist_core/schist_fakes/src/lib.rs
+++ b/schist_core/schist_fakes/src/lib.rs
@@ -2,6 +2,6 @@ pub mod account;
 pub mod account_transfer;
 pub mod bucket;
 pub mod budget_drip;
-pub mod category_transfer;
+pub mod bucket_transfer;
 pub mod transaction;
 pub mod transaction_categorisation;
diff --git a/schist_core/schist_fakes/src/transaction.rs b/schist_core/schist_fakes/src/transaction.rs
index 30d1788..cee7e00 100644
--- a/schist_core/schist_fakes/src/transaction.rs
+++ b/schist_core/schist_fakes/src/transaction.rs
@@ -9,7 +9,7 @@ pub fn make_fake_transaction_builder(id: i32) ->  TransactionBuilder {
     let mut builder = TransactionBuilder::default();
     builder
         .id(id)
-        .description(String::from("Fake category transfer"))
+        .description(String::from("Fake bucket transfer"))
         .payee(String::from("Fake payee"))
         .quantity(0)
         .date(DateUtc::now())
diff --git a/schist_core/schist_fakes/src/transaction_categorisation.rs b/schist_core/schist_fakes/src/transaction_categorisation.rs
index ce9460c..11b50c2 100644
--- a/schist_core/schist_fakes/src/transaction_categorisation.rs
+++ b/schist_core/schist_fakes/src/transaction_categorisation.rs
@@ -8,9 +8,9 @@ pub fn make_fake_transaction_categorisation_builder(id: i32) ->  TransactionCate
     let mut builder = TransactionCategorisationBuilder::default();
     builder
         .id(id)
-        .description(String::from("Fake category transfer"))
+        .description(String::from("Fake bucket transfer"))
         .quantity(0)
         .transaction_id(0)
-        .category_id(0);
+        .bucket_id(0);
     builder
 }
diff --git a/schist_core/schist_models/src/bucket.rs b/schist_core/schist_models/src/bucket.rs
index f162405..1ee6a13 100644
--- a/schist_core/schist_models/src/bucket.rs
+++ b/schist_core/schist_models/src/bucket.rs
@@ -16,7 +16,7 @@ use crate::{budget_period_unit::BudgetPeriodUnit, date_utc::DateUtc};
     Deserialize,
     Insertable,
 )]
-#[diesel(table_name = crate::schema::categories)]
+#[diesel(table_name = crate::schema::buckets)]
 pub struct Bucket {
     pub id: i32,
     pub name: String,
diff --git a/schist_core/schist_models/src/bucket_transfer.rs b/schist_core/schist_models/src/bucket_transfer.rs
index 5d2e268..bdf95d9 100644
--- a/schist_core/schist_models/src/bucket_transfer.rs
+++ b/schist_core/schist_models/src/bucket_transfer.rs
@@ -2,11 +2,11 @@ use derive_builder::Builder;
 use diesel::prelude::*;
 
 #[derive(Builder, Queryable, Identifiable, Selectable, Debug, PartialEq, Insertable)]
-#[diesel(table_name = crate::schema::category_transfers)]
+#[diesel(table_name = crate::schema::bucket_transfers)]
 pub struct BucketTransfer {
     pub id: i32,
     pub description: String,
     pub quantity: i32,
-    pub from_category_id: i32,
-    pub to_category_id: i32,
+    pub from_bucket_id: i32,
+    pub to_bucket_id: i32,
 }
diff --git a/schist_core/schist_models/src/budget_drip.rs b/schist_core/schist_models/src/budget_drip.rs
index 2cc2c63..419c8f9 100644
--- a/schist_core/schist_models/src/budget_drip.rs
+++ b/schist_core/schist_models/src/budget_drip.rs
@@ -8,7 +8,7 @@ use crate::date_utc::DateUtc;
 #[diesel(table_name = crate::schema::budget_drips)]
 pub struct BudgetDrip {
     pub id: i32,
-    pub category_id: i32,
+    pub bucket_id: i32,
     pub date: DateUtc,
     pub quantity: i32,
 }
diff --git a/schist_core/schist_models/src/schema.rs b/schist_core/schist_models/src/schema.rs
index 40af56f..1c9fc62 100644
--- a/schist_core/schist_models/src/schema.rs
+++ b/schist_core/schist_models/src/schema.rs
@@ -23,14 +23,14 @@ diesel::table! {
 diesel::table! {
     budget_drips (id) {
         id -> Integer,
-        category_id -> Integer,
+        bucket_id -> Integer,
         date -> Text,
         quantity -> Integer,
     }
 }
 
 diesel::table! {
-    categories (id) {
+    buckets (id) {
         id -> Integer,
         name -> Text,
         balance -> Integer,
@@ -43,12 +43,12 @@ diesel::table! {
 }
 
 diesel::table! {
-    category_transfers (id) {
+    bucket_transfers (id) {
         id -> Integer,
         description -> Text,
         quantity -> Integer,
-        from_category_id -> Integer,
-        to_category_id -> Integer,
+        from_bucket_id -> Integer,
+        to_bucket_id -> Integer,
     }
 }
 
@@ -58,7 +58,7 @@ diesel::table! {
         description -> Text,
         quantity -> Integer,
         transaction_id -> Integer,
-        category_id -> Integer,
+        bucket_id -> Integer,
     }
 }
 
@@ -73,8 +73,8 @@ diesel::table! {
     }
 }
 
-diesel::joinable!(budget_drips -> categories (category_id));
-diesel::joinable!(transaction_categorisations -> categories (category_id));
+diesel::joinable!(budget_drips -> buckets (bucket_id));
+diesel::joinable!(transaction_categorisations -> buckets (bucket_id));
 diesel::joinable!(transaction_categorisations -> transactions (transaction_id));
 diesel::joinable!(transactions -> accounts (account_id));
 
@@ -82,8 +82,8 @@ diesel::allow_tables_to_appear_in_same_query!(
     account_transfers,
     accounts,
     budget_drips,
-    categories,
-    category_transfers,
+    buckets,
+    bucket_transfers,
     transaction_categorisations,
     transactions,
 );
diff --git a/schist_core/schist_models/src/transaction_categorisation.rs b/schist_core/schist_models/src/transaction_categorisation.rs
index c6ac6ea..36752ee 100644
--- a/schist_core/schist_models/src/transaction_categorisation.rs
+++ b/schist_core/schist_models/src/transaction_categorisation.rs
@@ -8,5 +8,5 @@ pub struct TransactionCategorisation {
     pub description: String,
     pub quantity: i32,
     pub transaction_id: i32,
-    pub category_id: i32,
+    pub bucket_id: i32,
 }
diff --git a/schist_core/schist_queries/src/bucket_transfers.rs b/schist_core/schist_queries/src/bucket_transfers.rs
new file mode 100644
index 0000000..2145944
--- /dev/null
+++ b/schist_core/schist_queries/src/bucket_transfers.rs
@@ -0,0 +1,74 @@
+use anyhow::{Context, Result};
+use diesel::{dsl::sum, QueryDsl, RunQueryDsl, SelectableHelper, SqliteConnection};
+use schist_schema::schema::bucket_transfers::{
+    self as bucket_transfers_schema,
+    dsl::bucket_transfers as bucket_transfers_table,
+};
+use schist_models::bucket_transfer::BucketTransfer;
+
+pub fn delete_all_bucket_transfers(connection: &mut SqliteConnection) -> Result<usize> {
+    let num_rows_deleted = diesel::delete(bucket_transfers_table)
+        .execute(connection)
+        .with_context(|| "failed to delete all bucket transfers")?;
+    Ok(num_rows_deleted)
+}
+
+pub fn get_all_bucket_transfers(connection: &mut SqliteConnection) -> Result<Vec<BucketTransfer>> {
+    let all_bucket_transfers = bucket_transfers_table
+        .select(BucketTransfer::as_select())
+        .load(connection)
+        .with_context(|| "failed to get all bucket transfers")?;
+    Ok(all_bucket_transfers)
+}
+
+pub fn insert_bucket_transfers(
+    bucket_transfers: &[BucketTransfer],
+    connection: &mut SqliteConnection,
+) -> Result<usize> {
+    let num_rows_inserted = diesel::insert_into(bucket_transfers_table)
+        .values(bucket_transfers)
+        .execute(connection)
+        .with_context(|| insert_err_msg(&bucket_transfers))?;
+    Ok(num_rows_inserted)
+}
+
+fn insert_err_msg(bucket_transfers: &[BucketTransfer]) -> String {
+    format!(
+        "failed to insert bucket transfers: [{}]",
+        bucket_transfers
+            .iter()
+            .map(|ct| ct.id.to_string())
+            .collect::<Vec<String>>()
+            .join(", ")
+    )
+}
+
+pub fn sum_bucket_transfer_quantity_per_from_bucket_id(
+    connection: &mut SqliteConnection,
+) -> Result<Vec<(i32, i64)>> {
+    let sum = bucket_transfers_table
+        .group_by(bucket_transfers_schema::from_bucket_id)
+        .select((
+            bucket_transfers_schema::from_bucket_id,
+            sum(bucket_transfers_schema::quantity),
+        ))
+        .load::<(i32, Option<i64>)>(connection)
+        .map(|result| result.iter().map(|sum| (sum.0, sum.1.unwrap_or(0))).collect())
+        .with_context(|| "failed to sum bucket transfer quantity per from bucket ID")?;
+    Ok(sum)
+}
+
+pub fn sum_bucket_transfer_quantity_per_to_bucket_id(
+    connection: &mut SqliteConnection,
+) -> Result<Vec<(i32, i64)>> {
+    let sum = bucket_transfers_table
+        .group_by(bucket_transfers_schema::to_bucket_id)
+        .select((
+            bucket_transfers_schema::to_bucket_id,
+            sum(bucket_transfers_schema::quantity),
+        ))
+        .load::<(i32, Option<i64>)>(connection)
+        .map(|vec| vec.iter().map(|(id, sum)| (*id, sum.unwrap_or(0))).collect())
+        .with_context(|| "failed to sum bucket transfer quantity per to bucket ID")?;
+    Ok(sum)
+}
diff --git a/schist_core/schist_queries/src/buckets.rs b/schist_core/schist_queries/src/buckets.rs
new file mode 100644
index 0000000..c7cf213
--- /dev/null
+++ b/schist_core/schist_queries/src/buckets.rs
@@ -0,0 +1,49 @@
+use anyhow::{Context, Result};
+use diesel::{QueryDsl, RunQueryDsl, SelectableHelper, SqliteConnection};
+use schist_models::bucket::Bucket;
+use schist_schema::schema::buckets::{self as buckets_schema, dsl::buckets as buckets_table};
+
+pub fn delete_all_buckets(connection: &mut SqliteConnection) -> Result<usize> {
+    let num_rows_deleted = diesel::delete(buckets_table)
+        .execute(connection)
+        .with_context(|| "failed to delete all buckets")?;
+    Ok(num_rows_deleted)
+}
+
+pub fn get_all_buckets(connection: &mut SqliteConnection) -> Result<Vec<Bucket>> {
+    let all_buckets = buckets_table
+        .select(Bucket::as_select())
+        .load(connection)
+        .with_context(|| "failed to get all buckets")?;
+    Ok(all_buckets)
+}
+
+pub fn get_all_bucket_ids(connection: &mut SqliteConnection) -> Result<Vec<i32>> {
+    let all_bucket_ids = buckets_table
+        .select(buckets_schema::id)
+        .load(connection)
+        .with_context(|| "failed to get all bucket IDs")?;
+    Ok(all_bucket_ids)
+}
+
+pub fn insert_buckets(
+    buckets: &[Bucket],
+    connection: &mut SqliteConnection,
+) -> Result<usize> {
+    let num_buckets_inserted = diesel::insert_into(buckets_table)
+        .values(buckets)
+        .execute(connection)
+        .with_context(|| insert_err_msg(buckets))?;
+    Ok(num_buckets_inserted)
+}
+
+fn insert_err_msg(buckets: &[Bucket]) -> String {
+    format!(
+        "failed to insert buckets: [{}]",
+        buckets
+            .iter()
+            .map(|c| format!("\"{}\": \"{}\"", c.id, c.name))
+            .collect::<Vec<String>>()
+            .join(", ")
+    )
+}
diff --git a/schist_core/schist_queries/src/categories.rs b/schist_core/schist_queries/src/categories.rs
deleted file mode 100644
index f4a9747..0000000
--- a/schist_core/schist_queries/src/categories.rs
+++ /dev/null
@@ -1,49 +0,0 @@
-use anyhow::{Context, Result};
-use diesel::{QueryDsl, RunQueryDsl, SelectableHelper, SqliteConnection};
-use schist_models::category::Category;
-use schist_schema::schema::categories::{self as categories_schema, dsl::categories as categories_table};
-
-pub fn delete_all_categories(connection: &mut SqliteConnection) -> Result<usize> {
-    let num_rows_deleted = diesel::delete(categories_table)
-        .execute(connection)
-        .with_context(|| "failed to delete all categories")?;
-    Ok(num_rows_deleted)
-}
-
-pub fn get_all_categories(connection: &mut SqliteConnection) -> Result<Vec<Category>> {
-    let all_categories = categories_table
-        .select(Category::as_select())
-        .load(connection)
-        .with_context(|| "failed to get all categories")?;
-    Ok(all_categories)
-}
-
-pub fn get_all_category_ids(connection: &mut SqliteConnection) -> Result<Vec<i32>> {
-    let all_category_ids = categories_table
-        .select(categories_schema::id)
-        .load(connection)
-        .with_context(|| "failed to get all category IDs")?;
-    Ok(all_category_ids)
-}
-
-pub fn insert_categories(
-    categories: &[Category],
-    connection: &mut SqliteConnection,
-) -> Result<usize> {
-    let num_categories_inserted = diesel::insert_into(categories_table)
-        .values(categories)
-        .execute(connection)
-        .with_context(|| insert_err_msg(categories))?;
-    Ok(num_categories_inserted)
-}
-
-fn insert_err_msg(categories: &[Category]) -> String {
-    format!(
-        "failed to insert categories: [{}]",
-        categories
-            .iter()
-            .map(|c| format!("\"{}\": \"{}\"", c.id, c.name))
-            .collect::<Vec<String>>()
-            .join(", ")
-    )
-}
diff --git a/schist_core/schist_queries/src/category_transfers.rs b/schist_core/schist_queries/src/category_transfers.rs
deleted file mode 100644
index 33a53ea..0000000
--- a/schist_core/schist_queries/src/category_transfers.rs
+++ /dev/null
@@ -1,74 +0,0 @@
-use anyhow::{Context, Result};
-use diesel::{dsl::sum, QueryDsl, RunQueryDsl, SelectableHelper, SqliteConnection};
-use schist_schema::schema::category_transfers::{
-    self as category_transfers_schema,
-    dsl::category_transfers as category_transfers_table,
-};
-use schist_models::category_transfer::CategoryTransfer;
-
-pub fn delete_all_category_transfers(connection: &mut SqliteConnection) -> Result<usize> {
-    let num_rows_deleted = diesel::delete(category_transfers_table)
-        .execute(connection)
-        .with_context(|| "failed to delete all category transfers")?;
-    Ok(num_rows_deleted)
-}
-
-pub fn get_all_category_transfers(connection: &mut SqliteConnection) -> Result<Vec<CategoryTransfer>> {
-    let all_category_transfers = category_transfers_table
-        .select(CategoryTransfer::as_select())
-        .load(connection)
-        .with_context(|| "failed to get all category transfers")?;
-    Ok(all_category_transfers)
-}
-
-pub fn insert_category_transfers(
-    category_transfers: &[CategoryTransfer],
-    connection: &mut SqliteConnection,
-) -> Result<usize> {
-    let num_rows_inserted = diesel::insert_into(category_transfers_table)
-        .values(category_transfers)
-        .execute(connection)
-        .with_context(|| insert_err_msg(&category_transfers))?;
-    Ok(num_rows_inserted)
-}
-
-fn insert_err_msg(category_transfers: &[CategoryTransfer]) -> String {
-    format!(
-        "failed to insert category transfers: [{}]",
-        category_transfers
-            .iter()
-            .map(|ct| ct.id.to_string())
-            .collect::<Vec<String>>()
-            .join(", ")
-    )
-}
-
-pub fn sum_category_transfer_quantity_per_from_category_id(
-    connection: &mut SqliteConnection,
-) -> Result<Vec<(i32, i64)>> {
-    let sum = category_transfers_table
-        .group_by(category_transfers_schema::from_category_id)
-        .select((
-            category_transfers_schema::from_category_id,
-            sum(category_transfers_schema::quantity),
-        ))
-        .load::<(i32, Option<i64>)>(connection)
-        .map(|result| result.iter().map(|sum| (sum.0, sum.1.unwrap_or(0))).collect())
-        .with_context(|| "failed to sum category transfer quantity per from category ID")?;
-    Ok(sum)
-}
-
-pub fn sum_category_transfer_quantity_per_to_category_id(
-    connection: &mut SqliteConnection,
-) -> Result<Vec<(i32, i64)>> {
-    let sum = category_transfers_table
-        .group_by(category_transfers_schema::to_category_id)
-        .select((
-            category_transfers_schema::to_category_id,
-            sum(category_transfers_schema::quantity),
-        ))
-        .load::<(i32, Option<i64>)>(connection)
-        .map(|vec| vec.iter().map(|(id, sum)| (*id, sum.unwrap_or(0))).collect())
-        .with_context(|| "failed to sum category transfer quantity per to category ID")?;
-    Ok(sum)
-}
diff --git a/schist_core/schist_queries/src/clear.rs b/schist_core/schist_queries/src/clear.rs
index 7cee699..6d2894d 100644
--- a/schist_core/schist_queries/src/clear.rs
+++ b/schist_core/schist_queries/src/clear.rs
@@ -2,14 +2,14 @@ use anyhow::Result;
 use diesel::SqliteConnection;
 
 use crate::{
-    accounts::delete_all_accounts, budget_drips::delete_all_budget_drips, categories::delete_all_categories, category_transfers::delete_all_category_transfers, transaction_categorisations::delete_all_transaction_categorisations, transactions::delete_all_transactions
+    accounts::delete_all_accounts, budget_drips::delete_all_budget_drips, buckets::delete_all_buckets, bucket_transfers::delete_all_bucket_transfers, transaction_categorisations::delete_all_transaction_categorisations, transactions::delete_all_transactions
 };
 
 pub fn clear(connection: &mut SqliteConnection) -> Result<()> {
     delete_all_accounts(connection)?;
     delete_all_budget_drips(connection)?;
-    delete_all_categories(connection)?;
-    delete_all_category_transfers(connection)?;
+    delete_all_buckets(connection)?;
+    delete_all_bucket_transfers(connection)?;
     delete_all_transactions(connection)?;
     delete_all_transaction_categorisations(connection)?;
     Ok(())
diff --git a/schist_core/schist_queries/src/lib.rs b/schist_core/schist_queries/src/lib.rs
index a1a5c20..e3e5488 100644
--- a/schist_core/schist_queries/src/lib.rs
+++ b/schist_core/schist_queries/src/lib.rs
@@ -1,8 +1,8 @@
 pub mod accounts;
 pub mod account_transfers;
 pub mod budget_drips;
-pub mod categories;
-pub mod category_transfers;
+pub mod buckets;
+pub mod bucket_transfers;
 pub mod clear;
 pub mod transactions;
 pub mod transaction_categorisations;
diff --git a/schist_core/schist_queries/src/transaction_categorisations.rs b/schist_core/schist_queries/src/transaction_categorisations.rs
index 320782d..95aaf8d 100644
--- a/schist_core/schist_queries/src/transaction_categorisations.rs
+++ b/schist_core/schist_queries/src/transaction_categorisations.rs
@@ -43,17 +43,17 @@ fn insert_err_msg(transaction_categorisations: &[TransactionCategorisation]) ->
     )
 }
 
-pub fn sum_transaction_categorisation_quantity_per_category_id(
+pub fn sum_transaction_categorisation_quantity_per_bucket_id(
     connection: &mut SqliteConnection,
 ) -> Result<Vec<(i32, i64)>> {
     let sum = transaction_categorisations_table
-        .group_by(transaction_categorisations_schema::category_id)
+        .group_by(transaction_categorisations_schema::bucket_id)
         .select((
-            transaction_categorisations_schema::category_id,
+            transaction_categorisations_schema::bucket_id,
             sum(transaction_categorisations_schema::quantity),
         ))
         .load::<(i32, Option<i64>)>(connection)
-        .map(|vec| vec.iter().map(|(category_id, sum)| (*category_id, sum.unwrap_or(0))).collect())
-        .with_context(|| "failed to sum transaction categorisation quantity per category ID")?;
+        .map(|vec| vec.iter().map(|(bucket_id, sum)| (*bucket_id, sum.unwrap_or(0))).collect())
+        .with_context(|| "failed to sum transaction categorisation quantity per bucket ID")?;
     Ok(sum)
 }
diff --git a/schist_core/schist_queries/src/transactions.rs b/schist_core/schist_queries/src/transactions.rs
index 70b14e7..5941ebc 100644
--- a/schist_core/schist_queries/src/transactions.rs
+++ b/schist_core/schist_queries/src/transactions.rs
@@ -14,7 +14,7 @@ pub fn get_all_transactions(connection: &mut SqliteConnection) -> Result<Vec<Tra
     let all_transactions = transactions_table
         .select(Transaction::as_select())
         .load(connection)
-        .with_context(|| "failed to get all category transfers")?;
+        .with_context(|| "failed to get all bucket transfers")?;
     Ok(all_transactions)
 }
 
diff --git a/schist_core/schist_queries/src/utils/calculate_bucket_balance.rs b/schist_core/schist_queries/src/utils/calculate_bucket_balance.rs
new file mode 100644
index 0000000..5194084
--- /dev/null
+++ b/schist_core/schist_queries/src/utils/calculate_bucket_balance.rs
@@ -0,0 +1,130 @@
+use anyhow::Result;
+use schist_models::{bucket::Bucket, budget_drip::BudgetDrip};
+
+use super::{calculate_budgets_accrual, find_by_id_or};
+
+pub fn calculate_bucket_balance(
+    bucket: &Bucket,
+    transaction_sums: &[(i32, i64)],
+    bucket_transfer_from_sums: &[(i32, i64)],
+    bucket_transfer_to_sums: &[(i32, i64)],
+    budget_drips: &[BudgetDrip],
+) -> Result<i64> {
+    let transaction_sum = find_by_id_or(transaction_sums, bucket.id, 0);
+    let bucket_transfer_from_sum = find_by_id_or(bucket_transfer_from_sums, bucket.id, 0);
+    let bucket_transfer_to_sum = find_by_id_or(bucket_transfer_to_sums, bucket.id, 0);
+    let budget_accruals_sum = calculate_budgets_accrual(bucket, budget_drips)?;
+
+    Ok(
+        transaction_sum
+            + budget_accruals_sum
+            + bucket_transfer_to_sum
+            - bucket_transfer_from_sum
+    )
+}
+
+#[cfg(test)]
+mod test {
+    use schist_fakes::{budget_drip::make_fake_budget_drip_builder, bucket::make_fake_bucket};
+
+    use super::calculate_bucket_balance;
+
+    #[test]
+    fn when_no_data_then_returns_zero() {
+        let bucket = make_fake_bucket(0);
+
+        let result = calculate_bucket_balance(&bucket, &[], &[], &[], &[]);
+
+        assert!(result.is_ok());
+        assert_eq!(result.unwrap(), 0_i64);
+    }
+
+    #[test]
+    fn when_data_only_for_another_bucket_then_returns_zero() {
+        let bucket = make_fake_bucket(0);
+        let transaction_sums = [(1, 100)];
+        let bucket_transfer_from_sums = [(1, 91)];
+        let bucket_transfer_to_sums = [(2, 79)];
+        let budget_drips = [
+            make_fake_budget_drip_builder(0).quantity(100).bucket_id(1).build().unwrap(),
+        ];
+
+        let result = calculate_bucket_balance(
+            &bucket,
+            &transaction_sums,
+            &bucket_transfer_from_sums,
+            &bucket_transfer_to_sums,
+            &budget_drips,
+        );
+
+        assert!(result.is_ok());
+        assert_eq!(result.unwrap(), 0_i64);
+    }
+
+    #[test]
+    fn when_transaction_sum_is_zero_then_returns_zero() {
+        let bucket = make_fake_bucket(0);
+        let transaction_sums = [(0, 0)];
+        let bucket_transfer_from_sums = [];
+        let bucket_transfer_to_sums = [];
+        let budget_drips = [];
+
+        let result = calculate_bucket_balance(
+            &bucket,
+            &transaction_sums,
+            &bucket_transfer_from_sums,
+            &bucket_transfer_to_sums,
+            &budget_drips,
+        );
+
+        assert!(result.is_ok());
+        assert_eq!(result.unwrap(), 0_i64);
+    }
+
+    #[test]
+    fn when_bucket_transfers_are_zero_then_returns_zero() {
+        let bucket = make_fake_bucket(0);
+        let transaction_sums = [];
+        let bucket_transfer_from_sums = [(0, 0)];
+        let bucket_transfer_to_sums = [(0, 0)];
+        let budget_drips = [];
+
+        let result = calculate_bucket_balance(
+            &bucket,
+            &transaction_sums,
+            &bucket_transfer_from_sums,
+            &bucket_transfer_to_sums,
+            &budget_drips,
+        );
+
+        assert!(result.is_ok());
+        assert_eq!(result.unwrap(), 0_i64);
+    }
+
+    #[test]
+    fn when_some_data_then_calculates_as_expected() {
+        let bucket = make_fake_bucket(0);
+        let transaction_sums = [(0, 100)];
+        let bucket_transfer_from_sums = [(0, 91)];
+        let bucket_transfer_to_sums = [(0, 79)];
+        let budget_drips = [
+            make_fake_budget_drip_builder(0).quantity(77).bucket_id(0).build().unwrap(),
+            make_fake_budget_drip_builder(0).quantity(77).bucket_id(0).build().unwrap(),
+            make_fake_budget_drip_builder(0).quantity(77).bucket_id(0).build().unwrap(),
+            make_fake_budget_drip_builder(0).quantity(77).bucket_id(0).build().unwrap(),
+            make_fake_budget_drip_builder(0).quantity(77).bucket_id(0).build().unwrap(),
+        ];
+
+        let result = calculate_bucket_balance(
+            &bucket,
+            &transaction_sums,
+            &bucket_transfer_from_sums,
+            &bucket_transfer_to_sums,
+            &budget_drips,
+        );
+
+        let expected_result = 100 + (-91) + 79 + 77 * 5;
+        assert!(result.is_ok());
+        assert_eq!(result.unwrap(), expected_result);
+    }
+}
diff --git a/schist_core/schist_queries/src/utils/calculate_budgets_accrual.rs b/schist_core/schist_queries/src/utils/calculate_budgets_accrual.rs
index ca82953..cbf7180 100644
--- a/schist_core/schist_queries/src/utils/calculate_budgets_accrual.rs
+++ b/schist_core/schist_queries/src/utils/calculate_budgets_accrual.rs
@@ -1,13 +1,13 @@
 use anyhow::Result;
 use schist_models::{
     budget_drip::BudgetDrip,
-    category::Category,
+    bucket::Bucket,
 };
 
-pub fn calculate_budgets_accrual(category: &Category, budget_drips: &[BudgetDrip]) -> Result<i64> {
+pub fn calculate_budgets_accrual(bucket: &Bucket, budget_drips: &[BudgetDrip]) -> Result<i64> {
     Ok(budget_drips
         .iter()
-        .filter(|bd| bd.category_id == category.id)
+        .filter(|bd| bd.bucket_id == bucket.id)
         .map(|bd| Into::<i64>::into(bd.quantity))
         .sum()
     )
@@ -15,29 +15,29 @@ pub fn calculate_budgets_accrual(category: &Category, budget_drips: &[BudgetDrip
 
 #[cfg(test)]
 mod test {
-    use schist_fakes::{budget_drip::make_fake_budget_drip_builder, category::make_fake_category};
+    use schist_fakes::{budget_drip::make_fake_budget_drip_builder, bucket::make_fake_bucket};
 
     use super::calculate_budgets_accrual;
 
     #[test]
     fn when_no_budget_drips_then_return_zero() {
-        let category = make_fake_category(0);
+        let bucket = make_fake_bucket(0);
         let budget_drips = [];
 
-        let result = calculate_budgets_accrual(&category, &budget_drips);
+        let result = calculate_budgets_accrual(&bucket, &budget_drips);
 
         assert!(result.is_ok());
         assert_eq!(result.unwrap(), 0_i64);
     }
 
     #[test]
-    fn when_one_budget_drip_for_another_category_then_return_zero() {
-        let category = make_fake_category(0);
+    fn when_one_budget_drip_for_another_bucket_then_return_zero() {
+        let bucket = make_fake_bucket(0);
         let budget_drips = [
-            make_fake_budget_drip_builder(0).quantity(100).category_id(1).build().unwrap(),
+            make_fake_budget_drip_builder(0).quantity(100).bucket_id(1).build().unwrap(),
         ];
 
-        let result = calculate_budgets_accrual(&category, &budget_drips);
+        let result = calculate_budgets_accrual(&bucket, &budget_drips);
 
         assert!(result.is_ok());
         assert_eq!(result.unwrap(), 0_i64);
@@ -45,12 +45,12 @@ mod test {
 
     #[test]
     fn when_one_budget_drip_then_return_quantity() {
-        let category = make_fake_category(0);
+        let bucket = make_fake_bucket(0);
         let budget_drips = [
-            make_fake_budget_drip_builder(0).quantity(100).category_id(0).build().unwrap(),
+            make_fake_budget_drip_builder(0).quantity(100).bucket_id(0).build().unwrap(),
         ];
 
-        let result = calculate_budgets_accrual(&category, &budget_drips);
+        let result = calculate_budgets_accrual(&bucket, &budget_drips);
 
         assert!(result.is_ok());
         assert_eq!(result.unwrap(), 100);
@@ -58,13 +58,13 @@ mod test {
 
     #[test]
     fn when_two_budget_drips_then_return_sum() {
-        let category = make_fake_category(0);
+        let bucket = make_fake_bucket(0);
         let budget_drips = [
-            make_fake_budget_drip_builder(0).quantity(100).category_id(0).build().unwrap(),
-            make_fake_budget_drip_builder(1).quantity(120).category_id(0).build().unwrap(),
+            make_fake_budget_drip_builder(0).quantity(100).bucket_id(0).build().unwrap(),
+            make_fake_budget_drip_builder(1).quantity(120).bucket_id(0).build().unwrap(),
         ];
 
-        let result = calculate_budgets_accrual(&category, &budget_drips);
+        let result = calculate_budgets_accrual(&bucket, &budget_drips);
 
         assert!(result.is_ok());
         assert_eq!(result.unwrap(), 220);
diff --git a/schist_core/schist_queries/src/utils/calculate_category_balance.rs b/schist_core/schist_queries/src/utils/calculate_category_balance.rs
deleted file mode 100644
index 73e80cd..0000000
--- a/schist_core/schist_queries/src/utils/calculate_category_balance.rs
+++ /dev/null
@@ -1,130 +0,0 @@
-use anyhow::Result;
-use schist_models::{budget_drip::BudgetDrip, category::Category};
-
-use super::{calculate_budgets_accrual, find_by_id_or};
-
-pub fn calculate_category_balance(
-    category: &Category,
-    transaction_sums: &[(i32, i64)],
-    category_transfer_from_sums: &[(i32, i64)],
-    category_transfer_to_sums: &[(i32, i64)],
-    budget_drips: &[BudgetDrip],
-) -> Result<i64> {
-    let transaction_sum = find_by_id_or(transaction_sums, category.id, 0);
-    let category_transfer_from_sum = find_by_id_or(category_transfer_from_sums, category.id, 0);
-    let category_transfer_to_sum = find_by_id_or(category_transfer_to_sums, category.id, 0);
-    let budget_accruals_sum = calculate_budgets_accrual(category, budget_drips)?;
-
-    Ok(
-        transaction_sum
-            + budget_accruals_sum
-            + category_transfer_to_sum
-            - category_transfer_from_sum
-    )
-}
-
-#[cfg(test)]
-mod test {
-    use schist_fakes::{budget_drip::make_fake_budget_drip_builder, category::make_fake_category};
-
-    use super::calculate_category_balance;
-
-    #[test]
-    fn when_no_data_then_returns_zero() {
-        let category = make_fake_category(0);
-
-        let result = calculate_category_balance(&category, &[], &[], &[], &[]);
-
-        assert!(result.is_ok());
-        assert_eq!(result.unwrap(), 0_i64);
-    }
-
-    #[test]
-    fn when_data_only_for_another_category_then_returns_zero() {
-        let category = make_fake_category(0);
-        let transaction_sums = [(1, 100)];
-        let category_transfer_from_sums = [(1, 91)];
-        let category_transfer_to_sums = [(2, 79)];
-        let budget_drips = [
-            make_fake_budget_drip_builder(0).quantity(100).category_id(1).build().unwrap(),
-        ];
-
-        let result = calculate_category_balance(
-            &category,
-            &transaction_sums,
-            &category_transfer_from_sums,
-            &category_transfer_to_sums,
-            &budget_drips,
-        );
-
-        assert!(result.is_ok());
-        assert_eq!(result.unwrap(), 0_i64);
-    }
-
-    #[test]
-    fn when_transaction_sum_is_zero_then_returns_zero() {
-        let category = make_fake_category(0);
-        let transaction_sums = [(0, 0)];
-        let category_transfer_from_sums = [];
-        let category_transfer_to_sums = [];
-        let budget_drips = [];
-
-        let result = calculate_category_balance(
-            &category,
-            &transaction_sums,
-            &category_transfer_from_sums,
-            &category_transfer_to_sums,
-            &budget_drips,
-        );
-
-        assert!(result.is_ok());
-        assert_eq!(result.unwrap(), 0_i64);
-    }
-
-    #[test]
-    fn when_category_transfers_are_zero_then_returns_zero() {
-        let category = make_fake_category(0);
-        let transaction_sums = [];
-        let category_transfer_from_sums = [(0, 0)];
-        let category_transfer_to_sums = [(0, 0)];
-        let budget_drips = [];
-
-        let result = calculate_category_balance(
-            &category,
-            &transaction_sums,
-            &category_transfer_from_sums,
-            &category_transfer_to_sums,
-            &budget_drips,
-        );
-
-        assert!(result.is_ok());
-        assert_eq!(result.unwrap(), 0_i64);
-    }
-
-    #[test]
-    fn when_some_data_then_calculates_as_expected() {
-        let category = make_fake_category(0);
-        let transaction_sums = [(0, 100)];
-        let category_transfer_from_sums = [(0, 91)];
-        let category_transfer_to_sums = [(0, 79)];
-        let budget_drips = [
-            make_fake_budget_drip_builder(0).quantity(77).category_id(0).build().unwrap(),
-            make_fake_budget_drip_builder(0).quantity(77).category_id(0).build().unwrap(),
-            make_fake_budget_drip_builder(0).quantity(77).category_id(0).build().unwrap(),
-            make_fake_budget_drip_builder(0).quantity(77).category_id(0).build().unwrap(),
-            make_fake_budget_drip_builder(0).quantity(77).category_id(0).build().unwrap(),
-        ];
-
-        let result = calculate_category_balance(
-            &category,
-            &transaction_sums,
-            &category_transfer_from_sums,
-            &category_transfer_to_sums,
-            &budget_drips,
-        );
-
-        let expected_result = 100 + (-91) + 79 + 77 * 5;
-        assert!(result.is_ok());
-        assert_eq!(result.unwrap(), expected_result);
-    }
-}
diff --git a/schist_core/schist_queries/src/utils/mod.rs b/schist_core/schist_queries/src/utils/mod.rs
index f2653d8..c006a9b 100644
--- a/schist_core/schist_queries/src/utils/mod.rs
+++ b/schist_core/schist_queries/src/utils/mod.rs
@@ -1,8 +1,8 @@
 mod calculate_budgets_accrual;
-mod calculate_category_balance;
+mod calculate_bucket_balance;
 mod find_by_id_or;
 
 use calculate_budgets_accrual::calculate_budgets_accrual;
 
-pub use calculate_category_balance::calculate_category_balance;
+pub use calculate_bucket_balance::calculate_bucket_balance;
 pub use find_by_id_or::find_by_id_or;
diff --git a/schist_core/schist_queries/tests/budget_drips.rs b/schist_core/schist_queries/tests/budget_drips.rs
index ac33885..7c5bd4d 100644
--- a/schist_core/schist_queries/tests/budget_drips.rs
+++ b/schist_core/schist_queries/tests/budget_drips.rs
@@ -2,29 +2,29 @@ mod common;
 
 use common::test_context::TestContext;
 use diesel::{Connection, SqliteConnection};
-use schist_fakes::{budget_drip::make_fake_budget_drip_builder, category::make_fake_category};
-use schist_models::{category::Category, date_utc::DateUtc};
+use schist_fakes::{budget_drip::make_fake_budget_drip_builder, bucket::make_fake_bucket};
+use schist_models::{bucket::Bucket, date_utc::DateUtc};
 use schist_queries as queries;
 
-fn given_categories(connection: &mut SqliteConnection) -> Vec<Category> {
-    let categories = vec![make_fake_category(0), make_fake_category(1)];
-    let _ = queries::categories::insert_categories(&categories, connection);
-    categories
+fn given_buckets(connection: &mut SqliteConnection) -> Vec<Bucket> {
+    let buckets = vec![make_fake_bucket(0), make_fake_bucket(1)];
+    let _ = queries::buckets::insert_buckets(&buckets, connection);
+    buckets
 }
 
 #[test]
 fn when_insert_budget_drips_then_returns_num_budget_drips() {
     let context = TestContext::new();
     let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
-    let _categories = given_categories(connection);
+    let _buckets = given_buckets(connection);
     let budget_drips = [
         make_fake_budget_drip_builder(0)
             .date(DateUtc::from_ymd(2020, 12, 25).unwrap())
-            .category_id(0)
+            .bucket_id(0)
             .build().unwrap(),
         make_fake_budget_drip_builder(1)
             .date(DateUtc::from_ymd(2020, 12, 26).unwrap())
-            .category_id(0)
+            .bucket_id(0)
             .build().unwrap(),
     ];
 
@@ -34,14 +34,14 @@ fn when_insert_budget_drips_then_returns_num_budget_drips() {
 }
 
 #[test]
-fn given_budget_drip_when_insert_budget_drip_same_category_and_same_date_then_return_err() {
+fn given_budget_drip_when_insert_budget_drip_same_bucket_and_same_date_then_return_err() {
     let context = TestContext::new();
     let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
-    let _categories = given_categories(connection);
+    let _buckets = given_buckets(connection);
 
     let budget_drips_1 = [
         make_fake_budget_drip_builder(0)
-            .category_id(0)
+            .bucket_id(0)
             .date(DateUtc::from_ymd(2020, 12, 25).unwrap())
             .build().unwrap()
     ];
@@ -49,7 +49,7 @@ fn given_budget_drip_when_insert_budget_drip_same_category_and_same_date_then_re
 
     let budget_drips_2 = [
         make_fake_budget_drip_builder(1)
-            .category_id(0)
+            .bucket_id(0)
             .date(DateUtc::from_ymd(2020, 12, 25).unwrap())
             .build().unwrap()
     ];
@@ -59,14 +59,14 @@ fn given_budget_drip_when_insert_budget_drip_same_category_and_same_date_then_re
 }
 
 #[test]
-fn given_budget_drip_when_insert_budget_drip_different_category_and_same_date_then_return_num_budget_drips_inserted() {
+fn given_budget_drip_when_insert_budget_drip_different_bucket_and_same_date_then_return_num_budget_drips_inserted() {
     let context = TestContext::new();
     let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
-    let _categories = given_categories(connection);
+    let _buckets = given_buckets(connection);
 
     let budget_drips_1 = [
         make_fake_budget_drip_builder(0)
-            .category_id(0)
+            .bucket_id(0)
             .date(DateUtc::from_ymd(2020, 12, 25).unwrap())
             .build().unwrap()
     ];
@@ -74,7 +74,7 @@ fn given_budget_drip_when_insert_budget_drip_different_category_and_same_date_th
 
     let budget_drips_2 = [
         make_fake_budget_drip_builder(1)
-            .category_id(1)
+            .bucket_id(1)
             .date(DateUtc::from_ymd(2020, 12, 25).unwrap())
             .build().unwrap()
     ];
@@ -85,14 +85,14 @@ fn given_budget_drip_when_insert_budget_drip_different_category_and_same_date_th
 }
 
 #[test]
-fn given_budget_drip_when_insert_budget_drip_same_category_and_different_date_then_return_num_budget_drips_inserted() {
+fn given_budget_drip_when_insert_budget_drip_same_bucket_and_different_date_then_return_num_budget_drips_inserted() {
     let context = TestContext::new();
     let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
-    let _categories = given_categories(connection);
+    let _buckets = given_buckets(connection);
 
     let budget_drips_1 = [
         make_fake_budget_drip_builder(0)
-            .category_id(0)
+            .bucket_id(0)
             .date(DateUtc::from_ymd(2020, 12, 25).unwrap())
             .build().unwrap()
     ];
@@ -100,7 +100,7 @@ fn given_budget_drip_when_insert_budget_drip_same_category_and_different_date_th
 
     let budget_drips_2 = [
         make_fake_budget_drip_builder(1)
-            .category_id(0)
+            .bucket_id(0)
             .date(DateUtc::from_ymd(2020, 12, 26).unwrap())
             .build().unwrap()
     ];
@@ -114,15 +114,15 @@ fn given_budget_drip_when_insert_budget_drip_same_category_and_different_date_th
 fn given_budget_drips_when_get_all_budget_drips_then_return_budget_drips() {
     let context = TestContext::new();
     let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
-    let _categories = given_categories(connection);
+    let _buckets = given_buckets(connection);
     let budget_drips = [
         make_fake_budget_drip_builder(0)
             .date(DateUtc::from_ymd(2020, 12, 25).unwrap())
-            .category_id(0)
+            .bucket_id(0)
             .build().unwrap(),
         make_fake_budget_drip_builder(1)
             .date(DateUtc::from_ymd(2020, 12, 26).unwrap())
-            .category_id(0)
+            .bucket_id(0)
             .build().unwrap(),
     ];
     let _ = queries::budget_drips::insert_budget_drips(&budget_drips, connection).unwrap();
@@ -144,15 +144,15 @@ fn given_budget_drips_when_get_all_budget_drips_then_return_budget_drips() {
 fn given_budget_drips_when_delete_all_budget_drips_then_return_num_of_budget_drips() {
     let context = TestContext::new();
     let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
-    let _categories = given_categories(connection);
+    let _buckets = given_buckets(connection);
     let budget_drips = [
         make_fake_budget_drip_builder(0)
             .date(DateUtc::from_ymd(2020, 12, 25).unwrap())
-            .category_id(0)
+            .bucket_id(0)
             .build().unwrap(),
         make_fake_budget_drip_builder(1)
             .date(DateUtc::from_ymd(2020, 12, 26).unwrap())
-            .category_id(0)
+            .bucket_id(0)
             .build().unwrap(),
     ];
     let _ = queries::budget_drips::insert_budget_drips(&budget_drips, connection).unwrap();
@@ -166,15 +166,15 @@ fn given_budget_drips_when_delete_all_budget_drips_then_return_num_of_budget_dri
 fn given_deleted_budget_drips_when_get_all_budget_drips_then_return_empty() {
     let context = TestContext::new();
     let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
-    let _categories = given_categories(connection);
+    let _buckets = given_buckets(connection);
     let budget_drips = [
         make_fake_budget_drip_builder(0)
             .date(DateUtc::from_ymd(2020, 12, 25).unwrap())
-            .category_id(0)
+            .bucket_id(0)
             .build().unwrap(),
         make_fake_budget_drip_builder(1)
             .date(DateUtc::from_ymd(2020, 12, 26).unwrap())
-            .category_id(0)
+            .bucket_id(0)
             .build().unwrap(),
     ];
     let _ = queries::budget_drips::insert_budget_drips(&budget_drips, connection).unwrap();
diff --git a/schist_core/schist_queries/tests/categories.rs b/schist_core/schist_queries/tests/categories.rs
index 915e853..5ef6552 100644
--- a/schist_core/schist_queries/tests/categories.rs
+++ b/schist_core/schist_queries/tests/categories.rs
@@ -2,80 +2,80 @@ mod common;
 
 use common::test_context::TestContext;
 use diesel::{Connection, SqliteConnection};
-use schist_fakes::category::make_fake_category;
-use schist_models::category::Category;
+use schist_fakes::bucket::make_fake_bucket;
+use schist_models::bucket::Bucket;
 use schist_queries as queries;
 
-fn given_categories(connection: &mut SqliteConnection) -> Vec<Category> {
-    let categories = vec![make_fake_category(0), make_fake_category(1)];
-    let _ = queries::categories::insert_categories(&categories, connection).unwrap();
-    categories
+fn given_buckets(connection: &mut SqliteConnection) -> Vec<Bucket> {
+    let buckets = vec![make_fake_bucket(0), make_fake_bucket(1)];
+    let _ = queries::buckets::insert_buckets(&buckets, connection).unwrap();
+    buckets
 }
 
 #[test]
-fn when_insert_categories_then_returns_num_categories() {
+fn when_insert_buckets_then_returns_num_buckets() {
     let context = TestContext::new();
     let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
-    let categories = [make_fake_category(0), make_fake_category(1)];
+    let buckets = [make_fake_bucket(0), make_fake_bucket(1)];
 
-    let num_categories_inserted = queries::categories::insert_categories(&categories, connection).unwrap();
+    let num_buckets_inserted = queries::buckets::insert_buckets(&buckets, connection).unwrap();
 
-    assert_eq!(num_categories_inserted, 2);
+    assert_eq!(num_buckets_inserted, 2);
 }
 
 #[test]
-fn given_categories_when_get_all_categories_then_return_categories() {
+fn given_buckets_when_get_all_buckets_then_return_buckets() {
     let context = TestContext::new();
     let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
-    let categories = given_categories(connection);
+    let buckets = given_buckets(connection);
 
-    let categories_in_db = queries::categories::get_all_categories(connection).unwrap();
+    let buckets_in_db = queries::buckets::get_all_buckets(connection).unwrap();
 
-    assert_eq!(categories_in_db.len(), categories.len());
-    for category in &categories {
-        assert!(categories_in_db.iter().any(|category_in_db| category_in_db.eq(&category)));
+    assert_eq!(buckets_in_db.len(), buckets.len());
+    for bucket in &buckets {
+        assert!(buckets_in_db.iter().any(|bucket_in_db| bucket_in_db.eq(&bucket)));
     }
-    for category_in_db in categories_in_db {
-        assert!(categories.iter().any(|category| category.eq(&category_in_db)));
+    for bucket_in_db in buckets_in_db {
+        assert!(buckets.iter().any(|bucket| bucket.eq(&bucket_in_db)));
     }
 }
 
 #[test]
-fn given_categories_when_delete_all_categories_then_return_num_of_categories() {
+fn given_buckets_when_delete_all_buckets_then_return_num_of_buckets() {
     let context = TestContext::new();
     let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
-    let categories = given_categories(connection);
+    let buckets = given_buckets(connection);
 
-    let num_categories_deleted = queries::categories::delete_all_categories(connection).unwrap();
+    let num_buckets_deleted = queries::buckets::delete_all_buckets(connection).unwrap();
 
-    assert_eq!(num_categories_deleted, categories.len());
+    assert_eq!(num_buckets_deleted, buckets.len());
 }
 
 #[test]
-fn given_deleted_categories_when_get_all_categories_then_return_empty() {
+fn given_deleted_buckets_when_get_all_buckets_then_return_empty() {
     let context = TestContext::new();
     let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
-    given_categories(connection);
-    let _ = queries::categories::delete_all_categories(connection).unwrap();
+    given_buckets(connection);
+    let _ = queries::buckets::delete_all_buckets(connection).unwrap();
 
-    let categories_returned = queries::categories::get_all_categories(connection).unwrap();
+    let buckets_returned = queries::buckets::get_all_buckets(connection).unwrap();
 
-    assert_eq!(categories_returned.len(), 0);
+    assert_eq!(buckets_returned.len(), 0);
 }
 
 #[test]
-fn given_categories_when_get_all_ids_then_return_all_ids() {
+fn given_buckets_when_get_all_ids_then_return_all_ids() {
     let context = TestContext::new();
     let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
-    let categories = given_categories(connection);
+    let buckets = given_buckets(connection);
 
-    let ids = queries::categories::get_all_category_ids(connection).unwrap();
+    let ids = queries::buckets::get_all_bucket_ids(connection).unwrap();
 
-    assert_eq!(categories.len(), ids.len());
-    for category in &categories {
-        assert!(ids.iter().any(|id| category.id == *id));
+    assert_eq!(buckets.len(), ids.len());
+    for bucket in &buckets {
+        assert!(ids.iter().any(|id| bucket.id == *id));
     }
     for id in ids {
-        assert!(categories.iter().any(|category| category.id == id));
+        assert!(buckets.iter().any(|bucket| bucket.id == id));
     }
 }
diff --git a/schist_core/schist_queries/tests/category_transfers.rs b/schist_core/schist_queries/tests/category_transfers.rs
index f37a668..e913dcb 100644
--- a/schist_core/schist_queries/tests/category_transfers.rs
+++ b/schist_core/schist_queries/tests/category_transfers.rs
@@ -2,125 +2,125 @@ mod common;
 
 use common::test_context::TestContext;
 use diesel::{Connection, SqliteConnection};
-use schist_fakes::{category::make_fake_category, category_transfer::make_fake_category_transfer_builder};
+use schist_fakes::{bucket::make_fake_bucket, bucket_transfer::make_fake_bucket_transfer_builder};
 use schist_queries as queries;
 
 #[test]
-fn when_insert_category_transfers_then_returns_num_category_transfers() {
+fn when_insert_bucket_transfers_then_returns_num_bucket_transfers() {
     let context = TestContext::new();
     let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
-    let categories = [make_fake_category(0), make_fake_category(1)];
-    let category_transfers = [
-        make_fake_category_transfer_builder(0).from_category_id(0).to_category_id(1).build().unwrap(),
-        make_fake_category_transfer_builder(1).from_category_id(0).to_category_id(1).build().unwrap(),
+    let buckets = [make_fake_bucket(0), make_fake_bucket(1)];
+    let bucket_transfers = [
+        make_fake_bucket_transfer_builder(0).from_bucket_id(0).to_bucket_id(1).build().unwrap(),
+        make_fake_bucket_transfer_builder(1).from_bucket_id(0).to_bucket_id(1).build().unwrap(),
     ];
-    let _ = queries::categories::insert_categories(&categories, connection);
+    let _ = queries::buckets::insert_buckets(&buckets, connection);
 
-    let num_category_transfers_inserted = queries::category_transfers::insert_category_transfers(&category_transfers, connection).unwrap();
+    let num_bucket_transfers_inserted = queries::bucket_transfers::insert_bucket_transfers(&bucket_transfers, connection).unwrap();
 
-    assert_eq!(num_category_transfers_inserted, 2);
+    assert_eq!(num_bucket_transfers_inserted, 2);
 }
 
 #[test]
-fn given_category_transfers_when_get_all_category_transfers_then_return_category_transfers() {
+fn given_bucket_transfers_when_get_all_bucket_transfers_then_return_bucket_transfers() {
     let context = TestContext::new();
     let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
-    let categories = [make_fake_category(0), make_fake_category(1)];
-    let category_transfers = [
-        make_fake_category_transfer_builder(0).from_category_id(0).to_category_id(1).build().unwrap(),
-        make_fake_category_transfer_builder(1).from_category_id(0).to_category_id(1).build().unwrap(),
+    let buckets = [make_fake_bucket(0), make_fake_bucket(1)];
+    let bucket_transfers = [
+        make_fake_bucket_transfer_builder(0).from_bucket_id(0).to_bucket_id(1).build().unwrap(),
+        make_fake_bucket_transfer_builder(1).from_bucket_id(0).to_bucket_id(1).build().unwrap(),
     ];
-    let _ = queries::categories::insert_categories(&categories, connection);
-    let _ = queries::category_transfers::insert_category_transfers(&category_transfers, connection).unwrap();
+    let _ = queries::buckets::insert_buckets(&buckets, connection);
+    let _ = queries::bucket_transfers::insert_bucket_transfers(&bucket_transfers, connection).unwrap();
 
-    let category_transfers_in_db = queries::category_transfers::get_all_category_transfers(connection).unwrap();
+    let bucket_transfers_in_db = queries::bucket_transfers::get_all_bucket_transfers(connection).unwrap();
 
-    assert_eq!(category_transfers_in_db.len(), category_transfers.len());
-    for category_transfer in &category_transfers {
-        assert!(category_transfers_in_db.iter().any(|category_transfer_in_db| category_transfer_in_db.eq(&category_transfer)));
+    assert_eq!(bucket_transfers_in_db.len(), bucket_transfers.len());
+    for bucket_transfer in &bucket_transfers {
+        assert!(bucket_transfers_in_db.iter().any(|bucket_transfer_in_db| bucket_transfer_in_db.eq(&bucket_transfer)));
     }
-    for category_transfer_in_db in category_transfers_in_db {
-        assert!(category_transfers.iter().any(|category_transfer| category_transfer.eq(&category_transfer_in_db)));
+    for bucket_transfer_in_db in bucket_transfers_in_db {
+        assert!(bucket_transfers.iter().any(|bucket_transfer| bucket_transfer.eq(&bucket_transfer_in_db)));
     }
 }
 
 #[test]
-fn given_category_transfers_when_delete_all_category_transfers_then_return_num_of_category_transfers() {
+fn given_bucket_transfers_when_delete_all_bucket_transfers_then_return_num_of_bucket_transfers() {
     let context = TestContext::new();
     let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
-    let categories = [make_fake_category(0), make_fake_category(1)];
-    let category_transfers = [
-        make_fake_category_transfer_builder(0).from_category_id(0).to_category_id(1).build().unwrap(),
-        make_fake_category_transfer_builder(1).from_category_id(0).to_category_id(1).build().unwrap(),
+    let buckets = [make_fake_bucket(0), make_fake_bucket(1)];
+    let bucket_transfers = [
+        make_fake_bucket_transfer_builder(0).from_bucket_id(0).to_bucket_id(1).build().unwrap(),
+        make_fake_bucket_transfer_builder(1).from_bucket_id(0).to_bucket_id(1).build().unwrap(),
     ];
-    let _ = queries::categories::insert_categories(&categories, connection);
-    let _ = queries::category_transfers::insert_category_transfers(&category_transfers, connection).unwrap();
+    let _ = queries::buckets::insert_buckets(&buckets, connection);
+    let _ = queries::bucket_transfers::insert_bucket_transfers(&bucket_transfers, connection).unwrap();
 
-    let num_category_transfers_deleted = queries::category_transfers::delete_all_category_transfers(connection).unwrap();
+    let num_bucket_transfers_deleted = queries::bucket_transfers::delete_all_bucket_transfers(connection).unwrap();
 
-    assert_eq!(num_category_transfers_deleted, category_transfers.len());
+    assert_eq!(num_bucket_transfers_deleted, bucket_transfers.len());
 }
 
 #[test]
-fn given_deleted_category_transfers_when_get_all_category_transfers_then_return_empty() {
+fn given_deleted_bucket_transfers_when_get_all_bucket_transfers_then_return_empty() {
     let context = TestContext::new();
     let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
-    let categories = [make_fake_category(0), make_fake_category(1)];
-    let category_transfers = [
-        make_fake_category_transfer_builder(0).from_category_id(0).to_category_id(1).build().unwrap(),
-        make_fake_category_transfer_builder(1).from_category_id(0).to_category_id(1).build().unwrap(),
+    let buckets = [make_fake_bucket(0), make_fake_bucket(1)];
+    let bucket_transfers = [
+        make_fake_bucket_transfer_builder(0).from_bucket_id(0).to_bucket_id(1).build().unwrap(),
+        make_fake_bucket_transfer_builder(1).from_bucket_id(0).to_bucket_id(1).build().unwrap(),
     ];
-    let _ = queries::categories::insert_categories(&categories, connection);
-    let _ = queries::category_transfers::insert_category_transfers(&category_transfers, connection).unwrap();
-    let _ = queries::category_transfers::delete_all_category_transfers(connection).unwrap();
+    let _ = queries::buckets::insert_buckets(&buckets, connection);
+    let _ = queries::bucket_transfers::insert_bucket_transfers(&bucket_transfers, connection).unwrap();
+    let _ = queries::bucket_transfers::delete_all_bucket_transfers(connection).unwrap();
 
-    let category_transfers_returned = queries::category_transfers::get_all_category_transfers(connection).unwrap();
+    let bucket_transfers_returned = queries::bucket_transfers::get_all_bucket_transfers(connection).unwrap();
 
-    assert_eq!(category_transfers_returned.len(), 0);
+    assert_eq!(bucket_transfers_returned.len(), 0);
 }
 
 #[test]
-fn given_category_transfers_when_sum_quantity_per_from_category_id_then_returns_sum_per_from_category_id() {
+fn given_bucket_transfers_when_sum_quantity_per_from_bucket_id_then_returns_sum_per_from_bucket_id() {
     let context = TestContext::new();
     let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
-    let categories = [make_fake_category(0), make_fake_category(1)];
-    let category_transfers = [
-        make_fake_category_transfer_builder(0).from_category_id(0).to_category_id(1).quantity(1).build().unwrap(),
-        make_fake_category_transfer_builder(1).from_category_id(0).to_category_id(1).quantity(2).build().unwrap(),
-        make_fake_category_transfer_builder(2).from_category_id(1).to_category_id(0).quantity(4).build().unwrap(),
+    let buckets = [make_fake_bucket(0), make_fake_bucket(1)];
+    let bucket_transfers = [
+        make_fake_bucket_transfer_builder(0).from_bucket_id(0).to_bucket_id(1).quantity(1).build().unwrap(),
+        make_fake_bucket_transfer_builder(1).from_bucket_id(0).to_bucket_id(1).quantity(2).build().unwrap(),
+        make_fake_bucket_transfer_builder(2).from_bucket_id(1).to_bucket_id(0).quantity(4).build().unwrap(),
     ];
-    let _ = queries::categories::insert_categories(&categories, connection);
-    let _ = queries::category_transfers::insert_category_transfers(&category_transfers, connection).unwrap();
+    let _ = queries::buckets::insert_buckets(&buckets, connection);
+    let _ = queries::bucket_transfers::insert_bucket_transfers(&bucket_transfers, connection).unwrap();
 
-    let sums = queries::category_transfers::sum_category_transfer_quantity_per_from_category_id(connection);
+    let sums = queries::bucket_transfers::sum_bucket_transfer_quantity_per_from_bucket_id(connection);
 
     assert!(sums.is_ok());
     let mut sums = sums.unwrap();
     sums.sort_by_key(|sum| sum.0);
-    assert_eq!(categories.len(), sums.len());
+    assert_eq!(buckets.len(), sums.len());
     assert_eq!(3, sums[0].1);
     assert_eq!(4, sums[1].1);
 }
 
 #[test]
-fn given_category_transfers_when_sum_quantity_per_to_category_id_then_returns_sum_per_to_category_id() {
+fn given_bucket_transfers_when_sum_quantity_per_to_bucket_id_then_returns_sum_per_to_bucket_id() {
     let context = TestContext::new();
     let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
-    let categories = [make_fake_category(0), make_fake_category(1)];
-    let category_transfers = [
-        make_fake_category_transfer_builder(0).from_category_id(0).to_category_id(1).quantity(1).build().unwrap(),
-        make_fake_category_transfer_builder(1).from_category_id(0).to_category_id(1).quantity(2).build().unwrap(),
-        make_fake_category_transfer_builder(2).from_category_id(1).to_category_id(0).quantity(4).build().unwrap(),
+    let buckets = [make_fake_bucket(0), make_fake_bucket(1)];
+    let bucket_transfers = [
+        make_fake_bucket_transfer_builder(0).from_bucket_id(0).to_bucket_id(1).quantity(1).build().unwrap(),
+        make_fake_bucket_transfer_builder(1).from_bucket_id(0).to_bucket_id(1).quantity(2).build().unwrap(),
+        make_fake_bucket_transfer_builder(2).from_bucket_id(1).to_bucket_id(0).quantity(4).build().unwrap(),
     ];
-    let _ = queries::categories::insert_categories(&categories, connection);
-    let _ = queries::category_transfers::insert_category_transfers(&category_transfers, connection).unwrap();
+    let _ = queries::buckets::insert_buckets(&buckets, connection);
+    let _ = queries::bucket_transfers::insert_bucket_transfers(&bucket_transfers, connection).unwrap();
 
-    let sums = queries::category_transfers::sum_category_transfer_quantity_per_to_category_id(connection);
+    let sums = queries::bucket_transfers::sum_bucket_transfer_quantity_per_to_bucket_id(connection);
 
     assert!(sums.is_ok());
     let mut sums = sums.unwrap();
     sums.sort_by_key(|sum| sum.0);
-    assert_eq!(categories.len(), sums.len());
+    assert_eq!(buckets.len(), sums.len());
     assert_eq!(4, sums[0].1);
     assert_eq!(3, sums[1].1);
 }
diff --git a/schist_core/schist_queries/tests/transaction_categorisations.rs b/schist_core/schist_queries/tests/transaction_categorisations.rs
index 13864b4..bb88896 100644
--- a/schist_core/schist_queries/tests/transaction_categorisations.rs
+++ b/schist_core/schist_queries/tests/transaction_categorisations.rs
@@ -2,8 +2,8 @@ mod common;
 
 use common::test_context::TestContext;
 use diesel::{Connection, SqliteConnection};
-use schist_fakes::{account::make_fake_account, category::make_fake_category, transaction::make_fake_transaction_builder, transaction_categorisation::make_fake_transaction_categorisation_builder};
-use schist_models::{account::Account, category::Category, transaction::Transaction};
+use schist_fakes::{account::make_fake_account, bucket::make_fake_bucket, transaction::make_fake_transaction_builder, transaction_categorisation::make_fake_transaction_categorisation_builder};
+use schist_models::{account::Account, bucket::Bucket, transaction::Transaction};
 use schist_queries as queries;
 
 fn given_accounts(connection: &mut SqliteConnection) -> Vec<Account> {
@@ -12,10 +12,10 @@ fn given_accounts(connection: &mut SqliteConnection) -> Vec<Account> {
     accounts
 }
 
-fn given_categories(connection: &mut SqliteConnection) -> Vec<Category> {
-    let categories = vec![make_fake_category(0), make_fake_category(1)];
-    let _ = queries::categories::insert_categories(&categories, connection);
-    categories
+fn given_buckets(connection: &mut SqliteConnection) -> Vec<Bucket> {
+    let buckets = vec![make_fake_bucket(0), make_fake_bucket(1)];
+    let _ = queries::buckets::insert_buckets(&buckets, connection);
+    buckets
 }
 
 fn given_transactions(connection: &mut SqliteConnection) -> Vec<Transaction> {
@@ -32,11 +32,11 @@ fn when_insert_transaction_categorisations_then_returns_num_transaction_categori
     let context = TestContext::new();
     let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
     given_accounts(connection);
-    given_categories(connection);
+    given_buckets(connection);
     given_transactions(connection);
     let transaction_categorisations = [
-        make_fake_transaction_categorisation_builder(0).category_id(0).build().unwrap(),
-        make_fake_transaction_categorisation_builder(1).category_id(0).build().unwrap(),
+        make_fake_transaction_categorisation_builder(0).bucket_id(0).build().unwrap(),
+        make_fake_transaction_categorisation_builder(1).bucket_id(0).build().unwrap(),
     ];
 
     let num_transaction_categorisations_inserted = queries::transaction_categorisations::insert_transaction_categorisations(&transaction_categorisations, connection).unwrap();
@@ -49,11 +49,11 @@ fn given_transaction_categorisations_when_get_all_transaction_categorisations_th
     let context = TestContext::new();
     let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
     given_accounts(connection);
-    given_categories(connection);
+    given_buckets(connection);
     given_transactions(connection);
     let transaction_categorisations = [
-        make_fake_transaction_categorisation_builder(0).category_id(0).build().unwrap(),
-        make_fake_transaction_categorisation_builder(1).category_id(0).build().unwrap(),
+        make_fake_transaction_categorisation_builder(0).bucket_id(0).build().unwrap(),
+        make_fake_transaction_categorisation_builder(1).bucket_id(0).build().unwrap(),
     ];
     let _ = queries::transaction_categorisations::insert_transaction_categorisations(&transaction_categorisations, connection);
 
@@ -73,11 +73,11 @@ fn given_transaction_categorisations_when_delete_all_transaction_categorisations
     let context = TestContext::new();
     let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
     given_accounts(connection);
-    given_categories(connection);
+    given_buckets(connection);
     given_transactions(connection);
     let transaction_categorisations = [
-        make_fake_transaction_categorisation_builder(0).category_id(0).build().unwrap(),
-        make_fake_transaction_categorisation_builder(1).category_id(0).build().unwrap(),
+        make_fake_transaction_categorisation_builder(0).bucket_id(0).build().unwrap(),
+        make_fake_transaction_categorisation_builder(1).bucket_id(0).build().unwrap(),
     ];
     let _ = queries::transaction_categorisations::insert_transaction_categorisations(&transaction_categorisations, connection);
 
@@ -91,11 +91,11 @@ fn given_deleted_transaction_categorisations_when_get_all_transaction_categorisa
     let context = TestContext::new();
     let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
     given_accounts(connection);
-    given_categories(connection);
+    given_buckets(connection);
     given_transactions(connection);
     let transaction_categorisations = [
-        make_fake_transaction_categorisation_builder(0).category_id(0).build().unwrap(),
-        make_fake_transaction_categorisation_builder(1).category_id(0).build().unwrap(),
+        make_fake_transaction_categorisation_builder(0).bucket_id(0).build().unwrap(),
+        make_fake_transaction_categorisation_builder(1).bucket_id(0).build().unwrap(),
     ];
     let _ = queries::transaction_categorisations::insert_transaction_categorisations(&transaction_categorisations, connection);
     let _ = queries::transaction_categorisations::delete_all_transaction_categorisations(connection);
@@ -106,25 +106,25 @@ fn given_deleted_transaction_categorisations_when_get_all_transaction_categorisa
 }
 
 #[test]
-fn given_transaction_categorisations_when_sum_quantity_per_category_id_then_returns_sum_quantity_per_category_id() {
+fn given_transaction_categorisations_when_sum_quantity_per_bucket_id_then_returns_sum_quantity_per_bucket_id() {
     let context = TestContext::new();
     let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
     given_accounts(connection);
-    let categories = given_categories(connection);
+    let buckets = given_buckets(connection);
     given_transactions(connection);
     let transaction_categorisations = [
-        make_fake_transaction_categorisation_builder(0).category_id(0).quantity(1).build().unwrap(),
-        make_fake_transaction_categorisation_builder(1).category_id(0).quantity(2).build().unwrap(),
-        make_fake_transaction_categorisation_builder(2).category_id(1).quantity(4).build().unwrap(),
+        make_fake_transaction_categorisation_builder(0).bucket_id(0).quantity(1).build().unwrap(),
+        make_fake_transaction_categorisation_builder(1).bucket_id(0).quantity(2).build().unwrap(),
+        make_fake_transaction_categorisation_builder(2).bucket_id(1).quantity(4).build().unwrap(),
     ];
     let _ = queries::transaction_categorisations::insert_transaction_categorisations(&transaction_categorisations, connection);
 
-    let sums = queries::transaction_categorisations::sum_transaction_categorisation_quantity_per_category_id(connection);
+    let sums = queries::transaction_categorisations::sum_transaction_categorisation_quantity_per_bucket_id(connection);
 
     assert!(sums.is_ok());
     let mut sums = sums.unwrap();
     sums.sort_by_key(|sum| sum.0);
-    assert_eq!(categories.len(), sums.len());
+    assert_eq!(buckets.len(), sums.len());
     assert_eq!(3, sums[0].1);
     assert_eq!(4, sums[1].1);
 }