595 lines
20 KiB
Rust
595 lines
20 KiB
Rust
use crate::structs::*;
|
|
use lazy_static::lazy_static;
|
|
use regex::Regex;
|
|
use slug::slugify;
|
|
use sqlx::{sqlite::Sqlite, Acquire, Done, Executor, Transaction};
|
|
use std::cmp;
|
|
use std::collections::HashSet;
|
|
|
|
type SqlResult<T> = sqlx::Result<T>;
|
|
|
|
// ___ _ _
|
|
// | _ \_ _(_)_ ____ _| |_ ___
|
|
// | _/ '_| \ V / _` | _/ -_)
|
|
// |_| |_| |_|\_/\__,_|\__\___|
|
|
//
|
|
|
|
// I'm putting a lot of faith in Rust's ability to inline stuff. I'm
|
|
// sure this is okay. But really, this lets the API be clean and
|
|
// coherent and easily readable, and hides away the gnarliness of some
|
|
// of the SQL queries.
|
|
|
|
lazy_static! {
|
|
static ref SELECT_PAGE_BY_TITLE_SQL: String = str::replace(
|
|
include_str!("sql/select_notes_by_parameter.sql"),
|
|
"QUERYPARAMETER",
|
|
"notes.content"
|
|
);
|
|
}
|
|
|
|
lazy_static! {
|
|
static ref SELECT_PAGE_BY_ID_SQL: String = str::replace(
|
|
include_str!("sql/select_notes_by_parameter.sql"),
|
|
"QUERYPARAMETER",
|
|
"notes.id"
|
|
);
|
|
}
|
|
|
|
lazy_static! {
|
|
static ref SELECT_NOTES_BACKREFERENCING_PAGE_SQL: &'static str =
|
|
include_str!("sql/select_notes_backreferencing_page.sql");
|
|
}
|
|
|
|
// ___ _
|
|
// | _ \___ ___ ___| |_
|
|
// | / -_|_-</ -_) _|
|
|
// |_|_\___/__/\___|\__|
|
|
//
|
|
|
|
pub(crate) async fn reset_database<'a, E>(executor: E) -> SqlResult<()>
|
|
where
|
|
E: Executor<'a, Database = Sqlite>,
|
|
{
|
|
let initialize_sql = include_str!("sql/initialize_database.sql");
|
|
sqlx::query(initialize_sql).execute(executor).await.map(|_| ())
|
|
}
|
|
|
|
// ___ _ _ _ __ _
|
|
// | __|__| |_ __| |_ | |/ /__ _ __| |_ ___ _ _
|
|
// | _/ -_) _/ _| ' \ | ' </ _` (_-< _/ -_) ' \
|
|
// |_|\___|\__\__|_||_| |_|\_\__,_/__/\__\___|_||_|
|
|
//
|
|
|
|
// 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(Note::from).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
|
|
// page.
|
|
pub(crate) async fn select_page_by_slug<'a, E>(executor: E, slug: &str) -> SqlResult<Vec<Note>>
|
|
where
|
|
E: Executor<'a, Database = Sqlite>,
|
|
{
|
|
select_object_by_query(executor, &SELECT_PAGE_BY_ID_SQL, &slug).await
|
|
}
|
|
|
|
// 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_page_by_title<'a, E>(executor: E, title: &str) -> SqlResult<Vec<Note>>
|
|
where
|
|
E: Executor<'a, Database = Sqlite>,
|
|
{
|
|
select_object_by_query(executor, &SELECT_PAGE_BY_TITLE_SQL, &title).await
|
|
}
|
|
|
|
// 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_page<'a, E>(executor: E, page_id: &str) -> SqlResult<Vec<Note>>
|
|
where
|
|
E: Executor<'a, Database = Sqlite>,
|
|
{
|
|
select_object_by_query(executor, &SELECT_NOTES_BACKREFERENCING_PAGE_SQL, &page_id).await
|
|
}
|
|
|
|
// ___ _ ___ _ _ _
|
|
// |_ _|_ _ ___ ___ _ _| |_ / _ \ _ _ ___ | \| |___| |_ ___
|
|
// | || ' \(_-</ -_) '_| _| | (_) | ' \/ -_) | .` / _ \ _/ -_)
|
|
// |___|_||_/__/\___|_| \__| \___/|_||_\___| |_|\_\___/\__\___|
|
|
//
|
|
|
|
// Inserts a single note into the notes table. That is all.
|
|
pub(crate) async fn insert_note<'a, E>(executor: E, note: &NewNote) -> SqlResult<String>
|
|
where
|
|
E: Executor<'a, Database = Sqlite>,
|
|
{
|
|
let insert_one_note_sql = concat!(
|
|
"INSERT INTO notes (id, content, kind, ",
|
|
" creation_date, updated_date, lastview_date) ",
|
|
"VALUES (?, ?, ?, ?, ?, ?);"
|
|
);
|
|
|
|
sqlx::query(insert_one_note_sql)
|
|
.bind(¬e.id)
|
|
.bind(¬e.content)
|
|
.bind(note.kind.to_string())
|
|
.bind(¬e.creation_date)
|
|
.bind(¬e.updated_date)
|
|
.bind(¬e.lastview_date)
|
|
.execute(executor)
|
|
.await?;
|
|
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(¬e.id)
|
|
.bind(¬e.content)
|
|
.bind(note.kind.to_string())
|
|
.bind(¬e.creation_date)
|
|
.bind(¬e.updated_date)
|
|
.bind(¬e.lastview_date);
|
|
}
|
|
request.execute(executor).await.map(|_| ())
|
|
}
|
|
|
|
// ___ _ _ _ _ __ _
|
|
// | _ )_ _(_) |__| | | |/ /__ _ __| |_ ___ _ _
|
|
// | _ \ || | | / _` | | ' </ _` (_-< _/ -_) ' \
|
|
// |___/\_,_|_|_\__,_| |_|\_\__,_/__/\__\___|_||_|
|
|
//
|
|
|
|
// Given a possible slug, find the slug with the highest
|
|
// uniquification number, and return that number, if any.
|
|
pub(crate) fn find_maximal_slug_number(slugs: &[JustId]) -> Option<u32> {
|
|
lazy_static! {
|
|
static ref RE_CAP_NUM: Regex = Regex::new(r"-(\d+)$").unwrap();
|
|
}
|
|
|
|
if slugs.is_empty() {
|
|
return None;
|
|
}
|
|
|
|
let mut slug_counters: Vec<u32> = slugs
|
|
.iter()
|
|
.filter_map(|slug| RE_CAP_NUM.captures(&slug.id))
|
|
.map(|cap| cap.get(1).unwrap().as_str().parse::<u32>().unwrap())
|
|
.collect();
|
|
slug_counters.sort_unstable();
|
|
slug_counters.pop()
|
|
}
|
|
|
|
// Given an initial string and an existing collection of slugs,
|
|
// generate a new slug that does not conflict with the current
|
|
// collection. Right now we're using the slugify operation, which...
|
|
// isn't all that.
|
|
pub(crate) async fn generate_slug<'a, E>(executor: E, title: &str) -> SqlResult<String>
|
|
where
|
|
E: Executor<'a, Database = Sqlite>,
|
|
{
|
|
lazy_static! {
|
|
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::Page.to_string()
|
|
);
|
|
}
|
|
|
|
let initial_slug = slugify(title);
|
|
let sample_slug = RE_STRIP_NUM.replace_all(&initial_slug, "");
|
|
let similar_slugs: Vec<JustId> = sqlx::query_as(&SLUG_FINDER_SQL)
|
|
.bind(&*sample_slug)
|
|
.fetch_all(executor)
|
|
.await?;
|
|
let maximal_slug_number = find_maximal_slug_number(&similar_slugs);
|
|
Ok(match maximal_slug_number {
|
|
None => initial_slug,
|
|
Some(slug_number) => format!("{}-{}", initial_slug, slug_number + 1),
|
|
})
|
|
}
|
|
|
|
// A helper function: given a title and a slug, create a PageType
|
|
// note.
|
|
pub(crate) fn create_page(title: &str, slug: &str) -> NewNote {
|
|
NewNoteBuilder::default()
|
|
.id(slug.to_string())
|
|
.content(title.to_string())
|
|
.kind(NoteKind::Page)
|
|
.build()
|
|
.unwrap()
|
|
}
|
|
|
|
// _ _ _ _ ___ _ _ _
|
|
// | | | |_ __ __| |__ _| |_ ___ / _ \ _ _ ___ | \| |___| |_ ___
|
|
// | |_| | '_ \/ _` / _` | _/ -_) | (_) | ' \/ -_) | .` / _ \ _/ -_)
|
|
// \___/| .__/\__,_\__,_|\__\___| \___/|_||_\___| |_|\_\___/\__\___|
|
|
// |_|
|
|
|
|
pub(crate) async fn update_note_content<'a, E>(executor: E, note_id: &str, 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: &str,
|
|
note_id: &str,
|
|
) -> 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: &str,
|
|
note_id: &str,
|
|
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 (?, ?, ?, ?)"
|
|
);
|
|
|
|
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_relationship<'a, E>(
|
|
executor: E,
|
|
parent_id: &str,
|
|
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 = ?;"
|
|
);
|
|
|
|
sqlx::query(make_room_for_new_note_sql)
|
|
.bind(&location)
|
|
.bind(parent_id)
|
|
.execute(executor)
|
|
.await?;
|
|
Ok(())
|
|
}
|
|
|
|
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>,
|
|
{
|
|
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_page_relationships<'a, E>(
|
|
executor: E,
|
|
note_id: &str,
|
|
references: &[String],
|
|
) -> SqlResult<()>
|
|
where
|
|
E: Executor<'a, Database = Sqlite>,
|
|
{
|
|
if references.is_empty() {
|
|
return Ok(());
|
|
}
|
|
|
|
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.execute(executor).await.map(|_| ())
|
|
}
|
|
|
|
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_page_relationship_sql = "DELETE FROM note_page_relationships WHERE and note_id = ?;";
|
|
sqlx::query(delete_note_to_page_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_page_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::Page.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: &str,
|
|
note_id: &str,
|
|
) -> 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_page_relationships<'a, E>(executor: E, note_id: &str) -> SqlResult<()>
|
|
where
|
|
E: Executor<'a, Database = Sqlite>,
|
|
{
|
|
lazy_static! {
|
|
static ref DELETE_NOTE_TO_PAGE_RELATIONSHIPS_SQL: String = format!(
|
|
"DELETE FROM note_relationships WHERE kind in ('{}', '{}') AND parent_id = ?;",
|
|
PageRelationshipKind::Page.to_string(),
|
|
PageRelationshipKind::Unacked.to_string()
|
|
);
|
|
}
|
|
|
|
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: &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)
|
|
.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_relationship<'a, E>(
|
|
executor: E,
|
|
parent_id: &str,
|
|
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 = ?;"
|
|
);
|
|
|
|
sqlx::query(close_hole_for_deleted_note_sql)
|
|
.bind(&location)
|
|
.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));
|
|
}
|
|
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: &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: RowCount = sqlx::query_as(&count_existing_note_relationships_sql)
|
|
.bind(note_id)
|
|
.fetch_one(executor)
|
|
.await?;
|
|
Ok(count.count)
|
|
}
|