Feat/swap to sqlalchemy (#99)

* chore: wip swap to sqlalchemy

* feat: swap to sqlalchemy

* feat: swap to sqlalchemy

* feat: swap to sqlalchemy

* feat: swap to sqlalchemy

api/backend/database/queries/__init__.py

@@ -1,4 +0,0 @@
-# LOCAL
-from .job.job_queries import DELETE_JOB_QUERY, JOB_INSERT_QUERY
-
-__all__ = ["JOB_INSERT_QUERY", "DELETE_JOB_QUERY"]

api/backend/database/queries/job/job_queries.py

@@ -2,62 +2,61 @@
 import logging
 from typing import Any
 
+# PDM
+from sqlalchemy import delete as sql_delete
+from sqlalchemy import select
+from sqlalchemy import update as sql_update
+
 # LOCAL
-from api.backend.database.utils import format_list_for_query
-from api.backend.database.common import query, insert, update
-
-JOB_INSERT_QUERY = """
-INSERT INTO jobs 
-(id, url, elements, user, time_created, result, status, chat, job_options, agent_mode, prompt)
-VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-"""
-
-DELETE_JOB_QUERY = """
-DELETE FROM jobs WHERE id IN ()
-"""
+from api.backend.database.base import AsyncSessionLocal
+from api.backend.database.models import Job
 
 LOG = logging.getLogger("Database")
 
 
-def insert_job(item: dict[str, Any]) -> None:
-    insert(
-        JOB_INSERT_QUERY,
-        (
-            item["id"],
-            item["url"],
-            item["elements"],
-            item["user"],
-            item["time_created"],
-            item["result"],
-            item["status"],
-            item["chat"],
-            item["job_options"],
-            item["agent_mode"],
-            item["prompt"],
-        ),
-    )
-    LOG.info(f"Inserted item: {item}")
+async def insert_job(item: dict[str, Any]) -> None:
+    async with AsyncSessionLocal() as session:
+        job = Job(
+            id=item["id"],
+            url=item["url"],
+            elements=item["elements"],
+            user=item["user"],
+            time_created=item["time_created"],
+            result=item["result"],
+            status=item["status"],
+            chat=item["chat"],
+            job_options=item["job_options"],
+            agent_mode=item["agent_mode"],
+            prompt=item["prompt"],
+        )
+        session.add(job)
+        await session.commit()
+        LOG.info(f"Inserted item: {item}")
 
 
 async def get_queued_job():
-    queued_job_query = (
-        "SELECT * FROM jobs WHERE status = 'Queued' ORDER BY time_created DESC LIMIT 1"
-    )
-
-    res = query(queued_job_query)
-    LOG.info(f"Got queued job: {res}")
-    return res[0] if res else None
+    async with AsyncSessionLocal() as session:
+        stmt = (
+            select(Job)
+            .where(Job.status == "Queued")
+            .order_by(Job.time_created.desc())
+            .limit(1)
+        )
+        result = await session.execute(stmt)
+        job = result.scalars().first()
+        LOG.info(f"Got queued job: {job}")
+        return job
 
 
 async def update_job(ids: list[str], updates: dict[str, Any]):
     if not updates:
         return
 
-    set_clause = ", ".join(f"{field} = ?" for field in updates.keys())
-    query = f"UPDATE jobs SET {set_clause} WHERE id IN {format_list_for_query(ids)}"
-    values = list(updates.values()) + ids
-    res = update(query, tuple(values))
-    LOG.debug(f"Updated job: {res}")
+    async with AsyncSessionLocal() as session:
+        stmt = sql_update(Job).where(Job.id.in_(ids)).values(**updates)
+        result = await session.execute(stmt)
+        await session.commit()
+        LOG.debug(f"Updated job count: {result.rowcount}")
 
 
 async def delete_jobs(jobs: list[str]):
@@ -65,9 +64,9 @@ async def delete_jobs(jobs: list[str]):
         LOG.info("No jobs to delete.")
         return False
 
-    query = f"DELETE FROM jobs WHERE id IN {format_list_for_query(jobs)}"
-    res = update(query, tuple(jobs))
-
-    LOG.info(f"Deleted jobs: {res}")
-
-    return res
+    async with AsyncSessionLocal() as session:
+        stmt = sql_delete(Job).where(Job.id.in_(jobs))
+        result = await session.execute(stmt)
+        await session.commit()
+        LOG.info(f"Deleted jobs count: {result.rowcount}")
+        return result.rowcount

api/backend/database/queries/statistics/statistic_queries.py

@@ -1,41 +1,43 @@
+# PDM
+from sqlalchemy import func, select
+from sqlalchemy.ext.asyncio import AsyncSession
+
 # LOCAL
-from api.backend.database.common import query
+from api.backend.database.models import Job
 
 
-async def average_elements_per_link(user: str):
-    job_query = """
-    SELECT 
-        DATE(time_created) AS date,
-        AVG(json_array_length(elements)) AS average_elements,
-        COUNT(*) AS count
-    FROM 
-        jobs
-    WHERE 
-        status = 'Completed' AND user = ?
-    GROUP BY 
-        DATE(time_created)
-    ORDER BY 
-        date ASC;
-    """
-    results = query(job_query, (user,))
+async def average_elements_per_link(session: AsyncSession, user_email: str):
+    date_func = func.date(Job.time_created)
 
-    return results
+    stmt = (
+        select(
+            date_func.label("date"),
+            func.avg(func.json_array_length(Job.elements)).label("average_elements"),
+            func.count().label("count"),
+        )
+        .where(Job.status == "Completed", Job.user == user_email)
+        .group_by(date_func)
+        .order_by("date")
+    )
+
+    result = await session.execute(stmt)
+    rows = result.all()
+    return [dict(row._mapping) for row in rows]
 
 
-async def get_jobs_per_day(user: str):
-    job_query = """
-    SELECT 
-        DATE(time_created) AS date,
-        COUNT(*) AS job_count
-    FROM 
-        jobs
-    WHERE 
-        status = 'Completed' AND user = ?
-    GROUP BY 
-        DATE(time_created)
-    ORDER BY 
-        date ASC;
-    """
-    results = query(job_query, (user,))
+async def get_jobs_per_day(session: AsyncSession, user_email: str):
+    date_func = func.date(Job.time_created)
 
-    return results
+    stmt = (
+        select(
+            date_func.label("date"),
+            func.count().label("job_count"),
+        )
+        .where(Job.status == "Completed", Job.user == user_email)
+        .group_by(date_func)
+        .order_by("date")
+    )
+
+    result = await session.execute(stmt)
+    rows = result.all()
+    return [dict(row._mapping) for row in rows]