[virtual table cleanup] stop mapping _id fields between table numbers (#28688)

now that virtual ids match the system ids, we no longer need to map IDs between table numbers when an index range or filter includes an `_id`

GitOrigin-RevId: 28ad4c8c1e58236a8cbc62d0fb18c1bd56092cc4

Author: ldanilek

crates/common/src/query.rs

@@ -24,10 +24,7 @@ use sha2::{
 };
 use value::{
     heap_size::HeapSize,
-    id_v6::{
-        DeveloperDocumentId,
-        VirtualTableNumberMap,
-    },
+    id_v6::DeveloperDocumentId,
     utils::display_sequence,
     val,
     ConvexObject,
@@ -180,22 +177,12 @@ pub struct IndexRange {
 }
 
 impl IndexRange {
-    pub fn compile(
-        self,
-        indexed_fields: IndexedFields,
-        virtual_table_number_map: Option<VirtualTableNumberMap>,
-    ) -> anyhow::Result<Interval> {
+    pub fn compile(self, indexed_fields: IndexedFields) -> anyhow::Result<Interval> {
         let index_name = self.index_name.clone();
         let SplitIndexRange {
             equalities,
             inequality,
-        } = self.split()?.map_values(|field, v| {
-            if field == &*ID_FIELD_PATH {
-                map_id_value_to_tablet(v, virtual_table_number_map)
-            } else {
-                Ok(v)
-            }
-        })?;
+        } = self.split()?;
 
         // Check that some permutation of the equality field paths + the (optional)
         // inequality field path is a prefix of the indexed paths.
@@ -397,49 +384,6 @@ struct SplitIndexRange {
     inequality: Option<IndexInequality>,
 }
 
-impl SplitIndexRange {
-    pub fn map_values(
-        self,
-        f: impl Fn(&FieldPath, ConvexValue) -> anyhow::Result<ConvexValue>,
-    ) -> anyhow::Result<SplitIndexRange> {
-        let equalities = self
-            .equalities
-            .into_iter()
-            .map(|(field, value)| {
-                let new_value = match value.0 {
-                    Some(value) => MaybeValue(Some(f(&field, value)?)),
-                    None => MaybeValue(None),
-                };
-                anyhow::Ok((field, new_value))
-            })
-            .try_collect()?;
-        let inequality = self
-            .inequality
-            .map(|inequality| {
-                let start = match inequality.start {
-                    Bound::Unbounded => Bound::Unbounded,
-                    Bound::Included(value) => Bound::Included(f(&inequality.field_path, value)?),
-                    Bound::Excluded(value) => Bound::Excluded(f(&inequality.field_path, value)?),
-                };
-                let end = match inequality.end {
-                    Bound::Unbounded => Bound::Unbounded,
-                    Bound::Included(value) => Bound::Included(f(&inequality.field_path, value)?),
-                    Bound::Excluded(value) => Bound::Excluded(f(&inequality.field_path, value)?),
-                };
-                anyhow::Ok(IndexInequality {
-                    field_path: inequality.field_path,
-                    start,
-                    end,
-                })
-            })
-            .transpose()?;
-        Ok(SplitIndexRange {
-            equalities,
-            inequality,
-        })
-    }
-}
-
 struct IndexInequality {
     field_path: FieldPath,
     start: Bound<ConvexValue>,
@@ -456,21 +400,6 @@ impl Display for QueryFields {
     }
 }
 
-fn map_id_value_to_tablet(
-    value: ConvexValue,
-    virtual_table_number_map: Option<VirtualTableNumberMap>,
-) -> anyhow::Result<ConvexValue> {
-    let val = match (&value, virtual_table_number_map) {
-        (ConvexValue::String(id), Some(virtual_table_number_map)) => {
-            let mapped =
-                DeveloperDocumentId::map_string_between_table_numbers(id, virtual_table_number_map);
-            val!(mapped)
-        },
-        _ => value,
-    };
-    Ok(val)
-}
-
 fn already_defined_bound_error(
     bound_type: &str,
     field_path: &FieldPath,

crates/common/src/types/index.rs

@@ -15,14 +15,11 @@ use sync_types::identifier::{
 };
 use value::{
     heap_size::HeapSize,
-    id_v6::VirtualTableNumberMap,
     FieldName,
     InternalId,
     ResolvedDocumentId,
-    TableMapping,
     TableName,
     TabletId,
-    VirtualTableMapping,
 };
 
 use crate::{
@@ -147,33 +144,6 @@ impl StableIndexName {
             StableIndexName::Missing(index_name) => Err(index_name),
         }
     }
-
-    pub fn virtual_table_number_map(
-        &self,
-        table_mapping: &TableMapping,
-        virtual_table_mapping: &VirtualTableMapping,
-    ) -> anyhow::Result<Option<VirtualTableNumberMap>> {
-        match self {
-            StableIndexName::Physical(index_name) => {
-                let table_number = table_mapping.tablet_number(*index_name.table())?;
-                Ok(Some(VirtualTableNumberMap {
-                    virtual_table_number: table_number,
-                    physical_table_number: table_number,
-                }))
-            },
-            StableIndexName::Virtual(index_name, tablet_index_name) => {
-                let namespace = table_mapping.tablet_namespace(*tablet_index_name.table())?;
-                Ok(Some(VirtualTableNumberMap {
-                    virtual_table_number: virtual_table_mapping
-                        .namespace(namespace)
-                        .number(index_name.table())?,
-                    physical_table_number: table_mapping
-                        .tablet_number(*tablet_index_name.table())?,
-                }))
-            },
-            StableIndexName::Missing(_) => Ok(None),
-        }
-    }
 }
 
 impl HeapSize for TabletIndexName {

crates/database/src/query/mod.rs

@@ -366,11 +366,7 @@ impl<RT: Runtime> DeveloperQuery<RT> {
             )),
             QuerySource::IndexRange(index_range) => {
                 let order = index_range.order;
-                let virtual_table_mapping = tx.virtual_table_mapping().clone();
-                let virtual_table_number_map = stable_index_name
-                    .virtual_table_number_map(tx.table_mapping(), &virtual_table_mapping)?;
-                let interval =
-                    index_range.compile(indexed_fields.clone(), virtual_table_number_map)?;
+                let interval = index_range.compile(indexed_fields.clone())?;
                 QueryNode::IndexRange(IndexRange::new(
                     namespace,
                     stable_index_name,

crates/value/src/base32.rs

@@ -1,5 +1,3 @@
-use std::cmp;
-
 // Forked from https://github.com/andreasots/base32 @ 58909ac.
 //
 // Copyright (c) 2015 The base32 Developers - MIT License
@@ -123,72 +121,6 @@ pub fn decode(data: &str) -> Result<Vec<u8>, InvalidBase32Error> {
     Ok(out)
 }
 
-fn clamp_char_to_alphabet(c: char) -> char {
-    match c {
-        ..'0' => '0',
-        '0'..='9' => c,
-        ':'..'a' => 'a',
-        'a'..='h' => c,
-        'i' => 'j',
-        'j'..='k' => c,
-        'l' => 'm',
-        'm'..='n' => c,
-        'o' => 'p',
-        'p'..='t' => c,
-        'u' => 'v',
-        'v'..='z' => c,
-        '{'.. => 'z',
-    }
-}
-
-/// Returns a string that can be base32 decoded, and is the closest such string
-/// to the input string in lexicographic order.
-/// i.e. for every `t` which is valid base32 of length <= `target_len`,
-/// if s = t, then clamp_to_alphabet(s) = t,
-/// if s < t, then clamp_to_alphabet(s) <= t.
-/// if s > t, then clamp_to_alphabet(s) >= t.
-///
-/// How does it work?
-/// Each character is clamped to the closest character in the base32 alphabet.
-/// If a character has to be rounded up, following characters all become '0'.
-/// If a character has to be rounded down, following characters all become 'z'.
-/// And then we pad to a multiple of 5 characters to avoid dropping chars when
-/// decoding.
-///
-/// e.g. "azi" is between "azhzz" and "azj00", so it is clamped to "azj00".
-/// e.g. "abcd~" is between "abcdz" and "abce0", so it is clamped to "abcdz".
-pub fn clamp_to_alphabet(s: &str, target_len: usize) -> String {
-    let mut out = String::with_capacity(s.len());
-    let mut order = cmp::Ordering::Equal;
-    for c in s.chars() {
-        match order {
-            cmp::Ordering::Equal => {
-                let clamped = clamp_char_to_alphabet(c);
-                out.push(clamped);
-                order = c.cmp(&clamped);
-            },
-            cmp::Ordering::Less => {
-                out.push('0');
-            },
-            cmp::Ordering::Greater => {
-                out.push('z');
-            },
-        }
-    }
-    // Pad the output to a multiple of 5 with 0s so no characters are lost.
-    while out.len() < target_len || out.len() % 5 != 0 {
-        match order {
-            cmp::Ordering::Equal | cmp::Ordering::Less => {
-                out.push('0');
-            },
-            cmp::Ordering::Greater => {
-                out.push('z');
-            },
-        }
-    }
-    out
-}
-
 #[cfg(test)]
 mod tests {
     use proptest::prelude::*;