diff --git a/crates/codegen/src/csharp.rs b/crates/codegen/src/csharp.rs
index e81035aa594..5e9eab5763e 100644
--- a/crates/codegen/src/csharp.rs
+++ b/crates/codegen/src/csharp.rs
@@ -7,8 +7,8 @@ use std::ops::Deref;
 use super::code_indenter::CodeIndenter;
 use super::Lang;
 use crate::util::{
-    collect_case, is_reducer_invokable, iter_indexes, iter_reducers, iter_tables, print_auto_generated_file_comment,
-    print_auto_generated_version_comment, type_ref_name,
+    collect_case, is_reducer_invokable, iter_indexes, iter_reducers, iter_table_names_and_types,
+    print_auto_generated_file_comment, print_auto_generated_version_comment, type_ref_name,
 };
 use crate::{indent_scope, OutputFile};
 use convert_case::{Case, Casing};
@@ -745,11 +745,11 @@ impl Lang for Csharp<'_> {
         indented_block(&mut output, |output| {
             writeln!(output, "public RemoteTables(DbConnection conn)");
             indented_block(output, |output| {
-                for table in iter_tables(module) {
+                for (table_name, _) in iter_table_names_and_types(module) {
                     writeln!(
                         output,
                         "AddTable({} = new(conn));",
-                        table.name.deref().to_case(Case::Pascal)
+                        table_name.deref().to_case(Case::Pascal)
                     );
                 }
             });
diff --git a/crates/codegen/src/rust.rs b/crates/codegen/src/rust.rs
index a968ec7826a..9bcb427298c 100644
--- a/crates/codegen/src/rust.rs
+++ b/crates/codegen/src/rust.rs
@@ -2,8 +2,8 @@ use super::code_indenter::{CodeIndenter, Indenter};
 use super::util::{collect_case, iter_reducers, print_lines, type_ref_name};
 use super::Lang;
 use crate::util::{
-    iter_procedures, iter_tables, iter_types, iter_unique_cols, print_auto_generated_file_comment,
-    print_auto_generated_version_comment,
+    iter_procedures, iter_table_names_and_types, iter_tables, iter_types, iter_unique_cols, iter_views,
+    print_auto_generated_file_comment, print_auto_generated_version_comment,
 };
 use crate::OutputFile;
 use convert_case::{Case, Casing};
@@ -930,12 +930,13 @@ fn reducer_flags_trait_name(reducer: &ReducerDef) -> String {
     format!("set_flags_for_{}", reducer_function_name(reducer))
 }
 
-/// Iterate over all of the Rust `mod`s for types, reducers and tables in the `module`.
+/// Iterate over all of the Rust `mod`s for types, reducers, views, and tables in the `module`.
 fn iter_module_names(module: &ModuleDef) -> impl Iterator<Item = String> + '_ {
     itertools::chain!(
         iter_types(module).map(|ty| type_module_name(&ty.name)),
         iter_reducers(module).map(|r| reducer_module_name(&r.name)),
         iter_tables(module).map(|tbl| table_module_name(&tbl.name)),
+        iter_views(module).map(|view| table_module_name(&view.name)),
         iter_procedures(module).map(|proc| procedure_module_name(&proc.name)),
     )
 }
@@ -954,8 +955,8 @@ fn print_module_reexports(module: &ModuleDef, out: &mut Indenter) {
         let type_name = collect_case(Case::Pascal, ty.name.name_segments());
         writeln!(out, "pub use {mod_name}::{type_name};")
     }
-    for table in iter_tables(module) {
-        let mod_name = table_module_name(&table.name);
+    for (table_name, _) in iter_table_names_and_types(module) {
+        let mod_name = table_module_name(table_name);
         // TODO: More precise reexport: we want:
         // - The trait name.
         // - The insert, delete and possibly update callback ids.
@@ -1113,12 +1114,12 @@ fn print_db_update_defn(module: &ModuleDef, out: &mut Indenter) {
     out.delimited_block(
         "pub struct DbUpdate {",
         |out| {
-            for table in iter_tables(module) {
+            for (table_name, product_type_ref) in iter_table_names_and_types(module) {
                 writeln!(
                     out,
                     "{}: __sdk::TableUpdate<{}>,",
-                    table_method_name(&table.name),
-                    type_ref_name(module, table.product_type_ref),
+                    table_method_name(table_name),
+                    type_ref_name(module, product_type_ref),
                 );
             }
         },
@@ -1137,13 +1138,13 @@ impl TryFrom<__ws::DatabaseUpdate<__ws::BsatnFormat>> for DbUpdate {
             match &table_update.table_name[..] {
 ",
         |out| {
-            for table in iter_tables(module) {
+            for (table_name, _) in iter_table_names_and_types(module) {
                 writeln!(
                     out,
                     "{:?} => db_update.{}.append({}::parse_table_update(table_update)?),",
-                    table.name.deref(),
-                    table_method_name(&table.name),
-                    table_module_name(&table.name),
+                    table_name.deref(),
+                    table_method_name(table_name),
+                    table_module_name(table_name),
                 );
             }
         },
@@ -1198,6 +1199,15 @@ impl __sdk::InModule for DbUpdate {{
                             table.name.deref(),
                         );
                     }
+                    for view in iter_views(module) {
+                        let field_name = table_method_name(&view.name);
+                        writeln!(
+                            out,
+                            "diff.{field_name} = cache.apply_diff_to_table::<{}>({:?}, &self.{field_name});",
+                            type_ref_name(module, view.product_type_ref),
+                            view.name.deref(),
+                        );
+                    }
                 },
                 "
                     diff
@@ -1215,12 +1225,12 @@ fn print_applied_diff_defn(module: &ModuleDef, out: &mut Indenter) {
     out.delimited_block(
         "pub struct AppliedDiff<'r> {",
         |out| {
-            for table in iter_tables(module) {
+            for (table_name, product_type_ref) in iter_table_names_and_types(module) {
                 writeln!(
                     out,
                     "{}: __sdk::TableAppliedDiff<'r, {}>,",
-                    table_method_name(&table.name),
-                    type_ref_name(module, table.product_type_ref),
+                    table_method_name(table_name),
+                    type_ref_name(module, product_type_ref),
                 );
             }
             // Also write a `PhantomData` field which uses the lifetime `r`,
@@ -1248,13 +1258,13 @@ impl __sdk::InModule for AppliedDiff<'_> {{
             out.delimited_block(
                 "fn invoke_row_callbacks(&self, event: &EventContext, callbacks: &mut __sdk::DbCallbacks<RemoteModule>) {",
                 |out| {
-                    for table in iter_tables(module) {
+                    for (table_name, product_type_ref) in iter_table_names_and_types(module) {
                         writeln!(
                             out,
                             "callbacks.invoke_table_row_callbacks::<{}>({:?}, &self.{}, event);",
-                            type_ref_name(module, table.product_type_ref),
-                            table.name.deref(),
-                            table_method_name(&table.name),
+                            type_ref_name(module, product_type_ref),
+                            table_name.deref(),
+                            table_method_name(table_name),
                         );
                     }
                 },
@@ -1290,8 +1300,8 @@ type SubscriptionHandle = SubscriptionHandle;
             out.delimited_block(
                 "fn register_tables(client_cache: &mut __sdk::ClientCache<Self>) {",
                 |out| {
-                    for table in iter_tables(module) {
-                        writeln!(out, "{}::register_table(client_cache);", table_module_name(&table.name));
+                    for (table_name, _) in iter_table_names_and_types(module) {
+                        writeln!(out, "{}::register_table(client_cache);", table_module_name(table_name));
                     }
                 },
                 "}\n",
diff --git a/crates/codegen/src/typescript.rs b/crates/codegen/src/typescript.rs
index 14dd4fb4c4d..157939c08f1 100644
--- a/crates/codegen/src/typescript.rs
+++ b/crates/codegen/src/typescript.rs
@@ -1,5 +1,5 @@
 use crate::util::{
-    is_reducer_invokable, iter_constraints, iter_indexes, iter_reducers, iter_table_and_view_names, iter_tables,
+    is_reducer_invokable, iter_constraints, iter_indexes, iter_reducers, iter_table_names_and_types, iter_tables,
     iter_types, iter_views, print_auto_generated_version_comment,
 };
 use crate::OutputFile;
@@ -195,7 +195,7 @@ impl Lang for TypeScript {
 
         writeln!(out);
         writeln!(out, "// Import and reexport all table handle types");
-        for table_name in iter_table_and_view_names(module) {
+        for (table_name, _) in iter_table_names_and_types(module) {
             let table_module_name = table_module_name(table_name);
             let table_name_pascalcase = table_name.deref().to_case(Case::Pascal);
             // TODO: This really shouldn't be necessary. We could also have `table()` accept
diff --git a/crates/codegen/src/unrealcpp.rs b/crates/codegen/src/unrealcpp.rs
index 280b1be4475..588c681e4dc 100644
--- a/crates/codegen/src/unrealcpp.rs
+++ b/crates/codegen/src/unrealcpp.rs
@@ -1,7 +1,8 @@
 //! Autogenerated Unreal‑C++ code‑gen backend for SpacetimeDB CLI
 use crate::code_indenter::CodeIndenter;
 use crate::util::{
-    collect_case, fmt_fn, iter_tables, print_auto_generated_file_comment, print_auto_generated_version_comment,
+    collect_case, fmt_fn, iter_table_names_and_types, print_auto_generated_file_comment,
+    print_auto_generated_version_comment,
 };
 use crate::util::{iter_indexes, iter_reducers};
 use crate::Lang;
@@ -38,7 +39,8 @@ impl UnrealCpp<'_> {
 impl Lang for UnrealCpp<'_> {
     fn generate_table_file_from_schema(&self, module: &ModuleDef, table: &TableDef, schema: TableSchema) -> OutputFile {
         let struct_name = type_ref_name(module, table.product_type_ref);
-        let self_header = struct_name.clone() + "Table";
+        let table_pascal = table.name.deref().to_case(Case::Pascal);
+        let self_header = table_pascal.clone() + "Table";
 
         let mut output = UnrealCppAutogen::new(
             &[
@@ -54,9 +56,8 @@ impl Lang for UnrealCpp<'_> {
         );
 
         let row_struct = format!("F{struct_name}Type"); // e.g. "FUserType", "FMessageType"
-        let handle_cls = format!("U{struct_name}Table"); // "UMessageTable"
+        let handle_cls = format!("U{table_pascal}Table"); // "UMessageTable"
         let table_name = table.name.deref().to_string();
-        let table_pascal = struct_name.clone();
 
         // Generate unique index classes first
         let product_type = module.typespace_for_generate()[table.product_type_ref].as_product();
@@ -374,7 +375,7 @@ impl Lang for UnrealCpp<'_> {
             filename: format!(
                 "Source/{}/Public/ModuleBindings/Tables/{}Table.g.h",
                 self.module_name,
-                type_ref_name(module, table.product_type_ref)
+                table.name.deref().to_case(Case::Pascal) //type_ref_name(module, table.product_type_ref)
             ),
             code: output.into_inner(),
         }
@@ -683,9 +684,8 @@ impl Lang for UnrealCpp<'_> {
         writeln!(client_h);
 
         writeln!(client_h, "/** Forward declaration for tables */");
-        for table in iter_tables(module) {
-            let table_pascal = type_ref_name(module, table.product_type_ref);
-            writeln!(client_h, "class U{table_pascal}Table;");
+        for (table_name, _) in iter_table_names_and_types(module) {
+            writeln!(client_h, "class U{}Table;", table_name.deref().to_case(Case::Pascal));
         }
         writeln!(client_h, "/***/");
         writeln!(client_h);
@@ -774,12 +774,11 @@ impl Lang for UnrealCpp<'_> {
         });
 
         // Build table includes
-        let table_includes: Vec<String> = module
-            .tables()
-            .map(|table| {
+        let table_includes: Vec<String> = iter_table_names_and_types(module)
+            .map(|(table_name, _)| {
                 format!(
                     "ModuleBindings/Tables/{}Table.g.h",
-                    type_ref_name(module, table.product_type_ref)
+                    table_name.deref().to_case(Case::Pascal) //type_ref_name(module, product_type_ref)
                 )
             })
             .collect();
@@ -805,26 +804,46 @@ impl Lang for UnrealCpp<'_> {
 
         // Generate .cpp implementation files for each table
         for table in module.tables() {
-            let table_cpp_content = generate_table_cpp(module, table, self.module_name);
+            let schema = TableSchema::from_module_def(module, table, (), 0.into())
+                .validated()
+                .expect("table schema should validate");
+            let table_cpp_content = generate_table_cpp(module, table, self.module_name, &schema);
             let table_cpp_filename = format!(
                 "Source/{}/Private/ModuleBindings/Tables/{}Table.g.cpp",
                 self.module_name,
-                type_ref_name(module, table.product_type_ref)
+                table.name.deref().to_case(Case::Pascal) //type_ref_name(module, table.product_type_ref)
             );
             files.push(OutputFile {
                 filename: table_cpp_filename,
                 code: table_cpp_content,
             });
         }
+        for view in module.views() {
+            let tbl = TableDef::from(view.clone());
+            let schema = TableSchema::from_view_def_for_codegen(module, view)
+                .validated()
+                .expect("Failed to generate table due to validation errors");
+            let view_cpp_content = generate_table_cpp(module, &tbl, self.module_name, &schema);
+            let view_cpp_filename = format!(
+                "Source/{}/Private/ModuleBindings/Tables/{}Table.g.cpp",
+                self.module_name,
+                view.name.deref().to_case(Case::Pascal) //type_ref_name(module, view.product_type_ref)
+            );
+            files.push(OutputFile {
+                filename: view_cpp_filename,
+                code: view_cpp_content,
+            });
+        }
 
         files
     }
 }
 
 // Helper function to generate table .cpp implementation files
-fn generate_table_cpp(module: &ModuleDef, table: &TableDef, module_name: &str) -> String {
-    let table_pascal = type_ref_name(module, table.product_type_ref);
-    let row_struct = format!("F{table_pascal}Type");
+fn generate_table_cpp(module: &ModuleDef, table: &TableDef, module_name: &str, schema: &TableSchema) -> String {
+    let table_pascal = table.name.deref().to_case(Case::Pascal);
+    let struct_name = type_ref_name(module, table.product_type_ref);
+    let row_struct = format!("F{struct_name}Type");
 
     // Include the table header and other necessary headers
     let table_header = format!("ModuleBindings/Tables/{table_pascal}Table.g.h");
@@ -838,10 +857,6 @@ fn generate_table_cpp(module: &ModuleDef, table: &TableDef, module_name: &str) -
 
     let mut output = UnrealCppAutogen::new_cpp(&includes);
 
-    let schema = TableSchema::from_module_def(module, table, (), 0.into())
-        .validated()
-        .expect("table schema should validate");
-
     // Get unique indexes and non-unique BTree indexes
     let product_type = module.typespace_for_generate()[table.product_type_ref].as_product();
 
@@ -1856,14 +1871,13 @@ fn generate_remote_tables_class(output: &mut UnrealCppAutogen, module: &ModuleDe
     writeln!(output);
 
     // Generate table handle properties
-    for table in module.tables() {
-        let table_pascal = type_ref_name(module, table.product_type_ref);
-
+    for (table_name, _) in iter_table_names_and_types(module) {
         writeln!(output, "    UPROPERTY(BlueprintReadOnly, Category=\"SpacetimeDB\")");
         writeln!(
             output,
-            "    U{table_pascal}Table* {};",
-            table.name.deref().to_case(Case::Pascal)
+            "    U{}Table* {};",
+            table_name.deref().to_case(Case::Pascal),
+            table_name.deref().to_case(Case::Pascal)
         );
         writeln!(output);
     }
@@ -2357,16 +2371,16 @@ fn generate_client_implementation(output: &mut UnrealCppAutogen, module: &Module
     writeln!(output, "\tReducers->SetCallReducerFlags = SetReducerFlags;");
     writeln!(output, "\tReducers->Conn = this;");
     writeln!(output);
-    for table in module.tables() {
-        let table_pascal = type_ref_name(module, table.product_type_ref);
-        let table_name = table.name.deref();
+    for (table_name, product_type_ref) in iter_table_names_and_types(module) {
+        let struct_name = type_ref_name(module, product_type_ref);
+        let table_name = table_name.deref();
         writeln!(
             output,
             "\tRegisterTable<F{}Type, U{}Table, FEventContext>(TEXT(\"{}\"), Db->{});",
-            table_pascal,
-            table_pascal,
+            struct_name,
+            table_name.to_case(Case::Pascal),
             table_name,
-            table.name.deref().to_case(Case::Pascal)
+            table_name.to_case(Case::Pascal)
         );
     }
     writeln!(output, "}}");
@@ -2412,23 +2426,22 @@ fn generate_client_implementation(output: &mut UnrealCppAutogen, module: &Module
     writeln!(output, "{{");
     writeln!(output);
     writeln!(output, "\t/** Creating tables */");
-    for table in module.tables() {
-        let table_pascal = type_ref_name(module, table.product_type_ref);
+    for (table_name, _) in iter_table_names_and_types(module) {
         writeln!(
             output,
             "\t{} = NewObject<U{}Table>(this);",
-            table.name.deref().to_case(Case::Pascal),
-            table_pascal
+            table_name.deref().to_case(Case::Pascal),
+            table_name.deref().to_case(Case::Pascal)
         );
     }
     writeln!(output, "\t/**/");
     writeln!(output);
     writeln!(output, "\t/** Initialization */");
-    for table in module.tables() {
+    for (table_name, _) in iter_table_names_and_types(module) {
         writeln!(
             output,
             "\t{}->PostInitialize();",
-            table.name.deref().to_case(Case::Pascal)
+            table_name.deref().to_case(Case::Pascal)
         );
     }
     writeln!(output, "\t/**/");
@@ -3095,10 +3108,8 @@ fn collect_optional_types(module: &ModuleDef) -> HashSet<String> {
     }
 
     // Collect from all tables
-    for table in module.tables() {
-        let product_type = module.typespace_for_generate()[table.product_type_ref]
-            .as_product()
-            .unwrap();
+    for (_, product_type_ref) in iter_table_names_and_types(module) {
+        let product_type = module.typespace_for_generate()[product_type_ref].as_product().unwrap();
         for (_, field_ty) in &product_type.elements {
             collect_from_type(module, field_ty, &mut optional_types);
         }
diff --git a/crates/codegen/src/util.rs b/crates/codegen/src/util.rs
index 2a0bcca4ca2..6ff3d11b408 100644
--- a/crates/codegen/src/util.rs
+++ b/crates/codegen/src/util.rs
@@ -125,12 +125,12 @@ pub(super) fn iter_views(module: &ModuleDef) -> impl Iterator<Item = &ViewDef> {
 /// Iterate over the names of all the tables and views defined by the module, in alphabetical order.
 ///
 /// Sorting is necessary to have deterministic reproducible codegen.
-pub(super) fn iter_table_and_view_names(module: &ModuleDef) -> impl Iterator<Item = &Identifier> {
-    itertools::chain(
-        module.tables().map(|table| &table.name),
-        module.views().map(|view| &view.name),
-    )
-    .sorted()
+pub(super) fn iter_table_names_and_types(module: &ModuleDef) -> impl Iterator<Item = (&Identifier, AlgebraicTypeRef)> {
+    module
+        .tables()
+        .map(|def| (&def.name, def.product_type_ref))
+        .chain(module.views().map(|def| (&def.name, def.product_type_ref)))
+        .sorted_by_key(|(name, _)| *name)
 }
 
 pub(super) fn iter_unique_cols<'a>(
diff --git a/crates/codegen/tests/snapshots/codegen__codegen_csharp.snap b/crates/codegen/tests/snapshots/codegen__codegen_csharp.snap
index 4d2796d4811..38e8c9eafac 100644
--- a/crates/codegen/tests/snapshots/codegen__codegen_csharp.snap
+++ b/crates/codegen/tests/snapshots/codegen__codegen_csharp.snap
@@ -1011,6 +1011,7 @@ namespace SpacetimeDB
         {
             AddTable(HasSpecialStuff = new(conn));
             AddTable(LoggedOutPlayer = new(conn));
+            AddTable(MyPlayer = new(conn));
             AddTable(Person = new(conn));
             AddTable(PkMultiIdentity = new(conn));
             AddTable(Player = new(conn));
diff --git a/crates/codegen/tests/snapshots/codegen__codegen_rust.snap b/crates/codegen/tests/snapshots/codegen__codegen_rust.snap
index a334dec7a9c..995543ac4fa 100644
--- a/crates/codegen/tests/snapshots/codegen__codegen_rust.snap
+++ b/crates/codegen/tests/snapshots/codegen__codegen_rust.snap
@@ -1421,6 +1421,7 @@ pub mod test_a_table;
 pub mod test_d_table;
 pub mod test_e_table;
 pub mod test_f_table;
+pub mod my_player_table;
 pub mod return_value_procedure;
 pub mod sleep_one_second_procedure;
 
@@ -1442,6 +1443,7 @@ pub use namespace_test_c_type::NamespaceTestC;
 pub use namespace_test_f_type::NamespaceTestF;
 pub use has_special_stuff_table::*;
 pub use logged_out_player_table::*;
+pub use my_player_table::*;
 pub use person_table::*;
 pub use pk_multi_identity_table::*;
 pub use player_table::*;
@@ -1568,6 +1570,7 @@ fn try_from(value: __ws::ReducerCallInfo<__ws::BsatnFormat>) -> __sdk::Result<Se
 pub struct DbUpdate {
         has_special_stuff: __sdk::TableUpdate<HasSpecialStuff>,
     logged_out_player: __sdk::TableUpdate<Player>,
+    my_player: __sdk::TableUpdate<Player>,
     person: __sdk::TableUpdate<Person>,
     pk_multi_identity: __sdk::TableUpdate<PkMultiIdentity>,
     player: __sdk::TableUpdate<Player>,
@@ -1590,6 +1593,7 @@ impl TryFrom<__ws::DatabaseUpdate<__ws::BsatnFormat>> for DbUpdate {
 
         "has_special_stuff" => db_update.has_special_stuff.append(has_special_stuff_table::parse_table_update(table_update)?),
     "logged_out_player" => db_update.logged_out_player.append(logged_out_player_table::parse_table_update(table_update)?),
+    "my_player" => db_update.my_player.append(my_player_table::parse_table_update(table_update)?),
     "person" => db_update.person.append(person_table::parse_table_update(table_update)?),
     "pk_multi_identity" => db_update.pk_multi_identity.append(pk_multi_identity_table::parse_table_update(table_update)?),
     "player" => db_update.player.append(player_table::parse_table_update(table_update)?),
@@ -1634,6 +1638,7 @@ impl __sdk::DbUpdate for DbUpdate {
         diff.test_d = cache.apply_diff_to_table::<TestD>("test_d", &self.test_d);
         diff.test_e = cache.apply_diff_to_table::<TestE>("test_e", &self.test_e).with_updates_by_pk(|row| &row.id);
         diff.test_f = cache.apply_diff_to_table::<TestFoobar>("test_f", &self.test_f);
+        diff.my_player = cache.apply_diff_to_table::<Player>("my_player", &self.my_player);
 
                     diff
                 }
@@ -1645,6 +1650,7 @@ impl __sdk::DbUpdate for DbUpdate {
 pub struct AppliedDiff<'r> {
         has_special_stuff: __sdk::TableAppliedDiff<'r, HasSpecialStuff>,
     logged_out_player: __sdk::TableAppliedDiff<'r, Player>,
+    my_player: __sdk::TableAppliedDiff<'r, Player>,
     person: __sdk::TableAppliedDiff<'r, Person>,
     pk_multi_identity: __sdk::TableAppliedDiff<'r, PkMultiIdentity>,
     player: __sdk::TableAppliedDiff<'r, Player>,
@@ -1667,6 +1673,7 @@ impl<'r> __sdk::AppliedDiff<'r> for AppliedDiff<'r> {
     fn invoke_row_callbacks(&self, event: &EventContext, callbacks: &mut __sdk::DbCallbacks<RemoteModule>) {
                 callbacks.invoke_table_row_callbacks::<HasSpecialStuff>("has_special_stuff", &self.has_special_stuff, event);
         callbacks.invoke_table_row_callbacks::<Player>("logged_out_player", &self.logged_out_player, event);
+        callbacks.invoke_table_row_callbacks::<Player>("my_player", &self.my_player, event);
         callbacks.invoke_table_row_callbacks::<Person>("person", &self.person, event);
         callbacks.invoke_table_row_callbacks::<PkMultiIdentity>("pk_multi_identity", &self.pk_multi_identity, event);
         callbacks.invoke_table_row_callbacks::<Player>("player", &self.player, event);
@@ -2395,6 +2402,7 @@ impl __sdk::SpacetimeModule for RemoteModule {
 fn register_tables(client_cache: &mut __sdk::ClientCache<Self>) {
                 has_special_stuff_table::register_table(client_cache);
         logged_out_player_table::register_table(client_cache);
+        my_player_table::register_table(client_cache);
         person_table::register_table(client_cache);
         pk_multi_identity_table::register_table(client_cache);
         player_table::register_table(client_cache);
diff --git a/sdks/csharp/examples~/regression-tests/client/module_bindings/SpacetimeDBClient.g.cs b/sdks/csharp/examples~/regression-tests/client/module_bindings/SpacetimeDBClient.g.cs
index 7418a534cc3..fedbbce0396 100644
--- a/sdks/csharp/examples~/regression-tests/client/module_bindings/SpacetimeDBClient.g.cs
+++ b/sdks/csharp/examples~/regression-tests/client/module_bindings/SpacetimeDBClient.g.cs
@@ -1,7 +1,7 @@
 // THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
 // WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
 
-// This was generated using spacetimedb cli version 1.7.0 (commit f01df570c478b16793a4d3ab64fa972e270ce858).
+// This was generated using spacetimedb cli version 1.8.0 (commit 798b1c7909306e832723f507f7a3c97d6abc610d).
 
 #nullable enable
 
@@ -24,6 +24,8 @@ public sealed partial class RemoteTables : RemoteTablesBase
         public RemoteTables(DbConnection conn)
         {
             AddTable(ExampleData = new(conn));
+            AddTable(GetAnonymousExampleDataById = new(conn));
+            AddTable(GetExampleDataById = new(conn));
         }
     }
 
diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/SpacetimeDBClient.g.cpp b/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/SpacetimeDBClient.g.cpp
index 96501d29030..561421dff88 100644
--- a/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/SpacetimeDBClient.g.cpp
+++ b/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/SpacetimeDBClient.g.cpp
@@ -4,104 +4,104 @@
 #include "ModuleBindings/SpacetimeDBClient.g.h"
 #include "DBCache/WithBsatn.h"
 #include "BSATN/UEBSATNHelpers.h"
+#include "ModuleBindings/Tables/BtreeU32Table.g.h"
 #include "ModuleBindings/Tables/IndexedSimpleEnumTable.g.h"
-#include "ModuleBindings/Tables/OneU128Table.g.h"
-#include "ModuleBindings/Tables/UniqueI8Table.g.h"
-#include "ModuleBindings/Tables/UniqueU16Table.g.h"
-#include "ModuleBindings/Tables/BTreeU32Table.g.h"
 #include "ModuleBindings/Tables/IndexedTableTable.g.h"
-#include "ModuleBindings/Tables/OptionEveryPrimitiveStructTable.g.h"
-#include "ModuleBindings/Tables/UniqueI256Table.g.h"
-#include "ModuleBindings/Tables/OptionVecOptionI32Table.g.h"
-#include "ModuleBindings/Tables/UniqueU128Table.g.h"
-#include "ModuleBindings/Tables/VecI128Table.g.h"
-#include "ModuleBindings/Tables/OneByteStructTable.g.h"
-#include "ModuleBindings/Tables/VecI32Table.g.h"
-#include "ModuleBindings/Tables/PkU32Table.g.h"
-#include "ModuleBindings/Tables/PkStringTable.g.h"
-#include "ModuleBindings/Tables/PkU128Table.g.h"
-#include "ModuleBindings/Tables/VecU64Table.g.h"
 #include "ModuleBindings/Tables/IndexedTable2Table.g.h"
-#include "ModuleBindings/Tables/VecF64Table.g.h"
-#include "ModuleBindings/Tables/OneU256Table.g.h"
+#include "ModuleBindings/Tables/LargeTableTable.g.h"
+#include "ModuleBindings/Tables/OneBoolTable.g.h"
+#include "ModuleBindings/Tables/OneByteStructTable.g.h"
+#include "ModuleBindings/Tables/OneConnectionIdTable.g.h"
+#include "ModuleBindings/Tables/OneEnumWithPayloadTable.g.h"
 #include "ModuleBindings/Tables/OneEveryPrimitiveStructTable.g.h"
-#include "ModuleBindings/Tables/UniqueI128Table.g.h"
-#include "ModuleBindings/Tables/VecI64Table.g.h"
-#include "ModuleBindings/Tables/PkU8Table.g.h"
+#include "ModuleBindings/Tables/OneEveryVecStructTable.g.h"
+#include "ModuleBindings/Tables/OneF32Table.g.h"
 #include "ModuleBindings/Tables/OneF64Table.g.h"
-#include "ModuleBindings/Tables/VecU32Table.g.h"
-#include "ModuleBindings/Tables/PkI16Table.g.h"
-#include "ModuleBindings/Tables/PkI32Table.g.h"
-#include "ModuleBindings/Tables/OneU32Table.g.h"
-#include "ModuleBindings/Tables/UniqueBoolTable.g.h"
-#include "ModuleBindings/Tables/OneSimpleEnumTable.g.h"
-#include "ModuleBindings/Tables/VecI16Table.g.h"
-#include "ModuleBindings/Tables/UniqueIdentityTable.g.h"
-#include "ModuleBindings/Tables/PkU32TwoTable.g.h"
-#include "ModuleBindings/Tables/VecBoolTable.g.h"
-#include "ModuleBindings/Tables/OneEnumWithPayloadTable.g.h"
-#include "ModuleBindings/Tables/UniqueI32Table.g.h"
-#include "ModuleBindings/Tables/OneIdentityTable.g.h"
-#include "ModuleBindings/Tables/OneUnitStructTable.g.h"
-#include "ModuleBindings/Tables/UsersTable.g.h"
-#include "ModuleBindings/Tables/VecConnectionIdTable.g.h"
-#include "ModuleBindings/Tables/PkI128Table.g.h"
-#include "ModuleBindings/Tables/PkSimpleEnumTable.g.h"
-#include "ModuleBindings/Tables/PkI64Table.g.h"
 #include "ModuleBindings/Tables/OneI128Table.g.h"
-#include "ModuleBindings/Tables/PkConnectionIdTable.g.h"
 #include "ModuleBindings/Tables/OneI16Table.g.h"
-#include "ModuleBindings/Tables/LargeTableTable.g.h"
-#include "ModuleBindings/Tables/VecEnumWithPayloadTable.g.h"
-#include "ModuleBindings/Tables/OneI32Table.g.h"
-#include "ModuleBindings/Tables/VecF32Table.g.h"
-#include "ModuleBindings/Tables/UniqueConnectionIdTable.g.h"
-#include "ModuleBindings/Tables/OptionSimpleEnumTable.g.h"
-#include "ModuleBindings/Tables/VecI256Table.g.h"
-#include "ModuleBindings/Tables/VecTimestampTable.g.h"
-#include "ModuleBindings/Tables/PkI8Table.g.h"
 #include "ModuleBindings/Tables/OneI256Table.g.h"
-#include "ModuleBindings/Tables/ScheduledTableTable.g.h"
-#include "ModuleBindings/Tables/UniqueU256Table.g.h"
+#include "ModuleBindings/Tables/OneI32Table.g.h"
+#include "ModuleBindings/Tables/OneI64Table.g.h"
+#include "ModuleBindings/Tables/OneI8Table.g.h"
+#include "ModuleBindings/Tables/OneIdentityTable.g.h"
+#include "ModuleBindings/Tables/OneSimpleEnumTable.g.h"
 #include "ModuleBindings/Tables/OneStringTable.g.h"
-#include "ModuleBindings/Tables/VecU16Table.g.h"
-#include "ModuleBindings/Tables/VecU256Table.g.h"
-#include "ModuleBindings/Tables/OptionStringTable.g.h"
+#include "ModuleBindings/Tables/OneTimestampTable.g.h"
+#include "ModuleBindings/Tables/OneU128Table.g.h"
 #include "ModuleBindings/Tables/OneU16Table.g.h"
-#include "ModuleBindings/Tables/PkIdentityTable.g.h"
-#include "ModuleBindings/Tables/PkU64Table.g.h"
-#include "ModuleBindings/Tables/UniqueI16Table.g.h"
-#include "ModuleBindings/Tables/VecEveryPrimitiveStructTable.g.h"
-#include "ModuleBindings/Tables/VecU128Table.g.h"
-#include "ModuleBindings/Tables/OneI8Table.g.h"
-#include "ModuleBindings/Tables/UniqueU8Table.g.h"
-#include "ModuleBindings/Tables/VecByteStructTable.g.h"
+#include "ModuleBindings/Tables/OneU256Table.g.h"
+#include "ModuleBindings/Tables/OneU32Table.g.h"
 #include "ModuleBindings/Tables/OneU64Table.g.h"
-#include "ModuleBindings/Tables/TableHoldsTableTable.g.h"
-#include "ModuleBindings/Tables/UniqueStringTable.g.h"
-#include "ModuleBindings/Tables/OneTimestampTable.g.h"
-#include "ModuleBindings/Tables/VecSimpleEnumTable.g.h"
+#include "ModuleBindings/Tables/OneU8Table.g.h"
+#include "ModuleBindings/Tables/OneUnitStructTable.g.h"
+#include "ModuleBindings/Tables/OptionEveryPrimitiveStructTable.g.h"
 #include "ModuleBindings/Tables/OptionI32Table.g.h"
+#include "ModuleBindings/Tables/OptionIdentityTable.g.h"
+#include "ModuleBindings/Tables/OptionSimpleEnumTable.g.h"
+#include "ModuleBindings/Tables/OptionStringTable.g.h"
+#include "ModuleBindings/Tables/OptionVecOptionI32Table.g.h"
 #include "ModuleBindings/Tables/PkBoolTable.g.h"
+#include "ModuleBindings/Tables/PkConnectionIdTable.g.h"
+#include "ModuleBindings/Tables/PkI128Table.g.h"
+#include "ModuleBindings/Tables/PkI16Table.g.h"
 #include "ModuleBindings/Tables/PkI256Table.g.h"
-#include "ModuleBindings/Tables/OneEveryVecStructTable.g.h"
+#include "ModuleBindings/Tables/PkI32Table.g.h"
+#include "ModuleBindings/Tables/PkI64Table.g.h"
+#include "ModuleBindings/Tables/PkI8Table.g.h"
+#include "ModuleBindings/Tables/PkIdentityTable.g.h"
+#include "ModuleBindings/Tables/PkSimpleEnumTable.g.h"
+#include "ModuleBindings/Tables/PkStringTable.g.h"
+#include "ModuleBindings/Tables/PkU128Table.g.h"
+#include "ModuleBindings/Tables/PkU16Table.g.h"
+#include "ModuleBindings/Tables/PkU256Table.g.h"
+#include "ModuleBindings/Tables/PkU32Table.g.h"
+#include "ModuleBindings/Tables/PkU32TwoTable.g.h"
+#include "ModuleBindings/Tables/PkU64Table.g.h"
+#include "ModuleBindings/Tables/PkU8Table.g.h"
+#include "ModuleBindings/Tables/ScheduledTableTable.g.h"
+#include "ModuleBindings/Tables/TableHoldsTableTable.g.h"
+#include "ModuleBindings/Tables/UniqueBoolTable.g.h"
+#include "ModuleBindings/Tables/UniqueConnectionIdTable.g.h"
+#include "ModuleBindings/Tables/UniqueI128Table.g.h"
+#include "ModuleBindings/Tables/UniqueI16Table.g.h"
+#include "ModuleBindings/Tables/UniqueI256Table.g.h"
+#include "ModuleBindings/Tables/UniqueI32Table.g.h"
 #include "ModuleBindings/Tables/UniqueI64Table.g.h"
+#include "ModuleBindings/Tables/UniqueI8Table.g.h"
+#include "ModuleBindings/Tables/UniqueIdentityTable.g.h"
+#include "ModuleBindings/Tables/UniqueStringTable.g.h"
+#include "ModuleBindings/Tables/UniqueU128Table.g.h"
+#include "ModuleBindings/Tables/UniqueU16Table.g.h"
+#include "ModuleBindings/Tables/UniqueU256Table.g.h"
 #include "ModuleBindings/Tables/UniqueU32Table.g.h"
-#include "ModuleBindings/Tables/PkU16Table.g.h"
-#include "ModuleBindings/Tables/OneConnectionIdTable.g.h"
-#include "ModuleBindings/Tables/OneI64Table.g.h"
 #include "ModuleBindings/Tables/UniqueU64Table.g.h"
-#include "ModuleBindings/Tables/PkU256Table.g.h"
-#include "ModuleBindings/Tables/VecU8Table.g.h"
-#include "ModuleBindings/Tables/VecIdentityTable.g.h"
-#include "ModuleBindings/Tables/OneU8Table.g.h"
+#include "ModuleBindings/Tables/UniqueU8Table.g.h"
+#include "ModuleBindings/Tables/UsersTable.g.h"
+#include "ModuleBindings/Tables/VecBoolTable.g.h"
+#include "ModuleBindings/Tables/VecByteStructTable.g.h"
+#include "ModuleBindings/Tables/VecConnectionIdTable.g.h"
+#include "ModuleBindings/Tables/VecEnumWithPayloadTable.g.h"
+#include "ModuleBindings/Tables/VecEveryPrimitiveStructTable.g.h"
 #include "ModuleBindings/Tables/VecEveryVecStructTable.g.h"
-#include "ModuleBindings/Tables/VecUnitStructTable.g.h"
-#include "ModuleBindings/Tables/OneBoolTable.g.h"
-#include "ModuleBindings/Tables/VecStringTable.g.h"
-#include "ModuleBindings/Tables/OneF32Table.g.h"
-#include "ModuleBindings/Tables/OptionIdentityTable.g.h"
+#include "ModuleBindings/Tables/VecF32Table.g.h"
+#include "ModuleBindings/Tables/VecF64Table.g.h"
+#include "ModuleBindings/Tables/VecI128Table.g.h"
+#include "ModuleBindings/Tables/VecI16Table.g.h"
+#include "ModuleBindings/Tables/VecI256Table.g.h"
+#include "ModuleBindings/Tables/VecI32Table.g.h"
+#include "ModuleBindings/Tables/VecI64Table.g.h"
 #include "ModuleBindings/Tables/VecI8Table.g.h"
+#include "ModuleBindings/Tables/VecIdentityTable.g.h"
+#include "ModuleBindings/Tables/VecSimpleEnumTable.g.h"
+#include "ModuleBindings/Tables/VecStringTable.g.h"
+#include "ModuleBindings/Tables/VecTimestampTable.g.h"
+#include "ModuleBindings/Tables/VecU128Table.g.h"
+#include "ModuleBindings/Tables/VecU16Table.g.h"
+#include "ModuleBindings/Tables/VecU256Table.g.h"
+#include "ModuleBindings/Tables/VecU32Table.g.h"
+#include "ModuleBindings/Tables/VecU64Table.g.h"
+#include "ModuleBindings/Tables/VecU8Table.g.h"
+#include "ModuleBindings/Tables/VecUnitStructTable.g.h"
 
 static FReducer DecodeReducer(const FReducerEvent& Event)
 {
@@ -1201,104 +1201,104 @@ UDbConnection::UDbConnection(const FObjectInitializer& ObjectInitializer) : Supe
 	Reducers->SetCallReducerFlags = SetReducerFlags;
 	Reducers->Conn = this;
 
+	RegisterTable<FBTreeU32Type, UBtreeU32Table, FEventContext>(TEXT("btree_u32"), Db->BtreeU32);
 	RegisterTable<FIndexedSimpleEnumType, UIndexedSimpleEnumTable, FEventContext>(TEXT("indexed_simple_enum"), Db->IndexedSimpleEnum);
-	RegisterTable<FOneU128Type, UOneU128Table, FEventContext>(TEXT("one_u128"), Db->OneU128);
-	RegisterTable<FUniqueI8Type, UUniqueI8Table, FEventContext>(TEXT("unique_i8"), Db->UniqueI8);
-	RegisterTable<FUniqueU16Type, UUniqueU16Table, FEventContext>(TEXT("unique_u16"), Db->UniqueU16);
-	RegisterTable<FBTreeU32Type, UBTreeU32Table, FEventContext>(TEXT("btree_u32"), Db->BtreeU32);
 	RegisterTable<FIndexedTableType, UIndexedTableTable, FEventContext>(TEXT("indexed_table"), Db->IndexedTable);
-	RegisterTable<FOptionEveryPrimitiveStructType, UOptionEveryPrimitiveStructTable, FEventContext>(TEXT("option_every_primitive_struct"), Db->OptionEveryPrimitiveStruct);
-	RegisterTable<FUniqueI256Type, UUniqueI256Table, FEventContext>(TEXT("unique_i256"), Db->UniqueI256);
-	RegisterTable<FOptionVecOptionI32Type, UOptionVecOptionI32Table, FEventContext>(TEXT("option_vec_option_i32"), Db->OptionVecOptionI32);
-	RegisterTable<FUniqueU128Type, UUniqueU128Table, FEventContext>(TEXT("unique_u128"), Db->UniqueU128);
-	RegisterTable<FVecI128Type, UVecI128Table, FEventContext>(TEXT("vec_i128"), Db->VecI128);
-	RegisterTable<FOneByteStructType, UOneByteStructTable, FEventContext>(TEXT("one_byte_struct"), Db->OneByteStruct);
-	RegisterTable<FVecI32Type, UVecI32Table, FEventContext>(TEXT("vec_i32"), Db->VecI32);
-	RegisterTable<FPkU32Type, UPkU32Table, FEventContext>(TEXT("pk_u32"), Db->PkU32);
-	RegisterTable<FPkStringType, UPkStringTable, FEventContext>(TEXT("pk_string"), Db->PkString);
-	RegisterTable<FPkU128Type, UPkU128Table, FEventContext>(TEXT("pk_u128"), Db->PkU128);
-	RegisterTable<FVecU64Type, UVecU64Table, FEventContext>(TEXT("vec_u64"), Db->VecU64);
 	RegisterTable<FIndexedTable2Type, UIndexedTable2Table, FEventContext>(TEXT("indexed_table_2"), Db->IndexedTable2);
-	RegisterTable<FVecF64Type, UVecF64Table, FEventContext>(TEXT("vec_f64"), Db->VecF64);
-	RegisterTable<FOneU256Type, UOneU256Table, FEventContext>(TEXT("one_u256"), Db->OneU256);
+	RegisterTable<FLargeTableType, ULargeTableTable, FEventContext>(TEXT("large_table"), Db->LargeTable);
+	RegisterTable<FOneBoolType, UOneBoolTable, FEventContext>(TEXT("one_bool"), Db->OneBool);
+	RegisterTable<FOneByteStructType, UOneByteStructTable, FEventContext>(TEXT("one_byte_struct"), Db->OneByteStruct);
+	RegisterTable<FOneConnectionIdType, UOneConnectionIdTable, FEventContext>(TEXT("one_connection_id"), Db->OneConnectionId);
+	RegisterTable<FOneEnumWithPayloadType, UOneEnumWithPayloadTable, FEventContext>(TEXT("one_enum_with_payload"), Db->OneEnumWithPayload);
 	RegisterTable<FOneEveryPrimitiveStructType, UOneEveryPrimitiveStructTable, FEventContext>(TEXT("one_every_primitive_struct"), Db->OneEveryPrimitiveStruct);
-	RegisterTable<FUniqueI128Type, UUniqueI128Table, FEventContext>(TEXT("unique_i128"), Db->UniqueI128);
-	RegisterTable<FVecI64Type, UVecI64Table, FEventContext>(TEXT("vec_i64"), Db->VecI64);
-	RegisterTable<FPkU8Type, UPkU8Table, FEventContext>(TEXT("pk_u8"), Db->PkU8);
+	RegisterTable<FOneEveryVecStructType, UOneEveryVecStructTable, FEventContext>(TEXT("one_every_vec_struct"), Db->OneEveryVecStruct);
+	RegisterTable<FOneF32Type, UOneF32Table, FEventContext>(TEXT("one_f32"), Db->OneF32);
 	RegisterTable<FOneF64Type, UOneF64Table, FEventContext>(TEXT("one_f64"), Db->OneF64);
-	RegisterTable<FVecU32Type, UVecU32Table, FEventContext>(TEXT("vec_u32"), Db->VecU32);
-	RegisterTable<FPkI16Type, UPkI16Table, FEventContext>(TEXT("pk_i16"), Db->PkI16);
-	RegisterTable<FPkI32Type, UPkI32Table, FEventContext>(TEXT("pk_i32"), Db->PkI32);
-	RegisterTable<FOneU32Type, UOneU32Table, FEventContext>(TEXT("one_u32"), Db->OneU32);
-	RegisterTable<FUniqueBoolType, UUniqueBoolTable, FEventContext>(TEXT("unique_bool"), Db->UniqueBool);
-	RegisterTable<FOneSimpleEnumType, UOneSimpleEnumTable, FEventContext>(TEXT("one_simple_enum"), Db->OneSimpleEnum);
-	RegisterTable<FVecI16Type, UVecI16Table, FEventContext>(TEXT("vec_i16"), Db->VecI16);
-	RegisterTable<FUniqueIdentityType, UUniqueIdentityTable, FEventContext>(TEXT("unique_identity"), Db->UniqueIdentity);
-	RegisterTable<FPkU32TwoType, UPkU32TwoTable, FEventContext>(TEXT("pk_u32_two"), Db->PkU32Two);
-	RegisterTable<FVecBoolType, UVecBoolTable, FEventContext>(TEXT("vec_bool"), Db->VecBool);
-	RegisterTable<FOneEnumWithPayloadType, UOneEnumWithPayloadTable, FEventContext>(TEXT("one_enum_with_payload"), Db->OneEnumWithPayload);
-	RegisterTable<FUniqueI32Type, UUniqueI32Table, FEventContext>(TEXT("unique_i32"), Db->UniqueI32);
-	RegisterTable<FOneIdentityType, UOneIdentityTable, FEventContext>(TEXT("one_identity"), Db->OneIdentity);
-	RegisterTable<FOneUnitStructType, UOneUnitStructTable, FEventContext>(TEXT("one_unit_struct"), Db->OneUnitStruct);
-	RegisterTable<FUsersType, UUsersTable, FEventContext>(TEXT("users"), Db->Users);
-	RegisterTable<FVecConnectionIdType, UVecConnectionIdTable, FEventContext>(TEXT("vec_connection_id"), Db->VecConnectionId);
-	RegisterTable<FPkI128Type, UPkI128Table, FEventContext>(TEXT("pk_i128"), Db->PkI128);
-	RegisterTable<FPkSimpleEnumType, UPkSimpleEnumTable, FEventContext>(TEXT("pk_simple_enum"), Db->PkSimpleEnum);
-	RegisterTable<FPkI64Type, UPkI64Table, FEventContext>(TEXT("pk_i64"), Db->PkI64);
 	RegisterTable<FOneI128Type, UOneI128Table, FEventContext>(TEXT("one_i128"), Db->OneI128);
-	RegisterTable<FPkConnectionIdType, UPkConnectionIdTable, FEventContext>(TEXT("pk_connection_id"), Db->PkConnectionId);
 	RegisterTable<FOneI16Type, UOneI16Table, FEventContext>(TEXT("one_i16"), Db->OneI16);
-	RegisterTable<FLargeTableType, ULargeTableTable, FEventContext>(TEXT("large_table"), Db->LargeTable);
-	RegisterTable<FVecEnumWithPayloadType, UVecEnumWithPayloadTable, FEventContext>(TEXT("vec_enum_with_payload"), Db->VecEnumWithPayload);
-	RegisterTable<FOneI32Type, UOneI32Table, FEventContext>(TEXT("one_i32"), Db->OneI32);
-	RegisterTable<FVecF32Type, UVecF32Table, FEventContext>(TEXT("vec_f32"), Db->VecF32);
-	RegisterTable<FUniqueConnectionIdType, UUniqueConnectionIdTable, FEventContext>(TEXT("unique_connection_id"), Db->UniqueConnectionId);
-	RegisterTable<FOptionSimpleEnumType, UOptionSimpleEnumTable, FEventContext>(TEXT("option_simple_enum"), Db->OptionSimpleEnum);
-	RegisterTable<FVecI256Type, UVecI256Table, FEventContext>(TEXT("vec_i256"), Db->VecI256);
-	RegisterTable<FVecTimestampType, UVecTimestampTable, FEventContext>(TEXT("vec_timestamp"), Db->VecTimestamp);
-	RegisterTable<FPkI8Type, UPkI8Table, FEventContext>(TEXT("pk_i8"), Db->PkI8);
 	RegisterTable<FOneI256Type, UOneI256Table, FEventContext>(TEXT("one_i256"), Db->OneI256);
-	RegisterTable<FScheduledTableType, UScheduledTableTable, FEventContext>(TEXT("scheduled_table"), Db->ScheduledTable);
-	RegisterTable<FUniqueU256Type, UUniqueU256Table, FEventContext>(TEXT("unique_u256"), Db->UniqueU256);
+	RegisterTable<FOneI32Type, UOneI32Table, FEventContext>(TEXT("one_i32"), Db->OneI32);
+	RegisterTable<FOneI64Type, UOneI64Table, FEventContext>(TEXT("one_i64"), Db->OneI64);
+	RegisterTable<FOneI8Type, UOneI8Table, FEventContext>(TEXT("one_i8"), Db->OneI8);
+	RegisterTable<FOneIdentityType, UOneIdentityTable, FEventContext>(TEXT("one_identity"), Db->OneIdentity);
+	RegisterTable<FOneSimpleEnumType, UOneSimpleEnumTable, FEventContext>(TEXT("one_simple_enum"), Db->OneSimpleEnum);
 	RegisterTable<FOneStringType, UOneStringTable, FEventContext>(TEXT("one_string"), Db->OneString);
-	RegisterTable<FVecU16Type, UVecU16Table, FEventContext>(TEXT("vec_u16"), Db->VecU16);
-	RegisterTable<FVecU256Type, UVecU256Table, FEventContext>(TEXT("vec_u256"), Db->VecU256);
-	RegisterTable<FOptionStringType, UOptionStringTable, FEventContext>(TEXT("option_string"), Db->OptionString);
+	RegisterTable<FOneTimestampType, UOneTimestampTable, FEventContext>(TEXT("one_timestamp"), Db->OneTimestamp);
+	RegisterTable<FOneU128Type, UOneU128Table, FEventContext>(TEXT("one_u128"), Db->OneU128);
 	RegisterTable<FOneU16Type, UOneU16Table, FEventContext>(TEXT("one_u16"), Db->OneU16);
-	RegisterTable<FPkIdentityType, UPkIdentityTable, FEventContext>(TEXT("pk_identity"), Db->PkIdentity);
-	RegisterTable<FPkU64Type, UPkU64Table, FEventContext>(TEXT("pk_u64"), Db->PkU64);
-	RegisterTable<FUniqueI16Type, UUniqueI16Table, FEventContext>(TEXT("unique_i16"), Db->UniqueI16);
-	RegisterTable<FVecEveryPrimitiveStructType, UVecEveryPrimitiveStructTable, FEventContext>(TEXT("vec_every_primitive_struct"), Db->VecEveryPrimitiveStruct);
-	RegisterTable<FVecU128Type, UVecU128Table, FEventContext>(TEXT("vec_u128"), Db->VecU128);
-	RegisterTable<FOneI8Type, UOneI8Table, FEventContext>(TEXT("one_i8"), Db->OneI8);
-	RegisterTable<FUniqueU8Type, UUniqueU8Table, FEventContext>(TEXT("unique_u8"), Db->UniqueU8);
-	RegisterTable<FVecByteStructType, UVecByteStructTable, FEventContext>(TEXT("vec_byte_struct"), Db->VecByteStruct);
+	RegisterTable<FOneU256Type, UOneU256Table, FEventContext>(TEXT("one_u256"), Db->OneU256);
+	RegisterTable<FOneU32Type, UOneU32Table, FEventContext>(TEXT("one_u32"), Db->OneU32);
 	RegisterTable<FOneU64Type, UOneU64Table, FEventContext>(TEXT("one_u64"), Db->OneU64);
-	RegisterTable<FTableHoldsTableType, UTableHoldsTableTable, FEventContext>(TEXT("table_holds_table"), Db->TableHoldsTable);
-	RegisterTable<FUniqueStringType, UUniqueStringTable, FEventContext>(TEXT("unique_string"), Db->UniqueString);
-	RegisterTable<FOneTimestampType, UOneTimestampTable, FEventContext>(TEXT("one_timestamp"), Db->OneTimestamp);
-	RegisterTable<FVecSimpleEnumType, UVecSimpleEnumTable, FEventContext>(TEXT("vec_simple_enum"), Db->VecSimpleEnum);
+	RegisterTable<FOneU8Type, UOneU8Table, FEventContext>(TEXT("one_u8"), Db->OneU8);
+	RegisterTable<FOneUnitStructType, UOneUnitStructTable, FEventContext>(TEXT("one_unit_struct"), Db->OneUnitStruct);
+	RegisterTable<FOptionEveryPrimitiveStructType, UOptionEveryPrimitiveStructTable, FEventContext>(TEXT("option_every_primitive_struct"), Db->OptionEveryPrimitiveStruct);
 	RegisterTable<FOptionI32Type, UOptionI32Table, FEventContext>(TEXT("option_i32"), Db->OptionI32);
+	RegisterTable<FOptionIdentityType, UOptionIdentityTable, FEventContext>(TEXT("option_identity"), Db->OptionIdentity);
+	RegisterTable<FOptionSimpleEnumType, UOptionSimpleEnumTable, FEventContext>(TEXT("option_simple_enum"), Db->OptionSimpleEnum);
+	RegisterTable<FOptionStringType, UOptionStringTable, FEventContext>(TEXT("option_string"), Db->OptionString);
+	RegisterTable<FOptionVecOptionI32Type, UOptionVecOptionI32Table, FEventContext>(TEXT("option_vec_option_i32"), Db->OptionVecOptionI32);
 	RegisterTable<FPkBoolType, UPkBoolTable, FEventContext>(TEXT("pk_bool"), Db->PkBool);
+	RegisterTable<FPkConnectionIdType, UPkConnectionIdTable, FEventContext>(TEXT("pk_connection_id"), Db->PkConnectionId);
+	RegisterTable<FPkI128Type, UPkI128Table, FEventContext>(TEXT("pk_i128"), Db->PkI128);
+	RegisterTable<FPkI16Type, UPkI16Table, FEventContext>(TEXT("pk_i16"), Db->PkI16);
 	RegisterTable<FPkI256Type, UPkI256Table, FEventContext>(TEXT("pk_i256"), Db->PkI256);
-	RegisterTable<FOneEveryVecStructType, UOneEveryVecStructTable, FEventContext>(TEXT("one_every_vec_struct"), Db->OneEveryVecStruct);
-	RegisterTable<FUniqueI64Type, UUniqueI64Table, FEventContext>(TEXT("unique_i64"), Db->UniqueI64);
-	RegisterTable<FUniqueU32Type, UUniqueU32Table, FEventContext>(TEXT("unique_u32"), Db->UniqueU32);
-	RegisterTable<FPkU16Type, UPkU16Table, FEventContext>(TEXT("pk_u16"), Db->PkU16);
-	RegisterTable<FOneConnectionIdType, UOneConnectionIdTable, FEventContext>(TEXT("one_connection_id"), Db->OneConnectionId);
-	RegisterTable<FOneI64Type, UOneI64Table, FEventContext>(TEXT("one_i64"), Db->OneI64);
-	RegisterTable<FUniqueU64Type, UUniqueU64Table, FEventContext>(TEXT("unique_u64"), Db->UniqueU64);
-	RegisterTable<FPkU256Type, UPkU256Table, FEventContext>(TEXT("pk_u256"), Db->PkU256);
-	RegisterTable<FVecU8Type, UVecU8Table, FEventContext>(TEXT("vec_u8"), Db->VecU8);
-	RegisterTable<FVecIdentityType, UVecIdentityTable, FEventContext>(TEXT("vec_identity"), Db->VecIdentity);
-	RegisterTable<FOneU8Type, UOneU8Table, FEventContext>(TEXT("one_u8"), Db->OneU8);
+	RegisterTable<FPkI32Type, UPkI32Table, FEventContext>(TEXT("pk_i32"), Db->PkI32);
+	RegisterTable<FPkI64Type, UPkI64Table, FEventContext>(TEXT("pk_i64"), Db->PkI64);
+	RegisterTable<FPkI8Type, UPkI8Table, FEventContext>(TEXT("pk_i8"), Db->PkI8);
+	RegisterTable<FPkIdentityType, UPkIdentityTable, FEventContext>(TEXT("pk_identity"), Db->PkIdentity);
+	RegisterTable<FPkSimpleEnumType, UPkSimpleEnumTable, FEventContext>(TEXT("pk_simple_enum"), Db->PkSimpleEnum);
+	RegisterTable<FPkStringType, UPkStringTable, FEventContext>(TEXT("pk_string"), Db->PkString);
+	RegisterTable<FPkU128Type, UPkU128Table, FEventContext>(TEXT("pk_u128"), Db->PkU128);
+	RegisterTable<FPkU16Type, UPkU16Table, FEventContext>(TEXT("pk_u16"), Db->PkU16);
+	RegisterTable<FPkU256Type, UPkU256Table, FEventContext>(TEXT("pk_u256"), Db->PkU256);
+	RegisterTable<FPkU32Type, UPkU32Table, FEventContext>(TEXT("pk_u32"), Db->PkU32);
+	RegisterTable<FPkU32TwoType, UPkU32TwoTable, FEventContext>(TEXT("pk_u32_two"), Db->PkU32Two);
+	RegisterTable<FPkU64Type, UPkU64Table, FEventContext>(TEXT("pk_u64"), Db->PkU64);
+	RegisterTable<FPkU8Type, UPkU8Table, FEventContext>(TEXT("pk_u8"), Db->PkU8);
+	RegisterTable<FScheduledTableType, UScheduledTableTable, FEventContext>(TEXT("scheduled_table"), Db->ScheduledTable);
+	RegisterTable<FTableHoldsTableType, UTableHoldsTableTable, FEventContext>(TEXT("table_holds_table"), Db->TableHoldsTable);
+	RegisterTable<FUniqueBoolType, UUniqueBoolTable, FEventContext>(TEXT("unique_bool"), Db->UniqueBool);
+	RegisterTable<FUniqueConnectionIdType, UUniqueConnectionIdTable, FEventContext>(TEXT("unique_connection_id"), Db->UniqueConnectionId);
+	RegisterTable<FUniqueI128Type, UUniqueI128Table, FEventContext>(TEXT("unique_i128"), Db->UniqueI128);
+	RegisterTable<FUniqueI16Type, UUniqueI16Table, FEventContext>(TEXT("unique_i16"), Db->UniqueI16);
+	RegisterTable<FUniqueI256Type, UUniqueI256Table, FEventContext>(TEXT("unique_i256"), Db->UniqueI256);
+	RegisterTable<FUniqueI32Type, UUniqueI32Table, FEventContext>(TEXT("unique_i32"), Db->UniqueI32);
+	RegisterTable<FUniqueI64Type, UUniqueI64Table, FEventContext>(TEXT("unique_i64"), Db->UniqueI64);
+	RegisterTable<FUniqueI8Type, UUniqueI8Table, FEventContext>(TEXT("unique_i8"), Db->UniqueI8);
+	RegisterTable<FUniqueIdentityType, UUniqueIdentityTable, FEventContext>(TEXT("unique_identity"), Db->UniqueIdentity);
+	RegisterTable<FUniqueStringType, UUniqueStringTable, FEventContext>(TEXT("unique_string"), Db->UniqueString);
+	RegisterTable<FUniqueU128Type, UUniqueU128Table, FEventContext>(TEXT("unique_u128"), Db->UniqueU128);
+	RegisterTable<FUniqueU16Type, UUniqueU16Table, FEventContext>(TEXT("unique_u16"), Db->UniqueU16);
+	RegisterTable<FUniqueU256Type, UUniqueU256Table, FEventContext>(TEXT("unique_u256"), Db->UniqueU256);
+	RegisterTable<FUniqueU32Type, UUniqueU32Table, FEventContext>(TEXT("unique_u32"), Db->UniqueU32);
+	RegisterTable<FUniqueU64Type, UUniqueU64Table, FEventContext>(TEXT("unique_u64"), Db->UniqueU64);
+	RegisterTable<FUniqueU8Type, UUniqueU8Table, FEventContext>(TEXT("unique_u8"), Db->UniqueU8);
+	RegisterTable<FUsersType, UUsersTable, FEventContext>(TEXT("users"), Db->Users);
+	RegisterTable<FVecBoolType, UVecBoolTable, FEventContext>(TEXT("vec_bool"), Db->VecBool);
+	RegisterTable<FVecByteStructType, UVecByteStructTable, FEventContext>(TEXT("vec_byte_struct"), Db->VecByteStruct);
+	RegisterTable<FVecConnectionIdType, UVecConnectionIdTable, FEventContext>(TEXT("vec_connection_id"), Db->VecConnectionId);
+	RegisterTable<FVecEnumWithPayloadType, UVecEnumWithPayloadTable, FEventContext>(TEXT("vec_enum_with_payload"), Db->VecEnumWithPayload);
+	RegisterTable<FVecEveryPrimitiveStructType, UVecEveryPrimitiveStructTable, FEventContext>(TEXT("vec_every_primitive_struct"), Db->VecEveryPrimitiveStruct);
 	RegisterTable<FVecEveryVecStructType, UVecEveryVecStructTable, FEventContext>(TEXT("vec_every_vec_struct"), Db->VecEveryVecStruct);
-	RegisterTable<FVecUnitStructType, UVecUnitStructTable, FEventContext>(TEXT("vec_unit_struct"), Db->VecUnitStruct);
-	RegisterTable<FOneBoolType, UOneBoolTable, FEventContext>(TEXT("one_bool"), Db->OneBool);
-	RegisterTable<FVecStringType, UVecStringTable, FEventContext>(TEXT("vec_string"), Db->VecString);
-	RegisterTable<FOneF32Type, UOneF32Table, FEventContext>(TEXT("one_f32"), Db->OneF32);
-	RegisterTable<FOptionIdentityType, UOptionIdentityTable, FEventContext>(TEXT("option_identity"), Db->OptionIdentity);
+	RegisterTable<FVecF32Type, UVecF32Table, FEventContext>(TEXT("vec_f32"), Db->VecF32);
+	RegisterTable<FVecF64Type, UVecF64Table, FEventContext>(TEXT("vec_f64"), Db->VecF64);
+	RegisterTable<FVecI128Type, UVecI128Table, FEventContext>(TEXT("vec_i128"), Db->VecI128);
+	RegisterTable<FVecI16Type, UVecI16Table, FEventContext>(TEXT("vec_i16"), Db->VecI16);
+	RegisterTable<FVecI256Type, UVecI256Table, FEventContext>(TEXT("vec_i256"), Db->VecI256);
+	RegisterTable<FVecI32Type, UVecI32Table, FEventContext>(TEXT("vec_i32"), Db->VecI32);
+	RegisterTable<FVecI64Type, UVecI64Table, FEventContext>(TEXT("vec_i64"), Db->VecI64);
 	RegisterTable<FVecI8Type, UVecI8Table, FEventContext>(TEXT("vec_i8"), Db->VecI8);
+	RegisterTable<FVecIdentityType, UVecIdentityTable, FEventContext>(TEXT("vec_identity"), Db->VecIdentity);
+	RegisterTable<FVecSimpleEnumType, UVecSimpleEnumTable, FEventContext>(TEXT("vec_simple_enum"), Db->VecSimpleEnum);
+	RegisterTable<FVecStringType, UVecStringTable, FEventContext>(TEXT("vec_string"), Db->VecString);
+	RegisterTable<FVecTimestampType, UVecTimestampTable, FEventContext>(TEXT("vec_timestamp"), Db->VecTimestamp);
+	RegisterTable<FVecU128Type, UVecU128Table, FEventContext>(TEXT("vec_u128"), Db->VecU128);
+	RegisterTable<FVecU16Type, UVecU16Table, FEventContext>(TEXT("vec_u16"), Db->VecU16);
+	RegisterTable<FVecU256Type, UVecU256Table, FEventContext>(TEXT("vec_u256"), Db->VecU256);
+	RegisterTable<FVecU32Type, UVecU32Table, FEventContext>(TEXT("vec_u32"), Db->VecU32);
+	RegisterTable<FVecU64Type, UVecU64Table, FEventContext>(TEXT("vec_u64"), Db->VecU64);
+	RegisterTable<FVecU8Type, UVecU8Table, FEventContext>(TEXT("vec_u8"), Db->VecU8);
+	RegisterTable<FVecUnitStructType, UVecUnitStructTable, FEventContext>(TEXT("vec_unit_struct"), Db->VecUnitStruct);
 }
 
 FContextBase::FContextBase(UDbConnection* InConn)
@@ -1333,205 +1333,205 @@ void URemoteTables::Initialize()
 {
 
 	/** Creating tables */
+	BtreeU32 = NewObject<UBtreeU32Table>(this);
 	IndexedSimpleEnum = NewObject<UIndexedSimpleEnumTable>(this);
-	OneU128 = NewObject<UOneU128Table>(this);
-	UniqueI8 = NewObject<UUniqueI8Table>(this);
-	UniqueU16 = NewObject<UUniqueU16Table>(this);
-	BtreeU32 = NewObject<UBTreeU32Table>(this);
 	IndexedTable = NewObject<UIndexedTableTable>(this);
-	OptionEveryPrimitiveStruct = NewObject<UOptionEveryPrimitiveStructTable>(this);
-	UniqueI256 = NewObject<UUniqueI256Table>(this);
-	OptionVecOptionI32 = NewObject<UOptionVecOptionI32Table>(this);
-	UniqueU128 = NewObject<UUniqueU128Table>(this);
-	VecI128 = NewObject<UVecI128Table>(this);
-	OneByteStruct = NewObject<UOneByteStructTable>(this);
-	VecI32 = NewObject<UVecI32Table>(this);
-	PkU32 = NewObject<UPkU32Table>(this);
-	PkString = NewObject<UPkStringTable>(this);
-	PkU128 = NewObject<UPkU128Table>(this);
-	VecU64 = NewObject<UVecU64Table>(this);
 	IndexedTable2 = NewObject<UIndexedTable2Table>(this);
-	VecF64 = NewObject<UVecF64Table>(this);
-	OneU256 = NewObject<UOneU256Table>(this);
+	LargeTable = NewObject<ULargeTableTable>(this);
+	OneBool = NewObject<UOneBoolTable>(this);
+	OneByteStruct = NewObject<UOneByteStructTable>(this);
+	OneConnectionId = NewObject<UOneConnectionIdTable>(this);
+	OneEnumWithPayload = NewObject<UOneEnumWithPayloadTable>(this);
 	OneEveryPrimitiveStruct = NewObject<UOneEveryPrimitiveStructTable>(this);
-	UniqueI128 = NewObject<UUniqueI128Table>(this);
-	VecI64 = NewObject<UVecI64Table>(this);
-	PkU8 = NewObject<UPkU8Table>(this);
+	OneEveryVecStruct = NewObject<UOneEveryVecStructTable>(this);
+	OneF32 = NewObject<UOneF32Table>(this);
 	OneF64 = NewObject<UOneF64Table>(this);
-	VecU32 = NewObject<UVecU32Table>(this);
-	PkI16 = NewObject<UPkI16Table>(this);
-	PkI32 = NewObject<UPkI32Table>(this);
-	OneU32 = NewObject<UOneU32Table>(this);
-	UniqueBool = NewObject<UUniqueBoolTable>(this);
-	OneSimpleEnum = NewObject<UOneSimpleEnumTable>(this);
-	VecI16 = NewObject<UVecI16Table>(this);
-	UniqueIdentity = NewObject<UUniqueIdentityTable>(this);
-	PkU32Two = NewObject<UPkU32TwoTable>(this);
-	VecBool = NewObject<UVecBoolTable>(this);
-	OneEnumWithPayload = NewObject<UOneEnumWithPayloadTable>(this);
-	UniqueI32 = NewObject<UUniqueI32Table>(this);
-	OneIdentity = NewObject<UOneIdentityTable>(this);
-	OneUnitStruct = NewObject<UOneUnitStructTable>(this);
-	Users = NewObject<UUsersTable>(this);
-	VecConnectionId = NewObject<UVecConnectionIdTable>(this);
-	PkI128 = NewObject<UPkI128Table>(this);
-	PkSimpleEnum = NewObject<UPkSimpleEnumTable>(this);
-	PkI64 = NewObject<UPkI64Table>(this);
 	OneI128 = NewObject<UOneI128Table>(this);
-	PkConnectionId = NewObject<UPkConnectionIdTable>(this);
 	OneI16 = NewObject<UOneI16Table>(this);
-	LargeTable = NewObject<ULargeTableTable>(this);
-	VecEnumWithPayload = NewObject<UVecEnumWithPayloadTable>(this);
-	OneI32 = NewObject<UOneI32Table>(this);
-	VecF32 = NewObject<UVecF32Table>(this);
-	UniqueConnectionId = NewObject<UUniqueConnectionIdTable>(this);
-	OptionSimpleEnum = NewObject<UOptionSimpleEnumTable>(this);
-	VecI256 = NewObject<UVecI256Table>(this);
-	VecTimestamp = NewObject<UVecTimestampTable>(this);
-	PkI8 = NewObject<UPkI8Table>(this);
 	OneI256 = NewObject<UOneI256Table>(this);
-	ScheduledTable = NewObject<UScheduledTableTable>(this);
-	UniqueU256 = NewObject<UUniqueU256Table>(this);
+	OneI32 = NewObject<UOneI32Table>(this);
+	OneI64 = NewObject<UOneI64Table>(this);
+	OneI8 = NewObject<UOneI8Table>(this);
+	OneIdentity = NewObject<UOneIdentityTable>(this);
+	OneSimpleEnum = NewObject<UOneSimpleEnumTable>(this);
 	OneString = NewObject<UOneStringTable>(this);
-	VecU16 = NewObject<UVecU16Table>(this);
-	VecU256 = NewObject<UVecU256Table>(this);
-	OptionString = NewObject<UOptionStringTable>(this);
+	OneTimestamp = NewObject<UOneTimestampTable>(this);
+	OneU128 = NewObject<UOneU128Table>(this);
 	OneU16 = NewObject<UOneU16Table>(this);
-	PkIdentity = NewObject<UPkIdentityTable>(this);
-	PkU64 = NewObject<UPkU64Table>(this);
-	UniqueI16 = NewObject<UUniqueI16Table>(this);
-	VecEveryPrimitiveStruct = NewObject<UVecEveryPrimitiveStructTable>(this);
-	VecU128 = NewObject<UVecU128Table>(this);
-	OneI8 = NewObject<UOneI8Table>(this);
-	UniqueU8 = NewObject<UUniqueU8Table>(this);
-	VecByteStruct = NewObject<UVecByteStructTable>(this);
+	OneU256 = NewObject<UOneU256Table>(this);
+	OneU32 = NewObject<UOneU32Table>(this);
 	OneU64 = NewObject<UOneU64Table>(this);
-	TableHoldsTable = NewObject<UTableHoldsTableTable>(this);
-	UniqueString = NewObject<UUniqueStringTable>(this);
-	OneTimestamp = NewObject<UOneTimestampTable>(this);
-	VecSimpleEnum = NewObject<UVecSimpleEnumTable>(this);
+	OneU8 = NewObject<UOneU8Table>(this);
+	OneUnitStruct = NewObject<UOneUnitStructTable>(this);
+	OptionEveryPrimitiveStruct = NewObject<UOptionEveryPrimitiveStructTable>(this);
 	OptionI32 = NewObject<UOptionI32Table>(this);
+	OptionIdentity = NewObject<UOptionIdentityTable>(this);
+	OptionSimpleEnum = NewObject<UOptionSimpleEnumTable>(this);
+	OptionString = NewObject<UOptionStringTable>(this);
+	OptionVecOptionI32 = NewObject<UOptionVecOptionI32Table>(this);
 	PkBool = NewObject<UPkBoolTable>(this);
+	PkConnectionId = NewObject<UPkConnectionIdTable>(this);
+	PkI128 = NewObject<UPkI128Table>(this);
+	PkI16 = NewObject<UPkI16Table>(this);
 	PkI256 = NewObject<UPkI256Table>(this);
-	OneEveryVecStruct = NewObject<UOneEveryVecStructTable>(this);
+	PkI32 = NewObject<UPkI32Table>(this);
+	PkI64 = NewObject<UPkI64Table>(this);
+	PkI8 = NewObject<UPkI8Table>(this);
+	PkIdentity = NewObject<UPkIdentityTable>(this);
+	PkSimpleEnum = NewObject<UPkSimpleEnumTable>(this);
+	PkString = NewObject<UPkStringTable>(this);
+	PkU128 = NewObject<UPkU128Table>(this);
+	PkU16 = NewObject<UPkU16Table>(this);
+	PkU256 = NewObject<UPkU256Table>(this);
+	PkU32 = NewObject<UPkU32Table>(this);
+	PkU32Two = NewObject<UPkU32TwoTable>(this);
+	PkU64 = NewObject<UPkU64Table>(this);
+	PkU8 = NewObject<UPkU8Table>(this);
+	ScheduledTable = NewObject<UScheduledTableTable>(this);
+	TableHoldsTable = NewObject<UTableHoldsTableTable>(this);
+	UniqueBool = NewObject<UUniqueBoolTable>(this);
+	UniqueConnectionId = NewObject<UUniqueConnectionIdTable>(this);
+	UniqueI128 = NewObject<UUniqueI128Table>(this);
+	UniqueI16 = NewObject<UUniqueI16Table>(this);
+	UniqueI256 = NewObject<UUniqueI256Table>(this);
+	UniqueI32 = NewObject<UUniqueI32Table>(this);
 	UniqueI64 = NewObject<UUniqueI64Table>(this);
+	UniqueI8 = NewObject<UUniqueI8Table>(this);
+	UniqueIdentity = NewObject<UUniqueIdentityTable>(this);
+	UniqueString = NewObject<UUniqueStringTable>(this);
+	UniqueU128 = NewObject<UUniqueU128Table>(this);
+	UniqueU16 = NewObject<UUniqueU16Table>(this);
+	UniqueU256 = NewObject<UUniqueU256Table>(this);
 	UniqueU32 = NewObject<UUniqueU32Table>(this);
-	PkU16 = NewObject<UPkU16Table>(this);
-	OneConnectionId = NewObject<UOneConnectionIdTable>(this);
-	OneI64 = NewObject<UOneI64Table>(this);
 	UniqueU64 = NewObject<UUniqueU64Table>(this);
-	PkU256 = NewObject<UPkU256Table>(this);
-	VecU8 = NewObject<UVecU8Table>(this);
-	VecIdentity = NewObject<UVecIdentityTable>(this);
-	OneU8 = NewObject<UOneU8Table>(this);
+	UniqueU8 = NewObject<UUniqueU8Table>(this);
+	Users = NewObject<UUsersTable>(this);
+	VecBool = NewObject<UVecBoolTable>(this);
+	VecByteStruct = NewObject<UVecByteStructTable>(this);
+	VecConnectionId = NewObject<UVecConnectionIdTable>(this);
+	VecEnumWithPayload = NewObject<UVecEnumWithPayloadTable>(this);
+	VecEveryPrimitiveStruct = NewObject<UVecEveryPrimitiveStructTable>(this);
 	VecEveryVecStruct = NewObject<UVecEveryVecStructTable>(this);
-	VecUnitStruct = NewObject<UVecUnitStructTable>(this);
-	OneBool = NewObject<UOneBoolTable>(this);
-	VecString = NewObject<UVecStringTable>(this);
-	OneF32 = NewObject<UOneF32Table>(this);
-	OptionIdentity = NewObject<UOptionIdentityTable>(this);
+	VecF32 = NewObject<UVecF32Table>(this);
+	VecF64 = NewObject<UVecF64Table>(this);
+	VecI128 = NewObject<UVecI128Table>(this);
+	VecI16 = NewObject<UVecI16Table>(this);
+	VecI256 = NewObject<UVecI256Table>(this);
+	VecI32 = NewObject<UVecI32Table>(this);
+	VecI64 = NewObject<UVecI64Table>(this);
 	VecI8 = NewObject<UVecI8Table>(this);
+	VecIdentity = NewObject<UVecIdentityTable>(this);
+	VecSimpleEnum = NewObject<UVecSimpleEnumTable>(this);
+	VecString = NewObject<UVecStringTable>(this);
+	VecTimestamp = NewObject<UVecTimestampTable>(this);
+	VecU128 = NewObject<UVecU128Table>(this);
+	VecU16 = NewObject<UVecU16Table>(this);
+	VecU256 = NewObject<UVecU256Table>(this);
+	VecU32 = NewObject<UVecU32Table>(this);
+	VecU64 = NewObject<UVecU64Table>(this);
+	VecU8 = NewObject<UVecU8Table>(this);
+	VecUnitStruct = NewObject<UVecUnitStructTable>(this);
 	/**/
 
 	/** Initialization */
-	IndexedSimpleEnum->PostInitialize();
-	OneU128->PostInitialize();
-	UniqueI8->PostInitialize();
-	UniqueU16->PostInitialize();
 	BtreeU32->PostInitialize();
+	IndexedSimpleEnum->PostInitialize();
 	IndexedTable->PostInitialize();
-	OptionEveryPrimitiveStruct->PostInitialize();
-	UniqueI256->PostInitialize();
-	OptionVecOptionI32->PostInitialize();
-	UniqueU128->PostInitialize();
-	VecI128->PostInitialize();
-	OneByteStruct->PostInitialize();
-	VecI32->PostInitialize();
-	PkU32->PostInitialize();
-	PkString->PostInitialize();
-	PkU128->PostInitialize();
-	VecU64->PostInitialize();
 	IndexedTable2->PostInitialize();
-	VecF64->PostInitialize();
-	OneU256->PostInitialize();
+	LargeTable->PostInitialize();
+	OneBool->PostInitialize();
+	OneByteStruct->PostInitialize();
+	OneConnectionId->PostInitialize();
+	OneEnumWithPayload->PostInitialize();
 	OneEveryPrimitiveStruct->PostInitialize();
-	UniqueI128->PostInitialize();
-	VecI64->PostInitialize();
-	PkU8->PostInitialize();
+	OneEveryVecStruct->PostInitialize();
+	OneF32->PostInitialize();
 	OneF64->PostInitialize();
-	VecU32->PostInitialize();
-	PkI16->PostInitialize();
-	PkI32->PostInitialize();
-	OneU32->PostInitialize();
-	UniqueBool->PostInitialize();
-	OneSimpleEnum->PostInitialize();
-	VecI16->PostInitialize();
-	UniqueIdentity->PostInitialize();
-	PkU32Two->PostInitialize();
-	VecBool->PostInitialize();
-	OneEnumWithPayload->PostInitialize();
-	UniqueI32->PostInitialize();
-	OneIdentity->PostInitialize();
-	OneUnitStruct->PostInitialize();
-	Users->PostInitialize();
-	VecConnectionId->PostInitialize();
-	PkI128->PostInitialize();
-	PkSimpleEnum->PostInitialize();
-	PkI64->PostInitialize();
 	OneI128->PostInitialize();
-	PkConnectionId->PostInitialize();
 	OneI16->PostInitialize();
-	LargeTable->PostInitialize();
-	VecEnumWithPayload->PostInitialize();
-	OneI32->PostInitialize();
-	VecF32->PostInitialize();
-	UniqueConnectionId->PostInitialize();
-	OptionSimpleEnum->PostInitialize();
-	VecI256->PostInitialize();
-	VecTimestamp->PostInitialize();
-	PkI8->PostInitialize();
 	OneI256->PostInitialize();
-	ScheduledTable->PostInitialize();
-	UniqueU256->PostInitialize();
+	OneI32->PostInitialize();
+	OneI64->PostInitialize();
+	OneI8->PostInitialize();
+	OneIdentity->PostInitialize();
+	OneSimpleEnum->PostInitialize();
 	OneString->PostInitialize();
-	VecU16->PostInitialize();
-	VecU256->PostInitialize();
-	OptionString->PostInitialize();
+	OneTimestamp->PostInitialize();
+	OneU128->PostInitialize();
 	OneU16->PostInitialize();
-	PkIdentity->PostInitialize();
-	PkU64->PostInitialize();
-	UniqueI16->PostInitialize();
-	VecEveryPrimitiveStruct->PostInitialize();
-	VecU128->PostInitialize();
-	OneI8->PostInitialize();
-	UniqueU8->PostInitialize();
-	VecByteStruct->PostInitialize();
+	OneU256->PostInitialize();
+	OneU32->PostInitialize();
 	OneU64->PostInitialize();
-	TableHoldsTable->PostInitialize();
-	UniqueString->PostInitialize();
-	OneTimestamp->PostInitialize();
-	VecSimpleEnum->PostInitialize();
+	OneU8->PostInitialize();
+	OneUnitStruct->PostInitialize();
+	OptionEveryPrimitiveStruct->PostInitialize();
 	OptionI32->PostInitialize();
+	OptionIdentity->PostInitialize();
+	OptionSimpleEnum->PostInitialize();
+	OptionString->PostInitialize();
+	OptionVecOptionI32->PostInitialize();
 	PkBool->PostInitialize();
+	PkConnectionId->PostInitialize();
+	PkI128->PostInitialize();
+	PkI16->PostInitialize();
 	PkI256->PostInitialize();
-	OneEveryVecStruct->PostInitialize();
+	PkI32->PostInitialize();
+	PkI64->PostInitialize();
+	PkI8->PostInitialize();
+	PkIdentity->PostInitialize();
+	PkSimpleEnum->PostInitialize();
+	PkString->PostInitialize();
+	PkU128->PostInitialize();
+	PkU16->PostInitialize();
+	PkU256->PostInitialize();
+	PkU32->PostInitialize();
+	PkU32Two->PostInitialize();
+	PkU64->PostInitialize();
+	PkU8->PostInitialize();
+	ScheduledTable->PostInitialize();
+	TableHoldsTable->PostInitialize();
+	UniqueBool->PostInitialize();
+	UniqueConnectionId->PostInitialize();
+	UniqueI128->PostInitialize();
+	UniqueI16->PostInitialize();
+	UniqueI256->PostInitialize();
+	UniqueI32->PostInitialize();
 	UniqueI64->PostInitialize();
+	UniqueI8->PostInitialize();
+	UniqueIdentity->PostInitialize();
+	UniqueString->PostInitialize();
+	UniqueU128->PostInitialize();
+	UniqueU16->PostInitialize();
+	UniqueU256->PostInitialize();
 	UniqueU32->PostInitialize();
-	PkU16->PostInitialize();
-	OneConnectionId->PostInitialize();
-	OneI64->PostInitialize();
 	UniqueU64->PostInitialize();
-	PkU256->PostInitialize();
-	VecU8->PostInitialize();
-	VecIdentity->PostInitialize();
-	OneU8->PostInitialize();
+	UniqueU8->PostInitialize();
+	Users->PostInitialize();
+	VecBool->PostInitialize();
+	VecByteStruct->PostInitialize();
+	VecConnectionId->PostInitialize();
+	VecEnumWithPayload->PostInitialize();
+	VecEveryPrimitiveStruct->PostInitialize();
 	VecEveryVecStruct->PostInitialize();
-	VecUnitStruct->PostInitialize();
-	OneBool->PostInitialize();
-	VecString->PostInitialize();
-	OneF32->PostInitialize();
-	OptionIdentity->PostInitialize();
+	VecF32->PostInitialize();
+	VecF64->PostInitialize();
+	VecI128->PostInitialize();
+	VecI16->PostInitialize();
+	VecI256->PostInitialize();
+	VecI32->PostInitialize();
+	VecI64->PostInitialize();
 	VecI8->PostInitialize();
+	VecIdentity->PostInitialize();
+	VecSimpleEnum->PostInitialize();
+	VecString->PostInitialize();
+	VecTimestamp->PostInitialize();
+	VecU128->PostInitialize();
+	VecU16->PostInitialize();
+	VecU256->PostInitialize();
+	VecU32->PostInitialize();
+	VecU64->PostInitialize();
+	VecU8->PostInitialize();
+	VecUnitStruct->PostInitialize();
 	/**/
 }
 
diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/BTreeU32Table.g.cpp b/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/BTreeU32Table.g.cpp
index fe165e85c76..08f72ea396a 100644
--- a/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/BTreeU32Table.g.cpp
+++ b/sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/BTreeU32Table.g.cpp
@@ -1,21 +1,21 @@
 // THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
 // WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
 
-#include "ModuleBindings/Tables/BTreeU32Table.g.h"
+#include "ModuleBindings/Tables/BtreeU32Table.g.h"
 #include "DBCache/UniqueIndex.h"
 #include "DBCache/BTreeUniqueIndex.h"
 #include "DBCache/ClientCache.h"
 #include "DBCache/TableCache.h"
 
-void UBTreeU32Table::PostInitialize()
+void UBtreeU32Table::PostInitialize()
 {
     /** Client cache init and setting up indexes*/
     Data = MakeShared<UClientCache<FBTreeU32Type>>();
 
-    TSharedPtr<FTableCache<FBTreeU32Type>> BTreeU32Table = Data->GetOrAdd(TableName);
+    TSharedPtr<FTableCache<FBTreeU32Type>> BtreeU32Table = Data->GetOrAdd(TableName);
 
-    // Register a new multi-key B-Tree index named "n" on the BTreeU32Table.
-    BTreeU32Table->AddMultiKeyBTreeIndex<TTuple<uint32>>(
+    // Register a new multi-key B-Tree index named "n" on the BtreeU32Table.
+    BtreeU32Table->AddMultiKeyBTreeIndex<TTuple<uint32>>(
         TEXT("n"),
         [](const FBTreeU32Type& Row)
         {
@@ -24,25 +24,25 @@ void UBTreeU32Table::PostInitialize()
         }
     );
 
-    N = NewObject<UBTreeU32NIndex>(this);
-    N->SetCache(BTreeU32Table);
+    N = NewObject<UBtreeU32NIndex>(this);
+    N->SetCache(BtreeU32Table);
 
     /***/
 }
 
-FTableAppliedDiff<FBTreeU32Type> UBTreeU32Table::Update(TArray<FWithBsatn<FBTreeU32Type>> InsertsRef, TArray<FWithBsatn<FBTreeU32Type>> DeletesRef)
+FTableAppliedDiff<FBTreeU32Type> UBtreeU32Table::Update(TArray<FWithBsatn<FBTreeU32Type>> InsertsRef, TArray<FWithBsatn<FBTreeU32Type>> DeletesRef)
 {
     FTableAppliedDiff<FBTreeU32Type> Diff = BaseUpdate<FBTreeU32Type>(InsertsRef, DeletesRef, Data, TableName);
 
     return Diff;
 }
 
-int32 UBTreeU32Table::Count() const
+int32 UBtreeU32Table::Count() const
 {
     return GetRowCountFromTable<FBTreeU32Type>(Data, TableName);
 }
 
-TArray<FBTreeU32Type> UBTreeU32Table::Iter() const
+TArray<FBTreeU32Type> UBtreeU32Table::Iter() const
 {
     return GetAllRowsFromTable<FBTreeU32Type>(Data, TableName);
 }
diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/SpacetimeDBClient.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/SpacetimeDBClient.g.h
index 929f0949693..bedf69ae1cf 100644
--- a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/SpacetimeDBClient.g.h
+++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/SpacetimeDBClient.g.h
@@ -1,7 +1,7 @@
 // THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
 // WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
 
-// This was generated using spacetimedb cli version 1.5.0 (commit 4a57de1003025dd579c6e22bb49bd56e2aa27ff2).
+// This was generated using spacetimedb cli version 1.8.0 (commit 456d746afb312fab586b9d6b26db11f040a0d94e).
 
 #pragma once
 #include "CoreMinimal.h"
@@ -221,7 +221,7 @@ class USubscriptionBuilder;
 class USubscriptionHandle;
 
 /** Forward declaration for tables */
-class UBTreeU32Table;
+class UBtreeU32Table;
 class UIndexedSimpleEnumTable;
 class UIndexedTableTable;
 class UIndexedTable2Table;
@@ -6888,298 +6888,298 @@ class TESTCLIENT_API URemoteTables : public UObject
     void Initialize();
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UIndexedSimpleEnumTable* IndexedSimpleEnum;
+    UBtreeU32Table* BtreeU32;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UOneU128Table* OneU128;
+    UIndexedSimpleEnumTable* IndexedSimpleEnum;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UUniqueI8Table* UniqueI8;
+    UIndexedTableTable* IndexedTable;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UUniqueU16Table* UniqueU16;
+    UIndexedTable2Table* IndexedTable2;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UBTreeU32Table* BtreeU32;
+    ULargeTableTable* LargeTable;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UIndexedTableTable* IndexedTable;
+    UOneBoolTable* OneBool;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UOptionEveryPrimitiveStructTable* OptionEveryPrimitiveStruct;
+    UOneByteStructTable* OneByteStruct;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UUniqueI256Table* UniqueI256;
+    UOneConnectionIdTable* OneConnectionId;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UOptionVecOptionI32Table* OptionVecOptionI32;
+    UOneEnumWithPayloadTable* OneEnumWithPayload;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UUniqueU128Table* UniqueU128;
+    UOneEveryPrimitiveStructTable* OneEveryPrimitiveStruct;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UVecI128Table* VecI128;
+    UOneEveryVecStructTable* OneEveryVecStruct;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UOneByteStructTable* OneByteStruct;
+    UOneF32Table* OneF32;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UVecI32Table* VecI32;
+    UOneF64Table* OneF64;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UPkU32Table* PkU32;
+    UOneI128Table* OneI128;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UPkStringTable* PkString;
+    UOneI16Table* OneI16;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UPkU128Table* PkU128;
+    UOneI256Table* OneI256;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UVecU64Table* VecU64;
+    UOneI32Table* OneI32;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UIndexedTable2Table* IndexedTable2;
+    UOneI64Table* OneI64;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UVecF64Table* VecF64;
+    UOneI8Table* OneI8;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UOneU256Table* OneU256;
+    UOneIdentityTable* OneIdentity;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UOneEveryPrimitiveStructTable* OneEveryPrimitiveStruct;
+    UOneSimpleEnumTable* OneSimpleEnum;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UUniqueI128Table* UniqueI128;
+    UOneStringTable* OneString;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UVecI64Table* VecI64;
+    UOneTimestampTable* OneTimestamp;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UPkU8Table* PkU8;
+    UOneU128Table* OneU128;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UOneF64Table* OneF64;
+    UOneU16Table* OneU16;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UVecU32Table* VecU32;
+    UOneU256Table* OneU256;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UPkI16Table* PkI16;
+    UOneU32Table* OneU32;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UPkI32Table* PkI32;
+    UOneU64Table* OneU64;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UOneU32Table* OneU32;
+    UOneU8Table* OneU8;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UUniqueBoolTable* UniqueBool;
+    UOneUnitStructTable* OneUnitStruct;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UOneSimpleEnumTable* OneSimpleEnum;
+    UOptionEveryPrimitiveStructTable* OptionEveryPrimitiveStruct;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UVecI16Table* VecI16;
+    UOptionI32Table* OptionI32;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UUniqueIdentityTable* UniqueIdentity;
+    UOptionIdentityTable* OptionIdentity;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UPkU32TwoTable* PkU32Two;
+    UOptionSimpleEnumTable* OptionSimpleEnum;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UVecBoolTable* VecBool;
+    UOptionStringTable* OptionString;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UOneEnumWithPayloadTable* OneEnumWithPayload;
+    UOptionVecOptionI32Table* OptionVecOptionI32;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UUniqueI32Table* UniqueI32;
+    UPkBoolTable* PkBool;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UOneIdentityTable* OneIdentity;
+    UPkConnectionIdTable* PkConnectionId;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UOneUnitStructTable* OneUnitStruct;
+    UPkI128Table* PkI128;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UUsersTable* Users;
+    UPkI16Table* PkI16;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UVecConnectionIdTable* VecConnectionId;
+    UPkI256Table* PkI256;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UPkI128Table* PkI128;
+    UPkI32Table* PkI32;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UPkSimpleEnumTable* PkSimpleEnum;
+    UPkI64Table* PkI64;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UPkI64Table* PkI64;
+    UPkI8Table* PkI8;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UOneI128Table* OneI128;
+    UPkIdentityTable* PkIdentity;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UPkConnectionIdTable* PkConnectionId;
+    UPkSimpleEnumTable* PkSimpleEnum;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UOneI16Table* OneI16;
+    UPkStringTable* PkString;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    ULargeTableTable* LargeTable;
+    UPkU128Table* PkU128;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UVecEnumWithPayloadTable* VecEnumWithPayload;
+    UPkU16Table* PkU16;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UOneI32Table* OneI32;
+    UPkU256Table* PkU256;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UVecF32Table* VecF32;
+    UPkU32Table* PkU32;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UUniqueConnectionIdTable* UniqueConnectionId;
+    UPkU32TwoTable* PkU32Two;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UOptionSimpleEnumTable* OptionSimpleEnum;
+    UPkU64Table* PkU64;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UVecI256Table* VecI256;
+    UPkU8Table* PkU8;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UVecTimestampTable* VecTimestamp;
+    UScheduledTableTable* ScheduledTable;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UPkI8Table* PkI8;
+    UTableHoldsTableTable* TableHoldsTable;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UOneI256Table* OneI256;
+    UUniqueBoolTable* UniqueBool;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UScheduledTableTable* ScheduledTable;
+    UUniqueConnectionIdTable* UniqueConnectionId;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UUniqueU256Table* UniqueU256;
+    UUniqueI128Table* UniqueI128;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UOneStringTable* OneString;
+    UUniqueI16Table* UniqueI16;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UVecU16Table* VecU16;
+    UUniqueI256Table* UniqueI256;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UVecU256Table* VecU256;
+    UUniqueI32Table* UniqueI32;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UOptionStringTable* OptionString;
+    UUniqueI64Table* UniqueI64;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UOneU16Table* OneU16;
+    UUniqueI8Table* UniqueI8;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UPkIdentityTable* PkIdentity;
+    UUniqueIdentityTable* UniqueIdentity;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UPkU64Table* PkU64;
+    UUniqueStringTable* UniqueString;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UUniqueI16Table* UniqueI16;
+    UUniqueU128Table* UniqueU128;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UVecEveryPrimitiveStructTable* VecEveryPrimitiveStruct;
+    UUniqueU16Table* UniqueU16;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UVecU128Table* VecU128;
+    UUniqueU256Table* UniqueU256;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UOneI8Table* OneI8;
+    UUniqueU32Table* UniqueU32;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UUniqueU8Table* UniqueU8;
+    UUniqueU64Table* UniqueU64;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UVecByteStructTable* VecByteStruct;
+    UUniqueU8Table* UniqueU8;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UOneU64Table* OneU64;
+    UUsersTable* Users;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UTableHoldsTableTable* TableHoldsTable;
+    UVecBoolTable* VecBool;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UUniqueStringTable* UniqueString;
+    UVecByteStructTable* VecByteStruct;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UOneTimestampTable* OneTimestamp;
+    UVecConnectionIdTable* VecConnectionId;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UVecSimpleEnumTable* VecSimpleEnum;
+    UVecEnumWithPayloadTable* VecEnumWithPayload;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UOptionI32Table* OptionI32;
+    UVecEveryPrimitiveStructTable* VecEveryPrimitiveStruct;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UPkBoolTable* PkBool;
+    UVecEveryVecStructTable* VecEveryVecStruct;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UPkI256Table* PkI256;
+    UVecF32Table* VecF32;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UOneEveryVecStructTable* OneEveryVecStruct;
+    UVecF64Table* VecF64;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UUniqueI64Table* UniqueI64;
+    UVecI128Table* VecI128;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UUniqueU32Table* UniqueU32;
+    UVecI16Table* VecI16;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UPkU16Table* PkU16;
+    UVecI256Table* VecI256;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UOneConnectionIdTable* OneConnectionId;
+    UVecI32Table* VecI32;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UOneI64Table* OneI64;
+    UVecI64Table* VecI64;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UUniqueU64Table* UniqueU64;
+    UVecI8Table* VecI8;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UPkU256Table* PkU256;
+    UVecIdentityTable* VecIdentity;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UVecU8Table* VecU8;
+    UVecSimpleEnumTable* VecSimpleEnum;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UVecIdentityTable* VecIdentity;
+    UVecStringTable* VecString;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UOneU8Table* OneU8;
+    UVecTimestampTable* VecTimestamp;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UVecEveryVecStructTable* VecEveryVecStruct;
+    UVecU128Table* VecU128;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UVecUnitStructTable* VecUnitStruct;
+    UVecU16Table* VecU16;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UOneBoolTable* OneBool;
+    UVecU256Table* VecU256;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UVecStringTable* VecString;
+    UVecU32Table* VecU32;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UOneF32Table* OneF32;
+    UVecU64Table* VecU64;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UOptionIdentityTable* OptionIdentity;
+    UVecU8Table* VecU8;
 
     UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
-    UVecI8Table* VecI8;
+    UVecUnitStructTable* VecUnitStruct;
 
 };
 
diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/BTreeU32Table.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/BTreeU32Table.g.h
index a2381251578..067e94c0618 100644
--- a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/BTreeU32Table.g.h
+++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/BTreeU32Table.g.h
@@ -10,10 +10,10 @@
 #include "DBCache/WithBsatn.h"
 #include "DBCache/TableHandle.h"
 #include "DBCache/TableCache.h"
-#include "BTreeU32Table.g.generated.h"
+#include "BtreeU32Table.g.generated.h"
 
 UCLASS(Blueprintable)
-class UBTreeU32NIndex : public UObject
+class UBtreeU32NIndex : public UObject
 {
     GENERATED_BODY()
 
@@ -47,13 +47,13 @@ class UBTreeU32NIndex : public UObject
 };
 
 UCLASS(BlueprintType)
-class TESTCLIENT_API UBTreeU32Table : public URemoteTable
+class TESTCLIENT_API UBtreeU32Table : public URemoteTable
 {
     GENERATED_BODY()
 
 public:
     UPROPERTY(BlueprintReadOnly)
-    UBTreeU32NIndex* N;
+    UBtreeU32NIndex* N;
 
     void PostInitialize();
 
@@ -70,29 +70,29 @@ class TESTCLIENT_API UBTreeU32Table : public URemoteTable
 
     // Table Events
     DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( 
-        FOnBTreeU32Insert,
+        FOnBtreeU32Insert,
         const FEventContext&, Context,
         const FBTreeU32Type&, NewRow);
 
     DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams( 
-        FOnBTreeU32Update,
+        FOnBtreeU32Update,
         const FEventContext&, Context,
         const FBTreeU32Type&, OldRow,
         const FBTreeU32Type&, NewRow);
 
     DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams( 
-        FOnBTreeU32Delete,
+        FOnBtreeU32Delete,
         const FEventContext&, Context,
         const FBTreeU32Type&, DeletedRow);
 
     UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events")
-    FOnBTreeU32Insert OnInsert;
+    FOnBtreeU32Insert OnInsert;
 
     UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events")
-    FOnBTreeU32Update OnUpdate;
+    FOnBtreeU32Update OnUpdate;
 
     UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events")
-    FOnBTreeU32Delete OnDelete;
+    FOnBtreeU32Delete OnDelete;
 
 private:
     const FString TableName = TEXT("btree_u32");
diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/EnumWithPayloadType.g.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/EnumWithPayloadType.g.h
index 40f8b284a02..5b8bbe7c2a2 100644
--- a/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/EnumWithPayloadType.g.h
+++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/EnumWithPayloadType.g.h
@@ -4,9 +4,9 @@
 #pragma once
 #include "CoreMinimal.h"
 #include "BSATN/UESpacetimeDB.h"
+#include "Kismet/BlueprintFunctionLibrary.h"
 #include "Types/Builtins.h"
 #include "ModuleBindings/Types/SimpleEnumType.g.h"
-#include "Kismet/BlueprintFunctionLibrary.h"
 #include "EnumWithPayloadType.g.generated.h"
 
 UENUM(BlueprintType)
@@ -45,7 +45,7 @@ struct TESTCLIENT_API FEnumWithPayloadType
 public:
     FEnumWithPayloadType() = default;
 
-    TVariant<uint32, double, int16, int32, bool, uint16, int8, int64, FSpacetimeDBUInt256, FSpacetimeDBInt128, TArray<uint8>, uint8, TArray<ESimpleEnumType>, FSpacetimeDBTimestamp, FSpacetimeDBConnectionId, TArray<int32>, float, FSpacetimeDBUInt128, uint64, FSpacetimeDBInt256, FString, FSpacetimeDBIdentity, TArray<FString>> MessageData;
+    TVariant<FSpacetimeDBIdentity, FSpacetimeDBConnectionId, FSpacetimeDBInt256, TArray<int32>, int8, FSpacetimeDBTimestamp, int32, bool, FSpacetimeDBUInt256, FSpacetimeDBUInt128, TArray<uint8>, TArray<FString>, TArray<ESimpleEnumType>, uint8, uint16, int64, float, uint32, FSpacetimeDBInt128, uint64, int16, double, FString> MessageData;
 
     UPROPERTY(BlueprintReadOnly)
     EEnumWithPayloadTag Tag = static_cast<EEnumWithPayloadTag>(0);
diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/Tests/TestHandler.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/Tests/TestHandler.h
index 5b064b17878..6d060fa8c7e 100644
--- a/sdks/unreal/tests/TestClient/Source/TestClient/Public/Tests/TestHandler.h
+++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/Tests/TestHandler.h
@@ -524,4 +524,4 @@ class UOverlappingSubscriptionsHandler : public UTestHandler {
 	void OnInsertPkU8Reducer(const FReducerEventContext& Context, uint8 N, int32 Data);
 	UFUNCTION()
 	void OnUpdatePkU8(const FEventContext& Context, const FPkU8Type& OldValue, const FPkU8Type& NewValue);
-};
\ No newline at end of file
+};
diff --git a/sdks/unreal/tests/TestClient/Source/TestClient/Public/Tests/UmbreallaHeaderaTables.h b/sdks/unreal/tests/TestClient/Source/TestClient/Public/Tests/UmbreallaHeaderaTables.h
index ef2ae29fbbe..d901195b5f3 100644
--- a/sdks/unreal/tests/TestClient/Source/TestClient/Public/Tests/UmbreallaHeaderaTables.h
+++ b/sdks/unreal/tests/TestClient/Source/TestClient/Public/Tests/UmbreallaHeaderaTables.h
@@ -1,5 +1,5 @@
 //Include Tables
-#include "ModuleBindings/Tables/BTreeU32Table.g.h"
+#include "ModuleBindings/Tables/BtreeU32Table.g.h"
 #include "ModuleBindings/Tables/IndexedSimpleEnumTable.g.h"
 #include "ModuleBindings/Tables/IndexedTable2Table.g.h"
 #include "ModuleBindings/Tables/IndexedTableTable.g.h"