tina4ruby 3.13.85 → 3.13.87

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8fcb9fe4b1fb31911d0526492fae8dd15ebc272e57d3f536b60b367be0ca55d9
-  data.tar.gz: 497811d42911aafc4feb5b1aff1a4084ea7e00e4d074d9fd5884ac7a09e60d56
+  metadata.gz: 7743996e98fff70baf3c82a0f2a26dfafb24cb0c9ddc46cfc6a3be5a1df4c92f
+  data.tar.gz: 2b747045e71df0e69e7d6bdd3cb2b19309fcea16617770982b5743a4c6db9edc
 SHA512:
-  metadata.gz: 28698513a1fba4a12fcf35fb08ee91cc81ad150971326661164db8ee1ff3503505bfc7f6803c40d62f64a303f1d5aabe4c10adc8dd0a708482d4ddd76ff70bd7
-  data.tar.gz: 52fcfb7dea6f227561c3b6776a6ebb5d7357b1941baed3e1c3eeafefd9a66c2bc3dd71887b5fd22a10826fc0109cb13c7b6cab1ce1b27ece86b35822f08a1c01
+  metadata.gz: f94e1f6feeda985b8c5091c0235181bb34165f4ee42120fa808b5b8a39cd8deaabc8ae9fe68a9c05d33598d184680d3b49c40f9791b1f0d2fb57689a87b73054
+  data.tar.gz: 6d31b432dddc04f237bddd28e6580d294c9427a22b0fda2947a9e2d9e3aba469b2fd06cdb2e0560d8edb60f1383c6916ba407a7efb257202d7cb95e381514083

data/lib/tina4/database/sqlite3_adapter.rb

@@ -60,7 +60,7 @@ module Tina4
       # Execute a query and return rows as array of symbol-keyed hashes
       def query(sql, params = [])
         results = @connection.execute(sql, params)
-        results.map { |row| symbolize_keys(row) }
+        symbolize_rows(results)
       end
 
       # Paginated fetch
@@ -155,11 +155,31 @@ module Tina4
 
       private
 
-      def symbolize_keys(hash)
-        hash.each_with_object({}) do |(k, v), h|
-          h[k.to_s.to_sym] = v if k.is_a?(String) || k.is_a?(Symbol)
+      # Symbolize a whole result set's keys, computing the mapping ONCE per query
+      # rather than per cell. See the matching helper in drivers/sqlite_driver.rb
+      # for the rationale: the per-row form ran k.to_s.to_sym for every cell, so a
+      # 5,000-row x 6-column fetch did 30,000 conversions for 6 distinct keys. The
+      # is_a? guard still drops any positional Integer keys older gems emit.
+      def symbolize_rows(rows)
+        return rows if rows.empty?
+
+        str_keys = rows.first.keys.select { |k| k.is_a?(String) || k.is_a?(Symbol) }
+        sym_keys = str_keys.map(&:to_sym)
+        count = str_keys.length
+        rows.map do |row|
+          out = {}
+          i = 0
+          while i < count
+            out[sym_keys[i]] = row[str_keys[i]]
+            i += 1
+          end
+          out
         end
       end
+
+      def symbolize_keys(hash)
+        symbolize_rows([hash]).first
+      end
     end
   end
 end

data/lib/tina4/database.rb

@@ -517,7 +517,11 @@ module Tina4
       if drv.respond_to?(:insert)
         result = drv.insert(table, data)
         autocommit_standalone_write(drv)
-        return result
+        # A driver that owns its insert (PostgreSQL, via RETURNING *) returns a
+        # Hash { success:, last_id: }; normalise it to a DatabaseResult so every
+        # engine returns the same write-result shape (parity with Python master).
+        last_id = result.is_a?(Hash) ? result[:last_id] : drv.last_insert_id
+        return Tina4::DatabaseResult.new([], affected_rows: write_affected(drv, 1), last_id: last_id)
       end
 
       columns = data.keys.map(&:to_s)
@@ -526,8 +530,17 @@ module Tina4
       drv.execute(sql, data.values)
       last_id = drv.last_insert_id
       autocommit_standalone_write(drv)
-      { success: true, last_id: last_id }
+      Tina4::DatabaseResult.new([], affected_rows: write_affected(drv, 1), last_id: last_id)
+    end
+
+    # Rows a write affected, read from the driver where it exposes a count
+    # (SQLite: connection.changes), else a best-effort default (1 for a single
+    # insert). Mirrors the Python master + PHP, whose write DatabaseResult carries
+    # affected_rows/affectedRows; best-effort on drivers without a native count.
+    def write_affected(drv, default = 0)
+      drv.respond_to?(:affected_rows) ? drv.affected_rows.to_i : default
     end
+    private :write_affected
 
     def update(table, data, filter = {}, params = nil)
       cache_invalidate if @cache_enabled
