visibility_reads.rs (16382B)
1 use super::*; 2 use radroots_event::id::Nip01Coordinate; 3 use radroots_storage::event::VisibilityIndexBounds; 4 5 type Transaction<'a> = sqlx::Transaction<'a, Sqlite>; 6 7 impl SqliteStorage { 8 pub(super) async fn visibility_header( 9 &self, 10 transaction: &mut Transaction<'_>, 11 expected: Option<EventSourceToken>, 12 ) -> Result<EventStoreStatus, Error> { 13 let sql = "SELECT source.mutation_epoch, source.sequence_head, progress.ready, 14 progress.replay_epoch, progress.raw_events, progress.verified_events, 15 progress.visible_events 16 FROM radroots_runtime_source_generations AS source 17 LEFT JOIN radroots_runtime_visibility_progress AS progress 18 ON progress.source_generation = source.generation 19 WHERE source.generation = ? AND source.state = 'active'"; 20 #[cfg(test)] 21 self.work.request(work::Read::Aggregate, sql); 22 let row = sqlx::query(sql) 23 .bind(self.generation.as_bytes().as_slice()) 24 .fetch_optional(&mut **transaction) 25 .await 26 .map_err(map_backend)? 27 .ok_or(Error::SourceGenerationChanged)?; 28 #[cfg(test)] 29 self.work.aggregate_returned(); 30 let epoch = u64_from_i64(row.try_get("mutation_epoch").map_err(map_corrupt)?)?; 31 if expected.is_some_and(|token| token != EventSourceToken::new(self.generation, epoch)) { 32 return Err(Error::SourceEpochChanged); 33 } 34 let ready: Option<bool> = row.try_get("ready").map_err(map_corrupt)?; 35 if ready != Some(true) { 36 return Err(Error::VisibilityRebuilding); 37 } 38 let replay = u64_from_i64(row.try_get("replay_epoch").map_err(map_corrupt)?)?; 39 let raw = u64_from_i64(row.try_get("raw_events").map_err(map_corrupt)?)?; 40 let sequence = u64_from_i64(row.try_get("sequence_head").map_err(map_corrupt)?)?; 41 if replay != epoch || raw != sequence { 42 return Err(Error::CorruptStoredEvent); 43 } 44 EventStoreStatus::new( 45 self.generation, 46 self.mode, 47 EventStoreHealth::Available, 48 raw, 49 u64_from_i64(row.try_get("verified_events").map_err(map_corrupt)?)?, 50 u64_from_i64(row.try_get("visible_events").map_err(map_corrupt)?)?, 51 ) 52 } 53 54 pub(super) async fn indexed_visible_page( 55 &self, 56 query: EventQuery, 57 expected: Option<EventSourceToken>, 58 ) -> Result<EventPage<StoredVisibleEvent>, Error> { 59 self.validate_cursor(&query)?; 60 let mut transaction = self.pool.begin().await.map_err(map_backend)?; 61 self.visibility_header(&mut transaction, expected).await?; 62 let after = query 63 .bounds() 64 .cursor() 65 .map_or(0, |cursor| cursor.sequence().get()); 66 let mut builder = QueryBuilder::<Sqlite>::new( 67 "SELECT member.source_sequence, length(event.signed_event) AS signed_bytes 68 FROM radroots_runtime_visibility_members AS member INDEXED BY ", 69 ); 70 if query.event_ids().is_empty() { 71 builder.push("radroots_runtime_visibility_members_page_idx"); 72 } else { 73 builder.push("radroots_runtime_visibility_members_event_idx"); 74 } 75 builder.push( 76 " JOIN radroots_runtime_events AS event ON event.event_id = member.event_id 77 WHERE member.source_generation = ", 78 ); 79 builder.push_bind(self.generation.as_bytes().as_slice()); 80 builder 81 .push(" AND member.visible = 1 AND member.source_sequence > ") 82 .push_bind(i64_from_u64(after)?); 83 if !query.event_ids().is_empty() { 84 builder.push(" AND member.event_id IN ("); 85 let mut ids = builder.separated(", "); 86 for id in query.event_ids() { 87 ids.push_bind(id.as_bytes().to_vec()); 88 } 89 ids.push_unseparated(")"); 90 } 91 builder 92 .push(" ORDER BY member.source_sequence LIMIT ") 93 .push_bind(i64::from(query.bounds().limit()) + 1); 94 #[cfg(test)] 95 self.work.request(work::Read::Keys, builder.sql().as_str()); 96 let lengths = builder 97 .build() 98 .fetch_all(&mut *transaction) 99 .await 100 .map_err(map_backend)?; 101 #[cfg(test)] 102 self.work.keys_returned(lengths.len()); 103 let mut charged = 4096 + (u64::from(query.bounds().limit()) + 1) * 128; 104 let mut items = Vec::new(); 105 let mut more = false; 106 for row in lengths { 107 if items.len() == usize::from(query.bounds().limit()) { 108 more = true; 109 break; 110 } 111 let sequence: i64 = row.try_get("source_sequence").map_err(map_corrupt)?; 112 let bytes = u64_from_i64(row.try_get("signed_bytes").map_err(map_corrupt)?)?; 113 let next_charge = charged 114 .checked_add(VisibilityIndexBounds::charge(bytes)?) 115 .ok_or(Error::SpaceInsufficient)?; 116 if next_charge > 16 * 1024 * 1024 { 117 if items.is_empty() { 118 return Err(Error::SpaceInsufficient); 119 } 120 more = true; 121 break; 122 } 123 let sql = "SELECT source_generation, source_sequence, signed_event, admission_stage, 124 admitted_contract_id, admitted_registry_version 125 FROM radroots_runtime_events WHERE source_generation = ? AND source_sequence = ?"; 126 #[cfg(test)] 127 self.work.request(work::Read::Bounded, sql); 128 let payload = sqlx::query(sql) 129 .bind(self.generation.as_bytes().as_slice()) 130 .bind(sequence) 131 .fetch_one(&mut *transaction) 132 .await 133 .map_err(map_backend)?; 134 #[cfg(test)] 135 self.work.returned(std::slice::from_ref(&payload)); 136 let decoded = self.decode_event_row(&payload)?; 137 if decoded.raw_json.len() as u64 != bytes || decoded.stage != AdmissionStage::Visible { 138 return Err(Error::CorruptStoredEvent); 139 } 140 items.push(StoredVisibleEvent::new(decoded.position, decoded.event)); 141 charged = next_charge; 142 } 143 let next = more 144 .then(|| items.last().map(StoredVisibleEvent::position)) 145 .flatten(); 146 transaction.commit().await.map_err(map_backend)?; 147 EventPage::new(self.generation, items, next, query.bounds()) 148 } 149 150 pub(super) async fn update_visibility_membership( 151 &self, 152 transaction: &mut Transaction<'_>, 153 position: i64, 154 ) -> Result<(), Error> { 155 let row = sqlx::query( 156 "SELECT event_id, admission_stage, head_coordinate, created_at 157 FROM radroots_runtime_visibility_events WHERE source_generation = ? AND source_sequence = ?") 158 .bind(self.generation.as_bytes().as_slice()).bind(position) 159 .fetch_one(&mut **transaction).await.map_err(map_backend)?; 160 let id: Vec<u8> = row.try_get("event_id").map_err(map_corrupt)?; 161 let stage: String = row.try_get("admission_stage").map_err(map_corrupt)?; 162 sqlx::query( 163 "INSERT INTO radroots_runtime_visibility_members 164 (source_generation, source_sequence, event_id, admission_stage, visible) 165 VALUES (?, ?, ?, ?, 0) ON CONFLICT(source_generation, source_sequence) 166 DO UPDATE SET admission_stage = excluded.admission_stage", 167 ) 168 .bind(self.generation.as_bytes().as_slice()) 169 .bind(position) 170 .bind(&id) 171 .bind(stage) 172 .execute(&mut **transaction) 173 .await 174 .map_err(map_backend)?; 175 let coordinate: Option<Vec<u8>> = row.try_get("head_coordinate").map_err(map_corrupt)?; 176 if let Some(coordinate) = coordinate { 177 let old = sqlx::query( 178 "SELECT head.source_sequence, metadata.created_at, metadata.event_id 179 FROM radroots_runtime_visibility_heads AS head 180 JOIN radroots_runtime_visibility_events AS metadata ON metadata.event_id = head.event_id 181 WHERE head.source_generation = ? AND head.head_coordinate = ?") 182 .bind(self.generation.as_bytes().as_slice()).bind(&coordinate) 183 .fetch_optional(&mut **transaction).await.map_err(map_backend)?; 184 let time: Vec<u8> = row.try_get("created_at").map_err(map_corrupt)?; 185 let replace = match &old { 186 None => true, 187 Some(old) => { 188 let old_time: Vec<u8> = old.try_get("created_at").map_err(map_corrupt)?; 189 let old_id: Vec<u8> = old.try_get("event_id").map_err(map_corrupt)?; 190 time > old_time || (time == old_time && id < old_id) 191 } 192 }; 193 if replace { 194 sqlx::query( 195 "INSERT INTO radroots_runtime_visibility_heads 196 (source_generation, head_coordinate, source_sequence, event_id) VALUES (?, ?, ?, ?) 197 ON CONFLICT(source_generation, head_coordinate) DO UPDATE SET 198 source_sequence = excluded.source_sequence, event_id = excluded.event_id") 199 .bind(self.generation.as_bytes().as_slice()).bind(coordinate).bind(position).bind(id) 200 .execute(&mut **transaction).await.map_err(map_backend)?; 201 if let Some(old) = old { 202 let previous = old.try_get("source_sequence").map_err(map_corrupt)?; 203 self.refresh_visibility_member(transaction, previous) 204 .await?; 205 } 206 } 207 } 208 self.refresh_visibility_member(transaction, position) 209 .await?; 210 // Immutable targets persist; this queue changes only membership, not source truth. 211 sqlx::query( 212 "INSERT OR IGNORE INTO radroots_runtime_visibility_pending 213 SELECT source_generation, 0, target_event FROM radroots_runtime_visibility_deletion_events 214 WHERE request_id = ?") 215 .bind(row.try_get::<Vec<u8>, _>("event_id").map_err(map_corrupt)?) 216 .execute(&mut **transaction).await.map_err(map_backend)?; 217 sqlx::query( 218 "INSERT OR IGNORE INTO radroots_runtime_visibility_pending 219 SELECT source_generation, 1, CAST(target_coordinate AS BLOB) 220 FROM radroots_runtime_visibility_deletion_addresses WHERE request_id = ?", 221 ) 222 .bind(row.try_get::<Vec<u8>, _>("event_id").map_err(map_corrupt)?) 223 .execute(&mut **transaction) 224 .await 225 .map_err(map_backend)?; 226 Ok(()) 227 } 228 229 async fn refresh_visibility_member( 230 &self, 231 transaction: &mut Transaction<'_>, 232 position: i64, 233 ) -> Result<(), Error> { 234 sqlx::query( 235 "UPDATE radroots_runtime_visibility_members SET visible = ( 236 SELECT candidate.admission_stage = 'visible' AND candidate.ephemeral = 0 237 AND (candidate.head_coordinate IS NULL OR candidate.event_id = ( 238 SELECT head.event_id FROM radroots_runtime_visibility_heads AS head 239 WHERE head.source_generation = candidate.source_generation 240 AND head.head_coordinate = candidate.head_coordinate)) 241 AND (candidate.deletion_request = 1 OR ( 242 NOT EXISTS (SELECT 1 FROM radroots_runtime_visibility_deletion_events AS deletion 243 WHERE deletion.source_generation = candidate.source_generation 244 AND deletion.target_event = candidate.event_id AND deletion.author = candidate.author) 245 AND NOT EXISTS (SELECT 1 FROM radroots_runtime_visibility_deletion_addresses AS deletion 246 WHERE deletion.source_generation = candidate.source_generation 247 AND deletion.target_coordinate = candidate.deletion_coordinate 248 AND deletion.author = candidate.author AND deletion.created_at >= candidate.created_at))) 249 FROM radroots_runtime_visibility_events AS candidate 250 WHERE candidate.source_generation = ? AND candidate.source_sequence = ?) 251 WHERE source_generation = ? AND source_sequence = ?") 252 .bind(self.generation.as_bytes().as_slice()).bind(position) 253 .bind(self.generation.as_bytes().as_slice()).bind(position) 254 .execute(&mut **transaction).await.map_err(map_backend)?; 255 Ok(()) 256 } 257 258 pub(super) async fn drain_visibility_keys( 259 &self, 260 transaction: &mut Transaction<'_>, 261 remaining: u16, 262 charged: &mut u64, 263 byte_limit: u64, 264 ) -> Result<u16, Error> { 265 let keys = sqlx::query( 266 "SELECT target_type, length(target_key) AS key_bytes FROM radroots_runtime_visibility_pending 267 WHERE source_generation = ? ORDER BY target_type, target_key LIMIT ?", 268 ) 269 .bind(self.generation.as_bytes().as_slice()) 270 .bind(i64::from(remaining)) 271 .fetch_all(&mut **transaction) 272 .await 273 .map_err(map_backend)?; 274 let mut processed = 0; 275 for row in keys { 276 let kind: i64 = row.try_get("target_type").map_err(map_corrupt)?; 277 let key_bytes = u64_from_i64(row.try_get("key_bytes").map_err(map_corrupt)?)?; 278 let charge = charged 279 .checked_add(4096 + 16 * key_bytes) 280 .ok_or(Error::SpaceInsufficient)?; 281 if charge > byte_limit { 282 break; 283 } 284 let key: Vec<u8> = sqlx::query_scalar( 285 "SELECT target_key FROM radroots_runtime_visibility_pending 286 WHERE source_generation = ? ORDER BY target_type, target_key LIMIT 1", 287 ) 288 .bind(self.generation.as_bytes().as_slice()) 289 .fetch_one(&mut **transaction) 290 .await 291 .map_err(map_backend)?; 292 if key.len() as u64 != key_bytes { 293 return Err(Error::CorruptStoredEvent); 294 } 295 let position = if kind == 0 { 296 sqlx::query_scalar::<_, i64>( 297 "SELECT source_sequence FROM radroots_runtime_visibility_members 298 WHERE source_generation = ? AND event_id = ?", 299 ) 300 .bind(self.generation.as_bytes().as_slice()) 301 .bind(&key) 302 .fetch_optional(&mut **transaction) 303 .await 304 .map_err(map_backend)? 305 } else { 306 let coordinate = 307 std::str::from_utf8(&key).map_err(|_| Error::CorruptStoredEvent)?; 308 let coordinate = 309 Nip01Coordinate::parse(coordinate).map_err(|_| Error::CorruptStoredEvent)?; 310 let mut head = vec![u8::from(coordinate.kind() >= 30_000)]; 311 head.extend_from_slice(&coordinate.kind().to_be_bytes()); 312 head.extend_from_slice(coordinate.pubkey().as_bytes()); 313 if coordinate.kind() >= 30_000 { 314 head.extend_from_slice(coordinate.identifier().as_bytes()); 315 } 316 sqlx::query_scalar::<_, i64>( 317 "SELECT source_sequence FROM radroots_runtime_visibility_heads 318 WHERE source_generation = ? AND head_coordinate = ?", 319 ) 320 .bind(self.generation.as_bytes().as_slice()) 321 .bind(head) 322 .fetch_optional(&mut **transaction) 323 .await 324 .map_err(map_backend)? 325 }; 326 if let Some(position) = position { 327 self.refresh_visibility_member(transaction, position) 328 .await?; 329 } 330 sqlx::query( 331 "DELETE FROM radroots_runtime_visibility_pending 332 WHERE source_generation = ? AND target_type = ? AND target_key = ?", 333 ) 334 .bind(self.generation.as_bytes().as_slice()) 335 .bind(kind) 336 .bind(key) 337 .execute(&mut **transaction) 338 .await 339 .map_err(map_backend)?; 340 *charged = charge; 341 processed += 1; 342 } 343 Ok(processed) 344 } 345 }