Compare commits

...

7 Commits

Author SHA1 Message Date
Elf M. Sternberg e3fe863235 REFACTOR A solid final draft. 2020-11-12 14:30:39 -08:00
Elf M. Sternberg 013ca18c62 As cool as the ParentId/NoteId thing was, it didn't feel zero-abstraction,
and it was starting to prove to be clutter.  Maybe it's a mistake to
downtype them to a common type, but I don't think there was that much
risk here.
2020-11-12 13:33:27 -08:00
Elf M. Sternberg 8a83d802d3 REFACTOR Kasten -> Page
I don't speak German, and I kept getting confused about which was
which.  Let's just call it what it is, and worry about presentation
later.
2020-11-12 08:48:57 -08:00
Elf M. Sternberg 5672f2e235 REFACTOR "Build references" is now its own separate chunk of code.
This is good because in used to be somewhat cut-and-paste, and
that's just ugly.  There's a lot of commonality between "insert note"
and "update content," since both rely heavily on parsing the content
in order to establish the web of relationships between notes and pages,
so having that algorithm ONCE makes me happier.
2020-11-12 08:44:20 -08:00
Elf M. Sternberg 6bd14057ab Apparently updated some docs. 2020-11-12 07:27:45 -08:00
Elf M. Sternberg cf6f906fa4 It has the secret for nested transactions. 2020-11-10 20:08:26 -08:00
Elf M. Sternberg ec81083aa9 REFACTOR Moved the 'store' into its own module. 2020-11-10 12:52:44 -08:00
10 changed files with 317 additions and 233 deletions

View File

@ -1,4 +1,5 @@
[ ] Add RelationshipKind to Notes passed out
[ ] Add KastenKind to Backreferences passed out
[ ] Provide the array of notes references (the 'cycle' manager) to make
[ ] Provide the array of note references (the 'cycle' manager) to make
mapping from Vec->Tree easier.

View File

@ -0,0 +1 @@
Content analysis

View File

