activerecord 3.1.11 → 3.2.0

data/lib/active_record/connection_adapters/postgresql_adapter.rb

@@ -1,8 +1,6 @@
 require 'active_record/connection_adapters/abstract_adapter'
-require 'active_support/core_ext/kernel/requires'
 require 'active_support/core_ext/object/blank'
 require 'active_record/connection_adapters/statement_pool'
-require 'arel/visitors/bind_visitor'
 
 # Make sure we're using pg high enough for PGResult#values
 gem 'pg', '~> 0.11'
@@ -201,7 +199,7 @@ module ActiveRecord
     # * <tt>:password</tt> - Defaults to nothing.
     # * <tt>:database</tt> - The name of the database. No default, must be provided.
     # * <tt>:schema_search_path</tt> - An optional schema search path for the connection given
-    #   as a string of comma-separated schema names.  This is backward-compatible with the <tt>:schema_order</tt> option.
+    #   as a string of comma-separated schema names. This is backward-compatible with the <tt>:schema_order</tt> option.
     # * <tt>:encoding</tt> - An optional client encoding that is used in a <tt>SET client_encoding TO
     #   <encoding></tt> call on the connection.
     # * <tt>:min_messages</tt> - An optional client min messages that is used in a
@@ -249,6 +247,10 @@ module ActiveRecord
         true
       end
 
+      def supports_index_sort_order?
+        true
+      end
+
       class StatementPool < ConnectionAdapters::StatementPool
         def initialize(connection, max)
           super
@@ -301,17 +303,11 @@ module ActiveRecord
         end
       end
 
-      class BindSubstitution < Arel::Visitors::PostgreSQL # :nodoc:
-        include Arel::Visitors::BindVisitor
-      end
-
       # Initializes and connects a PostgreSQL adapter.
       def initialize(connection, logger, connection_parameters, config)
         super(connection, logger)
-
-        connection_parameters.delete :prepared_statements
-
         @connection_parameters, @config = connection_parameters, config
+        @visitor = Arel::Visitors::PostgreSQL.new self
 
         # @local_tz is initialized as nil to avoid warnings when connect tries to use it
         @local_tz = nil
@@ -328,15 +324,6 @@ module ActiveRecord
         @local_tz = execute('SHOW TIME ZONE', 'SCHEMA').first["TimeZone"]
       end
 
-      def self.visitor_for(pool) # :nodoc:
-        config = pool.spec.config
-        if config.fetch(:prepared_statements) { true }
-          Arel::Visitors::PostgreSQL.new pool
-        else
-          BindSubstitution.new pool
-        end
-      end
-
       # Clears the prepared statements cache.
       def clear_cache!
         @statements.clear
@@ -403,6 +390,11 @@ module ActiveRecord
         true
       end
 
+      # Returns true.
+      def supports_explain?
+        true
+      end
+
       # Returns the configured supported identifier length supported by PostgreSQL
       def table_alias_length
         @table_alias_length ||= query('SHOW max_identifier_length')[0][0].to_i
@@ -527,6 +519,48 @@ module ActiveRecord
 
       # DATABASE STATEMENTS ======================================
 
+      def explain(arel, binds = [])
+        sql = "EXPLAIN #{to_sql(arel)}"
+        ExplainPrettyPrinter.new.pp(exec_query(sql, 'EXPLAIN', binds))
+      end
+
+      class ExplainPrettyPrinter # :nodoc:
+        # Pretty prints the result of a EXPLAIN in a way that resembles the output of the
+        # PostgreSQL shell:
+        #
+        #                                     QUERY PLAN
+        #   ------------------------------------------------------------------------------
+        #    Nested Loop Left Join  (cost=0.00..37.24 rows=8 width=0)
+        #      Join Filter: (posts.user_id = users.id)
+        #      ->  Index Scan using users_pkey on users  (cost=0.00..8.27 rows=1 width=4)
+        #            Index Cond: (id = 1)
+        #      ->  Seq Scan on posts  (cost=0.00..28.88 rows=8 width=4)
+        #            Filter: (posts.user_id = 1)
+        #   (6 rows)
+        #
+        def pp(result)
+          header = result.columns.first
+          lines  = result.rows.map(&:first)
+
+          # We add 2 because there's one char of padding at both sides, note
+          # the extra hyphens in the example above.
+          width = [header, *lines].map(&:length).max + 2
+
+          pp = []
+
+          pp << header.center(width).rstrip
+          pp << '-' * width
+
+          pp += lines.map {|line| " #{line}"}
+
+          nrows = result.rows.length
+          rows_label = nrows == 1 ? 'row' : 'rows'
+          pp << "(#{nrows} #{rows_label})"
+
+          pp.join("\n") + "\n"
+        end
+      end
+
       # Executes a SELECT query and returns an array of rows. Each row is an
       # array of field values.
       def select_rows(sql, name = nil)
