Inheritance diagram for lsst.dax.apdb.apdbSqlSchema.ApdbSqlSchema:

Public Member Functions
	__init__ (self, sqlalchemy.engine.Engine engine, str dia_object_index, str htm_index_column, str schema_file, str schema_name="ApdbSchema", str prefix="", str\|None namespace=None, bool use_insert_id=False)

bool	empty (self)

None	makeSchema (self, bool drop=False)

Table	get_table (self, ApdbTables\|ExtraTables table_enum)

list[Column]	get_apdb_columns (self, ApdbTables\|ExtraTables table_enum)

bool	has_insert_id (self)

Static Public Attributes
tuple	pixel_id_tables = (ApdbTables.DiaObject, ApdbTables.DiaObjectLast, ApdbTables.DiaSource)

Protected Member Functions
bool	_check_insert_id (self)

Mapping[ApdbTables, Table]	_make_apdb_tables (self, str mysql_engine="InnoDB")

Mapping[ExtraTables, Table]	_make_extra_tables (self, Mapping[ApdbTables, Table] apdb_tables, str mysql_engine="InnoDB")

list[Column]	_tableColumns (self, ApdbTables table_name)

list[sqlalchemy.schema.SchemaItem]	_tableIndices (self, ApdbTables table_name)

list[Column]	_insertIdColumns (self, ExtraTables table_enum)

list[Column]	_tablePkColumns (self, ApdbTables table_enum)

list[sqlalchemy.schema.SchemaItem]	_insertIdIndices (self, ExtraTables table_enum, sqlalchemy.schema.Table apdb_table, sqlalchemy.schema.Table parent_table)

type\|sqlalchemy.types.TypeEngine	_getDoubleType (cls, sqlalchemy.engine.Engine engine)

Protected Attributes
	_engine

	_dia_object_index

	_htm_index_column

	_prefix

	_use_insert_id

	_metadata

	_type_map

	_apdb_tables

	_extra_tables

	_has_insert_id

	_metadata_check

Detailed Description

Class for management of APDB schema.

Attributes
----------
objects : `sqlalchemy.Table`
    DiaObject table instance
objects_last : `sqlalchemy.Table`
    DiaObjectLast table instance, may be None
sources : `sqlalchemy.Table`
    DiaSource table instance
forcedSources : `sqlalchemy.Table`
    DiaForcedSource table instance
has_insert_id : `bool`
    If true then schema has tables for insert ID tracking.

Parameters
----------
engine : `sqlalchemy.engine.Engine`
    SQLAlchemy engine instance
dia_object_index : `str`
    Indexing mode for DiaObject table, see `ApdbSqlConfig.dia_object_index`
    for details.
htm_index_column : `str`
    Name of a HTM index column for DiaObject and DiaSource tables.
schema_file : `str`
    Name of the YAML schema file.
schema_name : `str`, optional
    Name of the schema in YAML files.
prefix : `str`, optional
    Prefix to add to all schema elements.
namespace : `str`, optional
    Namespace (or schema name) to use for all APDB tables.
use_insert_id : `bool`, optional

Definition at line 146 of file apdbSqlSchema.py.

Constructor & Destructor Documentation

◆ init()

lsst.dax.apdb.apdbSqlSchema.ApdbSqlSchema.__init__	(		self,
		sqlalchemy.engine.Engine	engine,
		str	dia_object_index,
		str	htm_index_column,
		str	schema_file,
		str	schema_name = "ApdbSchema",
		str	prefix = "",
		str \| None	namespace = None,
		bool	use_insert_id = False )

Reimplemented from lsst.dax.apdb.apdbSchema.ApdbSchema.

