Simplify reserve() to use update1

- reserve() now uses update1 instead of raw SQL
- Remove status='pending' check since populate verifies this
- Change return type from bool to None
- Update autopopulate.py to not check reserve return value
- Update tests to reflect new behavior

Author: claude

src/datajoint/autopopulate.py

@@ -390,9 +390,9 @@ def _populate1(self, key, jobs, suppress_errors, return_exception_objects, make_
         job_key = self._job_key(key)
         start_time = time.time()
 
-        # Try to reserve the job (per-key, before make)
-        if jobs is not None and not jobs.reserve(job_key):
-            return False
+        # Reserve the job (per-key, before make)
+        if jobs is not None:
+            jobs.reserve(job_key)
 
         # if make is a generator, transaction can be delayed until the final stage
         is_generator = inspect.isgeneratorfunction(make)

src/datajoint/jobs.py

@@ -328,41 +328,31 @@ def _insert_job_with_delay(self, key: dict, priority: int, delay: float) -> None
         """
         self.connection.query(sql)
 
-    def reserve(self, key: dict) -> bool:
+    def reserve(self, key: dict) -> None:
         """
-        Attempt to reserve a job for processing.
+        Reserve a job for processing.
 
-        Updates status to 'reserved' if currently 'pending' and scheduled_time <= now.
+        Updates the job record to 'reserved' status. The caller (populate) is
+        responsible for verifying the job is pending before calling this method.
 
         Args:
             key: Primary key dict for the job
-
-        Returns:
-            True if reservation successful, False if job not found or not pending.
         """
         self._ensure_declared()
 
-        # Build WHERE clause for the key
         pk_attrs = [name for name, _ in self._get_fk_derived_primary_key()]
-        key_conditions = " AND ".join(
-            f"`{attr}`='{key[attr]}'" if isinstance(key[attr], str) else f"`{attr}`={key[attr]}" for attr in pk_attrs
-        )
+        job_key = {attr: key[attr] for attr in pk_attrs if attr in key}
 
-        # Attempt atomic update: pending -> reserved
-        sql = f"""
-            UPDATE {self.full_table_name}
-            SET status='reserved',
-                reserved_time=NOW(6),
-                user='{self._user}',
-                host='{platform.node()}',
-                pid={os.getpid()},
-                connection_id={self.connection.connection_id}
-            WHERE {key_conditions}
-              AND status='pending'
-              AND scheduled_time <= NOW(6)
-        """
-        result = self.connection.query(sql)
-        return result.rowcount > 0
+        update_row = {
+            **job_key,
+            "status": "reserved",
+            "reserved_time": datetime.now(),
+            "user": self._user,
+            "host": platform.node(),
+            "pid": os.getpid(),
+            "connection_id": self.connection.connection_id,
+        }
+        self.update1(update_row)
 
     def complete(self, key: dict, duration: float = None, keep: bool = None) -> None:
         """

tests/test_jobs.py

@@ -97,32 +97,30 @@ def test_reserve_pending_job(self, schema_any):
 
         # Get first pending job
         key = jobs.pending.fetch("KEY", limit=1)[0]
-        assert jobs.reserve(key)
+        jobs.reserve(key)
 
         # Verify status changed
         status = (jobs & key).fetch1("status")
         assert status == "reserved"
 
-    def test_reserve_already_reserved(self, schema_any):
-        """Test that reserve() returns False for already reserved job."""
+    def test_reserve_sets_metadata(self, schema_any):
+        """Test that reserve() sets user, host, pid, connection_id."""
         table = schema.SigIntTable()
         jobs = table.jobs
         jobs.delete()
         jobs.refresh()
 
         key = jobs.pending.fetch("KEY", limit=1)[0]
-        assert jobs.reserve(key)
-        assert not jobs.reserve(key)  # Second reserve should fail
-
-    def test_reserve_scheduled_future(self, schema_any):
-        """Test that reserve() fails for jobs scheduled in the future."""
-        table = schema.SigIntTable()
-        jobs = table.jobs
-        jobs.delete()
-        jobs.refresh(delay=3600)  # 1 hour delay
+        jobs.reserve(key)
 
-        key = jobs.fetch("KEY", limit=1)[0]
-        assert not jobs.reserve(key)  # Should fail - not yet scheduled
+        # Verify metadata was set
+        row = (jobs & key).fetch1()
+        assert row["status"] == "reserved"
+        assert row["reserved_time"] is not None
+        assert row["user"] != ""
+        assert row["host"] != ""
+        assert row["pid"] > 0
+        assert row["connection_id"] > 0
 
 
 class TestJobsComplete: