REFACTOR Again! note->note and note->kasten are now separate tables

This was getting semantically confusing, so I decided to short
circuit the whole mess by separating the two.  The results are
promising.  It does mean that deleting a note means traversing
two tables to clean out all the cruft, which is *sigh*, but it
also means that the tree is stored in one table and the graph in
another, giving us a much better separation of concerns down at
the SQL layer.

server/nm-store/src/lib.rs

@@ -29,8 +29,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.unwrap();
+        let foundkasten = storagepool.get_kasten_by_slug("nonexistent-kasten").await;
-        assert_eq!(foundkasten.len(), 0, "{:?}", foundkasten);
+        assert!(foundkasten.is_err());
     }
 
     // Request for the page by title.  If the page exists, return it.
@@ -45,7 +45,7 @@ mod tests {
         let newpageresult = storagepool.get_kasten_by_title(&title).await;
 
         assert!(newpageresult.is_ok(), "{:?}", newpageresult);
-        let newpages = newpageresult.unwrap();
+        let (newpages, _) = newpageresult.unwrap();
 
         assert_eq!(newpages.len(), 1);
         let newpage = newpages.iter().next().unwrap();
@@ -73,7 +73,7 @@ mod tests {
         let newpageresult = storagepool.get_kasten_by_title(&title).await;
 
         assert!(newpageresult.is_ok(), "{:?}", newpageresult);
-        let newpages = newpageresult.unwrap();
+        let (newpages, _) = newpageresult.unwrap();
         assert_eq!(newpages.len(), 1);
         let root = &newpages[0];
 
@@ -102,7 +102,7 @@ mod tests {
 
         let newpageresult = storagepool.get_kasten_by_title(&title).await;
         assert!(newpageresult.is_ok(), "{:?}", newpageresult);
-        let newpages = newpageresult.unwrap();
+        let (newpages, _) = newpageresult.unwrap();
 
         assert_eq!(newpages.len(), 5);
         let newroot = newpages.iter().next().unwrap();
@@ -113,4 +113,6 @@ mod tests {
         assert_eq!(newpages[1].parent_id, Some(newroot.id.clone()));
         assert_eq!(newpages[2].parent_id, Some(newpages[1].id.clone()));
     }
+
+	
 }

server/nm-store/src/sql/initialize_database.sql

@@ -1,6 +1,6 @@
 DROP TABLE IF EXISTS notes;
 DROP TABLE IF EXISTS note_relationships;
-DROP INDEX IF EXISTS note_ids;
+DROP TABLE IF EXISTS note_kasten_relationships;
 DROP TABLE IF EXISTS favorites;
 
 CREATE TABLE notes (
@@ -21,6 +21,10 @@ CREATE TABLE favorites (
     FOREIGN KEY (id) REFERENCES notes (id) ON DELETE CASCADE
 );
 
+-- This table represents the forest of data relating a kasten 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.
+--
 CREATE TABLE note_relationships (
     note_id TEXT NOT NULL,
     parent_id TEXT NOT NULL,
@@ -31,3 +35,14 @@ CREATE TABLE note_relationships (
     FOREIGN KEY (parent_id) REFERENCES notes (id) ON DELETE CASCADE
 );
 
+-- This table represents the graph of data relating notes to kastens.
+--
+CREATE TABLE note_kasten_relationships (
+    note_id TEXT NOT NULL,
+    kasten_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
+);
+

server/nm-store/src/sql/select_notes_backreferencing_kasten.sql

@@ -0,0 +1,72 @@
+SELECT
+  id,
+  parent_id,
+  content,
+  location,
+  kind,
+  creation_date,
+  updated_date,
+  lastview_date,
+  deleted_date
+
+FROM (
+
+  WITH RECURSIVE parents (
+    id,
+    parent_id,
+    content,
+    location,
+    kind,
+    creation_date,
+    updated_date,
+    lastview_date,
+    deleted_date,
+    cycle
+  )
+
+  AS (
+
+    SELECT
+           notes.id,
+           note_parents.id,
+           notes.content,
+		   note_relationships.location,
+           notes.kind,
+           notes.creation_date,
+           notes.updated_date,
+           notes.lastview_date,
+           notes.deleted_date,
+           ','||notes.id||','
+      FROM notes
+        INNER JOIN note_relationships
+          ON notes.id = note_relationships.note_id
+          AND notes.kind = 'note'
+        INNER JOIN notes as note_parents
+          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
+
+    UNION
+	SELECT DISTINCT
+	       notes.id,
+		   next_parent.id,
+      	   notes.content,
+		   note_relationships.location,
+		   notes.kind,
+      	   notes.creation_date,
+      	   notes.updated_date,
+      	   notes.lastview_date,
+      	   notes.deleted_date,
+      	   parents.cycle||notes.id||','
+      FROM notes
+      INNER JOIN parents
+	    ON parents.parent_id = notes.id
+	  LEFT JOIN note_relationships
+	    ON note_relationships.note_id = notes.id
+	  LEFT JOIN notes as next_parent
+	    ON next_parent.id = note_relationships.parent_id
+      WHERE parents.cycle NOT LIKE '%,'||notes.id||',%'
+  )
+  SELECT * from parents);

server/nm-store/src/store.rs

@@ -92,25 +92,35 @@ 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>> {
+    pub async fn get_kasten_by_slug(&self, slug: &str) -> NoteResult<(Vec<Note>, Vec<Note>)> {
-        let maybekasten = select_kasten_by_slug(&*self.0, slug).await;
+        let kasten = select_kasten_by_slug(&*self.0, &NoteId(slug.to_string())).await?;
-        match maybekasten {
+		if kasten.is_empty() {
-            Ok(v) => Ok(v),
+			return Err(NoteStoreError::NotFound)
-            Err(sqlx::Error::RowNotFound) => Err(NoteStoreError::NotFound),
-            Err(_) => maybekasten.map_err(NoteStoreError::DBError),
-        }
 		}
 
-    pub async fn get_kasten_by_title(&self, title: &str) -> NoteResult<Vec<Note>> {
+		let note_id = NoteId(kasten[0].id.clone());
+        Ok((kasten, select_backreferences_for_kasten(&*self.0, &note_id).await?))
+    }
+
+    /// 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>)> {
         if title.len() == 0 {
             return Err(NoteStoreError::NotFound);
         }
 
         let kasten = select_kasten_by_title(&*self.0, title).await?;
         if kasten.len() > 0 {
-            return Ok(kasten);
+			let note_id = NoteId(kasten[0].id.clone());
+            return Ok((kasten, select_backreferences_for_kasten(&*self.0, &note_id).await?));
         }
 
+        // Sanity check!
         let references = build_references(&title);
         if references.len() > 0 {
             return Err(NoteStoreError::InvalidNoteStructure(
@@ -124,11 +134,17 @@ impl NoteStore {
         let _ = insert_note(&mut tx, &zettlekasten).await?;
         tx.commit().await?;
 
-        Ok(vec![Note::from(zettlekasten)])
+        Ok((vec![Note::from(zettlekasten)], vec![]))
     }
 
     pub async fn add_note(&self, note: &NewNote, parent_id: &str, location: i64) -> NoteResult<String> {
-        self.insert_note(note, &ParentId(parent_id.to_string()), location, RelationshipKind::Direct).await
+        self.insert_note(
+            note,
+            &ParentId(parent_id.to_string()),
+            location,
+            RelationshipKind::Direct,
+        )
+        .await
     }
 
     /// Move a note from one location to another.
@@ -186,7 +202,8 @@ impl NoteStore {
 
         let mut tx = self.0.begin().await?;
         let _ = update_note_content(&mut tx, &note_id, &content).await?;
-        let found_references = find_all_kasten_references_for(&mut tx, &references).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() {
@@ -201,8 +218,6 @@ impl NoteStore {
         tx.commit().await?;
         Ok(())
     }
-	
-	
 }
 
 // The Private stuff
@@ -210,7 +225,13 @@ impl NoteStore {
 impl NoteStore {
     // Pretty much the most dangerous function in our system. Has to
     // have ALL the error checking.
-    async fn insert_note(&self, note: &NewNote, parent_id: &ParentId, location: i64, kind: RelationshipKind) -> NoteResult<String> {
+    async fn insert_note(
+        &self,
+        note: &NewNote,
+        parent_id: &ParentId,
+        location: i64,
+        kind: RelationshipKind,
+    ) -> NoteResult<String> {
         if location < 0 {
             return Err(NoteStoreError::InvalidNoteStructure(
                 "Add note: A negative position is not valid.".to_string(),
@@ -248,7 +269,7 @@ impl NoteStore {
         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_references_for(&mut tx, &references).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() {

server/nm-store/src/store_private.rs

@@ -2,7 +2,7 @@ use crate::structs::*;
 use lazy_static::lazy_static;
 use regex::Regex;
 use slug::slugify;
-use sqlx::{sqlite::Sqlite, Executor, Done};
+use sqlx::{sqlite::Sqlite, Done, Executor};
 use std::collections::HashSet;
 
 type SqlResult<T> = sqlx::Result<T>;
@@ -18,6 +18,12 @@ type SqlResult<T> = sqlx::Result<T>;
 // coherent and easily readable, and hides away the gnarliness of some
 // of the SQL queries.
 
+// Important!!!  Note_relationships are usually (parent_note -> note),
+// but Note to Kasten relationships are always (note-as-parent ->
+// kasten_note), so when looking for "all the notes referring to this
+// kasten", you use the kasten's id as the TARGET note_id, and the
+// note referring to the kasten in the parent_id.
+
 lazy_static! {
     static ref SELECT_KASTEN_BY_TITLE_SQL: String = str::replace(
         include_str!("sql/select_notes_by_parameter.sql"),
@@ -34,6 +40,17 @@ lazy_static! {
     );
 }
 
+lazy_static! {
+    static ref SELECT_NOTES_BACKREFENCING_KASTEN_SQL: &'static str =
+        include_str!("sql/select_notes_backreferencing_kasten.sql");
+}
+
+//  ___             _
+// | _ \___ ___ ___| |_
+// |   / -_|_-</ -_)  _|
+// |_|_\___/__/\___|\__|
+//
+
 pub(crate) async fn reset_database<'a, E>(executor: E) -> SqlResult<()>
 where
     E: Executor<'a, Database = Sqlite>,
@@ -42,12 +59,18 @@ where
     sqlx::query(initialize_sql).execute(executor).await.map(|_| ())
 }
 
-pub(crate) async fn select_kasten_by_slug<'a, E>(executor: E, slug: &str) -> SqlResult<Vec<Note>>
+//  ___    _      _      _  __        _
+// | __|__| |_ __| |_   | |/ /__ _ __| |_ ___ _ _
+// | _/ -_)  _/ _| ' \  | ' </ _` (_-<  _/ -_) ' \
+// |_|\___|\__\__|_||_| |_|\_\__,_/__/\__\___|_||_|
+//
+
+pub(crate) async fn select_kasten_by_slug<'a, E>(executor: E, slug: &NoteId) -> SqlResult<Vec<Note>>
 where
     E: Executor<'a, Database = Sqlite>,
 {
     let r: Vec<RowNote> = sqlx::query_as(&SELECT_KASTEN_BY_ID_SQL)
-        .bind(&slug)
+        .bind(&**slug)
         .fetch_all(executor)
         .await?;
     Ok(r.into_iter().map(|z| Note::from(z)).collect())
@@ -64,28 +87,23 @@ where
     Ok(r.into_iter().map(|z| Note::from(z)).collect())
 }
 
-pub(crate) async fn select_note_to_note_relationship<'a, E>(
+pub(crate) async fn select_backreferences_for_kasten<'a, E>(executor: E, kasten_id: &NoteId) -> SqlResult<Vec<Note>>
-		executor: E,
-		parent_id: &ParentId,
-		note_id: &NoteId,
-) -> SqlResult<NoteRelationship>
 where
     E: Executor<'a, Database = Sqlite>,
 {
-    let get_note_to_note_relationship_sql = concat!(
+    let r: Vec<RowNote> = sqlx::query_as(&SELECT_NOTES_BACKREFENCING_KASTEN_SQL)
-        "SELECT parent_id, note_id, location, kind ",
+        .bind(&**kasten_id)
-        "FROM note_relationships ",
+        .fetch_all(executor)
-        "WHERE parent_id = ? and note_id = ? ",
-        "LIMIT 1"
-    );
-	let s: NoteRelationshipRow = sqlx::query_as(get_note_to_note_relationship_sql)
-        .bind(&**parent_id)
-        .bind(&**note_id)
-        .fetch_one(executor)
         .await?;
-	Ok(NoteRelationship::from(s))
+    Ok(r.into_iter().map(|z| Note::from(z)).collect())
 }
 
+//  ___                  _      ___             _  _     _
+// |_ _|_ _  ___ ___ _ _| |_   / _ \ _ _  ___  | \| |___| |_ ___
+//  | || ' \(_-</ -_) '_|  _| | (_) | ' \/ -_) | .` / _ \  _/ -_)
+// |___|_||_/__/\___|_|  \__|  \___/|_||_\___| |_|\_\___/\__\___|
+//
+
 pub(crate) async fn insert_note<'a, E>(executor: E, zettle: &NewNote) -> SqlResult<String>
 where
     E: Executor<'a, Database = Sqlite>,
@@ -108,246 +126,11 @@ where
     Ok(zettle.id.clone())
 }
 
-pub(crate) async fn update_note_content<'a, E>(executor: E, note_id: &NoteId, content: &str) -> SqlResult<()>
+//  ___      _ _    _   _  __        _
-where
+// | _ )_  _(_) |__| | | |/ /__ _ __| |_ ___ _ _
-    E: Executor<'a, Database = Sqlite>,
+// | _ \ || | | / _` | | ' </ _` (_-<  _/ -_) ' \
-{
+// |___/\_,_|_|_\__,_| |_|\_\__,_/__/\__\___|_||_|
-    let update_note_content_sql = "UPDATE notes SET content = ? WHERE note_id = ?";
+//
-    let count = sqlx::query(update_note_content_sql)
-        .bind(content)
-        .bind(&**note_id)
-        .execute(executor)
-        .await?
-        .rows_affected();
-
-    match count {
-        1 => Ok(()),
-        _ => Err(sqlx::Error::RowNotFound),
-    }
-}
-
-pub(crate) async fn make_room_for_new_note<'a, E>(executor: E, parent_id: &ParentId, location: i64) -> SqlResult<()>
-where
-    E: Executor<'a, Database = Sqlite>,
-{
-    let make_room_for_new_note_sql = concat!(
-        "UPDATE note_relationships ",
-        "SET location = location + 1 ",
-        "WHERE location >= ? and parent_id = ?;"
-    );
-
-    let _ = sqlx::query(make_room_for_new_note_sql)
-        .bind(&location)
-        .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>
-where
-    E: Executor<'a, Database = Sqlite>,
-{
-    let assert_max_child_location_for_note_sql =
-        "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)
-        .fetch_one(executor)
-        .await?;
-
-    Ok(count.count)
-}
-
-pub(crate) async fn insert_note_to_note_relationship<'a, E>(
-    executor: E,
-    parent_id: &ParentId,
-    note_id: &NoteId,
-    location: i64,
-    kind: &RelationshipKind,
-) -> SqlResult<()>
-where
-    E: Executor<'a, Database = Sqlite>,
-{
-    let insert_note_to_note_relationship_sql = concat!(
-        "INSERT INTO note_relationships (parent_id, note_id, location, kind) ",
-        "values (?, ?, ?, ?)"
-    );
-
-    let _ = sqlx::query(insert_note_to_note_relationship_sql)
-        .bind(&**parent_id)
-        .bind(&**note_id)
-        .bind(&location)
-        .bind(&kind.to_string())
-        .execute(executor)
-        .await?;
-    Ok(())
-}
-
-pub(crate) async fn insert_bulk_note_to_kasten_relationships<'a, E>(
-		executor: E,
-		note_id: &NoteId,
-		references: &[NoteId],
-) -> SqlResult<()>
-where
-    E: Executor<'a, Database = Sqlite>,
-{
-    if references.is_empty() {
-        return Ok(());
-    }
-
-	let insert_pattern = format!("(?, ?, 0, {})", RelationshipKind::Kasten.to_string());
-	let insert_note_page_references_sql =
-		"INSERT INTO note_relationships (parent_id, note_id, location, 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.execute(executor).await.map(|_| ())
-}
-
-
-pub(crate) async fn find_all_kasten_references_for<'a, E>(executor: E, references: &[String]) -> SqlResult<Vec<PageTitle>>
-where
-    E: Executor<'a, Database = Sqlite>,
-{
-    if references.is_empty() {
-        return Ok(vec![]);
-    }
-
-    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()
-        );
-    }
-
-    let find_all_references_for_sql =
-        SELECT_ALL_REFERENCES_FOR_SQL_BASE.to_string() + &["?"].repeat(references.len()).join(",") + &");".to_string();
-
-    let mut request = sqlx::query_as(&find_all_references_for_sql);
-    for id in references.iter() {
-        request = request.bind(id);
-    }
-    request.fetch_all(executor).await
-}
-
-pub(crate) async fn delete_note_to_note_relationship<'a, E>(
-    executor: E,
-    parent_id: &ParentId,
-    note_id: &NoteId,
-) -> SqlResult<()>
-where
-    E: Executor<'a, Database = Sqlite>,
-{
-    let delete_note_to_note_relationship_sql = concat!(
-        "DELETE FROM note_relationships ",
-        "WHERE parent_id = ? and note_id = ? "
-    );
-	
-    let count = sqlx::query(delete_note_to_note_relationship_sql)
-        .bind(&**parent_id)
-        .bind(&**note_id)
-        .execute(executor)
-        .await?
-        .rows_affected();
-
-    match count {
-        1 => Ok(()),
-        _ => Err(sqlx::Error::RowNotFound),
-    }
-}
-
-pub(crate) async fn delete_note_to_kasten_relationships<'a, E>(executor: E, note_id: &NoteId) -> SqlResult<()>
-where
-    E: Executor<'a, Database = Sqlite>,
-{
-    lazy_static! {
-        static ref DELETE_NOTE_TO_KASTEN_RELATIONSHIPS_SQL: String = format!(
-            "DELETE FROM note_relationships WHERE kind in ({}, {}) AND parent_id = ?;",
-			RelationshipKind::Kasten.to_string(),
-			RelationshipKind::Unacked.to_string()
-        );
-    }
-
-    let _ = sqlx::query(&DELETE_NOTE_TO_KASTEN_RELATIONSHIPS_SQL)
-        .bind(&**note_id)
-        .execute(executor)
-        .await?;
-    Ok(())
-}
-
-pub(crate) async fn delete_note<'a, E>(executor: E, note_id: &NoteId) -> 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)
-        .execute(executor)
-        .await?
-        .rows_affected();
-
-    match count {
-        1 => Ok(()),
-        _ => Err(sqlx::Error::RowNotFound),
-    }
-}
-
-// 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>(executor: E, parent_id: &ParentId, location: i64) -> SqlResult<()>
-where
-    E: Executor<'a, Database = Sqlite>,
-{
-    let close_hole_for_deleted_note_sql = concat!(
-        "UPDATE note_relationships ",
-        "SET location = location - 1 ",
-        "WHERE location > ? and parent_id = ?;"
-    );
-
-    let _ = sqlx::query(close_hole_for_deleted_note_sql)
-        .bind(&location)
-        .bind(&**parent_id)
-        .execute(executor)
-        .await?;
-	Ok(())
-}
-
-pub(crate) async fn count_existing_note_relationships<'a, E>(executor: E, note_id: &NoteId) -> SqlResult<i64>
-where
-    E: Executor<'a, Database = Sqlite>,
-{
-    lazy_static! {
-        static ref COUNT_EXISTING_NOTE_RELATIONSHIPS_SQL: String = format!(
-			"SELECT COUNT(*) as count FROM note_relationships WHERE kind IN ({}, {}, {}) and note_id = ?;",
-			RelationshipKind::Direct.to_string(),
-			RelationshipKind::Reference.to_string(),
-			RelationshipKind::Embed.to_string(),
-        );
-    }
-
-    let count: RowCount = sqlx::query_as(&COUNT_EXISTING_NOTE_RELATIONSHIPS_SQL)
-        .bind(&**note_id)
-        .fetch_one(executor)
-        .await?;
-
-    Ok(count.count)
-}
-
-// Given the references supplied, and the references found in the datastore,
-// return a list of the references not found in the datastore.
-pub(crate) fn diff_references(references: &[String], found_references: &[PageTitle]) -> Vec<String> {
-    let all: HashSet<String> = references.iter().cloned().collect();
-    let found: HashSet<String> = found_references.iter().map(|r| r.content.clone()).collect();
-    all.difference(&found).cloned().collect()
-}
 
 // Given a possible slug, find the slug with the highest
 // uniquification number, and return that number, if any.
@@ -405,3 +188,325 @@ pub(crate) fn create_zettlekasten(title: &str, slug: &str) -> NewNote {
         .build()
         .unwrap()
 }
+
+//  _   _          _      _          ___             _  _     _
+// | | | |_ __  __| |__ _| |_ ___   / _ \ _ _  ___  | \| |___| |_ ___
+// | |_| | '_ \/ _` / _` |  _/ -_) | (_) | ' \/ -_) | .` / _ \  _/ -_)
+//  \___/| .__/\__,_\__,_|\__\___|  \___/|_||_\___| |_|\_\___/\__\___|
+//       |_|
+
+pub(crate) async fn update_note_content<'a, E>(executor: E, note_id: &NoteId, content: &str) -> SqlResult<()>
+where
+    E: Executor<'a, Database = Sqlite>,
+{
+    let update_note_content_sql = "UPDATE notes SET content = ? WHERE note_id = ?";
+    let count = sqlx::query(update_note_content_sql)
+        .bind(content)
+        .bind(&**note_id)
+        .execute(executor)
+        .await?
+        .rows_affected();
+
+    match count {
+        1 => Ok(()),
+        _ => Err(sqlx::Error::RowNotFound),
+    }
+}
+
+//  ___    _      _       ___             _  _     _         ___     _      _   _             _    _
+// | __|__| |_ __| |_    / _ \ _ _  ___  | \| |___| |_ ___  | _ \___| |__ _| |_(_)___ _ _  __| |_ (_)_ __
+// | _/ -_)  _/ _| ' \  | (_) | ' \/ -_) | .` / _ \  _/ -_) |   / -_) / _` |  _| / _ \ ' \(_-< ' \| | '_ \
+// |_|\___|\__\__|_||_|  \___/|_||_\___| |_|\_\___/\__\___| |_|_\___|_\__,_|\__|_\___/_||_/__/_||_|_| .__/
+//                                                                                                  |_|
+
+pub(crate) async fn select_note_to_note_relationship<'a, E>(
+    executor: E,
+    parent_id: &ParentId,
+    note_id: &NoteId,
+) -> SqlResult<NoteRelationship>
+where
+    E: Executor<'a, Database = Sqlite>,
+{
+    let get_note_to_note_relationship_sql = concat!(
+        "SELECT parent_id, note_id, location, kind ",
+        "FROM note_relationships ",
+        "WHERE parent_id = ? and note_id = ? ",
+        "LIMIT 1"
+    );
+    let s: NoteRelationshipRow = sqlx::query_as(get_note_to_note_relationship_sql)
+        .bind(&**parent_id)
+        .bind(&**note_id)
+        .fetch_one(executor)
+        .await?;
+    Ok(NoteRelationship::from(s))
+}
+
+//  _  _     _         _         _  _     _         ___     _      _   _             _    _
+// | \| |___| |_ ___  | |_ ___  | \| |___| |_ ___  | _ \___| |__ _| |_(_)___ _ _  __| |_ (_)_ __ ___
+// | .` / _ \  _/ -_) |  _/ _ \ | .` / _ \  _/ -_) |   / -_) / _` |  _| / _ \ ' \(_-< ' \| | '_ (_-<
+// |_|\_\___/\__\___|  \__\___/ |_|\_\___/\__\___| |_|_\___|_\__,_|\__|_\___/_||_/__/_||_|_| .__/__/
+//                                                                                         |_|
+
+pub(crate) async fn insert_note_to_note_relationship<'a, E>(
+    executor: E,
+    parent_id: &ParentId,
+    note_id: &NoteId,
+    location: i64,
+    kind: &RelationshipKind,
+) -> SqlResult<()>
+where
+    E: Executor<'a, Database = Sqlite>,
+{
+    let insert_note_to_note_relationship_sql = concat!(
+        "INSERT INTO note_relationships (parent_id, note_id, location, kind) ",
+        "values (?, ?, ?, ?)"
+    );
+
+    let _ = sqlx::query(insert_note_to_note_relationship_sql)
+        .bind(&**parent_id)
+        .bind(&**note_id)
+        .bind(&location)
+        .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<()>
+where
+    E: Executor<'a, Database = Sqlite>,
+{
+    let make_room_for_new_note_sql = concat!(
+        "UPDATE note_relationships ",
+        "SET location = location + 1 ",
+        "WHERE location >= ? and parent_id = ?;"
+    );
+
+    let _ = sqlx::query(make_room_for_new_note_sql)
+        .bind(&location)
+        .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>
+where
+    E: Executor<'a, Database = Sqlite>,
+{
+    let assert_max_child_location_for_note_sql =
+        "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)
+        .fetch_one(executor)
+        .await?;
+
+    Ok(count.count)
+}
+
+//  _  _     _         _         _  __        _              ___     _      _   _             _    _
+// | \| |___| |_ ___  | |_ ___  | |/ /__ _ __| |_ ___ _ _   | _ \___| |__ _| |_(_)___ _ _  __| |_ (_)_ __ ___
+// | .` / _ \  _/ -_) |  _/ _ \ | ' </ _` (_-<  _/ -_) ' \  |   / -_) / _` |  _| / _ \ ' \(_-< ' \| | '_ (_-<
+// |_|\_\___/\__\___|  \__\___/ |_|\_\__,_/__/\__\___|_||_| |_|_\___|_\__,_|\__|_\___/_||_/__/_||_|_| .__/__/
+//                                                                                                  |_|
+
+pub(crate) async fn insert_bulk_note_to_kasten_relationships<'a, E>(
+    executor: E,
+    note_id: &NoteId,
+    references: &[NoteId],
+) -> SqlResult<()>
+where
+    E: Executor<'a, Database = Sqlite>,
+{
+    if references.is_empty() {
+        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 "
+        .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.execute(executor).await.map(|_| ())
+}
+
+pub(crate) async fn delete_bulk_note_to_kasten_relationships<'a, E>(executor: E, note_id: &NoteId) -> 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)
+        .execute(executor)
+        .await?;
+    Ok(())
+}
+
+// Given the references supplied, and the references found in the datastore,
+// return a list of the references not found in the datastore.
+pub(crate) fn diff_references(references: &[String], found_references: &[PageTitle]) -> Vec<String> {
+    let all: HashSet<String> = references.iter().cloned().collect();
+    let found: HashSet<String> = found_references.iter().map(|r| r.content.clone()).collect();
+    all.difference(&found).cloned().collect()
+}
+
+//   ___         _           _     _         _  __        _              ___     _      _   _             _    _
+//  / __|___ _ _| |_ ___ _ _| |_  | |_ ___  | |/ /__ _ __| |_ ___ _ _   | _ \___| |__ _| |_(_)___ _ _  __| |_ (_)_ __ ___
+// | (__/ _ \ ' \  _/ -_) ' \  _| |  _/ _ \ | ' </ _` (_-<  _/ -_) ' \  |   / -_) / _` |  _| / _ \ ' \(_-< ' \| | '_ (_-<
+//  \___\___/_||_\__\___|_||_\__|  \__\___/ |_|\_\__,_/__/\__\___|_||_| |_|_\___|_\__,_|\__|_\___/_||_/__/_||_|_| .__/__/
+//                                                                                                              |_|
+
+// 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>(
+    executor: E,
+    references: &[String],
+) -> SqlResult<Vec<PageTitle>>
+where
+    E: Executor<'a, Database = Sqlite>,
+{
+    if references.is_empty() {
+        return Ok(vec![]);
+    }
+
+    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()
+        );
+    }
+
+    let find_all_references_for_sql =
+        SELECT_ALL_REFERENCES_FOR_SQL_BASE.to_string() + &["?"].repeat(references.len()).join(",") + &");".to_string();
+
+    let mut request = sqlx::query_as(&find_all_references_for_sql);
+    for id in references.iter() {
+        request = request.bind(id);
+    }
+    request.fetch_all(executor).await
+}
+
+//  ___      _     _
+// |   \ ___| |___| |_ ___
+// | |) / -_) / -_)  _/ -_)
+// |___/\___|_\___|\__\___|
+//
+
+pub(crate) async fn delete_note_to_note_relationship<'a, E>(
+    executor: E,
+    parent_id: &ParentId,
+    note_id: &NoteId,
+) -> SqlResult<()>
+where
+    E: Executor<'a, Database = Sqlite>,
+{
+    let delete_note_to_note_relationship_sql = concat!(
+        "DELETE FROM note_relationships ",
+        "WHERE parent_id = ? and note_id = ? "
+    );
+
+    let count = sqlx::query(delete_note_to_note_relationship_sql)
+        .bind(&**parent_id)
+        .bind(&**note_id)
+        .execute(executor)
+        .await?
+        .rows_affected();
+
+    match count {
+        1 => Ok(()),
+        _ => Err(sqlx::Error::RowNotFound),
+    }
+}
+
+pub(crate) async fn delete_note_to_kasten_relationships<'a, E>(executor: E, note_id: &NoteId) -> SqlResult<()>
+where
+    E: Executor<'a, Database = Sqlite>,
+{
+    lazy_static! {
+        static ref DELETE_NOTE_TO_KASTEN_RELATIONSHIPS_SQL: String = format!(
+            "DELETE FROM note_relationships WHERE kind in ('{}', '{}') AND parent_id = ?;",
+            KastenRelationshipKind::Kasten.to_string(),
+            KastenRelationshipKind::Unacked.to_string()
+        );
+    }
+
+    let _ = sqlx::query(&DELETE_NOTE_TO_KASTEN_RELATIONSHIPS_SQL)
+        .bind(&**note_id)
+        .execute(executor)
+        .await?;
+    Ok(())
+}
+
+pub(crate) async fn delete_note<'a, E>(executor: E, note_id: &NoteId) -> 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)
+        .execute(executor)
+        .await?
+        .rows_affected();
+
+    match count {
+        1 => Ok(()),
+        _ => Err(sqlx::Error::RowNotFound),
+    }
+}
+
+// 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>(
+    executor: E,
+    parent_id: &ParentId,
+    location: i64,
+) -> SqlResult<()>
+where
+    E: Executor<'a, Database = Sqlite>,
+{
+    let close_hole_for_deleted_note_sql = concat!(
+        "UPDATE note_relationships ",
+        "SET location = location - 1 ",
+        "WHERE location > ? and parent_id = ?;"
+    );
+
+    let _ = sqlx::query(close_hole_for_deleted_note_sql)
+        .bind(&location)
+        .bind(&**parent_id)
+        .execute(executor)
+        .await?;
+    Ok(())
+}
+
+//  __  __ _        
+// |  \/  (_)___ __ 
+// | |\/| | (_-</ _|
+// |_|  |_|_/__/\__|
+//                  
+
+// The dreaded miscellaneous!
+
+pub(crate) async fn count_existing_note_relationships<'a, E>(executor: E, note_id: &NoteId) -> 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: RowCount = sqlx::query_as(&count_existing_note_relationships_sql)
+        .bind(&**note_id)
+        .fetch_one(executor)
+        .await?;
+
+    Ok(count.count)
+}

server/nm-store/src/structs.rs

@@ -10,92 +10,79 @@ use sqlx::{self, FromRow};
 // "cargo," "cell," and so forth.  If I'd wanted to go the Full
 // Noguchi, I guess I could have used "envelope."
 
+// In order to prevent arbitrary enumeration tokens from getting into
+// the database, the private layer takes a very hard line on insisting
+// that everything sent TO the datastore come in the enumerated
+// format, and everything coming OUT of the database be converted back
+// into an enumeration.  These macros instantiate those objects
+// and their conversions to/from strings.
+
+macro_rules! build_conversion_enums {
+    ( $ty:ident, $( $s:literal => $x:ident, )*) => {
+		#[derive(Clone, Debug, PartialEq, Eq)]
+		pub enum $ty {
+			$( $x ), *
+		}
+
+        impl From<String> for $ty {
+            fn from(kind: String) -> Self {
+                match &kind[..] {
+                    $( $s => $ty::$x, )*
+                    _ => panic!("Illegal value in $ty database: {}", kind),
+                }
+            }
+        }
+
+        impl From<$ty> for String {
+            fn from(kind: $ty) -> Self {
+                match kind {
+                    $( $ty::$x => $s ),*
+                }
+                .to_string()
+            }
+        }
+
+        impl $ty {
+            pub fn to_string(&self) -> String {
+                String::from(self.clone())
+            }
+        }
+    };
+}
+
 #[derive(Shrinkwrap, Clone)]
 pub(crate) struct NoteId(pub String);
 
 #[derive(Shrinkwrap, Clone)]
 pub(crate) struct ParentId(pub String);
 
-/// The different kinds of objects we support.
+// The different kinds of objects we support.
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub enum NoteKind {
-    Kasten,
-    Note,
-    Resource,
-}
 
-impl From<String> for NoteKind {
+build_conversion_enums!(
-    fn from(kind: String) -> Self {
+    NoteKind,
-        match &kind[..] {
+    "box" => Kasten,
-            "box" => NoteKind::Kasten,
+    "note" => Note,
-            "note" => NoteKind::Note,
+    "resource" => Resource,
-            "resource" => NoteKind::Resource,
+);
-            _ => panic!("Illegal value in database: {}", kind),
-        }
-    }
-}
 
-impl From<NoteKind> for String {
+// The different kinds of relationships we support.  I do not yet
-    fn from(kind: NoteKind) -> Self {
+// know how to ensure that there is a maximum of one (a ->
-        match kind {
+// b)::Direct, and that for any (a -> b) there is no (b <- a), that
-            NoteKind::Kasten => "box",
+// is, nor, for that matter, do I know how to prevent cycles.
-            NoteKind::Note => "note",
-            NoteKind::Resource => "resource",
-        }
-        .to_string()
-    }
-}
 
-impl NoteKind {
+build_conversion_enums!(
-    pub fn to_string(&self) -> String {
+    RelationshipKind,
-        String::from(self.clone())
+    "direct" => Direct,
-    }
+    "reference" => Reference,
-}
+    "embed" => Embed,
+);
 
-/// The different kinds of relationships we support.  I do not yet
+build_conversion_enums!(
-/// know how to ensure that there is a maximum of one (a ->
+    KastenRelationshipKind,
-/// b)::Direct, and that for any (a -> b) there is no (b <- a), that
+    "kasten" => Kasten,
-/// is, nor, for that matter, do I know how to prevent cycles.
+    "unacked" => Unacked,
-#[derive(Clone, Debug, PartialEq, Eq)]
+    "cancelled" => Cancelled,
-pub enum RelationshipKind {
+);
-    Direct,
-    Reference,
-    Embed,
-    Kasten,
-    Unacked,
-}
-
-impl From<String> for RelationshipKind {
-    fn from(kind: String) -> Self {
-        match &kind[..] {
-            "direct" => RelationshipKind::Direct,
-            "reference" => RelationshipKind::Reference,
-            "embed" => RelationshipKind::Embed,
-            "kasten" => RelationshipKind::Kasten,
-            "unacked" => RelationshipKind::Unacked,
-            _ => panic!("Illegal value in database: {}", kind),
-        }
-    }
-}
-
-impl From<RelationshipKind> for String {
-    fn from(kind: RelationshipKind) -> Self {
-        match kind {
-            RelationshipKind::Direct => "direct",
-            RelationshipKind::Reference => "reference",
-            RelationshipKind::Embed => "embed",
-            RelationshipKind::Kasten => "kasten",
-            RelationshipKind::Unacked => "unacked",
-        }
-        .to_string()
-    }
-}
-
-impl RelationshipKind {
-    pub fn to_string(&self) -> String {
-        String::from(self.clone())
-    }
-}
 
 // A Note is the base construct of our system. It represents a
 // single note and contains information about its parent and location.
@@ -229,6 +216,30 @@ impl From<NoteRelationshipRow> for NoteRelationship {
     }
 }
 
+#[derive(Clone, Debug, FromRow)]
+pub(crate) struct KastenRelationshipRow {
+    pub note_id: String,
+    pub kasten_id: String,
+    pub kind: String,
+}
+
+#[derive(Clone, Debug)]
+pub(crate) struct KastenRelationship {
+    pub note_id: String,
+    pub kasten_id: String,
+    pub kind: KastenRelationshipKind,
+}
+
+impl From<KastenRelationshipRow> for KastenRelationship {
+    fn from(rel: KastenRelationshipRow) -> Self {
+        Self {
+            kasten_id: rel.kasten_id,
+            note_id: rel.note_id,
+            kind: KastenRelationshipKind::from(rel.kind),
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;