tina4ruby 3.13.14 → 3.13.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0c7aa0bfb2393540123bc96f0251850236854b27b8cb64afbe3a57dc7036c952
-  data.tar.gz: 675898e92f1d9fa832703afca63d833a2d895a37ce2d981963f24fe4a12ef451
+  metadata.gz: b1cf076eb39a57f9c1cbdff22ff957b6abf2bc24ab245d603a88f4fdc780ab1f
+  data.tar.gz: 87a49969a5de07822dfeee8f4d6792dd0260409344519396e108ee45d8c68245
 SHA512:
-  metadata.gz: 51d150d7e359a5ec89e3daaf02b4d77b41c632fe8e57ad838fcebe3a517607aea026e4d1faa575c6b1b277631c1fa21e4c43c927c49de2b2859f79b1e9b04c46
-  data.tar.gz: 5b002d55c8f5b822677b443ccffee40a88b5b46fe76bdd34df2e2ec3d2591f52010b93afd5ef6504cc22e55ce5d883726f80dba992a3886884a5f3a8e6acad42
+  metadata.gz: a46003bec7bcaf5c5a4df7731a80b6d4e77b4eca9a9f467dcd061e94db7372192ba8751cf29d333518c49988224172adfab0a05bd16a14bc65fa2d2a5a209d98
+  data.tar.gz: ff0760e9a50bfe4f07dafc1c842060693a710de0ff5c3c9c5adfe606e858aee4219ea4e5bbdda600cd0252f89f83f749b619e426a884f0a6260e0c5552ce04bf

data/lib/tina4/database.rb

@@ -405,6 +405,18 @@ module Tina4
       nil
     end
 
+    # Return the normalised engine name for this connection.
+    #
+    # Cross-framework parity with Python/PHP/Node ``get_database_type()``.
+    # ORM.create_table needs this to emit engine-correct DDL (SERIAL vs
+    # AUTOINCREMENT, BOOLEAN vs INTEGER, TIMESTAMP vs DATETIME). Returns the
+    # resolved driver key ("postgres", "mysql", "mssql", "firebird",
+    # "sqlite", ...) — the same alias-normalised value used to pick the
+    # driver class, so callers don't have to re-parse the connection string.
+    def get_database_type
+      @driver_name
+    end
+
     # Execute a write statement. Returns true/false for simple writes.
     # Returns DatabaseResult if SQL contains RETURNING, CALL, EXEC, or SELECT.
     def execute(sql, params = [])

data/lib/tina4/database_result.rb

@@ -39,8 +39,21 @@ module Tina4
       @records.empty?
     end
 
-    def [](index)
-      @records[index]
+    # Index / slice access into the result rows.
+    #
+    # ``result[0]`` is documented (book ch5 §4 "Index Access"). Delegating
+    # straight to the materialised rows means every Array subscript form
+    # works — ``result[0]``, ``result[-1]``, ``result[1, 2]`` and
+    # ``result[1..3]`` — and matches Python's ``DatabaseResult.__getitem__``,
+    # which forwards to its records list.
+    def [](*args)
+      @records[*args]
+    end
+
+    # Implicit array coercion, so a DatabaseResult can be splatted and used
+    # anywhere an Array is expected (``a, b = result``, ``[*result]``).
+    def to_ary
+      @records.dup
     end
 
     def length

data/lib/tina4/orm.rb

@@ -306,13 +306,29 @@ module Tina4
       def create_table
         return true if db.table_exists?(table_name)
 
-        # v3.13.11 (BooleanField parity): pick each engine's native
-        # bool type where it's reliable. SQLite has no native bool;
-        # Firebird's driver round-trip for native BOOLEAN is uneven —
-        # both stay on INTEGER. PG/MySQL/MSSQL use their native types
-        # so Python ``True``/Ruby ``true`` bind cleanly without
-        # ``operator does not exist: boolean = integer`` errors.
+        # v3.13.16: engine-aware DDL. Ruby used to emit SQLite-only DDL on
+        # every driver — INTEGER for booleans, DATETIME for datetimes, and a
+        # raw AUTOINCREMENT keyword — then ignore db.execute()'s return value
+        # and report success. On PostgreSQL the CREATE blew up
+        # ("syntax error at or near AUTOINCREMENT"), db.execute() swallowed it
+        # into get_error() and returned false, yet create_table still returned
+        # true with no table created — a silent, misleading pass.
+        #
+        # The fix mirrors the Python reference (tina4_python.orm.model):
+        #   • get_database_type() now exists on Database (it didn't before, so
+        #     the v3.13.11 BooleanField check never actually fired on Ruby).
+        #   • BooleanField → native BOOLEAN (PG/MySQL) / BIT (MSSQL) /
+        #     INTEGER (sqlite, firebird) — both PG aliases are matched.
+        #   • DateTimeField → TIMESTAMP on PG/Firebird (neither has a DATETIME
+        #     type), DATETIME elsewhere.
+        #   • boolean DEFAULT is engine-aware: TRUE/FALSE for a native BOOLEAN,
+        #     1/0 for INTEGER/BIT-backed bools.
+        #   • AUTOINCREMENT is translated per engine via SQLTranslator
+        #     (SERIAL on PG, AUTO_INCREMENT on MySQL, IDENTITY on MSSQL, dropped
+        #     on Firebird) instead of being emitted raw.
+        #   • return false (not true) when the DDL fails.
         engine = (db.respond_to?(:get_database_type) ? db.get_database_type : "").to_s.downcase