@@ -535,10 +569,11 @@ module ActiveRecord
 
       # Executes an INSERT query and returns the new record's ID
       def insert_sql(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)
-        # Extract the table from the insert sql. Yuck.
-        _, table = extract_schema_and_table(sql.split(" ", 4)[2])
-
-        pk ||= primary_key(table)
+        unless pk
+          # Extract the table from the insert sql. Yuck.
+          table_ref = extract_table_ref_from_insert_sql(sql)
+          pk = primary_key(table_ref) if table_ref
+        end
 
         if pk
           select_value("#{sql} RETURNING #{quote_column_name(pk)}")
@@ -607,7 +642,7 @@ module ActiveRecord
       end
 
       def substitute_at(column, index)
-        Arel::Nodes::BindParam.new "$#{index + 1}"
+        Arel.sql("$#{index + 1}")
       end
 
       def exec_query(sql, name = 'SQL', binds = [])
@@ -634,9 +669,9 @@ module ActiveRecord
 
       def sql_for_insert(sql, pk, id_value, sequence_name, binds)
         unless pk
-          _, table = extract_schema_and_table(sql.split(" ", 4)[2])
-
-          pk = primary_key(table)
+          # Extract the table from the insert sql. Yuck.
+          table_ref = extract_table_ref_from_insert_sql(sql)
+          pk = primary_key(table_ref) if table_ref
         end
 
         sql = "#{sql} RETURNING #{quote_column_name(pk)}" if pk
@@ -682,12 +717,14 @@ module ActiveRecord
 
       # SCHEMA STATEMENTS ========================================
 
-      def recreate_database(name) #:nodoc:
+      # Drops the database specified on the +name+ attribute
+      # and creates it again using the provided +options+.
+      def recreate_database(name, options = {}) #:nodoc:
         drop_database(name)
-        create_database(name)
+        create_database(name, options)
       end
 
-      # Create a new PostgreSQL database.  Options include <tt>:owner</tt>, <tt>:template</tt>,
+      # Create a new PostgreSQL database. Options include <tt>:owner</tt>, <tt>:template</tt>,
       # <tt>:encoding</tt>, <tt>:tablespace</tt>, and <tt>:connection_limit</tt> (note that MySQL uses
       # <tt>:charset</tt> while PostgreSQL uses <tt>:encoding</tt>).
       #
@@ -734,41 +771,39 @@ module ActiveRecord
         SQL
       end
 
+      # Returns true if table exists.
+      # If the schema is not specified as part of +name+ then it will only find tables within
+      # the current schema search path (regardless of permissions to access tables in other schemas)
       def table_exists?(name)
-        schema, table = extract_schema_and_table(name.to_s)
-        return false unless table # Abstract classes is having nil table name
+        schema, table = Utils.extract_schema_and_table(name.to_s)
+        return false unless table
 
-        binds = [[nil, table.gsub(/(^"|"$)/,'')]]
+        binds = [[nil, table]]
         binds << [nil, schema] if schema
 
         exec_query(<<-SQL, 'SCHEMA', binds).rows.first[0].to_i > 0
             SELECT COUNT(*)
-            FROM pg_tables
-            WHERE tablename = $1
-           AND schemaname = #{schema ? "$2" : "ANY (current_schemas(false))"}
+            FROM pg_class c
+            LEFT JOIN pg_namespace n ON n.oid = c.relnamespace
+            WHERE c.relkind in ('v','r')
+            AND c.relname = $1
+            AND n.nspname = #{schema ? '$2' : 'ANY (current_schemas(false))'}
         SQL
       end
 
