use postgres

src/allocation.py

@@ -102,13 +102,13 @@ class AllocationValidator:
         """Check if users exist in this round (warn for new users)."""
         with db._connect() as conn:
             # Check if assignments table exists
-            cur = conn.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='assignments'")
-            if not cur.fetchone():
+            cur = conn.execute("SELECT to_regclass('public.assignments')")
+            if cur.fetchone()[0] is None:
                 return  # New schema not initialized, skip check
 
             for user in users:
                 cur = conn.execute(
-                    'SELECT COUNT(*) FROM assignments WHERE round_id = ? AND user_id = ?', (round_id, user)
+                    'SELECT COUNT(*) FROM assignments WHERE round_id = %s AND user_id = %s', (round_id, user)
                 )
                 count = cur.fetchone()[0]
                 if count == 0:
@@ -240,7 +240,7 @@ class AllocationEngine:
                 """
                 SELECT item_id
                 FROM assignments
-                WHERE round_id = ? AND user_id = ? AND status = 'pending'
+                WHERE round_id = %s AND user_id = %s AND status = 'pending'
                 ORDER BY assigned_at
                 """,
                 (self.round_id, from_user),
@@ -274,11 +274,11 @@ class AllocationEngine:
         # Execute release
         now = datetime.now(timezone.utc).isoformat()
         with self.db._connect() as conn, self.db._lock:
-            placeholders = ','.join('?' * len(to_release))
+            placeholders = ','.join(['%s'] * len(to_release))
             conn.execute(
                 f"""
                 DELETE FROM assignments
-                WHERE round_id = ? AND user_id = ? AND item_id IN ({placeholders})
+                WHERE round_id = %s AND user_id = %s AND item_id IN ({placeholders})
                 """,
                 (self.round_id, from_user, *to_release),
             )
@@ -290,7 +290,7 @@ class AllocationEngine:
                 (round_id, operation, operator, from_source, to_target, amount_spec,
                  affected_users, affected_count, item_ids_sample, item_ids_hash,
                  dry_run, force, reason, created_at)
-                VALUES (?, 'release', ?, ?, 'pool', ?, ?, ?, ?, ?, 0, 0, ?, ?)
+                VALUES (%s, 'release', %s, %s, 'pool', %s, %s, %s, %s, %s, 0, 0, %s, %s)
                 """,
                 (
                     self.round_id,
@@ -328,12 +328,12 @@ class AllocationEngine:
         """
         # 1. Collect all unique pending tasks from these users (avoid duplicates for redundancy > 1)
         with self.db._connect() as conn:
-            placeholders_users = ','.join('?' * len(users))
+            placeholders_users = ','.join(['%s'] * len(users))
             cur = conn.execute(
                 f"""
                 SELECT DISTINCT item_id
                 FROM assignments
-                WHERE round_id = ? AND user_id IN ({placeholders_users}) AND status = 'pending'
+                WHERE round_id = %s AND user_id IN ({placeholders_users}) AND status = 'pending'
                 """,
                 (self.round_id, *users),
             )
@@ -351,7 +351,7 @@ class AllocationEngine:
                     """
                     SELECT redundancy_required
                     FROM task_config
-                    WHERE round_id = ? AND item_id = ?
+                    WHERE round_id = %s AND item_id = %s
                     """,
                     (self.round_id, item_id),
                 )
@@ -359,12 +359,12 @@ class AllocationEngine:
                 redundancy_required = row[0] if row else 1
 
                 # Count current assignments among rebalance users
-                placeholders = ','.join('?' * len(users))
+                placeholders = ','.join(['%s'] * len(users))
                 cur = conn.execute(
                     f"""
                     SELECT COUNT(*)
                     FROM assignments
-                    WHERE round_id = ? AND item_id = ? AND user_id IN ({placeholders}) AND status = 'pending'
+                    WHERE round_id = %s AND item_id = %s AND user_id IN ({placeholders}) AND status = 'pending'
                     """,
                     (self.round_id, item_id, *users),
                 )
@@ -402,16 +402,16 @@ class AllocationEngine:
                     user_available_tasks[user] = []
                     continue
                 # exclude items that the user already has
