PublicArchive/SpacetimeDB
2
0
Fork 0
mirror of https://github.com/clockworklabs/SpacetimeDB.git synced 2026-05-06 07:26:43 -04:00
Code Issues Packages Projects Releases Wiki Activity

Client codegen fixes for views (#3690)

Browse Source 
# Description of Changes

Fixes client codegen for views.

# API and ABI breaking changes

None

# Expected complexity level and risk

2

# Testing

I'm not sure what tests we have for C++.

- [x] Updated client snapshots for rust, C#, and typescript
- [ ] Rust sdk test

---------

Co-authored-by: John Detter <4099508+jdetter@users.noreply.github.com>
Co-authored-by: Jason Larabie <jason@clockworklabs.io>
This commit is contained in:
joshua-spacetime
2025-11-19 11:09:59 -08:00
committed by GitHub
parent 9e3ffeb932
commit 353cc0d3e6
15 changed files with 710 additions and 678 deletions
Download Patch File Download Diff File Expand all files Collapse all files
crates/codegen/src/csharp.rs
+4 -4
View File
@@ -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)
);
}
});
crates/codegen/src/rust.rs
+31 -21
View File
@@ -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",
crates/codegen/src/typescript.rs
+2 -2
View File
@@ -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
crates/codegen/src/unrealcpp.rs
+53 -42
View File
@@ -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);
}
crates/codegen/src/util.rs
+6 -6
View File
@@ -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>(
crates/codegen/tests/snapshots/codegen__codegen_csharp.snap
+1
View File
@@ -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));
crates/codegen/tests/snapshots/codegen__codegen_rust.snap
+8
View File
@@ -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);
sdks/csharp/examples~/regression-tests/client/module_bindings/SpacetimeDBClient.g.cs
Generated
+3 -1
View File
@@ -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 @@ namespace SpacetimeDB.Types
public RemoteTables(DbConnection conn)
{
AddTable(ExampleData = new(conn));
AddTable(GetAnonymousExampleDataById = new(conn));
AddTable(GetExampleDataById = new(conn));
}
}
sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/SpacetimeDBClient.g.cpp
+344 -344
View File
@@ -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/IndexedTable2Table.g.h"
#include "ModuleBindings/Tables/LargeTableTable.g.h"
#include "ModuleBindings/Tables/OneBoolTable.g.h"
#include "ModuleBindings/Tables/OneByteStructTable.g.h"
#include "ModuleBindings/Tables/VecI32Table.g.h"
#include "ModuleBindings/Tables/PkU32Table.g.h"
#include "ModuleBindings/Tables/OneConnectionIdTable.g.h"
#include "ModuleBindings/Tables/OneEnumWithPayloadTable.g.h"
#include "ModuleBindings/Tables/OneEveryPrimitiveStructTable.g.h"
#include "ModuleBindings/Tables/OneEveryVecStructTable.g.h"
#include "ModuleBindings/Tables/OneF32Table.g.h"
#include "ModuleBindings/Tables/OneF64Table.g.h"
#include "ModuleBindings/Tables/OneI128Table.g.h"
#include "ModuleBindings/Tables/OneI16Table.g.h"
#include "ModuleBindings/Tables/OneI256Table.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/OneTimestampTable.g.h"
#include "ModuleBindings/Tables/OneU128Table.g.h"
#include "ModuleBindings/Tables/OneU16Table.g.h"
#include "ModuleBindings/Tables/OneU256Table.g.h"
#include "ModuleBindings/Tables/OneU32Table.g.h"
#include "ModuleBindings/Tables/OneU64Table.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/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/VecU64Table.g.h"
#include "ModuleBindings/Tables/IndexedTable2Table.g.h"
#include "ModuleBindings/Tables/VecF64Table.g.h"
#include "ModuleBindings/Tables/OneU256Table.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/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/PkU16Table.g.h"
#include "ModuleBindings/Tables/PkU256Table.g.h"
#include "ModuleBindings/Tables/PkU32Table.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/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/OneStringTable.g.h"
#include "ModuleBindings/Tables/UniqueU32Table.g.h"
#include "ModuleBindings/Tables/UniqueU64Table.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/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/OptionStringTable.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/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/OptionI32Table.g.h"
#include "ModuleBindings/Tables/PkBoolTable.g.h"
#include "ModuleBindings/Tables/PkI256Table.g.h"
#include "ModuleBindings/Tables/OneEveryVecStructTable.g.h"
#include "ModuleBindings/Tables/UniqueI64Table.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/VecU32Table.g.h"
#include "ModuleBindings/Tables/VecU64Table.g.h"
#include "ModuleBindings/Tables/VecU8Table.g.h"
#include "ModuleBindings/Tables/VecIdentityTable.g.h"
#include "ModuleBindings/Tables/OneU8Table.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/VecI8Table.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<FIndexedTable2Type, UIndexedTable2Table, FEventContext>(TEXT("indexed_table_2"), Db->IndexedTable2);
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<FVecI32Type, UVecI32Table, FEventContext>(TEXT("vec_i32"), Db->VecI32);
RegisterTable<FPkU32Type, UPkU32Table, FEventContext>(TEXT("pk_u32"), Db->PkU32);
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<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<FOneI128Type, UOneI128Table, FEventContext>(TEXT("one_i128"), Db->OneI128);
RegisterTable<FOneI16Type, UOneI16Table, FEventContext>(TEXT("one_i16"), Db->OneI16);
RegisterTable<FOneI256Type, UOneI256Table, FEventContext>(TEXT("one_i256"), Db->OneI256);
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<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<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<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<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<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<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<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<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<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<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<FOneStringType, UOneStringTable, FEventContext>(TEXT("one_string"), Db->OneString);
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<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<FOptionStringType, UOptionStringTable, FEventContext>(TEXT("option_string"), Db->OptionString);
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<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<FOptionI32Type, UOptionI32Table, FEventContext>(TEXT("option_i32"), Db->OptionI32);
RegisterTable<FPkBoolType, UPkBoolTable, FEventContext>(TEXT("pk_bool"), Db->PkBool);
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<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<FVecIdentityType, UVecIdentityTable, FEventContext>(TEXT("vec_identity"), Db->VecIdentity);
RegisterTable<FOneU8Type, UOneU8Table, FEventContext>(TEXT("one_u8"), Db->OneU8);
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<FVecI8Type, UVecI8Table, FEventContext>(TEXT("vec_i8"), Db->VecI8);
}
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);
IndexedTable2 = NewObject<UIndexedTable2Table>(this);
LargeTable = NewObject<ULargeTableTable>(this);
OneBool = NewObject<UOneBoolTable>(this);
OneByteStruct = NewObject<UOneByteStructTable>(this);
VecI32 = NewObject<UVecI32Table>(this);
PkU32 = NewObject<UPkU32Table>(this);
OneConnectionId = NewObject<UOneConnectionIdTable>(this);
OneEnumWithPayload = NewObject<UOneEnumWithPayloadTable>(this);
OneEveryPrimitiveStruct = NewObject<UOneEveryPrimitiveStructTable>(this);
OneEveryVecStruct = NewObject<UOneEveryVecStructTable>(this);
OneF32 = NewObject<UOneF32Table>(this);
OneF64 = NewObject<UOneF64Table>(this);
OneI128 = NewObject<UOneI128Table>(this);
OneI16 = NewObject<UOneI16Table>(this);
OneI256 = NewObject<UOneI256Table>(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);
OneTimestamp = NewObject<UOneTimestampTable>(this);
OneU128 = NewObject<UOneU128Table>(this);
OneU16 = NewObject<UOneU16Table>(this);
OneU256 = NewObject<UOneU256Table>(this);
OneU32 = NewObject<UOneU32Table>(this);
OneU64 = NewObject<UOneU64Table>(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);
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);
VecU64 = NewObject<UVecU64Table>(this);
IndexedTable2 = NewObject<UIndexedTable2Table>(this);
VecF64 = NewObject<UVecF64Table>(this);
OneU256 = NewObject<UOneU256Table>(this);
OneEveryPrimitiveStruct = NewObject<UOneEveryPrimitiveStructTable>(this);
UniqueI128 = NewObject<UUniqueI128Table>(this);
VecI64 = NewObject<UVecI64Table>(this);
PkU8 = NewObject<UPkU8Table>(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);
PkU16 = NewObject<UPkU16Table>(this);
PkU256 = NewObject<UPkU256Table>(this);
PkU32 = NewObject<UPkU32Table>(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);
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);
OneString = NewObject<UOneStringTable>(this);
UniqueU32 = NewObject<UUniqueU32Table>(this);
UniqueU64 = NewObject<UUniqueU64Table>(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);
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);
OptionString = NewObject<UOptionStringTable>(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);
OneU64 = NewObject<UOneU64Table>(this);
TableHoldsTable = NewObject<UTableHoldsTableTable>(this);
UniqueString = NewObject<UUniqueStringTable>(this);
OneTimestamp = NewObject<UOneTimestampTable>(this);
VecSimpleEnum = NewObject<UVecSimpleEnumTable>(this);
OptionI32 = NewObject<UOptionI32Table>(this);
PkBool = NewObject<UPkBoolTable>(this);
PkI256 = NewObject<UPkI256Table>(this);
OneEveryVecStruct = NewObject<UOneEveryVecStructTable>(this);
UniqueI64 = NewObject<UUniqueI64Table>(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);
VecU32 = NewObject<UVecU32Table>(this);
VecU64 = NewObject<UVecU64Table>(this);
VecU8 = NewObject<UVecU8Table>(this);
VecIdentity = NewObject<UVecIdentityTable>(this);
OneU8 = NewObject<UOneU8Table>(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);
VecI8 = NewObject<UVecI8Table>(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();
IndexedTable2->PostInitialize();
LargeTable->PostInitialize();
OneBool->PostInitialize();
OneByteStruct->PostInitialize();
VecI32->PostInitialize();
PkU32->PostInitialize();
OneConnectionId->PostInitialize();
OneEnumWithPayload->PostInitialize();
OneEveryPrimitiveStruct->PostInitialize();
OneEveryVecStruct->PostInitialize();
OneF32->PostInitialize();
OneF64->PostInitialize();
OneI128->PostInitialize();
OneI16->PostInitialize();
OneI256->PostInitialize();
OneI32->PostInitialize();
OneI64->PostInitialize();
OneI8->PostInitialize();
OneIdentity->PostInitialize();
OneSimpleEnum->PostInitialize();
OneString->PostInitialize();
OneTimestamp->PostInitialize();
OneU128->PostInitialize();
OneU16->PostInitialize();
OneU256->PostInitialize();
OneU32->PostInitialize();
OneU64->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();
PkI32->PostInitialize();
PkI64->PostInitialize();
PkI8->PostInitialize();
PkIdentity->PostInitialize();
PkSimpleEnum->PostInitialize();
PkString->PostInitialize();
PkU128->PostInitialize();
VecU64->PostInitialize();
IndexedTable2->PostInitialize();
VecF64->PostInitialize();
OneU256->PostInitialize();
OneEveryPrimitiveStruct->PostInitialize();
UniqueI128->PostInitialize();
VecI64->PostInitialize();
PkU8->PostInitialize();
OneF64->PostInitialize();
VecU32->PostInitialize();
PkI16->PostInitialize();
PkI32->PostInitialize();
OneU32->PostInitialize();
UniqueBool->PostInitialize();
OneSimpleEnum->PostInitialize();
VecI16->PostInitialize();
UniqueIdentity->PostInitialize();
PkU16->PostInitialize();
PkU256->PostInitialize();
PkU32->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();
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();
OneString->PostInitialize();
UniqueU32->PostInitialize();
UniqueU64->PostInitialize();
UniqueU8->PostInitialize();
Users->PostInitialize();
VecBool->PostInitialize();
VecByteStruct->PostInitialize();
VecConnectionId->PostInitialize();
VecEnumWithPayload->PostInitialize();
VecEveryPrimitiveStruct->PostInitialize();
VecEveryVecStruct->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();
OptionString->PostInitialize();
OneU16->PostInitialize();
PkIdentity->PostInitialize();
PkU64->PostInitialize();
UniqueI16->PostInitialize();
VecEveryPrimitiveStruct->PostInitialize();
VecU128->PostInitialize();
OneI8->PostInitialize();
UniqueU8->PostInitialize();
VecByteStruct->PostInitialize();
OneU64->PostInitialize();
TableHoldsTable->PostInitialize();
UniqueString->PostInitialize();
OneTimestamp->PostInitialize();
VecSimpleEnum->PostInitialize();
OptionI32->PostInitialize();
PkBool->PostInitialize();
PkI256->PostInitialize();
OneEveryVecStruct->PostInitialize();
UniqueI64->PostInitialize();
UniqueU32->PostInitialize();
PkU16->PostInitialize();
OneConnectionId->PostInitialize();
OneI64->PostInitialize();
UniqueU64->PostInitialize();
PkU256->PostInitialize();
VecU32->PostInitialize();
VecU64->PostInitialize();
VecU8->PostInitialize();
VecIdentity->PostInitialize();
OneU8->PostInitialize();
VecEveryVecStruct->PostInitialize();
VecUnitStruct->PostInitialize();
OneBool->PostInitialize();
VecString->PostInitialize();
OneF32->PostInitialize();
OptionIdentity->PostInitialize();
VecI8->PostInitialize();
/**/
}
sdks/unreal/tests/TestClient/Source/TestClient/Private/ModuleBindings/Tables/BTreeU32Table.g.cpp
+10 -10
View File
@@ -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);
}
sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/SpacetimeDBClient.g.h
+234 -234
View File
@@ -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;
@@ -6887,47 +6887,143 @@ class TESTCLIENT_API URemoteTables : public UObject
public:
void Initialize();
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UBtreeU32Table* BtreeU32;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UIndexedSimpleEnumTable* IndexedSimpleEnum;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UOneU128Table* OneU128;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UUniqueI8Table* UniqueI8;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UUniqueU16Table* UniqueU16;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UBTreeU32Table* BtreeU32;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UIndexedTableTable* IndexedTable;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UOptionEveryPrimitiveStructTable* OptionEveryPrimitiveStruct;
UIndexedTable2Table* IndexedTable2;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UUniqueI256Table* UniqueI256;
ULargeTableTable* LargeTable;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UOptionVecOptionI32Table* OptionVecOptionI32;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UUniqueU128Table* UniqueU128;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UVecI128Table* VecI128;
UOneBoolTable* OneBool;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UOneByteStructTable* OneByteStruct;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UVecI32Table* VecI32;
UOneConnectionIdTable* OneConnectionId;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UPkU32Table* PkU32;
UOneEnumWithPayloadTable* OneEnumWithPayload;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UOneEveryPrimitiveStructTable* OneEveryPrimitiveStruct;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UOneEveryVecStructTable* OneEveryVecStruct;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UOneF32Table* OneF32;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UOneF64Table* OneF64;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UOneI128Table* OneI128;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UOneI16Table* OneI16;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UOneI256Table* OneI256;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UOneI32Table* OneI32;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UOneI64Table* OneI64;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UOneI8Table* OneI8;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UOneIdentityTable* OneIdentity;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UOneSimpleEnumTable* OneSimpleEnum;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UOneStringTable* OneString;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UOneTimestampTable* OneTimestamp;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UOneU128Table* OneU128;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UOneU16Table* OneU16;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UOneU256Table* OneU256;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UOneU32Table* OneU32;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UOneU64Table* OneU64;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UOneU8Table* OneU8;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UOneUnitStructTable* OneUnitStruct;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UOptionEveryPrimitiveStructTable* OptionEveryPrimitiveStruct;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UOptionI32Table* OptionI32;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UOptionIdentityTable* OptionIdentity;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UOptionSimpleEnumTable* OptionSimpleEnum;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UOptionStringTable* OptionString;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UOptionVecOptionI32Table* OptionVecOptionI32;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UPkBoolTable* PkBool;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UPkConnectionIdTable* PkConnectionId;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UPkI128Table* PkI128;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UPkI16Table* PkI16;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UPkI256Table* PkI256;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UPkI32Table* PkI32;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UPkI64Table* PkI64;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UPkI8Table* PkI8;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UPkIdentityTable* PkIdentity;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UPkSimpleEnumTable* PkSimpleEnum;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UPkStringTable* PkString;
@@ -6936,136 +7032,136 @@ public:
UPkU128Table* PkU128;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UVecU64Table* VecU64;
UPkU16Table* PkU16;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UIndexedTable2Table* IndexedTable2;
UPkU256Table* PkU256;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UVecF64Table* VecF64;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UOneU256Table* OneU256;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UOneEveryPrimitiveStructTable* OneEveryPrimitiveStruct;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UUniqueI128Table* UniqueI128;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UVecI64Table* VecI64;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UPkU8Table* PkU8;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UOneF64Table* OneF64;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UVecU32Table* VecU32;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UPkI16Table* PkI16;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UPkI32Table* PkI32;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UOneU32Table* OneU32;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UUniqueBoolTable* UniqueBool;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UOneSimpleEnumTable* OneSimpleEnum;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UVecI16Table* VecI16;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UUniqueIdentityTable* UniqueIdentity;
UPkU32Table* PkU32;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UPkU32TwoTable* PkU32Two;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UVecBoolTable* VecBool;
UPkU64Table* PkU64;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UOneEnumWithPayloadTable* OneEnumWithPayload;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UUniqueI32Table* UniqueI32;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UOneIdentityTable* OneIdentity;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UOneUnitStructTable* OneUnitStruct;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UUsersTable* Users;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UVecConnectionIdTable* VecConnectionId;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UPkI128Table* PkI128;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UPkSimpleEnumTable* PkSimpleEnum;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UPkI64Table* PkI64;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UOneI128Table* OneI128;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UPkConnectionIdTable* PkConnectionId;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UOneI16Table* OneI16;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
ULargeTableTable* LargeTable;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UVecEnumWithPayloadTable* VecEnumWithPayload;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UOneI32Table* OneI32;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UVecF32Table* VecF32;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UUniqueConnectionIdTable* UniqueConnectionId;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UOptionSimpleEnumTable* OptionSimpleEnum;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UVecI256Table* VecI256;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UVecTimestampTable* VecTimestamp;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UPkI8Table* PkI8;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UOneI256Table* OneI256;
UPkU8Table* PkU8;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UScheduledTableTable* ScheduledTable;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UTableHoldsTableTable* TableHoldsTable;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UUniqueBoolTable* UniqueBool;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UUniqueConnectionIdTable* UniqueConnectionId;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UUniqueI128Table* UniqueI128;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UUniqueI16Table* UniqueI16;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UUniqueI256Table* UniqueI256;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UUniqueI32Table* UniqueI32;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UUniqueI64Table* UniqueI64;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UUniqueI8Table* UniqueI8;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UUniqueIdentityTable* UniqueIdentity;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UUniqueStringTable* UniqueString;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UUniqueU128Table* UniqueU128;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UUniqueU16Table* UniqueU16;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UUniqueU256Table* UniqueU256;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UOneStringTable* OneString;
UUniqueU32Table* UniqueU32;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UUniqueU64Table* UniqueU64;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UUniqueU8Table* UniqueU8;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UUsersTable* Users;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UVecBoolTable* VecBool;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UVecByteStructTable* VecByteStruct;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UVecConnectionIdTable* VecConnectionId;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UVecEnumWithPayloadTable* VecEnumWithPayload;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UVecEveryPrimitiveStructTable* VecEveryPrimitiveStruct;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UVecEveryVecStructTable* VecEveryVecStruct;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UVecF32Table* VecF32;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UVecF64Table* VecF64;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UVecI128Table* VecI128;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UVecI16Table* VecI16;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UVecI256Table* VecI256;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UVecI32Table* VecI32;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UVecI64Table* VecI64;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UVecI8Table* VecI8;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UVecIdentityTable* VecIdentity;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UVecSimpleEnumTable* VecSimpleEnum;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UVecStringTable* VecString;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UVecTimestampTable* VecTimestamp;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UVecU128Table* VecU128;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UVecU16Table* VecU16;
@@ -7074,113 +7170,17 @@ public:
UVecU256Table* VecU256;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UOptionStringTable* OptionString;
UVecU32Table* VecU32;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UOneU16Table* OneU16;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UPkIdentityTable* PkIdentity;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UPkU64Table* PkU64;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UUniqueI16Table* UniqueI16;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UVecEveryPrimitiveStructTable* VecEveryPrimitiveStruct;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UVecU128Table* VecU128;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UOneI8Table* OneI8;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UUniqueU8Table* UniqueU8;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UVecByteStructTable* VecByteStruct;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UOneU64Table* OneU64;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UTableHoldsTableTable* TableHoldsTable;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UUniqueStringTable* UniqueString;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UOneTimestampTable* OneTimestamp;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UVecSimpleEnumTable* VecSimpleEnum;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UOptionI32Table* OptionI32;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UPkBoolTable* PkBool;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UPkI256Table* PkI256;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UOneEveryVecStructTable* OneEveryVecStruct;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UUniqueI64Table* UniqueI64;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UUniqueU32Table* UniqueU32;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UPkU16Table* PkU16;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UOneConnectionIdTable* OneConnectionId;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UOneI64Table* OneI64;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UUniqueU64Table* UniqueU64;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UPkU256Table* PkU256;
UVecU64Table* VecU64;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UVecU8Table* VecU8;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UVecIdentityTable* VecIdentity;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UOneU8Table* OneU8;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UVecEveryVecStructTable* VecEveryVecStruct;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UVecUnitStructTable* VecUnitStruct;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UOneBoolTable* OneBool;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UVecStringTable* VecString;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UOneF32Table* OneF32;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UOptionIdentityTable* OptionIdentity;
UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
UVecI8Table* VecI8;
};
// RemoteReducers class
sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Tables/BTreeU32Table.g.h
+10 -10
View File
@@ -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 @@ private:
};
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 @@ public:
// 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");
sdks/unreal/tests/TestClient/Source/TestClient/Public/ModuleBindings/Types/EnumWithPayloadType.g.h
+2 -2
View File
@@ -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);
sdks/unreal/tests/TestClient/Source/TestClient/Public/Tests/TestHandler.h
+1 -1
View File
@@ -524,4 +524,4 @@ public:
void OnInsertPkU8Reducer(const FReducerEventContext& Context, uint8 N, int32 Data);
UFUNCTION()
void OnUpdatePkU8(const FEventContext& Context, const FPkU8Type& OldValue, const FPkU8Type& NewValue);
};
};
sdks/unreal/tests/TestClient/Source/TestClient/Public/Tests/UmbreallaHeaderaTables.h
+1 -1
View File
@@ -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"