Struct PgMetadataRepository 

pub struct PgMetadataRepository<'connection> { /* private fields */ }

Core repository implementation backed by PostgreSQL metadata tables.

Implementations

impl PgMetadataRepository<'_>

pub fn with_reserved_dataset_admission<T, E>( &self, reservation: &mut PgDatasetReservation<'_>, asset: &AssetRecord, version: &AssetVersionRecord, admit: impl FnOnce(PgMetadataRepository<'_>) -> Result<T, E>, ) -> Result<T, DatasetAdmissionError<E>>

Admits Dataset metadata and consumes shared output ownership atomically. The exclusive mutable writer borrow excludes concurrent Lake effects.

pub fn dataset_admission_receipt( &self, version_id: VersionId, ) -> Result<Option<DatasetAdmissionReceipt>, CoreError>

Reads this actor’s private receipt without relying on catalogue visibility.

pub fn confirm_dataset_cleanup( &self, version_id: VersionId, ) -> Result<(), CoreError>

Clears pending evidence only after the caller has completed Lake cleanup. Admitted receipts cannot be removed through this cleanup boundary.

impl PgMetadataRepository<'static>

pub fn acquire_study_lifecycle( &self, study_id: StudyId, ) -> Result<PgStudyLifecycleGuard, CoreError>

impl PgMetadataRepository<'_>

pub fn authorize_acquisition_destination( &self, study: StudyId, classification: &IngestClassification, ) -> Result<(), CoreError>

Pre-connection destination authority; final admission rechecks current state.

pub fn validate_uploaded_table_source( &self, source: VersionId, study: StudyId, risk: AssetRisk, ) -> Result<(), CoreError>

Authorizes the one freshly ingested Datafile pinned by the App upload workflow. This does not confer trusted or arbitrary derivation authority.

impl PgMetadataRepository<'_>

pub fn new(connection: PgMetadataConnection) -> Self

Creates a repository that owns a direct PostgreSQL metadata connection.

pub fn from_shared(connection: Arc<Mutex<PgMetadataConnection>>) -> Self

Creates a repository from a shared direct PostgreSQL metadata connection.

pub fn from_oauth_shared(connection: Arc<Mutex<LibpqOAuthConnection>>) -> Self

Creates a repository from a shared OAuth-authenticated metadata connection.

pub fn with_correlation(self, context: CorrelationContext) -> Self

Scope observation to a newly constructed repository, never the retained connection.

impl PgMetadataRepository<'static>

pub fn upload_deadline( &self, deadline: Instant, cancelled: Arc<AtomicBool>, ) -> Result<UploadMetadataDeadline, CoreError>

impl PgMetadataRepository<'_>

pub fn capture_semantic_vocabulary( &self, intent: &DisclosureIntent, target: VocabularyId, ) -> Result<CapturedVocabulary, CoreError>

Captures every field and membership dependency under the same locks as admission. The caller’s suggested inputs are replaced by stored origins.

pub fn capture_semantic_vocabularies( &self, intent: &DisclosureIntent, targets: &[VocabularyId], ) -> Result<(DisclosureSnapshot, Vec<SemanticVocabulary>), CoreError>

A single policy decision closes over all values in a nested response.

pub fn catalogue_vocabulary_items( &self, target: VocabularyId, ) -> Result<Option<Vec<VocabularyItemRecord>>, CoreError>

Bounded non-content schema, captured atomically with its declaration proof. Unknown or derived dictionaries have no catalogue item projection.

pub fn retain_vocabulary_contribution( &self, target: VocabularyId, ) -> Result<(), CoreError>

Record a dependency even if equality checks reused every existing value.

pub fn with_semantic_derivation<T>( &self, inputs: &[VersionId], write: impl FnOnce(PgMetadataRepository<'_>) -> Result<T, CoreError>, ) -> Result<T, CoreError>

pub fn begin_semantic_derivation( &self, inputs: &[VersionId], ) -> Result<(), CoreError>

Joins an adapter-owned mutation transaction. This cannot mark a later independent write or turn source provenance into disclosure permission.

pub fn with_semantic_declarations<T>( &self, write: impl FnOnce(PgMetadataRepository<'_>) -> Result<T, CoreError>, ) -> Result<T, CoreError>

Only explicit dictionary declarations use this boundary. Inference and instance data must retain immutable source versions instead.

pub fn semantic_origin( &self, target: &SemanticTarget, ) -> Result<SemanticOrigin, CoreError>

impl PgMetadataRepository<'_>

pub fn begin_semantic_resolution(&self) -> Result<SemanticResolution, CoreError>

pub fn retain_instance_contribution( &self, instance: SemanticInstance, ) -> Result<(), CoreError>

pub fn capture_semantic_state( &self, resolution: &SemanticResolution, scope: &SemanticScope, limits: &DisclosureBudgets, ) -> Result<SemanticState, CoreError>

impl PgMetadataRepository<'_>

pub fn with_admitted_semantic_mutation<T>( &self, state: &SemanticState, admission: Uuid, write: impl FnOnce(PgMetadataRepository<'_>) -> Result<T, CoreError>, ) -> Result<T, CoreError>

Retains the captured state, verifies durable admission, and commits all semantic changes and their origins together. Any callback failure rolls back.

impl PgMetadataRepository<'_>

pub fn retained_semantic_mappings( &self, state: &SemanticState, ) -> Result<SemanticMappings, CoreError>

Reads only the mapping scope whose row/byte bounds and revision were captured. This is available inside the retained adapter transaction.

impl PgMetadataRepository<'_>

pub fn capture_semantic_records( &self, resolution: &SemanticResolution, selection: &SemanticRecordSelection, budgets: &DisclosureBudgets, ) -> Result<CapturedSemanticRecords, CoreError>

pub fn admit_semantic_records( &self, captured: &CapturedSemanticRecords, intent: &DisclosureIntent, ) -> Result<DisclosureSnapshot, CoreError>

Revalidate the retained revision under the same locks as the single policy decision. Inputs come from the stored origin closure, never the caller.

impl PgMetadataRepository<'_>

pub fn retain_semantic_version_access( &self, versions: &[VersionId], ) -> Result<(), CoreError>

Hold Study/version authorization until the enclosing mutation commits, including provenance attached to an existing no-op mapping or link.

pub fn with_semantic_record_mutation<T>( &self, resolution: &SemanticResolution, studies: &[StudyId], budgets: &DisclosureBudgets, write: impl FnOnce(PgMetadataRepository<'_>) -> Result<T, CoreError>, ) -> Result<T, CoreError>

Manual declarations do not acquire a derived-content origin. Mutations and their Transformation links commit together under the retained revision.

impl<'connection> PgMetadataRepository<'connection>

pub fn reserve_dataset_output( &self, executor: Arc<dyn DatasetExecutorLease>, output: DatasetOutputKey, ) -> Result<PgDatasetReservation<'connection>, DatasetReservationError>

Reserves output before version allocation, source staging, or Lake effects. Conflicting acceptance rolls back without an accepted private attempt.

pub fn reserve_dataset_output_with<T>( &self, executor: Arc<dyn DatasetExecutorLease>, output: DatasetOutputKey, accept: impl FnOnce(PgMetadataRepository<'_>, &RecoverableDatasetAttempt) -> Result<T, CoreError>, ) -> Result<(PgDatasetReservation<'connection>, T), DatasetReservationError>

Pending operation/idempotency repositories may participate in acceptance through this scoped metadata callback. No operation is required by writers.

pub fn recoverable_dataset_attempts( &self, executor: Arc<dyn DatasetExecutorLease>, ) -> Result<Vec<RecoverableDatasetAttempt>, CoreError>

Lists only attempts whose executor is excluded by the retained local coordinator. Metadata RLS limits ordinary actors to their own evidence; configured maintenance connections may see all actors’ attempts.

pub fn claim_dataset_recovery( &self, executor: Arc<dyn DatasetExecutorLease>, attempt_id: Uuid, ) -> Result<PgDatasetRecovery<'connection>, CoreError>

Claims a known stopped attempt before any physical reconciliation. The reservation row orders this claim against an in-flight metadata commit.

impl PgMetadataRepository<'static>

pub fn operation_stage_authorized(&self, id: Uuid) -> Result<bool, CoreError>

Recheck current Study authority before another governed stage. The operation record is correlation evidence and never supplies the grant.

pub fn operation_control( connection: LibpqOAuthConnection, ) -> Result<Self, CoreError>

A fresh user-authenticated lifecycle connection. The application exposes only inspection and cancellation; it shares no mutex with the producer.

impl PgMetadataRepository<'static>

pub fn lock_operation_key( &self, scope_digest: String, intent_digest: String, ) -> Result<PgOperationKey, CoreError>

impl PgMetadataRepository<'_>

pub fn operation_precondition_satisfied( &self, scope: &OperationResourceScope, precondition: &Precondition, ) -> Result<bool, CoreError>

Evaluated inside output acceptance after ownership has been acquired.

impl PgMetadataRepository<'_>

pub fn operation_now(&self) -> Result<DateTime<Utc>, CoreError>

One authoritative lifecycle instant, also used by key and cleanup queries.

Trait Implementations

impl AssetRepository for PgMetadataRepository<'_>

fn asset_classification<'life0, 'async_trait>( &'life0 self, asset: AssetId, ) -> Pin<Box<dyn Future<Output = Result<Option<AssetClassification>, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn validate_dataset_derivation<'life0, 'life1, 'async_trait>( &'life0 self, inputs: &'life1 [VersionId], risk: AssetRisk, inherit: bool, ) -> Pin<Box<dyn Future<Output = Result<(), CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn list_assets_for_study<'life0, 'async_trait>( &'life0 self, study_id: StudyId, ) -> Pin<Box<dyn Future<Output = Result<Vec<AssetRecord>, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn get_asset_by_id<'life0, 'async_trait>( &'life0 self, asset_id: AssetId, ) -> Pin<Box<dyn Future<Output = Result<Option<AssetRecord>, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn get_asset_by_name<'life0, 'life1, 'async_trait>( &'life0 self, study_id: StudyId, name: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<AssetRecord>, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn create_asset<'life0, 'life1, 'async_trait>( &'life0 self, asset: &'life1 NewAssetRecord, ) -> Pin<Box<dyn Future<Output = Result<AssetRecord, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn save_asset<'life0, 'life1, 'async_trait>( &'life0 self, asset: &'life1 AssetRecord, ) -> Pin<Box<dyn Future<Output = Result<AssetRecord, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn delete_asset_record<'life0, 'async_trait>( &'life0 self, asset_id: AssetId, ) -> Pin<Box<dyn Future<Output = Result<bool, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn list_asset_versions<'life0, 'async_trait>( &'life0 self, asset_id: AssetId, ) -> Pin<Box<dyn Future<Output = Result<Vec<AssetVersionRecord>, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn get_asset_version<'life0, 'async_trait>( &'life0 self, version_id: VersionId, ) -> Pin<Box<dyn Future<Output = Result<Option<AssetVersionRecord>, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn delete_datafile_version_metadata<'life0, 'async_trait>( &'life0 self, version_id: VersionId, latest_promotion: Option<(AssetId, Option<VersionId>)>, ) -> Pin<Box<dyn Future<Output = Result<bool, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Removes a Datafile version and its dependent metadata atomically with the application-selected latest promotion. Failure retains all metadata.

fn delete_asset_version_record<'life0, 'async_trait>( &'life0 self, version_id: VersionId, ) -> Pin<Box<dyn Future<Output = Result<bool, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn create_asset_version<'life0, 'life1, 'async_trait>( &'life0 self, version: &'life1 NewAssetVersionRecord, ) -> Pin<Box<dyn Future<Output = Result<AssetVersionRecord, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn save_asset_version<'life0, 'life1, 'async_trait>( &'life0 self, _version: &'life1 AssetVersionRecord, ) -> Pin<Box<dyn Future<Output = Result<AssetVersionRecord, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn admit_asset_version<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, version: &'life1 AssetVersionRecord, classification: &'life2 IngestClassification, ) -> Pin<Box<dyn Future<Output = Result<AssetVersionRecord, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Explicit admission intent is separate from an immutable version record.

fn mark_asset_version_latest<'life0, 'async_trait>( &'life0 self, asset_id: AssetId, version_id: VersionId, ) -> Pin<Box<dyn Future<Output = Result<AssetVersionRecord, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn list_asset_version_duo_restrictions<'life0, 'async_trait>( &'life0 self, version_id: VersionId, ) -> Pin<Box<dyn Future<Output = Result<Vec<AssetVersionDuoRestrictionRecord>, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn create_asset_version_duo_restriction<'life0, 'life1, 'async_trait>( &'life0 self, restriction: &'life1 NewAssetVersionDuoRestrictionRecord, ) -> Pin<Box<dyn Future<Output = Result<AssetVersionDuoRestrictionRecord, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn save_asset_version_duo_restriction<'life0, 'life1, 'async_trait>( &'life0 self, restriction: &'life1 AssetVersionDuoRestrictionRecord, ) -> Pin<Box<dyn Future<Output = Result<AssetVersionDuoRestrictionRecord, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn replace_asset_version_duo_restrictions<'life0, 'life1, 'async_trait>( &'life0 self, version_id: VersionId, restrictions: &'life1 [NewAssetVersionDuoRestrictionRecord], ) -> Pin<Box<dyn Future<Output = Result<Vec<AssetVersionDuoRestrictionRecord>, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn clear_asset_version_duo_restrictions<'life0, 'async_trait>( &'life0 self, version_id: VersionId, ) -> Pin<Box<dyn Future<Output = Result<Vec<AssetVersionDuoRestrictionRecord>, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn list_datasets_for_asset<'life0, 'async_trait>( &'life0 self, asset_id: AssetId, ) -> Pin<Box<dyn Future<Output = Result<Vec<DatasetRecord>, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn search_datasets<'life0, 'life1, 'async_trait>( &'life0 self, query: &'life1 DatasetSearchQuery, ) -> Pin<Box<dyn Future<Output = Result<SearchPage<DatasetSearchRecord, DatasetSearchCursorAnchor>, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn search_datafiles<'life0, 'life1, 'async_trait>( &'life0 self, query: &'life1 DataFileSearchQuery, ) -> Pin<Box<dyn Future<Output = Result<SearchPage<DataFileSearchRecord, DataFileSearchCursorAnchor>, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn get_dataset<'life0, 'async_trait>( &'life0 self, dataset_id: VersionId, ) -> Pin<Box<dyn Future<Output = Result<Option<DatasetRecord>, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn save_dataset<'life0, 'life1, 'async_trait>( &'life0 self, dataset: &'life1 DatasetRecord, ) -> Pin<Box<dyn Future<Output = Result<DatasetRecord, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn get_dataset_version_withdrawal<'life0, 'async_trait>( &'life0 self, dataset_id: VersionId, ) -> Pin<Box<dyn Future<Output = Result<Option<DatasetVersionWithdrawalRecord>, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn list_dataset_version_withdrawals<'life0, 'async_trait>( &'life0 self, asset_id: AssetId, ) -> Pin<Box<dyn Future<Output = Result<Vec<DatasetVersionWithdrawalRecord>, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn save_dataset_version_withdrawal<'life0, 'life1, 'async_trait>( &'life0 self, withdrawal: &'life1 NewDatasetVersionWithdrawalRecord, ) -> Pin<Box<dyn Future<Output = Result<DatasetVersionWithdrawalRecord, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn deactivate_dataset_version_links<'life0, 'async_trait>( &'life0 self, dataset_id: VersionId, ) -> Pin<Box<dyn Future<Output = Result<(), CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn clear_asset_version_latest<'life0, 'async_trait>( &'life0 self, asset_id: AssetId, version_id: VersionId, ) -> Pin<Box<dyn Future<Output = Result<AssetVersionRecord, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn list_datafiles_for_asset<'life0, 'async_trait>( &'life0 self, asset_id: AssetId, ) -> Pin<Box<dyn Future<Output = Result<Vec<DataFileRecord>, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn get_datafile<'life0, 'async_trait>( &'life0 self, datafile_id: VersionId, ) -> Pin<Box<dyn Future<Output = Result<Option<DataFileRecord>, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn save_datafile<'life0, 'life1, 'async_trait>( &'life0 self, datafile: &'life1 DataFileRecord, ) -> Pin<Box<dyn Future<Output = Result<DataFileRecord, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn delete_datafile_record<'life0, 'async_trait>( &'life0 self, datafile_id: VersionId, ) -> Pin<Box<dyn Future<Output = Result<bool, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

impl CatalogueRegistrationRepository for PgMetadataRepository<'_>

fn create_domain_registration<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, domain: &'life1 NewDomainRecord, normalized_tags: &'life2 [String], ) -> Pin<Box<dyn Future<Output = Result<DomainRecord, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

fn create_study_registration<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, study: &'life1 NewStudyRecord, domain_ids: &'life2 [DomainId], normalized_tags: &'life3 [String], ) -> Pin<Box<dyn Future<Output = Result<StudyRecord, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

fn save_domain_registration<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, domain: &'life1 DomainRecord, normalized_tags: &'life2 [String], ) -> Pin<Box<dyn Future<Output = Result<DomainRecord, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

fn save_study_registration<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, study: &'life1 StudyRecord, domain_ids: &'life2 [DomainId], normalized_tags: &'life3 [String], ) -> Pin<Box<dyn Future<Output = Result<StudyRecord, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

impl<'connection> Clone for PgMetadataRepository<'connection>

fn clone(&self) -> PgMetadataRepository<'connection>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'connection> Debug for PgMetadataRepository<'connection>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl DomainRepository for PgMetadataRepository<'_>

fn list_domains<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<DomainRecord>, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn list_domains_by_name<'life0, 'life1, 'async_trait>( &'life0 self, name: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Vec<DomainRecord>, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

All visible matches; name ambiguity is decided by the application.

fn get_domain_by_id<'life0, 'async_trait>( &'life0 self, domain_id: DomainId, ) -> Pin<Box<dyn Future<Output = Result<Option<DomainRecord>, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn get_domain_by_name<'life0, 'life1, 'async_trait>( &'life0 self, name: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<DomainRecord>, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn create_domain<'life0, 'life1, 'async_trait>( &'life0 self, domain: &'life1 NewDomainRecord, ) -> Pin<Box<dyn Future<Output = Result<DomainRecord, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn save_domain<'life0, 'life1, 'async_trait>( &'life0 self, domain: &'life1 DomainRecord, ) -> Pin<Box<dyn Future<Output = Result<DomainRecord, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn delete_domain_record<'life0, 'async_trait>( &'life0 self, domain_id: DomainId, ) -> Pin<Box<dyn Future<Output = Result<bool, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

impl EntityRepository for PgMetadataRepository<'_>

fn list_entities<'life0, 'async_trait>( &'life0 self, domain_id: DomainId, ) -> Pin<Box<dyn Future<Output = Result<Vec<EntityRecord>, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn list_entity_relations<'life0, 'async_trait>( &'life0 self, domain_id: DomainId, ) -> Pin<Box<dyn Future<Output = Result<Vec<EntityRelationRecord>, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn search_entities<'life0, 'life1, 'async_trait>( &'life0 self, query: &'life1 EntitySearchQuery, ) -> Pin<Box<dyn Future<Output = Result<SearchPage<EntitySearchRecord, EntitySearchCursorAnchor>, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn search_entity_relations<'life0, 'life1, 'async_trait>( &'life0 self, query: &'life1 RelationSearchQuery, ) -> Pin<Box<dyn Future<Output = Result<SearchPage<RelationSearchRecord, RelationSearchCursorAnchor>, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn create_entity<'life0, 'life1, 'async_trait>( &'life0 self, entity: &'life1 NewEntityRecord, ) -> Pin<Box<dyn Future<Output = Result<EntityRecord, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn save_entity<'life0, 'life1, 'async_trait>( &'life0 self, entity: &'life1 EntityRecord, ) -> Pin<Box<dyn Future<Output = Result<EntityRecord, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn create_entity_relation<'life0, 'life1, 'async_trait>( &'life0 self, relation: &'life1 NewEntityRelationRecord, ) -> Pin<Box<dyn Future<Output = Result<EntityRelationRecord, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn save_entity_relation<'life0, 'life1, 'async_trait>( &'life0 self, relation: &'life1 EntityRelationRecord, ) -> Pin<Box<dyn Future<Output = Result<EntityRelationRecord, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn delete_entity_record<'life0, 'async_trait>( &'life0 self, entity_id: EntityId, ) -> Pin<Box<dyn Future<Output = Result<bool, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn delete_entity_relation_record<'life0, 'async_trait>( &'life0 self, relation_id: EntityRelationId, ) -> Pin<Box<dyn Future<Output = Result<bool, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn get_entity_instance<'life0, 'async_trait>( &'life0 self, instance_id: i64, ) -> Pin<Box<dyn Future<Output = Result<Option<EntityInstanceRecord>, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn get_entity_instance_by_uuid<'life0, 'async_trait>( &'life0 self, uuid: Uuid, ) -> Pin<Box<dyn Future<Output = Result<Option<EntityInstanceRecord>, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn list_entity_instances<'life0, 'async_trait>( &'life0 self, entity_id: EntityId, ) -> Pin<Box<dyn Future<Output = Result<Vec<EntityInstanceRecord>, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn save_entity_instance<'life0, 'life1, 'async_trait>( &'life0 self, instance: &'life1 EntityInstanceWriteRecord, ) -> Pin<Box<dyn Future<Output = Result<EntityInstanceRecord, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn create_entity_instance<'life0, 'life1, 'async_trait>( &'life0 self, instance: &'life1 NewEntityInstanceRecord, ) -> Pin<Box<dyn Future<Output = Result<EntityInstanceRecord, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn get_study_entity_instance<'life0, 'life1, 'async_trait>( &'life0 self, study_id: StudyId, entity_id: EntityId, external_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<StudyEntityInstanceRecord>, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn save_study_entity_instance<'life0, 'life1, 'async_trait>( &'life0 self, mapping: &'life1 StudyEntityInstanceWriteRecord, ) -> Pin<Box<dyn Future<Output = Result<StudyEntityInstanceRecord, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn list_study_entity_instances<'life0, 'async_trait>( &'life0 self, study_id: StudyId, ) -> Pin<Box<dyn Future<Output = Result<Vec<StudyEntityInstanceRecord>, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn get_relation_instance<'life0, 'async_trait>( &'life0 self, relation_instance_id: i64, ) -> Pin<Box<dyn Future<Output = Result<Option<RelationInstanceRecord>, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn get_relation_instance_by_uuid<'life0, 'async_trait>( &'life0 self, uuid: Uuid, ) -> Pin<Box<dyn Future<Output = Result<Option<RelationInstanceRecord>, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn list_relation_instances<'life0, 'async_trait>( &'life0 self, relation_id: EntityRelationId, ) -> Pin<Box<dyn Future<Output = Result<Vec<RelationInstanceRecord>, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn save_relation_instance<'life0, 'life1, 'async_trait>( &'life0 self, relation: &'life1 RelationInstanceWriteRecord, ) -> Pin<Box<dyn Future<Output = Result<RelationInstanceRecord, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn create_relation_instance<'life0, 'life1, 'async_trait>( &'life0 self, relation: &'life1 NewRelationInstanceRecord, ) -> Pin<Box<dyn Future<Output = Result<RelationInstanceRecord, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn get_study_relation_instance<'life0, 'life1, 'async_trait>( &'life0 self, study_id: StudyId, relation_id: EntityRelationId, external_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<StudyRelationInstanceRecord>, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn save_study_relation_instance<'life0, 'life1, 'async_trait>( &'life0 self, mapping: &'life1 StudyRelationInstanceWriteRecord, ) -> Pin<Box<dyn Future<Output = Result<StudyRelationInstanceRecord, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn list_study_relation_instances<'life0, 'async_trait>( &'life0 self, study_id: StudyId, ) -> Pin<Box<dyn Future<Output = Result<Vec<StudyRelationInstanceRecord>, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn link_asset_version_entity<'life0, 'life1, 'async_trait>( &'life0 self, link: &'life1 AssetVersionEntityRecord, ) -> Pin<Box<dyn Future<Output = Result<AssetVersionEntityRecord, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn list_asset_version_entities<'life0, 'async_trait>( &'life0 self, version_id: VersionId, ) -> Pin<Box<dyn Future<Output = Result<Vec<AssetVersionEntityRecord>, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn list_asset_version_entities_for_instance<'life0, 'async_trait>( &'life0 self, entity_instance_id: i64, ) -> Pin<Box<dyn Future<Output = Result<Vec<AssetVersionEntityRecord>, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn link_dataset_version_entity<'life0, 'life1, 'async_trait>( &'life0 self, link: &'life1 DatasetVersionEntityRecord, ) -> Pin<Box<dyn Future<Output = Result<DatasetVersionEntityRecord, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn list_dataset_version_entities<'life0, 'async_trait>( &'life0 self, version_id: VersionId, ) -> Pin<Box<dyn Future<Output = Result<Vec<DatasetVersionEntityRecord>, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn list_dataset_version_entities_for_instance<'life0, 'async_trait>( &'life0 self, entity_instance_id: i64, ) -> Pin<Box<dyn Future<Output = Result<Vec<DatasetVersionEntityRecord>, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn link_asset_version_relation_instance<'life0, 'life1, 'async_trait>( &'life0 self, link: &'life1 AssetVersionRelationInstanceRecord, ) -> Pin<Box<dyn Future<Output = Result<AssetVersionRelationInstanceRecord, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn list_asset_version_relation_instances<'life0, 'async_trait>( &'life0 self, version_id: VersionId, ) -> Pin<Box<dyn Future<Output = Result<Vec<AssetVersionRelationInstanceRecord>, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn list_asset_version_relation_instances_for_instance<'life0, 'async_trait>( &'life0 self, relation_instance_id: i64, ) -> Pin<Box<dyn Future<Output = Result<Vec<AssetVersionRelationInstanceRecord>, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn link_dataset_version_relation_instance<'life0, 'life1, 'async_trait>( &'life0 self, link: &'life1 DatasetVersionRelationInstanceRecord, ) -> Pin<Box<dyn Future<Output = Result<DatasetVersionRelationInstanceRecord, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn list_dataset_version_relation_instances<'life0, 'async_trait>( &'life0 self, version_id: VersionId, ) -> Pin<Box<dyn Future<Output = Result<Vec<DatasetVersionRelationInstanceRecord>, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn list_dataset_version_relation_instances_for_instance<'life0, 'async_trait>( &'life0 self, relation_instance_id: i64, ) -> Pin<Box<dyn Future<Output = Result<Vec<DatasetVersionRelationInstanceRecord>, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn link_dataset_version_entities<'life0, 'life1, 'async_trait>( &'life0 self, links: &'life1 [DatasetVersionEntityRecord], ) -> Pin<Box<dyn Future<Output = Result<(), CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn link_dataset_version_relation_instances<'life0, 'life1, 'async_trait>( &'life0 self, links: &'life1 [DatasetVersionRelationInstanceRecord], ) -> Pin<Box<dyn Future<Output = Result<(), CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl OperationRepository for PgMetadataRepository<'_>

fn create_operation( &self, attempt_id: Uuid, record: &StoredOperation, ) -> Result<(), CoreError>

fn get_operation(&self, id: Uuid) -> Result<Option<StoredOperation>, CoreError>

fn operation_history( &self, query: &OperationHistoryQuery, ) -> Result<Vec<OperationHistoryEntry>, CoreError>

Bounded, actor-bound candidates in descending creation/ID order. Applications apply public scope/status/kind filters and recheck current resource authority before forming public pages.

fn transition_operation( &self, expected: OperationStatus, sequence: u64, record: &StoredOperation, ) -> Result<(), CoreError>

Compare-and-set status and event sequence; terminal records cannot change.

impl StudyDomainRepository for PgMetadataRepository<'_>

fn link_study_domain<'life0, 'async_trait>( &'life0 self, study_id: StudyId, domain_id: DomainId, ) -> Pin<Box<dyn Future<Output = Result<StudyDomainLinkRecord, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn list_domains_for_study<'life0, 'async_trait>( &'life0 self, study_id: StudyId, ) -> Pin<Box<dyn Future<Output = Result<Vec<DomainRecord>, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

impl StudyGovernanceRepository for PgMetadataRepository<'_>

fn list_access_grants<'life0, 'async_trait>( &'life0 self, study_id: StudyId, ) -> Pin<Box<dyn Future<Output = Result<Vec<StudyAccessGrantRecord>, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn grant_study_access<'life0, 'life1, 'async_trait>( &'life0 self, study_id: StudyId, target_user_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<StudyAccessGrantRecord, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn save_access_grant<'life0, 'life1, 'async_trait>( &'life0 self, grant: &'life1 StudyAccessGrantRecord, ) -> Pin<Box<dyn Future<Output = Result<StudyAccessGrantRecord, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn revoke_access_grant<'life0, 'life1, 'async_trait>( &'life0 self, study_id: StudyId, principal: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<(), CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn revoke_study_access<'life0, 'life1, 'async_trait>( &'life0 self, study_id: StudyId, target_user_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<(), CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn list_custodians<'life0, 'async_trait>( &'life0 self, study_id: StudyId, ) -> Pin<Box<dyn Future<Output = Result<Vec<StudyCustodianLinkRecord>, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn add_delegate_custodian<'life0, 'life1, 'async_trait>( &'life0 self, study_id: StudyId, target_user_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<StudyCustodianLinkRecord, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn transfer_primary_custodianship<'life0, 'life1, 'async_trait>( &'life0 self, study_id: StudyId, target_user_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<StudyCustodianLinkRecord, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn remove_delegate_custodian<'life0, 'life1, 'async_trait>( &'life0 self, study_id: StudyId, target_user_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<(), CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn save_custodian<'life0, 'life1, 'async_trait>( &'life0 self, custodian: &'life1 StudyCustodianLinkRecord, ) -> Pin<Box<dyn Future<Output = Result<StudyCustodianLinkRecord, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn list_study_duo_restrictions<'life0, 'async_trait>( &'life0 self, study_id: StudyId, ) -> Pin<Box<dyn Future<Output = Result<Vec<StudyDuoRestrictionRecord>, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn create_study_duo_restriction<'life0, 'life1, 'async_trait>( &'life0 self, restriction: &'life1 NewStudyDuoRestrictionRecord, ) -> Pin<Box<dyn Future<Output = Result<StudyDuoRestrictionRecord, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn save_study_duo_restriction<'life0, 'life1, 'async_trait>( &'life0 self, restriction: &'life1 StudyDuoRestrictionRecord, ) -> Pin<Box<dyn Future<Output = Result<StudyDuoRestrictionRecord, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn replace_study_duo_restrictions<'life0, 'life1, 'async_trait>( &'life0 self, study_id: StudyId, restrictions: &'life1 [NewStudyDuoRestrictionRecord], ) -> Pin<Box<dyn Future<Output = Result<Vec<StudyDuoRestrictionRecord>, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl StudyRepository for PgMetadataRepository<'_>

fn study_type_exists<'life0, 'async_trait>( &'life0 self, id: StudyTypeId, ) -> Pin<Box<dyn Future<Output = Result<bool, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn list_studies<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<StudyRecord>, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn get_study_by_id<'life0, 'async_trait>( &'life0 self, study_id: StudyId, ) -> Pin<Box<dyn Future<Output = Result<Option<StudyRecord>, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn get_study_by_name<'life0, 'life1, 'async_trait>( &'life0 self, name: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<StudyRecord>, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn search_studies<'life0, 'life1, 'async_trait>( &'life0 self, query: &'life1 StudySearchQuery, ) -> Pin<Box<dyn Future<Output = Result<SearchPage<StudyRecord, StudySearchCursorAnchor>, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn create_study<'life0, 'life1, 'async_trait>( &'life0 self, study: &'life1 NewStudyRecord, ) -> Pin<Box<dyn Future<Output = Result<StudyRecord, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn save_study<'life0, 'life1, 'async_trait>( &'life0 self, study: &'life1 StudyRecord, ) -> Pin<Box<dyn Future<Output = Result<StudyRecord, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn delete_study_record<'life0, 'async_trait>( &'life0 self, study_id: StudyId, ) -> Pin<Box<dyn Future<Output = Result<bool, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

impl TagRepository for PgMetadataRepository<'_>

fn list_tags<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<TagRecord>, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn upsert_tag<'life0, 'life1, 'async_trait>( &'life0 self, normalized_name: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<TagRecord, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn attach_tag<'life0, 'async_trait>( &'life0 self, tag_id: TagId, target: TagAttachmentTarget, ) -> Pin<Box<dyn Future<Output = Result<(), CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn detach_tag<'life0, 'async_trait>( &'life0 self, tag_id: TagId, target: TagAttachmentTarget, ) -> Pin<Box<dyn Future<Output = Result<(), CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn delete_tag_if_unused<'life0, 'async_trait>( &'life0 self, tag_id: TagId, ) -> Pin<Box<dyn Future<Output = Result<bool, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn list_tags_for_target<'life0, 'async_trait>( &'life0 self, target: TagAttachmentTarget, ) -> Pin<Box<dyn Future<Output = Result<Vec<TagRecord>, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn create_tag<'life0, 'life1, 'async_trait>( &'life0 self, tag: &'life1 NewTagRecord, ) -> Pin<Box<dyn Future<Output = Result<TagRecord, CoreError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

fn set_tags_for_target<'life0, 'life1, 'async_trait>( &'life0 self, target: TagAttachmentTarget, normalized_names: &'life1 [String], ) -> Pin<Box<dyn Future<Output = Result<Vec<TagRecord>, CoreError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

impl TransformationRepository for PgMetadataRepository<'_>

fn create_transformation<'life0, 'life1, 'async_trait>( &'life0 self, transformation: &'life1 NewTransformationRecord, ) -> Pin<Box<dyn Future<Output = Result<TransformationRecord, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn save_transformation<'life0, 'life1, 'async_trait>( &'life0 self, transformation: &'life1 TransformationRecord, ) -> Pin<Box<dyn Future<Output = Result<TransformationRecord, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn add_inputs<'life0, 'life1, 'async_trait>( &'life0 self, transformation_id: TransformationId, input_ids: &'life1 [VersionId], ) -> Pin<Box<dyn Future<Output = Result<(), CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn add_outputs<'life0, 'life1, 'async_trait>( &'life0 self, transformation_id: TransformationId, output_ids: &'life1 [VersionId], ) -> Pin<Box<dyn Future<Output = Result<(), CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn delete_transformation<'life0, 'async_trait>( &'life0 self, transformation_id: TransformationId, ) -> Pin<Box<dyn Future<Output = Result<bool, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn list_inputs<'life0, 'async_trait>( &'life0 self, transformation_id: TransformationId, ) -> Pin<Box<dyn Future<Output = Result<Vec<TransformationInputLinkRecord>, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn list_outputs<'life0, 'async_trait>( &'life0 self, transformation_id: TransformationId, ) -> Pin<Box<dyn Future<Output = Result<Vec<TransformationOutputLinkRecord>, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn list_transformations_producing<'life0, 'async_trait>( &'life0 self, version_id: VersionId, ) -> Pin<Box<dyn Future<Output = Result<Vec<TransformationRecord>, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn list_transformations<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<TransformationRecord>, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

impl VariableRepository for PgMetadataRepository<'_>

fn list_value_types<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<ValueTypeRecord>, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn list_domain_variables<'life0, 'async_trait>( &'life0 self, domain_id: DomainId, ) -> Pin<Box<dyn Future<Output = Result<Vec<VariableRecord>, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn get_variable<'life0, 'async_trait>( &'life0 self, variable_id: VariableId, ) -> Pin<Box<dyn Future<Output = Result<Option<VariableRecord>, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn create_variable<'life0, 'life1, 'async_trait>( &'life0 self, variable: &'life1 NewVariableRecord, ) -> Pin<Box<dyn Future<Output = Result<VariableRecord, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn save_variable<'life0, 'life1, 'async_trait>( &'life0 self, variable: &'life1 VariableRecord, ) -> Pin<Box<dyn Future<Output = Result<VariableRecord, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn update_variable_metadata<'life0, 'life1, 'async_trait>( &'life0 self, variable: &'life1 VariableRecord, ) -> Pin<Box<dyn Future<Output = Result<VariableRecord, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn link_dataset_variable<'life0, 'async_trait>( &'life0 self, dataset_id: VersionId, variable_id: VariableId, row_role: KeyRole, ) -> Pin<Box<dyn Future<Output = Result<DatasetVariableLinkRecord, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn list_dataset_variables<'life0, 'async_trait>( &'life0 self, dataset_id: VersionId, ) -> Pin<Box<dyn Future<Output = Result<Vec<DatasetVariableLinkRecord>, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn list_dataset_variables_for_variable<'life0, 'async_trait>( &'life0 self, variable_id: VariableId, ) -> Pin<Box<dyn Future<Output = Result<Vec<DatasetVariableLinkRecord>, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn delete_variable_record<'life0, 'async_trait>( &'life0 self, variable_id: VariableId, ) -> Pin<Box<dyn Future<Output = Result<bool, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn search_variables<'life0, 'life1, 'async_trait>( &'life0 self, query: &'life1 VariableSearchQuery, ) -> Pin<Box<dyn Future<Output = Result<SearchPage<VariableSearchRecord, VariableSearchCursorAnchor>, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl VocabularyRepository for PgMetadataRepository<'_>

fn list_vocabularies<'life0, 'async_trait>( &'life0 self, domain_id: DomainId, ) -> Pin<Box<dyn Future<Output = Result<Vec<VocabularyRecord>, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn get_vocabulary<'life0, 'async_trait>( &'life0 self, vocabulary_id: VocabularyId, ) -> Pin<Box<dyn Future<Output = Result<Option<VocabularyRecord>, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn list_vocabulary_items<'life0, 'async_trait>( &'life0 self, vocabulary_id: VocabularyId, ) -> Pin<Box<dyn Future<Output = Result<Vec<VocabularyItemRecord>, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn get_vocabulary_item<'life0, 'async_trait>( &'life0 self, vocabulary_item_id: VocabularyItemId, ) -> Pin<Box<dyn Future<Output = Result<Option<VocabularyItemRecord>, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn create_vocabulary<'life0, 'life1, 'async_trait>( &'life0 self, vocabulary: &'life1 NewVocabularyRecord, ) -> Pin<Box<dyn Future<Output = Result<VocabularyRecord, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn save_vocabulary<'life0, 'life1, 'async_trait>( &'life0 self, vocabulary: &'life1 VocabularyRecord, ) -> Pin<Box<dyn Future<Output = Result<VocabularyRecord, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn update_vocabulary<'life0, 'life1, 'async_trait>( &'life0 self, vocabulary: &'life1 VocabularyRecord, ) -> Pin<Box<dyn Future<Output = Result<VocabularyRecord, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn create_vocabulary_items<'life0, 'life1, 'async_trait>( &'life0 self, vocabulary_id: VocabularyId, items: &'life1 [NewVocabularyItemRecord], ) -> Pin<Box<dyn Future<Output = Result<Vec<VocabularyItemRecord>, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn save_vocabulary_items<'life0, 'life1, 'async_trait>( &'life0 self, items: &'life1 [VocabularyItemRecord], ) -> Pin<Box<dyn Future<Output = Result<(), CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn update_vocabulary_items<'life0, 'life1, 'async_trait>( &'life0 self, items: &'life1 [VocabularyItemRecord], ) -> Pin<Box<dyn Future<Output = Result<(), CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn list_vocabulary_mappings<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<VocabularyMappingRecord>, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn save_vocabulary_mapping<'life0, 'life1, 'async_trait>( &'life0 self, mapping: &'life1 VocabularyMappingRecord, ) -> Pin<Box<dyn Future<Output = Result<VocabularyMappingRecord, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn create_vocabulary_mapping<'life0, 'life1, 'async_trait>( &'life0 self, mapping: &'life1 NewVocabularyMappingRecord, ) -> Pin<Box<dyn Future<Output = Result<VocabularyMappingRecord, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn delete_vocabulary_record<'life0, 'async_trait>( &'life0 self, vocabulary_id: VocabularyId, ) -> Pin<Box<dyn Future<Output = Result<bool, CoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,