Wrap TableName in a newtype

Per Mazdak's request on #2793

Author: gefjon

crates/core/src/subscription/module_subscription_manager.rs

@@ -20,7 +20,7 @@ use spacetimedb_data_structures::map::{Entry, IntMap};
 use spacetimedb_lib::metrics::ExecutionMetrics;
 use spacetimedb_lib::{AlgebraicValue, ConnectionId, Identity, ProductValue};
 use spacetimedb_primitives::{ColId, TableId};
-use spacetimedb_subscription::SubscriptionPlan;
+use spacetimedb_subscription::{SubscriptionPlan, TableName};
 use std::collections::BTreeSet;
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::Arc;
@@ -363,7 +363,7 @@ struct ClientQueryUpdate<F: WebsocketFormat> {
 struct ClientUpdate {
     id: ClientId,
     table_id: TableId,
-    table_name: Arc<str>,
+    table_name: TableName,
     update: FormatSwitch<ClientQueryUpdate<BsatnFormat>, ClientQueryUpdate<JsonFormat>>,
 }
 
@@ -842,7 +842,7 @@ impl SubscriptionManager {
             // which involves cloning BSATN (binary) or product values (json).
             .fold(FoldState::default(), |mut acc, (qstate, plan)| {
                 let table_id = plan.subscribed_table_id();
-                let table_name = Arc::clone(plan.subscribed_table_name());
+                let table_name = plan.subscribed_table_name().clone();
                 // Store at most one copy for both the serialization to BSATN and JSON.
                 // Each subscriber gets to pick which of these they want,
                 // but we only fill `ops_bin_uncompressed` and `ops_json` at most once.

crates/subscription/src/lib.rs

@@ -211,13 +211,56 @@ impl Fragments {
     }
 }
 
+/// Newtype wrapper for table names.
+///
+/// Uses an `Arc` internally, so `Clone` is cheap.
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct TableName(Arc<str>);
+
+impl From<Arc<str>> for TableName {
+    fn from(name: Arc<str>) -> Self {
+        TableName(name)
+    }
+}
+
+impl From<Box<str>> for TableName {
+    fn from(name: Box<str>) -> Self {
+        TableName(name.into())
+    }
+}
+
+impl From<String> for TableName {
+    fn from(name: String) -> Self {
+        TableName(name.into())
+    }
+}
+
+impl std::ops::Deref for TableName {
+    type Target = str;
+    fn deref(&self) -> &Self::Target {
+        &*self.0
+    }
+}
+
+impl TableName {
+    pub fn from_str(name: &str) -> Self {
+        TableName(name.into())
+    }
+}
+
+impl std::fmt::Display for TableName {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        self.0.fmt(f)
+    }
+}
+
 /// A subscription defines a view over a table
 #[derive(Debug)]
 pub struct SubscriptionPlan {
     /// To which table are we subscribed?
     return_id: TableId,
     /// To which table are we subscribed?
-    return_name: Arc<str>,
+    return_name: TableName,
     /// A subscription can read from multiple tables.
     /// From which tables do we read?
     table_ids: Vec<TableId>,
@@ -243,7 +286,7 @@ impl SubscriptionPlan {
     }
 
     /// To which table does this plan subscribe?
-    pub fn subscribed_table_name(&self) -> &Arc<str> {
+    pub fn subscribed_table_name(&self) -> &TableName {
         &self.return_name
     }
 
@@ -333,7 +376,7 @@ impl SubscriptionPlan {
 
         let mut subscriptions = vec![];
 
-        let return_name = Arc::<str>::from(return_name);
+        let return_name = TableName::from(return_name);
 
         for plan in plans {
             if has_non_index_join(&plan) {
@@ -346,7 +389,7 @@ impl SubscriptionPlan {
 
             subscriptions.push(Self {
                 return_id,
-                return_name: Arc::clone(&return_name),
+                return_name: return_name.clone(),
                 table_ids,
                 plan,
                 fragments,