@@ -540,7 +553,7 @@ module Tina4
         sql += " WHERE #{filter}" unless filter.empty?
         drv.execute(sql, data.values + Array(params))
         autocommit_standalone_write(drv)
-        return { success: true }
+        return Tina4::DatabaseResult.new([], affected_rows: write_affected(drv))
       end
 
       set_parts = data.keys.map { |k| "#{k} = #{drv.placeholder}" }
@@ -550,7 +563,7 @@ module Tina4
       values = data.values + filter.values
       drv.execute(sql, values)
       autocommit_standalone_write(drv)
-      { success: true }
+      Tina4::DatabaseResult.new([], affected_rows: write_affected(drv))
     end
 
     def delete(table, filter = {}, params = nil)
@@ -559,8 +572,9 @@ module Tina4
 
       # List of hashes — delete each row
       if filter.is_a?(Array)
-        filter.each { |row| delete(table, row) }
-        return { success: true }
+        total = 0
+        filter.each { |row| total += delete(table, row).affected_rows }
+        return Tina4::DatabaseResult.new([], affected_rows: total)
       end
 
       # String filter — raw WHERE clause with optional params
@@ -569,7 +583,7 @@ module Tina4
         sql += " WHERE #{filter}" unless filter.empty?
         drv.execute(sql, Array(params))
         autocommit_standalone_write(drv)
-        return { success: true }
+        return Tina4::DatabaseResult.new([], affected_rows: write_affected(drv))
       end
 
       # Hash filter — build WHERE from keys
@@ -578,7 +592,7 @@ module Tina4
       sql += " WHERE #{where_parts.join(' AND ')}" unless filter.empty?
       drv.execute(sql, filter.values)
       autocommit_standalone_write(drv)
-      { success: true }
+      Tina4::DatabaseResult.new([], affected_rows: write_affected(drv))
     end
 
     # Return the last execute() error message, or nil.

data/lib/tina4/drivers/firebird_driver.rb

@@ -213,16 +213,38 @@ module Tina4
         "SELECT FIRST #{limit} SKIP #{offset} * FROM (#{sql})"
       end
 
+      # Transaction handling — mirrors the Python master's connection-level
+      # contract (tina4_python firebird.py: start_transaction sets a flag,
+      # commit/rollback act on the connection).
+      #
+      # In the `fb` gem the transaction lives ON the connection:
+      # `Fb::Connection#transaction` (no block) STARTS a transaction and returns
+      # `true` (a boolean — NOT a transaction object), and
+      # `Fb::Connection#commit` / `#rollback` end it. The old code stored that
+      # boolean in `@transaction` and called `@transaction&.commit` /
+      # `&.rollback`, i.e. `true.commit` / `true.rollback` — a NoMethodError that
+      # broke every explicit-transaction commit AND rollback (a rolled-back write
+      # was never undone). We now start the transaction on the connection and
+      # commit/rollback the CONNECTION, tracking open-ness with an
+      # `@in_transaction` boolean (parity with Python's `_in_transaction`).
+      #
+      # A standalone write auto-commits inside the gem's own `execute`, so the
+      # framework's autocommit_standalone_write then calls #commit with no txn
+      # open — `Fb::Connection#commit` is a harmless no-op there (returns nil, no
+      # raise), so standalone-autocommit is preserved.
       def begin_transaction
-        @transaction = @connection.transaction
+        @connection.transaction
+        @in_transaction = true
       end
 
       def commit
-        @transaction&.commit
+        @connection&.commit
+        @in_transaction = false
       end
 
       def rollback
-        @transaction&.rollback
+        @connection&.rollback
+        @in_transaction = false
       end
 
       def tables
@@ -263,7 +285,7 @@ module Tina4
           # connection already gone — nothing to clean up
         end
         @connection = nil
-        @transaction = nil
+        @in_transaction = false
         open_connection
       end
 
@@ -273,7 +295,7 @@ module Tina4
       def with_reconnect
         yield
       rescue StandardError => e
-        raise unless self.class.dead_connection?(e) && @transaction.nil?
+        raise unless self.class.dead_connection?(e) && !@in_transaction
         reconnect!
         yield
       end

data/lib/tina4/drivers/odbc_driver.rb

@@ -182,11 +182,9 @@ module Tina4
 
       private
 
-      def symbolize_keys(hash)
-        hash.each_with_object({}) do |(k, v), h|
-          h[k.to_s.to_sym] = v if k.is_a?(String) || k.is_a?(Symbol)
-        end
-      end
+      # (No symbolize_keys here: execute_query already hydrates by zipping a
+      # once-computed symbol column list against each array row, so there is no
+      # per-cell symbolize to hoist. A leftover unused symbolize_keys was removed.)
     end
   end
 end

data/lib/tina4/drivers/postgres_driver.rb