-      # Extracts the table and schema name from +name+
-      def extract_schema_and_table(name)
-        schema, table = name.split('.', 2)
-
-        unless table # A table was provided without a schema
-          table  = schema
-          schema = nil
-        end
-
-        if name =~ /^"/ # Handle quoted table names
-          table  = name
-          schema = nil
-        end
-        [schema, table]
+      # Returns true if schema exists.
+      def schema_exists?(name)
+        exec_query(<<-SQL, 'SCHEMA', [[nil, name]]).rows.first[0].to_i > 0
+          SELECT COUNT(*)
+          FROM pg_namespace
+          WHERE nspname = $1
+        SQL
       end
 
       # Returns an array of indexes for the given table.
       def indexes(table_name, name = nil)
          result = query(<<-SQL, name)
-           SELECT distinct i.relname, d.indisunique, d.indkey, t.oid
+           SELECT distinct i.relname, d.indisunique, d.indkey, pg_get_indexdef(d.indexrelid), t.oid
            FROM pg_class t
            INNER JOIN pg_index d ON t.oid = d.indrelid
            INNER JOIN pg_class i ON d.indexrelid = i.oid
@@ -784,7 +819,8 @@ module ActiveRecord
           index_name = row[0]
           unique = row[1] == 't'
           indkey = row[2].split(" ")
-          oid = row[3]
+          inddef = row[3]
+          oid = row[4]
 
           columns = Hash[query(<<-SQL, "Columns for index #{row[0]} on #{table_name}")]
           SELECT a.attnum, a.attname
@@ -794,7 +830,12 @@ module ActiveRecord
           SQL
 
           column_names = columns.values_at(*indkey).compact
-          column_names.empty? ? nil : IndexDefinition.new(table_name, index_name, unique, column_names)
+
+          # add info on sort order for columns (only desc order is explicitly specified, asc is the default)
+          desc_order_columns = inddef.scan(/(\w+) DESC/).flatten
+          orders = desc_order_columns.any? ? Hash[desc_order_columns.map {|order_column| [order_column, :desc]}] : {}
+      
+          column_names.empty? ? nil : IndexDefinition.new(table_name, index_name, unique, column_names, [], orders)
         end.compact
       end
 
@@ -811,6 +852,11 @@ module ActiveRecord
         query('select current_database()')[0][0]
       end
 
+      # Returns the current schema name.
+      def current_schema
+        query('SELECT current_schema', 'SCHEMA')[0][0]
+      end
+
       # Returns the current database encoding format.
       def encoding
         query(<<-end_sql)[0][0]
@@ -833,7 +879,7 @@ module ActiveRecord
 
       # Returns the active schema search path.
       def schema_search_path
-        @schema_search_path ||= query('SHOW search_path')[0][0]
+        @schema_search_path ||= query('SHOW search_path', 'SCHEMA')[0][0]
       end
 
       # Returns the current client message level.
@@ -874,7 +920,7 @@ module ActiveRecord
         end
 
         if pk && sequence
