Struct ResolvedRepository 

pub struct ResolvedRepository<'a, E> { /* private fields */ }

Implementations

impl<'a, E> ResolvedRepository<'a, E>

where E: QueryExecutor + MutationExecutor + Send + Sync + 'static,

pub async fn save_graph( &self, node: GraphNode, ) -> Result<GraphNode, RepositoryError<E::Error>>

pub async fn save_entity_graph_from( &self, graph: EntityGraph, ) -> Result<GraphNode, RepositoryError<E::Error>>

pub async fn save_entity_graph<T>( &self, entity: T, ) -> Result<GraphNode, RepositoryError<E::Error>>

where T: Entity,

pub async fn save_entity<T>( &self, entity: T, status: EntityStatus, ) -> Result<GraphNode, RepositoryError<E::Error>>

where T: Entity,

pub async fn save_entity_with_comment<T>( &self, entity: T, status: EntityStatus, comment: impl Into<String>, ) -> Result<GraphNode, RepositoryError<E::Error>>

where T: Entity,

pub async fn save_entity_graph_with_comment<T>( &self, entity: T, comment: impl Into<String>, ) -> Result<GraphNode, RepositoryError<E::Error>>

where T: Entity,

pub async fn create_entity_graph_with_comment<T>( &self, entity: T, comment: impl Into<String>, ) -> Result<GraphNode, RepositoryError<E::Error>>

where T: Entity,

Create a new entity graph with an annotation comment on the root node. This assumes all new nodes do not exist in the database, skipping existence checks and throwing an exception on primary key conflict.

pub async fn plan_graph( &self, node: GraphNode, ) -> Result<GraphMutationPlan, RepositoryError<E::Error>>

pub async fn execute_graph_plan( &self, plan: GraphMutationPlan, ) -> Result<GraphNode, RepositoryError<E::Error>>

pub fn graph_node_from_entity<T>( &self, entity: T, ) -> Result<GraphNode, RuntimeError>

where T: Entity,

pub async fn fetch_graph_current_row( &self, entity: &str, id_property: &str, id: &Value, trace_chain: Vec<TraceNode>, ) -> Result<Option<Record>, RepositoryError<E::Error>>

impl<'a, E> ResolvedRepository<'a, E>

where E: QueryExecutor + MutationExecutor + Send + Sync + 'static,

pub fn relation_loads(&self) -> Vec<String>

pub fn relation_plans(&self) -> Result<Vec<RelationLoadPlan>, RuntimeError>

pub fn relation_query( &self, relation_name: &str, parent_rows: &[Record], ) -> Result<SelectQuery, RuntimeError>

pub async fn enhance_relations( &self, parent_rows: &mut [Record], ) -> Result<(), RepositoryError<E::Error>>

pub async fn enhance_query_relations( &self, parent_rows: &mut [Record], query: &SelectQuery, ) -> Result<(), RepositoryError<E::Error>>

pub fn enhance_relation_aggregates<'b>( &'b self, parent_rows: &'b mut [Record], relation_aggregates: &'b [RelationAggregate], parent_cache_options: Option<AggregationCacheOptions>, parent_trace_chain: &'b [TraceNode], ) -> Pin<Box<dyn Future<Output = Result<(), RepositoryError<E::Error>>> + Send + 'b>>

pub fn enhance_object_group_bys<'b>( &'b self, rows: &'b mut [Record], object_group_bys: &'b [ObjectGroupBy], parent_trace_chain: &'b [TraceNode], ) -> Pin<Box<dyn Future<Output = Result<(), RepositoryError<E::Error>>> + Send + 'b>>

pub fn enhance_child_queries<'b>( &'b self, rows: &'b mut [Record], child_queries: &'b [SelectQuery], parent_trace_chain: &'b [TraceNode], ) -> Pin<Box<dyn Future<Output = Result<(), RepositoryError<E::Error>>> + Send + 'b>>

impl<'a, E> ResolvedRepository<'a, E>

where E: QueryExecutor + MutationExecutor + Send + Sync + 'static,

pub fn entity(&self) -> &str

pub fn select(&self) -> SelectQuery

pub fn insert_command(&self) -> InsertCommand

pub fn prepare_insert_command( &self, command: &InsertCommand, ) -> Result<InsertCommand, RuntimeError>

pub fn update_command(&self, id: impl Into<Value>) -> UpdateCommand

pub fn prepare_update_command( &self, command: &UpdateCommand, ) -> Result<UpdateCommand, RuntimeError>

pub fn delete_command(&self, id: impl Into<Value>) -> DeleteCommand

pub fn recover_command( &self, id: impl Into<Value>, expected_version: i64, ) -> RecoverCommand

pub async fn fetch_all( &self, query: &SelectQuery, ) -> Result<Vec<Record>, RepositoryError<E::Error>>

pub async fn fetch_all_with_relation_aggregates( &self, query: &SelectQuery, relation_aggregates: &[RelationAggregate], ) -> Result<Vec<Record>, RepositoryError<E::Error>>

pub async fn fetch_smart_list( &self, query: &SelectQuery, ) -> Result<SmartList<Record>, RepositoryError<E::Error>>

pub async fn fetch_smart_list_with_relation_aggregates( &self, query: &SelectQuery, relation_aggregates: &[RelationAggregate], ) -> Result<SmartList<Record>, RepositoryError<E::Error>>

pub async fn fetch_entities<T>( &self, query: &SelectQuery, ) -> Result<SmartList<T>, RepositoryError<E::Error>>

where T: Entity,

pub async fn fetch_entities_with_relation_aggregates<T>( &self, query: &SelectQuery, relation_aggregates: &[RelationAggregate], ) -> Result<SmartList<T>, RepositoryError<E::Error>>

where T: Entity,

pub async fn fetch_enhanced_entities_with_relation_aggregates<T>( &self, query: &SelectQuery, relation_aggregates: &[RelationAggregate], ) -> Result<SmartList<T>, RepositoryError<E::Error>>

where T: Entity,

pub async fn fetch_enhanced_entities<T>( &self, query: &SelectQuery, ) -> Result<SmartList<T>, RepositoryError<E::Error>>

where T: Entity,

pub async fn insert( &self, command: &InsertCommand, ) -> Result<u64, RepositoryError<E::Error>>

pub async fn update( &self, command: &UpdateCommand, ) -> Result<u64, RepositoryError<E::Error>>

pub async fn delete( &self, command: &DeleteCommand, ) -> Result<u64, RepositoryError<E::Error>>

pub async fn delete_scoped( &self, command: &DeleteCommand, trace_chain: Vec<TraceNode>, ) -> Result<u64, RepositoryError<E::Error>>

pub async fn recover( &self, command: &RecoverCommand, ) -> Result<u64, RepositoryError<E::Error>>

pub fn scoped_repository(&self, entity: String) -> ResolvedRepository<'a, E>

impl<'a, E> ResolvedRepository<'a, E>

pub fn with_trace_context(self, trace_context: Vec<TraceNode>) -> Self