task-012 (#2)

Co-authored-by: Joe Carstairs <jcarstairs@scottlogic.com>
Reviewed-on: https://git.joeac.net/joeac/schist/pulls/2
Co-authored-by: Joe Carstairs <me@joeac.net>
Co-committed-by: Joe Carstairs <me@joeac.net>

43 files changed, 832 insertions, 631 deletions

diff --git a/schist_core/schist_fakes/src/account_transfer.rs b/schist_core/schist_fakes/src/account_transfer.rs
index f762c2f..703d7ce 100644
--- a/schist_core/schist_fakes/src/account_transfer.rs
+++ b/schist_core/schist_fakes/src/account_transfer.rs
@@ -1,17 +1,20 @@
-use schist_models::{date_utc::DateUtc, account_transfer::{AccountTransfer, AccountTransferBuilder}};
+use schist_models::{
+    account_transfer::{AccountTransfer, AccountTransferBuilder},
+    date_utc::DateUtc,
+};
 use schist_traits::nowlike::Nowlike;
 
 pub fn make_fake_account_transfer(id: i32) -> AccountTransfer {
     make_fake_account_transfer_builder(id).build().unwrap()
 }
 
-pub fn make_fake_account_transfer_builder(id: i32) ->  AccountTransferBuilder {
+pub fn make_fake_account_transfer_builder(id: i32) -> AccountTransferBuilder {
     let mut builder = AccountTransferBuilder::default();
     builder
         .id(id)
         .date(DateUtc::now())
         .description(String::from("Fake account transfer"))
-        .quantity(0)
+        .amount(0)
         .from_account_id(0)
         .to_account_id(1);
     builder
diff --git a/schist_core/schist_fakes/src/bucket.rs b/schist_core/schist_fakes/src/bucket.rs
index 1b447b2..fe03a83 100644
--- a/schist_core/schist_fakes/src/bucket.rs
+++ b/schist_core/schist_fakes/src/bucket.rs
@@ -1,9 +1,4 @@
-use schist_models::{
-    bucket::{Bucket, BucketBuilder},
-    budget_period_unit::BudgetPeriodUnit,
-    date_utc::DateUtc,
-};
-use schist_traits::nowlike::Nowlike;
+use schist_models::bucket::{Bucket, BucketBuilder};
 
 pub fn make_fake_bucket(id: i32) -> Bucket {
     make_fake_bucket_builder(id).build().unwrap()
@@ -14,11 +9,8 @@ pub fn make_fake_bucket_builder(id: i32) -> BucketBuilder {
     builder
         .id(id)
         .name(String::from("Fake bucket"))
-        .balance(0)
-        .balance_date(DateUtc::now())
-        .budget_period(0)
-        .budget_period_unit(BudgetPeriodUnit::Day)
-        .budget_quantity(0)
+        .balance(None)
+        .balance_cache_key(None)
         .group(String::from("Fake group"));
     builder
 }
diff --git a/schist_core/schist_fakes/src/bucket_transfer.rs b/schist_core/schist_fakes/src/bucket_transfer.rs
index 9bc1f80..bf5e71b 100644
--- a/schist_core/schist_fakes/src/bucket_transfer.rs
+++ b/schist_core/schist_fakes/src/bucket_transfer.rs
@@ -9,7 +9,7 @@ pub fn make_fake_bucket_transfer_builder(id: i32) -> BucketTransferBuilder {
     builder
         .id(id)
         .description(String::from("Fake bucket transfer"))
-        .quantity(0)
+        .amount(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
deleted file mode 100644
index 498dd76..0000000
--- a/schist_core/schist_fakes/src/budget_drip.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-use schist_models::{budget_drip::{BudgetDrip, BudgetDripBuilder}, date_utc::DateUtc};
-use schist_traits::nowlike::Nowlike;
-
-pub fn make_fake_budget_drip(id: i32) -> BudgetDrip {
-    make_fake_budget_drip_builder(id).build().unwrap()
-}
-
-pub fn make_fake_budget_drip_builder(id: i32) -> BudgetDripBuilder {
-    let mut builder = BudgetDripBuilder::default();
-    builder
-        .id(id)
-        .bucket_id(0)
-        .date(DateUtc::now())
-        .quantity(0);
-    builder
-}
diff --git a/schist_core/schist_fakes/src/drip.rs b/schist_core/schist_fakes/src/drip.rs
new file mode 100644
index 0000000..88f0b05
--- /dev/null
+++ b/schist_core/schist_fakes/src/drip.rs
@@ -0,0 +1,15 @@
+use schist_models::{
+    date_utc::DateUtc,
+    drip::{Drip, DripBuilder},
+};
+use schist_traits::nowlike::Nowlike;
+
+pub fn make_fake_drip(id: i32) -> Drip {
+    make_fake_drip_builder(id).build().unwrap()
+}
+
+pub fn make_fake_drip_builder(id: i32) -> DripBuilder {
+    let mut builder = DripBuilder::default();
+    builder.id(id).amount(0).bucket_id(0).date(DateUtc::now());
+    builder
+}
diff --git a/schist_core/schist_fakes/src/lib.rs b/schist_core/schist_fakes/src/lib.rs
index ba88fb5..0e4cbb4 100644
--- a/schist_core/schist_fakes/src/lib.rs
+++ b/schist_core/schist_fakes/src/lib.rs
@@ -1,7 +1,7 @@
 pub mod account;
 pub mod account_transfer;
 pub mod bucket;
-pub mod budget_drip;
 pub mod bucket_transfer;
+pub mod drip;
+pub mod pipe;
 pub mod transaction;
-pub mod transaction_categorisation;
diff --git a/schist_core/schist_fakes/src/pipe.rs b/schist_core/schist_fakes/src/pipe.rs
new file mode 100644
index 0000000..6e96401
--- /dev/null
+++ b/schist_core/schist_fakes/src/pipe.rs
@@ -0,0 +1,21 @@
+use schist_models::{
+    budget_period_unit::BudgetPeriodUnit,
+    date_utc::DateUtc,
+    pipe::{Pipe, PipeBuilder},
+};
+use schist_traits::nowlike::Nowlike;
+
+pub fn make_fake_pipe(id: i32) -> Pipe {
+    make_fake_pipe_builder(id).build().unwrap()
+}
+
+pub fn make_fake_pipe_builder(id: i32) -> PipeBuilder {
+    let mut builder = PipeBuilder::default();
+    builder
+        .id(id)
+        .amount(0)
+        .bucket_id(0)
+        .period(BudgetPeriodUnit::Day)
+        .start_date(DateUtc::now());
+    builder
+}
diff --git a/schist_core/schist_fakes/src/transaction.rs b/schist_core/schist_fakes/src/transaction.rs
index cee7e00..bce02e5 100644
--- a/schist_core/schist_fakes/src/transaction.rs
+++ b/schist_core/schist_fakes/src/transaction.rs
@@ -1,18 +1,23 @@
-use schist_models::{date_utc::DateUtc, transaction::{Transaction, TransactionBuilder}};
+use schist_models::{
+    date_utc::DateUtc,
+    transaction::{Transaction, TransactionBuilder},
+};
 use schist_traits::nowlike::Nowlike;
 
 pub fn make_fake_transaction(id: i32) -> Transaction {
     make_fake_transaction_builder(id).build().unwrap()
 }
 
-pub fn make_fake_transaction_builder(id: i32) ->  TransactionBuilder {
+pub fn make_fake_transaction_builder(id: i32) -> TransactionBuilder {
     let mut builder = TransactionBuilder::default();
     builder
         .id(id)
-        .description(String::from("Fake bucket transfer"))
-        .payee(String::from("Fake payee"))
-        .quantity(0)
+        .account_id(0)
+        .amount(0)
+        .bucket_id(None)
+        .counterparty(String::from("Fake payee"))
         .date(DateUtc::now())
+        .description(String::from("Fake transaction"))
         .account_id(0);
     builder
 }
diff --git a/schist_core/schist_fakes/src/transaction_categorisation.rs b/schist_core/schist_fakes/src/transaction_categorisation.rs
deleted file mode 100644
index 11b50c2..0000000
--- a/schist_core/schist_fakes/src/transaction_categorisation.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-use schist_models::transaction_categorisation::{TransactionCategorisation, TransactionCategorisationBuilder};
-
-pub fn make_fake_transaction_categorisation(id: i32) -> TransactionCategorisation {
-    make_fake_transaction_categorisation_builder(id).build().unwrap()
-}
-
-pub fn make_fake_transaction_categorisation_builder(id: i32) ->  TransactionCategorisationBuilder {
-    let mut builder = TransactionCategorisationBuilder::default();
-    builder
-        .id(id)
-        .description(String::from("Fake bucket transfer"))
-        .quantity(0)
-        .transaction_id(0)
-        .bucket_id(0);
-    builder
-}
diff --git a/schist_core/schist_models/diesel.toml b/schist_core/schist_models/diesel.toml
deleted file mode 100644
index 2b8ebd8..0000000
--- a/schist_core/schist_models/diesel.toml
+++ /dev/null
@@ -1,9 +0,0 @@
-# For documentation on how to configure this file,
-# see https://diesel.rs/guides/configuring-diesel-cli
-
-[print_schema]
-file = "src/schema.rs"
-custom_type_derives = ["diesel::query_builder::QueryId", "Clone"]
-
-[migrations_directory]
-dir = "/home/joeac/src/schist/rust/schist_models/migrations"
diff --git a/schist_core/schist_models/migrations/2024-08-31-084439_initial_setup/down.sql b/schist_core/schist_models/migrations/2024-08-31-084439_initial_setup/down.sql
index ba65012..3b2c73e 100644
--- a/schist_core/schist_models/migrations/2024-08-31-084439_initial_setup/down.sql
+++ b/schist_core/schist_models/migrations/2024-08-31-084439_initial_setup/down.sql
@@ -1,7 +1,7 @@
 DROP TABLE accounts;
 DROP TABLE account_transfers;
-DROP TABLE budget_drips;
-DROP TABLE categories;
-DROP TABLE transaction_categorisations;
-DROP TABLE category_transfers;
+DROP TABLE buckets;
+DROP TABLE bucket_transfers;
+DROP TABLE drips;
+DROP TABLE pipes;
 DROP TABLE transactions;
diff --git a/schist_core/schist_models/migrations/2024-08-31-084439_initial_setup/up.sql b/schist_core/schist_models/migrations/2024-08-31-084439_initial_setup/up.sql
index a09bf7b..275f280 100644
--- a/schist_core/schist_models/migrations/2024-08-31-084439_initial_setup/up.sql
+++ b/schist_core/schist_models/migrations/2024-08-31-084439_initial_setup/up.sql
@@ -9,9 +9,9 @@ CREATE TABLE accounts(
 
 CREATE TABLE account_transfers(
     id INTEGER NOT NULL PRIMARY KEY,
+    amount INTEGER NOT NULL,
     date TEXT NOT NULL,
     description TEXT NOT NULL,
-    quantity INTEGER NOT NULL,
     from_account_id INTEGER NOT NULL,
     to_account_id INTEGER NOT NULL,
     FOREIGN KEY (from_account_id)
@@ -24,70 +24,66 @@ CREATE TABLE account_transfers(
         ON DELETE RESTRICT
 );
 
-
-CREATE TABLE budget_drips(
+CREATE TABLE buckets(
     id INTEGER NOT NULL PRIMARY KEY,
-    category_id INTEGER NOT NULL,
-    date TEXT NOT NULL,
-    quantity INTEGER NOT NULL,
-    FOREIGN KEY (category_id)
-        REFERENCES categories (id)
-        ON UPDATE CASCADE
-        ON DELETE RESTRICT,
-    UNIQUE(category_id, date)
+    balance INTEGER,
+    balance_cache_key TEXT,
+    bucket_group TEXT NOT NULL,
+    name TEXT NOT NULL
 );
 
-CREATE TABLE categories(
-    id INTEGER NOT NULL PRIMARY KEY,
-    name TEXT NOT NULL,
-    balance INTEGER NOT NULL,
-    balance_date TEXT NOT NULL,
-    budget_period INTEGER NOT NULL,
-    budget_period_unit TEXT NOT NULL,
-    budget_quantity INTEGER NOT NULL
-);
-
-CREATE TABLE category_transfers(
+CREATE TABLE bucket_transfers(
     id INTEGER NOT NULL PRIMARY KEY,
+    amount INTEGER NOT NULL,
     description TEXT NOT NULL,
-    quantity INTEGER NOT NULL,
-    from_category_id INTEGER NOT NULL,
-    to_category_id INTEGER NOT NULL,
-    FOREIGN KEY (from_category_id)
-        REFERENCES categories (id)
+    from_bucket_id INTEGER NOT NULL,
+    to_bucket_id INTEGER NOT NULL,
+    FOREIGN KEY (from_bucket_id)
+        REFERENCES buckets (id)
         ON UPDATE CASCADE
         ON DELETE RESTRICT,
-    FOREIGN KEY (to_category_id)
-        REFERENCES categories (id)
+    FOREIGN KEY (to_bucket_id)
+        REFERENCES buckets (id)
         ON UPDATE CASCADE
         ON DELETE RESTRICT
 );
 
-CREATE TABLE transactions(
+CREATE TABLE drips(
     id INTEGER NOT NULL PRIMARY KEY,
-    description TEXT NOT NULL,
-    payee TEXT NOT NULL,
-    quantity INTEGER NOT NULL,
+    amount INTEGER NOT NULL,
+    bucket_id INTEGER NOT NULL,
     date TEXT NOT NULL,
-    account_id INTEGER NOT NULL,
-    FOREIGN KEY (account_id)
-        REFERENCES accounts (id)
+    inserted_at_unix_seconds INTEGER NOT NULL,
+    pipe_id INTEGER NOT NULL,
+    FOREIGN KEY (bucket_id)
+        REFERENCES buckets (id)
+        ON UPDATE CASCADE
+        ON DELETE RESTRICT,
+    UNIQUE(bucket_id, date)
+);
+
+CREATE TABLE pipes(
+    id INTEGER NOT NULL PRIMARY KEY,
+    amount INTEGER NOT NULL,
+    bucket_id INTEGER NOT NULL,
+    period TEXT NOT NULL,
+    start_date TEXT NOT NULL,
+    FOREIGN KEY (bucket_id)
+        REFERENCES buckets (id)
         ON UPDATE CASCADE
         ON DELETE RESTRICT
 );
 
-CREATE TABLE transaction_categorisations(
+CREATE TABLE transactions(
     id INTEGER NOT NULL PRIMARY KEY,
+    account_id INTEGER NOT NULL,
+    amount INTEGER NOT NULL,
+    bucket_id INTEGER,
+    counterparty TEXT NOT NULL,
+    date TEXT NOT NULL,
     description TEXT NOT NULL,
-    quantity INTEGER NOT NULL,
-    transaction_id INTEGER NOT NULL,
-    category_id INTEGER NOT NULL,
-    FOREIGN KEY (transaction_id)
-        REFERENCES transactions (id)
-        ON UPDATE CASCADE
-        ON DELETE RESTRICT,
-    FOREIGN KEY (category_id)
-        REFERENCES categories (id)
+    FOREIGN KEY (account_id)
+        REFERENCES accounts (id)
         ON UPDATE CASCADE
         ON DELETE RESTRICT
 );
diff --git a/schist_core/schist_models/migrations/2025-08-15-090859_dummy_data/down.sql b/schist_core/schist_models/migrations/2025-08-15-090859_dummy_data/down.sql
new file mode 100644
index 0000000..8050572
--- /dev/null
+++ b/schist_core/schist_models/migrations/2025-08-15-090859_dummy_data/down.sql
@@ -0,0 +1,39 @@
+DELETE FROM accounts
+    WHERE id=0
+    AND name="Nationwide bank account"
+    AND opening_balance=0
+    AND opening_date="2024-01-01";
+
+DELETE FROM accounts
+    WHERE id=1
+    AND name="cash account"
+    AND opening_balance=0
+    AND opening_date="2024-01-01";
+
+DELETE FROM accounts
+    WHERE id=2
+    AND name="YBS savings account"
+    AND opening_balance=0
+    AND opening_date="2024-01-01";
+
+DELETE FROM buckets
+    WHERE id=0
+    AND balance IS NULL
+    AND balance_cache_key IS NULL
+    AND bucket_group="normal expenses"
+    AND name="groceries";
+
+DELETE FROM buckets
+    WHERE id=1
+    AND balance IS NULL
+    AND balance_cache_key IS NULL
+    AND bucket_group="luxuries"
+    AND name="bevvy";
+
+DELETE FROM buckets
+    WHERE id=2
+    AND balance IS NULL
+    AND balance_cache_key IS NULL
+    AND bucket_group="income"
+    AND name="salary";
+
diff --git a/schist_core/schist_models/migrations/2025-08-15-090859_dummy_data/up.sql b/schist_core/schist_models/migrations/2025-08-15-090859_dummy_data/up.sql
new file mode 100644
index 0000000..f5c97d0
--- /dev/null
+++ b/schist_core/schist_models/migrations/2025-08-15-090859_dummy_data/up.sql
@@ -0,0 +1,14 @@
+INSERT INTO accounts
+    (id, name, opening_balance, opening_date)
+    VALUES
+    (0, "Nationwide bank account", 0, "2024-01-01"),
+    (1, "cash account", 0, "2024-01-01"),
+    (2, "YBS savings account", 0, "2024-01-01");
+
+INSERT INTO buckets
+    (id, balance, balance_cache_key, bucket_group, name)
+    VALUES
+    (0, NULL, NULL, "normal expenses", "groceries"),
+    (1, NULL, NULL, "luxuries", "bevvy"),
+    (2, NULL, NULL, "income", "salary");
+
diff --git a/schist_core/schist_models/src/account_transfer.rs b/schist_core/schist_models/src/account_transfer.rs
index 06c51ac..ba33dee 100644
--- a/schist_core/schist_models/src/account_transfer.rs
+++ b/schist_core/schist_models/src/account_transfer.rs
@@ -7,9 +7,9 @@ use crate::date_utc::DateUtc;
 #[diesel(table_name = crate::schema::account_transfers)]
 pub struct AccountTransfer {
     pub id: i32,
+    pub amount: i32,
     pub date: DateUtc,
     pub description: String,
-    pub quantity: i32,
     pub from_account_id: i32,
     pub to_account_id: i32,
 }
diff --git a/schist_core/schist_models/src/bucket.rs b/schist_core/schist_models/src/bucket.rs
index 1ee6a13..1a78628 100644
--- a/schist_core/schist_models/src/bucket.rs
+++ b/schist_core/schist_models/src/bucket.rs
@@ -2,8 +2,6 @@ use derive_builder::Builder;
 use diesel::prelude::*;
 use serde::{Deserialize, Serialize};
 
-use crate::{budget_period_unit::BudgetPeriodUnit, date_utc::DateUtc};
-
 #[derive(
     Builder,
     Clone,
@@ -19,11 +17,9 @@ use crate::{budget_period_unit::BudgetPeriodUnit, date_utc::DateUtc};
 #[diesel(table_name = crate::schema::buckets)]
 pub struct Bucket {
     pub id: i32,
-    pub name: String,
-    pub balance: i32,
-    pub balance_date: DateUtc,
-    pub budget_period: i32,
-    pub budget_period_unit: BudgetPeriodUnit,
-    pub budget_quantity: i32,
+    pub balance: Option<i32>,
+    pub balance_cache_key: Option<String>,
+    #[column_name = "bucket_group"]
     pub group: String,
+    pub name: String,
 }
diff --git a/schist_core/schist_models/src/bucket_transfer.rs b/schist_core/schist_models/src/bucket_transfer.rs
index bdf95d9..7c3a9d2 100644
--- a/schist_core/schist_models/src/bucket_transfer.rs
+++ b/schist_core/schist_models/src/bucket_transfer.rs
@@ -5,8 +5,8 @@ use diesel::prelude::*;
 #[diesel(table_name = crate::schema::bucket_transfers)]
 pub struct BucketTransfer {
     pub id: i32,
+    pub amount: i32,
     pub description: String,
-    pub quantity: 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
deleted file mode 100644
index 419c8f9..0000000
--- a/schist_core/schist_models/src/budget_drip.rs
+++ /dev/null
@@ -1,14 +0,0 @@
-use derive_builder::Builder;
-use diesel::prelude::{Identifiable, Insertable, Queryable, Selectable};
-use serde::{Deserialize, Serialize};
-
-use crate::date_utc::DateUtc;
-
-#[derive(Builder, Clone, Copy, Queryable, Identifiable, Selectable, Debug, PartialEq, Serialize, Deserialize, Insertable)]
-#[diesel(table_name = crate::schema::budget_drips)]
-pub struct BudgetDrip {
-    pub id: i32,
-    pub bucket_id: i32,
-    pub date: DateUtc,
-    pub quantity: i32,
-}
diff --git a/schist_core/schist_models/src/drip.rs b/schist_core/schist_models/src/drip.rs
new file mode 100644
index 0000000..f092ae9
--- /dev/null
+++ b/schist_core/schist_models/src/drip.rs
@@ -0,0 +1,28 @@
+use derive_builder::Builder;
+use diesel::prelude::{Identifiable, Insertable, Queryable, Selectable};
+use serde::{Deserialize, Serialize};
+
+use crate::date_utc::DateUtc;
+
+#[derive(
+    Builder,
+    Clone,
+    Copy,
+    Queryable,
+    Identifiable,
+    Insertable,
+    Selectable,
+    Debug,
+    PartialEq,
+    Serialize,
+    Deserialize,
+)]
+#[diesel(table_name = crate::schema::drips)]
+pub struct Drip {
+    pub id: i32,
+    pub amount: i32,
+    pub bucket_id: i32,
+    pub date: DateUtc,
+    pub inserted_at_unix_seconds: i32,
+    pub pipe_id: i32,
+}
diff --git a/schist_core/schist_models/src/lib.rs b/schist_core/schist_models/src/lib.rs
index db5c593..503db17 100644
--- a/schist_core/schist_models/src/lib.rs
+++ b/schist_core/schist_models/src/lib.rs
@@ -2,11 +2,11 @@ pub mod account;
 pub mod account_transfer;
 pub mod bucket;
 pub mod bucket_transfer;
-pub mod budget_drip;
 pub mod budget_period_unit;
 pub mod date_utc;
 pub mod datetime_utc;
+pub mod drip;
 pub mod migrations;
+pub mod pipe;
 pub mod schema;
 pub mod transaction;
-pub mod transaction_categorisation;
diff --git a/schist_core/schist_models/src/pipe.rs b/schist_core/schist_models/src/pipe.rs
new file mode 100644
index 0000000..fb66a20
--- /dev/null
+++ b/schist_core/schist_models/src/pipe.rs
@@ -0,0 +1,27 @@
+use derive_builder::Builder;
+use diesel::prelude::*;
+use serde::{Deserialize, Serialize};
+
+use crate::{budget_period_unit::BudgetPeriodUnit, date_utc::DateUtc};
+
+#[derive(
+    Builder,
+    Insertable,
+    Queryable,
+    Identifiable,
+    Selectable,
+    Debug,
+    PartialEq,
+    Clone,
+    Serialize,
+    Deserialize,
+)]
+#[diesel(table_name = crate::schema::pipes)]
+#[diesel(belongs_to(Bucket))]
+pub struct Pipe {
+    pub id: i32,
+    pub amount: i32,
+    pub bucket_id: i32,
+    pub period: BudgetPeriodUnit,
+    pub start_date: DateUtc,
+}
diff --git a/schist_core/schist_models/src/schema.rs b/schist_core/schist_models/src/schema.rs
index 1c9fc62..3799479 100644
--- a/schist_core/schist_models/src/schema.rs
+++ b/schist_core/schist_models/src/schema.rs
@@ -3,9 +3,9 @@
 diesel::table! {
     account_transfers (id) {
         id -> Integer,
+        amount -> Integer,
         date -> Text,
         description -> Text,
-        quantity -> Integer,
         from_account_id -> Integer,
         to_account_id -> Integer,
     }
@@ -21,69 +21,68 @@ diesel::table! {
 }
 
 diesel::table! {
-    budget_drips (id) {
+    bucket_transfers (id) {
         id -> Integer,
-        bucket_id -> Integer,
-        date -> Text,
-        quantity -> Integer,
+        amount -> Integer,
+        description -> Text,
+        from_bucket_id -> Integer,
+        to_bucket_id -> Integer,
     }
 }
 
 diesel::table! {
     buckets (id) {
         id -> Integer,
+        balance -> Nullable<Integer>,
+        balance_cache_key -> Nullable<Text>,
+        bucket_group -> Text,
         name -> Text,
-        balance -> Integer,
-        balance_date -> Text,
-        budget_period -> Integer,
-        budget_period_unit -> Text,
-        budget_quantity -> Integer,
-        group -> Text,
     }
 }
 
 diesel::table! {
-    bucket_transfers (id) {
+    drips (id) {
         id -> Integer,
-        description -> Text,
-        quantity -> Integer,
-        from_bucket_id -> Integer,
-        to_bucket_id -> Integer,
+        amount -> Integer,
+        bucket_id -> Integer,
+        date -> Text,
+        inserted_at_unix_seconds -> Integer,
+        pipe_id -> Integer,
     }
 }
 
 diesel::table! {
-    transaction_categorisations (id) {
+    pipes (id) {
         id -> Integer,
-        description -> Text,
-        quantity -> Integer,
-        transaction_id -> Integer,
+        amount -> Integer,
         bucket_id -> Integer,
+        period -> Text,
+        start_date -> Text,
     }
 }
 
 diesel::table! {
     transactions (id) {
         id -> Integer,
-        description -> Text,
-        payee -> Text,
-        quantity -> Integer,
-        date -> Text,
         account_id -> Integer,
+        amount -> Integer,
+        bucket_id -> Nullable<Integer>,
+        counterparty -> Text,
+        date -> Text,
+        description -> Text,
     }
 }
 
-diesel::joinable!(budget_drips -> buckets (bucket_id));
-diesel::joinable!(transaction_categorisations -> buckets (bucket_id));
-diesel::joinable!(transaction_categorisations -> transactions (transaction_id));
+diesel::joinable!(drips -> buckets (bucket_id));
+diesel::joinable!(pipes -> buckets (bucket_id));
 diesel::joinable!(transactions -> accounts (account_id));
 
 diesel::allow_tables_to_appear_in_same_query!(
     account_transfers,
     accounts,
-    budget_drips,
-    buckets,
     bucket_transfers,
-    transaction_categorisations,
+    buckets,
+    drips,
+    pipes,
     transactions,
 );
diff --git a/schist_core/schist_models/src/transaction.rs b/schist_core/schist_models/src/transaction.rs
index 9e983f5..7e754be 100644
--- a/schist_core/schist_models/src/transaction.rs
+++ b/schist_core/schist_models/src/transaction.rs
@@ -3,14 +3,17 @@ use diesel::prelude::{Associations, Identifiable, Insertable, Queryable, Selecta
 
 use crate::{account::Account, date_utc::DateUtc};
 
-#[derive(Builder, Clone, Queryable, Identifiable, Selectable, Insertable, Associations, Debug, PartialEq)]
+#[derive(
+    Builder, Clone, Queryable, Identifiable, Selectable, Insertable, Associations, Debug, PartialEq,
+)]
 #[diesel(table_name = crate::schema::transactions)]
 #[diesel(belongs_to(Account))]
 pub struct Transaction {
     pub id: i32,
-    pub description: String,
-    pub payee: String,
-    pub quantity: i32,
-    pub date: DateUtc,
     pub account_id: i32,
+    pub amount: i32,
+    pub bucket_id: Option<i32>,
+    pub counterparty: String,
+    pub date: DateUtc,
+    pub description: String,
 }
diff --git a/schist_core/schist_models/src/transaction_categorisation.rs b/schist_core/schist_models/src/transaction_categorisation.rs
deleted file mode 100644
index 36752ee..0000000
--- a/schist_core/schist_models/src/transaction_categorisation.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-use derive_builder::Builder;
-use diesel::prelude::*;
-
-#[derive(Builder, Queryable, Identifiable, Selectable, Insertable, Debug, PartialEq)]
-#[diesel(table_name = crate::schema::transaction_categorisations)]
-pub struct TransactionCategorisation {
-    pub id: i32,
-    pub description: String,
-    pub quantity: i32,
-    pub transaction_id: i32,
-    pub bucket_id: i32,
-}
diff --git a/schist_core/schist_models/user_data.sqlite b/schist_core/schist_models/user_data.sqlite
index a428ff0..175ce60 100644
--- a/schist_core/schist_models/user_data.sqlite
+++ b/schist_core/schist_models/user_data.sqlite
diff --git a/schist_core/schist_queries/src/accounts.rs b/schist_core/schist_queries/src/accounts.rs
index ead281a..289faf6 100644
--- a/schist_core/schist_queries/src/accounts.rs
+++ b/schist_core/schist_queries/src/accounts.rs
@@ -11,16 +11,14 @@ pub fn delete_all_accounts(connection: &mut SqliteConnection) -> Result<usize> {
 }
 
 pub fn get_all_accounts(connection: &mut SqliteConnection) -> Result<Vec<Account>> {
-    let all_accounts = accounts_table.select(Account::as_select())
+    let all_accounts = accounts_table
+        .select(Account::as_select())
         .load(connection)
         .with_context(|| "failed to get all accounts")?;
     Ok(all_accounts)
 }
 
-pub fn insert_accounts(
-    accounts: &[Account],
-    connection: &mut SqliteConnection,
-) -> Result<usize> {
+pub fn insert_accounts(accounts: &[Account], connection: &mut SqliteConnection) -> Result<usize> {
     let num_accounts_inserted = diesel::insert_into(accounts_table)
         .values(accounts)
         .execute(connection)
diff --git a/schist_core/schist_queries/src/bucket_transfers.rs b/schist_core/schist_queries/src/bucket_transfers.rs
index 2145944..923867f 100644
--- a/schist_core/schist_queries/src/bucket_transfers.rs
+++ b/schist_core/schist_queries/src/bucket_transfers.rs
@@ -1,10 +1,9 @@
 use anyhow::{Context, Result};
 use diesel::{dsl::sum, QueryDsl, RunQueryDsl, SelectableHelper, SqliteConnection};
+use schist_models::bucket_transfer::BucketTransfer;
 use schist_schema::schema::bucket_transfers::{
-    self as bucket_transfers_schema,
-    dsl::bucket_transfers as bucket_transfers_table,
+    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)
@@ -50,10 +49,15 @@ pub fn sum_bucket_transfer_quantity_per_from_bucket_id(
         .group_by(bucket_transfers_schema::from_bucket_id)
         .select((
             bucket_transfers_schema::from_bucket_id,
-            sum(bucket_transfers_schema::quantity),
+            sum(bucket_transfers_schema::amount),
         ))
         .load::<(i32, Option<i64>)>(connection)
-        .map(|result| result.iter().map(|sum| (sum.0, sum.1.unwrap_or(0))).collect())
+        .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)
 }
@@ -65,10 +69,14 @@ pub fn sum_bucket_transfer_quantity_per_to_bucket_id(
         .group_by(bucket_transfers_schema::to_bucket_id)
         .select((
             bucket_transfers_schema::to_bucket_id,
-            sum(bucket_transfers_schema::quantity),
+            sum(bucket_transfers_schema::amount),
         ))
         .load::<(i32, Option<i64>)>(connection)
-        .map(|vec| vec.iter().map(|(id, sum)| (*id, sum.unwrap_or(0))).collect())
+        .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
index c7cf213..29270af 100644
--- a/schist_core/schist_queries/src/buckets.rs
+++ b/schist_core/schist_queries/src/buckets.rs
@@ -26,10 +26,7 @@ pub fn get_all_bucket_ids(connection: &mut SqliteConnection) -> Result<Vec<i32>>
     Ok(all_bucket_ids)
 }
 
-pub fn insert_buckets(
-    buckets: &[Bucket],
-    connection: &mut SqliteConnection,
-) -> Result<usize> {
+pub fn insert_buckets(buckets: &[Bucket], connection: &mut SqliteConnection) -> Result<usize> {
     let num_buckets_inserted = diesel::insert_into(buckets_table)
         .values(buckets)
         .execute(connection)
diff --git a/schist_core/schist_queries/src/budget_drips.rs b/schist_core/schist_queries/src/budget_drips.rs
deleted file mode 100644
index b6f9372..0000000
--- a/schist_core/schist_queries/src/budget_drips.rs
+++ /dev/null
@@ -1,40 +0,0 @@
-use anyhow::{Context, Result};
-use diesel::{QueryDsl, RunQueryDsl, SelectableHelper, SqliteConnection};
-use schist_models::budget_drip::BudgetDrip;
-use schist_schema::schema::budget_drips::dsl::budget_drips as budget_drips_table;
-
-pub fn delete_all_budget_drips(connection: &mut SqliteConnection) -> Result<usize> {
-    let num_rows_deleted = diesel::delete(budget_drips_table)
-        .execute(connection)
-        .with_context(|| "failed to delete all budget drips")?;
-    Ok(num_rows_deleted)
-}
-
-pub fn get_all_budget_drips(connection: &mut SqliteConnection) -> Result<Vec<BudgetDrip>> {
-    let all_budget_drips = budget_drips_table.select(BudgetDrip::as_select())
-        .load(connection)
-        .with_context(|| "failed to get all budget drips")?;
-    Ok(all_budget_drips)
-}
-
-pub fn insert_budget_drips(
-    budget_drips: &[BudgetDrip],
-    connection: &mut SqliteConnection,
-) -> Result<usize> {
-    let num_budget_drips_inserted = diesel::insert_into(budget_drips_table)
-        .values(budget_drips)
-        .execute(connection)
-        .with_context(|| insert_err_msg(budget_drips))?;
-    Ok(num_budget_drips_inserted)
-}
-
-fn insert_err_msg(budget_drips: &[BudgetDrip]) -> String {
-    format!(
-        "failed to insert budget drips: [{}]",
-        budget_drips
-            .iter()
-            .map(|a| a.id.to_string())
-            .collect::<Vec<String>>()
-            .join(", ")
-    )
-}
diff --git a/schist_core/schist_queries/src/clear.rs b/schist_core/schist_queries/src/clear.rs
index 6d2894d..04d22d9 100644
--- a/schist_core/schist_queries/src/clear.rs
+++ b/schist_core/schist_queries/src/clear.rs
@@ -2,15 +2,17 @@ use anyhow::Result;
 use diesel::SqliteConnection;
 
 use crate::{
-    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
+    accounts::delete_all_accounts, bucket_transfers::delete_all_bucket_transfers,
+    buckets::delete_all_buckets, drips::delete_all_drips, pipes::delete_all_pipes,
+    transactions::delete_all_transactions,
 };
 
 pub fn clear(connection: &mut SqliteConnection) -> Result<()> {
     delete_all_accounts(connection)?;
-    delete_all_budget_drips(connection)?;
+    delete_all_drips(connection)?;
     delete_all_buckets(connection)?;
     delete_all_bucket_transfers(connection)?;
     delete_all_transactions(connection)?;
-    delete_all_transaction_categorisations(connection)?;
+    delete_all_pipes(connection)?;
     Ok(())
 }
diff --git a/schist_core/schist_queries/src/drips.rs b/schist_core/schist_queries/src/drips.rs
new file mode 100644
index 0000000..d9e33a8
--- /dev/null
+++ b/schist_core/schist_queries/src/drips.rs
@@ -0,0 +1,38 @@
+use anyhow::{Context, Result};
+use diesel::{QueryDsl, RunQueryDsl, SelectableHelper, SqliteConnection};
+use schist_models::drip::Drip;
+use schist_schema::schema::drips::dsl::drips as drips_table;
+
+pub fn delete_all_drips(connection: &mut SqliteConnection) -> Result<usize> {
+    let num_rows_deleted = diesel::delete(drips_table)
+        .execute(connection)
+        .with_context(|| "failed to delete all drips")?;
+    Ok(num_rows_deleted)
+}
+
+pub fn get_all_drips(connection: &mut SqliteConnection) -> Result<Vec<Drip>> {
+    let all_drips = drips_table
+        .select(Drip::as_select())
+        .load(connection)
+        .with_context(|| "failed to get all drips")?;
+    Ok(all_drips)
+}
+
+pub fn insert_drips(drips: &[Drip], connection: &mut SqliteConnection) -> Result<usize> {
+    let num_drips_inserted = diesel::insert_into(drips_table)
+        .values(drips)
+        .execute(connection)
+        .with_context(|| insert_err_msg(drips))?;
+    Ok(num_drips_inserted)
+}
+
+fn insert_err_msg(drips: &[Drip]) -> String {
+    format!(
+        "failed to insert drips: [{}]",
+        drips
+            .iter()
+            .map(|a| a.id.to_string())
+            .collect::<Vec<String>>()
+            .join(", ")
+    )
+}
diff --git a/schist_core/schist_queries/src/lib.rs b/schist_core/schist_queries/src/lib.rs
index e3e5488..ccd558d 100644
--- a/schist_core/schist_queries/src/lib.rs
+++ b/schist_core/schist_queries/src/lib.rs
@@ -1,10 +1,10 @@
-pub mod accounts;
 pub mod account_transfers;
-pub mod budget_drips;
-pub mod buckets;
+pub mod accounts;
 pub mod bucket_transfers;
+pub mod buckets;
 pub mod clear;
+pub mod drips;
+pub mod pipes;
 pub mod transactions;
-pub mod transaction_categorisations;
 
 mod utils;
diff --git a/schist_core/schist_queries/src/pipes.rs b/schist_core/schist_queries/src/pipes.rs
new file mode 100644
index 0000000..188d193
--- /dev/null
+++ b/schist_core/schist_queries/src/pipes.rs
@@ -0,0 +1,55 @@
+use anyhow::{Context, Result};
+use diesel::{dsl::sum, QueryDsl, RunQueryDsl, SelectableHelper, SqliteConnection};
+use schist_models::pipe::Pipe;
+use schist_schema::schema::pipes::{self as pipes_schema, dsl::pipes as pipes_table};
+
+pub fn delete_all_pipes(connection: &mut SqliteConnection) -> Result<usize> {
+    let num_rows_deleted = diesel::delete(pipes_table)
+        .execute(connection)
+        .with_context(|| "failed to delete all pipes")?;
+    Ok(num_rows_deleted)
+}
+
+pub fn get_all_pipes(connection: &mut SqliteConnection) -> Result<Vec<Pipe>> {
+    let all_pipes = pipes_table
+        .select(Pipe::as_select())
+        .load(connection)
+        .with_context(|| "failed to get all pipes")?;
+    Ok(all_pipes)
+}
+
+pub fn insert_pipes(
+    pipes: &[Pipe],
+    connection: &mut SqliteConnection,
+) -> Result<usize> {
+    let num_rows_inserted = diesel::insert_into(pipes_table)
+        .values(pipes)
+        .execute(connection)
+        .with_context(|| insert_err_msg(&pipes))?;
+    Ok(num_rows_inserted)
+}
+
+fn insert_err_msg(pipes: &[Pipe]) -> String {
+    format!(
+        "failed to insert pipes: [{}]",
+        pipes
+            .iter()
+            .map(|tc| tc.id.to_string())
+            .collect::<Vec<String>>()
+            .join(", ")
+    )
+}
+
+pub fn sum_pipes_flow_per_bucket_id(connection: &mut SqliteConnection) -> Result<Vec<(i32, i64)>> {
+    let sum = pipes_table
+        .group_by(pipes_schema::bucket_id)
+        .select((pipes_schema::bucket_id, sum(pipes_schema::amount)))
+        .load::<(i32, Option<i64>)>(connection)
+        .map(|vec| {
+            vec.iter()
+                .map(|(bucket_id, sum)| (*bucket_id, sum.unwrap_or(0)))
+                .collect()
+        })
+        .with_context(|| "failed to sum pipes flow per bucket ID")?;
+    Ok(sum)
+}
diff --git a/schist_core/schist_queries/src/transaction_categorisations.rs b/schist_core/schist_queries/src/transaction_categorisations.rs
deleted file mode 100644
index 95aaf8d..0000000
--- a/schist_core/schist_queries/src/transaction_categorisations.rs
+++ /dev/null
@@ -1,59 +0,0 @@
-use anyhow::{Context, Result};
-use diesel::{dsl::sum, QueryDsl, RunQueryDsl, SelectableHelper, SqliteConnection};
-use schist_models::transaction_categorisation::TransactionCategorisation;
-use schist_schema::schema::transaction_categorisations::{
-    self as transaction_categorisations_schema,
-    dsl::transaction_categorisations as transaction_categorisations_table,
-};
-
-pub fn delete_all_transaction_categorisations(connection: &mut SqliteConnection) -> Result<usize> {
-    let num_rows_deleted = diesel::delete(transaction_categorisations_table)
-        .execute(connection)
-        .with_context(|| "failed to delete all transaction categorisations")?;
-    Ok(num_rows_deleted)
-}
-
-pub fn get_all_transaction_categorisations(connection: &mut SqliteConnection) -> Result<Vec<TransactionCategorisation>> {
-    let all_transaction_categorisations = transaction_categorisations_table
-        .select(TransactionCategorisation::as_select())
-        .load(connection)
-        .with_context(|| "failed to get all transaction categorisations")?;
-    Ok(all_transaction_categorisations)
-}
-
-pub fn insert_transaction_categorisations(
-    transaction_categorisations: &[TransactionCategorisation],
-    connection: &mut SqliteConnection,
-) -> Result<usize> {
-    let num_rows_inserted = diesel::insert_into(transaction_categorisations_table)
-        .values(transaction_categorisations)
-        .execute(connection)
-        .with_context(|| insert_err_msg(&transaction_categorisations))?;
-    Ok(num_rows_inserted)
-}
-
-fn insert_err_msg(transaction_categorisations: &[TransactionCategorisation]) -> String {
-    format!(
-        "failed to insert transaction categorisations: [{}]",
-        transaction_categorisations
-            .iter()
-            .map(|tc| tc.id.to_string())
-            .collect::<Vec<String>>()
-            .join(", ")
-    )
-}
-
-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::bucket_id)
-        .select((
-            transaction_categorisations_schema::bucket_id,
-            sum(transaction_categorisations_schema::quantity),
-        ))
-        .load::<(i32, Option<i64>)>(connection)
-        .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 5941ebc..3abacfb 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 bucket transfers")?;
+        .with_context(|| "failed to get all transactions")?;
     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
index 5194084..e238613 100644
--- a/schist_core/schist_queries/src/utils/calculate_bucket_balance.rs
+++ b/schist_core/schist_queries/src/utils/calculate_bucket_balance.rs
@@ -1,31 +1,26 @@
 use anyhow::Result;
-use schist_models::{bucket::Bucket, budget_drip::BudgetDrip};
+use schist_models::{bucket::Bucket, drip::Drip};
 
-use super::{calculate_budgets_accrual, find_by_id_or};
+use super::{find_by_id_or, sum_drips_for_bucket};
 
 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],
+    budget_drips: &[Drip],
 ) -> 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
-    )
+    let budget_accruals_sum = sum_drips_for_bucket(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 schist_fakes::{bucket::make_fake_bucket, drip::make_fake_drip_builder};
 
     use super::calculate_bucket_balance;
 
@@ -45,9 +40,11 @@ mod test {
         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 budget_drips = [make_fake_drip_builder(0)
+            .amount(100)
+            .bucket_id(1)
+            .build()
+            .unwrap()];
 
         let result = calculate_bucket_balance(
             &bucket,
@@ -108,11 +105,31 @@ mod test {
         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(),
+            make_fake_drip_builder(0)
+                .amount(77)
+                .bucket_id(0)
+                .build()
+                .unwrap(),
+            make_fake_drip_builder(0)
+                .amount(77)
+                .bucket_id(0)
+                .build()
+                .unwrap(),
+            make_fake_drip_builder(0)
+                .amount(77)
+                .bucket_id(0)
+                .build()
+                .unwrap(),
+            make_fake_drip_builder(0)
+                .amount(77)
+                .bucket_id(0)
+                .build()
+                .unwrap(),
+            make_fake_drip_builder(0)
+                .amount(77)
+                .bucket_id(0)
+                .build()
+                .unwrap(),
         ];
 
         let result = calculate_bucket_balance(
diff --git a/schist_core/schist_queries/src/utils/calculate_budgets_accrual.rs b/schist_core/schist_queries/src/utils/calculate_budgets_accrual.rs
deleted file mode 100644
index cbf7180..0000000
--- a/schist_core/schist_queries/src/utils/calculate_budgets_accrual.rs
+++ /dev/null
@@ -1,72 +0,0 @@
-use anyhow::Result;
-use schist_models::{
-    budget_drip::BudgetDrip,
-    bucket::Bucket,
-};
-
-pub fn calculate_budgets_accrual(bucket: &Bucket, budget_drips: &[BudgetDrip]) -> Result<i64> {
-    Ok(budget_drips
-        .iter()
-        .filter(|bd| bd.bucket_id == bucket.id)
-        .map(|bd| Into::<i64>::into(bd.quantity))
-        .sum()
-    )
-}
-
-#[cfg(test)]
-mod test {
-    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 bucket = make_fake_bucket(0);
-        let 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_bucket_then_return_zero() {
-        let bucket = make_fake_bucket(0);
-        let budget_drips = [
-            make_fake_budget_drip_builder(0).quantity(100).bucket_id(1).build().unwrap(),
-        ];
-
-        let result = calculate_budgets_accrual(&bucket, &budget_drips);
-
-        assert!(result.is_ok());
-        assert_eq!(result.unwrap(), 0_i64);
-    }
-
-    #[test]
-    fn when_one_budget_drip_then_return_quantity() {
-        let bucket = make_fake_bucket(0);
-        let budget_drips = [
-            make_fake_budget_drip_builder(0).quantity(100).bucket_id(0).build().unwrap(),
-        ];
-
-        let result = calculate_budgets_accrual(&bucket, &budget_drips);
-
-        assert!(result.is_ok());
-        assert_eq!(result.unwrap(), 100);
-    }
-
-    #[test]
-    fn when_two_budget_drips_then_return_sum() {
-        let bucket = make_fake_bucket(0);
-        let budget_drips = [
-            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(&bucket, &budget_drips);
-
-        assert!(result.is_ok());
-        assert_eq!(result.unwrap(), 220);
-    }
-}
diff --git a/schist_core/schist_queries/src/utils/mod.rs b/schist_core/schist_queries/src/utils/mod.rs
index c006a9b..6b47b48 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_bucket_balance;
 mod find_by_id_or;
+mod sum_drips_for_bucket;
 
-use calculate_budgets_accrual::calculate_budgets_accrual;
+use sum_drips_for_bucket::sum_drips_for_bucket;
 
 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/src/utils/sum_drips_for_bucket.rs b/schist_core/schist_queries/src/utils/sum_drips_for_bucket.rs
new file mode 100644
index 0000000..76f7988
--- /dev/null
+++ b/schist_core/schist_queries/src/utils/sum_drips_for_bucket.rs
@@ -0,0 +1,80 @@
+use anyhow::Result;
+use schist_models::{bucket::Bucket, drip::Drip};
+
+pub fn sum_drips_for_bucket(bucket: &Bucket, budget_drips: &[Drip]) -> Result<i64> {
+    Ok(budget_drips
+        .iter()
+        .filter(|bd| bd.bucket_id == bucket.id)
+        .map(|bd| Into::<i64>::into(bd.amount))
+        .sum())
+}
+
+#[cfg(test)]
+mod test {
+    use schist_fakes::{bucket::make_fake_bucket, drip::make_fake_drip_builder};
+
+    use super::sum_drips_for_bucket;
+
+    #[test]
+    fn when_no_budget_drips_then_return_zero() {
+        let bucket = make_fake_bucket(0);
+        let budget_drips = [];
+
+        let result = sum_drips_for_bucket(&bucket, &budget_drips);
+
+        assert!(result.is_ok());
+        assert_eq!(result.unwrap(), 0_i64);
+    }
+
+    #[test]
+    fn when_one_budget_drip_for_another_bucket_then_return_zero() {
+        let bucket = make_fake_bucket(0);
+        let budget_drips = [make_fake_drip_builder(0)
+            .amount(100)
+            .bucket_id(1)
+            .build()
+            .unwrap()];
+
+        let result = sum_drips_for_bucket(&bucket, &budget_drips);
+
+        assert!(result.is_ok());
+        assert_eq!(result.unwrap(), 0_i64);
+    }
+
+    #[test]
+    fn when_one_budget_drip_then_return_quantity() {
+        let bucket = make_fake_bucket(0);
+        let budget_drips = [make_fake_drip_builder(0)
+            .amount(100)
+            .bucket_id(0)
+            .build()
+            .unwrap()];
+
+        let result = sum_drips_for_bucket(&bucket, &budget_drips);
+
+        assert!(result.is_ok());
+        assert_eq!(result.unwrap(), 100);
+    }
+
+    #[test]
+    fn when_two_budget_drips_then_return_sum() {
+        let bucket = make_fake_bucket(0);
+        let budget_drips = [
+            make_fake_drip_builder(0)
+                .amount(100)
+                .bucket_id(0)
+                .build()
+                .unwrap(),
+            make_fake_drip_builder(1)
+                .amount(120)
+                .bucket_id(0)
+                .build()
+                .unwrap(),
+        ];
+
+        let result = sum_drips_for_bucket(&bucket, &budget_drips);
+
+        assert!(result.is_ok());
+        assert_eq!(result.unwrap(), 220);
+    }
+}
diff --git a/schist_core/schist_queries/tests/category_transfers.rs b/schist_core/schist_queries/tests/category_transfers.rs
index e913dcb..13b9866 100644
--- a/schist_core/schist_queries/tests/category_transfers.rs
+++ b/schist_core/schist_queries/tests/category_transfers.rs
@@ -11,12 +11,21 @@ fn when_insert_bucket_transfers_then_returns_num_bucket_transfers() {
     let connection = &mut SqliteConnection::establish(&context.db_url).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(),
+        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::buckets::insert_buckets(&buckets, connection);
 
-    let num_bucket_transfers_inserted = queries::bucket_transfers::insert_bucket_transfers(&bucket_transfers, connection).unwrap();
+    let num_bucket_transfers_inserted =
+        queries::bucket_transfers::insert_bucket_transfers(&bucket_transfers, connection).unwrap();
 
     assert_eq!(num_bucket_transfers_inserted, 2);
 }
@@ -27,20 +36,34 @@ fn given_bucket_transfers_when_get_all_bucket_transfers_then_return_bucket_trans
     let connection = &mut SqliteConnection::establish(&context.db_url).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(),
+        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::buckets::insert_buckets(&buckets, connection);
-    let _ = queries::bucket_transfers::insert_bucket_transfers(&bucket_transfers, connection).unwrap();
+    let _ =
+        queries::bucket_transfers::insert_bucket_transfers(&bucket_transfers, connection).unwrap();
 
-    let bucket_transfers_in_db = queries::bucket_transfers::get_all_bucket_transfers(connection).unwrap();
+    let bucket_transfers_in_db =
+        queries::bucket_transfers::get_all_bucket_transfers(connection).unwrap();
 
     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)));
+        assert!(bucket_transfers_in_db
+            .iter()
+            .any(|bucket_transfer_in_db| bucket_transfer_in_db.eq(&bucket_transfer)));
     }
     for bucket_transfer_in_db in bucket_transfers_in_db {
-        assert!(bucket_transfers.iter().any(|bucket_transfer| bucket_transfer.eq(&bucket_transfer_in_db)));
+        assert!(bucket_transfers
+            .iter()
+            .any(|bucket_transfer| bucket_transfer.eq(&bucket_transfer_in_db)));
     }
 }
 
@@ -50,13 +73,23 @@ fn given_bucket_transfers_when_delete_all_bucket_transfers_then_return_num_of_bu
     let connection = &mut SqliteConnection::establish(&context.db_url).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(),
+        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::buckets::insert_buckets(&buckets, connection);
-    let _ = queries::bucket_transfers::insert_bucket_transfers(&bucket_transfers, connection).unwrap();
+    let _ =
+        queries::bucket_transfers::insert_bucket_transfers(&bucket_transfers, connection).unwrap();
 
-    let num_bucket_transfers_deleted = queries::bucket_transfers::delete_all_bucket_transfers(connection).unwrap();
+    let num_bucket_transfers_deleted =
+        queries::bucket_transfers::delete_all_bucket_transfers(connection).unwrap();
 
     assert_eq!(num_bucket_transfers_deleted, bucket_transfers.len());
 }
@@ -67,32 +100,60 @@ fn given_deleted_bucket_transfers_when_get_all_bucket_transfers_then_return_empt
     let connection = &mut SqliteConnection::establish(&context.db_url).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(),
+        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::buckets::insert_buckets(&buckets, connection);
-    let _ = queries::bucket_transfers::insert_bucket_transfers(&bucket_transfers, connection).unwrap();
+    let _ =
+        queries::bucket_transfers::insert_bucket_transfers(&bucket_transfers, connection).unwrap();
     let _ = queries::bucket_transfers::delete_all_bucket_transfers(connection).unwrap();
 
-    let bucket_transfers_returned = queries::bucket_transfers::get_all_bucket_transfers(connection).unwrap();
+    let bucket_transfers_returned =
+        queries::bucket_transfers::get_all_bucket_transfers(connection).unwrap();
 
     assert_eq!(bucket_transfers_returned.len(), 0);
 }
 
 #[test]
-fn given_bucket_transfers_when_sum_quantity_per_from_bucket_id_then_returns_sum_per_from_bucket_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 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(),
+        make_fake_bucket_transfer_builder(0)
+            .from_bucket_id(0)
+            .to_bucket_id(1)
+            .amount(1)
+            .build()
+            .unwrap(),
+        make_fake_bucket_transfer_builder(1)
+            .from_bucket_id(0)
+            .to_bucket_id(1)
+            .amount(2)
+            .build()
+            .unwrap(),
+        make_fake_bucket_transfer_builder(2)
+            .from_bucket_id(1)
+            .to_bucket_id(0)
+            .amount(4)
+            .build()
+            .unwrap(),
     ];
     let _ = queries::buckets::insert_buckets(&buckets, connection);
-    let _ = queries::bucket_transfers::insert_bucket_transfers(&bucket_transfers, connection).unwrap();
+    let _ =
+        queries::bucket_transfers::insert_bucket_transfers(&bucket_transfers, connection).unwrap();
 
-    let sums = queries::bucket_transfers::sum_bucket_transfer_quantity_per_from_bucket_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();
@@ -108,12 +169,27 @@ fn given_bucket_transfers_when_sum_quantity_per_to_bucket_id_then_returns_sum_pe
     let connection = &mut SqliteConnection::establish(&context.db_url).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(),
+        make_fake_bucket_transfer_builder(0)
+            .from_bucket_id(0)
+            .to_bucket_id(1)
+            .amount(1)
+            .build()
+            .unwrap(),
+        make_fake_bucket_transfer_builder(1)
+            .from_bucket_id(0)
+            .to_bucket_id(1)
+            .amount(2)
+            .build()
+            .unwrap(),
+        make_fake_bucket_transfer_builder(2)
+            .from_bucket_id(1)
+            .to_bucket_id(0)
+            .build()
+            .unwrap(),
     ];
     let _ = queries::buckets::insert_buckets(&buckets, connection);
-    let _ = queries::bucket_transfers::insert_bucket_transfers(&bucket_transfers, connection).unwrap();
+    let _ =
+        queries::bucket_transfers::insert_bucket_transfers(&bucket_transfers, connection).unwrap();
 
     let sums = queries::bucket_transfers::sum_bucket_transfer_quantity_per_to_bucket_id(connection);
 
diff --git a/schist_core/schist_queries/tests/budget_drips.rs b/schist_core/schist_queries/tests/drips.rs
index 7c5bd4d..dccdbf4 100644
--- a/schist_core/schist_queries/tests/budget_drips.rs
+++ b/schist_core/schist_queries/tests/drips.rs
@@ -2,7 +2,7 @@ mod common;
 
 use common::test_context::TestContext;
 use diesel::{Connection, SqliteConnection};
-use schist_fakes::{budget_drip::make_fake_budget_drip_builder, bucket::make_fake_bucket};
+use schist_fakes::{bucket::make_fake_bucket, drip::make_fake_drip_builder};
 use schist_models::{bucket::Bucket, date_utc::DateUtc};
 use schist_queries as queries;
 
@@ -18,17 +18,20 @@ fn when_insert_budget_drips_then_returns_num_budget_drips() {
     let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
     let _buckets = given_buckets(connection);
     let budget_drips = [
-        make_fake_budget_drip_builder(0)
+        make_fake_drip_builder(0)
             .date(DateUtc::from_ymd(2020, 12, 25).unwrap())
             .bucket_id(0)
-            .build().unwrap(),
-        make_fake_budget_drip_builder(1)
+            .build()
+            .unwrap(),
+        make_fake_drip_builder(1)
             .date(DateUtc::from_ymd(2020, 12, 26).unwrap())
             .bucket_id(0)
-            .build().unwrap(),
+            .build()
+            .unwrap(),
     ];
 
-    let num_budget_drips_inserted = queries::budget_drips::insert_budget_drips(&budget_drips, connection).unwrap();
+    let num_budget_drips_inserted =
+        queries::drips::insert_drips(&budget_drips, connection).unwrap();
 
     assert_eq!(num_budget_drips_inserted, 2);
 }
@@ -39,72 +42,68 @@ fn given_budget_drip_when_insert_budget_drip_same_bucket_and_same_date_then_retu
     let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
     let _buckets = given_buckets(connection);
 
-    let budget_drips_1 = [
-        make_fake_budget_drip_builder(0)
-            .bucket_id(0)
-            .date(DateUtc::from_ymd(2020, 12, 25).unwrap())
-            .build().unwrap()
-    ];
-    let _ = queries::budget_drips::insert_budget_drips(&budget_drips_1, connection);
+    let budget_drips_1 = [make_fake_drip_builder(0)
+        .bucket_id(0)
+        .date(DateUtc::from_ymd(2020, 12, 25).unwrap())
+        .build()
+        .unwrap()];
+    let _ = queries::drips::insert_drips(&budget_drips_1, connection);
 
-    let budget_drips_2 = [
-        make_fake_budget_drip_builder(1)
-            .bucket_id(0)
-            .date(DateUtc::from_ymd(2020, 12, 25).unwrap())
-            .build().unwrap()
-    ];
-    let result = queries::budget_drips::insert_budget_drips(&budget_drips_2, connection);
+    let budget_drips_2 = [make_fake_drip_builder(1)
+        .bucket_id(0)
+        .date(DateUtc::from_ymd(2020, 12, 25).unwrap())
+        .build()
+        .unwrap()];
+    let result = queries::drips::insert_drips(&budget_drips_2, connection);
 
     assert!(result.is_err());
 }
 
 #[test]
-fn given_budget_drip_when_insert_budget_drip_different_bucket_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 _buckets = given_buckets(connection);
 
-    let budget_drips_1 = [
-        make_fake_budget_drip_builder(0)
-            .bucket_id(0)
-            .date(DateUtc::from_ymd(2020, 12, 25).unwrap())
-            .build().unwrap()
-    ];
-    let _ = queries::budget_drips::insert_budget_drips(&budget_drips_1, connection);
+    let budget_drips_1 = [make_fake_drip_builder(0)
+        .bucket_id(0)
+        .date(DateUtc::from_ymd(2020, 12, 25).unwrap())
+        .build()
+        .unwrap()];
+    let _ = queries::drips::insert_drips(&budget_drips_1, connection);
 
-    let budget_drips_2 = [
-        make_fake_budget_drip_builder(1)
-            .bucket_id(1)
-            .date(DateUtc::from_ymd(2020, 12, 25).unwrap())
-            .build().unwrap()
-    ];
-    let result = queries::budget_drips::insert_budget_drips(&budget_drips_2, connection);
+    let budget_drips_2 = [make_fake_drip_builder(1)
+        .bucket_id(1)
+        .date(DateUtc::from_ymd(2020, 12, 25).unwrap())
+        .build()
+        .unwrap()];
+    let result = queries::drips::insert_drips(&budget_drips_2, connection);
 
     assert!(result.is_ok());
     assert_eq!(result.unwrap(), 1);
 }
 
 #[test]
-fn given_budget_drip_when_insert_budget_drip_same_bucket_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 _buckets = given_buckets(connection);
 
-    let budget_drips_1 = [
-        make_fake_budget_drip_builder(0)
-            .bucket_id(0)
-            .date(DateUtc::from_ymd(2020, 12, 25).unwrap())
-            .build().unwrap()
-    ];
-    let _ = queries::budget_drips::insert_budget_drips(&budget_drips_1, connection);
+    let budget_drips_1 = [make_fake_drip_builder(0)
+        .bucket_id(0)
+        .date(DateUtc::from_ymd(2020, 12, 25).unwrap())
+        .build()
+        .unwrap()];
+    let _ = queries::drips::insert_drips(&budget_drips_1, connection);
 
-    let budget_drips_2 = [
-        make_fake_budget_drip_builder(1)
-            .bucket_id(0)
-            .date(DateUtc::from_ymd(2020, 12, 26).unwrap())
-            .build().unwrap()
-    ];
-    let result = queries::budget_drips::insert_budget_drips(&budget_drips_2, connection);
+    let budget_drips_2 = [make_fake_drip_builder(1)
+        .bucket_id(0)
+        .date(DateUtc::from_ymd(2020, 12, 26).unwrap())
+        .build()
+        .unwrap()];
+    let result = queries::drips::insert_drips(&budget_drips_2, connection);
 
     assert!(result.is_ok());
     assert_eq!(result.unwrap(), 1);
@@ -116,27 +115,33 @@ fn given_budget_drips_when_get_all_budget_drips_then_return_budget_drips() {
     let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
     let _buckets = given_buckets(connection);
     let budget_drips = [
-        make_fake_budget_drip_builder(0)
+        make_fake_drip_builder(0)
             .date(DateUtc::from_ymd(2020, 12, 25).unwrap())
             .bucket_id(0)
-            .build().unwrap(),
-        make_fake_budget_drip_builder(1)
+            .build()
+            .unwrap(),
+        make_fake_drip_builder(1)
             .date(DateUtc::from_ymd(2020, 12, 26).unwrap())
             .bucket_id(0)
-            .build().unwrap(),
+            .build()
+            .unwrap(),
     ];
-    let _ = queries::budget_drips::insert_budget_drips(&budget_drips, connection).unwrap();
+    let _ = queries::drips::insert_drips(&budget_drips, connection).unwrap();
 
-    let budget_drips_in_db = queries::budget_drips::get_all_budget_drips(connection).unwrap();
+    let budget_drips_in_db = queries::drips::get_all_drips(connection).unwrap();
 
     assert_eq!(budget_drips_in_db.len(), budget_drips.len());
     assert_eq!(budget_drips_in_db[0], budget_drips[0]);
     assert_eq!(budget_drips_in_db[1], budget_drips[1]);
     for budget_drip in &budget_drips {
-        assert!(budget_drips_in_db.iter().any(|budget_drip_in_db| budget_drip_in_db.eq(&budget_drip)));
+        assert!(budget_drips_in_db
+            .iter()
+            .any(|budget_drip_in_db| budget_drip_in_db.eq(&budget_drip)));
     }
     for budget_drip_in_db in budget_drips_in_db {
-        assert!(budget_drips.iter().any(|budget_drip| budget_drip.eq(&budget_drip_in_db)));
+        assert!(budget_drips
+            .iter()
+            .any(|budget_drip| budget_drip.eq(&budget_drip_in_db)));
     }
 }
 
@@ -146,18 +151,20 @@ fn given_budget_drips_when_delete_all_budget_drips_then_return_num_of_budget_dri
     let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
     let _buckets = given_buckets(connection);
     let budget_drips = [
-        make_fake_budget_drip_builder(0)
+        make_fake_drip_builder(0)
             .date(DateUtc::from_ymd(2020, 12, 25).unwrap())
             .bucket_id(0)
-            .build().unwrap(),
-        make_fake_budget_drip_builder(1)
+            .build()
+            .unwrap(),
+        make_fake_drip_builder(1)
             .date(DateUtc::from_ymd(2020, 12, 26).unwrap())
             .bucket_id(0)
-            .build().unwrap(),
+            .build()
+            .unwrap(),
     ];
-    let _ = queries::budget_drips::insert_budget_drips(&budget_drips, connection).unwrap();
+    let _ = queries::drips::insert_drips(&budget_drips, connection).unwrap();
 
-    let num_budget_drips_deleted = queries::budget_drips::delete_all_budget_drips(connection).unwrap();
+    let num_budget_drips_deleted = queries::drips::delete_all_drips(connection).unwrap();
 
     assert_eq!(num_budget_drips_deleted, budget_drips.len());
 }
@@ -168,19 +175,21 @@ fn given_deleted_budget_drips_when_get_all_budget_drips_then_return_empty() {
     let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
     let _buckets = given_buckets(connection);
     let budget_drips = [
-        make_fake_budget_drip_builder(0)
+        make_fake_drip_builder(0)
             .date(DateUtc::from_ymd(2020, 12, 25).unwrap())
             .bucket_id(0)
-            .build().unwrap(),
-        make_fake_budget_drip_builder(1)
+            .build()
+            .unwrap(),
+        make_fake_drip_builder(1)
             .date(DateUtc::from_ymd(2020, 12, 26).unwrap())
             .bucket_id(0)
-            .build().unwrap(),
+            .build()
+            .unwrap(),
     ];
-    let _ = queries::budget_drips::insert_budget_drips(&budget_drips, connection).unwrap();
-    let _ = queries::budget_drips::delete_all_budget_drips(connection).unwrap();
+    let _ = queries::drips::insert_drips(&budget_drips, connection).unwrap();
+    let _ = queries::drips::delete_all_drips(connection).unwrap();
 
-    let budget_drips_returned = queries::budget_drips::get_all_budget_drips(connection).unwrap();
+    let budget_drips_returned = queries::drips::get_all_drips(connection).unwrap();
 
     assert_eq!(budget_drips_returned.len(), 0);
 }
diff --git a/schist_core/schist_queries/tests/pipes.rs b/schist_core/schist_queries/tests/pipes.rs
new file mode 100644
index 0000000..abd5a5e
--- /dev/null
+++ b/schist_core/schist_queries/tests/pipes.rs
@@ -0,0 +1,151 @@
+mod common;
+
+use common::test_context::TestContext;
+use diesel::{Connection, SqliteConnection};
+use schist_fakes::{
+    account::make_fake_account, bucket::make_fake_bucket, pipe::make_fake_pipe_builder,
+    transaction::make_fake_transaction_builder,
+};
+use schist_models::{account::Account, bucket::Bucket, transaction::Transaction};
+use schist_queries as queries;
+
+fn given_accounts(connection: &mut SqliteConnection) -> Vec<Account> {
+    let accounts = vec![make_fake_account(0)];
+    let _ = queries::accounts::insert_accounts(&accounts, connection);
+    accounts
+}
+
+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> {
+    let transactions = vec![
+        make_fake_transaction_builder(0)
+            .account_id(0)
+            .build()
+            .unwrap(),
+        make_fake_transaction_builder(1)
+            .account_id(0)
+            .build()
+            .unwrap(),
+    ];
+    let _ = queries::transactions::insert_transactions(&transactions, connection);
+    transactions
+}
+
+#[test]
+fn when_insert_pipes_then_returns_num_pipes() {
+    let context = TestContext::new();
+    let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
+    given_accounts(connection);
+    given_buckets(connection);
+    given_transactions(connection);
+    let pipes = [
+        make_fake_pipe_builder(0).bucket_id(0).build().unwrap(),
+        make_fake_pipe_builder(1).bucket_id(0).build().unwrap(),
+    ];
+
+    let num_pipes_inserted = queries::pipes::insert_pipes(&pipes, connection).unwrap();
+
+    assert_eq!(num_pipes_inserted, 2);
+}
+
+#[test]
+fn given_pipes_when_get_all_pipes_then_return_pipes() {
+    let context = TestContext::new();
+    let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
+    given_accounts(connection);
+    given_buckets(connection);
+    given_transactions(connection);
+    let pipes = [
+        make_fake_pipe_builder(0).bucket_id(0).build().unwrap(),
+        make_fake_pipe_builder(1).bucket_id(0).build().unwrap(),
+    ];
+    let _ = queries::pipes::insert_pipes(&pipes, connection);
+
+    let pipes_in_db = queries::pipes::get_all_pipes(connection).unwrap();
+
+    assert_eq!(pipes_in_db.len(), pipes.len());
+    for pipe in &pipes {
+        assert!(pipes_in_db.iter().any(|pipe_in_db| pipe_in_db.eq(&pipe)));
+    }
+    for pipe_in_db in pipes_in_db {
+        assert!(pipes.iter().any(|pipe| pipe.eq(&pipe_in_db)));
+    }
+}
+
+#[test]
+fn given_pipes_when_delete_all_pipes_then_return_num_of_pipes() {
+    let context = TestContext::new();
+    let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
+    given_accounts(connection);
+    given_buckets(connection);
+    given_transactions(connection);
+    let pipes = [
+        make_fake_pipe_builder(0).bucket_id(0).build().unwrap(),
+        make_fake_pipe_builder(1).bucket_id(0).build().unwrap(),
+    ];
+    let _ = queries::pipes::insert_pipes(&pipes, connection);
+
+    let num_pipes_deleted = queries::pipes::delete_all_pipes(connection).unwrap();
+
+    assert_eq!(num_pipes_deleted, pipes.len());
+}
+
+#[test]
+fn given_deleted_pipes_when_get_all_pipes_then_return_empty() {
+    let context = TestContext::new();
+    let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
+    given_accounts(connection);
+    given_buckets(connection);
+    given_transactions(connection);
+    let pipes = [
+        make_fake_pipe_builder(0).bucket_id(0).build().unwrap(),
+        make_fake_pipe_builder(1).bucket_id(0).build().unwrap(),
+    ];
+    let _ = queries::pipes::insert_pipes(&pipes, connection);
+    let _ = queries::pipes::delete_all_pipes(connection);
+
+    let pipes_returned = queries::pipes::get_all_pipes(connection).unwrap();
+
+    assert_eq!(pipes_returned.len(), 0);
+}
+
+#[test]
+fn given_pipes_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 buckets = given_buckets(connection);
+    given_transactions(connection);
+    let pipes = [
+        make_fake_pipe_builder(0)
+            .bucket_id(0)
+            .amount(1)
+            .build()
+            .unwrap(),
+        make_fake_pipe_builder(1)
+            .bucket_id(0)
+            .amount(2)
+            .build()
+            .unwrap(),
+        make_fake_pipe_builder(2)
+            .bucket_id(1)
+            .amount(4)
+            .build()
+            .unwrap(),
+    ];
+    let _ = queries::pipes::insert_pipes(&pipes, connection);
+
+    let sums = queries::pipes::sum_pipes_flow_per_bucket_id(connection);
+
+    assert!(sums.is_ok());
+    let mut sums = sums.unwrap();
+    sums.sort_by_key(|sum| sum.0);
+    assert_eq!(buckets.len(), sums.len());
+    assert_eq!(3, sums[0].1);
+    assert_eq!(4, sums[1].1);
+}
diff --git a/schist_core/schist_queries/tests/transaction_categorisations.rs b/schist_core/schist_queries/tests/transaction_categorisations.rs
deleted file mode 100644
index bb88896..0000000
--- a/schist_core/schist_queries/tests/transaction_categorisations.rs
+++ /dev/null
@@ -1,130 +0,0 @@
-mod common;
-
-use common::test_context::TestContext;
-use diesel::{Connection, SqliteConnection};
-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> {
-    let accounts = vec![make_fake_account(0)];
-    let _ = queries::accounts::insert_accounts(&accounts, connection);
-    accounts
-}
-
-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> {
-    let transactions = vec![
-        make_fake_transaction_builder(0).account_id(0).build().unwrap(),
-        make_fake_transaction_builder(1).account_id(0).build().unwrap(),
-    ];
-    let _ = queries::transactions::insert_transactions(&transactions, connection);
-    transactions
-}
-
-#[test]
-fn when_insert_transaction_categorisations_then_returns_num_transaction_categorisations() {
-    let context = TestContext::new();
-    let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
-    given_accounts(connection);
-    given_buckets(connection);
-    given_transactions(connection);
-    let transaction_categorisations = [
-        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();
-
-    assert_eq!(num_transaction_categorisations_inserted, 2);
-}
-
-#[test]
-fn given_transaction_categorisations_when_get_all_transaction_categorisations_then_return_transaction_categorisations() {
-    let context = TestContext::new();
-    let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
-    given_accounts(connection);
-    given_buckets(connection);
-    given_transactions(connection);
-    let transaction_categorisations = [
-        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 transaction_categorisations_in_db = queries::transaction_categorisations::get_all_transaction_categorisations(connection).unwrap();
-
-    assert_eq!(transaction_categorisations_in_db.len(), transaction_categorisations.len());
-    for transaction_categorisation in &transaction_categorisations {
-        assert!(transaction_categorisations_in_db.iter().any(|transaction_categorisation_in_db| transaction_categorisation_in_db.eq(&transaction_categorisation)));
-    }
-    for transaction_categorisation_in_db in transaction_categorisations_in_db {
-        assert!(transaction_categorisations.iter().any(|transaction_categorisation| transaction_categorisation.eq(&transaction_categorisation_in_db)));
-    }
-}
-
-#[test]
-fn given_transaction_categorisations_when_delete_all_transaction_categorisations_then_return_num_of_transaction_categorisations() {
-    let context = TestContext::new();
-    let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
-    given_accounts(connection);
-    given_buckets(connection);
-    given_transactions(connection);
-    let transaction_categorisations = [
-        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 num_transaction_categorisations_deleted = queries::transaction_categorisations::delete_all_transaction_categorisations(connection).unwrap();
-
-    assert_eq!(num_transaction_categorisations_deleted, transaction_categorisations.len());
-}
-
-#[test]
-fn given_deleted_transaction_categorisations_when_get_all_transaction_categorisations_then_return_empty() {
-    let context = TestContext::new();
-    let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
-    given_accounts(connection);
-    given_buckets(connection);
-    given_transactions(connection);
-    let transaction_categorisations = [
-        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);
-
-    let transaction_categorisations_returned = queries::transaction_categorisations::get_all_transaction_categorisations(connection).unwrap();
-
-    assert_eq!(transaction_categorisations_returned.len(), 0);
-}
-
-#[test]
-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 buckets = given_buckets(connection);
-    given_transactions(connection);
-    let transaction_categorisations = [
-        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_bucket_id(connection);
-
-    assert!(sums.is_ok());
-    let mut sums = sums.unwrap();
-    sums.sort_by_key(|sum| sum.0);
-    assert_eq!(buckets.len(), sums.len());
-    assert_eq!(3, sums[0].1);
-    assert_eq!(4, sums[1].1);
-}