@@ -40,7 +40,7 @@ module Tina4
                  else
                    @connection.exec_params(converted_sql, params)
                  end
-        result.map { |row| decode_blobs(symbolize_keys(row)) }
+        symbolize_result(result)
       end
 
       def execute(sql, params = [])
@@ -297,8 +297,36 @@ module Tina4
         sql.gsub("?") { counter += 1; "$#{counter}" }
       end
 
-      def symbolize_keys(hash)
-        hash.each_with_object({}) { |(k, v), h| h[k.to_sym] = v }
+      # Hydrate a PG::Result into an array of symbol-keyed row hashes.
+      #
+      # The old path did `result.map { |row| decode_blobs(symbolize_keys(row)) }`,
+      # which made the pg gem build a string-keyed Hash PER ROW and then rebuilt
+      # each as symbol-keyed with a per-cell `k.to_sym` -- two hashes per row plus
+      # N symbol conversions per row. This reads directly from `each_row` (the gem
+      # yields positional String arrays, no per-row Hash) against the field names
+      # symbolised ONCE for the whole result. Measured on real PostgreSQL 16.14,
+      # a 5,000-row x 7-column fetch went 13.84ms -> 7.55ms (-45%) with
+      # byte-identical output (values are the same String forms `map` produced,
+      # e.g. "t" for a boolean, nil for NULL). Duplicate column names from a JOIN
+      # collapse last-wins, exactly as the gem's own row Hash did.
+      #
+      # decode_blobs stays per-row: it inspects values, not keys, so it cannot be
+      # hoisted. It is currently a documented no-op (pg returns bytea as raw
+      # ASCII-8BIT strings); keeping the call preserves the seam.
+      def symbolize_result(result)
+        fields = result.fields.map(&:to_sym)
+        count = fields.length
+        rows = []
+        result.each_row do |values|
+          row = {}
+          i = 0
+          while i < count
+            row[fields[i]] = values[i]
+            i += 1
+          end
+          rows << decode_blobs(row)
+        end
+        rows
       end
 
       # Ensure binary (bytea) columns are proper byte strings.

data/lib/tina4/drivers/sqlite_driver.rb

@@ -72,7 +72,7 @@ module Tina4
 
       def execute_query(sql, params = [])
         results = @connection.execute(sql, coerce_params(params))
-        results.map { |row| symbolize_keys(row) }
+        symbolize_rows(results)
       end
 
       def execute(sql, params = [])
@@ -101,6 +101,13 @@ module Tina4
         @connection.last_insert_row_id
       end
 
+      # Rows changed by the most recent INSERT/UPDATE/DELETE on this connection.
+      # Feeds Database#insert/update/delete's DatabaseResult.affected_rows (parity
+      # with the Python master + PHP, which surface affectedRows on writes).
+      def affected_rows
+        @connection.changes
+      end
+
       def placeholder
         "?"
       end
@@ -174,11 +181,42 @@ module Tina4
         str.to_s.match?(/\A[A-Za-z_][A-Za-z0-9_]*\z/)
       end
 
-      def symbolize_keys(hash)
-        hash.each_with_object({}) do |(k, v), h|
-          h[k.to_s.to_sym] = v if k.is_a?(String) || k.is_a?(Symbol)
+      # Symbolize the keys of a whole result set, computing the key mapping ONCE.
+      #
+      # results_as_hash=true hands back string-keyed hashes; every row of a query
+      # has the same columns, so the string->symbol conversion is identical for
+      # every row. The old code called `symbolize_keys` per row, which ran
+      # `k.to_s.to_sym` and an `is_a?` guard PER CELL: a 5,000-row x 6-column
+      # fetch did 30,000 conversions for 6 distinct keys and made Tina4 the
+      # slowest of the four frameworks at bulk reads (Select ALL 5,000 rows:
+      # 10.16ms vs raw sqlite3 2.56ms). Hoisting the mapping out of the loop
+      # roughly halves the hydration cost with byte-identical output.
+      #
+      # The is_a?(String|Symbol) guard is preserved: older sqlite3 gems put
+      # positional Integer keys in the hash alongside the string names, and those
+      # must still be dropped.
+      def symbolize_rows(rows)
+        return rows if rows.empty?
+
+        str_keys = rows.first.keys.select { |k| k.is_a?(String) || k.is_a?(Symbol) }
+        sym_keys = str_keys.map(&:to_sym)
+        count = str_keys.length
+        rows.map do |row|
+          out = {}
+          i = 0
+          while i < count
+            out[sym_keys[i]] = row[str_keys[i]]
+            i += 1
+          end
+          out
         end
       end
+
+      # Single-hash convenience kept for any external caller; delegates to the
+      # batch path so there is one implementation of the mapping rule.
+      def symbolize_keys(hash)
+        symbolize_rows([hash]).first
+      end
     end
   end
 end