tina4-python 3.13.10__tar.gz → 3.13.12__tar.gz

{tina4_python-3.13.10 → tina4_python-3.13.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tina4-python
-Version: 3.13.10
+Version: 3.13.12
 Summary: Tina4 Python v3 — Zero-dependency, lightweight web framework
 Author-email: Andre van Zuydam <andrevanzuydam@gmail.com>
 License: MIT

{tina4_python-3.13.10 → tina4_python-3.13.12}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tina4-python"
-version = "3.13.10"
+version = "3.13.12"
 description = "Tina4 Python v3 — Zero-dependency, lightweight web framework"
 authors = [
     {name = "Andre van Zuydam", email = "andrevanzuydam@gmail.com"}

{tina4_python-3.13.10 → tina4_python-3.13.12}/tina4_python/__init__.py

@@ -8,7 +8,7 @@ Tina4 Python v3.0 — Zero-dependency, lightweight web framework.
 
 One import, everything works.
 """
-__version__ = "3.13.10"
+__version__ = "3.13.12"
 
 # ── Route decorators ──
 from tina4_python.core.router import (  # noqa: E402, F401

{tina4_python-3.13.10 → tina4_python-3.13.12}/tina4_python/database/adapter.py

@@ -349,6 +349,32 @@ class DatabaseAdapter:
             last_id=last_id,
         )
 
+    @staticmethod
+    def _strip_trailing_semicolons(sql: str) -> str:
+        """v3.13.12: normalize user-supplied SQL by stripping trailing
+        semicolons and whitespace.
+
+        ``fetch()`` and ``fetch_one()`` wrap the user's SQL — fetch()
+        builds a ``SELECT COUNT(*) FROM ({sql}) AS _count_subquery``
+        for the pagination probe and appends ``LIMIT/OFFSET`` to the
+        real query. A trailing ``;`` in the user's SQL breaks both:
+
+            user input:  "SELECT * FROM users;"
+            wrapped:     "SELECT COUNT(*) FROM (SELECT * FROM users;) ..."   ← syntax error
+            paginated:   "SELECT * FROM users; LIMIT 100 OFFSET 0"           ← invalid
+
+        Stripping trailing semicolons before any wrapping is the
+        single-line defence. Internal semicolons (between meaningful
+        SQL statements) are left alone — the driver will reject those
+        if multi-statement isn't supported on the engine.
+        """
+        if not sql:
+            return sql
+        stripped = sql.rstrip()
+        while stripped.endswith(";"):
+            stripped = stripped[:-1].rstrip()
+        return stripped
+
     def fetch(self, sql: str, params: list = None,
               limit: int = 100, offset: int = 0) -> DatabaseResult:
         """Execute a read query and return multiple rows."""

{tina4_python-3.13.10 → tina4_python-3.13.12}/tina4_python/database/connection.py

@@ -421,7 +421,14 @@ class Database:
 
     def fetch(self, sql: str, params: list = None,
               limit: int = 100, offset: int = 0) -> DatabaseResult:
-        """Fetch rows with pagination."""
+        """Fetch rows with pagination.
+
+        v3.13.11 (issue #49 Gap 3): mirror :meth:`execute` and capture
+        ``last_error`` here too — pre-v3.13.11 a failed ``fetch`` left
+        ``db.get_error()`` returning ``None`` even though the adapter
+        had stored the failure on its own ``last_error``. Callers had
+        no way to read the cause via the public API.
+        """
         if self._cache_enabled:
             key = self._cache_key(sql + f":L{limit}:S{offset}", params)
             cached = self._cache_get(key)
@@ -430,17 +437,28 @@ class Database:
                     self._cache_hits += 1
                 return cached
             adapter = self._get_adapter()
-            result = adapter.fetch(sql, params, limit, offset)
+            try:
+                result = adapter.fetch(sql, params, limit, offset)
+                self.last_error = None
+            except Exception:
+                self.last_error = getattr(adapter, "last_error", None) or self.last_error
+                raise
             self._cache_set(key, result)
             with self._cache_lock:
                 self._cache_misses += 1
             return result
         adapter = self._get_adapter()
-        return adapter.fetch(sql, params, limit, offset)
+        try:
+            result = adapter.fetch(sql, params, limit, offset)
+            self.last_error = None
+            return result
+        except Exception:
+            self.last_error = getattr(adapter, "last_error", None) or self.last_error
+            raise
 
     def fetch_all(self, sql: str, params: list = None,
-                  limit: int = 100, offset: int = 0) -> list[dict]:
-        """Fetch rows and return the records list directly.
+                  limit: int = 0, offset: int = 0) -> list[dict]:
+        """Fetch ALL rows and return the records list directly.
 
         Symmetric with ``fetch_one``. For the common case where you just
         want the rows and don't need the ``DatabaseResult`` metadata
@@ -451,6 +469,10 @@ class Database:
             for row in rows:
                 print(row["name"])
 
+        v3.13.12: default ``limit`` is **0** (no truncation) — the method
+        name says ``fetch_all``, so it returns all matching rows. Pre-v3.13.12
+        silently truncated to 100. Pass an explicit ``limit=N`` to cap.
+
         Returns ``[]`` (not ``None``) when no rows match.
         """
         return self.fetch(sql, params, limit, offset).records

{tina4_python-3.13.10 → tina4_python-3.13.12}/tina4_python/database/firebird.py

@@ -283,6 +283,9 @@ class FirebirdAdapter(DatabaseAdapter):
 
     def fetch(self, sql: str, params: list = None,
               limit: int = 100, offset: int = 0) -> DatabaseResult:
+        # v3.13.12: strip trailing `;` — Firebird wraps with COUNT(*)
+        # and appends ROWS pagination; a trailing semicolon breaks both.
+        sql = self._strip_trailing_semicolons(sql)
         sql = self._translate_sql(sql)
         cursor = self._conn.cursor()
 
@@ -297,10 +300,15 @@ class FirebirdAdapter(DatabaseAdapter):
             # paginated query below regardless of whether count succeeded.
             cursor = self._conn.cursor()
 
-        # Apply Firebird pagination — ROWS start TO end
-        start = offset + 1
-        end = offset + limit
-        paginated_sql = f"{sql} ROWS {start} TO {end}"
+        # Apply Firebird pagination — ROWS start TO end.
+        # v3.13.12: limit <= 0 means "no pagination" (fetch_all's
+        # default — give me ALL rows).
+        if limit is None or limit <= 0:
+            paginated_sql = sql
+        else:
+            start = offset + 1
+            end = offset + limit
+            paginated_sql = f"{sql} ROWS {start} TO {end}"
         cursor = self._safe_cursor_execute(cursor, paginated_sql, params)
 
         desc = cursor.description
@@ -310,6 +318,7 @@ class FirebirdAdapter(DatabaseAdapter):
         return DatabaseResult(records=rows, count=total, limit=limit, offset=offset, sql=sql, adapter=self)
 
     def fetch_one(self, sql: str, params: list = None) -> dict | None:
+        sql = self._strip_trailing_semicolons(sql)
         sql = self._translate_sql(sql)
         cursor = self._conn.cursor()
         cursor = self._safe_cursor_execute(cursor, sql, params)

{tina4_python-3.13.10 → tina4_python-3.13.12}/tina4_python/database/mssql.py

@@ -105,6 +105,8 @@ class MSSQLAdapter(DatabaseAdapter):
 
     def fetch(self, sql: str, params: list = None,
               limit: int = 100, offset: int = 0) -> DatabaseResult:
+        # v3.13.12: strip trailing `;` — see DatabaseAdapter helper.
+        sql = self._strip_trailing_semicolons(sql)
         sql = self._translate_sql(sql)
         cursor = self._conn.cursor(as_dict=True)
 
@@ -116,20 +118,26 @@ class MSSQLAdapter(DatabaseAdapter):
         except Exception:
             total = 0
 
-        # Apply pagination — MSSQL uses OFFSET/FETCH
-        # This requires an ORDER BY; if none exists, add a default
-        if not re.search(r"\bORDER\s+BY\b", sql, re.IGNORECASE):
-            paginated_sql = f"{sql} ORDER BY (SELECT NULL) OFFSET %s ROWS FETCH NEXT %s ROWS ONLY"
+        # Apply pagination — MSSQL uses OFFSET/FETCH.
+        # v3.13.12: limit <= 0 means "no pagination" (fetch_all's
+        # default — give me ALL rows).
+        if limit is None or limit <= 0:
+            paginated_sql = sql
+            paginated_params = tuple(params or [])
         else:
-            paginated_sql = f"{sql} OFFSET %s ROWS FETCH NEXT %s ROWS ONLY"
-
-        paginated_params = tuple(params or []) + (offset, limit)
+            # OFFSET/FETCH requires an ORDER BY; if none exists, add a default
+            if not re.search(r"\bORDER\s+BY\b", sql, re.IGNORECASE):
+                paginated_sql = f"{sql} ORDER BY (SELECT NULL) OFFSET %s ROWS FETCH NEXT %s ROWS ONLY"
+            else:
+                paginated_sql = f"{sql} OFFSET %s ROWS FETCH NEXT %s ROWS ONLY"
+            paginated_params = tuple(params or []) + (offset, limit)
         cursor.execute(paginated_sql, paginated_params)
         rows = [dict(row) for row in cursor.fetchall()]
 
         return DatabaseResult(records=rows, count=total, limit=limit, offset=offset, sql=sql, adapter=self)
 
     def fetch_one(self, sql: str, params: list = None) -> dict | None:
+        sql = self._strip_trailing_semicolons(sql)
         sql = self._translate_sql(sql)
         cursor = self._conn.cursor(as_dict=True)
         cursor.execute(sql, tuple(params) if params else ())

{tina4_python-3.13.10 → tina4_python-3.13.12}/tina4_python/database/mysql.py

@@ -94,6 +94,9 @@ class MySQLAdapter(DatabaseAdapter):
 
     def fetch(self, sql: str, params: list = None,
               limit: int = 100, offset: int = 0) -> DatabaseResult:
+        # v3.13.12: strip trailing `;` before wrapping with COUNT(*)
+        # and appending LIMIT/OFFSET — see DatabaseAdapter helper.
+        sql = self._strip_trailing_semicolons(sql)
         sql = self._translate_sql(sql)
         cursor = self._conn.cursor(dictionary=True)
 
@@ -105,15 +108,21 @@ class MySQLAdapter(DatabaseAdapter):
         except Exception:
             total = 0
 
-        # Apply pagination
-        paginated_sql = f"{sql} LIMIT %s OFFSET %s"
-        paginated_params = (params or []) + [limit, offset]
+        # Apply pagination — v3.13.12: limit <= 0 means "no pagination"
+        # (fetch_all's default — give me ALL rows).
+        if limit is None or limit <= 0:
+            paginated_sql = sql
+            paginated_params = params or []
+        else:
+            paginated_sql = f"{sql} LIMIT %s OFFSET %s"
+            paginated_params = (params or []) + [limit, offset]
         cursor.execute(paginated_sql, paginated_params)
         rows = [dict(row) for row in cursor.fetchall()]
 
         return DatabaseResult(records=rows, count=total, limit=limit, offset=offset, sql=sql, adapter=self)
 
     def fetch_one(self, sql: str, params: list = None) -> dict | None:
+        sql = self._strip_trailing_semicolons(sql)
         sql = self._translate_sql(sql)
         cursor = self._conn.cursor(dictionary=True)
         cursor.execute(sql, params or [])

{tina4_python-3.13.10 → tina4_python-3.13.12}/tina4_python/database/postgres.py

@@ -137,7 +137,16 @@ class PostgreSQLAdapter(DatabaseAdapter):
             raise
 
     def _on_query_error(self, exc: Exception, sql: str, params=None):
-        """Handle a failed query: log, store, auto-rollback if implicit."""
+        """Handle a failed query: log, store, auto-rollback if implicit.
+
+        v3.13.11 (issue #49 Gap 1): inside an explicit transaction the
+        auto-rollback step defers to the user — they may be running a
+        SAVEPOINT/retry pattern. The visibility half stays: the original
+        cause is still logged via ``Log.error``, and an additional
+        ``Log.warning`` makes the context explicit so a tail-the-log
+        operator can spot the upstream cause that's about to be buried
+        by a downstream ``InFailedSqlTransaction`` cascade.
+        """
         # Lazy import — avoid circular import at module load and let the
         # framework boot without Log if something exotic is happening.
         try:
@@ -148,6 +157,15 @@ class PostgreSQLAdapter(DatabaseAdapter):
                 sql=preview,
                 params=params,
             )
+            # v3.13.11: extra in-txn marker so the original cause is
+            # easy to spot above the cascade line.
+            if self._in_transaction:
+                Log.warning(
+                    "Above failure occurred inside an explicit transaction — "
+                    "auto-rollback skipped (caller owns the transaction). "
+                    "Subsequent queries on this connection will cascade with "
+                    "'current transaction is aborted' until rollback() is called."
+                )
         except Exception:
             pass
 
@@ -166,6 +184,29 @@ class PostgreSQLAdapter(DatabaseAdapter):
                 # Don't mask the original error if rollback itself fails.
                 pass
 
+    def _log_silent_probe_failure(self, exc: Exception, sql: str, params=None):
+        """v3.13.11 (issue #49 Gap 1): log a probe-query failure as a
+        warning WITHOUT touching ``last_error`` or rolling back.
+
+        Used by the COUNT probe in :meth:`fetch` which is best-effort —
+        it's allowed to fail without surfacing to the caller — but inside
+        an explicit transaction the connection is now poisoned, the
+        paginated query that follows will cascade, and the real cause
+        used to be lost entirely. This logs it so an operator scrolling
+        back through the log can spot the upstream cause.
+        """
+        try:
+            from tina4_python.debug import Log
+            preview = sql.strip().splitlines()[0][:200] if sql else "<no sql>"
+            Log.warning(
+                f"PostgreSQL probe query failed (original cause, before "
+                f"any cascade): {exc.__class__.__name__}: {exc}",
+                sql=preview,
+                params=params,
+            )
+        except Exception:
+            pass
+
     def connect(self, connection_string: str, username: str = "", password: str = "", **kwargs):
         """Connect to PostgreSQL.
 
@@ -265,6 +306,10 @@ class PostgreSQLAdapter(DatabaseAdapter):
               limit: int = 100, offset: int = 0) -> DatabaseResult:
         import psycopg2.extras
 
+        # v3.13.12: strip trailing `;` before the framework wraps with
+        # COUNT(*) and appends LIMIT/OFFSET — otherwise a user-supplied
+        # `"SELECT * FROM users;"` produces invalid wrapped SQL.
+        sql = self._strip_trailing_semicolons(sql)
         sql = self._translate_sql(sql)
 
         # v3.13.8: heal first so the COUNT probe below doesn't open on a
@@ -280,8 +325,15 @@ class PostgreSQLAdapter(DatabaseAdapter):
         try:
             self._safe_execute(cursor, count_sql, params)
             total = cursor.fetchone()["cnt"]
-        except Exception:
+        except Exception as e:
             total = 0
+            # v3.13.11 (issue #49 Gap 1): log the probe failure as a
+            # warning so the original cause appears in the log even
+            # though the probe itself swallows. Without this line, a
+            # failure inside an explicit transaction is invisible —
+            # the cascade message from the paginated query below is
+            # all the operator sees.
+            self._log_silent_probe_failure(e, count_sql, params)
             # If the probe failed because the connection arrived (or
             # became) aborted, roll back so the real pagination query
             # below sees a clean txn. Without this we'd cascade.
@@ -294,8 +346,14 @@ class PostgreSQLAdapter(DatabaseAdapter):
         # Apply pagination — the real query, so use the error-handling
         # wrapper. The count probe above is best-effort and stays on
         # _safe_execute (a failed probe shouldn't taint last_error).
-        paginated_sql = f"{sql} LIMIT %s OFFSET %s"
-        paginated_params = (params or []) + [limit, offset]
+        # v3.13.12: limit <= 0 means "no pagination" (fetch_all's
+        # default — give me ALL rows, not a silent first-100 slice).
+        if limit is None or limit <= 0:
+            paginated_sql = sql
+            paginated_params = params or []
+        else:
+            paginated_sql = f"{sql} LIMIT %s OFFSET %s"
+            paginated_params = (params or []) + [limit, offset]
         self._exec_with_handling(cursor, paginated_sql, paginated_params)
         rows = [self._decode_blobs(dict(row)) for row in cursor.fetchall()]
 
@@ -304,6 +362,8 @@ class PostgreSQLAdapter(DatabaseAdapter):
     def fetch_one(self, sql: str, params: list = None) -> dict | None:
         import psycopg2.extras
 
+        # v3.13.12: see fetch() — trailing semicolons break the wrappers.
+        sql = self._strip_trailing_semicolons(sql)
         sql = self._translate_sql(sql)
         cursor = self._conn.cursor(cursor_factory=psycopg2.extras.RealDictCursor)
         self._exec_with_handling(cursor, sql, params)

{tina4_python-3.13.10 → tina4_python-3.13.12}/tina4_python/database/sqlite.py

@@ -108,6 +108,8 @@ class SQLiteAdapter(DatabaseAdapter):
 
     def fetch(self, sql: str, params: list = None,
               limit: int = 100, offset: int = 0) -> DatabaseResult:
+        # v3.13.12: strip trailing `;` before wrapping — see DatabaseAdapter.
+        sql = self._strip_trailing_semicolons(sql)
         # Count total rows (without LIMIT/OFFSET)
         count_sql = f"SELECT COUNT(*) as cnt FROM ({sql})"
         try:
@@ -115,8 +117,12 @@ class SQLiteAdapter(DatabaseAdapter):
         except Exception:
             total = 0
 
-        # Apply pagination — skip if SQL already has LIMIT
-        if "LIMIT" in sql.upper().split("--")[0]:
+        # Apply pagination — skip if SQL already has LIMIT, or if
+        # limit <= 0 (v3.13.12: fetch_all's "give me all rows" path).
+        if limit is None or limit <= 0:
+            paginated_sql = sql
+            paginated_params = params or []
+        elif "LIMIT" in sql.upper().split("--")[0]:
             paginated_sql = sql
             paginated_params = params or []
         else:
@@ -128,6 +134,7 @@ class SQLiteAdapter(DatabaseAdapter):
         return DatabaseResult(records=rows, count=total, limit=limit, offset=offset, sql=sql, adapter=self)
 
     def fetch_one(self, sql: str, params: list = None) -> dict | None:
+        sql = self._strip_trailing_semicolons(sql)
         cursor = self._conn.execute(sql, params or [])
         row = cursor.fetchone()
         return dict(row) if row else None

{tina4_python-3.13.10 → tina4_python-3.13.12}/tina4_python/orm/fields.py

@@ -51,12 +51,36 @@ class Field:
         self.choices = choices
         self.validator = validator  # Custom callable(value) → raises ValueError
 
+    # ── v3.13.11 (issue #50): callable-default resolution ──────────────
+    #
+    # Pre-v3.13.11 a callable default (e.g. ``DateTimeField(default=lambda:
+    # datetime.now())``) reached the driver verbatim and blew up with
+    # ``can't adapt type 'function'``. Now we evaluate the callable at the
+    # point of use, so every instance gets a freshly computed value (per-row
+    # timestamps actually differ). Types are excluded — ``default=int`` is
+    # almost never intended to mean "call int()".
+    def _resolve_default(self):
+        d = self.default
+        if callable(d) and not isinstance(d, type):
+            return d()
+        return d
+
     def validate(self, value):
         """Validate and coerce value to the field type."""
         if value is None:
             if self.required and self.default is None:
                 raise ValueError(f"Field '{self.name}' is required")
-            return self.default
+            return self._resolve_default()
+
+        # v3.13.11 (issue #50): if the user stored a callable as the field
+        # value (e.g. ``default=lambda: datetime.now()`` reached us without
+        # being resolved on instance init), evaluate it now so the driver
+        # gets a real value, not the function object. Types are excluded —
+        # ``default=int`` is almost never intended to mean "call int()".
+        if callable(value) and not isinstance(value, type):
+            value = value()
+            if value is None:
+                return None
 
         # Type coercion.
         #

{tina4_python-3.13.10 → tina4_python-3.13.12}/tina4_python/orm/model.py

@@ -177,9 +177,14 @@ class ORM(metaclass=ORMMeta):
         # Initialize relationship cache
         self._rel_cache = {}
 
-        # Set defaults from field definitions
+        # Set defaults from field definitions.
+        # v3.13.11 (issue #50): callable defaults are evaluated *per
+        # instance* so per-row timestamps (e.g. ``default=lambda:
+        # datetime.now()``) actually differ. Pre-v3.13.11 the function
+        # object reached the driver verbatim and blew up with
+        # ``can't adapt type 'function'``.
         for name, field in self._fields.items():
-            setattr(self, name, field.default)
+            setattr(self, name, field._resolve_default())
 
         # Accept JSON string or dict
         if isinstance(data, str):
@@ -304,10 +309,22 @@ class ORM(metaclass=ORMMeta):
     # ── CRUD ────────────────────────────────────────────────────
 
     def save(self) -> Self | bool:
-        """Insert or update. Returns self on success, False on failure."""
+        """Insert or update. Returns self on success, False on failure.
+
+        v3.13.11 (issue #50): for non-auto-increment primary keys (e.g.
+        user-supplied string IDs like ``"GC-100"``), the decision between
+        INSERT and UPDATE is made on whether the row *exists*, not on
+        whether the PK is set. Pre-v3.13.11 a natural-key save() always
+        chose UPDATE — matched zero rows — and silently returned success
+        without inserting anything.
+
+        Auto-increment behaviour is unchanged: ``pk_value is None`` means
+        "new row, let the engine assign an ID" and we still INSERT.
+        """
         db = self._get_db()
         pk = self._get_pk()
         pk_value = getattr(self, pk, None)
+        pk_field = self._fields[pk]
         table = self._get_table()
         pk_db_col = self.field_mapping.get(pk, self._fields[pk].column)
 
@@ -316,22 +333,52 @@ class ORM(metaclass=ORMMeta):
             if field.auto_increment and pk_value is None:
                 continue  # Skip auto-increment on insert
             value = getattr(self, name)
+            # v3.13.11 (issue #50): resolve callable values at write time
+            # too, in case the user set ``self.created_at = lambda: ...``
+            # directly. Defensive — Field.validate() already handles this
+            # for the normal __init__ + _populate paths.
+            if callable(value) and not isinstance(value, type):
+                value = value()
             if value is not None or not field.auto_increment:
                 # Use field_mapping for the column name, fall back to field.column
                 db_col = self.field_mapping.get(name, field.column)
                 data[db_col] = value
 
+        # v3.13.11 (issue #50): pick INSERT vs UPDATE on row existence
+        # for non-auto-increment PKs. Auto-increment keeps the legacy
+        # behaviour (PK is None → INSERT, PK is set → UPDATE).
+        is_update = False
+        if pk_value is not None:
+            if pk_field.auto_increment:
+                is_update = True
+            else:
+                # Natural-key model — check if the row already exists.
+                # type(self).exists() handles soft-delete + scope filters
+                # the same way the rest of the ORM does.
+                try:
+                    is_update = type(self).exists(pk_value)
+                except Exception:
+                    # If we can't tell (e.g. table doesn't exist yet),
+                    # fall back to INSERT — the user will see the real
+                    # error from the driver instead of a silent no-op.
+                    is_update = False
+
         db.start_transaction()
         try:
-            if pk_value is not None:
+            if is_update:
                 update_data = {k: v for k, v in data.items() if k != pk_db_col}
                 if update_data:
                     db.update(table, update_data, f"{pk_db_col} = ?", [pk_value])
             else:
                 db.insert(table, data)
-                last_id = db.get_last_id()
-                if last_id and pk in self._fields:
-                    setattr(self, pk, last_id)
+                # Only adopt the engine-assigned ID for auto-increment PKs.
+                # Natural-key PKs were already set by the caller; don't
+                # overwrite them with the driver's last_id (which on PG
+                # may be a sequence value that doesn't apply here).
+                if pk_field.auto_increment:
+                    last_id = db.get_last_id()
+                    if last_id and pk in self._fields:
+                        setattr(self, pk, last_id)
             db.commit()
         except Exception:
             db.rollback()
@@ -673,10 +720,21 @@ class ORM(metaclass=ORMMeta):
             StringField  → VARCHAR(255)
             TextField    → TEXT
             NumericField/FloatField → REAL
-            BooleanField → INTEGER
+            BooleanField → engine-aware (see below)
             DateTimeField → DATETIME
             BlobField    → BLOB
 
+        v3.13.11 BooleanField mapping (engine-aware):
+            SQLite    → INTEGER    (no native bool — historic convention)
+            PostgreSQL → BOOLEAN   (native type; psycopg2 binds Python
+                                    ``bool`` as BOOLEAN, so INTEGER columns
+                                    caused ``operator does not exist:
+                                    boolean = integer``)
+            MySQL     → BOOLEAN    (synonym for TINYINT(1))
+            MSSQL     → BIT        (the SQL Server bool type)
+            Firebird  → INTEGER    (driver round-trip is uneven; integer
+                                    is the safer choice on Firebird)
+
         Auto-increment primary keys use engine-appropriate syntax.
         Returns True on success.
         """
@@ -684,6 +742,21 @@ class ORM(metaclass=ORMMeta):
 
         db = cls._get_db()
         table = cls._get_table()
+        engine = (db.get_database_type() or "").lower()
+
+        # v3.13.11: BooleanField now uses each engine's native type
+        # where it's reliable. SQLite and Firebird stay on INTEGER —
+        # SQLite has no native bool, and Firebird's driver round-trip
+        # for native BOOLEAN is uneven across versions.
+        if engine == "postgres":
+            bool_sql = "BOOLEAN"
+        elif engine == "mysql":
+            bool_sql = "BOOLEAN"  # MySQL alias for TINYINT(1)
+        elif engine == "mssql":
+            bool_sql = "BIT"
+        else:
+            # sqlite, firebird, odbc, anything else
+            bool_sql = "INTEGER"
 
         # Don't recreate if table already exists
         if db.table_exists(table):
@@ -706,7 +779,7 @@ class ORM(metaclass=ORMMeta):
             elif kind in ("NumericField", "FloatField"):
                 sql_type = "REAL"
             elif kind == "BooleanField":
-                sql_type = "INTEGER"
+                sql_type = bool_sql
             elif kind == "DateTimeField":
                 sql_type = "DATETIME"
             elif kind == "BlobField":
@@ -719,7 +792,7 @@ class ORM(metaclass=ORMMeta):
                 elif ft == float:
                     sql_type = "REAL"
                 elif ft == bool:
-                    sql_type = "INTEGER"
+                    sql_type = bool_sql
                 elif ft == bytes:
                     sql_type = "BLOB"