-          quoted_sequence = quote_column_name(sequence)
+          quoted_sequence = quote_table_name(sequence)
 
           select_value <<-end_sql, 'Reset sequence'
             SELECT setval('#{quoted_sequence}', (SELECT COALESCE(MAX(#{quote_column_name pk})+(SELECT increment_by FROM #{quoted_sequence}), (SELECT min_value FROM #{quoted_sequence})) FROM #{quote_table_name(table)}), false)
@@ -886,46 +932,26 @@ module ActiveRecord
       def pk_and_sequence_for(table) #:nodoc:
         # First try looking for a sequence with a dependency on the
         # given table's primary key.
-        result = query(<<-end_sql, 'PK and serial sequence')[0]
-          SELECT attr.attname, seq.relname
-          FROM pg_class      seq,
-               pg_attribute  attr,
-               pg_depend     dep,
-               pg_namespace  name,
-               pg_constraint cons
-          WHERE seq.oid           = dep.objid
-            AND seq.relkind       = 'S'
-            AND attr.attrelid     = dep.refobjid
-            AND attr.attnum       = dep.refobjsubid
-            AND attr.attrelid     = cons.conrelid
-            AND attr.attnum       = cons.conkey[1]
-            AND cons.contype      = 'p'
-            AND dep.refobjid      = '#{quote_table_name(table)}'::regclass
+        result = exec_query(<<-end_sql, 'SCHEMA').rows.first
+          SELECT attr.attname, ns.nspname, seq.relname
+          FROM pg_class seq
+          INNER JOIN pg_depend dep ON seq.oid = dep.objid
+          INNER JOIN pg_attribute attr ON attr.attrelid = dep.refobjid AND attr.attnum = dep.refobjsubid
+          INNER JOIN pg_constraint cons ON attr.attrelid = cons.conrelid AND attr.attnum = cons.conkey[1]
+          INNER JOIN pg_namespace ns ON seq.relnamespace = ns.oid
+          WHERE seq.relkind  = 'S'
+            AND cons.contype = 'p'
+            AND dep.refobjid = '#{quote_table_name(table)}'::regclass
         end_sql
 
-        if result.nil? or result.empty?
-          # If that fails, try parsing the primary key's default value.
-          # Support the 7.x and 8.0 nextval('foo'::text) as well as
-          # the 8.1+ nextval('foo'::regclass).
-          result = query(<<-end_sql, 'PK and custom sequence')[0]
-            SELECT attr.attname,
-              CASE
-                WHEN split_part(def.adsrc, '''', 2) ~ '.' THEN
-                  substr(split_part(def.adsrc, '''', 2),
-                         strpos(split_part(def.adsrc, '''', 2), '.')+1)
-                ELSE split_part(def.adsrc, '''', 2)
-              END
-            FROM pg_class       t
-            JOIN pg_attribute   attr ON (t.oid = attrelid)
-            JOIN pg_attrdef     def  ON (adrelid = attrelid AND adnum = attnum)
-            JOIN pg_constraint  cons ON (conrelid = adrelid AND adnum = conkey[1])
-            WHERE t.oid = '#{quote_table_name(table)}'::regclass
-              AND cons.contype = 'p'
-              AND def.adsrc ~* 'nextval'
-          end_sql
+        # [primary_key, sequence]
+        if result.second ==  'public' then
+          sequence = result.last
+        else
+          sequence = result.second+'.'+result.last
         end
 
-        [result.first, result.last]
+        [result.first, sequence]
       rescue
         nil
       end
@@ -1037,6 +1063,25 @@ module ActiveRecord
         "DISTINCT #{columns}, #{order_columns * ', '}"
       end
 
+      module Utils
+        extend self
+
+        # Returns an array of <tt>[schema_name, table_name]</tt> extracted from +name+.
+        # +schema_name+ is nil if not specified in +name+.
+        # +schema_name+ and +table_name+ exclude surrounding quotes (regardless of whether provided in +name+)
+        # +name+ supports the range of schema/table references understood by PostgreSQL, for example:
+        #
+        # * <tt>table_name</tt>
+        # * <tt>"table.name"</tt>
+        # * <tt>schema_name.table_name</tt>
+        # * <tt>schema_name."table.name"</tt>
+        # * <tt>"schema.name"."table name"</tt>
+        def extract_schema_and_table(name)
+          table, schema = name.scan(/[^".\s]+|"[^"]*"/)[0..1].collect{|m| m.gsub(/(^"|"$)/,'') }.reverse
+          [schema, table]
+        end
+      end
+
       protected
         # Returns the version of the connected PostgreSQL server.
         def postgresql_version
@@ -1203,9 +1248,14 @@ module ActiveRecord
           end
         end
 
-      def table_definition
-        TableDefinition.new(self)
-      end
+        def extract_table_ref_from_insert_sql(sql)
+          sql[/into\s+([^\(]*).*values\s*\(/i]
+          $1.strip if $1
+        end
+
+        def table_definition
+          TableDefinition.new(self)
+        end
     end
   end
 end

data/lib/active_record/connection_adapters/schema_cache.rb

@@ -0,0 +1,50 @@
+module ActiveRecord
+  module ConnectionAdapters
+    class SchemaCache
+      attr_reader :columns, :columns_hash, :primary_keys, :tables
+      attr_reader :connection
+
+      def initialize(conn)
+        @connection = conn
+        @tables     = {}
+
+        @columns = Hash.new do |h, table_name|
+          h[table_name] = conn.columns(table_name, "#{table_name} Columns")
+        end
+
+        @columns_hash = Hash.new do |h, table_name|
+          h[table_name] = Hash[columns[table_name].map { |col|
+            [col.name, col]
+          }]
+        end
+
+        @primary_keys = Hash.new do |h, table_name|
+          h[table_name] = table_exists?(table_name) ? conn.primary_key(table_name) : nil
+        end
+      end
+
+      # A cached lookup for table existence.
+      def table_exists?(name)
+        return @tables[name] if @tables.key? name
+
+        @tables[name] = connection.table_exists?(name)
+      end
+
+      # Clears out internal caches
+      def clear!
+        @columns.clear
+        @columns_hash.clear
+        @primary_keys.clear
+        @tables.clear
+      end
+
+      # Clear out internal caches for table with +table_name+.
+      def clear_table_cache!(table_name)
+        @columns.delete table_name
+        @columns_hash.delete table_name
+        @primary_keys.delete table_name
+        @tables.delete table_name
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/sqlite3_adapter.rb

@@ -1,6 +1,6 @@
 require 'active_record/connection_adapters/sqlite_adapter'
 
-gem 'sqlite3', '~> 1.3.4'
+gem 'sqlite3', '~> 1.3.5'
 require 'sqlite3'
 
 module ActiveRecord
@@ -47,11 +47,7 @@ module ActiveRecord
 
       # Returns the current database encoding format as a string, eg: 'UTF-8'
       def encoding
-        if @connection.respond_to?(:encoding)
-          @connection.encoding.to_s
-        else
-          @connection.execute('PRAGMA encoding')[0]['encoding']
-        end
+        @connection.encoding.to_s
       end
 
     end

data/lib/active_record/connection_adapters/sqlite_adapter.rb

@@ -1,8 +1,6 @@
 require 'active_record/connection_adapters/abstract_adapter'
-require 'active_support/core_ext/kernel/requires'
 require 'active_record/connection_adapters/statement_pool'
 require 'active_support/core_ext/string/encoding'
-require 'arel/visitors/bind_visitor'
 
 module ActiveRecord
   module ConnectionAdapters #:nodoc:
@@ -86,25 +84,12 @@ module ActiveRecord
         end
       end
 
-      class BindSubstitution < Arel::Visitors::SQLite # :nodoc:
-        include Arel::Visitors::BindVisitor
-      end
-
       def initialize(connection, logger, config)
         super(connection, logger)
         @statements = StatementPool.new(@connection,
                                         config.fetch(:statement_limit) { 1000 })
         @config = config
-      end
-
-      def self.visitor_for(pool) # :nodoc:
-        config = pool.spec.config
-
-        if config.fetch(:prepared_statements) { true }
-          Arel::Visitors::SQLite.new pool
-        else
-          BindSubstitution.new pool
-        end
+        @visitor = Arel::Visitors::SQLite.new self
       end
 
       def adapter_name #:nodoc:
@@ -137,6 +122,11 @@ module ActiveRecord
         true
       end
 
+      # Returns true.
+      def supports_explain?
+        true
+      end
+
       def requires_reloading?
         true
       end
@@ -169,6 +159,10 @@ module ActiveRecord
         sqlite_version >= '3.1.0'
       end
 
+      def supports_index_sort_order?
+        sqlite_version >= '3.3.0'
+      end
+
       def native_database_types #:nodoc:
         {
           :primary_key => default_primary_key_type,
@@ -215,7 +209,7 @@ module ActiveRecord
 
           value = super
           if column.type == :string && value.encoding == Encoding::ASCII_8BIT
-            logger.error "Binary data inserted for `string` type on column `#{column.name}`" if logger
+            @logger.error "Binary data inserted for `string` type on column `#{column.name}`"
             value.encode! 'utf-8'
           end
           value
@@ -230,6 +224,25 @@ module ActiveRecord
 
       # DATABASE STATEMENTS ======================================
 
+      def explain(arel, binds = [])
+        sql = "EXPLAIN QUERY PLAN #{to_sql(arel)}"
+        ExplainPrettyPrinter.new.pp(exec_query(sql, 'EXPLAIN', binds))
+      end
+
+      class ExplainPrettyPrinter
+        # Pretty prints the result of a EXPLAIN QUERY PLAN in a way that resembles
+        # the output of the SQLite shell:
+        #
+        #   0|0|0|SEARCH TABLE users USING INTEGER PRIMARY KEY (rowid=?) (~1 rows)
+        #   0|1|1|SCAN TABLE posts (~100000 rows)
+        #
+        def pp(result) # :nodoc:
+          result.rows.map do |row|
+            row.join('|')
+          end.join("\n") + "\n"
+        end
+      end
+
       def exec_query(sql, name = nil, binds = [])
         log(sql, name, binds) do
 
@@ -303,31 +316,36 @@ module ActiveRecord
       end
 
       def begin_db_transaction #:nodoc:
-        @connection.transaction
+        log('begin transaction',nil) { @connection.transaction }
       end
 
       def commit_db_transaction #:nodoc:
-        @connection.commit
+        log('commit transaction',nil) { @connection.commit }
       end
 
       def rollback_db_transaction #:nodoc:
-        @connection.rollback
+        log('rollback transaction',nil) { @connection.rollback }
       end
 
       # SCHEMA STATEMENTS ========================================
 
-      def tables(name = 'SCHEMA') #:nodoc:
+      def tables(name = 'SCHEMA', table_name = nil) #:nodoc:
         sql = <<-SQL
           SELECT name
           FROM sqlite_master
           WHERE type = 'table' AND NOT name = 'sqlite_sequence'
         SQL
+        sql << " AND name = #{quote_table_name(table_name)}" if table_name
 
         exec_query(sql, name).map do |row|
           row['name']
         end
       end
 
+      def table_exists?(name)
+        name && tables('SCHEMA', name).any?
+      end
+
       # Returns an array of +SQLiteColumn+ objects for the table specified by +table_name+.
       def columns(table_name, name = nil) #:nodoc:
         table_structure(table_name).map do |field|
@@ -393,7 +411,7 @@ module ActiveRecord
       end
 
       def remove_column(table_name, *column_names) #:nodoc:
-        raise ArgumentError.new("You must specify at least one column name.  Example: remove_column(:people, :first_name)") if column_names.empty?
+        raise ArgumentError.new("You must specify at least one column name. Example: remove_column(:people, :first_name)") if column_names.empty?
         column_names.flatten.each do |column_name|
           alter_table(table_name) do |definition|
             definition.columns.delete(definition[column_name])
@@ -425,6 +443,8 @@ module ActiveRecord
             self.limit   = options[:limit] if options.include?(:limit)
             self.default = options[:default] if include_default
             self.null    = options[:null] if options.include?(:null)
+            self.precision = options[:precision] if options.include?(:precision)
+            self.scale   = options[:scale] if options.include?(:scale)
           end
         end
       end
@@ -479,6 +499,7 @@ module ActiveRecord
 
               @definition.column(column_name, column.type,
                 :limit => column.limit, :default => column.default,
+                :precision => column.precision, :scale => column.scale,
                 :null => column.null)
             end
             @definition.primary_key(primary_key(from)) if primary_key(from)

data/lib/active_record/counter_cache.rb

@@ -2,7 +2,7 @@ module ActiveRecord
   # = Active Record Counter Cache
   module CounterCache
     # Resets one or more counter caches to their correct value using an SQL
-    # count query.  This is useful when adding new counter caches, or if the
+    # count query. This is useful when adding new counter caches, or if the
     # counter has been corrupted or modified directly by SQL.
     #
     # ==== Parameters
@@ -25,9 +25,10 @@ module ActiveRecord
           self.name
         end
 
+        foreign_key  = has_many_association.foreign_key.to_s
         child_class  = has_many_association.klass
         belongs_to   = child_class.reflect_on_all_associations(:belongs_to)
-        reflection   = belongs_to.find { |e| e.class_name == expected_name }
+        reflection   = belongs_to.find { |e| e.foreign_key.to_s == foreign_key }
         counter_name = reflection.counter_cache_column
 
         stmt = unscoped.where(arel_table[primary_key].eq(object.id)).arel.compile_update({
@@ -65,7 +66,7 @@ module ActiveRecord
     #   Post.update_counters [10, 15], :comment_count => 1
     #   # Executes the following SQL:
     #   # UPDATE posts
-    #   #    SET comment_count = COALESCE(comment_count, 0) + 1,
+    #   #    SET comment_count = COALESCE(comment_count, 0) + 1
     #   #  WHERE id IN (10, 15)
     def update_counters(id, counters)
       updates = counters.map do |counter_name, value|