#529 add property index, speed up queries

CHANGELOG.md

@@ -6,6 +6,7 @@ Changes to JS assets are not included here, but in [`atomic-data-browser`'s CHAN
 
 ## UNRELEASED
 
+- Improve query performance, refactor indexes. The `.tpf` API is deprecated in favor of the more powerful `.query`. #529
 - Improved error handling for HTTPS initialization #530
 
 ## [v0.34.0] - 2022-10-31

cli/src/print.rs

@@ -64,7 +64,7 @@ pub fn print_resource(
         Format::Json => resource.to_json(&context.store)?,
         Format::JsonLd => resource.to_json_ld(&context.store)?,
         Format::JsonAd => resource.to_json_ad()?,
-        Format::NTriples => serialize::atoms_to_ntriples(resource.to_atoms()?, &context.store)?,
+        Format::NTriples => serialize::atoms_to_ntriples(resource.to_atoms(), &context.store)?,
         Format::Pretty => pretty_print_resource(resource, &context.store)?,
     };
     println!("{}", out);

lib/src/atoms.rs

@@ -1,9 +1,13 @@
-//! The smallest units of data, consiting of a Subject, a Property and a Value
+//! The smallest units of data, consisting of a Subject, a Property and a Value
 
-use crate::{errors::AtomicResult, values::Value};
+use crate::{
+    errors::AtomicResult,
+    values::{ReferenceString, SortableValue, Value},
+};
 
-/// The Atom is the (non-validated) string representation of a piece of data.
-/// It's RichAtom sibling provides some extra methods.
+/// The Atom is the smallest meaningful piece of data.
+/// It describes how one value relates to a subject.
+/// A [Resource] can be converted into a bunch of Atoms.
 #[derive(Clone, Debug)]
 pub struct Atom {
     /// The URL where the resource is located
@@ -27,6 +31,35 @@ impl Atom {
         let base_path = format!("{} {}", self.subject, self.property);
         self.value.to_subjects(Some(base_path))
     }
+
+    /// Converts one Atom to a series of stringified values that can be indexed.
+    pub fn to_indexable_atoms(&self) -> Vec<IndexAtom> {
+        let sort_value = self.value.to_sortable_string();
+        let index_atoms = match &self.value.to_reference_index_strings() {
+            Some(v) => v,
+            None => return vec![],
+        }
+        .iter()
+        .map(|v| IndexAtom {
+            ref_value: v.into(),
+            sort_value: sort_value.clone(),
+            subject: self.subject.clone(),
+            property: self.property.clone(),
+        })
+        .collect();
+        index_atoms
+    }
+}
+
+/// Differs from a regular [Atom], since the value here is always a string,
+/// and in the case of ResourceArrays, only a _single_ subject is used for each atom.
+/// One IndexAtom for every member of the ResourceArray is created.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct IndexAtom {
+    pub subject: String,
+    pub property: String,
+    pub ref_value: ReferenceString,
+    pub sort_value: SortableValue,
 }
 
 impl std::fmt::Display for Atom {

lib/src/commit.rs

@@ -344,18 +344,22 @@ impl Commit {
         // Remove all atoms from index if destroy
         if let Some(destroy) = self.destroy {
             if destroy {
-                for atom in resource.to_atoms()?.into_iter() {
+                for atom in resource.to_atoms().into_iter() {
                     remove_atoms.push(atom);
                 }
             }
         }
 
         if update_index {
             for atom in remove_atoms {
-                store.remove_atom_from_index(&atom, &resource_unedited)?;
+                store
+                    .remove_atom_from_index(&atom, &resource_unedited)
+                    .map_err(|e| format!("Error removing atom from index: {e}  Atom: {e}"))?
             }
             for atom in add_atoms {
-                store.add_atom_to_index(&atom, &resource)?;
+                store
+                    .add_atom_to_index(&atom, &resource)
+                    .map_err(|e| format!("Error adding atom to index: {e}  Atom: {e}"))?;
             }
         }
         Ok(resource)