diracx-db 0.0.1a21__py3-none-any.whl → 0.0.6__py3-none-any.whl

diracx/db/sql/job/db.py

@@ -1,22 +1,23 @@
 from __future__ import annotations
 
+__all__ = ["JobDB"]
+
 from datetime import datetime, timezone
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, Iterable
 
-from sqlalchemy import bindparam, delete, func, insert, select, update
-from sqlalchemy.exc import IntegrityError, NoResultFound
+from sqlalchemy import bindparam, case, delete, literal, select, update
 
 if TYPE_CHECKING:
     from sqlalchemy.sql.elements import BindParameter
-from diracx.core.exceptions import InvalidQueryError, JobNotFound
-from diracx.core.models import (
-    LimitedJobStatusReturn,
-    SearchSpec,
-    SortSpec,
-)
+from sqlalchemy.sql import expression
 
-from ..utils import BaseSQLDB, apply_search_filters, apply_sort_constraints
+from diracx.core.exceptions import InvalidQueryError
+from diracx.core.models import JobCommand, SearchSpec, SortSpec
+
+from ..utils import BaseSQLDB, _get_columns
+from ..utils.functions import utcnow
 from .schema import (
+    HeartBeatLoggingInfo,
     InputData,
     JobCommands,
     JobDBBase,
@@ -25,38 +26,29 @@ from .schema import (
 )
 
 
-def _get_columns(table, parameters):
-    columns = [x for x in table.columns]
-    if parameters:
-        if unrecognised_parameters := set(parameters) - set(table.columns.keys()):
-            raise InvalidQueryError(
-                f"Unrecognised parameters requested {unrecognised_parameters}"
-            )
-        columns = [c for c in columns if c.name in parameters]
-    return columns
-
-
 class JobDB(BaseSQLDB):
     metadata = JobDBBase.metadata
 
+    # Field names which should be stored in the HeartBeatLoggingInfo table
+    heartbeat_fields = {
+        "LoadAverage",
+        "MemoryUsed",
+        "Vsize",
+        "AvailableDiskSpace",
+        "CPUConsumed",
+        "WallClockTime",
+    }
+
     # TODO: this is copied from the DIRAC JobDB
-    # but is overwriten in LHCbDIRAC, so we need
+    # but is overwritten in LHCbDIRAC, so we need
     # to find a way to make it dynamic
-    jdl2DBParameters = ["JobName", "JobType", "JobGroup"]
-
-    async def summary(self, group_by, search) -> list[dict[str, str | int]]:
-        columns = _get_columns(Jobs.__table__, group_by)
-
-        stmt = select(*columns, func.count(Jobs.JobID).label("count"))
-        stmt = apply_search_filters(Jobs.__table__.columns.__getitem__, stmt, search)
-        stmt = stmt.group_by(*columns)
+    jdl_2_db_parameters = ["JobName", "JobType", "JobGroup"]
 
-        # Execute the query
-        return [
-            dict(row._mapping)
-            async for row in (await self.conn.stream(stmt))
-            if row.count > 0  # type: ignore
-        ]
+    async def summary(
+        self, group_by: list[str], search: list[SearchSpec]
+    ) -> list[dict[str, str | int]]:
+        """Get a summary of the jobs."""
+        return await self._summary(table=Jobs, group_by=group_by, search=search)
 
     async def search(
         self,
@@ -68,36 +60,35 @@ class JobDB(BaseSQLDB):
         per_page: int = 100,
         page: int | None = None,
     ) -> tuple[int, list[dict[Any, Any]]]:
-        # Find which columns to select
-        columns = _get_columns(Jobs.__table__, parameters)
-
-        stmt = select(*columns)
-
-        stmt = apply_search_filters(Jobs.__table__.columns.__getitem__, stmt, search)
-        stmt = apply_sort_constraints(Jobs.__table__.columns.__getitem__, stmt, sorts)
-
-        if distinct:
-            stmt = stmt.distinct()
-
-        # Calculate total count before applying pagination
-        total_count_subquery = stmt.alias()
-        total_count_stmt = select(func.count()).select_from(total_count_subquery)
-        total = (await self.conn.execute(total_count_stmt)).scalar_one()
+        """Search for jobs in the database."""
+        return await self._search(
+            table=Jobs,
+            parameters=parameters,
+            search=search,
+            sorts=sorts,
+            distinct=distinct,
+            per_page=per_page,
+            page=page,
+        )
 
-        # Apply pagination
-        if page is not None:
-            if page < 1:
-                raise InvalidQueryError("Page must be a positive integer")
-            if per_page < 1:
-                raise InvalidQueryError("Per page must be a positive integer")
-            stmt = stmt.offset((page - 1) * per_page).limit(per_page)
+    async def create_job(self, compressed_original_jdl: str):
+        """Used to insert a new job with original JDL. Returns inserted job id."""
+        result = await self.conn.execute(
+            JobJDLs.__table__.insert().values(
+                JDL="",
+                JobRequirements="",
+                OriginalJDL=compressed_original_jdl,
+            )
+        )
+        return result.lastrowid
 
-        # Execute the query
-        return total, [
-            dict(row._mapping) async for row in (await self.conn.stream(stmt))
-        ]
+    async def delete_jobs(self, job_ids: list[int]):
+        """Delete jobs from the database."""
+        stmt = delete(JobJDLs).where(JobJDLs.job_id.in_(job_ids))
+        await self.conn.execute(stmt)
 
     async def insert_input_data(self, lfns: dict[int, list[str]]):
+        """Insert input data for jobs."""
         await self.conn.execute(
             InputData.__table__.insert(),
             [
@@ -110,27 +101,8 @@ class JobDB(BaseSQLDB):
             ],
         )
 
-    async def setJobAttributes(self, job_id, jobData):
-        """TODO: add myDate and force parameters."""
-        if "Status" in jobData:
-            jobData = jobData | {"LastUpdateTime": datetime.now(tz=timezone.utc)}
-        stmt = update(Jobs).where(Jobs.JobID == job_id).values(jobData)
-        await self.conn.execute(stmt)
-
-    async def create_job(self, original_jdl):
-        """Used to insert a new job with original JDL. Returns inserted job id."""
-        from DIRAC.WorkloadManagementSystem.DB.JobDBUtils import compressJDL
-
-        result = await self.conn.execute(
-            JobJDLs.__table__.insert().values(
-                JDL="",
-                JobRequirements="",
-                OriginalJDL=compressJDL(original_jdl),
-            )
-        )
-        return result.lastrowid
-
     async def insert_job_attributes(self, jobs_to_update: dict[int, dict]):
+        """Insert the job attributes."""
         await self.conn.execute(
             Jobs.__table__.insert(),
             [
@@ -144,8 +116,6 @@ class JobDB(BaseSQLDB):
 
     async def update_job_jdls(self, jdls_to_update: dict[int, str]):
         """Used to update the JDL, typically just after inserting the original JDL, or rescheduling, for example."""
-        from DIRAC.WorkloadManagementSystem.DB.JobDBUtils import compressJDL
-
         await self.conn.execute(
             JobJDLs.__table__.update().where(
                 JobJDLs.__table__.c.JobID == bindparam("b_JobID")
@@ -153,138 +123,69 @@ class JobDB(BaseSQLDB):
             [
                 {
                     "b_JobID": job_id,
-                    "JDL": compressJDL(jdl),
+                    "JDL": compressed_jdl,
                 }
-                for job_id, jdl in jdls_to_update.items()
+                for job_id, compressed_jdl in jdls_to_update.items()
             ],
         )
 
-    async def checkAndPrepareJob(
-        self,
-        jobID,
-        class_ad_job,
-        class_ad_req,
-        owner,
-        owner_group,
-        job_attrs,
-        vo,
-    ):
-        """Check Consistency of Submitted JDL and set some defaults
-        Prepare subJDL with Job Requirements.
-        """
-        from DIRAC.Core.Utilities.DErrno import EWMSSUBM, cmpError
-        from DIRAC.Core.Utilities.ReturnValues import returnValueOrRaise
-        from DIRAC.WorkloadManagementSystem.DB.JobDBUtils import (
-            checkAndPrepareJob,
-        )
-
-        retVal = checkAndPrepareJob(
-            jobID,
-            class_ad_job,
-            class_ad_req,
-            owner,
-            owner_group,
-            job_attrs,
-            vo,
-        )
-
-        if not retVal["OK"]:
-            if cmpError(retVal, EWMSSUBM):
-                await self.setJobAttributes(jobID, job_attrs)
+    async def set_job_attributes(self, job_data):
+        """Update the parameters of the given jobs."""
+        # TODO: add myDate and force parameters.
 
-            returnValueOrRaise(retVal)
+        if not job_data:
+            # nothing to do!
+            raise ValueError("job_data is empty")
 
-    async def setJobJDL(self, job_id, jdl):
-        from DIRAC.WorkloadManagementSystem.DB.JobDBUtils import compressJDL
-
-        stmt = (
-            update(JobJDLs).where(JobJDLs.JobID == job_id).values(JDL=compressJDL(jdl))
-        )
-        await self.conn.execute(stmt)
-
-    async def setJobJDLsBulk(self, jdls):
-        from DIRAC.WorkloadManagementSystem.DB.JobDBUtils import compressJDL
-
-        await self.conn.execute(
-            JobJDLs.__table__.update().where(
-                JobJDLs.__table__.c.JobID == bindparam("b_JobID")
-            ),
-            [{"b_JobID": jid, "JDL": compressJDL(jdl)} for jid, jdl in jdls.items()],
-        )
-
-    async def setJobAttributesBulk(self, jobData):
-        """TODO: add myDate and force parameters."""
-        for job_id in jobData.keys():
-            if "Status" in jobData[job_id]:
-                jobData[job_id].update(
+        for job_id in job_data.keys():
+            if "Status" in job_data[job_id]:
+                job_data[job_id].update(
                     {"LastUpdateTime": datetime.now(tz=timezone.utc)}
                 )
+        columns = set(key for attrs in job_data.values() for key in attrs.keys())
+        case_expressions = {
+            column: case(
+                *[
+                    (
+                        Jobs.__table__.c.JobID == job_id,
+                        # Since the setting of the new column value is obscured by the CASE statement,
+                        # ensure that SQLAlchemy renders the new column value with the correct type
+                        literal(attrs[column], type_=Jobs.__table__.c[column].type)
+                        if not isinstance(attrs[column], expression.FunctionElement)
+                        else attrs[column],
+                    )
+                    for job_id, attrs in job_data.items()
+                    if column in attrs
+                ],
+                else_=getattr(Jobs.__table__.c, column),  # Retain original value
+            )
+            for column in columns
+        }
 
-        await self.conn.execute(
-            Jobs.__table__.update().where(
-                Jobs.__table__.c.JobID == bindparam("b_JobID")
-            ),
-            [{"b_JobID": job_id, **attrs} for job_id, attrs in jobData.items()],
+        stmt = (
+            Jobs.__table__.update()
+            .values(**case_expressions)
+            .where(Jobs.__table__.c.JobID.in_(job_data.keys()))
         )
+        await self.conn.execute(stmt)
 
-    async def getJobJDL(self, job_id: int, original: bool = False) -> str:
-        from DIRAC.WorkloadManagementSystem.DB.JobDBUtils import extractJDL
-
-        if original:
-            stmt = select(JobJDLs.OriginalJDL).where(JobJDLs.JobID == job_id)
-        else:
-            stmt = select(JobJDLs.JDL).where(JobJDLs.JobID == job_id)
-
-        jdl = (await self.conn.execute(stmt)).scalar_one()
-        if jdl:
-            jdl = extractJDL(jdl)
-
-        return jdl
-
-    async def getJobJDLs(self, job_ids, original: bool = False) -> dict[int | str, str]:
-        from DIRAC.WorkloadManagementSystem.DB.JobDBUtils import extractJDL
-
+    async def get_job_jdls(self, job_ids, original: bool = False) -> dict[int, str]:
+        """Get the JDLs for the given jobs."""
         if original:
-            stmt = select(JobJDLs.JobID, JobJDLs.OriginalJDL).where(
-                JobJDLs.JobID.in_(job_ids)
+            stmt = select(JobJDLs.job_id, JobJDLs.original_jdl).where(
+                JobJDLs.job_id.in_(job_ids)
             )
         else:
-            stmt = select(JobJDLs.JobID, JobJDLs.JDL).where(JobJDLs.JobID.in_(job_ids))
-
-        return {
-            jobid: extractJDL(jdl)
-            for jobid, jdl in (await self.conn.execute(stmt))
-            if jdl
-        }
-
-    async def get_job_status(self, job_id: int) -> LimitedJobStatusReturn:
-        try:
-            stmt = select(Jobs.Status, Jobs.MinorStatus, Jobs.ApplicationStatus).where(
-                Jobs.JobID == job_id
+            stmt = select(JobJDLs.job_id, JobJDLs.jdl).where(
+                JobJDLs.job_id.in_(job_ids)
             )
-            return LimitedJobStatusReturn(
-                **dict((await self.conn.execute(stmt)).one()._mapping)
-            )
-        except NoResultFound as e:
-            raise JobNotFound(job_id) from e
 
-    async def set_job_command(self, job_id: int, command: str, arguments: str = ""):
-        """Store a command to be passed to the job together with the next heart beat."""
-        try:
-            stmt = insert(JobCommands).values(
-                JobID=job_id,
-                Command=command,
-                Arguments=arguments,
-                ReceptionTime=datetime.now(tz=timezone.utc),
-            )
-            await self.conn.execute(stmt)
-        except IntegrityError as e:
-            raise JobNotFound(job_id) from e
+        return {jobid: jdl for jobid, jdl in (await self.conn.execute(stmt)) if jdl}
 
-    async def set_job_command_bulk(self, commands):
+    async def set_job_commands(self, commands: list[tuple[int, str, str]]) -> None:
         """Store a command to be passed to the job together with the next heart beat."""
-        self.conn.execute(
-            insert(JobCommands),
+        await self.conn.execute(
+            JobCommands.__table__.insert(),
             [
                 {
                     "JobID": job_id,
@@ -295,12 +196,6 @@ class JobDB(BaseSQLDB):
                 for job_id, command, arguments in commands
             ],
         )
-        # FIXME handle IntegrityError
-
-    async def delete_jobs(self, job_ids: list[int]):
-        """Delete jobs from the database."""
-        stmt = delete(JobJDLs).where(JobJDLs.JobID.in_(job_ids))
-        await self.conn.execute(stmt)
 
     async def set_properties(
         self, properties: dict[int, dict[str, Any]], update_timestamp: bool = False
@@ -332,7 +227,62 @@ class JobDB(BaseSQLDB):
         if update_timestamp:
             values["LastUpdateTime"] = datetime.now(tz=timezone.utc)
 
-        stmt = update(Jobs).where(Jobs.JobID == bindparam("job_id")).values(**values)
+        stmt = update(Jobs).where(Jobs.job_id == bindparam("job_id")).values(**values)
         rows = await self.conn.execute(stmt, update_parameters)
 
         return rows.rowcount
+
+    async def add_heartbeat_data(
+        self, job_id: int, dynamic_data: dict[str, str]
+    ) -> None:
+        """Add the job's heartbeat data to the database.
+
+        NOTE: This does not update the HeartBeatTime column in the Jobs table.
+        This is instead handled by the `diracx.logic.jobs.status.set_job_statuses`
+        as it involves updating multiple databases.
+
+        :param job_id: the job id
+        :param dynamic_data: mapping of the dynamic data to store,
+            e.g. {"AvailableDiskSpace": 123}
+        """
+        if extra_fields := set(dynamic_data) - self.heartbeat_fields:
+            raise InvalidQueryError(
+                f"Not allowed to store heartbeat data for: {extra_fields}. "
+                f"Allowed keys are: {self.heartbeat_fields}"
+            )
+        values = [
+            {
+                "JobID": job_id,
+                "Name": key,
+                "Value": value,
+                "HeartBeatTime": utcnow(),
+            }
+            for key, value in dynamic_data.items()
+        ]
+        await self.conn.execute(HeartBeatLoggingInfo.__table__.insert().values(values))
+
+    async def get_job_commands(self, job_ids: Iterable[int]) -> list[JobCommand]:
+        """Get a command to be passed to the job together with the next heartbeat.
+
+        :param job_ids: the job ids
+        :return: mapping of job id to list of commands
+        """
+        # Get the commands
+        stmt = (
+            select(JobCommands.job_id, JobCommands.command, JobCommands.arguments)
+            .where(JobCommands.job_id.in_(job_ids), JobCommands.status == "Received")
+            .order_by(JobCommands.job_id)
+        )
+        commands = await self.conn.execute(stmt)
+        # Update the status of the commands
+        stmt = (
+            update(JobCommands)
+            .where(JobCommands.job_id.in_(job_ids))
+            .values(Status="Sent")
+        )
+        await self.conn.execute(stmt)
+        # Return the commands grouped by job id
+        return [
+            JobCommand(job_id=cmd.JobID, command=cmd.Command, arguments=cmd.Arguments)
+            for cmd in commands
+        ]

diracx/db/sql/job/schema.py

@@ -1,6 +1,7 @@
+from __future__ import annotations
+
+import sqlalchemy.types as types
 from sqlalchemy import (
-    DateTime,
-    Enum,
     ForeignKey,
     Index,
     Integer,
@@ -9,44 +10,88 @@ from sqlalchemy import (
 )
 from sqlalchemy.orm import declarative_base
 
+from diracx.db.sql.utils.types import SmarterDateTime
+
 from ..utils import Column, EnumBackedBool, NullColumn
 
 JobDBBase = declarative_base()
 
 
+class AccountedFlagEnum(types.TypeDecorator):
+    """Maps a ``AccountedFlagEnum()`` column to True/False in Python."""
+
+    impl = types.Enum("True", "False", "Failed", name="accounted_flag_enum")
+    cache_ok = True
+
+    def process_bind_param(self, value, dialect) -> str:
+        if value is True:
+            return "True"
+        elif value is False:
+            return "False"
+        elif value == "Failed":
+            return "Failed"
+        else:
+            raise NotImplementedError(value, dialect)
+
+    def process_result_value(self, value, dialect) -> bool | str:
+        if value == "True":
+            return True
+        elif value == "False":
+            return False
+        elif value == "Failed":
+            return "Failed"
+        else:
+            raise NotImplementedError(f"Unknown {value=}")
+
+
 class Jobs(JobDBBase):
     __tablename__ = "Jobs"
 
-    JobID = Column(
+    job_id = Column(
         "JobID",
         Integer,
         ForeignKey("JobJDLs.JobID", ondelete="CASCADE"),
         primary_key=True,
         default=0,
     )
-    JobType = Column("JobType", String(32), default="user")
-    JobGroup = Column("JobGroup", String(32), default="00000000")
-    Site = Column("Site", String(100), default="ANY")
-    JobName = Column("JobName", String(128), default="Unknown")
-    Owner = Column("Owner", String(64), default="Unknown")
-    OwnerGroup = Column("OwnerGroup", String(128), default="Unknown")
-    VO = Column("VO", String(32))
-    SubmissionTime = NullColumn("SubmissionTime", DateTime)
-    RescheduleTime = NullColumn("RescheduleTime", DateTime)
-    LastUpdateTime = NullColumn("LastUpdateTime", DateTime)
-    StartExecTime = NullColumn("StartExecTime", DateTime)
-    HeartBeatTime = NullColumn("HeartBeatTime", DateTime)
-    EndExecTime = NullColumn("EndExecTime", DateTime)
-    Status = Column("Status", String(32), default="Received")
-    MinorStatus = Column("MinorStatus", String(128), default="Unknown")
-    ApplicationStatus = Column("ApplicationStatus", String(255), default="Unknown")
-    UserPriority = Column("UserPriority", Integer, default=0)
-    RescheduleCounter = Column("RescheduleCounter", Integer, default=0)
-    VerifiedFlag = Column("VerifiedFlag", EnumBackedBool(), default=False)
-    # TODO: Should this be True/False/"Failed"? Or True/False/Null?
-    AccountedFlag = Column(
-        "AccountedFlag", Enum("True", "False", "Failed"), default="False"
+    job_type = Column("JobType", String(32), default="user")
+    job_group = Column("JobGroup", String(32), default="00000000")
+    site = Column("Site", String(100), default="ANY")
+    job_name = Column("JobName", String(128), default="Unknown")
+    owner = Column("Owner", String(64), default="Unknown")
+    owner_group = Column("OwnerGroup", String(128), default="Unknown")
+    vo = Column("VO", String(32))
+    submission_time = NullColumn(
+        "SubmissionTime",
+        SmarterDateTime(),
+    )
+    reschedule_time = NullColumn(
+        "RescheduleTime",
+        SmarterDateTime(),
+    )
+    last_update_time = NullColumn(
+        "LastUpdateTime",
+        SmarterDateTime(),
     )
+    start_exec_time = NullColumn(
+        "StartExecTime",
+        SmarterDateTime(),
+    )
+    heart_beat_time = NullColumn(
+        "HeartBeatTime",
+        SmarterDateTime(),
+    )
+    end_exec_time = NullColumn(
+        "EndExecTime",
+        SmarterDateTime(),
+    )
+    status = Column("Status", String(32), default="Received")
+    minor_status = Column("MinorStatus", String(128), default="Unknown")
+    application_status = Column("ApplicationStatus", String(255), default="Unknown")
+    user_priority = Column("UserPriority", Integer, default=0)
+    reschedule_counter = Column("RescheduleCounter", Integer, default=0)
+    verified_flag = Column("VerifiedFlag", EnumBackedBool(), default=False)
+    accounted_flag = Column("AccountedFlag", AccountedFlagEnum(), default=False)
 
     __table_args__ = (
         Index("JobType", "JobType"),
@@ -64,66 +109,77 @@ class Jobs(JobDBBase):
 
 class JobJDLs(JobDBBase):
     __tablename__ = "JobJDLs"
-    JobID = Column(Integer, autoincrement=True, primary_key=True)
-    JDL = Column(Text)
-    JobRequirements = Column(Text)
-    OriginalJDL = Column(Text)
+    job_id = Column("JobID", Integer, autoincrement=True, primary_key=True)
+    jdl = Column("JDL", Text)
+    job_requirements = Column("JobRequirements", Text)
+    original_jdl = Column("OriginalJDL", Text)
 
 
 class InputData(JobDBBase):
     __tablename__ = "InputData"
-    JobID = Column(
-        Integer, ForeignKey("Jobs.JobID", ondelete="CASCADE"), primary_key=True
+    job_id = Column(
+        "JobID", Integer, ForeignKey("Jobs.JobID", ondelete="CASCADE"), primary_key=True
     )
-    LFN = Column(String(255), default="", primary_key=True)
-    Status = Column(String(32), default="AprioriGood")
+    lfn = Column("LFN", String(255), default="", primary_key=True)
+    status = Column("Status", String(32), default="AprioriGood")
 
 
 class JobParameters(JobDBBase):
     __tablename__ = "JobParameters"
-    JobID = Column(
-        Integer, ForeignKey("Jobs.JobID", ondelete="CASCADE"), primary_key=True
+    job_id = Column(
+        "JobID", Integer, ForeignKey("Jobs.JobID", ondelete="CASCADE"), primary_key=True
     )
-    Name = Column(String(100), primary_key=True)
-    Value = Column(Text)
+    name = Column("Name", String(100), primary_key=True)
+    value = Column("Value", Text)
 
 
 class OptimizerParameters(JobDBBase):
     __tablename__ = "OptimizerParameters"
-    JobID = Column(
-        Integer, ForeignKey("Jobs.JobID", ondelete="CASCADE"), primary_key=True
+    job_id = Column(
+        "JobID", Integer, ForeignKey("Jobs.JobID", ondelete="CASCADE"), primary_key=True
     )
-    Name = Column(String(100), primary_key=True)
-    Value = Column(Text)
+    name = Column("Name", String(100), primary_key=True)
+    value = Column("Value", Text)
 
 
 class AtticJobParameters(JobDBBase):
     __tablename__ = "AtticJobParameters"
-    JobID = Column(
-        Integer, ForeignKey("Jobs.JobID", ondelete="CASCADE"), primary_key=True
+    job_id = Column(
+        "JobID", Integer, ForeignKey("Jobs.JobID", ondelete="CASCADE"), primary_key=True
     )
-    Name = Column(String(100), primary_key=True)
-    Value = Column(Text)
-    RescheduleCycle = Column(Integer)
+    name = Column("Name", String(100), primary_key=True)
+    value = Column("Value", Text)
+    reschedule_cycle = Column("RescheduleCycle", Integer)
 
 
 class HeartBeatLoggingInfo(JobDBBase):
     __tablename__ = "HeartBeatLoggingInfo"
-    JobID = Column(
-        Integer, ForeignKey("Jobs.JobID", ondelete="CASCADE"), primary_key=True
+    job_id = Column(
+        "JobID", Integer, ForeignKey("Jobs.JobID", ondelete="CASCADE"), primary_key=True
+    )
+    name = Column("Name", String(100), primary_key=True)
+    value = Column("Value", Text)
+    heart_beat_time = Column(
+        "HeartBeatTime",
+        SmarterDateTime(),
+        primary_key=True,
     )
-    Name = Column(String(100), primary_key=True)
-    Value = Column(Text)
-    HeartBeatTime = Column(DateTime, primary_key=True)
 
 
 class JobCommands(JobDBBase):
     __tablename__ = "JobCommands"
-    JobID = Column(
-        Integer, ForeignKey("Jobs.JobID", ondelete="CASCADE"), primary_key=True
-    )
-    Command = Column(String(100))
-    Arguments = Column(String(100))
-    Status = Column(String(64), default="Received")
-    ReceptionTime = Column(DateTime, primary_key=True)
-    ExecutionTime = NullColumn(DateTime)
+    job_id = Column(
+        "JobID", Integer, ForeignKey("Jobs.JobID", ondelete="CASCADE"), primary_key=True
+    )
+    command = Column("Command", String(100))
+    arguments = Column("Arguments", String(100))
+    status = Column("Status", String(64), default="Received")
+    reception_time = Column(
+        "ReceptionTime",
+        SmarterDateTime(),
+        primary_key=True,
+    )
+    execution_time = NullColumn(
+        "ExecutionTime",
+        SmarterDateTime(),
+    )