-                placeholders = ','.join('?' * len(all_pending))
+                placeholders = ','.join(['%s'] * len(all_pending))
                 cur = conn.execute(
                     f"""
                     SELECT x.item_id
                     FROM (
-                        SELECT ? AS round_id, ? AS user_id
+                        SELECT %s AS round_id, %s AS user_id
                     ) p
                     JOIN (
                         SELECT item_id FROM (
-                            VALUES {','.join(['(?)'] * len(all_pending))}
+                            VALUES {','.join(['(%s)'] * len(all_pending))}
                         ) AS v(item_id)
                     ) AS x ON 1=1
                     WHERE NOT EXISTS (
@@ -443,15 +443,15 @@ class AllocationEngine:
         # 7. Execute rebalance (delete old assignments, insert new ones)
         now = datetime.now(timezone.utc).isoformat()
         with self.db._connect() as conn, self.db._lock:
-            conn.execute('BEGIN IMMEDIATE')
+            conn.execute('BEGIN')
 
             try:
                 # Delete all pending tasks from these users
-                placeholders_users = ','.join('?' * len(users))
+                placeholders_users = ','.join(['%s'] * len(users))
                 conn.execute(
                     f"""
                     DELETE FROM assignments
-                    WHERE round_id = ? AND user_id IN ({placeholders_users}) AND status = 'pending'
+                    WHERE round_id = %s AND user_id IN ({placeholders_users}) AND status = 'pending'
                     """,
                     (self.round_id, *users),
                 )
@@ -465,7 +465,7 @@ class AllocationEngine:
                             """
                             SELECT 1
                             FROM assignments
-                            WHERE round_id = ? AND item_id = ? AND user_id = ?
+                            WHERE round_id = %s AND item_id = %s AND user_id = %s
                             """,
                             (self.round_id, item_id, user),
                         )
@@ -478,7 +478,7 @@ class AllocationEngine:
                             """
                             SELECT COUNT(DISTINCT user_id)
                             FROM assignments
-                            WHERE round_id = ? AND item_id = ?
+                            WHERE round_id = %s AND item_id = %s
                             """,
                             (self.round_id, item_id),
                         )
@@ -489,7 +489,7 @@ class AllocationEngine:
                             """
                             INSERT INTO assignments
                             (round_id, item_id, user_id, status, assigned_at, redundancy_slot)
-                            VALUES (?, ?, ?, 'pending', ?, ?)
+                            VALUES (%s, %s, %s, 'pending', %s, %s)
                             """,
                             (self.round_id, item_id, user, now, next_slot),
                         )
@@ -501,7 +501,7 @@ class AllocationEngine:
                     (round_id, operation, operator, from_source, to_target, amount_spec,
                      affected_users, affected_count, item_ids_sample, item_ids_hash,
                      dry_run, force, reason, created_at)
-                    VALUES (?, 'rebalance', ?, ?, ?, ?, ?, ?, ?, ?, 0, 0, ?, ?)
+                    VALUES (%s, 'rebalance', %s, %s, %s, %s, %s, %s, %s, %s, 0, 0, %s, %s)
                     """,
                     (
                         self.round_id,
@@ -571,23 +571,23 @@ class AllocationEngine:
                         FROM tasks t
                         LEFT JOIN task_config tc
                           ON t.round_id = tc.round_id AND t.item_id = tc.item_id
-                        WHERE t.round_id = ?
+                        WHERE t.round_id = %s
                           -- This specific user doesn't have this task
                           AND NOT EXISTS (
                               SELECT 1
                               FROM assignments a
                               WHERE a.round_id = t.round_id
                                 AND a.item_id = t.item_id
-                                AND a.user_id = ?
+                                AND a.user_id = %s
                           )
                           -- Check redundancy limit (current assignments < required)
                           AND (
                               SELECT COUNT(DISTINCT a2.user_id)
                               FROM assignments a2
                               WHERE a2.round_id = t.round_id AND a2.item_id = t.item_id
-                          ) < COALESCE(tc.redundancy_required, ?)
+                          ) < COALESCE(tc.redundancy_required, %s)
                           -- Check redundancy completion
-                          AND COALESCE(tc.redundancy_completed, 0) < COALESCE(tc.redundancy_required, ?)
+                          AND COALESCE(tc.redundancy_completed, 0) < COALESCE(tc.redundancy_required, %s)
                         ORDER BY t.order_key
                         """,
                         (self.round_id, user, redundancy, redundancy),
@@ -605,9 +605,9 @@ class AllocationEngine:
                         SELECT DISTINCT a1.item_id
                         FROM assignments a1
                         LEFT JOIN task_config tc
-                          ON a1.round_id = tc.round_id AND a1.item_id = a1.item_id
-                        WHERE a1.round_id = ?
-                          AND a1.user_id = ?
+                          ON a1.round_id = tc.round_id AND tc.item_id = a1.item_id
+                        WHERE a1.round_id = %s
+                          AND a1.user_id = %s
                           AND a1.status IN {status_filter}
                           -- This specific target user doesn't have this task
                           AND NOT EXISTS (
@@ -615,16 +615,16 @@ class AllocationEngine:
                               FROM assignments a2
                               WHERE a2.round_id = a1.round_id
                                 AND a2.item_id = a1.item_id
-                                AND a2.user_id = ?
+                                AND a2.user_id = %s
                           )
                           -- Check redundancy limit
                           AND (
                               SELECT COUNT(DISTINCT a3.user_id)
                               FROM assignments a3
                               WHERE a3.round_id = a1.round_id AND a3.item_id = a1.item_id
-                          ) < COALESCE(tc.redundancy_required, ?)
+                          ) < COALESCE(tc.redundancy_required, %s)
                           -- Check redundancy completion
-                          AND COALESCE(tc.redundancy_completed, 0) < COALESCE(tc.redundancy_required, ?)
+                          AND COALESCE(tc.redundancy_completed, 0) < COALESCE(tc.redundancy_required, %s)
                         ORDER BY a1.assigned_at
                         """,
                         (self.round_id, source_user_id, user, redundancy, redundancy),
@@ -825,17 +825,17 @@ class AllocationEngine:
         all_assigned_items = [iid for items in distribution.values() for iid in items]
 
         with self.db._connect() as conn, self.db._lock:
-            conn.execute('BEGIN IMMEDIATE')
+            conn.execute('BEGIN')
 
             try:
                 # 1. If transferring from a user, delete their assignments (no skipped state)
                 if from_source.startswith('user:'):
                     source_user = from_source[5:]
-                    placeholders = ','.join('?' * len(all_assigned_items))
+                    placeholders = ','.join(['%s'] * len(all_assigned_items))
                     conn.execute(
                         f"""
                         DELETE FROM assignments
-                        WHERE round_id = ? AND user_id = ? AND item_id IN ({placeholders})
+                        WHERE round_id = %s AND user_id = %s AND item_id IN ({placeholders})
                         """,
                         (self.round_id, source_user, *all_assigned_items),
                     )
@@ -849,7 +849,7 @@ class AllocationEngine:
                             """
                             SELECT 1
                             FROM assignments
-                            WHERE round_id = ? AND item_id = ? AND user_id = ?
+                            WHERE round_id = %s AND item_id = %s AND user_id = %s
                             """,
                             (self.round_id, item_id, user),
                         )
@@ -862,7 +862,7 @@ class AllocationEngine:
                             """
                             SELECT COUNT(DISTINCT user_id)
                             FROM assignments
-                            WHERE round_id = ? AND item_id = ?
+                            WHERE round_id = %s AND item_id = %s
                             """,
                             (self.round_id, item_id),
                         )
@@ -872,7 +872,7 @@ class AllocationEngine:
                             """
                             INSERT INTO assignments
                             (round_id, item_id, user_id, status, assigned_at, redundancy_slot)
-                            VALUES (?, ?, ?, 'pending', ?, ?)
+                            VALUES (%s, %s, %s, 'pending', %s, %s)
                             """,
                             (self.round_id, item_id, user, now, next_slot),
                         )
@@ -884,7 +884,7 @@ class AllocationEngine:
                     (round_id, operation, operator, from_source, to_target, amount_spec,
                      affected_users, affected_count, item_ids_sample, item_ids_hash,
                      dry_run, force, reason, created_at)
-                    VALUES (?, 'allocate', ?, ?, ?, ?, ?, ?, ?, ?, 0, ?, ?, ?)
+                    VALUES (%s, 'allocate', %s, %s, %s, %s, %s, %s, %s, %s, 0, %s, %s, %s)
                     """,
                     (
                         self.round_id,

src/database.py

@@ -2,13 +2,14 @@
 
 import json
 import os
-import sqlite3
 import subprocess
 import threading
 from contextlib import contextmanager
 from datetime import datetime, timezone
 from typing import Optional
 
+import psycopg2
+import psycopg2.extras
 from huggingface_hub import CommitOperationAdd, HfApi
 
 REQUIRED_TABLES = ('tasks', 'assignments', 'task_config', 'answers', 'allocation_history')
@@ -22,35 +23,158 @@ class DB:
     """Database for the evaluation."""
 
     def __init__(self, db_path: str, schema_path: Optional[str] = None, verify_only: bool = True):
-        """Initialize the database."""
-        os.makedirs(os.path.dirname(db_path) or '.', exist_ok=True)
-        self.db_path = db_path
+        """Initialize the database.
+
+        Note: db_path/schema_path kept for compatibility; Postgres uses env vars.
+        Required env vars: PGHOST, PGPORT, PGUSER, PGPASSWORD, PGDATABASE
+        """
+        self.db_path = db_path  # kept for compatibility
         self._lock = threading.Lock()
 
-        with self._connect() as conn:
-            if schema_path is not None and os.path.exists(schema_path):
-                with open(schema_path, encoding='utf-8') as f:
-                    schema_sql = f.read()
-                conn.executescript(schema_sql)
-            elif verify_only:
+        # Validate environment variables early
+        self._pg_dsn = dict(
+            host=os.environ.get('PGHOST'),
+            port=int(os.environ.get('PGPORT')) if os.environ.get('PGPORT') else None,
+            user=os.environ.get('PGUSER'),
+            password=os.environ.get('PGPASSWORD'),
+            database=os.environ.get('PGDATABASE'),
+        )
+        if not all([self._pg_dsn['host'], self._pg_dsn['user'], self._pg_dsn['password'], self._pg_dsn['database']]):
+            raise OSError('Missing PostgreSQL env vars: PGHOST, PGUSER, PGPASSWORD, PGDATABASE')
+
+        # Verify required tables exist
+        if verify_only:
+            with self._connect() as conn:
                 missing = []
                 for t in REQUIRED_TABLES:
-                    cur = conn.execute('SELECT name FROM sqlite_master WHERE type="table" AND name=?', (t,))
-                    if cur.fetchone() is None:
+                    cur = conn.execute('SELECT to_regclass(%s)', (f'public.{t}',))
+                    exists = cur.fetchone()[0]
+                    if exists is None:
                         missing.append(t)
                 if missing:
                     raise FileNotFoundError(f'Missing required tables: {", ".join(missing)}')
-            else:
-                raise FileNotFoundError(f'SQL schema file not found at: {schema_path or "None"}')
 
     @contextmanager
     def _connect(self):
-        conn = sqlite3.connect(self.db_path, timeout=30, isolation_level=None)  # autocommit
-        conn.execute('PRAGMA foreign_keys=ON;')
+        """Context manager yielding a lightweight wrapper with conn.execute(...).
+
+        - Uses psycopg2 with autocommit by default (emulates sqlite autocommit usage).
+        - Supports BEGIN/COMMIT/ROLLBACK issued via execute for backward compatibility.
+        """
+
+        class _CursorWrapper:
+            def __init__(self, cursor):
+                self._cursor = cursor
+
+            def fetchone(self):
+                return self._cursor.fetchone()
+
+            def fetchall(self):
+                return self._cursor.fetchall()
+
+            @property
+            def rowcount(self):
+                return self._cursor.rowcount
+
+        class _ConnWrapper:
+            def __init__(self, real_conn):
+                self._conn = real_conn
+
+            def execute(self, sql: str, params: tuple | list | None = None):
+                sql_strip = (sql or '').strip().upper()
+                # Map transaction control statements
+                if sql_strip.startswith('BEGIN'):
+                    self._conn.autocommit = False
+                    with self._conn.cursor() as c:
+                        c.execute('BEGIN;')
+                    # Return dummy wrapper
+                    return _CursorWrapper(c)
+                if sql_strip == 'COMMIT':
+                    try:
+                        self._conn.commit()
+                    finally:
+                        self._conn.autocommit = True
+                    # Return a cursor with no data
+                    with self._conn.cursor() as c:
+                        return _CursorWrapper(c)
+                if sql_strip == 'ROLLBACK':
+                    try:
+                        self._conn.rollback()
+                    finally:
+                        self._conn.autocommit = True
+                    with self._conn.cursor() as c:
+                        return _CursorWrapper(c)
+
+                # Regular statement
+                with self._conn.cursor() as c:
+                    c.execute(sql, params or ())
+                    # For SELECTs, we need a cursor able to fetch after context ends.
+                    # Use named cursor copy via RealDictCursor? Simpler: re-execute on a new cursor kept open.
+                    # Instead, materialize results if it's a query returning rows.
+                    if c.description is not None:
+                        rows = c.fetchall()
+
+                        # Create a lightweight object mimicking cursor
+                        class _Mat:
+                            def __init__(self, rows):
+                                self._rows = rows
+
+                            def fetchone(self):
+                                return self._rows[0] if self._rows else None
+
+                            def fetchall(self):
+                                return list(self._rows)
+
+                            @property
+                            def rowcount(self):
+                                return len(self._rows)
+
+                        return _Mat(rows)
+                    else:
+                        # Non-SELECT: return wrapper with rowcount captured
+                        rc = c.rowcount
+
+                        class _Affect:
+                            def __init__(self, rc):
+                                self._rc = rc
+
+                            def fetchone(self):
+                                return None
+
+                            def fetchall(self):
+                                return []
+
+                            @property
+                            def rowcount(self):
+                                return self._rc
+
+                        return _Affect(rc)
+
+            def __enter__(self):
+                return self
+
+            def __exit__(self, exc_type, exc, tb):
+                # If a transaction is open and no explicit commit/rollback occurred, rollback on error
+                if not self._conn.autocommit:
+                    if exc is None:
+                        self._conn.commit()
+                    else:
+                        self._conn.rollback()
+                self._conn.close()
+
+        # Open a new psycopg2 connection per context
+        conn = psycopg2.connect(**{k: v for k, v in self._pg_dsn.items() if v is not None})
+        conn.autocommit = True
+        wrapper = _ConnWrapper(conn)
         try:
-            yield conn
+            yield wrapper
         finally:
-            conn.close()
+            # _ConnWrapper.__exit__ handles close when used with "with". If not, ensure close here.
+            try:
+                if not conn.closed:
+                    conn.close()
+            except Exception:
+                pass
 
     # ========== Answer Recording ==========
 
@@ -68,9 +192,15 @@ class DB:
         now = _get_time_now()
         with self._connect() as conn, self._lock:
             conn.execute(
-                'INSERT OR REPLACE INTO answers(round_id, user_id, item_id, label, image_path, '
-                'score, words_not_present, answered_at) '
-                'VALUES(?,?,?,?,?,?,?,?)',
+                (
+                    'INSERT INTO answers (round_id, user_id, item_id, label, image_path, '
+                    'score, words_not_present, answered_at) '
+                    'VALUES (%s, %s, %s, %s, %s, %s, %s, %s) '
+                    'ON CONFLICT (round_id, user_id, item_id) DO UPDATE SET '
+                    'score = EXCLUDED.score, '
+                    'words_not_present = EXCLUDED.words_not_present, '
+                    'answered_at = EXCLUDED.answered_at'
+                ),
                 (
                     round_id,
                     user_id,
@@ -87,7 +217,7 @@ class DB:
         """Get all the answered item ids of a user in a round."""
         with self._connect() as conn:
             cur = conn.execute(
-                'SELECT item_id FROM answers WHERE round_id=? AND user_id=?',
+                'SELECT item_id FROM answers WHERE round_id=%s AND user_id=%s',
                 (round_id, user_id),
             )
             return {r[0] for r in cur.fetchall()}  # fetchall returns a list of tuples
@@ -102,7 +232,7 @@ class DB:
         """
         with self._connect() as conn:
             cur = conn.execute(
-                'SELECT score, words_not_present FROM answers WHERE round_id=? AND user_id=? AND item_id=?',
+                'SELECT score, words_not_present FROM answers WHERE round_id=%s AND user_id=%s AND item_id=%s',
                 (round_id, user_id, item_id),
             )
             row = cur.fetchone()
@@ -125,9 +255,9 @@ class DB:
                 """
                 UPDATE assignments
                 SET status = 'pending', lease_until = NULL, started_at = NULL
-                WHERE round_id = ?
-                AND status = 'in_progress'
-                AND lease_until < ?
+                WHERE round_id = %s
+                  AND status = 'in_progress'
+                  AND lease_until < %s
                 """,
                 (round_id, now),
             )
@@ -139,7 +269,6 @@ class DB:
         space_id = os.getenv('SPACE_ID', None)
         if not space_id:
             return
-
         try:
             repo_root = subprocess.run(
                 ['git', 'rev-parse', '--show-toplevel'],

src/eval_server.py

@@ -211,7 +211,7 @@ def app_main(args) -> None:
                     SELECT t.item_id, t.label, t.path, t.words, t.order_key, a.status
                     FROM assignments a
                     JOIN tasks t ON a.round_id = t.round_id AND a.item_id = t.item_id
-                    WHERE a.round_id = ? AND a.user_id = ?
+                    WHERE a.round_id = %s AND a.user_id = %s
                     ORDER BY t.order_key
                     """,
                     (args.round_id, user_id),
@@ -428,7 +428,7 @@ def app_main(args) -> None:
             # Get item info
             with db._connect() as conn:
                 cur = conn.execute(
-                    'SELECT label, path FROM tasks WHERE round_id = ? AND item_id = ?',
+                    'SELECT label, path FROM tasks WHERE round_id = %s AND item_id = %s',
                     (args.round_id, current_item_id),
                 )
                 row = cur.fetchone()
@@ -450,8 +450,8 @@ def app_main(args) -> None:
                 conn.execute(
                     """
                     UPDATE assignments
-                    SET status = 'completed', completed_at = ?, lease_until = NULL
-                    WHERE round_id = ? AND item_id = ? AND user_id = ?
+                    SET status = 'completed', completed_at = %s, lease_until = NULL
+                    WHERE round_id = %s AND item_id = %s AND user_id = %s
                     """,
                     (now, args.round_id, current_item_id, user_id),
                 )
@@ -462,9 +462,9 @@ def app_main(args) -> None:
                     UPDATE task_config
                     SET redundancy_completed = (
                         SELECT COUNT(*) FROM assignments
-                        WHERE round_id = ? AND item_id = ? AND status = 'completed'
+                        WHERE round_id = %s AND item_id = %s AND status = 'completed'
                     )
-                    WHERE round_id = ? AND item_id = ?
+                    WHERE round_id = %s AND item_id = %s
                     """,
                     (args.round_id, current_item_id, args.round_id, current_item_id),
                 )
@@ -479,16 +479,16 @@ def app_main(args) -> None:
                 (i for i, item in enumerate(items_list) if item['item_id'] == current_item_id), None
             )
 
-            # db auto commit
-            if (
-                args.auto_commit > 0
-                and current_idx_in_list is not None
-                and (current_idx_in_list + 1) % args.auto_commit == 0
-            ):
-                try:
-                    db.commit_and_push_db()
-                except Exception as e:
-                    print(f'Failed to commit and push the database: {e}')
+            # # db auto commit
+            # if (
+            #     args.auto_commit > 0
+            #     and current_idx_in_list is not None
+            #     and (current_idx_in_list + 1) % args.auto_commit == 0
+            # ):
+            #     try:
+            #         db.commit_and_push_db()
+            #     except Exception as e:
+            #         print(f'Failed to commit and push the database: {e}')
 
             if current_idx_in_list is None or current_idx_in_list >= len(items_list) - 1:
                 # This was the last item - show completion message but stay on current item
@@ -546,8 +546,8 @@ def app_main(args) -> None:
                         conn.execute(
                             """
                             UPDATE assignments
-                            SET status = 'in_progress', started_at = ?, lease_until = ?
-                            WHERE round_id = ? AND item_id = ? AND user_id = ?
+                            SET status = 'in_progress', started_at = %s, lease_until = %s
+                            WHERE round_id = %s AND item_id = %s AND user_id = %s
                             """,
                             (now_dt.isoformat(), lease_until, args.round_id, item_id, user_id),
                         )
@@ -559,8 +559,8 @@ def app_main(args) -> None:
                         conn.execute(
                             """
                             UPDATE assignments
-                            SET lease_until = ?
-                            WHERE round_id = ? AND item_id = ? AND user_id = ?
+                            SET lease_until = %s
+                            WHERE round_id = %s AND item_id = %s AND user_id = %s
                             """,
                             (lease_until, args.round_id, item_id, user_id),
                         )