@ -1,13 +1,11 @@
mod errors;
mod reference_parser;
mod store;
mod store_private;
mod structs;
pub use crate::errors::NoteStoreError;
pub use crate::store::NoteStore;
pub use crate::structs::{Note, NoteKind, NoteRelationship, KastenRelationship};
pub use crate::structs::{Note, NoteKind, NoteRelationship, PageRelationship};
#[cfg(test)]
mod tests {
@ -30,8 +28,8 @@ mod tests {
#[tokio::test(threaded_scheduler)]
async fn fetching_unfound_page_by_slug_works() {
let storagepool = fresh_inmemory_database().await;
let foundkasten = storagepool.get_kasten_by_slug("nonexistent-kasten").await;
assert!(foundkasten.is_err());
let foundpage = storagepool.get_page_by_slug("nonexistent-page").await;
assert!(foundpage.is_err());
}
// Request for the page by title. If the page exists, return it.
@ -43,7 +41,7 @@ mod tests {
let title = "Nonexistent Page";
let now = chrono::Utc::now();
let storagepool = fresh_inmemory_database().await;
let newpageresult = storagepool.get_kasten_by_title(&title).await;
let newpageresult = storagepool.get_page_by_title(&title).await;
assert!(newpageresult.is_ok(), "{:?}", newpageresult);
let (newpages, _) = newpageresult.unwrap();
@ -53,7 +51,7 @@ mod tests {
assert_eq!(newpage.content, title, "{:?}", newpage.content);
assert_eq!(newpage.id, "nonexistent-page");
assert_eq!(newpage.kind, NoteKind::Kasten);
assert_eq!(newpage.kind, NoteKind::Page);
assert!((newpage.creation_date - now).num_minutes() < 1);
assert!((newpage.updated_date - now).num_minutes() < 1);
assert!((newpage.lastview_date - now).num_minutes() < 1);
@ -71,7 +69,7 @@ mod tests {
async fn can_nest_notes() {
let title = "Nonexistent Page";
let storagepool = fresh_inmemory_database().await;
let newpageresult = storagepool.get_kasten_by_title(&title).await;
let newpageresult = storagepool.get_page_by_title(&title).await;
assert!(newpageresult.is_ok(), "{:?}", newpageresult);
let (newpages, _) = newpageresult.unwrap();
@ -101,7 +99,7 @@ mod tests {
assert!(note4_id.is_ok(), "{:?}", note4_id);
let _note4_id = note4_id.unwrap();
let newpageresult = storagepool.get_kasten_by_title(&title).await;
let newpageresult = storagepool.get_page_by_title(&title).await;
assert!(newpageresult.is_ok(), "{:?}", newpageresult);
let (newpages, _) = newpageresult.unwrap();
@ -114,6 +112,4 @@ mod tests {
assert_eq!(newpages[1].parent_id, Some(newroot.id.clone()));
assert_eq!(newpages[2].parent_id, Some(newpages[1].id.clone()));
}
}

View File

@ -0,0 +1,58 @@
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
//! # Storage layer for Notesmachine
//!
//! This library implements the core functionality of Notesmachine and
//! describes that functionality to a storage layer. There's a bit of
//! intermingling in here which can't be helped, although it may make
//! sense in the future to separate the decomposition of the note
//! content into a higher layer.
//!
//! Notesmachine storage notes consist of two items: Note and Kasten.
//! This distinction is somewhat arbitrary, as structurally these two
//! items are stored in the same table.
//!
//! - Boxes have titles (and date metadata)
//! - Notes have content and a type (and date metadata)
//! - Notes are stored in boxes
//! - Notes are positioned with respect to other notes.
//! - There are two positions:
//! - Siblings, creating lists
//! - Children, creating trees like this one
//! - Notes may have references (pointers) to other boxes
//! - Notes may be moved around
//! - Notes may be deleted
//! - Boxes may be deleted
//! - When a box is renamed, every reference to that box is auto-edited to
//! reflect the change. If a box is renamed to match an existing box, the
//! notes in both boxes are merged.
//!
//! Note-to-note relationships form trees, and are kept in a SQL database of
//! (`parent_id`, `child_id`, `position`, `relationship_type`). The
//! `position` is a monotonic index on the parent (that is, every pair
//! (`parent_id`, `position`) must be unique). The `relationship_type` is
//! an enum and can specify that the relationship is *original*,
//! *embedding*, or *referencing*. An embedded or referenced note may be
//! read/write or read-only with respect to the original, but there is only
//! one original note at any time.
//!
//! Note-to-box relationships form a graph, and are kept in the SQL database
//! as a collection of *edges* from the note to the box (and naturally
//! vice-versa).
//!
//! - Decision: When an original note is deleted, do all references and
//! embeddings also get deleted, or is the oldest one elevated to be a new
//! "original"? Or is that something the user may choose?
//!
//! - Decision: Should the merging issue be handled at this layer, or would
//! it make sense to move this to a higher layer, and only provide the
//! hooks for it here?
//!
mod private;
mod store;
pub use crate::store::store::NoteResult;
pub use crate::store::store::NoteStore;

View File

@ -2,7 +2,8 @@ use crate::structs::*;
use lazy_static::lazy_static;
use regex::Regex;
use slug::slugify;
use sqlx::{sqlite::Sqlite, Done, Executor};
use sqlx::{sqlite::Sqlite, Acquire, Done, Executor, Transaction};
use std::cmp;
use std::collections::HashSet;
type SqlResult<T> = sqlx::Result<T>;
@ -19,7 +20,7 @@ type SqlResult<T> = sqlx::Result<T>;
// of the SQL queries.
lazy_static! {
static ref SELECT_KASTEN_BY_TITLE_SQL: String = str::replace(
static ref SELECT_PAGE_BY_TITLE_SQL: String = str::replace(
include_str!("sql/select_notes_by_parameter.sql"),
"QUERYPARAMETER",
"notes.content"
@ -27,7 +28,7 @@ lazy_static! {
}
lazy_static! {
static ref SELECT_KASTEN_BY_ID_SQL: String = str::replace(
static ref SELECT_PAGE_BY_ID_SQL: String = str::replace(
include_str!("sql/select_notes_by_parameter.sql"),
"QUERYPARAMETER",
"notes.id"
@ -35,8 +36,8 @@ lazy_static! {
}
lazy_static! {
static ref SELECT_NOTES_BACKREFENCING_KASTEN_SQL: &'static str =
include_str!("sql/select_notes_backreferencing_kasten.sql");
static ref SELECT_NOTES_BACKREFERENCING_PAGE_SQL: &'static str =
include_str!("sql/select_notes_backreferencing_page.sql");
}
// ___ _
@ -59,53 +60,51 @@ where
// |_|\___|\__\__|_||_| |_|\_\__,_/__/\__\___|_||_|
//
// Select the requested kasten via its id. This is fairly rare;
// kastens should usually be picked up via their title, but if you're
// navigating to an instance, this is how you specify the kasten in a
// The next three functions are essentially the same, although the internal
// SQL operations are quite different between the first two and the last.
async fn select_object_by_query<'a, E>(executor: E, query: &str, field: &str) -> SqlResult<Vec<Note>>
where
E: Executor<'a, Database = Sqlite>,
{
let r: Vec<RowNote> = sqlx::query_as(query).bind(field).fetch_all(executor).await?;
Ok(r.into_iter().map(|z| Note::from(z)).collect())
}
// Select the requested page via its id. This is fairly rare;
// pages should usually be picked up via their title, but if you're
// navigating to an instance, this is how you specify the page in a
// URL. The return value is an array of Note objects; it is the
// responsibility of client code to restructure these into a tree-like
// object.
//
// Recommended: Clients should update the URL whenever changing
// kasten.
pub(crate) async fn select_kasten_by_slug<'a, E>(executor: E, slug: &NoteId) -> SqlResult<Vec<Note>>
// page.
pub(crate) async fn select_page_by_slug<'a, E>(executor: E, slug: &str) -> SqlResult<Vec<Note>>
where
E: Executor<'a, Database = Sqlite>,
{
let r: Vec<RowNote> = sqlx::query_as(&SELECT_KASTEN_BY_ID_SQL)
.bind(&**slug)
.fetch_all(executor)
.await?;
Ok(r.into_iter().map(|z| Note::from(z)).collect())
select_object_by_query(executor, &SELECT_PAGE_BY_ID_SQL, &slug).await
}
// Fetch the kasten by title. The return value is an array of Note
// Fetch the page by title. The return value is an array of Note
// objects; it is the responsibility of client code to restructure
// these into a tree-like object.
pub(crate) async fn select_kasten_by_title<'a, E>(executor: E, title: &str) -> SqlResult<Vec<Note>>
pub(crate) async fn select_page_by_title<'a, E>(executor: E, title: &str) -> SqlResult<Vec<Note>>
where
E: Executor<'a, Database = Sqlite>,
{
let r: Vec<RowNote> = sqlx::query_as(&SELECT_KASTEN_BY_TITLE_SQL)
.bind(&title)
.fetch_all(executor)
.await?;
Ok(r.into_iter().map(|z| Note::from(z)).collect())
select_object_by_query(executor, &SELECT_PAGE_BY_TITLE_SQL, &title).await
}
// Fetch all backreferences to a kasten. The return value is an array
// of arrays, and inside each array is a list from a root kasten to
// the note that references the give kasten. Clients may choose how
// Fetch all backreferences to a page. The return value is an array
// of arrays, and inside each array is a list from a root page to
// the note that references the give page. Clients may choose how
// they want to display that collection.
pub(crate) async fn select_backreferences_for_kasten<'a, E>(executor: E, kasten_id: &NoteId) -> SqlResult<Vec<Note>>
pub(crate) async fn select_backreferences_for_page<'a, E>(executor: E, page_id: &str) -> SqlResult<Vec<Note>>
where
E: Executor<'a, Database = Sqlite>,
{
let r: Vec<RowNote> = sqlx::query_as(&SELECT_NOTES_BACKREFENCING_KASTEN_SQL)
.bind(&**kasten_id)
.fetch_all(executor)
.await?;
Ok(r.into_iter().map(|z| Note::from(z)).collect())
select_object_by_query(executor, &SELECT_NOTES_BACKREFERENCING_PAGE_SQL, &page_id).await
}
// ___ _ ___ _ _ _
@ -115,26 +114,54 @@ where
//
// Inserts a single note into the notes table. That is all.
pub(crate) async fn insert_note<'a, E>(executor: E, zettle: &NewNote) -> SqlResult<String>
pub(crate) async fn insert_note<'a, E>(executor: E, note: &NewNote) -> SqlResult<String>
where
E: Executor<'a, Database = Sqlite>,
{
let insert_one_page_sql = concat!(
let insert_one_note_sql = concat!(
"INSERT INTO notes (id, content, kind, ",
" creation_date, updated_date, lastview_date) ",
"VALUES (?, ?, ?, ?, ?, ?);"
);
let _ = sqlx::query(insert_one_page_sql)
.bind(&zettle.id)
.bind(&zettle.content)
.bind(zettle.kind.to_string())
.bind(&zettle.creation_date)
.bind(&zettle.updated_date)
.bind(&zettle.lastview_date)
let _ = sqlx::query(insert_one_note_sql)
.bind(&note.id)
.bind(&note.content)
.bind(note.kind.to_string())
.bind(&note.creation_date)
.bind(&note.updated_date)
.bind(&note.lastview_date)
.execute(executor)
.await?;
Ok(zettle.id.clone())
Ok(note.id.clone())
}
// Inserts a single note into the notes table. That is all.
pub(crate) async fn insert_bulk_notes<'a, E>(executor: E, notes: &[NewNote]) -> SqlResult<()>
where
E: Executor<'a, Database = Sqlite>,
{
if notes.is_empty() {
return Ok(());
}
let insert_pattern = "VALUES (?, ?, ?, ?, ?, ?)".to_string();
let insert_bulk_notes_sql = "INSERT INTO notes (id, content, kind, creation_date, updated_date, lastview_date) "
.to_string()
+ &[insert_pattern.as_str()].repeat(notes.len()).join(", ")
+ &";".to_string();
let mut request = sqlx::query(&insert_bulk_notes_sql);
for note in notes {
request = request
.bind(&note.id)
.bind(&note.content)
.bind(note.kind.to_string())
.bind(&note.creation_date)
.bind(&note.updated_date)
.bind(&note.lastview_date);
}
request.execute(executor).await.map(|_| ())
}
// ___ _ _ _ _ __ _
@ -175,7 +202,7 @@ where
static ref RE_STRIP_NUM: Regex = Regex::new(r"-\d+$").unwrap();
static ref SLUG_FINDER_SQL: String = format!(
"SELECT id FROM notes WHERE kind = '{}' AND id LIKE '?%';",
NoteKind::Kasten.to_string()
NoteKind::Page.to_string()
);
}
@ -192,13 +219,13 @@ where
})
}
// A helper function: given a title and a slug, create a KastenType
// A helper function: given a title and a slug, create a PageType
// note.
pub(crate) fn create_zettlekasten(title: &str, slug: &str) -> NewNote {
pub(crate) fn create_page(title: &str, slug: &str) -> NewNote {
NewNoteBuilder::default()
.id(slug.to_string())
.content(title.to_string())
.kind(NoteKind::Kasten)
.kind(NoteKind::Page)
.build()
.unwrap()
}
@ -209,7 +236,7 @@ pub(crate) fn create_zettlekasten(title: &str, slug: &str) -> NewNote {
// \___/| .__/\__,_\__,_|\__\___| \___/|_||_\___| |_|\_\___/\__\___|
// |_|
pub(crate) async fn update_note_content<'a, E>(executor: E, note_id: &NoteId, content: &str) -> SqlResult<()>
pub(crate) async fn update_note_content<'a, E>(executor: E, note_id: &str, content: &str) -> SqlResult<()>
where
E: Executor<'a, Database = Sqlite>,
{
@ -235,8 +262,8 @@ where
pub(crate) async fn select_note_to_note_relationship<'a, E>(
executor: E,
parent_id: &ParentId,
note_id: &NoteId,
parent_id: &str,
note_id: &str,
) -> SqlResult<NoteRelationship>
where
E: Executor<'a, Database = Sqlite>,
@ -248,8 +275,8 @@ where
"LIMIT 1"
);
let s: NoteRelationshipRow = sqlx::query_as(get_note_to_note_relationship_sql)
.bind(&**parent_id)
.bind(&**note_id)
.bind(parent_id)
.bind(note_id)
.fetch_one(executor)
.await?;
Ok(NoteRelationship::from(s))
@ -263,8 +290,8 @@ where
pub(crate) async fn insert_note_to_note_relationship<'a, E>(
executor: E,
parent_id: &ParentId,
note_id: &NoteId,
parent_id: &str,
note_id: &str,
location: i64,
kind: &RelationshipKind,
) -> SqlResult<()>
@ -277,16 +304,20 @@ where
);
let _ = sqlx::query(insert_note_to_note_relationship_sql)
.bind(&**parent_id)
.bind(&**note_id)
.bind(parent_id)
.bind(note_id)
.bind(&location)
.bind(&kind.to_string())
.bind(kind.to_string())
.execute(executor)
.await?;
Ok(())
}
pub(crate) async fn make_room_for_new_note<'a, E>(executor: E, parent_id: &ParentId, location: i64) -> SqlResult<()>
pub(crate) async fn make_room_for_new_note_relationship<'a, E>(
executor: E,
parent_id: &str,
location: i64,
) -> SqlResult<()>
where
E: Executor<'a, Database = Sqlite>,
{
@ -298,13 +329,28 @@ where
let _ = sqlx::query(make_room_for_new_note_sql)
.bind(&location)
.bind(&**parent_id)
.bind(parent_id)
.execute(executor)
.await?;
Ok(())
}
pub(crate) async fn assert_max_child_location_for_note<'a, E>(executor: E, note_id: &ParentId) -> SqlResult<i64>
pub(crate) async fn determine_max_child_location_for_note<'a, E>(
executor: E,
note_id: &str,
comp_loc: Option<i64>,
) -> SqlResult<i64>
where
E: Executor<'a, Database = Sqlite>,
{
let row_count = assert_max_child_location_for_note(executor, note_id).await? + 1;
Ok(match comp_loc {
Some(location) => cmp::min(row_count, location),
None => row_count,
})
}
pub(crate) async fn assert_max_child_location_for_note<'a, E>(executor: E, note_id: &str) -> SqlResult<i64>
where
E: Executor<'a, Database = Sqlite>,
{
@ -312,7 +358,7 @@ where
"SELECT MAX(location) AS count FROM note_relationships WHERE parent_id = ?;";
let count: RowCount = sqlx::query_as(assert_max_child_location_for_note_sql)
.bind(&**note_id)
.bind(note_id)
.fetch_one(executor)
.await?;
@ -325,10 +371,10 @@ where
// |_|\_\___/\__\___| \__\___/ |_|\_\__,_/__/\__\___|_||_| |_|_\___|_\__,_|\__|_\___/_||_/__/_||_|_| .__/__/
// |_|
pub(crate) async fn insert_bulk_note_to_kasten_relationships<'a, E>(
pub(crate) async fn insert_bulk_note_to_page_relationships<'a, E>(
executor: E,
note_id: &NoteId,
references: &[NoteId],
note_id: &str,
references: &[String],
) -> SqlResult<()>
where
E: Executor<'a, Database = Sqlite>,
@ -337,27 +383,27 @@ where
return Ok(());
}
let insert_pattern = format!("(?, ?, '{}')", KastenRelationshipKind::Kasten.to_string());
let insert_note_page_references_sql = "INSERT INTO note_kasten_relationships (note_id, kasten_id, kind) VALUES "
let insert_pattern = format!("(?, ?, '{}')", PageRelationshipKind::Page.to_string());
let insert_note_page_references_sql = "INSERT INTO note_page_relationships (note_id, page_id, kind) VALUES "
.to_string()
+ &[insert_pattern.as_str()].repeat(references.len()).join(", ")
+ &";".to_string();
let mut request = sqlx::query(&insert_note_page_references_sql);
for reference in references {
request = request.bind(&**note_id).bind(&**reference);
request = request.bind(note_id).bind(reference);
}
request.execute(executor).await.map(|_| ())
}
pub(crate) async fn delete_bulk_note_to_kasten_relationships<'a, E>(executor: E, note_id: &NoteId) -> SqlResult<()>
pub(crate) async fn delete_bulk_note_to_page_relationships<'a, E>(executor: E, note_id: &str) -> SqlResult<()>
where
E: Executor<'a, Database = Sqlite>,
{
let delete_note_to_kasten_relationship_sql = "DELETE FROM note_kasten_relationships WHERE and note_id = ?;";
let _ = sqlx::query(delete_note_to_kasten_relationship_sql)
.bind(&**note_id)
let delete_note_to_page_relationship_sql = "DELETE FROM note_page_relationships WHERE and note_id = ?;";
let _ = sqlx::query(delete_note_to_page_relationship_sql)
.bind(note_id)
.execute(executor)
.await?;
Ok(())
@ -380,7 +426,7 @@ pub(crate) fn diff_references(references: &[String], found_references: &[PageTit
// Returns all the (Id, title) pairs found in the database out of a
// list of titles. Used by insert_note and update_note_content to
// find the ids of all the references in a given document.
pub(crate) async fn find_all_kasten_from_list_of_references<'a, E>(
pub(crate) async fn find_all_page_from_list_of_references<'a, E>(
executor: E,
references: &[String],
) -> SqlResult<Vec<PageTitle>>
@ -394,7 +440,7 @@ where
lazy_static! {
static ref SELECT_ALL_REFERENCES_FOR_SQL_BASE: String = format!(
"SELECT id, content FROM notes WHERE kind = '{}' AND content IN (",
NoteKind::Kasten.to_string()
NoteKind::Page.to_string()
);
}
@ -416,8 +462,8 @@ where
pub(crate) async fn delete_note_to_note_relationship<'a, E>(
executor: E,
parent_id: &ParentId,
note_id: &NoteId,
parent_id: &str,
note_id: &str,
) -> SqlResult<()>
where
E: Executor<'a, Database = Sqlite>,
@ -428,8 +474,8 @@ where
);
let count = sqlx::query(delete_note_to_note_relationship_sql)
.bind(&**parent_id)
.bind(&**note_id)
.bind(parent_id)
.bind(note_id)
.execute(executor)
.await?
.rows_affected();
@ -440,33 +486,33 @@ where
}
}
pub(crate) async fn delete_note_to_kasten_relationships<'a, E>(executor: E, note_id: &NoteId) -> SqlResult<()>
pub(crate) async fn delete_note_to_page_relationships<'a, E>(executor: E, note_id: &str) -> SqlResult<()>
where
E: Executor<'a, Database = Sqlite>,
{
lazy_static! {
static ref DELETE_NOTE_TO_KASTEN_RELATIONSHIPS_SQL: String = format!(
static ref DELETE_NOTE_TO_PAGE_RELATIONSHIPS_SQL: String = format!(
"DELETE FROM note_relationships WHERE kind in ('{}', '{}') AND parent_id = ?;",
KastenRelationshipKind::Kasten.to_string(),
KastenRelationshipKind::Unacked.to_string()
PageRelationshipKind::Page.to_string(),
PageRelationshipKind::Unacked.to_string()
);
}
let _ = sqlx::query(&DELETE_NOTE_TO_KASTEN_RELATIONSHIPS_SQL)
.bind(&**note_id)
let _ = sqlx::query(&DELETE_NOTE_TO_PAGE_RELATIONSHIPS_SQL)
.bind(note_id)
.execute(executor)
.await?;
Ok(())
}
pub(crate) async fn delete_note<'a, E>(executor: E, note_id: &NoteId) -> SqlResult<()>
pub(crate) async fn delete_note<'a, E>(executor: E, note_id: &str) -> SqlResult<()>
where
E: Executor<'a, Database = Sqlite>,
{
let delete_note_sql = "DELETE FROM notes WHERE note_id = ?";
let count = sqlx::query(delete_note_sql)
.bind(&**note_id)
.bind(note_id)
.execute(executor)
.await?
.rows_affected();
@ -480,9 +526,9 @@ where
// After removing a note, recalculate the position of all notes under
// the parent note, such that there order is now completely
// sequential.
pub(crate) async fn close_hole_for_deleted_note<'a, E>(
pub(crate) async fn close_hole_for_deleted_note_relationship<'a, E>(
executor: E,
parent_id: &ParentId,
parent_id: &str,
location: i64,
) -> SqlResult<()>
where
@ -496,31 +542,53 @@ where
let _ = sqlx::query(close_hole_for_deleted_note_sql)
.bind(&location)
.bind(&**parent_id)
.bind(parent_id)
.execute(executor)
.await?;
Ok(())
}
// __ __ _
// | \/ (_)___ __
// Given a list of references found in the content, generate the
// references that do not previously exist, returning all found
// references. NOTE: The function signature for this is for a
// transaction, and uses a nested transaction.
pub(crate) async fn validate_or_generate_all_found_references(
txi: &mut Transaction<'_, Sqlite>,
references: &[String],
) -> SqlResult<Vec<String>> {
let mut tx = txi.begin().await?;
let found_references = find_all_page_from_list_of_references(&mut tx, &references).await?;
let new_references = diff_references(&references, &found_references);
let mut new_page: Vec<NewNote> = vec![];
for one_reference in new_references.iter() {
let slug = generate_slug(&mut tx, one_reference).await?;
new_page.push(create_page(&one_reference, &slug));
}
let _ = insert_bulk_notes(&mut tx, &new_page).await?;
let mut all_reference_ids: Vec<String> = found_references.iter().map(|r| r.id.clone()).collect();
all_reference_ids.append(&mut new_page.iter().map(|r| r.id.clone()).collect());
tx.commit().await?;
Ok(all_reference_ids)
}
// __ __ _
// | \/ (_)___ __
// | |\/| | (_-</ _|
// |_| |_|_/__/\__|
//
//
// The dreaded miscellaneous!
pub(crate) async fn count_existing_note_relationships<'a, E>(executor: E, note_id: &NoteId) -> SqlResult<i64>
pub(crate) async fn count_existing_note_relationships<'a, E>(executor: E, note_id: &str) -> SqlResult<i64>
where
E: Executor<'a, Database = Sqlite>,
{
let count_existing_note_relationships_sql =
"SELECT COUNT(*) as count FROM note_relationships WHERE note_id = ?;";
let count_existing_note_relationships_sql = "SELECT COUNT(*) as count FROM note_relationships WHERE note_id = ?;";
let count: RowCount = sqlx::query_as(&count_existing_note_relationships_sql)
.bind(&**note_id)
.bind(note_id)
.fetch_one(executor)
.await?;
Ok(count.count)
}

View File

@ -1,6 +1,6 @@
DROP TABLE IF EXISTS notes;
DROP TABLE IF EXISTS note_relationships;
DROP TABLE IF EXISTS note_kasten_relationships;
DROP TABLE IF EXISTS note_page_relationships;
DROP TABLE IF EXISTS favorites;
CREATE TABLE notes (
@ -21,9 +21,9 @@ CREATE TABLE favorites (
FOREIGN KEY (id) REFERENCES notes (id) ON DELETE CASCADE
);
-- This table represents the forest of data relating a kasten to its
-- This table represents the forest of data relating a page to its
-- collections of notes. The root is itself "a note," but the content
-- of that note will always be just the title of the kasten.
-- of that note will always be just the title of the page.
--
CREATE TABLE note_relationships (
note_id TEXT NOT NULL,
@ -37,22 +37,22 @@ CREATE TABLE note_relationships (
CHECK (note_id <> parent_id)
);
-- This table represents the graph of data relating notes to kastens.
-- This table represents the graph of data relating notes to pages.
--
CREATE TABLE note_kasten_relationships (
CREATE TABLE note_page_relationships (
note_id TEXT NOT NULL,
kasten_id TEXT NOT NULL,
page_id TEXT NOT NULL,
kind TEXT NOT NULL,
-- If either note disappears, we want all the edges to disappear as well.
FOREIGN KEY (note_id) REFERENCES notes (id) ON DELETE CASCADE,
FOREIGN KEY (kasten_id) REFERENCES notes (id) ON DELETE CASCADE,
UNIQUE (note_id, kasten_id),
CHECK (note_id <> kasten_id)
FOREIGN KEY (page_id) REFERENCES notes (id) ON DELETE CASCADE,
UNIQUE (note_id, page_id),
CHECK (note_id <> page_id)
);
-- A fabulous constraint. This index prevents us from saying that
-- if a note points to a kasten, the kasten may not point to a
-- note. Now, it's absolutely required that a kasten_id point to
-- a KastenType note; the content should be a title only.
CREATE UNIQUE INDEX note_kasten_unique_idx
ON note_kasten_relationships (MIN(note_id, kasten_id), MAX(note_id, kasten_id));
-- if a note points to a page, the page may not point to a
-- note. Now, it's absolutely required that a page_id point to
-- a PageType note; the content should be a title only.
CREATE UNIQUE INDEX note_page_unique_idx
ON note_page_relationships (MIN(note_id, page_id), MAX(note_id, page_id));

View File

@ -45,8 +45,8 @@ FROM (
ON note_parents.id = note_relationships.parent_id
WHERE notes.id
IN (SELECT note_id
FROM note_kasten_relationships
WHERE kasten_id = ?) -- IMPORTANT: THIS IS THE PARAMETER
FROM note_page_relationships
WHERE page_id = ?) -- IMPORTANT: THIS IS THE PARAMETER
UNION
SELECT DISTINCT

View File

@ -10,7 +10,7 @@
//! sense in the future to separate the decomposition of the note
//! content into a higher layer.
//!
//! Notesmachine storage notes consist of two items: Note and Kasten.
//! Notesmachine storage notes consist of two items: Note and Page.
//! This distinction is somewhat arbitrary, as structurally these two
//! items are stored in the same table.
//!
@ -53,21 +53,19 @@
use crate::errors::NoteStoreError;
use crate::reference_parser::build_references;
use crate::store_private::*;
use crate::store::private::*;
use crate::structs::*;
use sqlx::sqlite::SqlitePool;
use std::cmp;
// use std::collections::HashMap;
use std::sync::Arc;
/// A handle to our Sqlite database.
#[derive(Clone, Debug)]
pub struct NoteStore(Arc<SqlitePool>);
type NoteResult<T> = core::result::Result<T, NoteStoreError>;
pub type NoteResult<T> = core::result::Result<T, NoteStoreError>;
// After wrestling for a while with the fact that 'box' is a reserved
// word in Rust, I decided to just go with Note (note) and Kasten
// word in Rust, I decided to just go with Note (note) and Page
// (box).
impl NoteStore {
@ -92,32 +90,34 @@ impl NoteStore {
/// the slug, the slug is insufficient to generate a new page, so
/// this use case says that in the event of a failure to find the
/// requested page, return a basic NotFound.
pub async fn get_kasten_by_slug(&self, slug: &str) -> NoteResult<(Vec<Note>, Vec<Note>)> {
let kasten = select_kasten_by_slug(&*self.0, &NoteId(slug.to_string())).await?;
if kasten.is_empty() {
return Err(NoteStoreError::NotFound)
}
pub async fn get_page_by_slug(&self, slug: &str) -> NoteResult<(Vec<Note>, Vec<Note>)> {
let page = select_page_by_slug(&*self.0, slug).await?;
if page.is_empty() {
return Err(NoteStoreError::NotFound);
}
let note_id = NoteId(kasten[0].id.clone());
Ok((kasten, select_backreferences_for_kasten(&*self.0, &note_id).await?))
let note_id = &page[0].id;
let backreferences = select_backreferences_for_page(&*self.0, &note_id).await?;
Ok((page, backreferences))
}
/// Fetch page by title
///
/// The most common use case: the user is navigating by requesting
/// a page. The page either exists or it doesn't. If it
/// doesn't, we go out and make it. Since we know it doesn't exist,
/// we also know no backreferences to it exist, so in that case you
/// get back two empty vecs.
pub async fn get_kasten_by_title(&self, title: &str) -> NoteResult<(Vec<Note>, Vec<Note>)> {
pub async fn get_page_by_title(&self, title: &str) -> NoteResult<(Vec<Note>, Vec<Note>)> {
if title.len() == 0 {
return Err(NoteStoreError::NotFound);
}
let kasten = select_kasten_by_title(&*self.0, title).await?;
if kasten.len() > 0 {
let note_id = NoteId(kasten[0].id.clone());
return Ok((kasten, select_backreferences_for_kasten(&*self.0, &note_id).await?));
let page = select_page_by_title(&*self.0, title).await?;
if page.len() > 0 {
let note_id = &page[0].id;
let backreferences = select_backreferences_for_page(&*self.0, &note_id).await?;
return Ok((page, backreferences));
}
// Sanity check!
@ -130,20 +130,17 @@ impl NoteStore {
let mut tx = self.0.begin().await?;
let slug = generate_slug(&mut tx, title).await?;
let zettlekasten = create_zettlekasten(&title, &slug);
let _ = insert_note(&mut tx, &zettlekasten).await?;
let page = create_page(&title, &slug);
let _ = insert_note(&mut tx, &page).await?;
tx.commit().await?;
Ok((vec![Note::from(zettlekasten)], vec![]))
Ok((vec![Note::from(page)], vec![]))
}
pub async fn add_note(&self, note: &NewNote, parent_id: &str, location: Option<i64>) -> NoteResult<String> {
let new_id = self.insert_note(
note,
&ParentId(parent_id.to_string()),
location,
RelationshipKind::Direct).await?;
Ok(new_id)
let kind = RelationshipKind::Direct;
let new_id = self.insert_note(note, parent_id, location, kind).await?;
Ok(new_id)
}
/// Move a note from one location to another.
@ -156,19 +153,14 @@ impl NoteStore {
) -> NoteResult<()> {
let mut tx = self.0.begin().await?;
let old_parent_id = ParentId(old_parent_id.to_string());
let new_parent_id = ParentId(new_parent_id.to_string());
let note_id = NoteId(note_id.to_string());
let old_note = select_note_to_note_relationship(&mut tx, &old_parent_id, &note_id).await?;
let old_note_location = old_note.location;
let old_note_kind = old_note.kind;
let _ = delete_note_to_note_relationship(&mut tx, &old_parent_id, &note_id).await?;
let _ = close_hole_for_deleted_note(&mut tx, &old_parent_id, old_note_location).await?;
let parent_max_location = assert_max_child_location_for_note(&mut tx, &new_parent_id).await?;
let new_location = cmp::min(parent_max_location + 1, new_location);
let _ = make_room_for_new_note(&mut tx, &new_parent_id, new_location).await?;
let _ = close_hole_for_deleted_note_relationship(&mut tx, &old_parent_id, old_note_location).await?;
let new_location = determine_max_child_location_for_note(&mut tx, &new_parent_id, Some(new_location)).await?;
let _ = make_room_for_new_note_relationship(&mut tx, &new_parent_id, new_location).await?;
let _ =
insert_note_to_note_relationship(&mut tx, &new_parent_id, &note_id, new_location, &old_note_kind).await?;
tx.commit().await?;
@ -179,23 +171,11 @@ impl NoteStore {
/// outgoing edge reference list every time.
pub async fn update_note_content(&self, note_id: &str, content: &str) -> NoteResult<()> {
let references = build_references(&content);
let note_id = NoteId(note_id.to_string());
let mut tx = self.0.begin().await?;
let _ = update_note_content(&mut tx, &note_id, &content).await?;
let _ = delete_bulk_note_to_kasten_relationships(&mut tx, &note_id).await?;
let found_references = find_all_kasten_from_list_of_references(&mut tx, &references).await?;
let new_references = diff_references(&references, &found_references);
let mut known_reference_ids: Vec<NoteId> = Vec::new();
for one_reference in new_references.iter() {
let slug = generate_slug(&mut tx, one_reference).await?;
let zettlekasten = create_zettlekasten(&one_reference, &slug);
let _ = insert_note(&mut tx, &zettlekasten).await?;
known_reference_ids.push(NoteId(slug));
}
known_reference_ids.append(&mut found_references.iter().map(|r| NoteId(r.id.clone())).collect());
let _ = insert_bulk_note_to_kasten_relationships(&mut tx, &note_id, &known_reference_ids).await?;
let _ = delete_bulk_note_to_page_relationships(&mut tx, &note_id).await?;
let known_reference_ids = validate_or_generate_all_found_references(&mut tx, &references).await?;
let _ = insert_bulk_note_to_page_relationships(&mut tx, &note_id, &known_reference_ids).await?;
tx.commit().await?;
Ok(())
}
@ -204,22 +184,22 @@ impl NoteStore {
/// references from that note to pages are also deleted.
pub async fn delete_note(&self, note_id: &str, note_parent_id: &str) -> NoteResult<()> {
let mut tx = self.0.begin().await?;
let note_id = NoteId(note_id.to_string());
let parent_id = ParentId(note_parent_id.to_string());
if *parent_id != *note_id {
let _ = delete_note_to_note_relationship(&mut tx, &parent_id, &note_id);
}
let note_id = note_id.to_string();
let parent_id = note_parent_id.to_string();
if parent_id != note_id {
let _ = delete_note_to_note_relationship(&mut tx, &parent_id, &note_id);
}
// The big one: if zero parents report having an interest in this note, then it,
// *and any sub-relationships*, go away.
if count_existing_note_relationships(&mut tx, &note_id).await? == 0 {
let _ = delete_note_to_kasten_relationships(&mut tx, &note_id).await?;
let _ = delete_note_to_page_relationships(&mut tx, &note_id).await?;
let _ = delete_note(&mut tx, &note_id).await?;
}
tx.commit().await?;
Ok(())
}
}
// The Private stuff
@ -230,19 +210,19 @@ impl NoteStore {
async fn insert_note(
&self,
note: &NewNote,
parent_id: &ParentId,
parent_id: &str,
location: Option<i64>,
kind: RelationshipKind,
) -> NoteResult<String> {
if let Some(location) = location {
if location < 0 {
return Err(NoteStoreError::InvalidNoteStructure(
"Add note: A negative location is not valid.".to_string(),
));
}
}
if let Some(location) = location {
if location < 0 {
return Err(NoteStoreError::InvalidNoteStructure(
"Add note: A negative location is not valid.".to_string(),
));
}
}
if parent_id.is_empty() {
if parent_id.is_empty() {
return Err(NoteStoreError::InvalidNoteStructure(
"Add note: A parent note ID is required.".to_string(),
));
@ -263,33 +243,13 @@ impl NoteStore {
let references = build_references(&note.content);
let mut tx = self.0.begin().await?;
let location = {
let max_child = assert_max_child_location_for_note(&mut tx, parent_id).await? + 1;
if let Some(location) = location {
cmp::min(max_child, location)
} else {
max_child
}
};
let note_id = NoteId(note.id.clone());
let location = determine_max_child_location_for_note(&mut tx, parent_id, location).await?;
insert_note(&mut tx, &note).await?;
make_room_for_new_note(&mut tx, &parent_id, location).await?;
insert_note_to_note_relationship(&mut tx, &parent_id, &note_id, location, &kind).await?;
let found_references = find_all_kasten_from_list_of_references(&mut tx, &references).await?;
let new_references = diff_references(&references, &found_references);
let mut known_reference_ids: Vec<NoteId> = Vec::new();
for one_reference in new_references.iter() {
let slug = generate_slug(&mut tx, one_reference).await?;
let zettlekasten = create_zettlekasten(&one_reference, &slug);
let _ = insert_note(&mut tx, &zettlekasten).await?;
known_reference_ids.push(NoteId(slug));
}
known_reference_ids.append(&mut found_references.iter().map(|r| NoteId(r.id.clone())).collect());
let _ = insert_bulk_note_to_kasten_relationships(&mut tx, &note_id, &known_reference_ids).await?;
make_room_for_new_note_relationship(&mut tx, &parent_id, location).await?;
insert_note_to_note_relationship(&mut tx, &parent_id, &note.id, location, &kind).await?;
let known_reference_ids = validate_or_generate_all_found_references(&mut tx, &references).await?;
let _ = insert_bulk_note_to_page_relationships(&mut tx, &note.id, &known_reference_ids).await?;
tx.commit().await?;
Ok(note_id.to_string())
Ok(note.id.to_string())
}
}

View File

@ -4,8 +4,8 @@ use friendly_id;
use shrinkwraprs::Shrinkwrap;
use sqlx::{self, FromRow};
// Kasten is German for "Box," and is used both because this is
// supposed to be a Zettlekasten, and because "Box" is a heavily
// Page is German for "Box," and is used both because this is
// supposed to be a Page, and because "Box" is a heavily
// reserved word in Rust. So, for that matter, are "crate" and
// "cargo," "cell," and so forth. If I'd wanted to go the Full
// Noguchi, I guess I could have used "envelope."
@ -60,7 +60,7 @@ pub(crate) struct ParentId(pub String);
build_conversion_enums!(
NoteKind,
"box" => Kasten,
"box" => Page,
"note" => Note,
"resource" => Resource,
);
@ -78,8 +78,8 @@ build_conversion_enums!(
);
build_conversion_enums!(
KastenRelationshipKind,
"kasten" => Kasten,
PageRelationshipKind,
"page" => Page,
"unacked" => Unacked,
"cancelled" => Cancelled,
);
@ -136,7 +136,7 @@ impl From<RowNote> for Note {
/// A new Note object as it's inserted into the system. It has no
/// parent or location information; those are data relative to the
/// parent, and must be provided by the client. In the case of a
/// Kasten, no location or parent is necessary.
/// Page, no location or parent is necessary.
#[derive(Clone, Debug, Builder)]
pub struct NewNote {
#[builder(default = r#"friendly_id::create()"#)]
@ -155,8 +155,8 @@ pub struct NewNote {
}
impl From<NewNote> for Note {
/// Only used for building new kastens, so the decision- making is
/// limited to kasten-level things, like pointing to self and
/// Only used for building new pages, so the decision- making is
/// limited to page-level things, like pointing to self and
/// having a location of zero.
fn from(note: NewNote) -> Self {
Self {
@ -217,25 +217,25 @@ impl From<NoteRelationshipRow> for NoteRelationship {
}
#[derive(Clone, Debug, FromRow)]
pub(crate) struct KastenRelationshipRow {
pub(crate) struct PageRelationshipRow {
pub note_id: String,
pub kasten_id: String,
pub page_id: String,
pub kind: String,
}
#[derive(Clone, Debug)]
pub struct KastenRelationship {
pub struct PageRelationship {
pub note_id: String,
pub kasten_id: String,
pub kind: KastenRelationshipKind,
pub page_id: String,
pub kind: PageRelationshipKind,
}
impl From<KastenRelationshipRow> for KastenRelationship {
fn from(rel: KastenRelationshipRow) -> Self {
impl From<PageRelationshipRow> for PageRelationship {
fn from(rel: PageRelationshipRow) -> Self {
Self {
kasten_id: rel.kasten_id,
page_id: rel.page_id,
note_id: rel.note_id,
kind: KastenRelationshipKind::from(rel.kind),
kind: PageRelationshipKind::from(rel.kind),
}
}
}