From 1c1aea4abde3fa4726924c9099d6e82eae56da03 Mon Sep 17 00:00:00 2001 From: Jeff Rooks Date: Tue, 7 Jul 2026 19:46:52 -0400 Subject: [PATCH 1/2] feat: add table accessor without lifetime (#5055) # Description of Changes Adds a lifetime-aware `TableAccessor` trait to the Rust SDK and updates Rust codegen to emit a generated accessor marker type for each table. Generated bindings now include a marker type like: ```rust pub struct PlayerPositionTableAccessor; impl __sdk::TableAccessor for PlayerPositionTableAccessor { type Row = PlayerPositionRow; type Handle<'db> = PlayerPositionTableHandle<'db>; fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { db.player_position() } } ``` The existing generated table access methods remain unchanged: ```rust fn player_position(&self) -> PlayerPositionTableHandle<'_>; ``` ## Motivation Generated table handles are lifetime-scoped to `RemoteTables`, which makes it difficult for downstream crates to expose ergonomic generic APIs over generated table accessors. In particular, a method like `RemoteTables::player_position` returns a handle whose type depends on the borrow lifetime of `RemoteTables`, which is hard to represent in higher-order APIs. The existing lifetime is not mechanically required by the current handle storage model: generated table handles own an SDK `TableHandle`, which holds shared connection/cache state rather than borrowing from `RemoteTables`. However, the lifetime does express the conceptual scope of a handle relative to the database view that produced it. This PR preserves that scoped API contract instead of removing the lifetime, and adds a generated marker type so generic downstream APIs can name table accessors without erasing or weakening the lifetime relationship. This enables APIs such as the below instead of requiring closure-based registration everywhere which greatly simplifies downstream crate code and consumer code. ```diff - .add_table::(|reg, db| reg.bind(db.player_position())) + .add_table::() ``` # API and ABI breaking changes None. This is additive and should not break existing generated bindings usage. Existing code such as the below continues to work unchanged: ```rust ctx.db.player_position().on_insert(...) ``` The new `TableAccessor` trait is exported from both the SDK root and `__codegen`, and generated marker types are added alongside existing generated table handles and access traits. # Expected complexity level and risk Complexity: **2/5** The change is small and additive, but it touches Rust SDK codegen and generated binding shape. The main risk is introducing generated code that depends on the new SDK trait, so generated bindings and the SDK version must match. This does not alter table handle ownership, callback behavior, or existing access methods. # Testing - [x] Ran `cargo check -p spacetimedb-sdk`. - [x] Regenerated Rust bindings for my game. - [x] Verified generated bindings include `*TableAccessor` marker types. - [x] Used generated accessors from downstream local `bevy_stdb`. - [x] Ran `cargo check -p bevy_stdb` against the local SDK. --------- Signed-off-by: Jeff Rooks Co-authored-by: Phoebe Goldman Co-authored-by: clockwork-labs-bot --- crates/codegen/src/rust.rs | 13 ++++ .../snapshots/codegen__codegen_rust.snap | 72 +++++++++++++++++++ sdks/rust/src/lib.rs | 4 +- sdks/rust/src/table.rs | 27 +++++++ .../src/module_bindings/person_2_table.rs | 12 ++++ .../person_at_level_2_table.rs | 12 ++++ .../src/module_bindings/player_1_table.rs | 12 ++++ .../src/module_bindings/connected_table.rs | 12 ++++ .../src/module_bindings/disconnected_table.rs | 12 ++++ .../src/module_bindings/test_event_table.rs | 12 ++++ .../src/module_bindings/left_source_table.rs | 12 ++++ .../src/module_bindings/right_source_table.rs | 12 ++++ .../module_bindings/sender_left_view_table.rs | 12 ++++ .../sender_right_view_table.rs | 12 ++++ .../src/module_bindings/my_table_table.rs | 12 ++++ .../src/module_bindings/pk_uuid_table.rs | 12 ++++ .../proc_inserts_into_table.rs | 12 ++++ .../scheduled_proc_table_table.rs | 12 ++++ .../procedure_concurrency_row_table.rs | 12 ++++ .../scheduled_procedure_row_table.rs | 12 ++++ .../scheduled_reducer_row_table.rs | 12 ++++ .../src/module_bindings/btree_u_32_table.rs | 12 ++++ .../indexed_simple_enum_table.rs | 12 ++++ .../module_bindings/indexed_table_2_table.rs | 12 ++++ .../module_bindings/indexed_table_table.rs | 12 ++++ .../src/module_bindings/large_table_table.rs | 12 ++++ .../src/module_bindings/one_bool_table.rs | 12 ++++ .../module_bindings/one_byte_struct_table.rs | 12 ++++ .../one_connection_id_table.rs | 12 ++++ .../one_enum_with_payload_table.rs | 12 ++++ .../one_every_primitive_struct_table.rs | 12 ++++ .../one_every_vec_struct_table.rs | 12 ++++ .../src/module_bindings/one_f_32_table.rs | 12 ++++ .../src/module_bindings/one_f_64_table.rs | 12 ++++ .../src/module_bindings/one_i_128_table.rs | 12 ++++ .../src/module_bindings/one_i_16_table.rs | 12 ++++ .../src/module_bindings/one_i_256_table.rs | 12 ++++ .../src/module_bindings/one_i_32_table.rs | 12 ++++ .../src/module_bindings/one_i_64_table.rs | 12 ++++ .../src/module_bindings/one_i_8_table.rs | 12 ++++ .../src/module_bindings/one_identity_table.rs | 12 ++++ .../module_bindings/one_simple_enum_table.rs | 12 ++++ .../src/module_bindings/one_string_table.rs | 12 ++++ .../module_bindings/one_timestamp_table.rs | 12 ++++ .../src/module_bindings/one_u_128_table.rs | 12 ++++ .../src/module_bindings/one_u_16_table.rs | 12 ++++ .../src/module_bindings/one_u_256_table.rs | 12 ++++ .../src/module_bindings/one_u_32_table.rs | 12 ++++ .../src/module_bindings/one_u_64_table.rs | 12 ++++ .../src/module_bindings/one_u_8_table.rs | 12 ++++ .../module_bindings/one_unit_struct_table.rs | 12 ++++ .../src/module_bindings/one_uuid_table.rs | 12 ++++ .../option_every_primitive_struct_table.rs | 12 ++++ .../src/module_bindings/option_i_32_table.rs | 12 ++++ .../module_bindings/option_identity_table.rs | 12 ++++ .../option_simple_enum_table.rs | 12 ++++ .../module_bindings/option_string_table.rs | 12 ++++ .../src/module_bindings/option_uuid_table.rs | 12 ++++ .../option_vec_option_i_32_table.rs | 12 ++++ .../src/module_bindings/pk_bool_table.rs | 12 ++++ .../module_bindings/pk_connection_id_table.rs | 12 ++++ .../src/module_bindings/pk_i_128_table.rs | 12 ++++ .../src/module_bindings/pk_i_16_table.rs | 12 ++++ .../src/module_bindings/pk_i_256_table.rs | 12 ++++ .../src/module_bindings/pk_i_32_table.rs | 12 ++++ .../src/module_bindings/pk_i_64_table.rs | 12 ++++ .../src/module_bindings/pk_i_8_table.rs | 12 ++++ .../src/module_bindings/pk_identity_table.rs | 12 ++++ .../module_bindings/pk_simple_enum_table.rs | 12 ++++ .../src/module_bindings/pk_string_table.rs | 12 ++++ .../src/module_bindings/pk_u_128_table.rs | 12 ++++ .../src/module_bindings/pk_u_16_table.rs | 12 ++++ .../src/module_bindings/pk_u_256_table.rs | 12 ++++ .../src/module_bindings/pk_u_32_table.rs | 12 ++++ .../src/module_bindings/pk_u_32_two_table.rs | 12 ++++ .../src/module_bindings/pk_u_64_table.rs | 12 ++++ .../src/module_bindings/pk_u_8_table.rs | 12 ++++ .../src/module_bindings/pk_uuid_table.rs | 12 ++++ ...ult_every_primitive_struct_string_table.rs | 12 ++++ .../result_i_32_string_table.rs | 12 ++++ .../result_identity_string_table.rs | 12 ++++ .../result_simple_enum_i_32_table.rs | 12 ++++ .../result_string_i_32_table.rs | 12 ++++ .../result_vec_i_32_string_table.rs | 12 ++++ .../module_bindings/scheduled_table_table.rs | 12 ++++ .../table_holds_table_table.rs | 12 ++++ .../src/module_bindings/unique_bool_table.rs | 12 ++++ .../unique_connection_id_table.rs | 12 ++++ .../src/module_bindings/unique_i_128_table.rs | 12 ++++ .../src/module_bindings/unique_i_16_table.rs | 12 ++++ .../src/module_bindings/unique_i_256_table.rs | 12 ++++ .../src/module_bindings/unique_i_32_table.rs | 12 ++++ .../src/module_bindings/unique_i_64_table.rs | 12 ++++ .../src/module_bindings/unique_i_8_table.rs | 12 ++++ .../module_bindings/unique_identity_table.rs | 12 ++++ .../module_bindings/unique_string_table.rs | 12 ++++ .../src/module_bindings/unique_u_128_table.rs | 12 ++++ .../src/module_bindings/unique_u_16_table.rs | 12 ++++ .../src/module_bindings/unique_u_256_table.rs | 12 ++++ .../src/module_bindings/unique_u_32_table.rs | 12 ++++ .../src/module_bindings/unique_u_64_table.rs | 12 ++++ .../src/module_bindings/unique_u_8_table.rs | 12 ++++ .../src/module_bindings/unique_uuid_table.rs | 12 ++++ .../src/module_bindings/users_table.rs | 12 ++++ .../src/module_bindings/vec_bool_table.rs | 12 ++++ .../module_bindings/vec_byte_struct_table.rs | 12 ++++ .../vec_connection_id_table.rs | 12 ++++ .../vec_enum_with_payload_table.rs | 12 ++++ .../vec_every_primitive_struct_table.rs | 12 ++++ .../vec_every_vec_struct_table.rs | 12 ++++ .../src/module_bindings/vec_f_32_table.rs | 12 ++++ .../src/module_bindings/vec_f_64_table.rs | 12 ++++ .../src/module_bindings/vec_i_128_table.rs | 12 ++++ .../src/module_bindings/vec_i_16_table.rs | 12 ++++ .../src/module_bindings/vec_i_256_table.rs | 12 ++++ .../src/module_bindings/vec_i_32_table.rs | 12 ++++ .../src/module_bindings/vec_i_64_table.rs | 12 ++++ .../src/module_bindings/vec_i_8_table.rs | 12 ++++ .../src/module_bindings/vec_identity_table.rs | 12 ++++ .../module_bindings/vec_simple_enum_table.rs | 12 ++++ .../src/module_bindings/vec_string_table.rs | 12 ++++ .../module_bindings/vec_timestamp_table.rs | 12 ++++ .../src/module_bindings/vec_u_128_table.rs | 12 ++++ .../src/module_bindings/vec_u_16_table.rs | 12 ++++ .../src/module_bindings/vec_u_256_table.rs | 12 ++++ .../src/module_bindings/vec_u_32_table.rs | 12 ++++ .../src/module_bindings/vec_u_64_table.rs | 12 ++++ .../src/module_bindings/vec_u_8_table.rs | 12 ++++ .../module_bindings/vec_unit_struct_table.rs | 12 ++++ .../src/module_bindings/vec_uuid_table.rs | 12 ++++ .../my_player_and_level_table.rs | 12 ++++ .../src/module_bindings/my_player_table.rs | 12 ++++ .../module_bindings/nearby_players_table.rs | 12 ++++ .../src/module_bindings/player_level_table.rs | 12 ++++ .../module_bindings/player_location_table.rs | 12 ++++ .../src/module_bindings/player_table.rs | 12 ++++ .../players_at_level_0_table.rs | 12 ++++ .../all_view_pk_players_table.rs | 12 ++++ .../sender_view_pk_players_a_table.rs | 12 ++++ .../sender_view_pk_players_b_table.rs | 12 ++++ .../view_pk_membership_secondary_table.rs | 12 ++++ .../view_pk_membership_table.rs | 12 ++++ .../module_bindings/view_pk_player_table.rs | 12 ++++ 143 files changed, 1782 insertions(+), 2 deletions(-) diff --git a/crates/codegen/src/rust.rs b/crates/codegen/src/rust.rs index 4dbafae1a2f..cea7ea87dd9 100644 --- a/crates/codegen/src/rust.rs +++ b/crates/codegen/src/rust.rs @@ -127,6 +127,7 @@ impl __sdk::InModule for {type_name} {{ let table_name = table.name.deref(); let table_name_pascalcase = table.accessor_name.deref().to_case(Case::Pascal); let table_handle = table_name_pascalcase.clone() + "TableHandle"; + let table_accessor = table_name_pascalcase.clone() + "TableAccessor"; let insert_callback_id = table_name_pascalcase.clone() + "InsertCallbackId"; let delete_callback_id = table_name_pascalcase.clone() + "DeleteCallbackId"; let accessor_trait = table_access_trait_name(&table.accessor_name); @@ -148,6 +149,18 @@ pub struct {table_handle}<'ctx> {{ ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, }} +/// Lifetime-aware accessor marker for the table `{table_name}`. +pub struct {table_accessor}; + +impl __sdk::TableAccessor for {table_accessor} {{ + type Row = {row_type}; + type Handle<'db> = {table_handle}<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> {{ + db.{accessor_method}() + }} +}} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `{table_name}`. /// diff --git a/crates/codegen/tests/snapshots/codegen__codegen_rust.snap b/crates/codegen/tests/snapshots/codegen__codegen_rust.snap index 639f67a62f7..1cda8c8d75b 100644 --- a/crates/codegen/tests/snapshots/codegen__codegen_rust.snap +++ b/crates/codegen/tests/snapshots/codegen__codegen_rust.snap @@ -812,6 +812,18 @@ pub struct LoggedOutPlayerTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `logged_out_player`. +pub struct LoggedOutPlayerTableAccessor; + +impl __sdk::TableAccessor for LoggedOutPlayerTableAccessor { + type Row = Player; + type Handle<'db> = LoggedOutPlayerTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.logged_out_player() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `logged_out_player`. /// @@ -2091,6 +2103,18 @@ pub struct MyPlayerTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `my_player`. +pub struct MyPlayerTableAccessor; + +impl __sdk::TableAccessor for MyPlayerTableAccessor { + type Row = Player; + type Handle<'db> = MyPlayerTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.my_player() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `my_player`. /// @@ -2374,6 +2398,18 @@ pub struct PersonTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `person`. +pub struct PersonTableAccessor; + +impl __sdk::TableAccessor for PersonTableAccessor { + type Row = Person; + type Handle<'db> = PersonTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.person() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `person`. /// @@ -2729,6 +2765,18 @@ pub struct PlayerTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `player`. +pub struct PlayerTableAccessor; + +impl __sdk::TableAccessor for PlayerTableAccessor { + type Row = Player; + type Handle<'db> = PlayerTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.player() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `player`. /// @@ -3752,6 +3800,18 @@ pub struct TestDTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `test_d`. +pub struct TestDTableAccessor; + +impl __sdk::TableAccessor for TestDTableAccessor { + type Row = TestD; + type Handle<'db> = TestDTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.test_d() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `test_d`. /// @@ -4039,6 +4099,18 @@ pub struct TestFTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `test_f`. +pub struct TestFTableAccessor; + +impl __sdk::TableAccessor for TestFTableAccessor { + type Row = TestFoobar; + type Handle<'db> = TestFTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.test_f() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `test_f`. /// diff --git a/sdks/rust/src/lib.rs b/sdks/rust/src/lib.rs index bf419b3d2bf..e7efd286514 100644 --- a/sdks/rust/src/lib.rs +++ b/sdks/rust/src/lib.rs @@ -29,7 +29,7 @@ pub use db_connection::DbConnectionBuilder; pub use db_context::DbContext; pub use error::{Error, Result}; pub use event::{Event, ReducerEvent, Status}; -pub use table::{EventTable, Table, TableWithPrimaryKey}; +pub use table::{EventTable, Table, TableAccessor, TableWithPrimaryKey}; pub use spacetime_module::SubscriptionHandle; pub use spacetimedb_client_api_messages::websocket::v1::Compression; @@ -63,7 +63,7 @@ pub mod __codegen { pub use crate::table::{TableLike, WithDelete, WithInsert, WithUpdate}; pub use crate::{ ConnectionId, DbConnectionBuilder, DbContext, Event, EventTable, Identity, ReducerEvent, ScheduleAt, Table, - TableWithPrimaryKey, TimeDuration, Timestamp, Uuid, + TableAccessor, TableWithPrimaryKey, TimeDuration, Timestamp, Uuid, }; } diff --git a/sdks/rust/src/table.rs b/sdks/rust/src/table.rs index cab37a1aae4..073612407b0 100644 --- a/sdks/rust/src/table.rs +++ b/sdks/rust/src/table.rs @@ -7,6 +7,33 @@ //! which mediate access to tables in the client cache. //! Obtain a table handle by calling a method on `ctx.db`, where `ctx` is a `DbConnection` or `EventContext`. +/// Accesses a generated table handle from a database view. +/// +/// For each table, this trait is implemented by a marker type generated by `spacetime generate`, +/// named in the form `{TableNamePascalCase}TableAccessor`. +/// These markers are primarily used when writing extensions to the SpacetimeDB client SDK, +/// and are not generally expected to be useful to applications building with the SpacetimeDB client SDK directly. +/// They were added for use by [the `bevy_stdb` project](https://github.com/onx2/bevy_stdb) +/// to simplify their interface for registering tables. +/// +/// An instance of the marker type which implements this trait does not directly provide access to the client cache; +/// [`TableAccessor::get`] still requires a `DbView` derived from a `DbConnection` or context. +/// The table accessor exists only to simplify type inference in generic contexts. +/// Particularly, table accessor markers do not allow side-stepping the lifetime bounds on client cache access, +/// so it is not possible to use an accessor marker to view an inconsistent client cache state through an out-of-date event context. +pub trait TableAccessor { + /// The type of rows stored in this table. + type Row: 'static; + + /// The generated table handle type for a database view borrow. + type Handle<'db> + where + DbView: 'db; + + /// Returns the generated table handle for `db`. + fn get<'db>(db: &'db DbView) -> Self::Handle<'db>; +} + /// Supports common table handle operations. /// /// This trait is implemented by generated handles for persistent tables, diff --git a/sdks/rust/tests/case-conversion-client/src/module_bindings/person_2_table.rs b/sdks/rust/tests/case-conversion-client/src/module_bindings/person_2_table.rs index 1f393bb363e..aea07899b81 100644 --- a/sdks/rust/tests/case-conversion-client/src/module_bindings/person_2_table.rs +++ b/sdks/rust/tests/case-conversion-client/src/module_bindings/person_2_table.rs @@ -19,6 +19,18 @@ pub struct Person2TableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `person_2`. +pub struct Person2TableAccessor; + +impl __sdk::TableAccessor for Person2TableAccessor { + type Row = Person2; + type Handle<'db> = Person2TableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.person_2() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `person_2`. /// diff --git a/sdks/rust/tests/case-conversion-client/src/module_bindings/person_at_level_2_table.rs b/sdks/rust/tests/case-conversion-client/src/module_bindings/person_at_level_2_table.rs index bfee10e2db1..5b1ba05fbd7 100644 --- a/sdks/rust/tests/case-conversion-client/src/module_bindings/person_at_level_2_table.rs +++ b/sdks/rust/tests/case-conversion-client/src/module_bindings/person_at_level_2_table.rs @@ -19,6 +19,18 @@ pub struct PersonAtLevel2TableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `Level2Person`. +pub struct PersonAtLevel2TableAccessor; + +impl __sdk::TableAccessor for PersonAtLevel2TableAccessor { + type Row = Person2; + type Handle<'db> = PersonAtLevel2TableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.person_at_level_2() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `Level2Person`. /// diff --git a/sdks/rust/tests/case-conversion-client/src/module_bindings/player_1_table.rs b/sdks/rust/tests/case-conversion-client/src/module_bindings/player_1_table.rs index 808263f864c..ba08974caa8 100644 --- a/sdks/rust/tests/case-conversion-client/src/module_bindings/player_1_table.rs +++ b/sdks/rust/tests/case-conversion-client/src/module_bindings/player_1_table.rs @@ -19,6 +19,18 @@ pub struct Player1TableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `Player1Canonical`. +pub struct Player1TableAccessor; + +impl __sdk::TableAccessor for Player1TableAccessor { + type Row = Player1; + type Handle<'db> = Player1TableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.player_1() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `Player1Canonical`. /// diff --git a/sdks/rust/tests/connect_disconnect_client/src/module_bindings/connected_table.rs b/sdks/rust/tests/connect_disconnect_client/src/module_bindings/connected_table.rs index a3982d98a1a..b4c0a848f78 100644 --- a/sdks/rust/tests/connect_disconnect_client/src/module_bindings/connected_table.rs +++ b/sdks/rust/tests/connect_disconnect_client/src/module_bindings/connected_table.rs @@ -18,6 +18,18 @@ pub struct ConnectedTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `connected`. +pub struct ConnectedTableAccessor; + +impl __sdk::TableAccessor for ConnectedTableAccessor { + type Row = Connected; + type Handle<'db> = ConnectedTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.connected() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `connected`. /// diff --git a/sdks/rust/tests/connect_disconnect_client/src/module_bindings/disconnected_table.rs b/sdks/rust/tests/connect_disconnect_client/src/module_bindings/disconnected_table.rs index 016c69734ed..4a773e642c7 100644 --- a/sdks/rust/tests/connect_disconnect_client/src/module_bindings/disconnected_table.rs +++ b/sdks/rust/tests/connect_disconnect_client/src/module_bindings/disconnected_table.rs @@ -18,6 +18,18 @@ pub struct DisconnectedTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `disconnected`. +pub struct DisconnectedTableAccessor; + +impl __sdk::TableAccessor for DisconnectedTableAccessor { + type Row = Disconnected; + type Handle<'db> = DisconnectedTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.disconnected() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `disconnected`. /// diff --git a/sdks/rust/tests/event-table-client/src/module_bindings/test_event_table.rs b/sdks/rust/tests/event-table-client/src/module_bindings/test_event_table.rs index c9ea4c191ed..69dfb91a1a1 100644 --- a/sdks/rust/tests/event-table-client/src/module_bindings/test_event_table.rs +++ b/sdks/rust/tests/event-table-client/src/module_bindings/test_event_table.rs @@ -18,6 +18,18 @@ pub struct TestEventTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `test_event`. +pub struct TestEventTableAccessor; + +impl __sdk::TableAccessor for TestEventTableAccessor { + type Row = TestEvent; + type Handle<'db> = TestEventTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.test_event() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `test_event`. /// diff --git a/sdks/rust/tests/procedural-view-pk-client/src/module_bindings/left_source_table.rs b/sdks/rust/tests/procedural-view-pk-client/src/module_bindings/left_source_table.rs index b8e6e48aef1..1b3130bd445 100644 --- a/sdks/rust/tests/procedural-view-pk-client/src/module_bindings/left_source_table.rs +++ b/sdks/rust/tests/procedural-view-pk-client/src/module_bindings/left_source_table.rs @@ -18,6 +18,18 @@ pub struct LeftSourceTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `left_source`. +pub struct LeftSourceTableAccessor; + +impl __sdk::TableAccessor for LeftSourceTableAccessor { + type Row = LeftSource; + type Handle<'db> = LeftSourceTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.left_source() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `left_source`. /// diff --git a/sdks/rust/tests/procedural-view-pk-client/src/module_bindings/right_source_table.rs b/sdks/rust/tests/procedural-view-pk-client/src/module_bindings/right_source_table.rs index f38392c6930..9daa51b4db1 100644 --- a/sdks/rust/tests/procedural-view-pk-client/src/module_bindings/right_source_table.rs +++ b/sdks/rust/tests/procedural-view-pk-client/src/module_bindings/right_source_table.rs @@ -18,6 +18,18 @@ pub struct RightSourceTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `right_source`. +pub struct RightSourceTableAccessor; + +impl __sdk::TableAccessor for RightSourceTableAccessor { + type Row = RightSource; + type Handle<'db> = RightSourceTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.right_source() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `right_source`. /// diff --git a/sdks/rust/tests/procedural-view-pk-client/src/module_bindings/sender_left_view_table.rs b/sdks/rust/tests/procedural-view-pk-client/src/module_bindings/sender_left_view_table.rs index c726c0ab169..43a45547d4e 100644 --- a/sdks/rust/tests/procedural-view-pk-client/src/module_bindings/sender_left_view_table.rs +++ b/sdks/rust/tests/procedural-view-pk-client/src/module_bindings/sender_left_view_table.rs @@ -18,6 +18,18 @@ pub struct SenderLeftViewTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `sender_left_view`. +pub struct SenderLeftViewTableAccessor; + +impl __sdk::TableAccessor for SenderLeftViewTableAccessor { + type Row = LeftSource; + type Handle<'db> = SenderLeftViewTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.sender_left_view() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `sender_left_view`. /// diff --git a/sdks/rust/tests/procedural-view-pk-client/src/module_bindings/sender_right_view_table.rs b/sdks/rust/tests/procedural-view-pk-client/src/module_bindings/sender_right_view_table.rs index 115b811cdf6..9b305f3fc10 100644 --- a/sdks/rust/tests/procedural-view-pk-client/src/module_bindings/sender_right_view_table.rs +++ b/sdks/rust/tests/procedural-view-pk-client/src/module_bindings/sender_right_view_table.rs @@ -18,6 +18,18 @@ pub struct SenderRightViewTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `sender_right_view`. +pub struct SenderRightViewTableAccessor; + +impl __sdk::TableAccessor for SenderRightViewTableAccessor { + type Row = RightSource; + type Handle<'db> = SenderRightViewTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.sender_right_view() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `sender_right_view`. /// diff --git a/sdks/rust/tests/procedure-client/src/module_bindings/my_table_table.rs b/sdks/rust/tests/procedure-client/src/module_bindings/my_table_table.rs index a73cb1a8a21..2ed229f6d65 100644 --- a/sdks/rust/tests/procedure-client/src/module_bindings/my_table_table.rs +++ b/sdks/rust/tests/procedure-client/src/module_bindings/my_table_table.rs @@ -19,6 +19,18 @@ pub struct MyTableTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `my_table`. +pub struct MyTableTableAccessor; + +impl __sdk::TableAccessor for MyTableTableAccessor { + type Row = MyTable; + type Handle<'db> = MyTableTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.my_table() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `my_table`. /// diff --git a/sdks/rust/tests/procedure-client/src/module_bindings/pk_uuid_table.rs b/sdks/rust/tests/procedure-client/src/module_bindings/pk_uuid_table.rs index 02eb8317a3d..57973cbfe49 100644 --- a/sdks/rust/tests/procedure-client/src/module_bindings/pk_uuid_table.rs +++ b/sdks/rust/tests/procedure-client/src/module_bindings/pk_uuid_table.rs @@ -18,6 +18,18 @@ pub struct PkUuidTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `pk_uuid`. +pub struct PkUuidTableAccessor; + +impl __sdk::TableAccessor for PkUuidTableAccessor { + type Row = PkUuid; + type Handle<'db> = PkUuidTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.pk_uuid() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `pk_uuid`. /// diff --git a/sdks/rust/tests/procedure-client/src/module_bindings/proc_inserts_into_table.rs b/sdks/rust/tests/procedure-client/src/module_bindings/proc_inserts_into_table.rs index c0640413dcf..5452771b99c 100644 --- a/sdks/rust/tests/procedure-client/src/module_bindings/proc_inserts_into_table.rs +++ b/sdks/rust/tests/procedure-client/src/module_bindings/proc_inserts_into_table.rs @@ -18,6 +18,18 @@ pub struct ProcInsertsIntoTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `proc_inserts_into`. +pub struct ProcInsertsIntoTableAccessor; + +impl __sdk::TableAccessor for ProcInsertsIntoTableAccessor { + type Row = ProcInsertsInto; + type Handle<'db> = ProcInsertsIntoTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.proc_inserts_into() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `proc_inserts_into`. /// diff --git a/sdks/rust/tests/procedure-client/src/module_bindings/scheduled_proc_table_table.rs b/sdks/rust/tests/procedure-client/src/module_bindings/scheduled_proc_table_table.rs index f1306bfdac6..26f7f7fb0f5 100644 --- a/sdks/rust/tests/procedure-client/src/module_bindings/scheduled_proc_table_table.rs +++ b/sdks/rust/tests/procedure-client/src/module_bindings/scheduled_proc_table_table.rs @@ -18,6 +18,18 @@ pub struct ScheduledProcTableTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `scheduled_proc_table`. +pub struct ScheduledProcTableTableAccessor; + +impl __sdk::TableAccessor for ScheduledProcTableTableAccessor { + type Row = ScheduledProcTable; + type Handle<'db> = ScheduledProcTableTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.scheduled_proc_table() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `scheduled_proc_table`. /// diff --git a/sdks/rust/tests/procedure-concurrency-client/src/module_bindings/procedure_concurrency_row_table.rs b/sdks/rust/tests/procedure-concurrency-client/src/module_bindings/procedure_concurrency_row_table.rs index 13ae176b730..087b297d76a 100644 --- a/sdks/rust/tests/procedure-concurrency-client/src/module_bindings/procedure_concurrency_row_table.rs +++ b/sdks/rust/tests/procedure-concurrency-client/src/module_bindings/procedure_concurrency_row_table.rs @@ -18,6 +18,18 @@ pub struct ProcedureConcurrencyRowTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `procedure_concurrency_row`. +pub struct ProcedureConcurrencyRowTableAccessor; + +impl __sdk::TableAccessor for ProcedureConcurrencyRowTableAccessor { + type Row = ProcedureConcurrencyRow; + type Handle<'db> = ProcedureConcurrencyRowTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.procedure_concurrency_row() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `procedure_concurrency_row`. /// diff --git a/sdks/rust/tests/procedure-concurrency-client/src/module_bindings/scheduled_procedure_row_table.rs b/sdks/rust/tests/procedure-concurrency-client/src/module_bindings/scheduled_procedure_row_table.rs index 4ee8c3b4cb6..dedc5bf64cd 100644 --- a/sdks/rust/tests/procedure-concurrency-client/src/module_bindings/scheduled_procedure_row_table.rs +++ b/sdks/rust/tests/procedure-concurrency-client/src/module_bindings/scheduled_procedure_row_table.rs @@ -18,6 +18,18 @@ pub struct ScheduledProcedureRowTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `scheduled_procedure_row`. +pub struct ScheduledProcedureRowTableAccessor; + +impl __sdk::TableAccessor for ScheduledProcedureRowTableAccessor { + type Row = ScheduledProcedureRow; + type Handle<'db> = ScheduledProcedureRowTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.scheduled_procedure_row() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `scheduled_procedure_row`. /// diff --git a/sdks/rust/tests/procedure-concurrency-client/src/module_bindings/scheduled_reducer_row_table.rs b/sdks/rust/tests/procedure-concurrency-client/src/module_bindings/scheduled_reducer_row_table.rs index 53df5f6470f..c4fd87011fe 100644 --- a/sdks/rust/tests/procedure-concurrency-client/src/module_bindings/scheduled_reducer_row_table.rs +++ b/sdks/rust/tests/procedure-concurrency-client/src/module_bindings/scheduled_reducer_row_table.rs @@ -18,6 +18,18 @@ pub struct ScheduledReducerRowTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `scheduled_reducer_row`. +pub struct ScheduledReducerRowTableAccessor; + +impl __sdk::TableAccessor for ScheduledReducerRowTableAccessor { + type Row = ScheduledReducerRow; + type Handle<'db> = ScheduledReducerRowTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.scheduled_reducer_row() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `scheduled_reducer_row`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/btree_u_32_table.rs b/sdks/rust/tests/test-client/src/module_bindings/btree_u_32_table.rs index b300ed6b893..ce932e03083 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/btree_u_32_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/btree_u_32_table.rs @@ -18,6 +18,18 @@ pub struct BtreeU32TableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `btree_u_32`. +pub struct BtreeU32TableAccessor; + +impl __sdk::TableAccessor for BtreeU32TableAccessor { + type Row = BTreeU32; + type Handle<'db> = BtreeU32TableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.btree_u_32() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `btree_u_32`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/indexed_simple_enum_table.rs b/sdks/rust/tests/test-client/src/module_bindings/indexed_simple_enum_table.rs index 86fd8181760..7bd892a29b9 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/indexed_simple_enum_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/indexed_simple_enum_table.rs @@ -19,6 +19,18 @@ pub struct IndexedSimpleEnumTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `indexed_simple_enum`. +pub struct IndexedSimpleEnumTableAccessor; + +impl __sdk::TableAccessor for IndexedSimpleEnumTableAccessor { + type Row = IndexedSimpleEnum; + type Handle<'db> = IndexedSimpleEnumTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.indexed_simple_enum() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `indexed_simple_enum`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/indexed_table_2_table.rs b/sdks/rust/tests/test-client/src/module_bindings/indexed_table_2_table.rs index 191f33f44e2..46956f337fb 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/indexed_table_2_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/indexed_table_2_table.rs @@ -18,6 +18,18 @@ pub struct IndexedTable2TableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `indexed_table_2`. +pub struct IndexedTable2TableAccessor; + +impl __sdk::TableAccessor for IndexedTable2TableAccessor { + type Row = IndexedTable2; + type Handle<'db> = IndexedTable2TableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.indexed_table_2() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `indexed_table_2`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/indexed_table_table.rs b/sdks/rust/tests/test-client/src/module_bindings/indexed_table_table.rs index db8eddbd44e..32a6dc67625 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/indexed_table_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/indexed_table_table.rs @@ -18,6 +18,18 @@ pub struct IndexedTableTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `indexed_table`. +pub struct IndexedTableTableAccessor; + +impl __sdk::TableAccessor for IndexedTableTableAccessor { + type Row = IndexedTable; + type Handle<'db> = IndexedTableTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.indexed_table() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `indexed_table`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/large_table_table.rs b/sdks/rust/tests/test-client/src/module_bindings/large_table_table.rs index b39c3d54f35..d7ac9462f97 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/large_table_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/large_table_table.rs @@ -24,6 +24,18 @@ pub struct LargeTableTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `large_table`. +pub struct LargeTableTableAccessor; + +impl __sdk::TableAccessor for LargeTableTableAccessor { + type Row = LargeTable; + type Handle<'db> = LargeTableTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.large_table() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `large_table`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/one_bool_table.rs b/sdks/rust/tests/test-client/src/module_bindings/one_bool_table.rs index d38947948c1..b6bed674e6e 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/one_bool_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/one_bool_table.rs @@ -18,6 +18,18 @@ pub struct OneBoolTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `one_bool`. +pub struct OneBoolTableAccessor; + +impl __sdk::TableAccessor for OneBoolTableAccessor { + type Row = OneBool; + type Handle<'db> = OneBoolTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.one_bool() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `one_bool`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/one_byte_struct_table.rs b/sdks/rust/tests/test-client/src/module_bindings/one_byte_struct_table.rs index 405579dc312..5ba05e290d4 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/one_byte_struct_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/one_byte_struct_table.rs @@ -19,6 +19,18 @@ pub struct OneByteStructTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `one_byte_struct`. +pub struct OneByteStructTableAccessor; + +impl __sdk::TableAccessor for OneByteStructTableAccessor { + type Row = OneByteStruct; + type Handle<'db> = OneByteStructTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.one_byte_struct() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `one_byte_struct`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/one_connection_id_table.rs b/sdks/rust/tests/test-client/src/module_bindings/one_connection_id_table.rs index 08d32fb1112..f3325018b22 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/one_connection_id_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/one_connection_id_table.rs @@ -18,6 +18,18 @@ pub struct OneConnectionIdTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `one_connection_id`. +pub struct OneConnectionIdTableAccessor; + +impl __sdk::TableAccessor for OneConnectionIdTableAccessor { + type Row = OneConnectionId; + type Handle<'db> = OneConnectionIdTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.one_connection_id() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `one_connection_id`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/one_enum_with_payload_table.rs b/sdks/rust/tests/test-client/src/module_bindings/one_enum_with_payload_table.rs index 93c8fbc69f0..9de891003c2 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/one_enum_with_payload_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/one_enum_with_payload_table.rs @@ -19,6 +19,18 @@ pub struct OneEnumWithPayloadTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `one_enum_with_payload`. +pub struct OneEnumWithPayloadTableAccessor; + +impl __sdk::TableAccessor for OneEnumWithPayloadTableAccessor { + type Row = OneEnumWithPayload; + type Handle<'db> = OneEnumWithPayloadTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.one_enum_with_payload() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `one_enum_with_payload`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/one_every_primitive_struct_table.rs b/sdks/rust/tests/test-client/src/module_bindings/one_every_primitive_struct_table.rs index dfc98309166..d3637d74a82 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/one_every_primitive_struct_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/one_every_primitive_struct_table.rs @@ -19,6 +19,18 @@ pub struct OneEveryPrimitiveStructTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `one_every_primitive_struct`. +pub struct OneEveryPrimitiveStructTableAccessor; + +impl __sdk::TableAccessor for OneEveryPrimitiveStructTableAccessor { + type Row = OneEveryPrimitiveStruct; + type Handle<'db> = OneEveryPrimitiveStructTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.one_every_primitive_struct() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `one_every_primitive_struct`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/one_every_vec_struct_table.rs b/sdks/rust/tests/test-client/src/module_bindings/one_every_vec_struct_table.rs index cadab9022f4..5262a4bc224 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/one_every_vec_struct_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/one_every_vec_struct_table.rs @@ -19,6 +19,18 @@ pub struct OneEveryVecStructTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `one_every_vec_struct`. +pub struct OneEveryVecStructTableAccessor; + +impl __sdk::TableAccessor for OneEveryVecStructTableAccessor { + type Row = OneEveryVecStruct; + type Handle<'db> = OneEveryVecStructTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.one_every_vec_struct() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `one_every_vec_struct`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/one_f_32_table.rs b/sdks/rust/tests/test-client/src/module_bindings/one_f_32_table.rs index 68ecc5c0cc7..6bc485dce7f 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/one_f_32_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/one_f_32_table.rs @@ -18,6 +18,18 @@ pub struct OneF32TableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `one_f_32`. +pub struct OneF32TableAccessor; + +impl __sdk::TableAccessor for OneF32TableAccessor { + type Row = OneF32; + type Handle<'db> = OneF32TableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.one_f_32() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `one_f_32`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/one_f_64_table.rs b/sdks/rust/tests/test-client/src/module_bindings/one_f_64_table.rs index ddfc832020a..58b748b791a 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/one_f_64_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/one_f_64_table.rs @@ -18,6 +18,18 @@ pub struct OneF64TableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `one_f_64`. +pub struct OneF64TableAccessor; + +impl __sdk::TableAccessor for OneF64TableAccessor { + type Row = OneF64; + type Handle<'db> = OneF64TableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.one_f_64() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `one_f_64`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/one_i_128_table.rs b/sdks/rust/tests/test-client/src/module_bindings/one_i_128_table.rs index 4561ae243fc..3bafe09a9bd 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/one_i_128_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/one_i_128_table.rs @@ -18,6 +18,18 @@ pub struct OneI128TableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `one_i_128`. +pub struct OneI128TableAccessor; + +impl __sdk::TableAccessor for OneI128TableAccessor { + type Row = OneI128; + type Handle<'db> = OneI128TableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.one_i_128() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `one_i_128`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/one_i_16_table.rs b/sdks/rust/tests/test-client/src/module_bindings/one_i_16_table.rs index 1185b986cda..ef7b5a58f69 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/one_i_16_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/one_i_16_table.rs @@ -18,6 +18,18 @@ pub struct OneI16TableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `one_i_16`. +pub struct OneI16TableAccessor; + +impl __sdk::TableAccessor for OneI16TableAccessor { + type Row = OneI16; + type Handle<'db> = OneI16TableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.one_i_16() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `one_i_16`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/one_i_256_table.rs b/sdks/rust/tests/test-client/src/module_bindings/one_i_256_table.rs index 8d18514eb2a..e3e045dd8e5 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/one_i_256_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/one_i_256_table.rs @@ -18,6 +18,18 @@ pub struct OneI256TableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `one_i_256`. +pub struct OneI256TableAccessor; + +impl __sdk::TableAccessor for OneI256TableAccessor { + type Row = OneI256; + type Handle<'db> = OneI256TableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.one_i_256() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `one_i_256`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/one_i_32_table.rs b/sdks/rust/tests/test-client/src/module_bindings/one_i_32_table.rs index 6e12c0fcfa1..1d9ad4c6371 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/one_i_32_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/one_i_32_table.rs @@ -18,6 +18,18 @@ pub struct OneI32TableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `one_i_32`. +pub struct OneI32TableAccessor; + +impl __sdk::TableAccessor for OneI32TableAccessor { + type Row = OneI32; + type Handle<'db> = OneI32TableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.one_i_32() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `one_i_32`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/one_i_64_table.rs b/sdks/rust/tests/test-client/src/module_bindings/one_i_64_table.rs index b675f4fa334..11e106acc9c 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/one_i_64_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/one_i_64_table.rs @@ -18,6 +18,18 @@ pub struct OneI64TableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `one_i_64`. +pub struct OneI64TableAccessor; + +impl __sdk::TableAccessor for OneI64TableAccessor { + type Row = OneI64; + type Handle<'db> = OneI64TableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.one_i_64() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `one_i_64`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/one_i_8_table.rs b/sdks/rust/tests/test-client/src/module_bindings/one_i_8_table.rs index c876380b01f..05531bcd156 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/one_i_8_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/one_i_8_table.rs @@ -18,6 +18,18 @@ pub struct OneI8TableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `one_i_8`. +pub struct OneI8TableAccessor; + +impl __sdk::TableAccessor for OneI8TableAccessor { + type Row = OneI8; + type Handle<'db> = OneI8TableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.one_i_8() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `one_i_8`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/one_identity_table.rs b/sdks/rust/tests/test-client/src/module_bindings/one_identity_table.rs index 8e2c662cdd1..38a55e1507d 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/one_identity_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/one_identity_table.rs @@ -18,6 +18,18 @@ pub struct OneIdentityTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `one_identity`. +pub struct OneIdentityTableAccessor; + +impl __sdk::TableAccessor for OneIdentityTableAccessor { + type Row = OneIdentity; + type Handle<'db> = OneIdentityTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.one_identity() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `one_identity`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/one_simple_enum_table.rs b/sdks/rust/tests/test-client/src/module_bindings/one_simple_enum_table.rs index e42d15c2077..96ccaa82a85 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/one_simple_enum_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/one_simple_enum_table.rs @@ -19,6 +19,18 @@ pub struct OneSimpleEnumTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `one_simple_enum`. +pub struct OneSimpleEnumTableAccessor; + +impl __sdk::TableAccessor for OneSimpleEnumTableAccessor { + type Row = OneSimpleEnum; + type Handle<'db> = OneSimpleEnumTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.one_simple_enum() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `one_simple_enum`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/one_string_table.rs b/sdks/rust/tests/test-client/src/module_bindings/one_string_table.rs index 9ee55deda50..56699df2b3a 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/one_string_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/one_string_table.rs @@ -18,6 +18,18 @@ pub struct OneStringTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `one_string`. +pub struct OneStringTableAccessor; + +impl __sdk::TableAccessor for OneStringTableAccessor { + type Row = OneString; + type Handle<'db> = OneStringTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.one_string() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `one_string`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/one_timestamp_table.rs b/sdks/rust/tests/test-client/src/module_bindings/one_timestamp_table.rs index fe41bdb2512..847eb2ebfd7 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/one_timestamp_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/one_timestamp_table.rs @@ -18,6 +18,18 @@ pub struct OneTimestampTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `one_timestamp`. +pub struct OneTimestampTableAccessor; + +impl __sdk::TableAccessor for OneTimestampTableAccessor { + type Row = OneTimestamp; + type Handle<'db> = OneTimestampTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.one_timestamp() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `one_timestamp`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/one_u_128_table.rs b/sdks/rust/tests/test-client/src/module_bindings/one_u_128_table.rs index 42b771ced2d..8a3fbbd5716 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/one_u_128_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/one_u_128_table.rs @@ -18,6 +18,18 @@ pub struct OneU128TableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `one_u_128`. +pub struct OneU128TableAccessor; + +impl __sdk::TableAccessor for OneU128TableAccessor { + type Row = OneU128; + type Handle<'db> = OneU128TableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.one_u_128() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `one_u_128`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/one_u_16_table.rs b/sdks/rust/tests/test-client/src/module_bindings/one_u_16_table.rs index 24304f74c34..cba5163ba55 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/one_u_16_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/one_u_16_table.rs @@ -18,6 +18,18 @@ pub struct OneU16TableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `one_u_16`. +pub struct OneU16TableAccessor; + +impl __sdk::TableAccessor for OneU16TableAccessor { + type Row = OneU16; + type Handle<'db> = OneU16TableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.one_u_16() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `one_u_16`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/one_u_256_table.rs b/sdks/rust/tests/test-client/src/module_bindings/one_u_256_table.rs index 2c0d2429009..bb1d952106a 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/one_u_256_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/one_u_256_table.rs @@ -18,6 +18,18 @@ pub struct OneU256TableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `one_u_256`. +pub struct OneU256TableAccessor; + +impl __sdk::TableAccessor for OneU256TableAccessor { + type Row = OneU256; + type Handle<'db> = OneU256TableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.one_u_256() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `one_u_256`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/one_u_32_table.rs b/sdks/rust/tests/test-client/src/module_bindings/one_u_32_table.rs index 49ca5793a4e..51702285dac 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/one_u_32_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/one_u_32_table.rs @@ -18,6 +18,18 @@ pub struct OneU32TableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `one_u_32`. +pub struct OneU32TableAccessor; + +impl __sdk::TableAccessor for OneU32TableAccessor { + type Row = OneU32; + type Handle<'db> = OneU32TableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.one_u_32() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `one_u_32`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/one_u_64_table.rs b/sdks/rust/tests/test-client/src/module_bindings/one_u_64_table.rs index d08eb70f82f..011906d80b9 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/one_u_64_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/one_u_64_table.rs @@ -18,6 +18,18 @@ pub struct OneU64TableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `one_u_64`. +pub struct OneU64TableAccessor; + +impl __sdk::TableAccessor for OneU64TableAccessor { + type Row = OneU64; + type Handle<'db> = OneU64TableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.one_u_64() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `one_u_64`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/one_u_8_table.rs b/sdks/rust/tests/test-client/src/module_bindings/one_u_8_table.rs index fe8253cd4bb..18b0d73d5e8 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/one_u_8_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/one_u_8_table.rs @@ -18,6 +18,18 @@ pub struct OneU8TableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `one_u_8`. +pub struct OneU8TableAccessor; + +impl __sdk::TableAccessor for OneU8TableAccessor { + type Row = OneU8; + type Handle<'db> = OneU8TableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.one_u_8() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `one_u_8`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/one_unit_struct_table.rs b/sdks/rust/tests/test-client/src/module_bindings/one_unit_struct_table.rs index 37c2c202449..6eb8e0a443f 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/one_unit_struct_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/one_unit_struct_table.rs @@ -19,6 +19,18 @@ pub struct OneUnitStructTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `one_unit_struct`. +pub struct OneUnitStructTableAccessor; + +impl __sdk::TableAccessor for OneUnitStructTableAccessor { + type Row = OneUnitStruct; + type Handle<'db> = OneUnitStructTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.one_unit_struct() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `one_unit_struct`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/one_uuid_table.rs b/sdks/rust/tests/test-client/src/module_bindings/one_uuid_table.rs index cf1cb173198..f7070635839 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/one_uuid_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/one_uuid_table.rs @@ -18,6 +18,18 @@ pub struct OneUuidTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `one_uuid`. +pub struct OneUuidTableAccessor; + +impl __sdk::TableAccessor for OneUuidTableAccessor { + type Row = OneUuid; + type Handle<'db> = OneUuidTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.one_uuid() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `one_uuid`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/option_every_primitive_struct_table.rs b/sdks/rust/tests/test-client/src/module_bindings/option_every_primitive_struct_table.rs index bf05c2bc2d8..593708b909d 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/option_every_primitive_struct_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/option_every_primitive_struct_table.rs @@ -19,6 +19,18 @@ pub struct OptionEveryPrimitiveStructTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `option_every_primitive_struct`. +pub struct OptionEveryPrimitiveStructTableAccessor; + +impl __sdk::TableAccessor for OptionEveryPrimitiveStructTableAccessor { + type Row = OptionEveryPrimitiveStruct; + type Handle<'db> = OptionEveryPrimitiveStructTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.option_every_primitive_struct() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `option_every_primitive_struct`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/option_i_32_table.rs b/sdks/rust/tests/test-client/src/module_bindings/option_i_32_table.rs index f258c4b766f..1909bc4eede 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/option_i_32_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/option_i_32_table.rs @@ -18,6 +18,18 @@ pub struct OptionI32TableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `option_i_32`. +pub struct OptionI32TableAccessor; + +impl __sdk::TableAccessor for OptionI32TableAccessor { + type Row = OptionI32; + type Handle<'db> = OptionI32TableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.option_i_32() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `option_i_32`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/option_identity_table.rs b/sdks/rust/tests/test-client/src/module_bindings/option_identity_table.rs index 71bc61478d4..4da2a2deed4 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/option_identity_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/option_identity_table.rs @@ -18,6 +18,18 @@ pub struct OptionIdentityTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `option_identity`. +pub struct OptionIdentityTableAccessor; + +impl __sdk::TableAccessor for OptionIdentityTableAccessor { + type Row = OptionIdentity; + type Handle<'db> = OptionIdentityTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.option_identity() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `option_identity`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/option_simple_enum_table.rs b/sdks/rust/tests/test-client/src/module_bindings/option_simple_enum_table.rs index 8b9dd418f72..f70331ce40f 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/option_simple_enum_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/option_simple_enum_table.rs @@ -19,6 +19,18 @@ pub struct OptionSimpleEnumTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `option_simple_enum`. +pub struct OptionSimpleEnumTableAccessor; + +impl __sdk::TableAccessor for OptionSimpleEnumTableAccessor { + type Row = OptionSimpleEnum; + type Handle<'db> = OptionSimpleEnumTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.option_simple_enum() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `option_simple_enum`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/option_string_table.rs b/sdks/rust/tests/test-client/src/module_bindings/option_string_table.rs index da4fe6847b8..657411b0f47 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/option_string_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/option_string_table.rs @@ -18,6 +18,18 @@ pub struct OptionStringTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `option_string`. +pub struct OptionStringTableAccessor; + +impl __sdk::TableAccessor for OptionStringTableAccessor { + type Row = OptionString; + type Handle<'db> = OptionStringTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.option_string() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `option_string`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/option_uuid_table.rs b/sdks/rust/tests/test-client/src/module_bindings/option_uuid_table.rs index 8b86e2bbfc1..1d4502ac7bb 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/option_uuid_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/option_uuid_table.rs @@ -18,6 +18,18 @@ pub struct OptionUuidTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `option_uuid`. +pub struct OptionUuidTableAccessor; + +impl __sdk::TableAccessor for OptionUuidTableAccessor { + type Row = OptionUuid; + type Handle<'db> = OptionUuidTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.option_uuid() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `option_uuid`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/option_vec_option_i_32_table.rs b/sdks/rust/tests/test-client/src/module_bindings/option_vec_option_i_32_table.rs index 846f58a0fb9..7e334e7d4fc 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/option_vec_option_i_32_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/option_vec_option_i_32_table.rs @@ -18,6 +18,18 @@ pub struct OptionVecOptionI32TableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `option_vec_option_i_32`. +pub struct OptionVecOptionI32TableAccessor; + +impl __sdk::TableAccessor for OptionVecOptionI32TableAccessor { + type Row = OptionVecOptionI32; + type Handle<'db> = OptionVecOptionI32TableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.option_vec_option_i_32() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `option_vec_option_i_32`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/pk_bool_table.rs b/sdks/rust/tests/test-client/src/module_bindings/pk_bool_table.rs index 6fbe2b0bfa0..09cd4486599 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/pk_bool_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/pk_bool_table.rs @@ -18,6 +18,18 @@ pub struct PkBoolTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `pk_bool`. +pub struct PkBoolTableAccessor; + +impl __sdk::TableAccessor for PkBoolTableAccessor { + type Row = PkBool; + type Handle<'db> = PkBoolTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.pk_bool() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `pk_bool`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/pk_connection_id_table.rs b/sdks/rust/tests/test-client/src/module_bindings/pk_connection_id_table.rs index 65e934ca2e4..f2ca80fea2d 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/pk_connection_id_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/pk_connection_id_table.rs @@ -18,6 +18,18 @@ pub struct PkConnectionIdTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `pk_connection_id`. +pub struct PkConnectionIdTableAccessor; + +impl __sdk::TableAccessor for PkConnectionIdTableAccessor { + type Row = PkConnectionId; + type Handle<'db> = PkConnectionIdTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.pk_connection_id() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `pk_connection_id`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/pk_i_128_table.rs b/sdks/rust/tests/test-client/src/module_bindings/pk_i_128_table.rs index 48334cbeb56..3ee9b76ac48 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/pk_i_128_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/pk_i_128_table.rs @@ -18,6 +18,18 @@ pub struct PkI128TableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `pk_i_128`. +pub struct PkI128TableAccessor; + +impl __sdk::TableAccessor for PkI128TableAccessor { + type Row = PkI128; + type Handle<'db> = PkI128TableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.pk_i_128() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `pk_i_128`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/pk_i_16_table.rs b/sdks/rust/tests/test-client/src/module_bindings/pk_i_16_table.rs index 57385478ff1..1d1c67764ac 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/pk_i_16_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/pk_i_16_table.rs @@ -18,6 +18,18 @@ pub struct PkI16TableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `pk_i_16`. +pub struct PkI16TableAccessor; + +impl __sdk::TableAccessor for PkI16TableAccessor { + type Row = PkI16; + type Handle<'db> = PkI16TableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.pk_i_16() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `pk_i_16`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/pk_i_256_table.rs b/sdks/rust/tests/test-client/src/module_bindings/pk_i_256_table.rs index e1773cce5ec..79e33cfa909 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/pk_i_256_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/pk_i_256_table.rs @@ -18,6 +18,18 @@ pub struct PkI256TableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `pk_i_256`. +pub struct PkI256TableAccessor; + +impl __sdk::TableAccessor for PkI256TableAccessor { + type Row = PkI256; + type Handle<'db> = PkI256TableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.pk_i_256() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `pk_i_256`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/pk_i_32_table.rs b/sdks/rust/tests/test-client/src/module_bindings/pk_i_32_table.rs index a6f2b5420a4..26b6f4f2ed2 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/pk_i_32_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/pk_i_32_table.rs @@ -18,6 +18,18 @@ pub struct PkI32TableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `pk_i_32`. +pub struct PkI32TableAccessor; + +impl __sdk::TableAccessor for PkI32TableAccessor { + type Row = PkI32; + type Handle<'db> = PkI32TableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.pk_i_32() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `pk_i_32`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/pk_i_64_table.rs b/sdks/rust/tests/test-client/src/module_bindings/pk_i_64_table.rs index 7d475550a75..8a5e53511c3 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/pk_i_64_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/pk_i_64_table.rs @@ -18,6 +18,18 @@ pub struct PkI64TableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `pk_i_64`. +pub struct PkI64TableAccessor; + +impl __sdk::TableAccessor for PkI64TableAccessor { + type Row = PkI64; + type Handle<'db> = PkI64TableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.pk_i_64() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `pk_i_64`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/pk_i_8_table.rs b/sdks/rust/tests/test-client/src/module_bindings/pk_i_8_table.rs index 7bd855da69c..4171162fd68 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/pk_i_8_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/pk_i_8_table.rs @@ -18,6 +18,18 @@ pub struct PkI8TableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `pk_i_8`. +pub struct PkI8TableAccessor; + +impl __sdk::TableAccessor for PkI8TableAccessor { + type Row = PkI8; + type Handle<'db> = PkI8TableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.pk_i_8() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `pk_i_8`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/pk_identity_table.rs b/sdks/rust/tests/test-client/src/module_bindings/pk_identity_table.rs index b417e16ba9c..c29eb924357 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/pk_identity_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/pk_identity_table.rs @@ -18,6 +18,18 @@ pub struct PkIdentityTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `pk_identity`. +pub struct PkIdentityTableAccessor; + +impl __sdk::TableAccessor for PkIdentityTableAccessor { + type Row = PkIdentity; + type Handle<'db> = PkIdentityTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.pk_identity() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `pk_identity`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/pk_simple_enum_table.rs b/sdks/rust/tests/test-client/src/module_bindings/pk_simple_enum_table.rs index afc74ef7579..f145431ff60 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/pk_simple_enum_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/pk_simple_enum_table.rs @@ -19,6 +19,18 @@ pub struct PkSimpleEnumTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `pk_simple_enum`. +pub struct PkSimpleEnumTableAccessor; + +impl __sdk::TableAccessor for PkSimpleEnumTableAccessor { + type Row = PkSimpleEnum; + type Handle<'db> = PkSimpleEnumTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.pk_simple_enum() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `pk_simple_enum`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/pk_string_table.rs b/sdks/rust/tests/test-client/src/module_bindings/pk_string_table.rs index 1bbb673b6d0..7c7577bd403 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/pk_string_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/pk_string_table.rs @@ -18,6 +18,18 @@ pub struct PkStringTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `pk_string`. +pub struct PkStringTableAccessor; + +impl __sdk::TableAccessor for PkStringTableAccessor { + type Row = PkString; + type Handle<'db> = PkStringTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.pk_string() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `pk_string`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/pk_u_128_table.rs b/sdks/rust/tests/test-client/src/module_bindings/pk_u_128_table.rs index 4980c0a487f..ba09eb67f42 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/pk_u_128_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/pk_u_128_table.rs @@ -18,6 +18,18 @@ pub struct PkU128TableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `pk_u_128`. +pub struct PkU128TableAccessor; + +impl __sdk::TableAccessor for PkU128TableAccessor { + type Row = PkU128; + type Handle<'db> = PkU128TableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.pk_u_128() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `pk_u_128`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/pk_u_16_table.rs b/sdks/rust/tests/test-client/src/module_bindings/pk_u_16_table.rs index 6df02f1f9f6..140f4d69ec3 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/pk_u_16_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/pk_u_16_table.rs @@ -18,6 +18,18 @@ pub struct PkU16TableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `pk_u_16`. +pub struct PkU16TableAccessor; + +impl __sdk::TableAccessor for PkU16TableAccessor { + type Row = PkU16; + type Handle<'db> = PkU16TableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.pk_u_16() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `pk_u_16`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/pk_u_256_table.rs b/sdks/rust/tests/test-client/src/module_bindings/pk_u_256_table.rs index 92edd27c363..ac307d969a8 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/pk_u_256_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/pk_u_256_table.rs @@ -18,6 +18,18 @@ pub struct PkU256TableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `pk_u_256`. +pub struct PkU256TableAccessor; + +impl __sdk::TableAccessor for PkU256TableAccessor { + type Row = PkU256; + type Handle<'db> = PkU256TableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.pk_u_256() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `pk_u_256`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/pk_u_32_table.rs b/sdks/rust/tests/test-client/src/module_bindings/pk_u_32_table.rs index 1af468b8d3a..48b2289e5c0 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/pk_u_32_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/pk_u_32_table.rs @@ -18,6 +18,18 @@ pub struct PkU32TableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `pk_u_32`. +pub struct PkU32TableAccessor; + +impl __sdk::TableAccessor for PkU32TableAccessor { + type Row = PkU32; + type Handle<'db> = PkU32TableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.pk_u_32() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `pk_u_32`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/pk_u_32_two_table.rs b/sdks/rust/tests/test-client/src/module_bindings/pk_u_32_two_table.rs index 9f9a8c07518..8d434f991d0 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/pk_u_32_two_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/pk_u_32_two_table.rs @@ -18,6 +18,18 @@ pub struct PkU32TwoTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `pk_u_32_two`. +pub struct PkU32TwoTableAccessor; + +impl __sdk::TableAccessor for PkU32TwoTableAccessor { + type Row = PkU32Two; + type Handle<'db> = PkU32TwoTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.pk_u_32_two() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `pk_u_32_two`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/pk_u_64_table.rs b/sdks/rust/tests/test-client/src/module_bindings/pk_u_64_table.rs index 0531895f2bb..6fd0fc782e9 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/pk_u_64_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/pk_u_64_table.rs @@ -18,6 +18,18 @@ pub struct PkU64TableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `pk_u_64`. +pub struct PkU64TableAccessor; + +impl __sdk::TableAccessor for PkU64TableAccessor { + type Row = PkU64; + type Handle<'db> = PkU64TableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.pk_u_64() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `pk_u_64`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/pk_u_8_table.rs b/sdks/rust/tests/test-client/src/module_bindings/pk_u_8_table.rs index 4417012752d..25fda01e9d2 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/pk_u_8_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/pk_u_8_table.rs @@ -18,6 +18,18 @@ pub struct PkU8TableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `pk_u_8`. +pub struct PkU8TableAccessor; + +impl __sdk::TableAccessor for PkU8TableAccessor { + type Row = PkU8; + type Handle<'db> = PkU8TableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.pk_u_8() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `pk_u_8`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/pk_uuid_table.rs b/sdks/rust/tests/test-client/src/module_bindings/pk_uuid_table.rs index 132ccb20ddb..4056fbd6ceb 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/pk_uuid_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/pk_uuid_table.rs @@ -18,6 +18,18 @@ pub struct PkUuidTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `pk_uuid`. +pub struct PkUuidTableAccessor; + +impl __sdk::TableAccessor for PkUuidTableAccessor { + type Row = PkUuid; + type Handle<'db> = PkUuidTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.pk_uuid() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `pk_uuid`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/result_every_primitive_struct_string_table.rs b/sdks/rust/tests/test-client/src/module_bindings/result_every_primitive_struct_string_table.rs index 8f0f9404579..e77cb2ac6b0 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/result_every_primitive_struct_string_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/result_every_primitive_struct_string_table.rs @@ -19,6 +19,18 @@ pub struct ResultEveryPrimitiveStructStringTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `result_every_primitive_struct_string`. +pub struct ResultEveryPrimitiveStructStringTableAccessor; + +impl __sdk::TableAccessor for ResultEveryPrimitiveStructStringTableAccessor { + type Row = ResultEveryPrimitiveStructString; + type Handle<'db> = ResultEveryPrimitiveStructStringTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.result_every_primitive_struct_string() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `result_every_primitive_struct_string`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/result_i_32_string_table.rs b/sdks/rust/tests/test-client/src/module_bindings/result_i_32_string_table.rs index 5568835f64f..8b9fe084fda 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/result_i_32_string_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/result_i_32_string_table.rs @@ -18,6 +18,18 @@ pub struct ResultI32StringTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `result_i_32_string`. +pub struct ResultI32StringTableAccessor; + +impl __sdk::TableAccessor for ResultI32StringTableAccessor { + type Row = ResultI32String; + type Handle<'db> = ResultI32StringTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.result_i_32_string() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `result_i_32_string`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/result_identity_string_table.rs b/sdks/rust/tests/test-client/src/module_bindings/result_identity_string_table.rs index fe9369b98e7..6021a251cb6 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/result_identity_string_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/result_identity_string_table.rs @@ -18,6 +18,18 @@ pub struct ResultIdentityStringTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `result_identity_string`. +pub struct ResultIdentityStringTableAccessor; + +impl __sdk::TableAccessor for ResultIdentityStringTableAccessor { + type Row = ResultIdentityString; + type Handle<'db> = ResultIdentityStringTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.result_identity_string() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `result_identity_string`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/result_simple_enum_i_32_table.rs b/sdks/rust/tests/test-client/src/module_bindings/result_simple_enum_i_32_table.rs index 7dbae96f279..b1ffebdfd22 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/result_simple_enum_i_32_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/result_simple_enum_i_32_table.rs @@ -19,6 +19,18 @@ pub struct ResultSimpleEnumI32TableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `result_simple_enum_i_32`. +pub struct ResultSimpleEnumI32TableAccessor; + +impl __sdk::TableAccessor for ResultSimpleEnumI32TableAccessor { + type Row = ResultSimpleEnumI32; + type Handle<'db> = ResultSimpleEnumI32TableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.result_simple_enum_i_32() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `result_simple_enum_i_32`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/result_string_i_32_table.rs b/sdks/rust/tests/test-client/src/module_bindings/result_string_i_32_table.rs index 8f02d461414..f5e0d8ed915 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/result_string_i_32_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/result_string_i_32_table.rs @@ -18,6 +18,18 @@ pub struct ResultStringI32TableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `result_string_i_32`. +pub struct ResultStringI32TableAccessor; + +impl __sdk::TableAccessor for ResultStringI32TableAccessor { + type Row = ResultStringI32; + type Handle<'db> = ResultStringI32TableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.result_string_i_32() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `result_string_i_32`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/result_vec_i_32_string_table.rs b/sdks/rust/tests/test-client/src/module_bindings/result_vec_i_32_string_table.rs index 5de246779e1..0ff5b694d01 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/result_vec_i_32_string_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/result_vec_i_32_string_table.rs @@ -18,6 +18,18 @@ pub struct ResultVecI32StringTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `result_vec_i_32_string`. +pub struct ResultVecI32StringTableAccessor; + +impl __sdk::TableAccessor for ResultVecI32StringTableAccessor { + type Row = ResultVecI32String; + type Handle<'db> = ResultVecI32StringTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.result_vec_i_32_string() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `result_vec_i_32_string`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/scheduled_table_table.rs b/sdks/rust/tests/test-client/src/module_bindings/scheduled_table_table.rs index 2d87202b2c7..e473f6c0e84 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/scheduled_table_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/scheduled_table_table.rs @@ -18,6 +18,18 @@ pub struct ScheduledTableTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `scheduled_table`. +pub struct ScheduledTableTableAccessor; + +impl __sdk::TableAccessor for ScheduledTableTableAccessor { + type Row = ScheduledTable; + type Handle<'db> = ScheduledTableTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.scheduled_table() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `scheduled_table`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/table_holds_table_table.rs b/sdks/rust/tests/test-client/src/module_bindings/table_holds_table_table.rs index b694676e1ee..3112a4fd7fe 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/table_holds_table_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/table_holds_table_table.rs @@ -20,6 +20,18 @@ pub struct TableHoldsTableTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `table_holds_table`. +pub struct TableHoldsTableTableAccessor; + +impl __sdk::TableAccessor for TableHoldsTableTableAccessor { + type Row = TableHoldsTable; + type Handle<'db> = TableHoldsTableTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.table_holds_table() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `table_holds_table`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/unique_bool_table.rs b/sdks/rust/tests/test-client/src/module_bindings/unique_bool_table.rs index afa6f6c65e4..ac35e348fb4 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/unique_bool_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/unique_bool_table.rs @@ -18,6 +18,18 @@ pub struct UniqueBoolTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `unique_bool`. +pub struct UniqueBoolTableAccessor; + +impl __sdk::TableAccessor for UniqueBoolTableAccessor { + type Row = UniqueBool; + type Handle<'db> = UniqueBoolTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.unique_bool() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `unique_bool`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/unique_connection_id_table.rs b/sdks/rust/tests/test-client/src/module_bindings/unique_connection_id_table.rs index 44569af506d..788e97eb00d 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/unique_connection_id_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/unique_connection_id_table.rs @@ -18,6 +18,18 @@ pub struct UniqueConnectionIdTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `unique_connection_id`. +pub struct UniqueConnectionIdTableAccessor; + +impl __sdk::TableAccessor for UniqueConnectionIdTableAccessor { + type Row = UniqueConnectionId; + type Handle<'db> = UniqueConnectionIdTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.unique_connection_id() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `unique_connection_id`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/unique_i_128_table.rs b/sdks/rust/tests/test-client/src/module_bindings/unique_i_128_table.rs index edde6a3f131..1c5ceb866f2 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/unique_i_128_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/unique_i_128_table.rs @@ -18,6 +18,18 @@ pub struct UniqueI128TableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `unique_i_128`. +pub struct UniqueI128TableAccessor; + +impl __sdk::TableAccessor for UniqueI128TableAccessor { + type Row = UniqueI128; + type Handle<'db> = UniqueI128TableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.unique_i_128() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `unique_i_128`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/unique_i_16_table.rs b/sdks/rust/tests/test-client/src/module_bindings/unique_i_16_table.rs index 257301eb112..5ebc1ab9397 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/unique_i_16_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/unique_i_16_table.rs @@ -18,6 +18,18 @@ pub struct UniqueI16TableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `unique_i_16`. +pub struct UniqueI16TableAccessor; + +impl __sdk::TableAccessor for UniqueI16TableAccessor { + type Row = UniqueI16; + type Handle<'db> = UniqueI16TableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.unique_i_16() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `unique_i_16`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/unique_i_256_table.rs b/sdks/rust/tests/test-client/src/module_bindings/unique_i_256_table.rs index 56b56b0db38..c3f65e7d560 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/unique_i_256_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/unique_i_256_table.rs @@ -18,6 +18,18 @@ pub struct UniqueI256TableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `unique_i_256`. +pub struct UniqueI256TableAccessor; + +impl __sdk::TableAccessor for UniqueI256TableAccessor { + type Row = UniqueI256; + type Handle<'db> = UniqueI256TableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.unique_i_256() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `unique_i_256`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/unique_i_32_table.rs b/sdks/rust/tests/test-client/src/module_bindings/unique_i_32_table.rs index 349640d7c6f..0f7ac6d96a2 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/unique_i_32_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/unique_i_32_table.rs @@ -18,6 +18,18 @@ pub struct UniqueI32TableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `unique_i_32`. +pub struct UniqueI32TableAccessor; + +impl __sdk::TableAccessor for UniqueI32TableAccessor { + type Row = UniqueI32; + type Handle<'db> = UniqueI32TableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.unique_i_32() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `unique_i_32`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/unique_i_64_table.rs b/sdks/rust/tests/test-client/src/module_bindings/unique_i_64_table.rs index 0a5f3237203..423750f686c 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/unique_i_64_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/unique_i_64_table.rs @@ -18,6 +18,18 @@ pub struct UniqueI64TableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `unique_i_64`. +pub struct UniqueI64TableAccessor; + +impl __sdk::TableAccessor for UniqueI64TableAccessor { + type Row = UniqueI64; + type Handle<'db> = UniqueI64TableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.unique_i_64() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `unique_i_64`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/unique_i_8_table.rs b/sdks/rust/tests/test-client/src/module_bindings/unique_i_8_table.rs index badf7654ae0..f7de246976c 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/unique_i_8_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/unique_i_8_table.rs @@ -18,6 +18,18 @@ pub struct UniqueI8TableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `unique_i_8`. +pub struct UniqueI8TableAccessor; + +impl __sdk::TableAccessor for UniqueI8TableAccessor { + type Row = UniqueI8; + type Handle<'db> = UniqueI8TableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.unique_i_8() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `unique_i_8`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/unique_identity_table.rs b/sdks/rust/tests/test-client/src/module_bindings/unique_identity_table.rs index d0e5a881c6e..3915cbe213e 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/unique_identity_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/unique_identity_table.rs @@ -18,6 +18,18 @@ pub struct UniqueIdentityTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `unique_identity`. +pub struct UniqueIdentityTableAccessor; + +impl __sdk::TableAccessor for UniqueIdentityTableAccessor { + type Row = UniqueIdentity; + type Handle<'db> = UniqueIdentityTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.unique_identity() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `unique_identity`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/unique_string_table.rs b/sdks/rust/tests/test-client/src/module_bindings/unique_string_table.rs index 9cb141c7e25..5ce36a50381 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/unique_string_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/unique_string_table.rs @@ -18,6 +18,18 @@ pub struct UniqueStringTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `unique_string`. +pub struct UniqueStringTableAccessor; + +impl __sdk::TableAccessor for UniqueStringTableAccessor { + type Row = UniqueString; + type Handle<'db> = UniqueStringTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.unique_string() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `unique_string`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/unique_u_128_table.rs b/sdks/rust/tests/test-client/src/module_bindings/unique_u_128_table.rs index 37b7ce034bf..d70b4f3e4f9 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/unique_u_128_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/unique_u_128_table.rs @@ -18,6 +18,18 @@ pub struct UniqueU128TableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `unique_u_128`. +pub struct UniqueU128TableAccessor; + +impl __sdk::TableAccessor for UniqueU128TableAccessor { + type Row = UniqueU128; + type Handle<'db> = UniqueU128TableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.unique_u_128() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `unique_u_128`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/unique_u_16_table.rs b/sdks/rust/tests/test-client/src/module_bindings/unique_u_16_table.rs index da092f15c5c..40bd8d68b0c 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/unique_u_16_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/unique_u_16_table.rs @@ -18,6 +18,18 @@ pub struct UniqueU16TableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `unique_u_16`. +pub struct UniqueU16TableAccessor; + +impl __sdk::TableAccessor for UniqueU16TableAccessor { + type Row = UniqueU16; + type Handle<'db> = UniqueU16TableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.unique_u_16() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `unique_u_16`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/unique_u_256_table.rs b/sdks/rust/tests/test-client/src/module_bindings/unique_u_256_table.rs index 706f5b4c83b..6d5a35a8ed7 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/unique_u_256_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/unique_u_256_table.rs @@ -18,6 +18,18 @@ pub struct UniqueU256TableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `unique_u_256`. +pub struct UniqueU256TableAccessor; + +impl __sdk::TableAccessor for UniqueU256TableAccessor { + type Row = UniqueU256; + type Handle<'db> = UniqueU256TableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.unique_u_256() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `unique_u_256`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/unique_u_32_table.rs b/sdks/rust/tests/test-client/src/module_bindings/unique_u_32_table.rs index d50dcf1aac7..ba06da79a88 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/unique_u_32_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/unique_u_32_table.rs @@ -18,6 +18,18 @@ pub struct UniqueU32TableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `unique_u_32`. +pub struct UniqueU32TableAccessor; + +impl __sdk::TableAccessor for UniqueU32TableAccessor { + type Row = UniqueU32; + type Handle<'db> = UniqueU32TableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.unique_u_32() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `unique_u_32`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/unique_u_64_table.rs b/sdks/rust/tests/test-client/src/module_bindings/unique_u_64_table.rs index 2330178e05e..048cd2f28d5 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/unique_u_64_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/unique_u_64_table.rs @@ -18,6 +18,18 @@ pub struct UniqueU64TableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `unique_u_64`. +pub struct UniqueU64TableAccessor; + +impl __sdk::TableAccessor for UniqueU64TableAccessor { + type Row = UniqueU64; + type Handle<'db> = UniqueU64TableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.unique_u_64() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `unique_u_64`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/unique_u_8_table.rs b/sdks/rust/tests/test-client/src/module_bindings/unique_u_8_table.rs index d7e64f0bb42..b64790f65d0 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/unique_u_8_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/unique_u_8_table.rs @@ -18,6 +18,18 @@ pub struct UniqueU8TableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `unique_u_8`. +pub struct UniqueU8TableAccessor; + +impl __sdk::TableAccessor for UniqueU8TableAccessor { + type Row = UniqueU8; + type Handle<'db> = UniqueU8TableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.unique_u_8() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `unique_u_8`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/unique_uuid_table.rs b/sdks/rust/tests/test-client/src/module_bindings/unique_uuid_table.rs index 9a98fc49c1b..771fff58d0a 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/unique_uuid_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/unique_uuid_table.rs @@ -18,6 +18,18 @@ pub struct UniqueUuidTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `unique_uuid`. +pub struct UniqueUuidTableAccessor; + +impl __sdk::TableAccessor for UniqueUuidTableAccessor { + type Row = UniqueUuid; + type Handle<'db> = UniqueUuidTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.unique_uuid() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `unique_uuid`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/users_table.rs b/sdks/rust/tests/test-client/src/module_bindings/users_table.rs index 35e162af9b6..b6d7e21b337 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/users_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/users_table.rs @@ -18,6 +18,18 @@ pub struct UsersTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `users`. +pub struct UsersTableAccessor; + +impl __sdk::TableAccessor for UsersTableAccessor { + type Row = Users; + type Handle<'db> = UsersTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.users() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `users`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/vec_bool_table.rs b/sdks/rust/tests/test-client/src/module_bindings/vec_bool_table.rs index 4cdca77dd00..dd9a218a504 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/vec_bool_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/vec_bool_table.rs @@ -18,6 +18,18 @@ pub struct VecBoolTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `vec_bool`. +pub struct VecBoolTableAccessor; + +impl __sdk::TableAccessor for VecBoolTableAccessor { + type Row = VecBool; + type Handle<'db> = VecBoolTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.vec_bool() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `vec_bool`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/vec_byte_struct_table.rs b/sdks/rust/tests/test-client/src/module_bindings/vec_byte_struct_table.rs index 1a32d13a43f..43f461b30f9 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/vec_byte_struct_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/vec_byte_struct_table.rs @@ -19,6 +19,18 @@ pub struct VecByteStructTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `vec_byte_struct`. +pub struct VecByteStructTableAccessor; + +impl __sdk::TableAccessor for VecByteStructTableAccessor { + type Row = VecByteStruct; + type Handle<'db> = VecByteStructTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.vec_byte_struct() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `vec_byte_struct`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/vec_connection_id_table.rs b/sdks/rust/tests/test-client/src/module_bindings/vec_connection_id_table.rs index 9f8456163e1..8c00acf476e 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/vec_connection_id_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/vec_connection_id_table.rs @@ -18,6 +18,18 @@ pub struct VecConnectionIdTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `vec_connection_id`. +pub struct VecConnectionIdTableAccessor; + +impl __sdk::TableAccessor for VecConnectionIdTableAccessor { + type Row = VecConnectionId; + type Handle<'db> = VecConnectionIdTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.vec_connection_id() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `vec_connection_id`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/vec_enum_with_payload_table.rs b/sdks/rust/tests/test-client/src/module_bindings/vec_enum_with_payload_table.rs index 37a85d66612..956e0f58c81 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/vec_enum_with_payload_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/vec_enum_with_payload_table.rs @@ -19,6 +19,18 @@ pub struct VecEnumWithPayloadTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `vec_enum_with_payload`. +pub struct VecEnumWithPayloadTableAccessor; + +impl __sdk::TableAccessor for VecEnumWithPayloadTableAccessor { + type Row = VecEnumWithPayload; + type Handle<'db> = VecEnumWithPayloadTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.vec_enum_with_payload() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `vec_enum_with_payload`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/vec_every_primitive_struct_table.rs b/sdks/rust/tests/test-client/src/module_bindings/vec_every_primitive_struct_table.rs index 97928e177dc..93f60f06f90 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/vec_every_primitive_struct_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/vec_every_primitive_struct_table.rs @@ -19,6 +19,18 @@ pub struct VecEveryPrimitiveStructTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `vec_every_primitive_struct`. +pub struct VecEveryPrimitiveStructTableAccessor; + +impl __sdk::TableAccessor for VecEveryPrimitiveStructTableAccessor { + type Row = VecEveryPrimitiveStruct; + type Handle<'db> = VecEveryPrimitiveStructTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.vec_every_primitive_struct() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `vec_every_primitive_struct`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/vec_every_vec_struct_table.rs b/sdks/rust/tests/test-client/src/module_bindings/vec_every_vec_struct_table.rs index 481d1a89111..9ea40d9cd30 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/vec_every_vec_struct_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/vec_every_vec_struct_table.rs @@ -19,6 +19,18 @@ pub struct VecEveryVecStructTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `vec_every_vec_struct`. +pub struct VecEveryVecStructTableAccessor; + +impl __sdk::TableAccessor for VecEveryVecStructTableAccessor { + type Row = VecEveryVecStruct; + type Handle<'db> = VecEveryVecStructTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.vec_every_vec_struct() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `vec_every_vec_struct`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/vec_f_32_table.rs b/sdks/rust/tests/test-client/src/module_bindings/vec_f_32_table.rs index 15c78aebd89..6be8ea7ee79 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/vec_f_32_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/vec_f_32_table.rs @@ -18,6 +18,18 @@ pub struct VecF32TableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `vec_f_32`. +pub struct VecF32TableAccessor; + +impl __sdk::TableAccessor for VecF32TableAccessor { + type Row = VecF32; + type Handle<'db> = VecF32TableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.vec_f_32() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `vec_f_32`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/vec_f_64_table.rs b/sdks/rust/tests/test-client/src/module_bindings/vec_f_64_table.rs index 1e012811484..14f662a81ea 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/vec_f_64_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/vec_f_64_table.rs @@ -18,6 +18,18 @@ pub struct VecF64TableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `vec_f_64`. +pub struct VecF64TableAccessor; + +impl __sdk::TableAccessor for VecF64TableAccessor { + type Row = VecF64; + type Handle<'db> = VecF64TableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.vec_f_64() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `vec_f_64`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/vec_i_128_table.rs b/sdks/rust/tests/test-client/src/module_bindings/vec_i_128_table.rs index b9418838a38..7121fa17d19 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/vec_i_128_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/vec_i_128_table.rs @@ -18,6 +18,18 @@ pub struct VecI128TableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `vec_i_128`. +pub struct VecI128TableAccessor; + +impl __sdk::TableAccessor for VecI128TableAccessor { + type Row = VecI128; + type Handle<'db> = VecI128TableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.vec_i_128() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `vec_i_128`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/vec_i_16_table.rs b/sdks/rust/tests/test-client/src/module_bindings/vec_i_16_table.rs index 28b008e976f..1dd95b42f3a 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/vec_i_16_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/vec_i_16_table.rs @@ -18,6 +18,18 @@ pub struct VecI16TableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `vec_i_16`. +pub struct VecI16TableAccessor; + +impl __sdk::TableAccessor for VecI16TableAccessor { + type Row = VecI16; + type Handle<'db> = VecI16TableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.vec_i_16() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `vec_i_16`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/vec_i_256_table.rs b/sdks/rust/tests/test-client/src/module_bindings/vec_i_256_table.rs index 8b147ea552b..3dda493bbed 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/vec_i_256_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/vec_i_256_table.rs @@ -18,6 +18,18 @@ pub struct VecI256TableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `vec_i_256`. +pub struct VecI256TableAccessor; + +impl __sdk::TableAccessor for VecI256TableAccessor { + type Row = VecI256; + type Handle<'db> = VecI256TableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.vec_i_256() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `vec_i_256`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/vec_i_32_table.rs b/sdks/rust/tests/test-client/src/module_bindings/vec_i_32_table.rs index b7520f58c46..6adffc936cc 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/vec_i_32_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/vec_i_32_table.rs @@ -18,6 +18,18 @@ pub struct VecI32TableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `vec_i_32`. +pub struct VecI32TableAccessor; + +impl __sdk::TableAccessor for VecI32TableAccessor { + type Row = VecI32; + type Handle<'db> = VecI32TableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.vec_i_32() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `vec_i_32`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/vec_i_64_table.rs b/sdks/rust/tests/test-client/src/module_bindings/vec_i_64_table.rs index c5913d2affe..08caa3b6394 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/vec_i_64_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/vec_i_64_table.rs @@ -18,6 +18,18 @@ pub struct VecI64TableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `vec_i_64`. +pub struct VecI64TableAccessor; + +impl __sdk::TableAccessor for VecI64TableAccessor { + type Row = VecI64; + type Handle<'db> = VecI64TableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.vec_i_64() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `vec_i_64`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/vec_i_8_table.rs b/sdks/rust/tests/test-client/src/module_bindings/vec_i_8_table.rs index 2f327ce53f3..b71435fe6b3 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/vec_i_8_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/vec_i_8_table.rs @@ -18,6 +18,18 @@ pub struct VecI8TableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `vec_i_8`. +pub struct VecI8TableAccessor; + +impl __sdk::TableAccessor for VecI8TableAccessor { + type Row = VecI8; + type Handle<'db> = VecI8TableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.vec_i_8() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `vec_i_8`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/vec_identity_table.rs b/sdks/rust/tests/test-client/src/module_bindings/vec_identity_table.rs index 15ad2e39761..2305931ecec 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/vec_identity_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/vec_identity_table.rs @@ -18,6 +18,18 @@ pub struct VecIdentityTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `vec_identity`. +pub struct VecIdentityTableAccessor; + +impl __sdk::TableAccessor for VecIdentityTableAccessor { + type Row = VecIdentity; + type Handle<'db> = VecIdentityTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.vec_identity() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `vec_identity`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/vec_simple_enum_table.rs b/sdks/rust/tests/test-client/src/module_bindings/vec_simple_enum_table.rs index 063fef09cbc..5652240ae5d 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/vec_simple_enum_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/vec_simple_enum_table.rs @@ -19,6 +19,18 @@ pub struct VecSimpleEnumTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `vec_simple_enum`. +pub struct VecSimpleEnumTableAccessor; + +impl __sdk::TableAccessor for VecSimpleEnumTableAccessor { + type Row = VecSimpleEnum; + type Handle<'db> = VecSimpleEnumTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.vec_simple_enum() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `vec_simple_enum`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/vec_string_table.rs b/sdks/rust/tests/test-client/src/module_bindings/vec_string_table.rs index e7bd7d044bf..14cc565af01 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/vec_string_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/vec_string_table.rs @@ -18,6 +18,18 @@ pub struct VecStringTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `vec_string`. +pub struct VecStringTableAccessor; + +impl __sdk::TableAccessor for VecStringTableAccessor { + type Row = VecString; + type Handle<'db> = VecStringTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.vec_string() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `vec_string`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/vec_timestamp_table.rs b/sdks/rust/tests/test-client/src/module_bindings/vec_timestamp_table.rs index 03807dc8cb1..e9cea3f4c83 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/vec_timestamp_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/vec_timestamp_table.rs @@ -18,6 +18,18 @@ pub struct VecTimestampTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `vec_timestamp`. +pub struct VecTimestampTableAccessor; + +impl __sdk::TableAccessor for VecTimestampTableAccessor { + type Row = VecTimestamp; + type Handle<'db> = VecTimestampTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.vec_timestamp() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `vec_timestamp`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/vec_u_128_table.rs b/sdks/rust/tests/test-client/src/module_bindings/vec_u_128_table.rs index e2e3ac06cd2..b15dfa72fbf 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/vec_u_128_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/vec_u_128_table.rs @@ -18,6 +18,18 @@ pub struct VecU128TableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `vec_u_128`. +pub struct VecU128TableAccessor; + +impl __sdk::TableAccessor for VecU128TableAccessor { + type Row = VecU128; + type Handle<'db> = VecU128TableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.vec_u_128() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `vec_u_128`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/vec_u_16_table.rs b/sdks/rust/tests/test-client/src/module_bindings/vec_u_16_table.rs index 87b5f22643b..ba08ff2fd49 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/vec_u_16_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/vec_u_16_table.rs @@ -18,6 +18,18 @@ pub struct VecU16TableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `vec_u_16`. +pub struct VecU16TableAccessor; + +impl __sdk::TableAccessor for VecU16TableAccessor { + type Row = VecU16; + type Handle<'db> = VecU16TableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.vec_u_16() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `vec_u_16`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/vec_u_256_table.rs b/sdks/rust/tests/test-client/src/module_bindings/vec_u_256_table.rs index ebad10f1a97..00c2e01fb82 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/vec_u_256_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/vec_u_256_table.rs @@ -18,6 +18,18 @@ pub struct VecU256TableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `vec_u_256`. +pub struct VecU256TableAccessor; + +impl __sdk::TableAccessor for VecU256TableAccessor { + type Row = VecU256; + type Handle<'db> = VecU256TableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.vec_u_256() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `vec_u_256`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/vec_u_32_table.rs b/sdks/rust/tests/test-client/src/module_bindings/vec_u_32_table.rs index 81036fd9f1e..fed73e38c3e 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/vec_u_32_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/vec_u_32_table.rs @@ -18,6 +18,18 @@ pub struct VecU32TableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `vec_u_32`. +pub struct VecU32TableAccessor; + +impl __sdk::TableAccessor for VecU32TableAccessor { + type Row = VecU32; + type Handle<'db> = VecU32TableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.vec_u_32() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `vec_u_32`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/vec_u_64_table.rs b/sdks/rust/tests/test-client/src/module_bindings/vec_u_64_table.rs index 1ec02648ad7..d5dfc1162f4 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/vec_u_64_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/vec_u_64_table.rs @@ -18,6 +18,18 @@ pub struct VecU64TableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `vec_u_64`. +pub struct VecU64TableAccessor; + +impl __sdk::TableAccessor for VecU64TableAccessor { + type Row = VecU64; + type Handle<'db> = VecU64TableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.vec_u_64() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `vec_u_64`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/vec_u_8_table.rs b/sdks/rust/tests/test-client/src/module_bindings/vec_u_8_table.rs index f9b67d9b4ea..7f3f1ae4aa8 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/vec_u_8_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/vec_u_8_table.rs @@ -18,6 +18,18 @@ pub struct VecU8TableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `vec_u_8`. +pub struct VecU8TableAccessor; + +impl __sdk::TableAccessor for VecU8TableAccessor { + type Row = VecU8; + type Handle<'db> = VecU8TableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.vec_u_8() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `vec_u_8`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/vec_unit_struct_table.rs b/sdks/rust/tests/test-client/src/module_bindings/vec_unit_struct_table.rs index 40b1c5136e6..e5474323236 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/vec_unit_struct_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/vec_unit_struct_table.rs @@ -19,6 +19,18 @@ pub struct VecUnitStructTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `vec_unit_struct`. +pub struct VecUnitStructTableAccessor; + +impl __sdk::TableAccessor for VecUnitStructTableAccessor { + type Row = VecUnitStruct; + type Handle<'db> = VecUnitStructTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.vec_unit_struct() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `vec_unit_struct`. /// diff --git a/sdks/rust/tests/test-client/src/module_bindings/vec_uuid_table.rs b/sdks/rust/tests/test-client/src/module_bindings/vec_uuid_table.rs index 95ff248290a..073ab76e9b8 100644 --- a/sdks/rust/tests/test-client/src/module_bindings/vec_uuid_table.rs +++ b/sdks/rust/tests/test-client/src/module_bindings/vec_uuid_table.rs @@ -18,6 +18,18 @@ pub struct VecUuidTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `vec_uuid`. +pub struct VecUuidTableAccessor; + +impl __sdk::TableAccessor for VecUuidTableAccessor { + type Row = VecUuid; + type Handle<'db> = VecUuidTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.vec_uuid() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `vec_uuid`. /// diff --git a/sdks/rust/tests/view-client/src/module_bindings/my_player_and_level_table.rs b/sdks/rust/tests/view-client/src/module_bindings/my_player_and_level_table.rs index 088fe741dc4..ababfc4132c 100644 --- a/sdks/rust/tests/view-client/src/module_bindings/my_player_and_level_table.rs +++ b/sdks/rust/tests/view-client/src/module_bindings/my_player_and_level_table.rs @@ -18,6 +18,18 @@ pub struct MyPlayerAndLevelTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `my_player_and_level`. +pub struct MyPlayerAndLevelTableAccessor; + +impl __sdk::TableAccessor for MyPlayerAndLevelTableAccessor { + type Row = PlayerAndLevel; + type Handle<'db> = MyPlayerAndLevelTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.my_player_and_level() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `my_player_and_level`. /// diff --git a/sdks/rust/tests/view-client/src/module_bindings/my_player_table.rs b/sdks/rust/tests/view-client/src/module_bindings/my_player_table.rs index 92b21a7c2fc..824373521bc 100644 --- a/sdks/rust/tests/view-client/src/module_bindings/my_player_table.rs +++ b/sdks/rust/tests/view-client/src/module_bindings/my_player_table.rs @@ -18,6 +18,18 @@ pub struct MyPlayerTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `my_player`. +pub struct MyPlayerTableAccessor; + +impl __sdk::TableAccessor for MyPlayerTableAccessor { + type Row = Player; + type Handle<'db> = MyPlayerTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.my_player() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `my_player`. /// diff --git a/sdks/rust/tests/view-client/src/module_bindings/nearby_players_table.rs b/sdks/rust/tests/view-client/src/module_bindings/nearby_players_table.rs index 481648b2be7..6bafcaf0bd3 100644 --- a/sdks/rust/tests/view-client/src/module_bindings/nearby_players_table.rs +++ b/sdks/rust/tests/view-client/src/module_bindings/nearby_players_table.rs @@ -18,6 +18,18 @@ pub struct NearbyPlayersTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `nearby_players`. +pub struct NearbyPlayersTableAccessor; + +impl __sdk::TableAccessor for NearbyPlayersTableAccessor { + type Row = PlayerLocation; + type Handle<'db> = NearbyPlayersTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.nearby_players() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `nearby_players`. /// diff --git a/sdks/rust/tests/view-client/src/module_bindings/player_level_table.rs b/sdks/rust/tests/view-client/src/module_bindings/player_level_table.rs index f6274526693..b5195f5be93 100644 --- a/sdks/rust/tests/view-client/src/module_bindings/player_level_table.rs +++ b/sdks/rust/tests/view-client/src/module_bindings/player_level_table.rs @@ -18,6 +18,18 @@ pub struct PlayerLevelTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `player_level`. +pub struct PlayerLevelTableAccessor; + +impl __sdk::TableAccessor for PlayerLevelTableAccessor { + type Row = PlayerLevel; + type Handle<'db> = PlayerLevelTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.player_level() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `player_level`. /// diff --git a/sdks/rust/tests/view-client/src/module_bindings/player_location_table.rs b/sdks/rust/tests/view-client/src/module_bindings/player_location_table.rs index 50fbf245b95..086129c4656 100644 --- a/sdks/rust/tests/view-client/src/module_bindings/player_location_table.rs +++ b/sdks/rust/tests/view-client/src/module_bindings/player_location_table.rs @@ -18,6 +18,18 @@ pub struct PlayerLocationTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `player_location`. +pub struct PlayerLocationTableAccessor; + +impl __sdk::TableAccessor for PlayerLocationTableAccessor { + type Row = PlayerLocation; + type Handle<'db> = PlayerLocationTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.player_location() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `player_location`. /// diff --git a/sdks/rust/tests/view-client/src/module_bindings/player_table.rs b/sdks/rust/tests/view-client/src/module_bindings/player_table.rs index 2172a70646f..0b27effc580 100644 --- a/sdks/rust/tests/view-client/src/module_bindings/player_table.rs +++ b/sdks/rust/tests/view-client/src/module_bindings/player_table.rs @@ -18,6 +18,18 @@ pub struct PlayerTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `player`. +pub struct PlayerTableAccessor; + +impl __sdk::TableAccessor for PlayerTableAccessor { + type Row = Player; + type Handle<'db> = PlayerTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.player() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `player`. /// diff --git a/sdks/rust/tests/view-client/src/module_bindings/players_at_level_0_table.rs b/sdks/rust/tests/view-client/src/module_bindings/players_at_level_0_table.rs index ff42c8809f7..50fc665950b 100644 --- a/sdks/rust/tests/view-client/src/module_bindings/players_at_level_0_table.rs +++ b/sdks/rust/tests/view-client/src/module_bindings/players_at_level_0_table.rs @@ -18,6 +18,18 @@ pub struct PlayersAtLevel0TableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `players_at_level_0`. +pub struct PlayersAtLevel0TableAccessor; + +impl __sdk::TableAccessor for PlayersAtLevel0TableAccessor { + type Row = Player; + type Handle<'db> = PlayersAtLevel0TableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.players_at_level_0() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `players_at_level_0`. /// diff --git a/sdks/rust/tests/view-pk-client/src/module_bindings/all_view_pk_players_table.rs b/sdks/rust/tests/view-pk-client/src/module_bindings/all_view_pk_players_table.rs index ec490f0caa9..fdaec1d6307 100644 --- a/sdks/rust/tests/view-pk-client/src/module_bindings/all_view_pk_players_table.rs +++ b/sdks/rust/tests/view-pk-client/src/module_bindings/all_view_pk_players_table.rs @@ -18,6 +18,18 @@ pub struct AllViewPkPlayersTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `all_view_pk_players`. +pub struct AllViewPkPlayersTableAccessor; + +impl __sdk::TableAccessor for AllViewPkPlayersTableAccessor { + type Row = ViewPkPlayer; + type Handle<'db> = AllViewPkPlayersTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.all_view_pk_players() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `all_view_pk_players`. /// diff --git a/sdks/rust/tests/view-pk-client/src/module_bindings/sender_view_pk_players_a_table.rs b/sdks/rust/tests/view-pk-client/src/module_bindings/sender_view_pk_players_a_table.rs index aec8b088316..a48b791e705 100644 --- a/sdks/rust/tests/view-pk-client/src/module_bindings/sender_view_pk_players_a_table.rs +++ b/sdks/rust/tests/view-pk-client/src/module_bindings/sender_view_pk_players_a_table.rs @@ -18,6 +18,18 @@ pub struct SenderViewPkPlayersATableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `sender_view_pk_players_a`. +pub struct SenderViewPkPlayersATableAccessor; + +impl __sdk::TableAccessor for SenderViewPkPlayersATableAccessor { + type Row = ViewPkPlayer; + type Handle<'db> = SenderViewPkPlayersATableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.sender_view_pk_players_a() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `sender_view_pk_players_a`. /// diff --git a/sdks/rust/tests/view-pk-client/src/module_bindings/sender_view_pk_players_b_table.rs b/sdks/rust/tests/view-pk-client/src/module_bindings/sender_view_pk_players_b_table.rs index 84beae51e9f..f049b6e195b 100644 --- a/sdks/rust/tests/view-pk-client/src/module_bindings/sender_view_pk_players_b_table.rs +++ b/sdks/rust/tests/view-pk-client/src/module_bindings/sender_view_pk_players_b_table.rs @@ -18,6 +18,18 @@ pub struct SenderViewPkPlayersBTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `sender_view_pk_players_b`. +pub struct SenderViewPkPlayersBTableAccessor; + +impl __sdk::TableAccessor for SenderViewPkPlayersBTableAccessor { + type Row = ViewPkPlayer; + type Handle<'db> = SenderViewPkPlayersBTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.sender_view_pk_players_b() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `sender_view_pk_players_b`. /// diff --git a/sdks/rust/tests/view-pk-client/src/module_bindings/view_pk_membership_secondary_table.rs b/sdks/rust/tests/view-pk-client/src/module_bindings/view_pk_membership_secondary_table.rs index ae6a293de09..b68e82ca4d6 100644 --- a/sdks/rust/tests/view-pk-client/src/module_bindings/view_pk_membership_secondary_table.rs +++ b/sdks/rust/tests/view-pk-client/src/module_bindings/view_pk_membership_secondary_table.rs @@ -18,6 +18,18 @@ pub struct ViewPkMembershipSecondaryTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `view_pk_membership_secondary`. +pub struct ViewPkMembershipSecondaryTableAccessor; + +impl __sdk::TableAccessor for ViewPkMembershipSecondaryTableAccessor { + type Row = ViewPkMembershipSecondary; + type Handle<'db> = ViewPkMembershipSecondaryTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.view_pk_membership_secondary() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `view_pk_membership_secondary`. /// diff --git a/sdks/rust/tests/view-pk-client/src/module_bindings/view_pk_membership_table.rs b/sdks/rust/tests/view-pk-client/src/module_bindings/view_pk_membership_table.rs index 90661ef8fc0..8424a6c4cd1 100644 --- a/sdks/rust/tests/view-pk-client/src/module_bindings/view_pk_membership_table.rs +++ b/sdks/rust/tests/view-pk-client/src/module_bindings/view_pk_membership_table.rs @@ -18,6 +18,18 @@ pub struct ViewPkMembershipTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `view_pk_membership`. +pub struct ViewPkMembershipTableAccessor; + +impl __sdk::TableAccessor for ViewPkMembershipTableAccessor { + type Row = ViewPkMembership; + type Handle<'db> = ViewPkMembershipTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.view_pk_membership() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `view_pk_membership`. /// diff --git a/sdks/rust/tests/view-pk-client/src/module_bindings/view_pk_player_table.rs b/sdks/rust/tests/view-pk-client/src/module_bindings/view_pk_player_table.rs index 07e916ab217..c5df53a69c3 100644 --- a/sdks/rust/tests/view-pk-client/src/module_bindings/view_pk_player_table.rs +++ b/sdks/rust/tests/view-pk-client/src/module_bindings/view_pk_player_table.rs @@ -18,6 +18,18 @@ pub struct ViewPkPlayerTableHandle<'ctx> { ctx: std::marker::PhantomData<&'ctx super::RemoteTables>, } +/// Lifetime-aware accessor marker for the table `view_pk_player`. +pub struct ViewPkPlayerTableAccessor; + +impl __sdk::TableAccessor for ViewPkPlayerTableAccessor { + type Row = ViewPkPlayer; + type Handle<'db> = ViewPkPlayerTableHandle<'db>; + + fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> { + db.view_pk_player() + } +} + #[allow(non_camel_case_types)] /// Extension trait for access to the table `view_pk_player`. /// From 173b014e8abac8ce9d0fd20fe7ddd5c4fb52becf Mon Sep 17 00:00:00 2001 From: Shubham Mishra Date: Wed, 8 Jul 2026 07:12:51 +0530 Subject: [PATCH 2/2] Make `dst` crate a lib in public. (#5466) # Description of Changes Makes `spacetimedb-dst` to `spacetimedb-dst-lib`. To be able to write tests for private repo, We have two options: 1. Write all DST code in private. 2. Make this a `lib` with test covering public specific code, and write a `bin` in private, I chose option 2 as it's easier to maintain tests like this, otherwise you may have to raise a separate PR for changes in `engine` crate, which will be painful. This also makes methods of `TestSuite` async. binary crate PR - https://github.com/clockworklabs/SpacetimeDBPrivate/pull/3287 # API and ABI breaking changes NA # Expected complexity level and risk 1 # Testing Not applicable. --- Cargo.lock | 2 +- crates/dst/Cargo.toml | 6 ++- crates/dst/README.md | 20 -------- crates/dst/src/engine.rs | 5 +- crates/dst/src/lib.rs | 6 +++ crates/dst/src/main.rs | 91 --------------------------------- crates/dst/src/sim/commitlog.rs | 10 ++++ crates/dst/src/traits.rs | 34 +++++++----- 8 files changed, 45 insertions(+), 129 deletions(-) delete mode 100644 crates/dst/README.md create mode 100644 crates/dst/src/lib.rs delete mode 100644 crates/dst/src/main.rs diff --git a/Cargo.lock b/Cargo.lock index 3187ad56920..40ddf5ea619 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -8413,7 +8413,7 @@ dependencies = [ ] [[package]] -name = "spacetimedb-dst" +name = "spacetimedb-dst-lib" version = "2.7.0" dependencies = [ "anyhow", diff --git a/crates/dst/Cargo.toml b/crates/dst/Cargo.toml index 722d293ba19..7d47c9a1b47 100644 --- a/crates/dst/Cargo.toml +++ b/crates/dst/Cargo.toml @@ -1,9 +1,13 @@ [package] -name = "spacetimedb-dst" +name = "spacetimedb-dst-lib" version.workspace = true edition.workspace = true rust-version.workspace = true +[features] +default = ["fallocate"] +fallocate = ["spacetimedb-commitlog/fallocate"] + [dependencies] anyhow.workspace = true clap.workspace = true diff --git a/crates/dst/README.md b/crates/dst/README.md deleted file mode 100644 index 1a4dfcb2396..00000000000 --- a/crates/dst/README.md +++ /dev/null @@ -1,20 +0,0 @@ -# SpacetimeDB DST - -Deterministic Simulation Testing framework for SpacetimeDB. - -## Test - -```sh -cargo test -p spacetimedb-dst -``` - -## Run - -```sh -cargo run -p spacetimedb-dst -- run --seed 42 --max-interactions 1000 -``` - -Options: - -- `--seed ` — RNG seed (defaults to wall-clock nanos) -- `--max-interactions ` — interaction budget diff --git a/crates/dst/src/engine.rs b/crates/dst/src/engine.rs index 8dcfaab46a7..451b7417e41 100644 --- a/crates/dst/src/engine.rs +++ b/crates/dst/src/engine.rs @@ -274,10 +274,11 @@ impl EngineTarget { impl TargetDriver for EngineTarget { type Observation = Observation; - fn execute(&mut self, interaction: &Interaction) -> Result { + async fn execute<'a>(&'a mut self, interaction: &'a Interaction) -> Result { EngineTarget::execute(self, interaction) } } + pub struct EngineTest; impl TestSuite for EngineTest { @@ -289,7 +290,7 @@ impl TestSuite for EngineTest { type Properties = EngineProperties; - fn build(&self, rng: Rng) -> Result<(Self::Interactions, Self::Target, Self::Properties), anyhow::Error> { + async fn build(&self, rng: Rng) -> Result<(Self::Interactions, Self::Target, Self::Properties), anyhow::Error> { let schema = default_schema(rng.clone()); let runtime_seed = rng.next_u64(); let target = EngineTarget::init(schema.clone(), runtime_seed)?; diff --git a/crates/dst/src/lib.rs b/crates/dst/src/lib.rs new file mode 100644 index 00000000000..8d12c575e4c --- /dev/null +++ b/crates/dst/src/lib.rs @@ -0,0 +1,6 @@ +pub mod engine; +pub mod schema; +pub mod sim; +pub mod traits; + +pub use traits::{Properties, TargetDriver, TestSuite, TestSuiteParts}; diff --git a/crates/dst/src/main.rs b/crates/dst/src/main.rs deleted file mode 100644 index e208f921a83..00000000000 --- a/crates/dst/src/main.rs +++ /dev/null @@ -1,91 +0,0 @@ -use std::time::{SystemTime, UNIX_EPOCH}; - -use clap::{Args, Parser, Subcommand}; -use spacetimedb_runtime::sim::Rng; -use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt}; - -mod engine; -mod schema; -mod sim; -mod traits; - -use crate::{engine::EngineTest, traits::TestSuite}; - -#[derive(Parser, Debug)] -#[command(name = "spacetimedb-dst")] -#[command(about = "Run deterministic simulation targets")] -struct Cli { - #[command(subcommand)] - command: Command, -} - -#[derive(Subcommand, Debug)] -enum Command { - Run(RunArgs), -} - -#[derive(Args, Debug)] -struct RunArgs { - #[arg(long, help = "Seed for generated choices. Defaults to wall-clock time.")] - seed: Option, - #[arg(long, help = "Deterministic interaction budget.")] - max_interactions: Option, -} - -fn main() -> anyhow::Result<()> { - init_tracing(); - match Cli::parse().command { - Command::Run(args) => run_command(args), - } -} - -fn init_tracing() { - let timer = tracing_subscriber::fmt::time(); - let format = tracing_subscriber::fmt::format::Format::default() - .with_timer(timer) - .with_line_number(true) - .with_file(true) - .with_target(false) - .compact(); - let fmt_layer = tracing_subscriber::fmt::Layer::default() - .event_format(format) - .with_writer(std::io::stderr); - let env_filter_layer = tracing_subscriber::EnvFilter::from_default_env(); - - let _ = tracing_subscriber::Registry::default() - .with(fmt_layer) - .with(env_filter_layer) - .try_init(); -} - -fn run_command(args: RunArgs) -> anyhow::Result<()> { - let seed = resolve_seed(args.seed); - let config = RunConfig { - max_interactions: args.max_interactions, - seed, - }; - - tracing::info!(?config, "initial run config"); - - // Generate schema from seed. - let rng = Rng::new(config.seed); - - let test = EngineTest {}; - test.run(rng, config.max_interactions)?; - Ok(()) -} - -fn resolve_seed(seed: Option) -> u64 { - seed.unwrap_or_else(|| { - SystemTime::now() - .duration_since(UNIX_EPOCH) - .expect("time went backwards") - .as_nanos() as u64 - }) -} - -#[derive(Clone, Debug, Eq, PartialEq)] -pub struct RunConfig { - pub max_interactions: Option, - pub seed: u64, -} diff --git a/crates/dst/src/sim/commitlog.rs b/crates/dst/src/sim/commitlog.rs index dbf6d004a4c..f2644d8767a 100644 --- a/crates/dst/src/sim/commitlog.rs +++ b/crates/dst/src/sim/commitlog.rs @@ -22,6 +22,12 @@ pub struct InMemoryCommitlog { options: Options, } +impl Default for InMemoryCommitlog { + fn default() -> Self { + Self::new() + } +} + impl InMemoryCommitlog { pub fn new() -> Self { Self { @@ -394,6 +400,10 @@ impl FileLike for Segment { Ok(()) } + + fn fallocate(&mut self, _size: u64) -> io::Result<()> { + Ok(()) + } } pub struct ReadOnlySegment { diff --git a/crates/dst/src/traits.rs b/crates/dst/src/traits.rs index d84aafa97db..2185e0ec918 100644 --- a/crates/dst/src/traits.rs +++ b/crates/dst/src/traits.rs @@ -5,7 +5,10 @@ use spacetimedb_runtime::sim::Rng; pub trait TargetDriver { type Observation; - fn execute(&mut self, interaction: &I) -> Result; + fn execute<'a>( + &'a mut self, + interaction: &'a I, + ) -> impl std::future::Future> + 'a; } /// Ensures if Output of `TargetDrive` is expected for the input @@ -20,32 +23,35 @@ pub type TestSuiteParts = ( ); pub trait TestSuite { - type Interaction; + type Interaction: std::fmt::Debug; type Interactions: Iterator + std::fmt::Debug; type Target: TargetDriver; type Properties: Properties>::Observation>; - fn build(&self, rng: Rng) -> Result, Error> + fn build(&self, rng: Rng) -> impl std::future::Future, Error>> + '_ where Self: Sized; - fn run(&self, rng: Rng, max_interactions: Option) -> Result<(), Error> + fn run(&self, rng: Rng, max_interactions: usize) -> impl std::future::Future> + '_ where Self: Sized, { - let (mut interactions, mut target, mut properties) = self.build(rng)?; + async move { + let (mut interactions, mut target, mut properties) = self.build(rng).await?; - let result = (|| { - for interaction in interactions.by_ref().take(max_interactions.unwrap_or(usize::MAX)) { - let observation = target.execute(&interaction)?; - properties.observe(&interaction, &observation)?; - } + let result = async { + for interaction in interactions.by_ref().take(max_interactions) { + let observation = target.execute(&interaction).await?; + properties.observe(&interaction, &observation)?; + } - Ok(()) - })(); + Ok(()) + } + .await; - tracing::info!(interaction_counts = ?interactions, "final interaction counts"); + tracing::info!(interaction_counts = ?interactions, "final interaction counts"); - result + result + } } }