pygpt-net 2.1.37__py3-none-any.whl → 2.4.48__py3-none-any.whl

pygpt_net/provider/core/ctx/db_sqlite/storage.py

@@ -6,23 +6,26 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2024.03.09 21:00:00                  #
+# Updated Date: 2024.12.14 22:00:00                  #
 # ================================================== #
 
 from datetime import datetime
 import re
 import time
+from typing import Dict, Optional, Tuple, List
 
 from sqlalchemy import text
 
-from pygpt_net.item.ctx import CtxMeta, CtxItem
+from pygpt_net.utils import get_tz_offset
+from pygpt_net.item.ctx import CtxMeta, CtxItem, CtxGroup
 from .utils import \
     search_by_date_string, \
     pack_item_value, \
     unpack_meta, \
     unpack_item, \
-    get_month_start_end_timestamps,\
-    get_year_start_end_timestamps
+    get_month_start_end_timestamps, \
+    get_year_start_end_timestamps, \
+    unpack_group
 
 
 class Storage:
@@ -44,11 +47,11 @@ class Storage:
 
     def prepare_query(
             self,
-            search_string: str = None,
-            filters: dict = None,
+            search_string: Optional[str] = None,
+            filters: Optional[dict] = None,
             search_content: bool = False,
             append_date_ranges: bool = True,
-    ):
+    ) -> Tuple[str, str, dict]:
         """
         Prepare query for search_string and filters
 
@@ -62,6 +65,12 @@ class Storage:
         join_clauses = []
         bind_params = {}
 
+        # only base by default
+        where_clauses.append("(m.root_id IS NULL OR m.root_id = 0)")
+
+        # join group
+        join_clauses.append("LEFT JOIN ctx_group g ON m.group_id = g.id")
+
         # search_string
         if search_string:
             date_ranges = search_by_date_string(search_string)
@@ -100,15 +109,16 @@ class Storage:
                     continue
                 mode = filter.get('mode', '=')
                 value = filter.get('value', '')
+                key_name = 'm.' + key
                 if isinstance(value, int):
-                    where_clauses.append(f"{key} {mode} :{key}")
+                    where_clauses.append(f"{key_name} {mode} :{key}")
                     bind_params[key] = value
                 elif isinstance(value, str):
-                    where_clauses.append(f"{key} {mode} :{key}")
+                    where_clauses.append(f"{key_name} {mode} :{key}")
                     bind_params[key] = f"%{value}%"
                 elif isinstance(value, list):
                     values = "(" + ",".join([str(x) for x in value]) + ")"
-                    where_clauses.append(f"{key} {mode} {values}")
+                    where_clauses.append(f"{key_name} {mode} {values}")
 
         where_statement = " AND ".join(where_clauses) if where_clauses else "1"
         join_statement = " ".join(join_clauses) if join_clauses else ""
@@ -117,14 +127,14 @@ class Storage:
 
     def get_meta(
             self,
-            search_string: str = None,
-            order_by: str = None,
-            order_direction: str = None,
-            limit: int = None,
-            offset: int = None,
-            filters: dict = None,
+            search_string: Optional[str] = None,
+            order_by: Optional[str] = None,
+            order_direction: Optional[str] = None,
+            limit: Optional[int] = None,
+            offset: Optional[int] = None,
+            filters: Optional[dict] = None,
             search_content: bool = False,
-    ) -> dict:
+    ) -> Dict[int, CtxMeta]:
         """
         Return dict with CtxMeta objects, indexed by ID
 
@@ -148,8 +158,18 @@ class Storage:
             append_date_ranges=True,
         )
         stmt_text = f"""
-            SELECT m.* FROM ctx_meta m {join_statement} WHERE {where_statement}
-            ORDER BY m.updated_ts DESC {limit_suffix}
+            SELECT 
+                m.*,
+                g.name as group_name,
+                g.uuid as group_uuid,
+                g.additional_ctx_json as group_additional_ctx_json
+            FROM 
+                ctx_meta m 
+                {join_statement} 
+            WHERE 
+                {where_statement}
+            ORDER BY 
+                m.updated_ts DESC {limit_suffix}
         """
         stmt = text(stmt_text).bindparams(**bind_params)
 