Definition at line 186 of file apdbSqlSchema.py.

    ):
        super().__init__(schema_file, schema_name)
 
        self._engine = engine
        self._dia_object_index = dia_object_index
        self._htm_index_column = htm_index_column
        self._prefix = prefix
        self._use_insert_id = use_insert_id
 
        self._metadata = MetaData(schema=namespace)
 
        # map YAML column types to SQLAlchemy
        self._type_map = {
            felis.types.Double: self._getDoubleType(engine),
            felis.types.Float: sqlalchemy.types.Float,
            felis.types.Timestamp: sqlalchemy.types.TIMESTAMP,
            felis.types.Long: sqlalchemy.types.BigInteger,
            felis.types.Int: sqlalchemy.types.Integer,
            felis.types.Short: sqlalchemy.types.Integer,
            felis.types.Byte: sqlalchemy.types.Integer,
            felis.types.Binary: sqlalchemy.types.LargeBinary,
            felis.types.Text: sqlalchemy.types.Text,
            felis.types.String: sqlalchemy.types.CHAR,
            felis.types.Char: sqlalchemy.types.CHAR,
            felis.types.Unicode: sqlalchemy.types.CHAR,
            felis.types.Boolean: sqlalchemy.types.Boolean,
        }
 
        # Add pixelId column and index to tables that need it
        for table in self.pixel_id_tables:
            tableDef = self.tableSchemas.get(table)
            if not tableDef:
                continue
            column = simple.Column(
                id=f"#{htm_index_column}",
                name=htm_index_column,
                datatype=felis.types.Long,
                nullable=False,
                value=None,
                description="Pixelization index column.",
                table=tableDef,
            )
            tableDef.columns.append(column)
 
            # Adjust index if needed
            if table == ApdbTables.DiaObject and self._dia_object_index == "pix_id_iov":
                tableDef.primary_key.insert(0, column)
 
            if table is ApdbTables.DiaObjectLast:
                # use it as a leading PK column
                tableDef.primary_key.insert(0, column)
            else:
                # make a regular index
                name = f"IDX_{tableDef.name}_{htm_index_column}"
                index = simple.Index(id=f"#{name}", name=name, columns=[column])
                tableDef.indexes.append(index)
 
        # generate schema for all tables, must be called last
        self._apdb_tables = self._make_apdb_tables()
        self._extra_tables = self._make_extra_tables(self._apdb_tables)
 
        self._has_insert_id: bool | None = None
        self._metadata_check: bool | None = None
 

Member Function Documentation

◆ _check_insert_id()

bool lsst.dax.apdb.apdbSqlSchema.ApdbSqlSchema._check_insert_id ( self )

protected

Check whether database has tables for tracking insert IDs.

Definition at line 396 of file apdbSqlSchema.py.

    def _check_insert_id(self) -> bool:
        """Check whether database has tables for tracking insert IDs."""
        inspector = inspect(self._engine)
        db_tables = set(inspector.get_table_names(schema=self._metadata.schema))
        return ExtraTables.DiaInsertId.table_name(self._prefix) in db_tables
 

◆ _getDoubleType()

type \| sqlalchemy.types.TypeEngine lsst.dax.apdb.apdbSqlSchema.ApdbSqlSchema._getDoubleType	(		cls,
		sqlalchemy.engine.Engine	engine )

protected

DOUBLE type is database-specific, select one based on dialect.

Parameters
----------
engine : `sqlalchemy.engine.Engine`
    Database engine.

Returns
-------
type_object : `object`
    Database-specific type definition.

Definition at line 585 of file apdbSqlSchema.py.

    def _getDoubleType(cls, engine: sqlalchemy.engine.Engine) -> type | sqlalchemy.types.TypeEngine:
        """DOUBLE type is database-specific, select one based on dialect.
 
        Parameters
        ----------
        engine : `sqlalchemy.engine.Engine`
            Database engine.
 
        Returns
        -------
        type_object : `object`
            Database-specific type definition.
        """
        if engine.name == "mysql":
            from sqlalchemy.dialects.mysql import DOUBLE
 
            return DOUBLE(asdecimal=False)
        elif engine.name == "postgresql":
            from sqlalchemy.dialects.postgresql import DOUBLE_PRECISION
 
            return DOUBLE_PRECISION
        elif engine.name == "oracle":
            from sqlalchemy.dialects.oracle import DOUBLE_PRECISION
 
            return DOUBLE_PRECISION
        elif engine.name == "sqlite":
            # all floats in sqlite are 8-byte
            from sqlalchemy.dialects.sqlite import REAL
 
            return REAL
        else:
            raise TypeError("cannot determine DOUBLE type, unexpected dialect: " + engine.name)

