tina4-python 0.2.198__tar.gz → 0.2.200__tar.gz

{tina4_python-0.2.198 → tina4_python-0.2.200}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tina4-python
-Version: 0.2.198
+Version: 0.2.200
 Summary: Tina4Python - This is not another framework for Python
 Author-email: Andre van Zuydam <andrevanzuydam@gmail.com>
 Requires-Python: <4.0,>=3.12

{tina4_python-0.2.198 → tina4_python-0.2.200}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tina4-python"
-version = "0.2.198"
+version = "0.2.200"
 description = "Tina4Python - This is not another framework for Python"
 authors = [
     {name = "Andre van Zuydam",email = "andrevanzuydam@gmail.com"}

{tina4_python-0.2.198 → tina4_python-0.2.200}/tina4_python/CLAUDE.md

@@ -280,6 +280,7 @@ Producer(Queue(topic="tasks")).produce({"action": "send_email"})
 4. **fetch_one()**: Returns a plain dict (or None), NOT a DatabaseResult
 5. **Dict access**: All query results use dict access `row["column"]` not attribute access `row.column`
 6. **Firebird connection string**: `firebird.driver:<host>/<port>:<database_path>` — note the `firebird.driver:` prefix (the module name), NOT `firebird:`
+6b. **MongoDB connection string**: `pymongo:<host>/<port>:<database_name>` — uses the same SQL API as all other engines (SQL is translated to MongoDB queries internally). JOINs are not supported. Install: `pip install pymongo`
 7. **Running the app**: `uv run python app.py <port> <name>` — port and name are CLI args handled by tina4_python
 8. **SCSS**: Files in `src/scss/` are auto-compiled to `src/public/css/` on startup
 
@@ -663,9 +664,35 @@ Every `send_request()` returns:
 from tina4_python.Database import Database
 
 db = Database("sqlite3:app.db")        # SQLite
-db = Database("postgresql:host=localhost;dbname=mydb;user=me;password=secret")
+db = Database("psycopg2:localhost/5432:mydb", "user", "password")  # PostgreSQL
+db = Database("mysql.connector:localhost/3306:mydb", "user", "password")  # MySQL
+db = Database("firebird.driver:localhost/3050:/path/to/db", "SYSDBA", "masterkey")  # Firebird
+db = Database("pymssql:localhost/1433:mydb", "sa", "password")  # MSSQL
+db = Database("pymongo:localhost/27017:mydb")  # MongoDB
+db = Database("pymongo:localhost/27017:mydb", "user", "password")  # MongoDB with auth
 ```
 
+### MongoDB support
+
+MongoDB uses the same SQL API as all other engines. The `SQLToMongo` module translates SQL to MongoDB queries transparently:
+
+```python
+db = Database("pymongo:localhost/27017:mydb")
+
+# All standard operations work — SQL is translated to MongoDB internally
+db.execute("CREATE TABLE users (id INTEGER)")  # creates collection
+db.insert("users", {"id": 1, "name": "Alice", "email": "alice@test.com"})
+result = db.fetch("SELECT * FROM users WHERE name = ?", ["Alice"])
+db.execute("UPDATE users SET name = ? WHERE id = ?", ["Bob", 1])
+db.execute("DELETE FROM users WHERE id = ?", [1])
+
+# WHERE operators: =, !=, <>, >, >=, <, <=, LIKE, IN, NOT IN, IS NULL, IS NOT NULL, BETWEEN, AND, OR
+# Pagination, search, fetch_one, table_exists, get_next_id all work
+# RETURNING is emulated (returns affected documents)
+```
+
+**Limitations**: MongoDB is document-based — JOINs are not supported. Use embedded documents or application-level joins instead. Migrations (`CREATE TABLE`) map to collection creation (column definitions are ignored — MongoDB is schema-less).
+
 ### CRUD operations
 
 ```python

{tina4_python-0.2.198 → tina4_python-0.2.200}/tina4_python/Database.py

@@ -51,6 +51,7 @@ from tina4_python import Debug
 from tina4_python.DatabaseResult import DatabaseResult
 from tina4_python.DatabaseTypes import *
 from tina4_python.FieldTypes import get_field_type_values
+from tina4_python.SQLToMongo import SQLToMongo
 import datetime
 
 class Database:
@@ -95,6 +96,8 @@ class Database:
                 install_message = Messages.MSG_DB_MISSING_FIREBIRD.format(install_cmd=FIREBIRD_INSTALL)
             elif params[0] == MSSQL:
                 install_message = Messages.MSG_DB_MISSING_MSSQL.format(install_cmd=MSSQL_INSTALL)
+            elif params[0] == MONGODB:
+                install_message = f"Please install pymongo: {MONGODB_INSTALL}"
 
             sys.exit(Messages.MSG_DB_DRIVER_NOT_FOUND.format(driver=params[0]) + "\n" + install_message + "\n" + str(e))
 
@@ -195,6 +198,16 @@ class Database:
                     database=self.database_path
                 )
                 self.dba.autocommit(False)
+            elif self.database_engine == MONGODB:
+                # pymongo: MongoClient → Database
+                mongo_args = {"host": self.host, "port": self.port}
+                if self.username:
+                    mongo_args["username"] = self.username
+                if self.password:
+                    mongo_args["password"] = self.password
+                self._mongo_client = self.database_module.MongoClient(**mongo_args)
+                self.dba = self._mongo_client[self.database_path]
+                self._mongo_session = None
             else:
                 sys.exit("Could not load database driver for " + params[0])
 
@@ -207,7 +220,9 @@ class Database:
         :return: bool : True if table exists, else False
         """
 
-        if self.database_engine == MSSQL:
+        if self.database_engine == MONGODB:
+            return table_name in self.dba.list_collection_names()
+        elif self.database_engine == MSSQL:
             sql = "select count(*) as count_table from sys.tables WHERE name = '" + table_name.upper() + "'"
         elif self.database_engine == SQLITE:
             sql = "SELECT count(*) as count_table FROM sqlite_master WHERE type='table' AND name='" + table_name + "'"
@@ -244,6 +259,12 @@ class Database:
         :return: int : The next id in the sequence
         """
         try:
+            if self.database_engine == MONGODB:
+                coll = self.dba[table_name]
+                doc = coll.find_one(sort=[(column_name, -1)], projection={column_name: 1})
+                max_val = doc[column_name] if doc and column_name in doc else 0
+                return int(max_val) + 1
+
             sql = "select max(" + column_name + ") as \"max_id\" from " + table_name
             record = self.fetch_one(sql)
             if record["max_id"] is None:
@@ -306,6 +327,12 @@ class Database:
         """
         if self.database_engine == MYSQL:
             self.dba.ping(reconnect=True, attempts=1, delay=0)
+        elif self.database_engine == MONGODB:
+            # pymongo auto-reconnects; ping to confirm
+            try:
+                self._mongo_client.admin.command('ping')
+            except Exception:
+                pass
         else:
             # implement other database requirements if needed
             pass
@@ -330,6 +357,10 @@ class Database:
 
         self.check_connected()
 
+        # --- MongoDB: translate SQL to MongoDB queries ---
+        if self.database_engine == MONGODB:
+            return self._mongo_fetch(sql, params, limit, skip, search, search_columns)
+
         final_sql = sql
         final_params = params
 
@@ -365,14 +396,15 @@ class Database:
                 where_clause = " WHERE (" + " OR ".join(conditions) + ")"
                 final_sql = sql + where_clause
 
-        # 3. TOTAL COUNT (with the same filter!)
-        count_sql = f"SELECT COUNT(*) AS count_records FROM ({final_sql}) AS t"
+        # 3. TOTAL COUNT — strip ORDER BY (doesn't affect count, breaks MSSQL subqueries)
+        count_inner = re.sub(r"(?i)\s+order\s+by\s+.+?$", "", final_sql, flags=re.DOTALL).strip()
+        count_sql = f"SELECT COUNT(*) AS count_records FROM ({count_inner}) AS t"
         counter = self.dba.cursor()
         try:
             counter.execute(self.parse_place_holders(count_sql), final_params)
             total = counter.fetchone()[0]
         except Exception as e:
-            Debug.error ("COUNT ERROR", count_sql, final_params, str(e))
+            Debug.error("COUNT ERROR", count_sql, final_params, str(e))
             try:
                 self.dba.rollback()
             except Exception:
@@ -381,35 +413,30 @@ class Database:
         finally:
             counter.close()
 
-        # 4. FINAL PAGINATION – applied AFTER the filter
+        # 4. PAGINATED DATA query
         if self.database_engine == FIREBIRD:
             final_sql = f"SELECT FIRST {limit} SKIP {skip} * FROM ({final_sql}) AS t"
-        elif self.database_engine in (MYSQL, SQLITE):
-            final_sql = f"SELECT * FROM ({final_sql}) AS t LIMIT {limit} OFFSET {skip}"
-        elif self.database_engine == POSTGRES:
-            final_sql = f"SELECT * FROM ({final_sql}) AS t LIMIT {limit} OFFSET {skip}"
         elif self.database_engine == MSSQL:
             inner = final_sql.strip()
-            # Detect and extract ORDER BY if present
             order_by_match = re.search(r"(?i)\border\s+by\s+.+?$", inner, re.DOTALL)
             has_order_by = order_by_match is not None
-
-            # Clean inner query: remove trailing ORDER BY if it exists
             if has_order_by:
                 inner_clean = re.sub(r"(?i)\s+order\s+by\s+.+?$", "", inner, flags=re.DOTALL).strip()
                 order_by_part = order_by_match.group(0)
+                # Strip table aliases from ORDER BY columns (e.g. "e.salary" -> "salary")
+                # since the inner query is wrapped as subquery "t"
+                order_by_part = re.sub(r'(\b\w+)\.(\w+)', r'\2', order_by_part)
             else:
                 inner_clean = inner
                 order_by_part = "ORDER BY (SELECT NULL)"
-
-            # Build final paginated query
             final_sql = f"SELECT * FROM ({inner_clean}) AS t {order_by_part} OFFSET {skip} ROWS FETCH NEXT {limit} ROWS ONLY"
         else:
+            # SQLite, MySQL, PostgreSQL
             final_sql = f"SELECT * FROM ({final_sql}) AS t LIMIT {limit} OFFSET {skip}"
 
         final_sql = self.parse_place_holders(final_sql)
 
-        # 5. Execute the real query
+        # 5. Execute the data query
         cursor = self.dba.cursor()
         try:
             cursor.execute(final_sql, final_params)
@@ -460,11 +487,272 @@ class Database:
         :param sql:
         :return:
         """
-        if self.database_engine == MYSQL or self.database_engine == POSTGRES or self.database_engine == MSSQL:
+        if self.database_engine == MONGODB:
+            return sql  # MongoDB doesn't use SQL placeholders
+        elif self.database_engine == MYSQL or self.database_engine == POSTGRES or self.database_engine == MSSQL:
             return sql.replace("?", "%s")
         else:
             return sql.replace("%s", "?")
 
+    @staticmethod
+    def _has_returning_clause(sql):
+        """Detect a SQL RETURNING clause without false positives.
+
+        Strips string literals and comments first, then checks that RETURNING
+        appears as a standalone keyword at the end of an INSERT, UPDATE, or
+        DELETE statement.  This avoids matching column names, table names, or
+        values that happen to contain the word "returning".
+        """
+        # Strip single-quoted string literals ('' escapes inside)
+        cleaned = re.sub(r"'(?:[^']|'')*'", "''", sql)
+        # Strip double-quoted identifiers
+        cleaned = re.sub(r'"(?:[^"]|"")*"', '""', cleaned)
+        # Strip block comments
+        cleaned = re.sub(r'/\*.*?\*/', ' ', cleaned, flags=re.DOTALL)
+        # Strip line comments
+        cleaned = re.sub(r'--[^\n]*', ' ', cleaned)
+
+        # Check the statement type is INSERT, UPDATE, or DELETE
+        stripped = cleaned.strip()
+        if not re.match(r'(?i)^(INSERT|UPDATE|DELETE)\b', stripped):
+            return False
+
+        # Look for RETURNING as a standalone keyword (word boundary on both sides)
+        # It should appear after the main clause, not as part of an identifier
+        return bool(re.search(r'\bRETURNING\b', cleaned, re.IGNORECASE))
+
+    def _emulate_returning(self, sql, params, cursor):
+        """Emulate RETURNING for engines that don't support it natively.
+
+        MySQL and MSSQL don't support the RETURNING clause directly.
+        - For INSERT: uses lastrowid to fetch the inserted row back.
+        - For UPDATE/DELETE: extracts the RETURNING columns and the WHERE
+          clause to SELECT the affected rows before executing the mutation.
+
+        Returns a DatabaseResult, or None if emulation isn't needed/possible.
+        """
+        cleaned_sql = sql.strip()
+        upper_sql = cleaned_sql.upper()
+
+        # Extract the RETURNING column list
+        ret_match = re.search(r'\bRETURNING\b\s+(.+)$', cleaned_sql, re.IGNORECASE | re.DOTALL)
+        if not ret_match:
+            return None
+        returning_cols = ret_match.group(1).strip().rstrip(';')
+
+        # SQL without the RETURNING clause
+        base_sql = cleaned_sql[:ret_match.start()].strip()
+
+        if upper_sql.startswith('INSERT'):
+            # Execute the INSERT (without RETURNING)
+            base_parsed = self.parse_place_holders(base_sql)
+            cursor.execute(base_parsed, params)
+
+            # Fetch the inserted row using lastrowid
+            last_id = cursor.lastrowid
+            if last_id is not None and last_id > 0:
+                # Extract table name from INSERT INTO <table>
+                table_match = re.match(r'(?i)INSERT\s+INTO\s+(\S+)', base_sql)
+                if table_match:
+                    table_name = table_match.group(1)
+                    # For MSSQL use different ID retrieval
+                    if self.database_engine == MSSQL:
+                        select_sql = f"SELECT {returning_cols} FROM {table_name} WHERE id = @@IDENTITY"
+                        cursor.execute(select_sql)
+                    else:
+                        select_sql = self.parse_place_holders(
+                            f"SELECT {returning_cols} FROM {table_name} WHERE id = ?"
+                        )
+                        cursor.execute(select_sql, [last_id])
+                    return self.get_database_result(cursor, 1, 1, 0, sql)
+
+            # Fallback: return lastrowid as "id"
+            return DatabaseResult([{"id": last_id}], [], None, 1, 1, 0, sql, self)
+
+        elif upper_sql.startswith('UPDATE') or upper_sql.startswith('DELETE'):
+            # For UPDATE/DELETE: extract WHERE clause, SELECT matching rows first,
+            # then execute the mutation
+            where_match = re.search(r'\bWHERE\b\s+(.+)$', base_sql, re.IGNORECASE | re.DOTALL)
+
+            if upper_sql.startswith('UPDATE'):
+                table_match = re.match(r'(?i)UPDATE\s+(\S+)', base_sql)
+            else:
+                table_match = re.match(r'(?i)DELETE\s+FROM\s+(\S+)', base_sql)
+
+            if table_match and where_match:
+                table_name = table_match.group(1)
+                where_clause = where_match.group(1).strip()
+                # SELECT the rows that will be affected
+                select_sql = self.parse_place_holders(
+                    f"SELECT {returning_cols} FROM {table_name} WHERE {where_clause}"
+                )
+                cursor.execute(select_sql, params)
+                rows = cursor.fetchall()
+                columns = [col[0].lower() for col in cursor.description]
+                result_rows = [dict(zip(columns, row)) for row in rows]
+
+                # Now execute the actual mutation
+                base_parsed = self.parse_place_holders(base_sql)
+                cursor.execute(base_parsed, params)
+
+                return DatabaseResult(result_rows, columns, None, len(result_rows), len(result_rows), 0, sql, self)
+
+        return None
+
+    # -------------------------------------------------------------------
+    # MongoDB helpers
+    # -------------------------------------------------------------------
+
+    def _mongo_fetch(self, sql, params, limit, skip, search, search_columns):
+        """Execute a SQL SELECT against MongoDB via SQLToMongo translation."""
+        try:
+            op = SQLToMongo.translate(sql, params)
+        except Exception as e:
+            Debug.error("MONGO SQL PARSE ERROR", sql, str(e))
+            return DatabaseResult(None, [], str(e))
+
+        collection = self.dba[op["collection"]]
+        mongo_filter = op.get("filter", {})
+
+        # Add search conditions
+        if search and search.strip():
+            search_filter = self._mongo_search_filter(search, search_columns, op)
+            if search_filter:
+                if mongo_filter:
+                    mongo_filter = {"$and": [mongo_filter, search_filter]}
+                else:
+                    mongo_filter = search_filter
+
+        try:
+            if op["type"] == "count":
+                total = collection.count_documents(mongo_filter)
+                return DatabaseResult([{"count_records": total}], ["count_records"], None, 1, 1, 0, sql, self)
+
+            # Total count
+            total = collection.count_documents(mongo_filter)
+
+            # Build find kwargs
+            find_kwargs = {}
+            projection = op.get("projection")
+            if projection:
+                find_kwargs["projection"] = projection
+                # Always exclude _id unless explicitly requested
+                if "_id" not in projection:
+                    find_kwargs["projection"]["_id"] = 0
+            else:
+                find_kwargs["projection"] = {"_id": 0}
+
+            cursor = collection.find(mongo_filter, **find_kwargs)
+
+            sort = op.get("sort")
+            if sort:
+                cursor = cursor.sort(list(sort.items()))
+
+            # Use pagination from the op if present, otherwise use method params
+            actual_skip = op.get("skip", skip)
+            actual_limit = op.get("limit", limit)
+            cursor = cursor.skip(actual_skip).limit(actual_limit)
+
+            rows = list(cursor)
+            columns = list(rows[0].keys()) if rows else []
+
+            return DatabaseResult(rows, columns, None, total, actual_limit, actual_skip, sql, self)
+
+        except Exception as e:
+            Debug.error("MONGO FETCH ERROR", sql, str(e))
+            return DatabaseResult(None, [], str(e))
+
+    def _mongo_execute(self, sql, params):
+        """Execute a SQL INSERT/UPDATE/DELETE/CREATE/DROP against MongoDB."""
+        try:
+            op = SQLToMongo.translate(sql, params)
+        except Exception as e:
+            Debug.error("MONGO SQL PARSE ERROR", sql, str(e))
+            return DatabaseResult(None, [], str(e))
+
+        try:
+            op_type = op["type"]
+            collection_name = op["collection"]
+
+            if op_type == "insert":
+                coll = self.dba[collection_name]
+                doc = op["document"]
+                result = coll.insert_one(doc)
+                # Build a result that includes the inserted doc
+                return_doc = dict(doc)
+                if "_id" in return_doc:
+                    return_doc["_id"] = str(return_doc["_id"])
+                columns = list(return_doc.keys())
+                return DatabaseResult([return_doc], columns, None, 1, 1, 0, sql, self)
+
+            elif op_type == "update":
+                coll = self.dba[collection_name]
+                mongo_filter = op.get("filter", {})
+                update_doc = op["update"]
+
+                if op.get("returning"):
+                    # Fetch matching docs before update for RETURNING emulation
+                    pre_docs = list(coll.find(mongo_filter, {"_id": 0}))
+
+                result = coll.update_many(mongo_filter, update_doc)
+
+                if op.get("returning"):
+                    columns = list(pre_docs[0].keys()) if pre_docs else []
+                    return DatabaseResult(pre_docs, columns, None, len(pre_docs), len(pre_docs), 0, sql, self)
+
+                return DatabaseResult(None, [], None, result.modified_count, 0, 0, sql, self)
+
+            elif op_type == "delete":
+                coll = self.dba[collection_name]
+                mongo_filter = op.get("filter", {})
+
+                if op.get("returning"):
+                    # Fetch matching docs before delete for RETURNING emulation
+                    pre_docs = list(coll.find(mongo_filter, {"_id": 0}))
+
+                result = coll.delete_many(mongo_filter)
+
+                if op.get("returning"):
+                    columns = list(pre_docs[0].keys()) if pre_docs else []
+                    return DatabaseResult(pre_docs, columns, None, len(pre_docs), len(pre_docs), 0, sql, self)
+
+                return DatabaseResult(None, [], None, result.deleted_count, 0, 0, sql, self)
+
+            elif op_type == "create_collection":
+                if collection_name not in self.dba.list_collection_names():
+                    self.dba.create_collection(collection_name)
+                return DatabaseResult(None, [], None, 0, 0, 0, sql, self)
+
+            elif op_type == "drop_collection":
+                if collection_name in self.dba.list_collection_names():
+                    self.dba.drop_collection(collection_name)
+                return DatabaseResult(None, [], None, 0, 0, 0, sql, self)
+
+            else:
+                return DatabaseResult(None, [], f"Unsupported MongoDB operation: {op_type}")
+
+        except Exception as e:
+            Debug.error("MONGO EXECUTE ERROR", sql, str(e))
+            return DatabaseResult(None, [], str(e))
+
+    def _mongo_search_filter(self, search, search_columns, op):
+        """Build a MongoDB $or filter for full-text search across columns."""
+        cols = search_columns
+        if not cols:
+            # Try to get columns from the projection
+            proj = op.get("projection", {})
+            cols = [k for k in proj if k != "_id" and proj[k] == 1]
+
+        if not cols:
+            # Fallback: search all fields (not ideal but workable)
+            return {"$where": f"JSON.stringify(this).toLowerCase().indexOf('{search.lower()}') !== -1"}
+
+        conditions = []
+        for col in cols:
+            conditions.append({col: {"$regex": re.escape(search), "$options": "i"}})
+
+        return {"$or": conditions} if conditions else {}
+
     def execute(self, sql, params=None):
         """
         Execute a query based on a SQL statement
@@ -476,6 +764,11 @@ class Database:
             params = []
 
         self.check_connected()
+
+        # --- MongoDB: route through SQLToMongo ---
+        if self.database_engine == MONGODB:
+            return self._mongo_execute(sql, params)
+
         if params != []:
             sql = self.parse_place_holders(sql)
         cursor = self.dba.cursor()
@@ -483,8 +776,19 @@ class Database:
         try:
             if params != []:
                 params = get_field_type_values(params)
+
+            has_returning = self._has_returning_clause(sql)
+
+            if has_returning and self.database_engine in (MYSQL, MSSQL):
+                # Emulate RETURNING for engines that don't support it natively
+                result = self._emulate_returning(sql, params, cursor)
+                if result is not None:
+                    return result
+
             cursor.execute(sql, params)
-            if "returning" in sql.lower():
+
+            if has_returning:
+                # Native RETURNING support (PostgreSQL, SQLite, Firebird)
                 return self.get_database_result(cursor, 1, 1, 0, sql)
             else:
                 # see if we are mysql and if we are insert statement to get the last record
@@ -555,6 +859,9 @@ class Database:
                 self.dba.execute("BEGIN TRANSACTION")
             elif self.database_engine == POSTGRES:
                 self.dba.rollback()  # start fresh
+            elif self.database_engine == MONGODB:
+                self._mongo_session = self._mongo_client.start_session()
+                self._mongo_session.start_transaction()
             else:
                 Debug.error("START TRANSACTION ERROR:", "Database engine unrecognised/not supported")
         except Exception as e:
@@ -566,7 +873,14 @@ class Database:
         :return:
         """
         try:
-            self.dba.commit()
+            if self.database_engine == MONGODB:
+                if self._mongo_session:
+                    self._mongo_session.commit_transaction()
+                    self._mongo_session.end_session()
+                    self._mongo_session = None
+                # MongoDB auto-commits individual operations; no-op otherwise
+            else:
+                self.dba.commit()
         except Exception as e:
             Debug.error("COMMIT TRANSACTION ERROR:", str(e))
 
@@ -576,7 +890,13 @@ class Database:
         :return:
         """
         try:
-            self.dba.rollback()
+            if self.database_engine == MONGODB:
+                if self._mongo_session:
+                    self._mongo_session.abort_transaction()
+                    self._mongo_session.end_session()
+                    self._mongo_session = None
+            else:
+                self.dba.rollback()
         except Exception as e:
             Debug.error("ROLLBACK TRANSACTION ERROR:", str(e))
 
@@ -586,7 +906,10 @@ class Database:
         :return:
         """
         try:
-            self.dba.close()
+            if self.database_engine == MONGODB:
+                self._mongo_client.close()
+            else:
+                self.dba.close()
         except Exception as e:
             Debug.error("DATABASE CLOSE ERROR:", str(e))
 

{tina4_python-0.2.198 → tina4_python-0.2.200}/tina4_python/DatabaseTypes.py

@@ -16,6 +16,7 @@ __all__ = [
     "MYSQL", "MYSQL_INSTALL",
     "POSTGRES", "POSTGRES_INSTALL",
     "MSSQL", "MSSQL_INSTALL",
+    "MONGODB", "MONGODB_INSTALL",
 ]
 
 SQLITE = "sqlite3"
@@ -27,3 +28,5 @@ POSTGRES = "psycopg2"
 POSTGRES_INSTALL = "pip install psycopg2-binary or poetry add psycopg2-binary"
 MSSQL = "pymssql"
 MSSQL_INSTALL = "pip install pymssql or poetry add pymssql"
+MONGODB = "pymongo"
+MONGODB_INSTALL = "pip install pymongo or poetry add pymongo"

{tina4_python-0.2.198 → tina4_python-0.2.200}/tina4_python/Migration.py

@@ -5,6 +5,7 @@
 #
 # flake8: noqa: E501
 import os
+import re
 import sys
 
 from tina4_python import ShellColors
@@ -15,6 +16,54 @@ from tina4_python.Database import MSSQL, POSTGRES, FIREBIRD, MYSQL
 import tina4_python
 
 
+def _firebird_column_exists(dba, table_name, column_name):
+    """Check if a column already exists in a Firebird table via RDB$RELATION_FIELDS.
+
+    Uses a raw cursor to bypass the pagination layer (which wraps queries in
+    subqueries with COUNT(*) OVER()) — system catalogue queries break when wrapped.
+    """
+    cursor = dba.dba.cursor()
+    try:
+        cursor.execute(
+            "SELECT 1 FROM RDB$RELATION_FIELDS "
+            "WHERE TRIM(RDB$RELATION_NAME) = ? AND TRIM(RDB$FIELD_NAME) = ?",
+            [table_name.upper(), column_name.upper()],
+        )
+        row = cursor.fetchone()
+        return row is not None
+    finally:
+        cursor.close()
+
+
+def _is_idempotent_skip(dba, script):
+    """
+    Check if a DDL statement can be safely skipped because the change already exists.
+    Returns True if the statement should be skipped (already applied), False otherwise.
+    Currently handles:
+      - Firebird: ALTER TABLE ... ADD <column> (no IF NOT EXISTS support)
+    """
+    if dba.database_engine != FIREBIRD:
+        return False
+
+    stripped = script.strip()
+    # Match: ALTER TABLE <table> ADD <column> <datatype>...
+    match = re.match(
+        r"(?i)ALTER\s+TABLE\s+(\S+)\s+ADD\s+(\S+)\s+",
+        stripped,
+    )
+    if match:
+        table_name = match.group(1).strip('"')
+        column_name = match.group(2).strip('"')
+        if _firebird_column_exists(dba, table_name, column_name):
+            Debug.info(
+                ShellColors.bright_yellow,
+                f"  Skipping (column already exists): ALTER TABLE {table_name} ADD {column_name}",
+                ShellColors.end,
+            )
+            return True
+    return False
+
+
 def migrate(dba, delimiter=";", migration_folder="migrations"):
     """
     Migrates the database from the migrate folder
@@ -69,6 +118,9 @@ def migrate(dba, delimiter=";", migration_folder="migrations"):
                     error_message = ""
                     for script in script_content:
                         if script.strip() != "":
+                            # Skip DDL that is already applied (e.g. Firebird ALTER TABLE ADD)
+                            if _is_idempotent_skip(dba, script):
+                                continue
                             result = dba.execute(script)
                             if result.error is not None:
                                 error = True