@@ -164,14 +184,24 @@ class Storage:
 
         return items
 
-    def get_meta_indexed(self) -> dict:
+    def get_meta_indexed(self) -> Dict[int, CtxMeta]:
         """
         Return dict with indexed CtxMeta objects, indexed by ID
 
         :return: dict of CtxMeta
         """
         stmt_text = f"""
-            SELECT * FROM ctx_meta WHERE indexed_ts > 0
+            SELECT 
+                m.*, 
+                g.name as group_name,
+                g.uuid as group_uuid,
+                g.additional_ctx_json as group_additional_ctx_json 
+            FROM 
+                ctx_meta m 
+            LEFT JOIN 
+                ctx_group g ON m.group_id = g.id
+            WHERE 
+                indexed_ts > 0
         """
         stmt = text(stmt_text)
         items = {}
@@ -184,7 +214,91 @@ class Storage:
                 items[meta.id] = meta
         return items
 
-    def get_items(self, id: int) -> list:
+    def get_item_by_id(self, id: int) -> Optional[CtxItem]:
+        """
+        Return ctx item by ID
+
+        :return: CtxItem
+        """
+        stmt = text("""
+            SELECT * FROM ctx_item WHERE id = :id
+        """).bindparams(id=id)
+        db = self.window.core.db.get_db()
+        with db.connect() as conn:
+            result = conn.execute(stmt)
+            row = result.fetchone()
+            if row:
+                item = CtxItem()
+                unpack_item(item, row._asdict())
+                meta = self.get_meta_by_id(item.meta_id)  # append meta
+                item.meta = meta
+                return item
+        return None
+
+    def get_meta_by_root_id_and_preset_id(
+            self,
+            root_id: int,
+            preset_id: str
+    ) -> Dict[int, CtxMeta]:
+        """
+        Return dict with indexed CtxMeta objects, indexed by ID
+
+        :return: dict of CtxMeta
+        """
+        stmt_text = f"""
+            SELECT * FROM ctx_meta WHERE root_id = :root_id AND preset_id = :preset_id
+        """
+        stmt = text(stmt_text).bindparams(
+            root_id=root_id,
+            preset_id=preset_id,
+        )
+        items = {}
+        db = self.window.core.db.get_db()
+        with db.connect() as conn:
+            result = conn.execute(stmt)
+            for row in result:
+                meta = CtxMeta()
+                unpack_meta(meta, row._asdict())
+                items[meta.id] = meta
+        return items
+
+    def get_meta_by_id(self, id: int) -> Optional[CtxMeta]:
+        """
+        Return ctx meta by ID
+
+        :return: CtxMeta
+        """
+        stmt = text("""
+            SELECT * FROM ctx_meta WHERE id = :id
+        """).bindparams(id=id)
+        db = self.window.core.db.get_db()
+        with db.connect() as conn:
+            result = conn.execute(stmt)
+            row = result.fetchone()
+            if row:
+                meta = CtxMeta()
+                unpack_meta(meta, row._asdict())
+                return meta
+        return None
+
+    def get_last_meta_id(self) -> int:
+        """
+        Return last ctx meta ID
+
+        :return: int
+        """
+        stmt = text("""
+            SELECT id FROM ctx_meta ORDER BY updated_ts DESC LIMIT 1
+        """)
+        db = self.window.core.db.get_db()
+        with db.connect() as conn:
+            result = conn.execute(stmt)
+            row = result.fetchone()
+            if row:
+                return int(row.id)
+        return 0
+
+    def get_items(self, id: int) -> List[CtxItem]:
         """
         Return ctx items list by ctx meta ID
 
@@ -311,7 +425,10 @@ class Storage:
                 is_deleted = :is_deleted,
                 is_important = :is_important,
                 is_archived = :is_archived,
-                label = :label
+                label = :label,
+                root_id = :root_id,
+                parent_id = :parent_id,
+                additional_ctx_json = :additional_ctx_json
             WHERE id = :id
         """).bindparams(
             id=meta.id,
@@ -332,12 +449,38 @@ class Storage:
             is_important=int(meta.important),
             is_archived=int(meta.archived),
             label=int(meta.label),
+            root_id=meta.root_id,
+            parent_id=meta.parent_id,
+            additional_ctx_json=pack_item_value(meta.additional_ctx),
         )
         with db.begin() as conn:
             conn.execute(stmt)