◆ _insertIdColumns()

list[Column] lsst.dax.apdb.apdbSqlSchema.ApdbSqlSchema._insertIdColumns	(		self,
		ExtraTables	table_enum )

protected

Return list of columns for insert ID tables.

Definition at line 532 of file apdbSqlSchema.py.

    def _insertIdColumns(self, table_enum: ExtraTables) -> list[Column]:
        """Return list of columns for insert ID tables."""
        column_defs: list[Column] = [Column("insert_id", GUID, nullable=False)]
        insert_id_tables = ExtraTables.insert_id_tables()
        if table_enum in insert_id_tables:
            column_defs += self._tablePkColumns(insert_id_tables[table_enum])
        else:
            assert False, "Above branches have to cover all enum values"
        return column_defs
 

◆ _insertIdIndices()

list[sqlalchemy.schema.SchemaItem] lsst.dax.apdb.apdbSqlSchema.ApdbSqlSchema._insertIdIndices	(		self,
		ExtraTables	table_enum,
		sqlalchemy.schema.Table	apdb_table,
		sqlalchemy.schema.Table	parent_table )

protected

Return set of constraints/indices for insert ID tables.

Definition at line 551 of file apdbSqlSchema.py.

    ) -> list[sqlalchemy.schema.SchemaItem]:
        """Return set of constraints/indices for insert ID tables."""
        index_defs: list[sqlalchemy.schema.SchemaItem] = []
 
        # Special case for insert ID tables that are not in felis schema.
        insert_id_tables = ExtraTables.insert_id_tables()
        if table_enum in insert_id_tables:
            # PK is the same as for original table
            pk_names = [column.name for column in self._tablePkColumns(insert_id_tables[table_enum])]
            index_defs.append(PrimaryKeyConstraint(*pk_names))
            # Non-unique index on insert_id column.
            name = self._prefix + table_enum.name + "_idx"
            index_defs.append(Index(name, "insert_id"))
            # Foreign key to original table
            pk_columns = [apdb_table.columns[column] for column in pk_names]
            index_defs.append(
                ForeignKeyConstraint(pk_names, pk_columns, onupdate="CASCADE", ondelete="CASCADE")
            )
            # Foreign key to parent table
            index_defs.append(
                ForeignKeyConstraint(
                    ["insert_id"], [parent_table.columns["insert_id"]], onupdate="CASCADE", ondelete="CASCADE"
                )
            )
        else:
            assert False, "Above branches have to cover all enum values"
        return index_defs
 

◆ _make_apdb_tables()

Mapping[ApdbTables, Table] lsst.dax.apdb.apdbSqlSchema.ApdbSqlSchema._make_apdb_tables	(		self,
		str	mysql_engine = "InnoDB" )

protected

Generate schema for regular tables.

Parameters
----------
mysql_engine : `str`, optional
    MySQL engine type to use for new tables.

Definition at line 402 of file apdbSqlSchema.py.

    def _make_apdb_tables(self, mysql_engine: str = "InnoDB") -> Mapping[ApdbTables, Table]:
        """Generate schema for regular tables.
 
        Parameters
        ----------
        mysql_engine : `str`, optional
            MySQL engine type to use for new tables.
        """
        tables = {}
        for table_enum in ApdbTables:
            if table_enum is ApdbTables.DiaObjectLast and self._dia_object_index != "last_object_table":
                continue
            if table_enum is ApdbTables.metadata and table_enum not in self.tableSchemas:
                # Schema does not define metadata.
                continue
 
            columns = self._tableColumns(table_enum)
            constraints = self._tableIndices(table_enum)
            table = Table(
                table_enum.table_name(self._prefix),
                self._metadata,
                *columns,
                *constraints,
                mysql_engine=mysql_engine,
            )
            tables[table_enum] = table
 
        return tables
 

