Rename search indexes to text indexes (#27750)

This PR renames search indexes to text indexes when we mean full text search indexes. We have a bunch of generic code for building text and vector indexes where we use the term search index to mean both, so this should help clarify in the codebase what code is specific to text search. I didn't touch anything that's serialized because we should be more careful there about renames.

GitOrigin-RevId: 811120b188e43f02a60bafd0076f024a79eeb032

Author: emmaling27

crates/common/src/bootstrap_model/index/developer_index_config.rs

@@ -41,7 +41,7 @@ impl From<IndexConfig> for DeveloperIndexConfig {
             IndexConfig::Database {
                 developer_config, ..
             } => DeveloperIndexConfig::Database(developer_config),
-            IndexConfig::Search {
+            IndexConfig::Text {
                 developer_config, ..
             } => DeveloperIndexConfig::Search(developer_config),
             IndexConfig::Vector {

crates/common/src/bootstrap_model/index/index_config.rs

@@ -41,7 +41,7 @@ pub enum IndexConfig {
     },
 
     /// Full text search index.
-    Search {
+    Text {
         developer_config: DeveloperTextIndexConfig,
 
         /// Whether the index is fully backfilled or not on disk.
@@ -60,7 +60,7 @@ impl IndexConfig {
             IndexConfig::Database { on_disk_state, .. } => {
                 matches!(on_disk_state, DatabaseIndexState::Enabled)
             },
-            IndexConfig::Search { on_disk_state, .. } => {
+            IndexConfig::Text { on_disk_state, .. } => {
                 matches!(on_disk_state, TextIndexState::SnapshottedAt(_))
             },
             IndexConfig::Vector { on_disk_state, .. } => {
@@ -74,7 +74,7 @@ impl IndexConfig {
             IndexConfig::Database { on_disk_state, .. } => {
                 matches!(on_disk_state, DatabaseIndexState::Backfilling(_))
             },
-            IndexConfig::Search { on_disk_state, .. } => {
+            IndexConfig::Text { on_disk_state, .. } => {
                 matches!(on_disk_state, TextIndexState::Backfilling(_))
             },
             IndexConfig::Vector { on_disk_state, .. } => {
@@ -95,10 +95,10 @@ impl IndexConfig {
                 },
             ) => developer_config == config_to_compare,
             (
-                IndexConfig::Search {
+                IndexConfig::Text {
                     developer_config, ..
                 },
-                IndexConfig::Search {
+                IndexConfig::Text {
                     developer_config: config_to_compare,
                     ..
                 },
@@ -129,7 +129,7 @@ impl IndexConfig {
     /// on other index types will panic.
     pub fn estimate_pricing_size_bytes(&self) -> anyhow::Result<u64> {
         match self {
-            IndexConfig::Database { .. } | IndexConfig::Search { .. } => {
+            IndexConfig::Database { .. } | IndexConfig::Text { .. } => {
                 // TODO(sam): We should support this for all index types in the future. Right
                 // now search indexes are free and we estimate the size of
                 // database indexes. Both of those could instead track usage in their metadata,
@@ -188,7 +188,7 @@ impl TryFrom<IndexConfig> for SerializedIndexConfig {
                 developer_config: developer_config.try_into()?,
                 on_disk_state: on_disk_state.try_into()?,
             },
-            IndexConfig::Search {
+            IndexConfig::Text {
                 developer_config,
                 on_disk_state,
             } => SerializedIndexConfig::Search {
@@ -221,7 +221,7 @@ impl TryFrom<SerializedIndexConfig> for IndexConfig {
             SerializedIndexConfig::Search {
                 developer_config,
                 on_disk_state,
-            } => IndexConfig::Search {
+            } => IndexConfig::Text {
                 developer_config: developer_config.try_into()?,
                 on_disk_state: on_disk_state.try_into()?,
             },

crates/common/src/bootstrap_model/index/index_metadata.rs

@@ -78,12 +78,12 @@ impl<T: IndexTableIdentifier> IndexMetadata<T> {
         }
     }
 
-    pub fn new_backfilling_search_index(
+    pub fn new_backfilling_text_index(
         name: GenericIndexName<T>,
         search_field: FieldPath,
         filter_fields: BTreeSet<FieldPath>,
     ) -> Self {
-        Self::new_search_index(
+        Self::new_text_index(
             name,
             DeveloperTextIndexConfig {
                 search_field,
@@ -116,14 +116,14 @@ impl<T: IndexTableIdentifier> IndexMetadata<T> {
         }
     }
 
-    pub fn new_search_index(
+    pub fn new_text_index(
         name: GenericIndexName<T>,
         developer_config: DeveloperTextIndexConfig,
         on_disk_state: TextIndexState,
     ) -> Self {
         Self {
             name,
-            config: IndexConfig::Search {
+            config: IndexConfig::Text {
                 developer_config,
                 on_disk_state,
             },
@@ -144,8 +144,8 @@ impl<T: IndexTableIdentifier> IndexMetadata<T> {
         matches!(self.config, IndexConfig::Database { .. })
     }
 
-    pub fn is_search_index(&self) -> bool {
-        matches!(self.config, IndexConfig::Search { .. })
+    pub fn is_text_index(&self) -> bool {
+        matches!(self.config, IndexConfig::Text { .. })
     }
 
     pub fn is_vector_index(&self) -> bool {

crates/common/src/bootstrap_model/index/mod.rs

@@ -35,5 +35,5 @@ pub static TABLE_ID_FIELD_PATH: LazyLock<FieldPath> =
     LazyLock::new(|| FieldPath::new(vec![TABLE_ID_FIELD_NAME.clone()]).unwrap());
 
 pub const MAX_INDEX_FIELDS_SIZE: usize = 16;
-pub const MAX_SEARCH_INDEX_FILTER_FIELDS_SIZE: usize = 16;
+pub const MAX_TEXT_INDEX_FILTER_FIELDS_SIZE: usize = 16;
 pub const MAX_VECTOR_INDEX_FILTER_FIELDS_SIZE: usize = 16;

crates/common/src/bootstrap_model/index/text_index/mod.rs

@@ -36,7 +36,7 @@ mod tests {
         #![proptest_config(ProptestConfig { cases: 64 * env_config("CONVEX_PROPTEST_MULTIPLIER", 1), failure_persistence: None, .. ProptestConfig::default() })]
 
         #[test]
-        fn test_developer_search_index_config_roundtrips(v in any::<DeveloperTextIndexConfig>()) {
+        fn test_developer_text_index_config_roundtrips(v in any::<DeveloperTextIndexConfig>()) {
                 assert_roundtrips::<
                 DeveloperTextIndexConfig,
                 pb::searchlight::SearchIndexConfig

crates/common/src/knobs.rs

@@ -364,7 +364,7 @@ pub static BACKEND_STARTUP_DELAY: LazyLock<Duration> =
     LazyLock::new(|| Duration::from_secs(env_config("BACKEND_STARTUP_DELAY_SECS", 0)));
 
 /// When to start rejecting new additions to the search memory index.
-pub static SEARCH_INDEX_SIZE_HARD_LIMIT: LazyLock<usize> =
+pub static TEXT_INDEX_SIZE_HARD_LIMIT: LazyLock<usize> =
     LazyLock::new(|| env_config("SEARCH_INDEX_SIZE_HARD_LIMIT", 100 * (1 << 20))); // 100 MiB
 
 /// When to start rejecting new additions to the vector memory index.

crates/common/src/schemas/mod.rs

@@ -43,7 +43,7 @@ use crate::{
         database_index::IndexedFields,
         index_validation_error,
         vector_index::VectorDimensions,
-        MAX_SEARCH_INDEX_FILTER_FIELDS_SIZE,
+        MAX_TEXT_INDEX_FILTER_FIELDS_SIZE,
         MAX_VECTOR_INDEX_FILTER_FIELDS_SIZE,
     },
     document::ResolvedDocument,
@@ -672,9 +672,9 @@ impl SearchIndexSchema {
         search_field: FieldPath,
         filter_fields: BTreeSet<FieldPath>,
     ) -> anyhow::Result<Self> {
-        if filter_fields.len() > MAX_SEARCH_INDEX_FILTER_FIELDS_SIZE {
+        if filter_fields.len() > MAX_TEXT_INDEX_FILTER_FIELDS_SIZE {
             anyhow::bail!(index_validation_error::too_many_filter_fields(
-                MAX_SEARCH_INDEX_FILTER_FIELDS_SIZE
+                MAX_TEXT_INDEX_FILTER_FIELDS_SIZE
             ));
         }
         Ok(Self {

crates/common/src/testing/schema.rs

@@ -10,7 +10,7 @@ use serde_json::{
 use crate::{
     bootstrap_model::index::{
         MAX_INDEX_FIELDS_SIZE,
-        MAX_SEARCH_INDEX_FILTER_FIELDS_SIZE,
+        MAX_TEXT_INDEX_FILTER_FIELDS_SIZE,
         MAX_VECTOR_INDEX_FILTER_FIELDS_SIZE,
     },
     schemas::{
@@ -790,7 +790,7 @@ fn test_too_many_fields() {
 
 #[test]
 fn test_too_many_search_filter_fields() {
-    let fields: Vec<_> = (0..MAX_SEARCH_INDEX_FILTER_FIELDS_SIZE + 1)
+    let fields: Vec<_> = (0..MAX_TEXT_INDEX_FILTER_FIELDS_SIZE + 1)
         .map(|i| format!("field_{}", i))
         .collect();
     let value = json!({

crates/database/src/bootstrap_model/index.rs

@@ -224,7 +224,7 @@ impl<'a, RT: Runtime> IndexModel<'a, RT> {
                     *on_disk_state = DatabaseIndexState::Enabled;
                 },
             },
-            IndexConfig::Search {
+            IndexConfig::Text {
                 ref mut on_disk_state,
                 ..
             } => match on_disk_state {
@@ -385,7 +385,7 @@ impl<'a, RT: Runtime> IndexModel<'a, RT> {
             // Collect the search indexes.
             for (index_descriptor, index_schema) in &table_schema.search_indexes {
                 let index_name = IndexName::new(table_name.clone(), index_descriptor.clone())?;
-                indexes_in_schema.push(IndexMetadata::new_backfilling_search_index(
+                indexes_in_schema.push(IndexMetadata::new_backfilling_text_index(
                     index_name.clone(),
                     index_schema.search_field.clone(),
                     index_schema.filter_fields.clone(),
@@ -912,14 +912,14 @@ impl<'a, RT: Runtime> IndexModel<'a, RT> {
                     developer_config: DeveloperDatabaseIndexConfig { fields },
                     ..
                 } => IndexMetadata::new_backfilling(*self.tx.begin_timestamp(), index_name, fields),
-                IndexConfig::Search {
+                IndexConfig::Text {
                     developer_config:
                         DeveloperTextIndexConfig {
                             search_field,
                             filter_fields,
                         },
                     ..
-                } => IndexMetadata::new_backfilling_search_index(
+                } => IndexMetadata::new_backfilling_text_index(
                     index_name,
                     search_field,
                     filter_fields,

crates/database/src/committer.rs

@@ -107,9 +107,9 @@ use crate::{
         finish_bootstrap_update,
     },
     reads::ReadSet,
-    search_and_vector_bootstrap::{
+    search_index_bootstrap::{
         stream_revision_pairs_for_indexes,
-        BootstrappedSearchAndVectorIndexes,
+        BootstrappedSearchIndexes,
     },
     snapshot_manager::SnapshotManager,
     transaction::FinalTransaction,
@@ -285,7 +285,7 @@ impl<RT: Runtime> Committer<RT> {
                         Some(CommitterMessage::BumpMaxRepeatableTs { result }) => {
                             self.bump_max_repeatable_ts(result);
                         },
-                        Some(CommitterMessage::FinishSearchAndVectorBootstrap {
+                        Some(CommitterMessage::FinishTextAndVectorBootstrap {
                             bootstrapped_indexes,
                             bootstrap_ts,
                             result,
@@ -309,18 +309,18 @@ impl<RT: Runtime> Committer<RT> {
     }
 
     async fn update_indexes_since_bootstrap(
-        BootstrappedSearchAndVectorIndexes {
-            search_index_manager,
+        BootstrappedSearchIndexes {
+            text_index_manager,
             vector_index_manager,
             tables_with_indexes,
-        }: &mut BootstrappedSearchAndVectorIndexes<RT>,
+        }: &mut BootstrappedSearchIndexes<RT>,
         bootstrap_ts: Timestamp,
         persistence: RepeatablePersistence,
         registry: &IndexRegistry,
     ) -> anyhow::Result<()> {
         let _timer = bootstrap_update_timer();
         anyhow::ensure!(
-            !search_index_manager.is_bootstrapping(),
+            !text_index_manager.is_bootstrapping(),
             "Trying to update search index while it's still bootstrapping"
         );
         anyhow::ensure!(
@@ -338,7 +338,7 @@ impl<RT: Runtime> Committer<RT> {
         while let Some(revision_pair) = revision_stream.try_next().await? {
             num_revisions += 1;
             total_size += revision_pair.document().map(|d| d.size()).unwrap_or(0);
-            search_index_manager.update(
+            text_index_manager.update(
                 registry,
                 revision_pair.prev_document(),
                 revision_pair.document(),
@@ -357,7 +357,7 @@ impl<RT: Runtime> Committer<RT> {
 
     async fn finish_search_and_vector_bootstrap(
         &mut self,
-        mut bootstrapped_indexes: BootstrappedSearchAndVectorIndexes<RT>,
+        mut bootstrapped_indexes: BootstrappedSearchIndexes<RT>,
         bootstrap_ts: RepeatableTimestamp,
         result: oneshot::Sender<anyhow::Result<()>>,
     ) {
@@ -393,8 +393,8 @@ impl<RT: Runtime> Committer<RT> {
         if latest_ts != snapshot_manager.latest_ts() {
             panic!("Snapshots were changed concurrently during commit?");
         }
-        snapshot_manager.overwrite_last_snapshot_search_and_vector_indexes(
-            bootstrapped_indexes.search_index_manager,
+        snapshot_manager.overwrite_last_snapshot_text_and_vector_indexes(
+            bootstrapped_indexes.text_index_manager,
             bootstrapped_indexes.vector_index_manager,
         );
         tracing::info!("Committed backfilled vector indexes");
@@ -849,11 +849,11 @@ impl<RT: Runtime> Clone for CommitterClient<RT> {
 impl<RT: Runtime> CommitterClient<RT> {
     pub async fn finish_search_and_vector_bootstrap(
         &self,
-        bootstrapped_indexes: BootstrappedSearchAndVectorIndexes<RT>,
+        bootstrapped_indexes: BootstrappedSearchIndexes<RT>,
         bootstrap_ts: RepeatableTimestamp,
     ) -> anyhow::Result<()> {
         let (tx, rx) = oneshot::channel();
-        let message = CommitterMessage::FinishSearchAndVectorBootstrap {
+        let message = CommitterMessage::FinishTextAndVectorBootstrap {
             bootstrapped_indexes,
             bootstrap_ts,
             result: tx,
@@ -1012,8 +1012,8 @@ enum CommitterMessage<RT: Runtime> {
         tables: BTreeSet<TableName>,
         result: oneshot::Sender<anyhow::Result<()>>,
     },
-    FinishSearchAndVectorBootstrap {
-        bootstrapped_indexes: BootstrappedSearchAndVectorIndexes<RT>,
+    FinishTextAndVectorBootstrap {
+        bootstrapped_indexes: BootstrappedSearchIndexes<RT>,
         bootstrap_ts: RepeatableTimestamp,
         result: oneshot::Sender<anyhow::Result<()>>,
     },