-            return True
 
-    def update_meta_all(self, meta: CtxMeta, items: list) -> bool:
+        # update group
+        if meta.group:
+            stmt = text("""
+                UPDATE ctx_group
+                SET
+                    name = :name,
+                    additional_ctx_json = :additional_ctx_json,
+                    updated_ts = :updated_ts
+                WHERE id = :id
+            """).bindparams(
+                id=meta.group.id,
+                name=meta.group.name,
+                additional_ctx_json=pack_item_value(meta.group.additional_ctx),
+                updated_ts=int(time.time()),
+            )
+            with db.begin() as conn:
+                conn.execute(stmt)
+
+        return True
+
+    def update_meta_all(
+            self,
+            meta: CtxMeta,
+            items: List[CtxItem]
+    ) -> bool:
         """
         Update all, meta and items
 
@@ -545,7 +688,11 @@ class Storage:
                 is_deleted,
                 is_important,
                 is_archived,
-                label
+                label,
+                group_id,
+                root_id,
+                parent_id,
+                additional_ctx_json
             )
             VALUES 
             (
@@ -568,7 +715,11 @@ class Storage:
                 :is_deleted,
                 :is_important,
                 :is_archived,
-                :label
+                :label,
+                :group_id,
+                :root_id,
+                :parent_id,
+                :additional_ctx_json
             )
         """).bindparams(
             uuid=meta.uuid,
@@ -591,6 +742,10 @@ class Storage:
             is_important=int(meta.important),
             is_archived=int(meta.archived),
             label=int(meta.label),
+            group_id=meta.group_id,
+            root_id=meta.root_id,
+            parent_id=meta.parent_id,
+            additional_ctx_json=pack_item_value(meta.additional_ctx),
         )
         with db.begin() as conn:
             result = conn.execute(stmt)
@@ -617,6 +772,8 @@ class Storage:
                 output_name,
                 input_ts,
                 output_ts,
+                hidden_input,
+                hidden_output,
                 mode,
                 model,
                 thread_id,
@@ -628,12 +785,15 @@ class Storage:
                 images_json,
                 files_json,
                 attachments_json,
+                additional_ctx_json,
                 extra,
                 input_tokens,
                 output_tokens,
                 total_tokens,
                 is_internal,
