nest DeveloperQuery inside ResolvedQuery (#25381)

see docstring on ResolvedQuery.

this gets us closer to removing TableIdAndTableNumber which is a confusing concept since it mashes together tablets and table numbers.

GitOrigin-RevId: 9586355db96f0e276a37e030a4e732f49a3f4455

Author: ldanilek

crates/application/src/export_worker.rs

@@ -988,7 +988,8 @@ mod tests {
                 },
             };
             let doc = UserFacingModel::new(&mut tx).get(id, None).await?.unwrap();
-            let doc = doc.to_resolved(&tx.table_mapping().inject_table_id())?;
+            let tablet_id = tx.table_mapping().inject_table_id()(doc.table())?.table_id;
+            let doc = doc.to_resolved(tablet_id);
             let id_v6 = doc.developer_id().encode();
             expected_export_entries.insert(
                 format!("table_{i}/documents.jsonl"),

crates/common/src/document.rs

@@ -655,16 +655,16 @@ impl DeveloperDocument {
         }
     }
 
-    pub fn to_resolved(
-        self,
-        f: &impl Fn(TableNumber) -> anyhow::Result<TableIdAndTableNumber>,
-    ) -> anyhow::Result<ResolvedDocument> {
-        let id = self.id.map_table(f)?;
-        Ok(ResolvedDocument {
-            id,
+    pub fn to_resolved(self, tablet_id: TableId) -> ResolvedDocument {
+        ResolvedDocument {
+            id: TableIdAndTableNumber {
+                table_id: tablet_id,
+                table_number: *self.id.table(),
+            }
+            .id(self.id.internal_id()),
             creation_time: self.creation_time,
             value: self.value,
-        })
+        }
     }
 
     pub fn id(&self) -> DeveloperDocumentId {

crates/database/src/bootstrap_model/user_facing.rs

@@ -29,15 +29,17 @@ use value::{
     DeveloperDocumentId,
     Size,
     TableName,
-    TableNumber,
 };
 
 use crate::{
     metrics::{
         log_virtual_table_get,
         log_virtual_table_query,
     },
-    query::IndexRangeResponse,
+    query::{
+        DeveloperIndexRangeResponse,
+        IndexRangeResponse,
+    },
     transaction::{
         IndexRangeRequest,
         MAX_PAGE_SIZE,
@@ -329,9 +331,9 @@ impl<'a, RT: Runtime> UserFacingModel<'a, RT> {
     fn start_index_range(
         &mut self,
         request: IndexRangeRequest,
-    ) -> anyhow::Result<Result<IndexRangeResponse<TableNumber>, RangeRequest>> {
+    ) -> anyhow::Result<Result<DeveloperIndexRangeResponse, RangeRequest>> {
         if request.interval.is_empty() {
-            return Ok(Ok(IndexRangeResponse {
+            return Ok(Ok(DeveloperIndexRangeResponse {
                 page: vec![],
                 cursor: CursorPosition::End,
             }));
@@ -362,7 +364,7 @@ impl<'a, RT: Runtime> UserFacingModel<'a, RT> {
                     max_size: max_rows,
                 }))
             },
-            StableIndexName::Missing => Ok(Ok(IndexRangeResponse {
+            StableIndexName::Missing => Ok(Ok(DeveloperIndexRangeResponse {
                 page: vec![],
                 cursor: CursorPosition::End,
             })),
@@ -376,7 +378,7 @@ impl<'a, RT: Runtime> UserFacingModel<'a, RT> {
     pub async fn index_range_batch(
         &mut self,
         requests: BTreeMap<BatchKey, IndexRangeRequest>,
-    ) -> BTreeMap<BatchKey, anyhow::Result<IndexRangeResponse<TableNumber>>> {
+    ) -> BTreeMap<BatchKey, anyhow::Result<DeveloperIndexRangeResponse>> {
         let batch_size = requests.len();
         let mut results = BTreeMap::new();
         let mut fetch_requests = BTreeMap::new();
@@ -421,7 +423,7 @@ impl<'a, RT: Runtime> UserFacingModel<'a, RT> {
                         .map(|(key, doc, ts)| (key, doc.to_developer(), ts))
                         .collect(),
                 };
-                anyhow::Ok(IndexRangeResponse {
+                anyhow::Ok(DeveloperIndexRangeResponse {
                     page: developer_results,
                     cursor,
                 })

crates/database/src/query/filter.rs

@@ -9,11 +9,10 @@ use common::{
 };
 
 use super::{
-    IndexRangeResponse,
+    DeveloperIndexRangeResponse,
     QueryNode,
     QueryStream,
     QueryStreamNext,
-    QueryType,
 };
 use crate::Transaction;
 
@@ -23,19 +22,19 @@ use crate::Transaction;
 const FILTER_QUERY_PREFETCH: usize = 100;
 
 /// See Query.filter().
-pub(super) struct Filter<T: QueryType> {
-    inner: QueryNode<T>,
+pub(super) struct Filter {
+    inner: QueryNode,
     expr: Expression,
 }
 
-impl<T: QueryType> Filter<T> {
-    pub fn new(inner: QueryNode<T>, expr: Expression) -> Self {
+impl Filter {
+    pub fn new(inner: QueryNode, expr: Expression) -> Self {
         Self { inner, expr }
     }
 }
 
 #[async_trait]
-impl<T: QueryType> QueryStream<T> for Filter<T> {
+impl QueryStream for Filter {
     fn cursor_position(&self) -> &Option<CursorPosition> {
         self.inner.cursor_position()
     }
@@ -52,7 +51,7 @@ impl<T: QueryType> QueryStream<T> for Filter<T> {
         &mut self,
         tx: &mut Transaction<RT>,
         _prefetch_hint: Option<usize>,
-    ) -> anyhow::Result<QueryStreamNext<T>> {
+    ) -> anyhow::Result<QueryStreamNext> {
         loop {
             let (document, write_timestamp) =
                 match self.inner.next(tx, Some(FILTER_QUERY_PREFETCH)).await? {
@@ -69,7 +68,7 @@ impl<T: QueryType> QueryStream<T> for Filter<T> {
         }
     }
 
-    fn feed(&mut self, index_range_response: IndexRangeResponse<T::T>) -> anyhow::Result<()> {
+    fn feed(&mut self, index_range_response: DeveloperIndexRangeResponse) -> anyhow::Result<()> {
         self.inner.feed(index_range_response)
     }
 

crates/database/src/query/index_range.rs

@@ -5,7 +5,7 @@ use std::{
 
 use async_trait::async_trait;
 use common::{
-    document::GenericDocument,
+    document::DeveloperDocument,
     index::IndexKeyBytes,
     interval::Interval,
     knobs::{
@@ -29,21 +29,21 @@ use common::{
 use super::{
     query_scanned_too_many_documents_error,
     query_scanned_too_much_data,
-    IndexRangeResponse,
+    DeveloperIndexRangeResponse,
     QueryStream,
     QueryStreamNext,
-    QueryType,
     DEFAULT_QUERY_PREFETCH,
     MAX_QUERY_FETCH,
 };
 use crate::{
     metrics,
     transaction::IndexRangeRequest,
     Transaction,
+    UserFacingModel,
 };
 
 /// A `QueryStream` that scans a range of an index.
-pub struct IndexRange<T: QueryType> {
+pub struct IndexRange {
     stable_index_name: StableIndexName,
     /// For usage and error messages. If the table mapping has changed, this
     /// might get out of sync with `stable_index_name`, which is the index
@@ -60,7 +60,7 @@ pub struct IndexRange<T: QueryType> {
     /// `cursor_interval` must always be a subset of `interval`.
     cursor_interval: CursorInterval,
     intermediate_cursors: Option<Vec<CursorPosition>>,
-    page: VecDeque<(IndexKeyBytes, GenericDocument<T::T>, WriteTimestamp)>,
+    page: VecDeque<(IndexKeyBytes, DeveloperDocument, WriteTimestamp)>,
     /// The interval which we have yet to fetch.
     /// This starts as an intersection of the IndexRange's `interval` and
     /// `cursor_interval`, and gets smaller as results are fetched into `page`.
@@ -81,7 +81,7 @@ pub struct IndexRange<T: QueryType> {
     version: Option<Version>,
 }
 
-impl<T: QueryType> IndexRange<T> {
+impl IndexRange {
     pub fn new(
         stable_index_name: StableIndexName,
         printable_index_name: IndexName,
@@ -146,7 +146,7 @@ impl<T: QueryType> IndexRange<T> {
         &mut self,
         tx: &mut Transaction<RT>,
         prefetch_hint: Option<usize>,
-    ) -> anyhow::Result<QueryStreamNext<T>> {
+    ) -> anyhow::Result<QueryStreamNext> {
         // If we have an end cursor, for correctness we need to process
         // the entire interval, so ignore `maximum_rows_read` and `maximum_bytes_read`.
         let enforce_limits = self.cursor_interval.end_inclusive.is_none();
@@ -169,7 +169,7 @@ impl<T: QueryType> IndexRange<T> {
             }
             self.cursor_interval.curr_exclusive = Some(CursorPosition::After(index_position));
             self.returned_results += 1;
-            T::record_read_document(tx, &v, self.printable_index_name.table())?;
+            UserFacingModel::new(tx).record_read_document(&v, self.printable_index_name.table())?;
             // Database bandwidth for index reads
             tx.usage_tracker.track_database_egress_size(
                 self.printable_index_name.table().to_string(),
@@ -216,7 +216,7 @@ impl<T: QueryType> IndexRange<T> {
 
     fn process_fetch(
         &mut self,
-        page: Vec<(IndexKeyBytes, GenericDocument<T::T>, WriteTimestamp)>,
+        page: Vec<(IndexKeyBytes, DeveloperDocument, WriteTimestamp)>,
         fetch_cursor: CursorPosition,
     ) -> anyhow::Result<()> {
         let (_, new_unfetched_interval) = self.unfetched_interval.split(fetch_cursor, self.order);
@@ -234,7 +234,7 @@ pub const fn soft_data_limit(hard_limit: usize) -> usize {
 }
 
 #[async_trait]
-impl<T: QueryType> QueryStream<T> for IndexRange<T> {
+impl QueryStream for IndexRange {
     fn cursor_position(&self) -> &Option<CursorPosition> {
         &self.cursor_interval.curr_exclusive
     }
@@ -257,11 +257,11 @@ impl<T: QueryType> QueryStream<T> for IndexRange<T> {
         &mut self,
         tx: &mut Transaction<RT>,
         prefetch_hint: Option<usize>,
-    ) -> anyhow::Result<QueryStreamNext<T>> {
+    ) -> anyhow::Result<QueryStreamNext> {
         self.start_next(tx, prefetch_hint)
     }
 
-    fn feed(&mut self, index_range_response: IndexRangeResponse<T::T>) -> anyhow::Result<()> {
+    fn feed(&mut self, index_range_response: DeveloperIndexRangeResponse) -> anyhow::Result<()> {
         self.process_fetch(index_range_response.page, index_range_response.cursor)
     }
 
@@ -270,7 +270,7 @@ impl<T: QueryType> QueryStream<T> for IndexRange<T> {
     }
 }
 
-impl<T: QueryType> Drop for IndexRange<T> {
+impl Drop for IndexRange {
     fn drop(&mut self) {
         metrics::log_index_range(
             self.returned_results,

crates/database/src/query/limit.rs

@@ -8,24 +8,23 @@ use common::{
 };
 
 use super::{
-    IndexRangeResponse,
+    DeveloperIndexRangeResponse,
     QueryNode,
     QueryStream,
     QueryStreamNext,
-    QueryType,
     DEFAULT_QUERY_PREFETCH,
 };
 use crate::Transaction;
 
 /// See Query.limit().
-pub(super) struct Limit<T: QueryType> {
-    inner: QueryNode<T>,
+pub(super) struct Limit {
+    inner: QueryNode,
     limit: usize,
     rows_emitted: usize,
 }
 
-impl<T: QueryType> Limit<T> {
-    pub fn new(inner: QueryNode<T>, limit: usize) -> Self {
+impl Limit {
+    pub fn new(inner: QueryNode, limit: usize) -> Self {
         Self {
             inner,
             limit,
@@ -35,7 +34,7 @@ impl<T: QueryType> Limit<T> {
 }
 
 #[async_trait]
-impl<T: QueryType> QueryStream<T> for Limit<T> {
+impl QueryStream for Limit {
     fn cursor_position(&self) -> &Option<CursorPosition> {
         self.inner.cursor_position()
     }
@@ -52,7 +51,7 @@ impl<T: QueryType> QueryStream<T> for Limit<T> {
         &mut self,
         tx: &mut Transaction<RT>,
         prefetch_hint: Option<usize>,
-    ) -> anyhow::Result<QueryStreamNext<T>> {
+    ) -> anyhow::Result<QueryStreamNext> {
         if self.rows_emitted >= self.limit {
             return Ok(QueryStreamNext::Ready(None));
         }
@@ -67,7 +66,7 @@ impl<T: QueryType> QueryStream<T> for Limit<T> {
         Ok(result)
     }
 
-    fn feed(&mut self, index_range_response: IndexRangeResponse<T::T>) -> anyhow::Result<()> {
+    fn feed(&mut self, index_range_response: DeveloperIndexRangeResponse) -> anyhow::Result<()> {
         self.inner.feed(index_range_response)
     }