Struct ResolvedRepository 

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

Implementations

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

where D: SqlDialect, E: QueryExecutor,

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

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

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

where T: Entity,

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

where T: Entity,

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

where T: Entity,

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

where T: Entity,

pub 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 fn plan_graph( &self, node: GraphNode, ) -> Result<GraphMutationPlan, RepositoryError<E::Error>>

pub 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,

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

where D: SqlDialect, E: QueryExecutor,

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 fn enhance_relations( &self, parent_rows: &mut [Record], ) -> Result<(), RepositoryError<E::Error>>

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

pub fn enhance_relation_aggregates( &self, parent_rows: &mut [Record], relation_aggregates: &[RelationAggregate], parent_cache_options: Option<AggregationCacheOptions>, parent_trace_chain: &[TraceNode], ) -> Result<(), RepositoryError<E::Error>>

pub fn enhance_object_group_bys( &self, rows: &mut [Record], object_group_bys: &[ObjectGroupBy], parent_trace_chain: &[TraceNode], ) -> Result<(), RepositoryError<E::Error>>

pub fn enhance_child_queries( &self, rows: &mut [Record], child_queries: &[SelectQuery], parent_trace_chain: &[TraceNode], ) -> Result<(), RepositoryError<E::Error>>

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

where D: SqlDialect, E: QueryExecutor,

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 fn compile( &self, query: &SelectQuery, ) -> Result<CompiledQuery, RuntimeError>

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

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

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

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

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

where T: Entity,

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

where T: Entity,

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

where T: Entity,

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

where T: Entity,

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

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

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

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

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

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

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

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