galchemy - v3.1.0

galchemy/session/runtime

Types

HookTrackError

</> 
pub type HookTrackError(hook_error) {
  TrackFailure(TrackError)
  HookFailure(hook_error)
}

Constructors 

  • TrackFailure(TrackError)
  • HookFailure(hook_error)

Session

</> 
pub type Session {
  Session(
    snapshot: model.SchemaSnapshot,
    pending: unit_of_work.Session,
    tracked: identity_map.IdentityMap,
    persisted: identity_map.IdentityMap,
  )
}

Constructors

SessionExecutionError

</> 
pub type SessionExecutionError(exec_error) {
  TrackError(TrackError)
  ExecutionError(execution.ExecutionError(exec_error))
}

Constructors

TrackError

</> 
pub type TrackError {
  EntityError(entity.EntityError)
  IdentityMapError(identity_map.IdentityMapError)
  UnknownTrackedEntity(relation.TableRef, unit_of_work.Identity)
}

Constructors

Values

attach

</> 
pub fn attach(
  session: Session,
  next_entity: entity.Entity,
) -> Result(Session, TrackError)

attach_with_hooks

</> 
pub fn attach_with_hooks(
  session: Session,
  next_entity: entity.Entity,
  hooks: hook.EntityHooks(hook_error),
) -> Result(Session, HookTrackError(hook_error))

commit

</> 
pub fn commit(
  session: Session,
  executor: fn(query.Query) -> Result(result, exec_error),
) -> Result(
  #(execution.FlushExecution(result), Session),
  SessionExecutionError(exec_error),
)

detach

</> 
pub fn detach(
  session: Session,
  next_entity: entity.Entity,
) -> Result(Session, TrackError)

flush

</> 
pub fn flush(
  session: Session,
  executor: fn(query.Query) -> Result(result, exec_error),
) -> Result(
  #(execution.FlushExecution(result), Session),
  SessionExecutionError(exec_error),
)

get

</> 
pub fn get(
  session: Session,
  table: relation.TableRef,
  identity: unit_of_work.Identity,
) -> option.Option(entity.Entity)

new

</> 
pub fn new(snapshot: model.SchemaSnapshot) -> Session

pending_changes

</> 
pub fn pending_changes(session: Session) -> unit_of_work.Session

refresh

</> 
pub fn refresh(
  session: Session,
  next_entity: entity.Entity,
) -> Result(Session, TrackError)

refresh_with_hooks

</> 
pub fn refresh_with_hooks(
  session: Session,
  next_entity: entity.Entity,
  hooks: hook.EntityHooks(hook_error),
) -> Result(Session, HookTrackError(hook_error))

rollback

</> 
pub fn rollback(session: Session) -> Session

stage

</> 
pub fn stage(
  session: Session,
  next_entity: entity.Entity,
) -> Result(Session, TrackError)

stage_with_hooks

</> 
pub fn stage_with_hooks(
  session: Session,
  next_entity: entity.Entity,
  hooks: hook.EntityHooks(hook_error),
) -> Result(Session, HookTrackError(hook_error))

track

</> 
pub fn track(
  session: Session,
  next_entity: entity.Entity,
) -> Result(Session, TrackError)

tracked_entities

</> 
pub fn tracked_entities(session: Session) -> List(entity.Entity)
✨ Search Document