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;