lsst-felis 29.2025.2700__tar.gz → 29.2025.2900__tar.gz

{lsst_felis-29.2025.2700/python/lsst_felis.egg-info → lsst_felis-29.2025.2900}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lsst-felis
-Version: 29.2025.2700
+Version: 29.2025.2900
 Summary: A vocabulary for describing catalogs and acting on those descriptions
 Author-email: Rubin Observatory Data Management <dm-admin@lists.lsst.org>
 License: GNU General Public License v3 or later (GPLv3+)

{lsst_felis-29.2025.2700 → lsst_felis-29.2025.2900}/python/felis/datamodel.py

@@ -618,7 +618,9 @@ class ForeignKeyConstraint(Constraint):
     """Table foreign key constraint model.
 
     This constraint is used to define a foreign key relationship between two
-    tables in the schema.
+    tables in the schema. There must be at least one column in the
+    `columns` list, and at least one column in the `referenced_columns` list
+    or a validation error will be raised.
 
     Notes
     -----
@@ -629,10 +631,10 @@ class ForeignKeyConstraint(Constraint):
     type: Literal["ForeignKey"] = Field("ForeignKey", alias="@type")
     """Type of the constraint."""
 
-    columns: list[str]
+    columns: list[str] = Field(min_length=1)
     """The columns comprising the foreign key."""
 
-    referenced_columns: list[str] = Field(alias="referencedColumns")
+    referenced_columns: list[str] = Field(alias="referencedColumns", min_length=1)
     """The columns referenced by the foreign key."""
 
     on_delete: Literal["CASCADE", "SET NULL", "SET DEFAULT", "RESTRICT", "NO ACTION"] | None = None
@@ -657,6 +659,28 @@ class ForeignKeyConstraint(Constraint):
         """
         return value
 