◆ _make_extra_tables()

Mapping[ExtraTables, Table] lsst.dax.apdb.apdbSqlSchema.ApdbSqlSchema._make_extra_tables	(		self,
		Mapping[ApdbTables, Table]	apdb_tables,
		str	mysql_engine = "InnoDB" )

protected

Generate schema for insert ID tables.

Definition at line 431 of file apdbSqlSchema.py.

    ) -> Mapping[ExtraTables, Table]:
        """Generate schema for insert ID tables."""
        tables: dict[ExtraTables, Table] = {}
        if not self._use_insert_id:
            return tables
 
        # Parent table needs to be defined first
        column_defs = [
            Column("insert_id", GUID, primary_key=True),
            Column("insert_time", sqlalchemy.types.TIMESTAMP, nullable=False),
        ]
        parent_table = Table(
            ExtraTables.DiaInsertId.table_name(self._prefix),
            self._metadata,
            *column_defs,
            mysql_engine=mysql_engine,
        )
        tables[ExtraTables.DiaInsertId] = parent_table
 
        for table_enum, apdb_enum in ExtraTables.insert_id_tables().items():
            apdb_table = apdb_tables[apdb_enum]
            columns = self._insertIdColumns(table_enum)
            constraints = self._insertIdIndices(table_enum, apdb_table, parent_table)
            table = Table(
                table_enum.table_name(self._prefix),
                self._metadata,
                *columns,
                *constraints,
                mysql_engine=mysql_engine,
            )
            tables[table_enum] = table
 
        return tables
 

◆ _tableColumns()

list[Column] lsst.dax.apdb.apdbSqlSchema.ApdbSqlSchema._tableColumns	(		self,
		ApdbTables	table_name )

protected

Return set of columns in a table

Parameters
----------
table_name : `ApdbTables`
    Name of the table.

Returns
-------
column_defs : `list`
    List of `Column` objects.

Definition at line 467 of file apdbSqlSchema.py.

    def _tableColumns(self, table_name: ApdbTables) -> list[Column]:
        """Return set of columns in a table
 
        Parameters
        ----------
        table_name : `ApdbTables`
            Name of the table.
 
        Returns
        -------
        column_defs : `list`
            List of `Column` objects.
        """
        # get the list of columns in primary key, they are treated somewhat
        # specially below
        table_schema = self.tableSchemas[table_name]
 
        # convert all column dicts into alchemy Columns
        column_defs: list[Column] = []
        for column in table_schema.columns:
            kwargs: dict[str, Any] = dict(nullable=column.nullable)
            if column.value is not None:
                kwargs.update(server_default=str(column.value))
            if column in table_schema.primary_key:
                kwargs.update(autoincrement=False)
            ctype = self._type_map[column.datatype]
            column_defs.append(Column(column.name, ctype, **kwargs))
 
        return column_defs
 

◆ _tableIndices()

list[sqlalchemy.schema.SchemaItem] lsst.dax.apdb.apdbSqlSchema.ApdbSqlSchema._tableIndices	(		self,
		ApdbTables	table_name )

protected

Return set of constraints/indices in a table

Parameters
----------
table_name : `ApdbTables`
    Name of the table.
info : `dict`
    Additional options passed to SQLAlchemy index constructor.

Returns
-------
index_defs : `list`
    List of SQLAlchemy index/constraint objects.

