tina4ruby 3.13.14 → 3.13.17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0c7aa0bfb2393540123bc96f0251850236854b27b8cb64afbe3a57dc7036c952
-  data.tar.gz: 675898e92f1d9fa832703afca63d833a2d895a37ce2d981963f24fe4a12ef451
+  metadata.gz: 198d9905bf51e280f45f2bba90aac40fd64ea1bdf0c0f0b29e9a80d5e95020c9
+  data.tar.gz: 74c01ef1ac870c47aebf57e686a9b3bd7efa46f5c56c1d78df4c378102ee39f2
 SHA512:
-  metadata.gz: 51d150d7e359a5ec89e3daaf02b4d77b41c632fe8e57ad838fcebe3a517607aea026e4d1faa575c6b1b277631c1fa21e4c43c927c49de2b2859f79b1e9b04c46
-  data.tar.gz: 5b002d55c8f5b822677b443ccffee40a88b5b46fe76bdd34df2e2ec3d2591f52010b93afd5ef6504cc22e55ce5d883726f80dba992a3886884a5f3a8e6acad42
+  metadata.gz: 03a840227106a3e2c12a78bde6c5d62ff8e4eb3041bc443fe73cad5e5d6d1dbd366ffa5458d34faeffe8448ad8fb19ce9bd74c821a4d3ec436ab80aa984b58fc
+  data.tar.gz: deefa98487ff855b8ad66beaa13b2e70f2b9f71677c0e317b52fc9153f43782a40723dc5519e814a2d65a29685fae18647f0bc84c124763aa8e5e7dcbddd07ca

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/drivers/postgres_driver.rb

@@ -25,6 +25,8 @@ module Tina4
           url = uri.to_s
         end
         @connection = PG.connect(url)
+        apply_result_type_map(@connection)
+        @connection
       end
 
       def close
@@ -151,6 +153,55 @@ module Tina4
 
       private
 
+      # Decode result columns to native Ruby types (parity with SQLite, and
+      # with Python psycopg2 / Node node-postgres which both return native
+      # types). Without this the pg gem hands back EVERY column as a String —
+      # ``id: "1"``, ``active: "t"``, timestamps as strings — so an app
+      # written on SQLite silently changes behaviour on PostgreSQL.
+      #
+      # PG::BasicTypeMapForResults decodes by column OID:
+      #   int2/int4/int8/serial -> Integer
+      #   bool                  -> true / false
+      #   float4/float8         -> Float
+      #   numeric               -> BigDecimal
+      #   timestamp/timestamptz -> Time
+      #   date                  -> Date
+      #   text/varchar          -> String (unchanged)
+      #
+      # The map is set on the *connection*, so it applies uniformly to both
+      # ``exec`` and ``exec_params`` and therefore to every fetch / fetch_one /
+      # columns path that flows through execute_query.
+      #
+      # uuid / json / jsonb / regclass have no built-in coder; left alone the
+      # map prints a noisy "no type cast defined" warning to stderr and falls
+      # back to a raw string anyway. We register explicit text decoders for them
+      # so they stay plain strings (the documented behaviour) without the
+      # warning — regclass matters because table_exists? selects to_regclass().
+      # bytea is already handled by the map as an ASCII-8BIT binary string,
+      # which is what decode_blobs expects.
+      def apply_result_type_map(conn)
+        type_map = PG::BasicTypeMapForResults.new(conn)
+        register_text_decoders(conn, type_map, %w[uuid json jsonb regclass])
+        conn.type_map_for_results = type_map
+      rescue PG::Error, NameError
+        # If the type map can't be built (e.g. a minimal pg build without
+        # BasicTypeMapForResults, or a connection that can't resolve OIDs),
+        # leave results as strings rather than breaking the connection.
+        nil
+      end
+
+      # Register a plain-text decoder for each named PostgreSQL type so the
+      # result map returns it unchanged as a String instead of warning that no
+      # cast is defined. Unknown type names are skipped silently.
+      def register_text_decoders(conn, type_map, type_names)
+        type_names.each do |name|
+          oid = conn.exec_params("SELECT $1::regtype::oid", [name]).getvalue(0, 0).to_i
+          type_map.add_coder(PG::TextDecoder::String.new(oid: oid, name: name, format: 0))
+        rescue PG::Error
+          next
+        end
+      end
+
       def convert_placeholders(sql)
         counter = 0
         sql.gsub("?") { counter += 1; "$#{counter}" }

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.17"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tina4ruby
 version: !ruby/object:Gem::Version
-  version: 3.13.14
+  version: 3.13.17
 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