DimensionRecordStorage

class lsst.daf.butler.registry.interfaces.DimensionRecordStorage

Bases: ABC

An abstract base class that represents a way of storing the records associated with a single DimensionElement.

Concrete DimensionRecordStorage instances should generally be constructed via a call to setupDimensionStorage, which selects the appropriate subclass for each element according to its configuration.

All DimensionRecordStorage methods are pure abstract, even though in some cases a reasonable default implementation might be possible, in order to better guarantee all methods are correctly overridden. All of these potentially-defaultable implementations are extremely trivial, so asking subclasses to provide them is not a significant burden.

Attributes Summary

element

The element whose records this instance managers (DimensionElement).

Methods Summary

clearCaches()	Clear any in-memory caches held by the storage instance.
digestTables()	Return tables used for schema digest.
fetch_one(data_id, context)	Retrieve a single record from storage.
get_record_cache(context)	Return a local cache of all DimensionRecord objects for this element, fetching it if necessary.
insert(*records[, replace, skip_existing])	Insert one or more records into storage.
join(target, join, context)	Join this dimension element's records to a relation.
sync(record[, update])	Synchronize a record with the database, inserting it only if it does not exist and comparing values if it does.

Attributes Documentation

element

The element whose records this instance managers (DimensionElement).

Methods Documentation

abstract clearCaches() → None

Clear any in-memory caches held by the storage instance.

This is called by Registry when transactions are rolled back, to avoid in-memory caches from ever containing records that are not present in persistent storage.

abstract digestTables() → list[sqlalchemy.sql.schema.Table]

Return tables used for schema digest.

Returns:

tableslist [ sqlalchemy.schema.Table ]

Possibly empty list of tables for schema digest calculations.

abstract fetch_one(data_id: DataCoordinate, context: queries.SqlQueryContext) → DimensionRecord | None

Retrieve a single record from storage.

Parameters:

data_idDataCoordinate

Data ID of the record to fetch. Implied dimensions do not need to be present.

contextqueries.SqlQueryContext

Context to be used to execute queries when no cached result is available.

Returns:

recordDimensionRecord or None

Fetched record, or possibly None if there was no match for the given data ID.

get_record_cache(context: queries.SqlQueryContext) → Mapping[DataCoordinate, DimensionRecord] | None

Return a local cache of all DimensionRecord objects for this element, fetching it if necessary.

Implementations that never cache records should return None.

Parameters:

contextqueries.SqlQueryContext

Context to be used to execute queries when no cached result is available.

Returns:

cacheMapping [ DataCoordinate, DimensionRecord ] or None

Mapping from data ID to dimension record, or None.

abstract insert(*records: DimensionRecord, replace: bool = False, skip_existing: bool = False) → None

Insert one or more records into storage.

Parameters:

records

One or more instances of the DimensionRecord subclass for the element this storage is associated with.

replace: `bool`, optional

If True (False is default), replace existing records in the database if there is a conflict.

skip_existingbool, optional

If True (False is default), skip insertion if a record with the same primary key values already exists.

Raises:

TypeError

Raised if the element does not support record insertion.

sqlalchemy.exc.IntegrityError

Raised if one or more records violate database integrity constraints.

Notes

As insert is expected to be called only by a Registry, we rely on Registry to provide transactionality, both by using a SQLALchemy connection shared with the Registry and by relying on it to call clearCaches when rolling back transactions.

abstract join(target: Relation, join: Join, context: queries.SqlQueryContext) → Relation

Join this dimension element’s records to a relation.

Parameters:

targetRelation

Existing relation to join to. Implementations may require that this relation already include dimension key columns for this dimension element and assume that dataset or spatial join relations that might provide these will be included in the relation tree first.

joinJoin

Join operation to use when the implementation is an actual join. When a true join is being simulated by other relation operations, this objects min_columns and max_columns should still be respected.

contextqueries.SqlQueryContext

Object that manages relation engines and database-side state (e.g. temporary tables) for the query.

Returns:

joinedRelation

New relation that includes this relation’s dimension key and record columns, as well as all columns in target, with rows constrained to those for which this element’s dimension key values exist in the registry and rows already exist in target.

abstract sync(record: DimensionRecord, update: bool = False) → bool | dict[str, Any]

Synchronize a record with the database, inserting it only if it does not exist and comparing values if it does.

Parameters:

recordDimensionRecord.

An instance of the DimensionRecord subclass for the element this storage is associated with.

update: `bool`, optional

If True (False is default), update the existing record in the database if there is a conflict.

Returns:

inserted_or_updatedbool or dict

True if a new row was inserted, False if no changes were needed, or a dict mapping updated column names to their old values if an update was performed (only possible if update=True).

Raises:

DatabaseConflictError

Raised if the record exists in the database (according to primary key lookup) but is inconsistent with the given one.

TypeError

Raised if the element does not support record synchronization.

sqlalchemy.exc.IntegrityError

Raised if one or more records violate database integrity constraints.