Definition at line 497 of file apdbSqlSchema.py.

    def _tableIndices(self, table_name: ApdbTables) -> list[sqlalchemy.schema.SchemaItem]:
        """Return set of constraints/indices in a table
 
        Parameters
        ----------
        table_name : `ApdbTables`
            Name of the table.
        info : `dict`
            Additional options passed to SQLAlchemy index constructor.
 
        Returns
        -------
        index_defs : `list`
            List of SQLAlchemy index/constraint objects.
        """
        table_schema = self.tableSchemas[table_name]
 
        # convert all index dicts into alchemy Columns
        index_defs: list[sqlalchemy.schema.SchemaItem] = []
        if table_schema.primary_key:
            index_defs.append(PrimaryKeyConstraint(*[column.name for column in table_schema.primary_key]))
        for index in table_schema.indexes:
            name = self._prefix + index.name if index.name else ""
            index_defs.append(Index(name, *[column.name for column in index.columns]))
        for constraint in table_schema.constraints:
            constr_name: str | None = None
            if constraint.name:
                constr_name = self._prefix + constraint.name
            if isinstance(constraint, simple.UniqueConstraint):
                index_defs.append(
                    UniqueConstraint(*[column.name for column in constraint.columns], name=constr_name)
                )
 
        return index_defs
 

◆ _tablePkColumns()

list[Column] lsst.dax.apdb.apdbSqlSchema.ApdbSqlSchema._tablePkColumns	(		self,
		ApdbTables	table_enum )

protected

Return a list of columns for table PK.

Definition at line 542 of file apdbSqlSchema.py.

    def _tablePkColumns(self, table_enum: ApdbTables) -> list[Column]:
        """Return a list of columns for table PK."""
        table_schema = self.tableSchemas[table_enum]
        column_defs: list[Column] = []
        for column in table_schema.primary_key:
            ctype = self._type_map[column.datatype]
            column_defs.append(Column(column.name, ctype, nullable=False, autoincrement=False))
        return column_defs
 

◆ empty()

bool lsst.dax.apdb.apdbSqlSchema.ApdbSqlSchema.empty ( self )

Return True if database schema is empty.

Returns
-------
empty : `bool`
    `True` if none of the required APDB tables exist in the database,
    `False` if all required tables exist.

Raises
------
InconsistentSchemaError
    Raised when some of the required tables exist but not all.

Definition at line 260 of file apdbSqlSchema.py.

    def empty(self) -> bool:
        """Return True if database schema is empty.
 
        Returns
        -------
        empty : `bool`
            `True` if none of the required APDB tables exist in the database,
            `False` if all required tables exist.
 
        Raises
        ------
        InconsistentSchemaError
            Raised when some of the required tables exist but not all.
        """
        inspector = inspect(self._engine)
        table_names = set(inspector.get_table_names(self._metadata.schema))
 
        existing_tables = []
        missing_tables = []
        for table_enum in self._apdb_tables:
            table_name = table_enum.table_name(self._prefix)
            if table_name in table_names:
                existing_tables.append(table_name)
            else:
                missing_tables.append(table_name)
 
        if not missing_tables:
            return False
        elif not existing_tables:
            return True
        else:
            raise InconsistentSchemaError(
                f"Only some required APDB tables exist: {existing_tables}, missing tables: {missing_tables}"
            )
 

◆ get_apdb_columns()

list[Column] lsst.dax.apdb.apdbSqlSchema.ApdbSqlSchema.get_apdb_columns	(		self,
		ApdbTables \| ExtraTables	table_enum )

Return list of columns defined for a table in APDB schema.

Returned list excludes columns that are implementation-specific, e.g.
``pixelId`` column is not include in the returned list.

Parameters
----------
table_enum : `ApdbTables` or `ExtraTables`
    Type of table.

Returns
-------
table : `list` [`sqlalchemy.schema.Column`]
    Table instance.

Raises
------
ValueError
    Raised if ``table_enum`` is not valid for this database.

