Shrink AV and AT to 24 & 16 bytes respectively, and also friends.

Author: Centril

crates/bench/benches/callgrind.rs

@@ -528,13 +528,10 @@ mod callgrind_benches {
             assert_eq!(self.format, "bsatn", "provided metadata has incorrect format");
 
             let buckets = 64;
-            let data = create_sequential::<u32_u64_str>(0xdeadbeef, self.count, buckets);
-            let data = ProductValue {
-                elements: data
-                    .into_iter()
-                    .map(|row| spacetimedb_lib::AlgebraicValue::Product(row.into_product_value()))
-                    .collect::<Vec<_>>(),
-            };
+            let data = create_sequential::<u32_u64_str>(0xdeadbeef, self.count, buckets)
+                .into_iter()
+                .map(|row| spacetimedb_lib::AlgebraicValue::Product(row.into_product_value()))
+                .collect::<ProductValue>();
 
             spacetimedb::callgrind_flag::enable_callgrind_globally(|| {
                 // don't time deallocation: return this!
@@ -567,13 +564,10 @@ mod callgrind_benches {
             assert_eq!(self.format, "json", "provided metadata has incorrect format");
 
             let buckets = 64;
-            let data = create_sequential::<u32_u64_str>(0xdeadbeef, self.count, buckets);
-            let data = ProductValue {
-                elements: data
-                    .into_iter()
-                    .map(|row| spacetimedb_lib::AlgebraicValue::Product(row.into_product_value()))
-                    .collect::<Vec<_>>(),
-            };
+            let data = create_sequential::<u32_u64_str>(0xdeadbeef, self.count, buckets)
+                .into_iter()
+                .map(|row| spacetimedb_lib::AlgebraicValue::Product(row.into_product_value()))
+                .collect::<ProductValue>();
 
             spacetimedb::callgrind_flag::enable_callgrind_globally(|| {
                 // don't time deallocation: return this!

crates/bench/benches/special.rs

@@ -29,7 +29,7 @@ fn custom_module_benchmarks(c: &mut Criterion) {
     };
     let module = runtime.block_on(async { BENCHMARKS_MODULE.load_module(config, None).await });
 
-    let args = sats::product!["0".repeat(65536)];
+    let args = sats::product!["0".repeat(65536).into_boxed_str()];
     c.bench_function("special/stdb_module/large_arguments/64KiB", |b| {
         b.iter_batched(
             || args.clone(),
@@ -66,12 +66,10 @@ fn serialize_benchmarks<T: BenchTable + RandomTable>(c: &mut Criterion) {
         );
     });
     // this measures serialization from a ProductValue, not directly (as in, from generated code in the Rust SDK.)
-    let data_pv = ProductValue {
-        elements: data
-            .into_iter()
-            .map(|row| spacetimedb_lib::AlgebraicValue::Product(row.into_product_value()))
-            .collect::<Vec<_>>(),
-    };
+    let data_pv = data
+        .into_iter()
+        .map(|row| spacetimedb_lib::AlgebraicValue::Product(row.into_product_value()))
+        .collect::<ProductValue>();
 
     group.bench_function(&format!("{name}/bsatn/count={count}"), |b| {
         b.iter_batched_ref(

crates/bench/benches/subscription.rs

@@ -40,7 +40,7 @@ fn create_table_footprint(db: &RelationalDB) -> Result<TableId, DBError> {
 fn insert_op(table_id: TableId, table_name: &str, row: ProductValue) -> DatabaseTableUpdate {
     DatabaseTableUpdate {
         table_id,
-        table_name: table_name.to_string(),
+        table_name: table_name.into(),
         inserts: [row].into(),
         deletes: [].into(),
     }

crates/bench/src/schemas.rs

@@ -19,7 +19,7 @@ pub struct u32_u64_str {
     // column 1
     age: u64,
     // column 2
-    name: String,
+    name: Box<str>,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -82,7 +82,7 @@ impl BenchTable for u32_u64_str {
         sats::product![self.id, self.age, self.name,]
     }
 
-    type SqliteParams = (u32, u64, String);
+    type SqliteParams = (u32, u64, Box<str>);
     fn into_sqlite_params(self) -> Self::SqliteParams {
         (self.id, self.age, self.name)
     }
@@ -192,7 +192,7 @@ pub trait RandomTable {
 
 impl RandomTable for u32_u64_str {
     fn gen(id: u32, rng: &mut XorShiftLite, buckets: u64) -> Self {
-        let name = nth_name(rng.gen() % buckets);
+        let name = nth_name(rng.gen() % buckets).into();
         let age = rng.gen() % buckets;
         u32_u64_str { id, name, age }
     }

crates/bench/src/spacetime_module.rs

@@ -3,7 +3,7 @@ use std::path::Path;
 use spacetimedb::db::{Config, Storage};
 use spacetimedb_lib::{
     sats::{product, ArrayValue},
-    AlgebraicValue, ProductValue,
+    AlgebraicValue,
 };
 use spacetimedb_testing::modules::{start_runtime, CompilationMode, CompiledModule, LoggerRecord, ModuleHandle};
 use tokio::runtime::Runtime;
@@ -107,7 +107,7 @@ impl BenchDatabase for SpacetimeModule {
             module.call_reducer_binary(&name, ProductValue::new(&[])).await?;
             */
             // workaround for now
-            module.client.module.clear_table(table_id.pascal_case.clone()).await?;
+            module.client.module.clear_table(&table_id.pascal_case).await?;
             Ok(())
         })
     }
@@ -194,9 +194,7 @@ impl BenchDatabase for SpacetimeModule {
         let reducer_name = format!("filter_{}_by_{}", table_id.snake_case, column_name);
 
         runtime.block_on(async move {
-            module
-                .call_reducer_binary(&reducer_name, ProductValue { elements: vec![value] })
-                .await?;
+            module.call_reducer_binary(&reducer_name, [value].into()).await?;
             Ok(())
         })
     }

crates/bench/src/sqlite.rs

@@ -135,8 +135,8 @@ impl BenchDatabase for SQLite {
 
     fn update_bulk<T: BenchTable>(&mut self, table_id: &Self::TableId, row_count: u32) -> ResultBench<()> {
         let mut product = T::product_type();
-        let id_column = product.elements.swap_remove(0).name.unwrap();
-        let update_column = product.elements.swap_remove(1).name.unwrap();
+        let id_column = product.elements[0].name.take().unwrap();
+        let update_column = product.elements[1].name.take().unwrap();
         // this relies on IDs having been generated in order...
         let statement =
             format!("UPDATE {table_id} SET {update_column} = {update_column} + 1 WHERE {id_column} < {row_count}");
@@ -175,11 +175,7 @@ impl BenchDatabase for SQLite {
         value: AlgebraicValue,
     ) -> ResultBench<()> {
         let statement = memo_query(BenchName::Filter, table_id, || {
-            let column: String = T::product_type()
-                .elements
-                .swap_remove(column_index as usize)
-                .name
-                .unwrap();
+            let column: Box<str> = T::product_type().elements[column_index as usize].name.take().unwrap();
             format!("SELECT * FROM {table_id} WHERE {column} = ?")
         });
 

crates/bindings/src/rt.rs

@@ -270,7 +270,7 @@ macro_rules! impl_reducer {
                     name: Info::NAME.into(),
                     args: vec![
                         $(ProductTypeElement {
-                            name: $T.map(str::to_owned),
+                            name: $T.map(Into::into),
                             algebraic_type: <$T>::make_type(_typespace),
                         }),*
                     ],
@@ -470,7 +470,7 @@ impl From<crate::IndexDesc<'_>> for IndexDef {
         };
 
         IndexDef {
-            index_name: index.name.to_string(),
+            index_name: index.name.into(),
             is_unique: false,
             index_type: index.ty,
             columns,

crates/cli/src/subcommands/generate/csharp.rs

@@ -1,6 +1,7 @@
 use super::util::fmt_fn;
 
 use std::fmt::{self, Write};
+use std::ops::Deref;
 
 use convert_case::{Case, Casing};
 use spacetimedb_lib::sats::db::def::TableSchema;
@@ -110,7 +111,7 @@ fn ty_fmt<'a>(ctx: &'a GenCtx, ty: &'a AlgebraicType, namespace: &'a str) -> imp
             let name = csharp_typename(ctx, *r);
             match &ctx.typespace.types[r.idx()] {
                 AlgebraicType::Sum(sum_type) => {
-                    if is_enum(sum_type) {
+                    if sum_type.is_simple_enum() {
                         let parts: Vec<&str> = name.split('.').collect();
                         if parts.len() >= 2 {
                             let enum_namespace = parts[0];
@@ -253,7 +254,7 @@ fn convert_type<'a>(
             let algebraic_type = &ctx.typespace.types[r.idx()];
             match algebraic_type {
                 AlgebraicType::Sum(sum) => {
-                    if is_enum(sum) {
+                    if sum.is_simple_enum() {
                         let split: Vec<&str> = name.split('.').collect();
                         if split.len() >= 2 {
                             assert_eq!(
@@ -317,7 +318,7 @@ fn convert_algebraic_type<'a>(ctx: &'a GenCtx, ty: &'a AlgebraicType, namespace:
             let name = csharp_typename(ctx, *r);
             match &ctx.typespace.types[r.idx()] {
                 AlgebraicType::Sum(sum_type) => {
-                    if is_enum(sum_type) {
+                    if sum_type.is_simple_enum() {
                         let parts: Vec<&str> = name.split('.').collect();
                         if parts.len() >= 2 {
                             let enum_namespace = parts[0];
@@ -349,7 +350,7 @@ fn convert_product_type<'a>(
             "SpacetimeDB.SATS.AlgebraicType.CreateProductType(new SpacetimeDB.SATS.ProductTypeElement[]"
         )?;
         writeln!(f, "{{")?;
-        for elem in &product_type.elements {
+        for elem in &*product_type.elements {
             writeln!(
                 f,
                 "{INDENT}new SpacetimeDB.SATS.ProductTypeElement({}, {}),",
@@ -371,7 +372,7 @@ fn convert_sum_type<'a>(ctx: &'a GenCtx, sum_type: &'a SumType, namespace: &'a s
             "SpacetimeDB.SATS.AlgebraicType.CreateSumType(new System.Collections.Generic.List<SpacetimeDB.SATS.SumTypeVariant>"
         )?;
         writeln!(f, "{{")?;
-        for elem in &sum_type.variants {
+        for elem in &*sum_type.variants {
             writeln!(
                 f,
                 "\tnew SpacetimeDB.SATS.SumTypeVariant({}, {}),",
@@ -386,23 +387,8 @@ fn convert_sum_type<'a>(ctx: &'a GenCtx, sum_type: &'a SumType, namespace: &'a s
     })
 }
 
-pub fn is_enum(sum_type: &SumType) -> bool {
-    for variant in sum_type.clone().variants {
-        match variant.algebraic_type {
-            AlgebraicType::Product(product) => {
-                if product.elements.is_empty() {
-                    continue;
-                }
-            }
-            _ => return false,
-        }
-    }
-
-    true
-}
-
 pub fn autogen_csharp_sum(ctx: &GenCtx, name: &str, sum_type: &SumType, namespace: &str) -> String {
-    if is_enum(sum_type) {
+    if sum_type.is_simple_enum() {
         autogen_csharp_enum(ctx, name, sum_type, namespace)
     } else {
         unimplemented!();
@@ -467,7 +453,7 @@ pub fn autogen_csharp_enum(ctx: &GenCtx, name: &str, sum_type: &SumType, namespa
                         writeln!(output, "{{").unwrap();
                         {
                             indent_scope!(output);
-                            for variant in &sum_type.variants {
+                            for variant in &*sum_type.variants {
                                 let variant_name = variant
                                     .name
                                     .as_ref()
@@ -500,7 +486,7 @@ pub fn autogen_csharp_enum(ctx: &GenCtx, name: &str, sum_type: &SumType, namespa
                     .unwrap();
                 }
                 None => {
-                    for variant in &sum_type.variants {
+                    for variant in &*sum_type.variants {
                         let variant_name = variant
                             .name
                             .as_ref()
@@ -614,7 +600,7 @@ fn autogen_csharp_product_table_common(
         {
             indent_scope!(output);
 
-            for field in &product_type.elements {
+            for field in &*product_type.elements {
                 let field_name = field
                     .name
                     .as_ref()
@@ -641,7 +627,7 @@ fn autogen_csharp_product_table_common(
                     AlgebraicType::Ref(type_ref) => {
                         let ref_type = &ctx.typespace.types[type_ref.idx()];
                         if let AlgebraicType::Sum(sum_type) = ref_type {
-                            if is_enum(sum_type) {
+                            if sum_type.is_simple_enum() {
                                 writeln!(output, "[SpacetimeDB.Enum]").unwrap();
                             } else {
                                 unimplemented!()
@@ -1307,7 +1293,7 @@ pub fn autogen_csharp_reducer(ctx: &GenCtx, reducer: &ReducerDef, namespace: &st
                 AlgebraicType::Ref(type_ref) => {
                     let ref_type = &ctx.typespace.types[type_ref.idx()];
                     if let AlgebraicType::Sum(sum_type) = ref_type {
-                        if is_enum(sum_type) {
+                        if sum_type.is_simple_enum() {
                             json_args.push_str(
                                 format!("new SpacetimeDB.EnumWrapper<{}>({})", arg_type_str, arg_name).as_str(),
                             );
@@ -1403,7 +1389,8 @@ pub fn autogen_csharp_reducer(ctx: &GenCtx, reducer: &ReducerDef, namespace: &st
                         let arg_name = arg
                             .name
                             .clone()
-                            .unwrap_or_else(|| format!("arg_{}", i))
+                            .unwrap_or_else(|| format!("arg_{}", i).into())
+                            .deref()
                             .to_case(Case::Pascal);
                         let arg_type_str = ty_fmt(ctx, &arg.algebraic_type, namespace);
                         writeln!(output, ",({arg_type_str})args.{arg_name}").unwrap();
@@ -1441,7 +1428,8 @@ pub fn autogen_csharp_reducer(ctx: &GenCtx, reducer: &ReducerDef, namespace: &st
                 let arg_name = arg
                     .name
                     .clone()
-                    .unwrap_or_else(|| format!("arg_{}", i))
+                    .unwrap_or_else(|| format!("arg_{}", i).into())
+                    .deref()
                     .to_case(Case::Pascal);
                 let algebraic_type = convert_algebraic_type(ctx, &arg.algebraic_type, namespace);
                 writeln!(
@@ -1472,7 +1460,8 @@ pub fn autogen_csharp_reducer(ctx: &GenCtx, reducer: &ReducerDef, namespace: &st
             let arg_name = arg
                 .name
                 .clone()
-                .unwrap_or_else(|| format!("arg_{}", i))
+                .unwrap_or_else(|| format!("arg_{}", i).into())
+                .deref()
                 .to_case(Case::Pascal);
             let cs_type = ty_fmt(ctx, &arg.algebraic_type, namespace);
             writeln!(output, "public {cs_type} {arg_name};").unwrap();
@@ -1503,7 +1492,7 @@ pub fn autogen_csharp_globals(items: &[GenItem], namespace: &str) -> Vec<Vec<(St
         .collect();
     let reducer_names: Vec<String> = reducers
         .iter()
-        .map(|reducer| reducer.name.to_case(Case::Pascal))
+        .map(|reducer| reducer.name.deref().to_case(Case::Pascal))
         .collect();
 
     let use_namespace = true;
@@ -1570,7 +1559,7 @@ pub fn autogen_csharp_globals(items: &[GenItem], namespace: &str) -> Vec<Vec<(St
         writeln!(output).unwrap();
         // Properties for reducer args
         for reducer in &reducers {
-            let reducer_name = reducer.name.to_case(Case::Pascal);
+            let reducer_name = reducer.name.deref().to_case(Case::Pascal);
             writeln!(output, "public {reducer_name}ArgsStruct {reducer_name}Args").unwrap();
             writeln!(output, "{{").unwrap();
             {
@@ -1598,7 +1587,7 @@ pub fn autogen_csharp_globals(items: &[GenItem], namespace: &str) -> Vec<Vec<(St
             {
                 indent_scope!(output);
                 for reducer in &reducers {
-                    let reducer_name = reducer.name.to_case(Case::Pascal);
+                    let reducer_name = reducer.name.deref().to_case(Case::Pascal);
                     writeln!(output, "case ReducerType.{reducer_name}:").unwrap();
                     writeln!(output, "{{").unwrap();
                     {
@@ -1611,7 +1600,8 @@ pub fn autogen_csharp_globals(items: &[GenItem], namespace: &str) -> Vec<Vec<(St
                                 let arg_name = arg
                                     .name
                                     .clone()
-                                    .unwrap_or_else(|| format!("arg_{}", i))
+                                    .unwrap_or_else(|| format!("arg_{}", i).into())
+                                    .deref()
                                     .to_case(Case::Pascal);
                                 writeln!(output, "args.{arg_name},").unwrap();
                             }