def test_composites(self):
"""Test components within composite DatasetTypes."""
storageClassA = StorageClass("compA")
storageClassB = StorageClass("compB")
storageClass = StorageClass("test_composite", components={"compA": storageClassA,
"compB": storageClassB})
self.assertTrue(storageClass.isComposite())
self.assertFalse(storageClassA.isComposite())
self.assertFalse(storageClassB.isComposite())
dimensions = self.universe.extract(("instrument", "visit"))
datasetTypeComposite = DatasetType("composite", dimensions, storageClass)
datasetTypeComponentA = DatasetType("composite.compA", dimensions, storageClassA)
datasetTypeComponentB = DatasetType("composite.compB", dimensions, storageClassB)
self.assertTrue(datasetTypeComposite.isComposite())
self.assertFalse(datasetTypeComponentA.isComposite())
self.assertTrue(datasetTypeComponentB.isComponent())
self.assertFalse(datasetTypeComposite.isComponent())
self.assertEqual(datasetTypeComposite.name, "composite")
self.assertEqual(datasetTypeComponentA.name, "composite.compA")
self.assertEqual(datasetTypeComponentB.component(), "compB")
self.assertEqual(datasetTypeComposite.nameAndComponent(), ("composite", None))
self.assertEqual(datasetTypeComponentA.nameAndComponent(), ("composite", "compA"))
def register(self, datasetType: DatasetType) -> Tuple[DatasetRecordStorage, bool]:
# Docstring inherited from DatasetRecordStorageManager.
if datasetType.isComponent():
raise ValueError("Component dataset types can not be stored in registry."
f" Rejecting {datasetType.name}")
storage = self._byName.get(datasetType.name)
if storage is None:
row, inserted = self._db.sync(
self._static.dataset_type,
keys={"name": datasetType.name},
compared={
"dimensions_encoded": datasetType.dimensions.encode(),
"storage_class": datasetType.storageClass.name,
},
returning=["id"],
)
assert row is not None
dynamic = self._db.ensureTableExists(
makeDynamicTableName(datasetType),
makeDynamicTableSpec(datasetType, type(self._collections)),
)
storage = ByDimensionsDatasetRecordStorage(db=self._db, datasetType=datasetType,
static=self._static, dynamic=dynamic,
dataset_type_id=row["id"],
collections=self._collections)
self._byName[datasetType.name] = storage
self._byId[storage._dataset_type_id] = storage
else:
if datasetType != storage.datasetType:
raise ConflictingDefinitionError(f"Given dataset type {datasetType} is inconsistent "
f"with database definition {storage.datasetType}.")
inserted = False
return storage, inserted
def register(self, datasetType: DatasetType) -> Tuple[DatasetRecordStorage, bool]:
# Docstring inherited from DatasetRecordStorageManager.
if datasetType.isComponent():
raise ValueError("Component dataset types can not be stored in registry."
f" Rejecting {datasetType.name}")
storage = self._byName.get(datasetType.name)
if storage is None:
dimensionsKey = self._dimensions.saveDimensionGraph(datasetType.dimensions)
tagTableName = makeTagTableName(datasetType, dimensionsKey)
calibTableName = (makeCalibTableName(datasetType, dimensionsKey)
if datasetType.isCalibration() else None)
row, inserted = self._db.sync(
self._static.dataset_type,
keys={"name": datasetType.name},
compared={
"dimensions_key": dimensionsKey,
"storage_class": datasetType.storageClass.name,
},
extra={
"tag_association_table": tagTableName,
"calibration_association_table": calibTableName,
},
returning=["id", "tag_association_table"],
)
assert row is not None
tags = self._db.ensureTableExists(
tagTableName,
makeTagTableSpec(datasetType, type(self._collections)),
)
if calibTableName is not None:
calibs = self._db.ensureTableExists(
calibTableName,
makeCalibTableSpec(datasetType, type(self._collections),
self._db.getTimespanRepresentation()),
)
else:
calibs = None
storage = ByDimensionsDatasetRecordStorage(db=self._db, datasetType=datasetType,
static=self._static, summaries=self._summaries,
tags=tags, calibs=calibs,
dataset_type_id=row["id"],
collections=self._collections)
self._byName[datasetType.name] = storage
self._byId[storage._dataset_type_id] = storage
else:
if datasetType != storage.datasetType:
raise ConflictingDefinitionError(f"Given dataset type {datasetType} is inconsistent "
f"with database definition {storage.datasetType}.")
inserted = False
return storage, inserted