+    @model_validator(mode="after")
+    def check_column_lengths(self) -> ForeignKeyConstraint:
+        """Check that the `columns` and `referenced_columns` lists have the
+        same length.
+
+        Returns
+        -------
+        `ForeignKeyConstraint`
+            The foreign key constraint being validated.
+
+        Raises
+        ------
+        ValueError
+            Raised if the `columns` and `referenced_columns` lists do not have
+            the same length.
+        """
+        if len(self.columns) != len(self.referenced_columns):
+            raise ValueError(
+                "Columns and referencedColumns must have the same length for a ForeignKey constraint"
+            )
+        return self
+
 
 _ConstraintType = Annotated[
     CheckConstraint | ForeignKeyConstraint | UniqueConstraint, Field(discriminator="type")

{lsst_felis-29.2025.2700 → lsst_felis-29.2025.2900}/python/felis/tap_schema.py

@@ -470,7 +470,7 @@ class DataLoader:
             logger.info("Dry run - not loading data into database")
 
     def _insert_schemas(self) -> None:
-        """Insert the schema data into the schemas table."""
+        """Insert the schema data into the ``schemas`` table."""
         schema_record = {
             "schema_name": self.schema.name,
             "utype": self.schema.votable_utype,
@@ -495,7 +495,7 @@ class DataLoader:
         return f"{self.schema.name}.{table.name}"
 
     def _insert_tables(self) -> None:
-        """Insert the table data into the tables table."""
+        """Insert the table data into the ``tables`` table."""
         for table in self.schema.tables:
             table_record = {
                 "schema_name": self.schema.name,
@@ -508,7 +508,7 @@ class DataLoader:
             self._insert("tables", table_record)
 
     def _insert_columns(self) -> None:
-        """Insert the column data into the columns table."""
+        """Insert the column data into the ``columns`` table."""
         for table in self.schema.tables:
             for column in table.columns:
                 felis_type = FelisType.felis_type(column.datatype.value)
@@ -563,11 +563,15 @@ class DataLoader:
         return key_id
 
     def _insert_keys(self) -> None:
-        """Insert the foreign keys into the keys and key_columns tables."""
+        """Insert the foreign keys into the ``keys`` and ``key_columns``
+        tables.
+        """
         for table in self.schema.tables:
             for constraint in table.constraints:
                 if isinstance(constraint, datamodel.ForeignKeyConstraint):
+                    ###########################################################
                     # Handle keys table
+                    ###########################################################
                     referenced_column = self.schema.find_object_by_id(
                         constraint.referenced_columns[0], datamodel.Column
                     )
@@ -582,17 +586,23 @@ class DataLoader:
                     }
                     self._insert("keys", key_record)
 
+                    ###########################################################
                     # Handle key_columns table
-                    from_column = self.schema.find_object_by_id(constraint.columns[0], datamodel.Column)
-                    target_column = self.schema.find_object_by_id(
-                        constraint.referenced_columns[0], datamodel.Column
-                    )
-                    key_columns_record = {
-                        "key_id": key_id,
-                        "from_column": from_column.name,
-                        "target_column": target_column.name,
-                    }
-                    self._insert("key_columns", key_columns_record)
+                    ###########################################################
+                    # Loop over the corresponding columns and referenced
+                    # columns and insert a record for each pair. This is
+                    # necessary for proper handling of composite keys.
+                    for from_column_id, target_column_id in zip(
+                        constraint.columns, constraint.referenced_columns
+                    ):
+                        from_column = self.schema.find_object_by_id(from_column_id, datamodel.Column)
+                        target_column = self.schema.find_object_by_id(target_column_id, datamodel.Column)
+                        key_columns_record = {
+                            "key_id": key_id,
+                            "from_column": from_column.name,
+                            "target_column": target_column.name,
+                        }
+                        self._insert("key_columns", key_columns_record)
 
     def _generate_all_inserts(self) -> None:
         """Generate the inserts for all the data."""

{lsst_felis-29.2025.2700 → lsst_felis-29.2025.2900/python/lsst_felis.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lsst-felis
-Version: 29.2025.2700
+Version: 29.2025.2900
 Summary: A vocabulary for describing catalogs and acting on those descriptions
 Author-email: Rubin Observatory Data Management <dm-admin@lists.lsst.org>
 License: GNU General Public License v3 or later (GPLv3+)

{lsst_felis-29.2025.2700 → lsst_felis-29.2025.2900}/tests/test_datamodel.py

@@ -422,6 +422,31 @@ class ConstraintTestCase(unittest.TestCase):
             constraint.referenced_columns, ["test_column"], "referenced_columns should be ['test_column']"
         )
 
+        # Creating a foreign key constraint with no columns should raise an
+        # exception.
+        with self.assertRaises(ValidationError):
+            ForeignKeyConstraint(
+                name="fk_test", id="#fk_test", columns=[], referenced_columns=["test_column"]
+            )
+
+        # Creating a foreign key constraint with no referenced columns should
+        # raise an exception.
+        with self.assertRaises(ValidationError):
+            ForeignKeyConstraint(
+                name="fk_test", id="#fk_test", columns=["test_column"], referenced_columns=[]
+            )
+
+        # Creating a foreign key constraint where the number of foreign key
+        # columns does not match the number of referenced columns should raise
+        # an exception.
+        with self.assertRaises(ValidationError):
+            ForeignKeyConstraint(
+                name="fk_test",
+                id="#fk_test",
+                columns=["test_column", "test_column2"],
+                referenced_columns=["test_column"],
+            )
+
     def test_check_constraint(self) -> None:
         """Test validation of check constraints."""
         # Setting name and id should throw an exception from missing

{lsst_felis-29.2025.2700 → lsst_felis-29.2025.2900}/tests/test_tap_schema.py

@@ -33,6 +33,7 @@ from felis.tap_schema import DataLoader, TableManager
 TEST_DIR = os.path.dirname(__file__)
 TEST_SALES = os.path.join(TEST_DIR, "data", "sales.yaml")
 TEST_TAP_SCHEMA = os.path.join(TEST_DIR, "data", "test_tap_schema.yaml")
+TEST_COMPOSITE_KEYS = os.path.join(TEST_DIR, "data", "test_composite_keys.yaml")
 
 
 class TableManagerTestCase(unittest.TestCase):
@@ -158,12 +159,15 @@ class TapSchemaSqliteSetup:
 
     Parameters
     ----------
-    context : `dict`
+    test_file_path:
+        Path to the TAP_SCHEMA test file.
+
+    context
         Context for the schema. Default is an empty dictionary.
     """
 
-    def __init__(self, context: dict = {}) -> None:
-        with open(TEST_TAP_SCHEMA) as test_file:
+    def __init__(self, test_file_path: str, context: dict = {}) -> None:
+        with open(test_file_path) as test_file:
             self._schema = Schema.from_stream(test_file, context=context)
 
         self._engine = create_engine("sqlite:///:memory:")
@@ -196,7 +200,7 @@ class TapSchemaDataTest(unittest.TestCase):
 
     def setUp(self) -> None:
         """Set up the test case."""
-        self.tap_schema_setup = TapSchemaSqliteSetup(context={"id_generation": True})
+        self.tap_schema_setup = TapSchemaSqliteSetup(TEST_TAP_SCHEMA, context={"id_generation": True})
 
     def test_schemas(self) -> None:
         schemas_table = self.tap_schema_setup.mgr["schemas"]
@@ -347,7 +351,7 @@ class ForceUnboundArraySizeTest(unittest.TestCase):
     def setUp(self) -> None:
         """Set up the test case."""
         self.tap_schema_setup = TapSchemaSqliteSetup(
-            context={"id_generation": True, "force_unbounded_arraysize": True}
+            TEST_TAP_SCHEMA, context={"id_generation": True, "force_unbounded_arraysize": True}
         )
 
     def test_force_unbounded_arraysize(self) -> None:
@@ -365,5 +369,60 @@ class ForceUnboundArraySizeTest(unittest.TestCase):
                 self.assertEqual(row["arraysize"], "*")
 
 
+class CompositeKeysTestCase(unittest.TestCase):
+    """Test the handling of composite foreign keys."""
+
+    def setUp(self) -> None:
+        """Set up the test case."""
+        self.tap_schema_setup = TapSchemaSqliteSetup(TEST_COMPOSITE_KEYS, context={"id_generation": True})
+
+        # Fetch the keys and key_columns data from the TAP_SCHEMA tables.
+        keys_table = self.tap_schema_setup.mgr["keys"]
+        key_columns_table = self.tap_schema_setup.mgr["key_columns"]
+        with self.tap_schema_setup.engine.connect() as connection:
+            key_columns_result = connection.execute(select(key_columns_table))
+            self.key_columns_data = [row._asdict() for row in key_columns_result]
+
+            keys_result = connection.execute(select(keys_table))
+            self.keys_data = [row._asdict() for row in keys_result]
+
+    def test_keys(self) -> None:
+        """Test that composite keys are handled correctly by inspecting the
+        data in the generated TAP_SCHEMA ``keys`` table.
+        """
+        print(f"\nComposite keys data: {self.keys_data}")
+
+        self.assertEqual(len(self.keys_data), 1)
+
+        self.assertEqual(
+            self.keys_data[0],
+            {
+                "key_id": "fk_composite",
+                "from_table": "test_composite_keys.table1",
+                "target_table": "test_composite_keys.table2",
+                "utype": "ForeignKey",
+                "description": "Composite foreign key from table1 to table2",
+            },
+        )
+
+    def test_key_columns(self) -> None:
+        """Test that composite keys are handled correctly by inspecting the
+        data in the generated TAP_SCHEMA ``key_columns`` table.
+        """
+        print(f"\nComposite key columns data: {self.key_columns_data}")
+
+        self.assertEqual(len(self.key_columns_data), 2)
+
+        key_columns_row1 = self.key_columns_data[0]
+        self.assertEqual(
+            key_columns_row1, {"key_id": "fk_composite", "from_column": "id1", "target_column": "id1"}
+        )
+
+        key_columns_row2 = self.key_columns_data[1]
+        self.assertEqual(
+            key_columns_row2, {"key_id": "fk_composite", "from_column": "id2", "target_column": "id2"}
+        )
+
+
 if __name__ == "__main__":
     unittest.main()