lsst-felis 28.2025.402__py3-none-any.whl → 28.2025.600__py3-none-any.whl

felis/cli.py

@@ -38,7 +38,6 @@ from .db.schema import create_database
 from .db.utils import DatabaseContext, is_mock_url
 from .diff import DatabaseDiff, FormattedSchemaDiff, SchemaDiff
 from .metadata import MetaDataBuilder
-from .tap import Tap11Base, TapLoadingVisitor, init_tables
 from .tap_schema import DataLoader, TableManager
 
 __all__ = ["cli"]
@@ -179,174 +178,9 @@ def create(
         raise click.ClickException(str(e))
 
 
-@cli.command("init-tap", help="Initialize TAP_SCHEMA objects in the database")
-@click.option("--tap-schema-name", help="Alternate database schema name for 'TAP_SCHEMA'")
-@click.option("--tap-schemas-table", help="Alternate table name for 'schemas'")
-@click.option("--tap-tables-table", help="Alternate table name for 'tables'")
-@click.option("--tap-columns-table", help="Alternate table name for 'columns'")
-@click.option("--tap-keys-table", help="Alternate table name for 'keys'")
-@click.option("--tap-key-columns-table", help="Alternate table name for 'key_columns'")
-@click.argument("engine-url")
-def init_tap(
-    engine_url: str,
-    tap_schema_name: str,
-    tap_schemas_table: str,
-    tap_tables_table: str,
-    tap_columns_table: str,
-    tap_keys_table: str,
-    tap_key_columns_table: str,
-) -> None:
-    """Initialize TAP_SCHEMA objects in the database.
-
-    Parameters
-    ----------
-    engine_url
-        SQLAlchemy Engine URL. The target PostgreSQL schema or MySQL database
-        must already exist and be referenced in the URL.
-    tap_schema_name
-        Alterate name for the database schema ``TAP_SCHEMA``.
-    tap_schemas_table
-        Alterate table name for ``schemas``.
-    tap_tables_table
-        Alterate table name for ``tables``.
-    tap_columns_table
-        Alterate table name for ``columns``.
-    tap_keys_table
-        Alterate table name for ``keys``.
-    tap_key_columns_table
-        Alterate table name for ``key_columns``.
-
-    Notes
-    -----
-    The supported version of TAP_SCHEMA in the SQLAlchemy metadata is 1.1. The
-    tables are created in the database schema specified by the engine URL,
-    which must be a PostgreSQL schema or MySQL database that already exists.
-    """
-    engine = create_engine(engine_url)
-    init_tables(
-        tap_schema_name,
-        tap_schemas_table,
-        tap_tables_table,
-        tap_columns_table,
-        tap_keys_table,
-        tap_key_columns_table,
-    )
-    Tap11Base.metadata.create_all(engine)
-
-
-@cli.command("load-tap", help="Load metadata from a Felis file into a TAP_SCHEMA database")
-@click.option("--engine-url", envvar="FELIS_ENGINE_URL", help="SQLAlchemy Engine URL")
-@click.option("--schema-name", help="Alternate Schema Name for Felis file")
-@click.option("--catalog-name", help="Catalog Name for Schema")
-@click.option("--dry-run", is_flag=True, help="Dry Run Only. Prints out the DDL that would be executed")
-@click.option("--tap-schema-name", help="Alternate schema name for 'TAP_SCHEMA'")
-@click.option("--tap-tables-postfix", help="Postfix for TAP_SCHEMA table names")
-@click.option("--tap-schemas-table", help="Alternate table name for 'schemas'")
-@click.option("--tap-tables-table", help="Alternate table name for 'tables'")
-@click.option("--tap-columns-table", help="Alternate table name for 'columns'")
-@click.option("--tap-keys-table", help="Alternate table name for 'keys'")
-@click.option("--tap-key-columns-table", help="Alternate table name for 'key_columns'")
-@click.option("--tap-schema-index", type=int, help="TAP_SCHEMA index of the schema in this environment")
-@click.argument("file", type=click.File())
-def load_tap(
-    engine_url: str,
-    schema_name: str,
-    catalog_name: str,
-    dry_run: bool,
-    tap_schema_name: str,
-    tap_tables_postfix: str,
-    tap_schemas_table: str,
-    tap_tables_table: str,
-    tap_columns_table: str,
-    tap_keys_table: str,
-    tap_key_columns_table: str,
-    tap_schema_index: int,
-    file: IO[str],
-) -> None:
-    """Load TAP metadata from a Felis file.
-
-    This command loads the associated TAP metadata from a Felis YAML file
-    into the TAP_SCHEMA tables.
-
-    Parameters
-    ----------
-    engine_url
-        SQLAlchemy Engine URL to catalog.
-    schema_name
-        Alternate schema name. This overrides the schema name in the
-        ``catalog`` field of the Felis file.
-    catalog_name
-        Catalog name for the schema. This possibly duplicates the
-        ``tap_schema_name`` argument (DM-44870).
-    dry_run
-        Dry run only to print out commands instead of executing.
-    tap_schema_name
-        Alternate name for the schema of TAP_SCHEMA in the database.
-    tap_tables_postfix
-        Postfix for TAP table names that will be automatically appended.
-    tap_schemas_table
-        Alternate table name for ``schemas``.
-    tap_tables_table
-        Alternate table name for ``tables``.
-    tap_columns_table
-        Alternate table name for ``columns``.
-    tap_keys_table
-        Alternate table name for ``keys``.
-    tap_key_columns_table
-        Alternate table name for ``key_columns``.
-    tap_schema_index
-        TAP_SCHEMA index of the schema in this TAP environment.
-    file
-        Felis file to read.
-
-    Notes
-    -----
-    The data will be loaded into the TAP_SCHEMA from the engine URL. The
-    tables must have already been initialized or an error will occur.
-    """
-    schema = Schema.from_stream(file)
-
-    tap_tables = init_tables(
-        tap_schema_name,
-        tap_tables_postfix,
-        tap_schemas_table,
-        tap_tables_table,
-        tap_columns_table,
-        tap_keys_table,
-        tap_key_columns_table,
-    )
-
-    if not dry_run:
-        engine = create_engine(engine_url)
-
-        if engine_url == "sqlite://" and not dry_run:
-            # In Memory SQLite - Mostly used to test
-            Tap11Base.metadata.create_all(engine)
-
-        tap_visitor = TapLoadingVisitor(
-            engine,
-            catalog_name=catalog_name,
-            schema_name=schema_name,
-            tap_tables=tap_tables,
-            tap_schema_index=tap_schema_index,
-        )
-        tap_visitor.visit_schema(schema)
-    else:
-        conn = DatabaseContext.create_mock_engine(engine_url)
-
-        tap_visitor = TapLoadingVisitor.from_mock_connection(
-            conn,
-            catalog_name=catalog_name,
-            schema_name=schema_name,
-            tap_tables=tap_tables,
-            tap_schema_index=tap_schema_index,
-        )
-        tap_visitor.visit_schema(schema)
-
-
 @cli.command("load-tap-schema", help="Load metadata from a Felis file into a TAP_SCHEMA database")
 @click.option("--engine-url", envvar="FELIS_ENGINE_URL", help="SQLAlchemy Engine URL")
-@click.option("--tap-schema-name", help="Name of the TAP_SCHEMA schema in the database")
+@click.option("--tap-schema-name", help="Name of the TAP_SCHEMA schema in the database (default: TAP_SCHEMA)")
 @click.option(
     "--tap-tables-postfix", help="Postfix which is applied to standard TAP_SCHEMA table names", default=""
 )
@@ -417,6 +251,40 @@ def load_tap_schema(
     ).load()
 
 
+@cli.command("init-tap-schema", help="Initialize a standard TAP_SCHEMA database")
+@click.option("--engine-url", envvar="FELIS_ENGINE_URL", help="SQLAlchemy Engine URL")
+@click.option("--tap-schema-name", help="Name of the TAP_SCHEMA schema in the database")
+@click.option(
+    "--tap-tables-postfix", help="Postfix which is applied to standard TAP_SCHEMA table names", default=""
+)
+@click.pass_context
+def init_tap_schema(
+    ctx: click.Context, engine_url: str, tap_schema_name: str, tap_tables_postfix: str
+) -> None:
+    """Initialize a standard TAP_SCHEMA database.
+
+    Parameters
+    ----------
+    engine_url
+        SQLAlchemy Engine URL.
+    tap_schema_name
+        Name of the TAP_SCHEMA schema in the database.
+    tap_tables_postfix
+        Postfix which is applied to standard TAP_SCHEMA table names.
+    """
+    url = make_url(engine_url)
+    engine: Engine | MockConnection
+    if is_mock_url(url):
+        raise click.ClickException("Mock engine URL is not supported for this command")
+    engine = create_engine(engine_url)
+    mgr = TableManager(
+        apply_schema_to_metadata=False if engine.dialect.name == "sqlite" else True,
+        schema_name=tap_schema_name,
+        table_name_postfix=tap_tables_postfix,
+    )
+    mgr.initialize_database(engine)
+
+
 @cli.command("validate", help="Validate one or more Felis YAML files")
 @click.option(
     "--check-description", is_flag=True, help="Check that all objects have a description", default=False

felis/datamodel.py

@@ -134,6 +134,32 @@ class DataType(StrEnum):
     timestamp = auto()
 
 
+def validate_ivoa_ucd(ivoa_ucd: str) -> str:
+    """Validate IVOA UCD values.
+
+    Parameters
+    ----------
+    ivoa_ucd
+        IVOA UCD value to check.
+
+    Returns
+    -------
+    `str`
+        The IVOA UCD value if it is valid.
+
+    Raises
+    ------
+    ValueError
+        If the IVOA UCD value is invalid.
+    """
+    if ivoa_ucd is not None:
+        try:
+            ucd.parse_ucd(ivoa_ucd, check_controlled_vocabulary=True, has_colon=";" in ivoa_ucd)
+        except ValueError as e:
+            raise ValueError(f"Invalid IVOA UCD: {e}")
+    return ivoa_ucd
+
+
 class Column(BaseObject):
     """Column model."""
 
@@ -235,12 +261,7 @@ class Column(BaseObject):
         `str`
             The IVOA UCD value if it is valid.
         """
-        if ivoa_ucd is not None:
-            try:
-                ucd.parse_ucd(ivoa_ucd, check_controlled_vocabulary=True, has_colon=";" in ivoa_ucd)
-            except ValueError as e:
-                raise ValueError(f"Invalid IVOA UCD: {e}")
-        return ivoa_ucd
+        return validate_ivoa_ucd(ivoa_ucd)
 
     @model_validator(mode="after")
     def check_units(self) -> Column:
@@ -551,6 +572,70 @@ _ConstraintType = Annotated[
 """Type alias for a constraint type."""
 
 
+ColumnRef: TypeAlias = str
+"""Type alias for a column reference."""
+
+
+class ColumnGroup(BaseObject):
+    """Column group model."""
+
+    columns: list[ColumnRef | Column] = Field(..., min_length=1)
+    """Columns in the group."""
+
+    ivoa_ucd: str | None = Field(None, alias="ivoa:ucd")
+    """IVOA UCD of the column."""
+
+    table: Table | None = None
+    """Reference to the parent table."""
+
+    @field_validator("ivoa_ucd")
+    @classmethod
+    def check_ivoa_ucd(cls, ivoa_ucd: str) -> str:
+        """Check that IVOA UCD values are valid.
+
+        Parameters
+        ----------
+        ivoa_ucd
+            IVOA UCD value to check.
+
+        Returns
+        -------
+        `str`
+            The IVOA UCD value if it is valid.
+        """
+        return validate_ivoa_ucd(ivoa_ucd)
+
+    @model_validator(mode="after")
+    def check_unique_columns(self) -> ColumnGroup:
+        """Check that the columns list contains unique items.
+
+        Returns
+        -------
+        `ColumnGroup`
+            The column group being validated.
+        """
+        column_ids = [col if isinstance(col, str) else col.id for col in self.columns]
+        if len(column_ids) != len(set(column_ids)):
+            raise ValueError("Columns in the group must be unique")
+        return self
+
+    def _dereference_columns(self) -> None:
+        """Dereference ColumnRef to Column objects."""
+        if self.table is None:
+            raise ValueError("ColumnGroup must have a reference to its parent table")
+
+        dereferenced_columns: list[ColumnRef | Column] = []
+        for col in self.columns:
+            if isinstance(col, str):
+                # Dereference ColumnRef to Column object
+                col_obj = self.table._find_column_by_id(col)
+                dereferenced_columns.append(col_obj)
+            else:
+                dereferenced_columns.append(col)
+
+        self.columns = dereferenced_columns
+
+
 class Table(BaseObject):
     """Table model."""
 
@@ -563,6 +648,9 @@ class Table(BaseObject):
     indexes: list[Index] = Field(default_factory=list)
     """Indexes on the table."""
 
+    column_groups: list[ColumnGroup] = Field(default_factory=list, alias="columnGroups")
+    """Column groups in the table."""
+
     primary_key: str | list[str] | None = Field(None, alias="primaryKey")
     """Primary key of the table."""
 
@@ -653,6 +741,43 @@ class Table(BaseObject):
                 return self
         raise ValueError(f"Table '{self.name}' is missing at least one column designated as 'tap:principal'")
 
+    def _find_column_by_id(self, id: str) -> Column:
+        """Find a column by ID.
+
+        Parameters
+        ----------
+        id
+            The ID of the column to find.
+
+        Returns
+        -------
+        `Column`
+            The column with the given ID.
+
+        Raises
+        ------
+        ValueError
+            Raised if the column is not found.
+        """
+        for column in self.columns:
+            if column.id == id:
+                return column
+        raise ValueError(f"Column '{id}' not found in table '{self.name}'")
+
+    @model_validator(mode="after")
+    def dereference_column_groups(self: Table) -> Table:
+        """Dereference columns in column groups.
+
+        Returns
+        -------
+        `Table`
+            The table with dereferenced column groups.
+        """
+        for group in self.column_groups:
+            group.table = self
+            group._dereference_columns()
+        return self
+
 
 class SchemaVersion(BaseModel):
     """Schema version model."""

felis/metadata.py

@@ -127,6 +127,8 @@ class MetaDataBuilder:
         Whether to apply the schema name to the metadata object.
     ignore_constraints
         Whether to ignore constraints when building the metadata.
+    table_name_postfix
+        A string to append to the table names when building the metadata.
     """
 
     def __init__(
@@ -134,6 +136,7 @@ class MetaDataBuilder:
         schema: Schema,
         apply_schema_to_metadata: bool = True,
         ignore_constraints: bool = False,
+        table_name_postfix: str = "",
     ) -> None:
         """Initialize the metadata builder."""
         self.schema = schema
@@ -142,6 +145,7 @@ class MetaDataBuilder:
         self.metadata = MetaData(schema=schema.name if apply_schema_to_metadata else None)
         self._objects: dict[str, Any] = {}
         self.ignore_constraints = ignore_constraints
+        self.table_name_postfix = table_name_postfix
 
     def build(self) -> MetaData:
         """Build the SQLAlchemy tables and constraints from the schema.
@@ -225,7 +229,7 @@ class MetaDataBuilder:
         description = table_obj.description
         columns = [self.build_column(column) for column in table_obj.columns]
         table = Table(
-            name,
+            name + self.table_name_postfix,
             self.metadata,
             *columns,
             comment=description,

felis/tap_schema.py

@@ -91,9 +91,15 @@ class TableManager:
         self.table_name_postfix = table_name_postfix
         self.apply_schema_to_metadata = apply_schema_to_metadata
         self.schema_name = schema_name or TableManager._SCHEMA_NAME_STD
+        self.table_name_postfix = table_name_postfix
 
         if is_valid_engine(engine):
             assert isinstance(engine, Engine)
+            if table_name_postfix != "":
+                logger.warning(
+                    "Table name postfix '%s' will be ignored when reflecting TAP_SCHEMA database",
+                    table_name_postfix,
+                )
             logger.debug(
                 "Reflecting TAP_SCHEMA database from existing database at %s",
                 engine.url._replace(password="***"),
@@ -131,7 +137,9 @@ class TableManager:
             self.schema_name = self.schema.name
 
         self._metadata = MetaDataBuilder(
-            self.schema, apply_schema_to_metadata=self.apply_schema_to_metadata
+            self.schema,
+            apply_schema_to_metadata=self.apply_schema_to_metadata,
+            table_name_postfix=self.table_name_postfix,
         ).build()
 
         logger.debug("Loaded TAP_SCHEMA '%s' from YAML resource", self.schema_name)
@@ -353,7 +361,7 @@ class TableManager:
         engine
             The SQLAlchemy engine to use to create the tables.
         """
-        logger.info("Creating TAP_SCHEMA database '%s'", self.metadata.schema)
+        logger.info("Creating TAP_SCHEMA database '%s'", self.schema_name)
         self._create_schema(engine)
         self.metadata.create_all(engine)
 
@@ -424,7 +432,7 @@ class DataLoader:
             # Execute the inserts if not in dry run mode.
             self._execute_inserts()
         else:
-            logger.info("Dry run: not loading data into database")
+            logger.info("Dry run - not loading data into database")
 
     def _insert_schemas(self) -> None:
         """Insert the schema data into the schemas table."""
@@ -565,7 +573,7 @@ class DataLoader:
     def _print_sql(self) -> None:
         """Print the generated inserts to stdout."""
         for insert_str in self._compiled_inserts():
-            print(insert_str)
+            print(insert_str + ";")
 
     def _write_sql_to_file(self) -> None:
         """Write the generated insert statements to a file."""
@@ -573,7 +581,7 @@ class DataLoader:
             raise ValueError("No output path specified")
         with open(self.output_path, "w") as outfile:
             for insert_str in self._compiled_inserts():
-                outfile.write(insert_str + "\n")
+                outfile.write(insert_str + ";" + "\n")
 
     def _insert(self, table_name: str, record: list[Any] | dict[str, Any]) -> None:
         """Generate an insert statement for a record.

felis/version.py

@@ -1,2 +1,2 @@
 __all__ = ["__version__"]
-__version__ = "28.2025.402"
+__version__ = "28.2025.600"

{lsst_felis-28.2025.402.dist-info → lsst_felis-28.2025.600.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: lsst-felis
-Version: 28.2025.402
+Version: 28.2025.600
 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-28.2025.402.dist-info → lsst_felis-28.2025.600.dist-info}/RECORD

@@ -1,13 +1,12 @@
 felis/__init__.py,sha256=r1KFSnc55gziwUuYb9s2EfwrI_85aa3LpaKwk6rUvvs,1108
-felis/cli.py,sha256=uvrPZ7L6Jm3B69Kbejkv1qyDffIh6dxvj50sosJrg14,19220
-felis/datamodel.py,sha256=3iZiNlCrOjJj87cCdTdRraUyx5o-Iwzh46aQ-dIwVDQ,35942
+felis/cli.py,sha256=Wf-sEUZ-B9zzn4M1huY2ruV1nkgVmpzX8f8iuFfyxZc,14469
+felis/datamodel.py,sha256=NczAA4HBBC4-uxPNsrKAFX-hdlgvCT2qqEJCEqDy4yg,39265
 felis/diff.py,sha256=0N4OcBCzbL9DW_XGAeuvGsQ0zIhq8fY-Kx2QdvLv-Ds,7492
-felis/metadata.py,sha256=6Ct-tKIZB26bwBF3juxjpCmKzASkMr6uzhoEKQYcGAo,13322
+felis/metadata.py,sha256=cYx_qizkLBqcoxWV46h4TbwTi1KVJAkuA2OuUmD-K5k,13536
 felis/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-felis/tap.py,sha256=76o8-ijmwgSE8UxMVn9KTlKrCPjG72LWyyAXO8yeqFE,21564
-felis/tap_schema.py,sha256=MvRZdNYl9ObJCsfiWyAp-3EpTdVeKCKimYba-pSZNos,22392
+felis/tap_schema.py,sha256=DgHH4hBf4q_F540TAR9GTKcALwUkk8iTw5pzQlmv1DA,22753
 felis/types.py,sha256=m80GSGfNHQ3-NzRuTzKOyRXLJboPxdk9kzpp1SO8XdY,5510
-felis/version.py,sha256=cQxdqMuS0r6APcE0FvPz5UloooZHknxy-vbWA0xA_Oo,54
+felis/version.py,sha256=d9ENfpCeS2I77L3quCjEA1SqEJuEwmWi9q2wJwk_Xhw,54
 felis/db/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 felis/db/dialects.py,sha256=n5La-shu-8fHLIyf8rrazHDyrzATmMCdELtKV_0ymxI,3517
 felis/db/schema.py,sha256=NOFXzBoBQcgpoRlgT3LoC70FKp7pCSmFEJ7rU8FIT-c,2101
@@ -17,11 +16,11 @@ felis/db/variants.py,sha256=eahthrbVeV8ZdGamWQccNmWgx6CCscGrU0vQRs5HZK8,5260
 felis/schemas/tap_schema_std.yaml,sha256=sPW-Vk72nY0PFpCvP5d8L8fWvhkif-x32sGtcfDZ8bU,7131
 felis/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 felis/tests/postgresql.py,sha256=B_xk4fLual5-viGDqP20r94okuc0pbSvytRH_L0fvMs,4035
-lsst_felis-28.2025.402.dist-info/COPYRIGHT,sha256=vJAFLFTSF1mhy9eIuA3P6R-3yxTWKQgpig88P-1IzRw,129
-lsst_felis-28.2025.402.dist-info/LICENSE,sha256=jOtLnuWt7d5Hsx6XXB2QxzrSe2sWWh3NgMfFRetluQM,35147
-lsst_felis-28.2025.402.dist-info/METADATA,sha256=phxmqyk2-mYCObW5WreJMx6Xaq_GfQUnZamdgtDzqo0,1410
-lsst_felis-28.2025.402.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-lsst_felis-28.2025.402.dist-info/entry_points.txt,sha256=Gk2XFujA_Gp52VBk45g5kim8TDoMDJFPctsMqiq72EM,40
-lsst_felis-28.2025.402.dist-info/top_level.txt,sha256=F4SvPip3iZRVyISi50CHhwTIAokAhSxjWiVcn4IVWRI,6
-lsst_felis-28.2025.402.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-lsst_felis-28.2025.402.dist-info/RECORD,,
+lsst_felis-28.2025.600.dist-info/COPYRIGHT,sha256=vJAFLFTSF1mhy9eIuA3P6R-3yxTWKQgpig88P-1IzRw,129
+lsst_felis-28.2025.600.dist-info/LICENSE,sha256=jOtLnuWt7d5Hsx6XXB2QxzrSe2sWWh3NgMfFRetluQM,35147
+lsst_felis-28.2025.600.dist-info/METADATA,sha256=spGx-It8JoY8mgWkQLwxngz3gD2Jr1bJi_0T1NeMAjs,1410
+lsst_felis-28.2025.600.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+lsst_felis-28.2025.600.dist-info/entry_points.txt,sha256=Gk2XFujA_Gp52VBk45g5kim8TDoMDJFPctsMqiq72EM,40
+lsst_felis-28.2025.600.dist-info/top_level.txt,sha256=F4SvPip3iZRVyISi50CHhwTIAokAhSxjWiVcn4IVWRI,6
+lsst_felis-28.2025.600.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+lsst_felis-28.2025.600.dist-info/RECORD,,

felis/tap.py

@@ -1,597 +0,0 @@
-"""Translate a Felis schema into a TAP_SCHEMA representation."""
-
-# This file is part of felis.
-#
-# Developed for the LSST Data Management System.
-# This product includes software developed by the LSST Project
-# (https://www.lsst.org).
-# See the COPYRIGHT file at the top-level directory of this distribution
-# for details of code ownership.
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-from __future__ import annotations
-
-import logging
-import re
-from collections.abc import Iterable, MutableMapping
-from typing import Any
-
-from sqlalchemy import Column, Integer, String
-from sqlalchemy.engine import Engine
-from sqlalchemy.engine.mock import MockConnection
-from sqlalchemy.orm import Session, declarative_base, sessionmaker
-from sqlalchemy.schema import MetaData
-from sqlalchemy.sql.expression import Insert, insert
-
-from felis import datamodel
-
-from .datamodel import Constraint, ForeignKeyConstraint, Index, Schema, Table
-from .types import FelisType
-
-__all__ = ["TapLoadingVisitor", "init_tables"]
-
-logger = logging.getLogger(__name__)
-
-Tap11Base: Any = declarative_base()  # Any to avoid mypy mess with SA 2
-
-IDENTIFIER_LENGTH = 128
-SMALL_FIELD_LENGTH = 32
-SIMPLE_FIELD_LENGTH = 128
-TEXT_FIELD_LENGTH = 2048
-QUALIFIED_TABLE_LENGTH = 3 * IDENTIFIER_LENGTH + 2
-
-_init_table_once = False
-
-
-def init_tables(
-    tap_schema_name: str | None = None,
-    tap_tables_postfix: str | None = None,
-    tap_schemas_table: str | None = None,
-    tap_tables_table: str | None = None,
-    tap_columns_table: str | None = None,
-    tap_keys_table: str | None = None,
-    tap_key_columns_table: str | None = None,
-) -> MutableMapping[str, Any]:
-    """Generate definitions for TAP tables.
-
-    Parameters
-    ----------
-    tap_schema_name
-        Name of the TAP schema.
-    tap_tables_postfix
-        Postfix for table names.
-    tap_schemas_table
-        Name of the schemas table.
-    tap_tables_table
-        Name of the tables table.
-    tap_columns_table
-        Name of the columns table.
-    tap_keys_table
-        Name of the keys table.
-    tap_key_columns_table
-        Name of the key columns table.
-
-    Returns
-    -------
-    `dict` [ `str`, `Any`]
-        A dictionary of table definitions.
-    """
-    postfix = tap_tables_postfix or ""
-
-    # Dirty hack to enable this method to be called more than once, replaces
-    # MetaData instance with a fresh copy if called more than once.
-    # TODO: probably replace ORM stuff with core sqlalchemy functions.
-    global _init_table_once
-    if not _init_table_once:
-        _init_table_once = True
-    else:
-        Tap11Base.metadata = MetaData()
-
-    if tap_schema_name:
-        Tap11Base.metadata.schema = tap_schema_name
-
-    class Tap11Schemas(Tap11Base):
-        __tablename__ = (tap_schemas_table or "schemas") + postfix
-        schema_name = Column(String(IDENTIFIER_LENGTH), primary_key=True, nullable=False)
-        utype = Column(String(SIMPLE_FIELD_LENGTH))
-        description = Column(String(TEXT_FIELD_LENGTH))
-        schema_index = Column(Integer)
-
-    class Tap11Tables(Tap11Base):
-        __tablename__ = (tap_tables_table or "tables") + postfix
-        schema_name = Column(String(IDENTIFIER_LENGTH), nullable=False)
-        table_name = Column(String(QUALIFIED_TABLE_LENGTH), nullable=False, primary_key=True)
-        table_type = Column(String(SMALL_FIELD_LENGTH), nullable=False)
-        utype = Column(String(SIMPLE_FIELD_LENGTH))
-        description = Column(String(TEXT_FIELD_LENGTH))
-        table_index = Column(Integer)
-
-    class Tap11Columns(Tap11Base):
-        __tablename__ = (tap_columns_table or "columns") + postfix
-        table_name = Column(String(QUALIFIED_TABLE_LENGTH), nullable=False, primary_key=True)
-        column_name = Column(String(IDENTIFIER_LENGTH), nullable=False, primary_key=True)
-        datatype = Column(String(SIMPLE_FIELD_LENGTH), nullable=False)
-        arraysize = Column(String(10))
-        xtype = Column(String(SIMPLE_FIELD_LENGTH))
-        # Size is deprecated
-        size = Column("size", Integer(), quote=True)
-        description = Column(String(TEXT_FIELD_LENGTH))
-        utype = Column(String(SIMPLE_FIELD_LENGTH))
-        unit = Column(String(SIMPLE_FIELD_LENGTH))
-        ucd = Column(String(SIMPLE_FIELD_LENGTH))
-        indexed = Column(Integer, nullable=False)
-        principal = Column(Integer, nullable=False)
-        std = Column(Integer, nullable=False)
-        column_index = Column(Integer)
-
-    class Tap11Keys(Tap11Base):
-        __tablename__ = (tap_keys_table or "keys") + postfix
-        key_id = Column(String(IDENTIFIER_LENGTH), nullable=False, primary_key=True)
-        from_table = Column(String(QUALIFIED_TABLE_LENGTH), nullable=False)
-        target_table = Column(String(QUALIFIED_TABLE_LENGTH), nullable=False)
-        description = Column(String(TEXT_FIELD_LENGTH))
-        utype = Column(String(SIMPLE_FIELD_LENGTH))
-
-    class Tap11KeyColumns(Tap11Base):
-        __tablename__ = (tap_key_columns_table or "key_columns") + postfix
-        key_id = Column(String(IDENTIFIER_LENGTH), nullable=False, primary_key=True)
-        from_column = Column(String(IDENTIFIER_LENGTH), nullable=False, primary_key=True)
-        target_column = Column(String(IDENTIFIER_LENGTH), nullable=False, primary_key=True)
-
-    return dict(
-        schemas=Tap11Schemas,
-        tables=Tap11Tables,
-        columns=Tap11Columns,
-        keys=Tap11Keys,
-        key_columns=Tap11KeyColumns,
-    )
-
-
-class TapLoadingVisitor:
-    """Generate TAP_SCHEMA data and insert it into a database using the
-    SQLAlchemy ORM.
-
-    Parameters
-    ----------
-    engine
-        SQLAlchemy engine instance.
-    catalog_name
-        Name of the database catalog.
-    schema_name
-        Name of the schema.
-    tap_tables
-        Mapping of TAP_SCHEMA table name to its SQLAlchemy table object.
-    tap_schema_index
-        The index of the schema for this TAP environment.
-    """
-
-    def __init__(
-        self,
-        engine: Engine | None,
-        catalog_name: str | None = None,
-        schema_name: str | None = None,
-        tap_tables: MutableMapping[str, Any] | None = None,
-        tap_schema_index: int | None = None,
-    ) -> None:
-        """Create a TAP loading visitor."""
-        self.graph_index: MutableMapping[str, Any] = {}
-        self.catalog_name = catalog_name
-        self.schema_name = schema_name
-        self.engine = engine
-        self._mock_connection: MockConnection | None = None
-        self.tables = tap_tables or init_tables()
-        self.tap_schema_index = tap_schema_index
-
-    @classmethod
-    def from_mock_connection(
-        cls,
-        mock_connection: MockConnection,
-        catalog_name: str | None = None,
-        schema_name: str | None = None,
-        tap_tables: MutableMapping[str, Any] | None = None,
-        tap_schema_index: int | None = None,
-    ) -> TapLoadingVisitor:
-        """Create a TAP visitor from a mock connection.
-
-        Parameters
-        ----------
-        mock_connection
-            Mock connection object.
-        catalog_name
-            Name of the database catalog.
-        schema_name
-            Name of the database schema.
-        tap_tables
-            Optional mapping of table name to its SQLAlchemy table object.
-        tap_schema_index
-            The index of the schema for this TAP environment.
-
-        Returns
-        -------
-        `TapLoadingVisitor`
-            The TAP loading visitor.
-        """
-        visitor = cls(engine=None, catalog_name=catalog_name, schema_name=schema_name, tap_tables=tap_tables)
-        visitor._mock_connection = mock_connection
-        visitor.tap_schema_index = tap_schema_index
-        return visitor
-
-    def visit_schema(self, schema_obj: Schema) -> None:
-        """Visit a schema object and insert it into the TAP_SCHEMA database.
-
-        Parameters
-        ----------
-        schema_obj
-            The schema object to visit.
-        """
-        schema = self.tables["schemas"]()
-        # Override with default
-        self.schema_name = self.schema_name or schema_obj.name
-
-        schema.schema_name = self._schema_name()
-        schema.description = schema_obj.description
-        schema.utype = schema_obj.votable_utype
-        schema.schema_index = self.tap_schema_index
-        logger.debug(f"Set TAP_SCHEMA index: {self.tap_schema_index}")
-
-        if self.engine is not None:
-            session: Session = sessionmaker(self.engine)()
-
-            session.add(schema)
-
-            for table_obj in schema_obj.tables:
-                table, columns = self.visit_table(table_obj, schema_obj)
-                session.add(table)
-                session.add_all(columns)
-
-            keys, key_columns = self.visit_constraints(schema_obj)
-            session.add_all(keys)
-            session.add_all(key_columns)
-
-            logger.debug("Committing TAP schema: %s", schema_obj.name)
-            logger.debug("TAP tables: %s", len(self.tables))
-            session.commit()
-        else:
-            logger.info("Dry run, not inserting into database")
-
-            # Only if we are mocking (dry run)
-            assert self._mock_connection is not None, "Mock connection must not be None"
-            conn = self._mock_connection
-            conn.execute(_insert(self.tables["schemas"], schema))
-
-            for table_obj in schema_obj.tables:
-                table, columns = self.visit_table(table_obj, schema_obj)
-                conn.execute(_insert(self.tables["tables"], table))
-                for column in columns:
-                    conn.execute(_insert(self.tables["columns"], column))
-
-            keys, key_columns = self.visit_constraints(schema_obj)
-            for key in keys:
-                conn.execute(_insert(self.tables["keys"], key))
-            for key_column in key_columns:
-                conn.execute(_insert(self.tables["key_columns"], key_column))
-
-    def visit_constraints(self, schema_obj: Schema) -> tuple:
-        """Visit all constraints in a schema.
-
-        Parameters
-        ----------
-        schema_obj
-            The schema object to visit.
-
-        Returns
-        -------
-        `tuple`
-            A tuple of all TAP_SCHEMA keys and key columns that were created.
-        """
-        all_keys = []
-        all_key_columns = []
-        for table_obj in schema_obj.tables:
-            for c in table_obj.constraints:
-                key, key_columns = self.visit_constraint(c)
-                if not key:
-                    continue
-                all_keys.append(key)
-                all_key_columns += key_columns
-        return all_keys, all_key_columns
-
-    def visit_table(self, table_obj: Table, schema_obj: Schema) -> tuple:
-        """Visit a table object and build its TAP_SCHEMA representation.
-
-        Parameters
-        ----------
-        table_obj
-            The table object to visit.
-        schema_obj
-            The schema object which the table belongs to.
-
-        Returns
-        -------
-        `tuple`
-            A tuple of the SQLAlchemy ORM objects for the tables and columns.
-        """
-        table_id = table_obj.id
-        table = self.tables["tables"]()
-        table.schema_name = self._schema_name()
-        table.table_name = self._table_name(table_obj.name)
-        table.table_type = "table"
-        table.utype = table_obj.votable_utype
-        table.description = table_obj.description
-        table.table_index = 0 if table_obj.tap_table_index is None else table_obj.tap_table_index
-
-        columns = [self.visit_column(c, table_obj) for c in table_obj.columns]
-        self.visit_primary_key(table_obj.primary_key, table_obj)
-
-        for i in table_obj.indexes:
-            self.visit_index(i, table)
-
-        self.graph_index[table_id] = table
-        return table, columns
-
-    def check_column(self, column_obj: datamodel.Column) -> None:
-        """Check consistency of VOTable attributes for a column.
-
-        Parameters
-        ----------
-        column_obj
-            The column object to check.
-
-        Notes
-        -----
-        This method checks that a column with a sized datatype has either a
-        ``votable:arraysize`` or a ``length`` attribute and issues a warning
-        message if not. It also checks if a column with a timestamp datatype
-        has a ``arraysize`` attribute and issues a warning if not.
-        """
-        _id = column_obj.id
-        datatype_name = column_obj.datatype
-        felis_type = FelisType.felis_type(datatype_name.value)
-        if felis_type.is_sized:
-            # It is expected that both arraysize and length are fine for
-            # length types.
-            arraysize = column_obj.votable_arraysize or column_obj.length
-            if arraysize is None:
-                logger.warning(
-                    f"votable:arraysize and length for {_id} are None for type {datatype_name}. "
-                    'Using length "*". '
-                    "Consider setting `votable:arraysize` or `length`."
-                )
-        if felis_type.is_timestamp:
-            # datetime types really should have a votable:arraysize, because
-            # they are converted to strings and the `length` is loosely to the
-            # string size
-            if not column_obj.votable_arraysize:
-                logger.warning(
-                    f"votable:arraysize for {_id} is None for type {datatype_name}. "
-                    f'Using length "*". '
-                    "Consider setting `votable:arraysize` to an appropriate size for "
-                    "materialized datetime/timestamp strings."
-                )
-
-    def visit_column(self, column_obj: datamodel.Column, table_obj: Table) -> Tap11Base:
-        """Visit a column object and build its TAP_SCHEMA representation.
-
-        Parameters
-        ----------
-        column_obj
-            The column object to visit.
-        table_obj
-            The table object which the column belongs to.
-
-        Returns
-        -------
-        ``Tap11Base``
-            The SQLAlchemy ORM object for the column.
-        """
-        self.check_column(column_obj)
-        column_id = column_obj.id
-        table_name = self._table_name(table_obj.name)
-
-        column = self.tables["columns"]()
-        column.table_name = table_name
-        column.column_name = column_obj.name
-
-        felis_datatype = column_obj.datatype
-        felis_type = FelisType.felis_type(felis_datatype.value)
-        column.datatype = column_obj.votable_datatype or felis_type.votable_name
-
-        column.arraysize = column_obj.votable_arraysize
-
-        def _is_int(s: str) -> bool:
-            try:
-                int(s)
-                return True
-            except ValueError:
-                return False
-
-        # Handle the deprecated size attribute
-        arraysize = column.arraysize
-        if arraysize is not None and arraysize != "":
-            if isinstance(arraysize, int):
-                column.size = arraysize
-            elif _is_int(arraysize):
-                column.size = int(arraysize)
-            elif bool(re.match(r"^[0-9]+\*$", arraysize)):
-                column.size = int(arraysize.replace("*", ""))
-
-        if column.size is not None:
-            logger.debug(f"Set size to {column.size} for {column.column_name} with arraysize {arraysize}")
-
-        column.xtype = column_obj.votable_xtype
-        column.description = column_obj.description
-        column.utype = column_obj.votable_utype
-
-        unit = column_obj.ivoa_unit or column_obj.fits_tunit
-        column.unit = unit
-        column.ucd = column_obj.ivoa_ucd
-
-        # We modify this after we process columns
-        column.indexed = 0
-
-        column.principal = column_obj.tap_principal
-        column.std = column_obj.tap_std
-        column.column_index = column_obj.tap_column_index
-
-        self.graph_index[column_id] = column
-        return column
-
-    def visit_primary_key(self, primary_key_obj: str | Iterable[str] | None, table_obj: Table) -> None:
-        """Visit a primary key object and update the TAP_SCHEMA representation.
-
-        Parameters
-        ----------
-        primary_key_obj
-            The primary key object to visit.
-        table_obj
-            The table object which the primary key belongs to.
-        """
-        if primary_key_obj:
-            if isinstance(primary_key_obj, str):
-                primary_key_obj = [primary_key_obj]
-            columns = [self.graph_index[c_id] for c_id in primary_key_obj]
-            # if just one column and it's indexed, update the object
-            if len(columns) == 1:
-                columns[0].indexed = 1
-
-    def visit_constraint(self, constraint_obj: Constraint) -> tuple:
-        """Visit a constraint object and build its TAP_SCHEMA representation.
-
-        Parameters
-        ----------
-        constraint_obj
-            The constraint object to visit.
-
-        Returns
-        -------
-        `tuple`
-            A tuple of the SQLAlchemy ORM objects for the TAP_SCHEMA ``key``
-            and ``key_columns`` data.
-        """
-        key = None
-        key_columns = []
-        if isinstance(constraint_obj, ForeignKeyConstraint):
-            constraint_name = constraint_obj.name
-            description = constraint_obj.description
-            utype = constraint_obj.votable_utype
-
-            columns = [self.graph_index[col_id] for col_id in getattr(constraint_obj, "columns", [])]
-            refcolumns = [
-                self.graph_index[refcol_id] for refcol_id in getattr(constraint_obj, "referenced_columns", [])
-            ]
-
-            table_name = None
-            for column in columns:
-                if not table_name:
-                    table_name = column.table_name
-                if table_name != column.table_name:
-                    raise ValueError("Inconsisent use of table names")
-
-            table_name = None
-            for column in refcolumns:
-                if not table_name:
-                    table_name = column.table_name
-                if table_name != column.table_name:
-                    raise ValueError("Inconsisent use of table names")
-            first_column = columns[0]
-            first_refcolumn = refcolumns[0]
-
-            key = self.tables["keys"]()
-            key.key_id = constraint_name
-            key.from_table = first_column.table_name
-            key.target_table = first_refcolumn.table_name
-            key.description = description
-            key.utype = utype
-            for column, refcolumn in zip(columns, refcolumns):
-                key_column = self.tables["key_columns"]()
-                key_column.key_id = constraint_name
-                key_column.from_column = column.column_name
-                key_column.target_column = refcolumn.column_name
-                key_columns.append(key_column)
-        return key, key_columns
-
-    def visit_index(self, index_obj: Index, table_obj: Table) -> None:
-        """Visit an index object and update the TAP_SCHEMA representation.
-
-        Parameters
-        ----------
-        index_obj
-            The index object to visit.
-        table_obj
-            The table object which the index belongs to.
-        """
-        columns = [self.graph_index[col_id] for col_id in getattr(index_obj, "columns", [])]
-        # if just one column and it's indexed, update the object
-        if len(columns) == 1:
-            columns[0].indexed = 1
-        return None
-
-    def _schema_name(
-        self, schema_name: str | None = None
-    ) -> str | None:  # DM-44870: Usage of this method needs to be better understood and possibly removed
-        """Return the schema name.
-
-        Parameters
-        ----------
-        schema_name
-            Name of the schema.
-
-        Returns
-        -------
-        schema_name
-            The schema name.
-        """
-        # If _schema_name is None, SQLAlchemy will catch it
-        _schema_name = schema_name or self.schema_name
-        if self.catalog_name and _schema_name:
-            return ".".join([self.catalog_name, _schema_name])
-        return _schema_name
-
-    def _table_name(self, table_name: str) -> str:
-        """Return the table name.
-
-        Parameters
-        ----------
-        table_name
-            Name of the table.
-        """
-        schema_name = self._schema_name()
-        if schema_name:
-            return ".".join([schema_name, table_name])
-        return table_name
-
-
-def _insert(table: Tap11Base, value: Any) -> Insert:
-    """Return a SQLAlchemy insert statement.
-
-    Parameters
-    ----------
-    table
-        The table we are inserting into.
-    value
-        An object representing the object we are inserting to the table.
-
-    Returns
-    -------
-    `Insert`
-        SQLAlchemy insert statement.
-    """
-    values_dict = {}
-    for i in table.__table__.columns:
-        name = i.name
-        column_value = getattr(value, i.name)
-        if isinstance(column_value, str):
-            column_value = column_value.replace("'", "''")
-        values_dict[name] = column_value
-    return insert(table).values(values_dict)