Definition at line 362 of file apdbSqlSchema.py.

    def get_apdb_columns(self, table_enum: ApdbTables | ExtraTables) -> list[Column]:
        """Return list of columns defined for a table in APDB schema.
 
        Returned list excludes columns that are implementation-specific, e.g.
        ``pixelId`` column is not include in the returned list.
 
        Parameters
        ----------
        table_enum : `ApdbTables` or `ExtraTables`
            Type of table.
 
        Returns
        -------
        table : `list` [`sqlalchemy.schema.Column`]
            Table instance.
 
        Raises
        ------
        ValueError
            Raised if ``table_enum`` is not valid for this database.
        """
        table = self.get_table(table_enum)
        exclude_columns = set()
        if table_enum in self.pixel_id_tables:
            exclude_columns.add(self._htm_index_column)
        return [column for column in table.columns if column.name not in exclude_columns]
 

◆ get_table()

Table lsst.dax.apdb.apdbSqlSchema.ApdbSqlSchema.get_table	(		self,
		ApdbTables \| ExtraTables	table_enum )

Return SQLAlchemy table instance for a specified table type/enum.

Parameters
----------
table_enum : `ApdbTables` or `ExtraTables`
    Type of table to return.

Returns
-------
table : `sqlalchemy.schema.Table`
    Table instance.

Raises
------
ValueError
    Raised if ``table_enum`` is not valid for this database.

Definition at line 324 of file apdbSqlSchema.py.

    def get_table(self, table_enum: ApdbTables | ExtraTables) -> Table:
        """Return SQLAlchemy table instance for a specified table type/enum.
 
        Parameters
        ----------
        table_enum : `ApdbTables` or `ExtraTables`
            Type of table to return.
 
        Returns
        -------
        table : `sqlalchemy.schema.Table`
            Table instance.
 
        Raises
        ------
        ValueError
            Raised if ``table_enum`` is not valid for this database.
        """
        try:
            if isinstance(table_enum, ApdbTables):
                if table_enum is ApdbTables.metadata:
                    # There may be cases when schema is configured with the
                    # metadata table but database is still missing it. Check
                    # that table actually exists in the database. Note that
                    # this may interact with `makeSchema`.
                    if self._metadata_check is None:
                        inspector = inspect(self._engine)
                        table_name = table_enum.table_name(self._prefix)
                        self._metadata_check = inspector.has_table(table_name, schema=self._metadata.schema)
                    if not self._metadata_check:
                        # this will be caught below
                        raise LookupError("metadata table is missing")
                return self._apdb_tables[table_enum]
            else:
                return self._extra_tables[table_enum]
        except LookupError:
            raise ValueError(f"Table type {table_enum} does not exist in the schema") from None
 

◆ has_insert_id()

bool lsst.dax.apdb.apdbSqlSchema.ApdbSqlSchema.has_insert_id ( self )

Whether insert ID tables are to be used (`bool`).

Definition at line 390 of file apdbSqlSchema.py.

    def has_insert_id(self) -> bool:
        """Whether insert ID tables are to be used (`bool`)."""
        if self._has_insert_id is None:
            self._has_insert_id = self._use_insert_id and self._check_insert_id()
        return self._has_insert_id
 

◆ makeSchema()

None lsst.dax.apdb.apdbSqlSchema.ApdbSqlSchema.makeSchema	(		self,
		bool	drop = False )

Create or re-create all tables.

Parameters
----------
drop : `bool`, optional
    If True then drop tables before creating new ones.

Definition at line 295 of file apdbSqlSchema.py.

    def makeSchema(self, drop: bool = False) -> None:
        """Create or re-create all tables.
 
        Parameters
        ----------
        drop : `bool`, optional
            If True then drop tables before creating new ones.
        """
        # Create namespace if it does not exist yet, for now this only makes
        # sense for postgres.
        if self._metadata.schema:
            dialect = self._engine.dialect
            quoted_schema = dialect.preparer(dialect).quote_schema(self._metadata.schema)
            create_schema = DDL(
                "CREATE SCHEMA IF NOT EXISTS %(schema)s", context={"schema": quoted_schema}
            ).execute_if(dialect="postgresql")
            event.listen(self._metadata, "before_create", create_schema)
 
        # create all tables (optionally drop first)
        if drop:
            _LOG.info("dropping all tables")
            self._metadata.drop_all(self._engine)
        _LOG.info("creating all tables")
        self._metadata.create_all(self._engine)
 
        # Reset possibly cached value.
        self._has_insert_id = None
        self._metadata_check = None
 