-                docs_json
+                docs_json,
+                audio_id,
+                audio_expires_ts
             )
             VALUES 
             (
@@ -645,6 +805,8 @@ class Storage:
                 :output_name,
                 :input_ts,
                 :output_ts,
+                :hidden_input,
+                :hidden_output,
                 :mode,
                 :model,
                 :thread_id,
@@ -656,12 +818,15 @@ class Storage:
                 :images_json,
                 :files_json,
                 :attachments_json,
+                :additional_ctx_json,
                 :extra,
                 :input_tokens,
                 :output_tokens,
                 :total_tokens,
                 :is_internal,
-                :docs_json
+                :docs_json,
+                :audio_id,
+                :audio_expires_ts
             )
         """).bindparams(
             meta_id=int(meta.id),
@@ -672,6 +837,8 @@ class Storage:
             output_name=item.output_name,
             input_ts=int(item.input_timestamp or 0),
             output_ts=int(item.output_timestamp or 0),
+            hidden_input=item.hidden_input,
+            hidden_output=item.hidden_output,
             mode=item.mode,
             model=item.model,
             thread_id=item.thread,
@@ -683,12 +850,15 @@ class Storage:
             images_json=pack_item_value(item.images),
             files_json=pack_item_value(item.files),
             attachments_json=pack_item_value(item.attachments),
+            additional_ctx_json=pack_item_value(item.additional_ctx),
             extra=pack_item_value(item.extra),
             input_tokens=int(item.input_tokens or 0),
             output_tokens=int(item.output_tokens or 0),
             total_tokens=int(item.total_tokens or 0),
             is_internal=int(item.internal),
             docs_json=pack_item_value(item.doc_ids),
+            audio_id=item.audio_id,
+            audio_expires_ts=int(item.audio_expires_ts or 0)
         )
         with db.begin() as conn:
             result = conn.execute(stmt)
@@ -712,6 +882,8 @@ class Storage:
                 output_name = :output_name,
                 input_ts = :input_ts,
                 output_ts = :output_ts,
+                hidden_input = :hidden_input,
+                hidden_output = :hidden_output,
                 mode = :mode,
                 model = :model,
                 thread_id = :thread_id,
@@ -723,12 +895,15 @@ class Storage:
                 images_json = :images_json,
                 files_json = :files_json,
                 attachments_json = :attachments_json,
+                additional_ctx_json = :additional_ctx_json,
                 extra = :extra,
                 input_tokens = :input_tokens,
                 output_tokens = :output_tokens,
                 total_tokens = :total_tokens,
                 is_internal = :is_internal,
-                docs_json = :docs_json
+                docs_json = :docs_json,
+                audio_id = :audio_id,
+                audio_expires_ts = :audio_expires_ts
             WHERE id = :id
         """).bindparams(
             id=item.id,
@@ -738,6 +913,8 @@ class Storage:
             output_name=item.output_name,
             input_ts=int(item.input_timestamp or 0),
             output_ts=int(item.output_timestamp or 0),
+            hidden_input=item.hidden_input,
+            hidden_output=item.hidden_output,
             mode=item.mode,
             model=item.model,
             thread_id=item.thread,
@@ -749,12 +926,15 @@ class Storage:
             images_json=pack_item_value(item.images),
             files_json=pack_item_value(item.files),
             attachments_json=pack_item_value(item.attachments),
+            additional_ctx_json=pack_item_value(item.additional_ctx),
             extra=pack_item_value(item.extra),
             input_tokens=int(item.input_tokens or 0),
             output_tokens=int(item.output_tokens or 0),
             total_tokens=int(item.total_tokens or 0),
             is_internal=int(item.internal or 0),
             docs_json=pack_item_value(item.doc_ids),
+            audio_id=item.audio_id,
+            audio_expires_ts=int(item.audio_expires_ts or 0)
         )
         with db.begin() as conn:
             conn.execute(stmt)
@@ -763,12 +943,12 @@ class Storage:
     def get_ctx_count_by_day(
             self,
             year: int,
-            month: int = None,
-            day: int = None,
-            search_string: str = None,
-            filters: dict = None,
+            month: Optional[int] = None,
+            day: Optional[int] = None,
+            search_string: Optional[str] = None,
+            filters: Optional[dict] = None,
             search_content: bool = False,
-    ) -> dict:
+    ) -> Dict[str, int]:
         """
         Return ctx counters by day for given year and month
 
@@ -794,37 +974,44 @@ class Storage:
         else:
             where_statement = f"AND {where_statement}"
 
+        offset_seconds = get_tz_offset()
+        offset_suffix = ""
+        if offset_seconds > 0:
+            offset_suffix = f" + {offset_seconds}"
+        elif offset_seconds < 0:
+            offset_suffix = f" - {abs(offset_seconds)}"
+
         db = self.window.core.db.get_db()
         with db.connect() as conn:
             # by day
             if year and month and day:
-                bind_params['start_ts'] = int(datetime(year, month, day, 0, 0, 0).timestamp())
-                bind_params['end_ts'] = int(datetime(year, month, day, 23, 59, 59).timestamp())
+                bind_params['start_ts'] = int(datetime(year, month, day, 0, 0, 0).timestamp()) + offset_seconds
+                bind_params['end_ts'] = int(datetime(year, month, day, 23, 59, 59).timestamp()) + offset_seconds
                 stmt_text = f"""
                     SELECT
-                        date(datetime(m.updated_ts, 'unixepoch')) as day,
+                        date(datetime(m.updated_ts{offset_suffix}, 'unixepoch')) as day,
                         COUNT(m.updated_ts) as count
                     FROM ctx_meta m
                     {join_statement}
-                    WHERE (m.updated_ts BETWEEN :start_ts AND :end_ts) {where_statement}
+                    WHERE (m.parent_id IS NULL AND m.updated_ts BETWEEN :start_ts AND :end_ts) {where_statement}
                     GROUP BY day
                 """
                 stmt = text(stmt_text).bindparams(**bind_params)
                 result = conn.execute(stmt)
                 return {row._mapping['day']: row._mapping['count'] for row in result}
 
-            # by month
+            # by year and month
             elif year and month:
                 start_timestamp, end_timestamp = get_month_start_end_timestamps(year, month)
                 bind_params['start_ts'] = start_timestamp
                 bind_params['end_ts'] = end_timestamp
                 stmt_text = f"""
                     SELECT
-                        date(datetime(m.updated_ts, 'unixepoch')) as day,
+                        date(datetime(m.updated_ts{offset_suffix}, 'unixepoch')) as day,
                         COUNT(m.updated_ts) as count
                     FROM ctx_meta m
                     {join_statement}
-                    WHERE (m.updated_ts BETWEEN :start_ts AND :end_ts) {where_statement}
+                    WHERE (m.parent_id IS NULL AND m.updated_ts BETWEEN :start_ts AND :end_ts) {where_statement}
                     GROUP BY day
                 """
                 stmt = text(stmt_text).bindparams(**bind_params)
@@ -834,17 +1021,314 @@ class Storage:
             # by year (return months, not days)
             elif year:
                 start_timestamp, end_timestamp = get_year_start_end_timestamps(year)
-                bind_params['start_ts'] = start_timestamp
-                bind_params['end_ts'] = end_timestamp
+                bind_params['start_ts'] = start_timestamp + offset_seconds
+                bind_params['end_ts'] = end_timestamp + offset_seconds
                 stmt_text = f"""
                     SELECT
-                        strftime('%m', datetime(m.updated_ts, 'unixepoch')) as month,
+                        strftime('%m', datetime(m.updated_ts{offset_suffix}, 'unixepoch')) as month,
                         COUNT(m.updated_ts) as count
                     FROM ctx_meta m
                     {join_statement}
-                    WHERE (m.updated_ts BETWEEN :start_ts AND :end_ts) {where_statement}
+                    WHERE (m.parent_id IS NULL AND m.updated_ts BETWEEN :start_ts AND :end_ts) {where_statement}
                     GROUP BY month
                 """
                 stmt = text(stmt_text).bindparams(**bind_params)
                 result = conn.execute(stmt)
                 return {row._mapping['month']: row._mapping['count'] for row in result}
+
+    def get_ctx_labels_count_by_day(
+            self,
+            year: int,
+            month: Optional[int] = None,
+            day: Optional[int] = None,
+            search_string: Optional[str] = None,
+            filters: Optional[dict] = None,
+            search_content: bool = False,
+    ) -> Dict[str, Dict[int, int]]:
+        """
+        Return ctx counters by day for given year and month
+
+        :param year: year
+        :param month: month
+        :param day: day
+        :param search_string: search string
+        :param filters: dict of filters
+        :param search_content: search in content (input, output)
+        :return: dict with day as key and count as value
+        """
+        # prepare query with search filters
+        where_statement, join_statement, bind_params = self.prepare_query(
+            search_string=search_string,
+            filters=filters,
+            search_content=search_content,
+            append_date_ranges=False,  # without date ranges
+        )
+
+        # prepare where statement
+        if where_statement == "1":
+            where_statement = ""
+        else:
+            where_statement = f"AND {where_statement}"
+
+        offset_seconds = get_tz_offset()
+        offset_suffix = ""
+        if offset_seconds > 0:
+            offset_suffix = f" + {offset_seconds}"
+        elif offset_seconds < 0:
+            offset_suffix = f" - {abs(offset_seconds)}"
+
+        db = self.window.core.db.get_db()
+        with db.connect() as conn:
+            # by day
+            if year and month and day:
+                bind_params['start_ts'] = int(datetime(year, month, day, 0, 0, 0).timestamp()) + offset_seconds
+                bind_params['end_ts'] = int(datetime(year, month, day, 23, 59, 59).timestamp()) + offset_seconds
+                stmt_text = f"""
+                    SELECT
+                        date(datetime(m.updated_ts{offset_suffix}, 'unixepoch')) as day,
+                        label,
+                        COUNT(m.updated_ts) as count
+                    FROM ctx_meta m
+                    {join_statement}
+                    WHERE (m.parent_id IS NULL AND m.updated_ts BETWEEN :start_ts AND :end_ts) {where_statement}
+                    GROUP BY day, label
+                """
+                stmt = text(stmt_text).bindparams(**bind_params)
+                result = conn.execute(stmt)
+                result_dict = {}
+                for row in result:
+                    day = row._mapping['day']
+                    label = row._mapping['label']
+                    count = row._mapping['count']
+
+                    if day not in result_dict:
+                        result_dict[day] = {}
+
+                    result_dict[day][label] = count
+
+                return result_dict
+
+            # by year and month
+            elif year and month:
+                start_timestamp, end_timestamp = get_month_start_end_timestamps(year, month)
+                bind_params['start_ts'] = start_timestamp
+                bind_params['end_ts'] = end_timestamp
+                stmt_text = f"""
+                    SELECT
+                        date(datetime(m.updated_ts{offset_suffix}, 'unixepoch')) as day,
+                        label,
+                        COUNT(m.updated_ts) as count
+                    FROM ctx_meta m
+                    {join_statement}
+                    WHERE (m.parent_id IS NULL AND m.updated_ts BETWEEN :start_ts AND :end_ts) {where_statement}
+                    GROUP BY day, label
+                """
+                stmt = text(stmt_text).bindparams(**bind_params)
+                result = conn.execute(stmt)
+                result_dict = {}
+                for row in result:
+                    day = row._mapping['day']
+                    label = row._mapping['label']
+                    count = row._mapping['count']
+
+                    if day not in result_dict:
+                        result_dict[day] = {}
+
+                    result_dict[day][label] = count
+
+                return result_dict
+
+            # by year (return months, not days)
+            elif year:
+                start_timestamp, end_timestamp = get_year_start_end_timestamps(year)
+                bind_params['start_ts'] = start_timestamp + offset_seconds
+                bind_params['end_ts'] = end_timestamp + offset_seconds
+                stmt_text = f"""
+                    SELECT
+                        strftime('%m', datetime(m.updated_ts{offset_suffix}, 'unixepoch')) as month,
+                        label,
+                        COUNT(m.updated_ts) as count
+                    FROM ctx_meta m
+                    {join_statement}
+                    WHERE (m.parent_id IS NULL AND m.updated_ts BETWEEN :start_ts AND :end_ts) {where_statement}
+                    GROUP BY month, label
+                """
+                stmt = text(stmt_text).bindparams(**bind_params)
+                result = conn.execute(stmt)
+                result_dict = {}
+                for row in result:
+                    day = row._mapping['month']
+                    label = row._mapping['label']
+                    count = row._mapping['count']
+
+                    if day not in result_dict:
+                        result_dict[day] = {}
+
+                    result_dict[day][label] = count
+
+                return result_dict
+
+    def get_groups(self) -> Dict[int, CtxGroup]:
+        """
+        Return dict with CtxGroup objects, indexed by ID
+
+        :return: dict of CtxGroup
+        """
+        stmt_text = f"""
+            SELECT * FROM ctx_group g ORDER BY g.name ASC
+        """
+        stmt = text(stmt_text)
+
+        items = {}
+        db = self.window.core.db.get_db()
+        with db.connect() as conn:
+            result = conn.execute(stmt)
+            for row in result:
+                group = CtxGroup()
+                unpack_group(group, row._asdict())
+                items[group.id] = group
+
+        return items
+
+    def delete_group(self, id: int, all: bool = False) -> bool:
+        """
+        Delete ctx group by ID
+
+        :param id: ctx group ID
+        :param all: remove items
+        :return: True if deleted
+        """
+        stmt = text("""
+            DELETE FROM ctx_group WHERE id = :id
+        """).bindparams(
+            id=id,
+        )
+        db = self.window.core.db.get_db()
+        with db.begin() as conn:
+            conn.execute(stmt)
+
+        # remove items in group
+        if all:
+            stmt = text("""
+                DELETE FROM ctx_meta WHERE group_id = :id
+            """).bindparams(
+                id=id,
+            )
+            with db.begin() as conn:
+                conn.execute(stmt)
+        else:
+            # set group_id to NULL (remove group association)
+            stmt = text("""
+                UPDATE ctx_meta 
+                SET group_id = NULL
+                WHERE group_id = :group_id
+            """).bindparams(
+                group_id=id,
+            )
+            with db.begin() as conn:
+                conn.execute(stmt)
+        return True
+
+    def truncate_groups(self) -> bool:
+        """
+        Remove all groups
+
+        :return: True if truncated
+        """
+        db = self.window.core.db.get_db()
+        with db.begin() as conn:
+            conn.execute(text("DELETE FROM ctx_group"))
+            conn.execute(text("DELETE FROM sqlite_sequence WHERE name='ctx_group'"))
+        return True
+
+    def clear_meta(self, meta_id: int) -> bool:
+        """
+        Delete all items with meta ID
+
+        :param meta_id: meta ID
+        :return: True if cleared
+        """
+        db = self.window.core.db.get_db()
+        with db.begin() as conn:
+            conn.execute(text(f"DELETE FROM ctx_item WHERE meta_id = {meta_id}"))
+        return True
+
+    def update_group(self, group: CtxGroup) -> bool:
+        """
+        Update group
+
+        :param group: CtxGroup
+        :return: True if updated
+        """
+        id = group.id
+        db = self.window.core.db.get_db()
+        stmt = text("""
+            UPDATE ctx_group
+            SET
+                name = :name,
+                updated_ts = :updated_ts
+            WHERE id = :id
+        """).bindparams(
+            id=id,
+            name=group.name,
+            updated_ts=int(group.updated),
+        )
+        with db.begin() as conn:
+            conn.execute(stmt)
+            return True
+
+    def insert_group(self, group: CtxGroup) -> int:
+        """
+        Insert ctx group
+
+        :param group: CtxGroup
+        :return: inserted record ID
+        """
+        db = self.window.core.db.get_db()
+        stmt = text("""
+            INSERT INTO ctx_group 
+            (
+                uuid,
+                created_ts,
+                updated_ts,
+                name
+            )
+            VALUES 
+            (
+                :uuid,
+                :created_ts,
+                :updated_ts,
+                :name
+            )
+        """).bindparams(
+            uuid=group.uuid,
+            created_ts=int(group.created or 0),
+            updated_ts=int(group.updated or 0),
+            name=group.name,
+        )
+        with db.begin() as conn:
+            result = conn.execute(stmt)
+            group.id = result.lastrowid
+            return group.id
+
+    def update_meta_group_id(self, meta_id: int, group_id: int = None) -> bool:
+        """
+        Update meta group ID
+
+        :param meta_id: ctx meta ID
+        :param group_id: ctx group ID
+        :return: True if updated
+        """
+        db = self.window.core.db.get_db()
+        stmt = text("""
+            UPDATE ctx_meta 
+            SET
+                group_id = :group_id
+            WHERE id = :id
+        """).bindparams(
+            id=meta_id,
+            group_id=group_id,
+        )
+        with db.begin() as conn:
+            conn.execute(stmt)
+            return True