minor: add constants for metadata key values (#11811)

timsaucer · web-flow · commit eea1d8d0a20e · 2025-11-07T11:30:16.000-05:00
This PR adds constants for metadata keys we use throughout the
repository. The purpose is to reduce opportunities for errors due to
mangled constants.

There are no functional changes in this PR.
diff --git a/crates/store/re_protos/src/v1alpha1/rerun.cloud.v1alpha1.ext.rs b/crates/store/re_protos/src/v1alpha1/rerun.cloud.v1alpha1.ext.rs
@@ -189,19 +189,25 @@ impl QueryDatasetResponse {
     pub fn field_chunk_id() -> FieldRef {
         lazy_field_ref!(
             Field::new(Self::FIELD_CHUNK_ID, DataType::FixedSizeBinary(16), false).with_metadata(
-                [("rerun:kind".to_owned(), "control".to_owned())]
-                    .into_iter()
-                    .collect(),
+                [(
+                    re_sorbet::metadata::RERUN_KIND.to_owned(),
+                    "control".to_owned()
+                )]
+                .into_iter()
+                .collect(),
             )
         )
     }
 
     pub fn field_chunk_partition_id() -> FieldRef {
         lazy_field_ref!(
             Field::new(Self::FIELD_CHUNK_PARTITION_ID, DataType::Utf8, false).with_metadata(
-                [("rerun:kind".to_owned(), "control".to_owned())]
-                    .into_iter()
-                    .collect(),
+                [(
+                    re_sorbet::metadata::RERUN_KIND.to_owned(),
+                    "control".to_owned()
+                )]
+                .into_iter()
+                .collect(),
             )
         )
     }
@@ -221,19 +227,25 @@ impl QueryDatasetResponse {
     pub fn field_chunk_entity_path() -> FieldRef {
         lazy_field_ref!(
             Field::new(Self::FIELD_CHUNK_ENTITY_PATH, DataType::Utf8, false).with_metadata(
-                [("rerun:kind".to_owned(), "control".to_owned())]
-                    .into_iter()
-                    .collect(),
+                [(
+                    re_sorbet::metadata::RERUN_KIND.to_owned(),
+                    "control".to_owned()
+                )]
+                .into_iter()
+                .collect(),
             )
         )
     }
 
     pub fn field_chunk_is_static() -> FieldRef {
         lazy_field_ref!(
             Field::new(Self::FIELD_CHUNK_IS_STATIC, DataType::Boolean, false).with_metadata(
-                [("rerun:kind".to_owned(), "control".to_owned())]
-                    .into_iter()
-                    .collect(),
+                [(
+                    re_sorbet::metadata::RERUN_KIND.to_owned(),
+                    "control".to_owned()
+                )]
+                .into_iter()
+                .collect(),
             )
         )
     }
diff --git a/crates/store/re_sorbet/src/column_kind.rs b/crates/store/re_sorbet/src/column_kind.rs
@@ -44,7 +44,7 @@ impl TryFrom<&ArrowField> for ColumnKind {
             "We should have migrated to 'rerun:kind'"
         );
 
-        let Some(kind) = field.get_opt("rerun:kind") else {
+        let Some(kind) = field.get_opt(crate::metadata::RERUN_KIND) else {
             return Ok(Self::default());
         };
         match kind {
diff --git a/crates/store/re_sorbet/src/component_column_descriptor.rs b/crates/store/re_sorbet/src/component_column_descriptor.rs
@@ -199,13 +199,22 @@ impl ComponentColumnDescriptor {
         } = self;
 
         let mut metadata = std::collections::HashMap::from([
-            ("rerun:kind".to_owned(), ColumnKind::Component.to_string()),
-            ("rerun:component".to_owned(), component.to_string()),
+            (
+                crate::metadata::RERUN_KIND.to_owned(),
+                ColumnKind::Component.to_string(),
+            ),
+            (
+                re_types_core::FIELD_METADATA_KEY_COMPONENT.to_owned(),
+                component.to_string(),
+            ),
         ]);
 
         match batch_type {
             BatchType::Dataframe => {
-                metadata.insert("rerun:entity_path".to_owned(), entity_path.to_string());
+                metadata.insert(
+                    crate::metadata::SORBET_ENTITY_PATH.to_owned(),
+                    entity_path.to_string(),
+                );
             }
             BatchType::Chunk => {
                 // The whole chunk is for the same entity, which is set in the record batch metadata.
@@ -215,14 +224,14 @@ impl ComponentColumnDescriptor {
 
         if let Some(archetype_name) = archetype_name {
             metadata.insert(
-                "rerun:archetype".to_owned(),
+                re_types_core::FIELD_METADATA_KEY_ARCHETYPE.to_owned(),
                 archetype_name.full_name().to_owned(),
             );
         }
 
         if let Some(component_type) = component_type {
             metadata.insert(
-                "rerun:component_type".to_owned(),
+                re_types_core::FIELD_METADATA_KEY_COMPONENT_TYPE.to_owned(),
                 component_type.full_name().to_owned(),
             );
         }
@@ -294,26 +303,32 @@ impl ComponentColumnDescriptor {
     /// `chunk_entity_path`: if this column is part of a chunk batch,
     /// what is its entity path (so we can set [`ComponentColumnDescriptor::entity_path`])?
     pub fn from_arrow_field(chunk_entity_path: Option<&EntityPath>, field: &ArrowField) -> Self {
-        let entity_path = if let Some(entity_path) = field.get_opt("rerun:entity_path") {
-            EntityPath::parse_forgiving(entity_path)
-        } else if let Some(chunk_entity_path) = chunk_entity_path {
-            chunk_entity_path.clone()
-        } else {
-            EntityPath::root() // TODO(#8744): make entity_path optional for general sorbet batches
-        };
-
-        let component = if let Some(component) = field.get_opt("rerun:component") {
-            ComponentIdentifier::from(component)
-        } else {
-            ComponentIdentifier::new(field.name()) // fallback
-        };
+        let entity_path =
+            if let Some(entity_path) = field.get_opt(crate::metadata::SORBET_ENTITY_PATH) {
+                EntityPath::parse_forgiving(entity_path)
+            } else if let Some(chunk_entity_path) = chunk_entity_path {
+                chunk_entity_path.clone()
+            } else {
+                EntityPath::root() // TODO(#8744): make entity_path optional for general sorbet batches
+            };
+
+        let component =
+            if let Some(component) = field.get_opt(re_types_core::FIELD_METADATA_KEY_COMPONENT) {
+                ComponentIdentifier::from(component)
+            } else {
+                ComponentIdentifier::new(field.name()) // fallback
+            };
 
         let schema = Self {
             store_datatype: field.data_type().clone(),
             entity_path,
-            archetype: field.get_opt("rerun:archetype").map(Into::into),
+            archetype: field
+                .get_opt(re_types_core::FIELD_METADATA_KEY_ARCHETYPE)
+                .map(Into::into),
             component,
-            component_type: field.get_opt("rerun:component_type").map(Into::into),
+            component_type: field
+                .get_opt(re_types_core::FIELD_METADATA_KEY_COMPONENT_TYPE)
+                .map(Into::into),
             is_static: field.get_bool("rerun:is_static"),
             is_tombstone: field.get_bool("rerun:is_tombstone"),
             is_semantically_empty: field.get_bool("rerun:is_semantically_empty"),
diff --git a/crates/store/re_sorbet/src/index_column_descriptor.rs b/crates/store/re_sorbet/src/index_column_descriptor.rs
@@ -106,10 +106,13 @@ impl IndexColumnDescriptor {
 
         let mut metadata = std::collections::HashMap::from([
             (
-                "rerun:kind".to_owned(),
+                crate::metadata::RERUN_KIND.to_owned(),
                 crate::ColumnKind::Index.to_string(),
             ),
-            ("rerun:index_name".to_owned(), timeline.name().to_string()),
+            (
+                crate::metadata::SORBET_INDEX_NAME.to_owned(),
+                timeline.name().to_string(),
+            ),
         ]);
         if *is_sorted {
             metadata.insert("rerun:is_sorted".to_owned(), "true".to_owned());
@@ -134,7 +137,7 @@ impl TryFrom<&ArrowField> for IndexColumnDescriptor {
     type Error = UnsupportedTimeType;
 
     fn try_from(field: &ArrowField) -> Result<Self, Self::Error> {
-        let name = if let Some(name) = field.metadata().get("rerun:index_name") {
+        let name = if let Some(name) = field.metadata().get(crate::metadata::SORBET_INDEX_NAME) {
             name.to_owned()
         } else {
             re_log::debug_once!(
diff --git a/crates/store/re_sorbet/src/lib.rs b/crates/store/re_sorbet/src/lib.rs
@@ -21,7 +21,7 @@ mod component_column_descriptor;
 mod error;
 mod index_column_descriptor;
 mod ipc;
-mod metadata;
+pub mod metadata;
 mod migrations;
 mod row_id_column_descriptor;
 mod schema_builder;
diff --git a/crates/store/re_sorbet/src/metadata.rs b/crates/store/re_sorbet/src/metadata.rs
@@ -2,6 +2,19 @@ use std::collections::HashMap;
 
 use arrow::datatypes::Field as ArrowField;
 
+// The following constants are used as metadata keys. See also
+// [`re_types_core::component_descriptor`] for additional constants.
+
+/// The key used to identify the index name in field-level metadata.
+pub const SORBET_INDEX_NAME: &str = "rerun:index_name";
+
+/// The key used to identify the entity path in field-level metadata.
+pub const SORBET_ENTITY_PATH: &str = "rerun:entity_path";
+
+/// The key used to identify the [`crate::column_kind::ColumnKind`] in
+/// field-level metadata.
+pub const RERUN_KIND: &str = "rerun:kind";
+
 /// Arrow metadata for an arrow record batch.
 pub type ArrowBatchMetadata = HashMap<String, String>;
 
diff --git a/crates/store/re_sorbet/src/migrations/v0_0_2__to__v0_1_0.rs b/crates/store/re_sorbet/src/migrations/v0_0_2__to__v0_1_0.rs
@@ -61,9 +61,9 @@ fn rewire_tagged_components(batch: &RecordBatch) -> RecordBatch {
             }
 
             // These metadata fields don't require value changes.
-            rename_key(&mut metadata, "rerun.index_name", "rerun:index_name");
-            rename_key(&mut metadata, "rerun.entity_path", "rerun:entity_path");
-            rename_key(&mut metadata, "rerun.kind", "rerun:kind");
+            rename_key(&mut metadata, "rerun.index_name", crate::metadata::SORBET_INDEX_NAME);
+            rename_key(&mut metadata, "rerun.entity_path", crate::metadata::SORBET_ENTITY_PATH);
+            rename_key(&mut metadata, "rerun.kind", crate::metadata::RERUN_KIND);
             rename_key(&mut metadata, "rerun.is_static", "rerun:is_static");
             rename_key(&mut metadata, "rerun.is_indicator", "rerun:is_indicator");
             rename_key(&mut metadata, "rerun.is_tombstone", "rerun:is_tombstone");
@@ -83,13 +83,13 @@ fn rewire_tagged_components(batch: &RecordBatch) -> RecordBatch {
                         component.ends_with("Indicator"),
                         "Expected component to end with 'Indicator', got: {component:?}"
                     );
-                    metadata.insert("rerun:component".to_owned(), component);
+                    metadata.insert(re_types_core::FIELD_METADATA_KEY_COMPONENT.to_owned(), component);
                 } else if field_name.starts_with("rerun.") {
                     // Long name
-                    metadata.insert("rerun:component".to_owned(), field_name.clone());
+                    metadata.insert(re_types_core::FIELD_METADATA_KEY_COMPONENT.to_owned(), field_name.clone());
                 } else {
                     // Short name: expand it to be long
-                    metadata.insert("rerun:component".to_owned(), format!("rerun.components.{field_name}"));
+                    metadata.insert(re_types_core::FIELD_METADATA_KEY_COMPONENT.to_owned(), format!("rerun.components.{field_name}"));
                 }
 
                 // Remove everything else.
@@ -137,11 +137,11 @@ fn rewire_tagged_components(batch: &RecordBatch) -> RecordBatch {
                 };
 
                 if let Some(archetype) = archetype {
-                    metadata.insert("rerun:archetype".to_owned(), archetype);
+                    metadata.insert(re_types_core::FIELD_METADATA_KEY_ARCHETYPE.to_owned(), archetype);
                 }
-                metadata.insert("rerun:component".to_owned(), component);
+                metadata.insert(re_types_core::FIELD_METADATA_KEY_COMPONENT.to_owned(), component);
                 if let Some(component_type) = component_type {
-                    metadata.insert("rerun:component_type".to_owned(), component_type);
+                    metadata.insert(re_types_core::FIELD_METADATA_KEY_COMPONENT_TYPE.to_owned(), component_type);
                 }
             }
 
@@ -192,7 +192,9 @@ fn port_recording_info(batch: &mut RecordBatch) {
 
     // We renamed `RecordingProperties` to `RecordingInfo`,
     // and moved it from `/__properties/recording` to `/__properties`.
-    if let Some(entity_path) = batch.schema_metadata_mut().get_mut("rerun:entity_path")
+    if let Some(entity_path) = batch
+        .schema_metadata_mut()
+        .get_mut(crate::metadata::SORBET_ENTITY_PATH)
         && entity_path == "/__properties/recording"
     {
         *entity_path = "/__properties".to_owned();
@@ -220,7 +222,9 @@ fn port_recording_info(batch: &mut RecordBatch) {
             .with_metadata(field.metadata().clone());
 
             // Migrate per-column entity paths (if any):
-            if let Some(entity_path) = field.metadata_mut().get_mut("rerun:entity_path")
+            if let Some(entity_path) = field
+                .metadata_mut()
+                .get_mut(crate::metadata::SORBET_ENTITY_PATH)
                 && entity_path == "/__properties/recording"
             {
                 *entity_path = "/__properties".to_owned();
diff --git a/crates/store/re_sorbet/src/migrations/v0_1_0__to__v0_1_1.rs b/crates/store/re_sorbet/src/migrations/v0_1_0__to__v0_1_1.rs
@@ -42,10 +42,17 @@ fn drop_indicators(batch: RecordBatch) -> RecordBatch {
                     );
                     Some(i) // Keep
                 }
-            } else if field.metadata().get("rerun:component").is_some_and(|val| {
-                val.starts_with("rerun.components.") && val.ends_with("Indicator")
-            }) {
-                let Some(indicator) = field.metadata().get("rerun:component") else {
+            } else if field
+                .metadata()
+                .get(re_types_core::FIELD_METADATA_KEY_COMPONENT)
+                .is_some_and(|val| {
+                    val.starts_with("rerun.components.") && val.ends_with("Indicator")
+                })
+            {
+                let Some(indicator) = field
+                    .metadata()
+                    .get(re_types_core::FIELD_METADATA_KEY_COMPONENT)
+                else {
                     debug_assert!(
                         false,
                         "missing 'rerun:component' entry that should be present"
diff --git a/crates/store/re_sorbet/src/row_id_column_descriptor.rs b/crates/store/re_sorbet/src/row_id_column_descriptor.rs
@@ -42,7 +42,7 @@ impl RowIdColumnDescriptor {
 
         let mut metadata = std::collections::HashMap::from([
             (
-                "rerun:kind".to_owned(),
+                crate::metadata::RERUN_KIND.to_owned(),
                 crate::ColumnKind::RowId.to_string(),
             ),
             (
diff --git a/crates/store/re_sorbet/src/sorbet_schema.rs b/crates/store/re_sorbet/src/sorbet_schema.rs
@@ -59,7 +59,10 @@ impl SorbetSchema {
     }
 
     pub fn entity_path_metadata(entity_path: &EntityPath) -> (String, String) {
-        ("rerun:entity_path".to_owned(), entity_path.to_string())
+        (
+            crate::metadata::SORBET_ENTITY_PATH.to_owned(),
+            entity_path.to_string(),
+        )
     }
 
     pub fn partition_id_metadata(partition_id: impl AsRef<str>) -> (String, String) {
@@ -136,7 +139,7 @@ impl SorbetSchema {
         let ArrowSchema { metadata, fields } = arrow_schema;
 
         let entity_path = metadata
-            .get("rerun:entity_path")
+            .get(crate::metadata::SORBET_ENTITY_PATH)
             .map(|s| EntityPath::parse_forgiving(s));
 
         let columns = SorbetColumnDescriptors::try_from_arrow_fields(entity_path.as_ref(), fields)?;
diff --git a/crates/store/re_types_core/src/component_batch.rs b/crates/store/re_types_core/src/component_batch.rs
@@ -300,17 +300,6 @@ impl SerializedComponentBatch {
 // all things related to tags up and running so we can gather learnings.
 // This is only used on the archetype deserialization path, which isn't ever used outside of tests anyway.
 
-// TODO(cmc): we really shouldn't be duplicating these.
-
-/// The key used to identify the [`ArchetypeName`] in field-level metadata.
-const FIELD_METADATA_KEY_ARCHETYPE_NAME: &str = "rerun:archetype";
-
-/// The [`crate::ComponentIdentifier`] in field-level metadata.
-const FIELD_METADATA_KEY_COMPONENT: &str = "rerun:component";
-
-/// The key used to identify the [`ComponentType`] in field-level metadata.
-const FIELD_METADATA_KEY_COMPONENT_TYPE: &str = "rerun:component_type";
-
 impl From<&SerializedComponentBatch> for arrow::datatypes::Field {
     #[inline]
     fn from(batch: &SerializedComponentBatch) -> Self {
@@ -323,17 +312,17 @@ impl From<&SerializedComponentBatch> for arrow::datatypes::Field {
             [
                 batch.descriptor.archetype.map(|name| {
                     (
-                        FIELD_METADATA_KEY_ARCHETYPE_NAME.to_owned(),
+                        crate::FIELD_METADATA_KEY_ARCHETYPE.to_owned(),
                         name.to_string(),
                     )
                 }),
                 Some((
-                    FIELD_METADATA_KEY_COMPONENT.to_owned(),
+                    crate::FIELD_METADATA_KEY_COMPONENT.to_owned(),
                     batch.descriptor.component.to_string(),
                 )),
                 batch.descriptor.component_type.map(|name| {
                     (
-                        FIELD_METADATA_KEY_COMPONENT_TYPE.to_owned(),
+                        crate::FIELD_METADATA_KEY_COMPONENT_TYPE.to_owned(),
                         name.to_string(),
                     )
                 }),
diff --git a/crates/top/rerun/src/commands/rrd/print.rs b/crates/top/rerun/src/commands/rrd/print.rs
@@ -199,7 +199,7 @@ fn print_msg(options: &Options, msg: LogMsg) -> anyhow::Result<()> {
                 if let Some(only_this_entity) = &options.entity
                     && let metadata = original_batch.schema_ref().metadata()
                     && let Some(chunk_entity_path) = metadata
-                        .get("rerun:entity_path")
+                        .get(re_sorbet::metadata::SORBET_ENTITY_PATH)
                         .or_else(|| metadata.get("rerun.entity_path"))
                     && only_this_entity != &EntityPath::parse_forgiving(chunk_entity_path)
                 {
diff --git a/crates/top/rerun/src/commands/rrd/stats.rs b/crates/top/rerun/src/commands/rrd/stats.rs
diff --git a/crates/viewer/re_dataframe_ui/tests/column_header_tooltips.rs b/crates/viewer/re_dataframe_ui/tests/column_header_tooltips.rs

Original file line number	Diff line number	Diff line change
`@@ -189,19 +189,25 @@ impl QueryDatasetResponse {`
`189`	`189`	`pub fn field_chunk_id() -> FieldRef {`
`190`	`190`	`lazy_field_ref!(`
`191`	`191`	`Field::new(Self::FIELD_CHUNK_ID, DataType::FixedSizeBinary(16), false).with_metadata(`
`192`		`- [("rerun:kind".to_owned(), "control".to_owned())]`
`193`		`- .into_iter()`
`194`		`- .collect(),`
	`192`	`+ [(`
	`193`	`+ re_sorbet::metadata::RERUN_KIND.to_owned(),`
	`194`	`+ "control".to_owned()`
	`195`	`+ )]`
	`196`	`+ .into_iter()`
	`197`	`+ .collect(),`
`195`	`198`	`)`
`196`	`199`	`)`
`197`	`200`	`}`
`198`	`201`
`199`	`202`	`pub fn field_chunk_partition_id() -> FieldRef {`
`200`	`203`	`lazy_field_ref!(`
`201`	`204`	`Field::new(Self::FIELD_CHUNK_PARTITION_ID, DataType::Utf8, false).with_metadata(`
`202`		`- [("rerun:kind".to_owned(), "control".to_owned())]`
`203`		`- .into_iter()`
`204`		`- .collect(),`
	`205`	`+ [(`
	`206`	`+ re_sorbet::metadata::RERUN_KIND.to_owned(),`
	`207`	`+ "control".to_owned()`
	`208`	`+ )]`
	`209`	`+ .into_iter()`
	`210`	`+ .collect(),`
`205`	`211`	`)`
`206`	`212`	`)`
`207`	`213`	`}`
`@@ -221,19 +227,25 @@ impl QueryDatasetResponse {`
`221`	`227`	`pub fn field_chunk_entity_path() -> FieldRef {`
`222`	`228`	`lazy_field_ref!(`
`223`	`229`	`Field::new(Self::FIELD_CHUNK_ENTITY_PATH, DataType::Utf8, false).with_metadata(`
`224`		`- [("rerun:kind".to_owned(), "control".to_owned())]`
`225`		`- .into_iter()`
`226`		`- .collect(),`
	`230`	`+ [(`
	`231`	`+ re_sorbet::metadata::RERUN_KIND.to_owned(),`
	`232`	`+ "control".to_owned()`
	`233`	`+ )]`
	`234`	`+ .into_iter()`
	`235`	`+ .collect(),`
`227`	`236`	`)`
`228`	`237`	`)`
`229`	`238`	`}`
`230`	`239`
`231`	`240`	`pub fn field_chunk_is_static() -> FieldRef {`
`232`	`241`	`lazy_field_ref!(`
`233`	`242`	`Field::new(Self::FIELD_CHUNK_IS_STATIC, DataType::Boolean, false).with_metadata(`
`234`		`- [("rerun:kind".to_owned(), "control".to_owned())]`
`235`		`- .into_iter()`
`236`		`- .collect(),`
	`243`	`+ [(`
	`244`	`+ re_sorbet::metadata::RERUN_KIND.to_owned(),`
	`245`	`+ "control".to_owned()`
	`246`	`+ )]`
	`247`	`+ .into_iter()`
	`248`	`+ .collect(),`
`237`	`249`	`)`
`238`	`250`	`)`
`239`	`251`	`}`
Original file line number	Diff line number	Diff line change
`@@ -42,7 +42,7 @@ impl RowIdColumnDescriptor {`
`42`	`42`
`43`	`43`	`let mut metadata = std::collections::HashMap::from([`
`44`	`44`	`(`
`45`		`- "rerun:kind".to_owned(),`
	`45`	`+ crate::metadata::RERUN_KIND.to_owned(),`
`46`	`46`	`crate::ColumnKind::RowId.to_string(),`
`47`	`47`	`),`
`48`	`48`	`(`