lib

Core libraries for Radroots
git clone https://radroots.dev/git/lib.git
Log | Files | Refs | README

document_query.rs (6097B)


      1 use super::{SqliteStorage, map_backend};
      2 use radroots_storage::{
      3     Error,
      4     projection::{
      5         ProjectionDocument, ProjectionGeneration,
      6         document_query::{
      7             PROJECTION_DOCUMENT_PAGE_BYTES_MAX, ProjectionDocumentGenerations,
      8             ProjectionDocumentPage, ProjectionDocumentQuery, ProjectionDocumentRecord,
      9         },
     10     },
     11 };
     12 use sqlx::Row;
     13 
     14 pub(super) async fn page(
     15     store: &SqliteStorage,
     16     query: ProjectionDocumentQuery,
     17 ) -> Result<ProjectionDocumentPage, Error> {
     18     let mut transaction = store.pool().begin().await.map_err(map_backend)?;
     19     let result = read_page(&mut transaction, &query).await;
     20     let rollback = transaction.rollback().await.map_err(map_backend);
     21     match result {
     22         Ok(page) => {
     23             rollback?;
     24             Ok(page)
     25         }
     26         Err(error) => Err(error),
     27     }
     28 }
     29 
     30 pub(super) async fn page_at(
     31     store: &SqliteStorage,
     32     query: ProjectionDocumentQuery,
     33     source: radroots_storage::event::EventSourceToken,
     34     active: ProjectionGeneration,
     35 ) -> Result<ProjectionDocumentPage, Error> {
     36     if query.generations() != ProjectionDocumentGenerations::Exact(active) {
     37         return Err(Error::InvalidProjectionDocument);
     38     }
     39     let mut transaction = store.pool().begin().await.map_err(map_backend)?;
     40     super::batch::read_fence(
     41         &mut transaction,
     42         store,
     43         source,
     44         query.projection_id(),
     45         active,
     46     )
     47     .await?;
     48     let result = read_page(&mut transaction, &query).await;
     49     let rollback = transaction.rollback().await.map_err(map_backend);
     50     match result {
     51         Ok(page) => {
     52             rollback?;
     53             Ok(page)
     54         }
     55         Err(error) => Err(error),
     56     }
     57 }
     58 
     59 fn selection(query: &ProjectionDocumentQuery) -> sqlx::QueryBuilder<sqlx::Sqlite> {
     60     // CASE bounds every variable-width metadata value before SQLx allocates it.
     61     // Payloads are loaded separately, only after charging this page's byte budget.
     62     let mut selection = sqlx::QueryBuilder::new(
     63         "SELECT CASE WHEN length(generation) = 32 THEN generation END AS generation,
     64                 CASE WHEN length(CAST(document_key AS BLOB)) BETWEEN 1 AND 512 THEN document_key END AS document_key,
     65                 CASE WHEN length(value_sha256) = 32 THEN value_sha256 END AS value_sha256,
     66                 length(value) AS value_bytes
     67          FROM radroots_runtime_projection_documents AS documents
     68          WHERE projection_id = "
     69     );
     70     selection.push_bind(query.projection_id().as_str());
     71     if let ProjectionDocumentGenerations::Exact(generation) = query.generations() {
     72         selection
     73             .push(" AND generation = ")
     74             .push_bind(generation.as_bytes().to_vec());
     75     }
     76     if let Some((generation, key)) = query.after() {
     77         selection
     78             .push(" AND (generation, document_key) > (")
     79             .push_bind(generation.as_bytes().to_vec())
     80             .push(", ")
     81             .push_bind(key)
     82             .push(")");
     83     }
     84     if let Some(range) = query.key_range() {
     85         selection
     86             .push(" AND document_key >= ")
     87             .push_bind(range.first())
     88             .push(" AND document_key <= ")
     89             .push_bind(range.last());
     90     }
     91     selection
     92         .push(" ORDER BY documents.generation, documents.document_key LIMIT ")
     93         .push_bind(i64::from(query.limit()) + 1);
     94     selection
     95 }
     96 
     97 async fn read_page(
     98     transaction: &mut sqlx::Transaction<'_, sqlx::Sqlite>,
     99     query: &ProjectionDocumentQuery,
    100 ) -> Result<ProjectionDocumentPage, Error> {
    101     let mut selection = selection(query);
    102     let rows = selection
    103         .build()
    104         .fetch_all(&mut **transaction)
    105         .await
    106         .map_err(map_backend)?;
    107     let mut has_more = rows.len() > usize::from(query.limit());
    108     let mut records = Vec::new();
    109     let mut bytes = 0;
    110     for row in rows.iter().take(usize::from(query.limit())) {
    111         let generation: Vec<u8> = row
    112             .try_get("generation")
    113             .map_err(|_| Error::CorruptProjectionDocument)?;
    114         let generation = ProjectionGeneration::new(
    115             generation
    116                 .try_into()
    117                 .map_err(|_| Error::CorruptProjectionDocument)?,
    118         )
    119         .map_err(|_| Error::CorruptProjectionDocument)?;
    120         let key: String = row
    121             .try_get("document_key")
    122             .map_err(|_| Error::CorruptProjectionDocument)?;
    123         let corrupt = ProjectionDocumentRecord::corrupt(generation, key.clone())?;
    124         let digest: Option<Vec<u8>> = row
    125             .try_get("value_sha256")
    126             .map_err(|_| Error::CorruptProjectionDocument)?;
    127         let size: i64 = row
    128             .try_get("value_bytes")
    129             .map_err(|_| Error::CorruptProjectionDocument)?;
    130         let Some(digest) = digest else {
    131             records.push(corrupt);
    132             continue;
    133         };
    134         let digest: [u8; 32] = digest
    135             .try_into()
    136             .map_err(|_| Error::CorruptProjectionDocument)?;
    137         if size <= 0 || size > PROJECTION_DOCUMENT_PAGE_BYTES_MAX as i64 {
    138             records.push(corrupt);
    139             continue;
    140         }
    141         let size = size as usize;
    142         if bytes + size > query.payload_budget() {
    143             if records.is_empty() {
    144                 return Err(Error::SpaceInsufficient);
    145             }
    146             has_more = true;
    147             break;
    148         }
    149         bytes += size;
    150         let value: Vec<u8> = sqlx::query_scalar(
    151             "SELECT value FROM radroots_runtime_projection_documents WHERE projection_id = ? AND generation = ? AND document_key = ?"
    152         ).bind(query.projection_id().as_str()).bind(generation.as_bytes().as_slice()).bind(&key)
    153             .fetch_one(&mut **transaction).await.map_err(map_backend)?;
    154         records.push(
    155             match ProjectionDocument::from_stored_parts(key, value, digest) {
    156                 Ok(document) => ProjectionDocumentRecord::new(generation, document)?,
    157                 Err(_) => corrupt,
    158             },
    159         );
    160     }
    161     ProjectionDocumentPage::new(query, records, has_more)
    162 }
    163 
    164 #[cfg(test)]
    165 mod selection_tests;
    166 #[cfg(test)]
    167 mod tests;