Member Data Documentation

◆ _apdb_tables

lsst.dax.apdb.apdbSqlSchema.ApdbSqlSchema._apdb_tables

protected

Definition at line 254 of file apdbSqlSchema.py.

◆ _dia_object_index

lsst.dax.apdb.apdbSqlSchema.ApdbSqlSchema._dia_object_index

protected

Definition at line 200 of file apdbSqlSchema.py.

◆ _engine

lsst.dax.apdb.apdbSqlSchema.ApdbSqlSchema._engine

protected

Definition at line 199 of file apdbSqlSchema.py.

◆ _extra_tables

lsst.dax.apdb.apdbSqlSchema.ApdbSqlSchema._extra_tables

protected

Definition at line 255 of file apdbSqlSchema.py.

◆ _has_insert_id

lsst.dax.apdb.apdbSqlSchema.ApdbSqlSchema._has_insert_id

protected

Definition at line 321 of file apdbSqlSchema.py.

◆ _htm_index_column

lsst.dax.apdb.apdbSqlSchema.ApdbSqlSchema._htm_index_column

protected

Definition at line 201 of file apdbSqlSchema.py.

◆ _metadata

lsst.dax.apdb.apdbSqlSchema.ApdbSqlSchema._metadata

protected

Definition at line 205 of file apdbSqlSchema.py.

◆ _metadata_check

lsst.dax.apdb.apdbSqlSchema.ApdbSqlSchema._metadata_check

protected

Definition at line 322 of file apdbSqlSchema.py.

◆ _prefix

lsst.dax.apdb.apdbSqlSchema.ApdbSqlSchema._prefix

protected

Definition at line 202 of file apdbSqlSchema.py.

◆ _type_map

lsst.dax.apdb.apdbSqlSchema.ApdbSqlSchema._type_map

protected

Definition at line 208 of file apdbSqlSchema.py.

◆ _use_insert_id

lsst.dax.apdb.apdbSqlSchema.ApdbSqlSchema._use_insert_id

protected

Definition at line 203 of file apdbSqlSchema.py.

◆ pixel_id_tables

tuple lsst.dax.apdb.apdbSqlSchema.ApdbSqlSchema.pixel_id_tables = (ApdbTables.DiaObject, ApdbTables.DiaObjectLast, ApdbTables.DiaSource)

static

Definition at line 183 of file apdbSqlSchema.py.

The documentation for this class was generated from the following file:

/j/snowflake/release/lsstsw/stack/lsst-scipipe-8.0.0/Linux64/dax_apdb/gd2a12a3803+f8351bc914/python/lsst/dax/apdb/apdbSqlSchema.py

Public Member Functions

Static Public Attributes

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ __init__()

Member Function Documentation

◆ _check_insert_id()

◆ _getDoubleType()

◆ _insertIdColumns()

◆ _insertIdIndices()

◆ _make_apdb_tables()

◆ _make_extra_tables()

◆ _tableColumns()

◆ _tableIndices()

◆ _tablePkColumns()

◆ empty()

◆ get_apdb_columns()

◆ get_table()

◆ has_insert_id()

◆ makeSchema()

Member Data Documentation

◆ _apdb_tables

◆ _dia_object_index

◆ _engine

◆ _extra_tables

◆ _has_insert_id

◆ _htm_index_column

◆ _metadata

◆ _metadata_check

◆ _prefix

◆ _type_map

◆ _use_insert_id

◆ pixel_id_tables

◆ init()