+
         bool_sql = case engine
                    when "postgres", "postgresql" then "BOOLEAN"
                    when "mysql" then "BOOLEAN" # alias for TINYINT(1)
@@ -320,6 +336,15 @@ module Tina4
                    else "INTEGER" # sqlite, firebird, odbc, anything else
                    end
 
+        # PostgreSQL and Firebird have no DATETIME type — CREATE TABLE fails
+        # with `type "datetime" does not exist`. Emit each engine's real
+        # timestamp type. (MySQL/MSSQL/SQLite keep DATETIME: valid there, and
+        # on MySQL it avoids TIMESTAMP's auto-update + 2038 surprises.)
+        datetime_sql = case engine
+                       when "postgres", "postgresql", "firebird" then "TIMESTAMP"
+                       else "DATETIME"
+                       end
+
         type_map = {
           integer: "INTEGER",
           string: "VARCHAR(255)",
@@ -328,7 +353,7 @@ module Tina4
           decimal: "REAL",
           boolean: bool_sql,
           date: "DATE",
-          datetime: "DATETIME",
+          datetime: datetime_sql,
           timestamp: "TIMESTAMP",
           blob: "BLOB",
           json: "TEXT"
@@ -346,15 +371,29 @@ module Tina4
           parts << "AUTOINCREMENT" if opts[:auto_increment]
           parts << "NOT NULL" if !opts[:nullable] && !opts[:primary_key]
           if opts[:default] && !opts[:auto_increment]
-            default_val = opts[:default].is_a?(String) ? "'#{opts[:default]}'" : opts[:default]
-            parts << "DEFAULT #{default_val}"
+            parts << "DEFAULT #{default_literal(opts[:default], opts[:type], bool_sql)}"
           end
           col_defs << parts.join(" ")
         end
 
         sql = "CREATE TABLE IF NOT EXISTS #{table_name} (#{col_defs.join(', ')})"
-        db.execute(sql)
+
+        # Translate AUTOINCREMENT to the engine's auto-increment syntax
+        # (INTEGER PRIMARY KEY AUTOINCREMENT -> SERIAL PRIMARY KEY on PG, etc.).
+        # SQLTranslator keys off the -ql spelling for postgres.
+        translator_engine = %w[postgres postgresql].include?(engine) ? "postgresql" : engine
+        sql = SQLTranslator.auto_increment_syntax(sql, translator_engine)
+
+        # Don't claim success when the DDL failed. db.execute() swallows the
+        # driver error into get_error() and returns false, so a bad type (or
+        # any DDL error) used to leave create_table returning true while no
+        # table was actually created.
+        ok = db.execute(sql)
         db.commit
+        if ok == false
+          Tina4::Log.error("create_table failed for #{table_name}: #{db.get_error}", { sql: sql })
+          return false
+        end
         true
       end
 
@@ -427,6 +466,28 @@ module Tina4
         results = db.fetch(sql, filter.values)
         results.map { |row| from_hash(row) }
       end
+
+      # Render a column DEFAULT literal for create_table.
+      #
+      # Strings are quoted. Booleans are engine-aware: a native BOOLEAN
+      # column (PG/MySQL) needs TRUE/FALSE, while INTEGER- and BIT-backed
+      # bools (SQLite, Firebird, MSSQL) need 1/0 — `DEFAULT 0` on a PG
+      # BOOLEAN raises "default expression is of type integer". Everything
+      # else is emitted as-is.
+      def default_literal(value, type, bool_sql)
+        if value.is_a?(String)
+          "'#{value}'"
+        elsif value == true || value == false || type == :boolean
+          truthy = value == true || value == 1 || value == "1"
+          if bool_sql == "BOOLEAN"
+            truthy ? "TRUE" : "FALSE"
+          else
+            truthy ? "1" : "0"
+          end
+        else
+          value.to_s
+        end
+      end
     end
 
     def initialize(attributes = {})

data/lib/tina4/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Tina4
-  VERSION = "3.13.14"
+  VERSION = "3.13.16"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tina4ruby
 version: !ruby/object:Gem::Version
-  version: 3.13.14
+  version: 3.13.16
 platform: ruby
 authors:
 - Tina4 Team
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-06-13 00:00:00.000000000 Z
+date: 2026-06-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack