activerecord-spanner-adapter 1.6.3 → 2.0.0

data/lib/activerecord_spanner_adapter/base.rb

@@ -16,6 +16,7 @@ module ActiveRecord
 
   class Base
     VERSION_7_1 = Gem::Version.create "7.1.0"
+    VERSION_7_2 = Gem::Version.create "7.2.0"
 
     # Creates an object (or multiple objects) and saves it to the database. This method will use mutations instead
     # of DML if there is no active transaction, or if the active transaction has been created with the option
@@ -48,8 +49,26 @@ module ActiveRecord
       spanner_adapter? && connection&.current_spanner_transaction&.isolation == :buffered_mutations
     end
 
-    def self._insert_record values, returning = []
-      if !(buffered_mutations? || (primary_key && values.is_a?(Hash))) || !spanner_adapter?
+    def self._should_use_standard_insert_record? values
+      !(buffered_mutations? || (primary_key && values.is_a?(Hash))) || !spanner_adapter?
+    end
+
+    def self._internal_insert_record values
+      if ActiveRecord.gem_version < VERSION_7_2
+        _insert_record values
+      else
+        _insert_record nil, values
+      end
+    end
+
+    def self._insert_record *args
+      if ActiveRecord.gem_version < VERSION_7_2
+        values, returning = args
+      else
+        _connection, values, returning = args
+      end
+
+      if _should_use_standard_insert_record? values
         return super values if ActiveRecord.gem_version < VERSION_7_1
         return super
       end
@@ -57,7 +76,7 @@ module ActiveRecord
       # Mutations cannot be used in combination with a sequence, as mutations do not support a THEN RETURN clause.
       if buffered_mutations? && sequence_name
         raise StatementInvalid, "Mutations cannot be used to create records that use a sequence " \
-                                     "to generate the primary key. #{self} uses #{sequence_name}."
+                                "to generate the primary key. #{self} uses #{sequence_name}."
       end
 
       return _buffer_record values, :insert, returning if buffered_mutations?
@@ -99,20 +118,30 @@ module ActiveRecord
       keys = returning || primary_key
       return primary_key_value if keys == primary_key
 
-      primary_key_values_hash = Hash[primary_key.zip(primary_key_value)]
-      values = []
-      keys.each do |column|
-        values.append primary_key_values_hash[column]
+      primary_key_values_hash = primary_key.zip(primary_key_value).to_h
+      keys.map do |column|
+        primary_key_values_hash[column]
       end
-      values
     end
 
     def self._upsert_record values, returning
       _buffer_record values, :insert_or_update, returning
     end
 
-    def self.insert_all _attributes, **_kwargs
-      raise NotImplementedError, "Cloud Spanner does not support skip_duplicates. Use insert! or upsert instead."
+    def self.insert_all attributes, returning: nil, **_kwargs
+      if active_transaction? && buffered_mutations?
+        raise NotImplementedError,
+              "Spanner does not support skip_duplicates for mutations. " \
+              "Use a transaction that uses DML, or use insert! or upsert instead."
+      end
+      super
+    end
+
+    def self.insert! attributes, returning: nil, **kwargs
+      return super unless spanner_adapter?
+      return super if active_transaction? && !buffered_mutations?
+
+      insert_all! [attributes], returning: returning, **kwargs
     end
 
     def self.insert_all! attributes, returning: nil, **_kwargs
@@ -123,24 +152,27 @@ module ActiveRecord
       # The mutations will be sent as one batch when the transaction is committed.
       if active_transaction?
         attributes.each do |record|
-          _insert_record record
+          _internal_insert_record record
         end
       else
         transaction isolation: :buffered_mutations do
           attributes.each do |record|
-            _insert_record record
+            _internal_insert_record record
           end
         end
       end
     end
 
-    def self.upsert_all attributes, returning: nil, unique_by: nil, **_kwargs
+    def self.upsert attributes, returning: nil, **kwargs
       return super unless spanner_adapter?
-      if active_transaction? && !buffered_mutations?
-        raise NotImplementedError, "Cloud Spanner does not support upsert using DML. " \
-                                   "Use upsert outside a transaction block or in a transaction " \
-                                   "block with isolation: :buffered_mutations"
-      end
+      return super if active_transaction? && !buffered_mutations?
+
+      upsert_all [attributes], returning: returning, **kwargs
+    end
+
+    def self.upsert_all attributes, returning: nil, unique_by: nil, **kwargs
+      return super unless spanner_adapter?
+      return super if active_transaction? && !buffered_mutations?
 
       # This might seem inefficient, but is actually not, as it is only buffering a mutation locally.
       # The mutations will be sent as one batch when the transaction is committed.
@@ -182,11 +214,9 @@ module ActiveRecord
     end
 
     def self._set_composite_primary_key_values primary_key, values
-      primary_key_value = []
-      primary_key.each do |col|
-        primary_key_value.append _set_composite_primary_key_value col, values
+      primary_key.map do |col|
+        _set_composite_primary_key_value col, values
       end
-      primary_key_value
     end
 
     def self._set_composite_primary_key_value primary_key, values
@@ -385,14 +415,12 @@ module ActiveRecord
     end
 
     def serialize_keys metadata, keys
-      serialized_values = []
-      keys.each do |key|
-        serialized_values << ActiveRecord::Type::Spanner::SpannerActiveRecordConverter
-                             .serialize_with_transaction_isolation_level(metadata.type(key),
-                                                                         attribute_in_database(key),
-                                                                         :mutation)
+      keys.map do |key|
+        ActiveRecord::Type::Spanner::SpannerActiveRecordConverter
+          .serialize_with_transaction_isolation_level(metadata.type(key),
+                                                      attribute_in_database(key),
+                                                      :mutation)
       end
-      serialized_values
     end
 
     def _execute_version_check attempted_action # rubocop:disable Metrics/AbcSize
@@ -422,7 +450,7 @@ module ActiveRecord
 
       # We need to check the version using a SELECT query, as a mutation cannot include a WHERE clause.
       sql = "SELECT 1 FROM `#{self.class.arel_table.name}` " \
-              "WHERE #{pk_sql} AND `#{locking_column}` = @lock_version"
+            "WHERE #{pk_sql} AND `#{locking_column}` = @lock_version"
       locked_row = self.class.connection.raw_connection.execute_query sql, params: params, types: param_types
       raise ActiveRecord::StaleObjectError.new(self, attempted_action) unless locked_row.rows.any?
     end

data/lib/activerecord_spanner_adapter/connection.rb

@@ -10,7 +10,9 @@ require "activerecord_spanner_adapter/information_schema"
 
 module ActiveRecordSpannerAdapter
   class Connection
-    attr_reader :instance_id, :database_id, :spanner
+    attr_reader :instance_id
+    attr_reader :database_id
+    attr_reader :spanner
     attr_accessor :current_transaction
 
     def initialize config
@@ -45,7 +47,7 @@ module ActiveRecordSpannerAdapter
 
     def self.information_schema config
       @information_schemas ||= {}
-      @information_schemas[database_path(config)] ||= \
+      @information_schemas[database_path(config)] ||=
         ActiveRecordSpannerAdapter::InformationSchema.new new(config)
     end
 
@@ -202,7 +204,7 @@ module ActiveRecordSpannerAdapter
 
     def execute_query sql, params: nil, types: nil, single_use_selector: nil, request_options: nil
       if params
-        converted_params, types = \
+        converted_params, types =
           Google::Cloud::Spanner::Convert.to_input_params_and_types(
             params, types
           )
@@ -217,6 +219,7 @@ module ActiveRecordSpannerAdapter
       execute_sql_request sql, converted_params, types, selector, request_options
     end
 
+    # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
     def execute_sql_request sql, converted_params, types, selector, request_options = nil
       res = session.execute_query \
         sql,
@@ -224,7 +227,7 @@ module ActiveRecordSpannerAdapter
         types: types,
         transaction: selector,
         request_options: request_options,
-        seqno: (current_transaction&.next_sequence_number)
+        seqno: current_transaction&.next_sequence_number
       current_transaction.grpc_transaction = res.metadata.transaction \
           if current_transaction && res&.metadata&.transaction
       res
@@ -252,6 +255,7 @@ module ActiveRecordSpannerAdapter
       # It was not the first statement, so propagate the error.
       raise
     end
+    # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
     # Creates a transaction using a BeginTransaction RPC. This is used if the first statement of a
     # transaction fails, as that also means that no transaction id was returned.
@@ -283,7 +287,7 @@ module ActiveRecordSpannerAdapter
     end
 
     def transaction_selector
-      return current_transaction&.transaction_selector if current_transaction&.active?
+      current_transaction&.transaction_selector if current_transaction&.active?
     end
 
     def truncate table_name

data/lib/activerecord_spanner_adapter/foreign_key.rb

@@ -6,8 +6,15 @@
 
 module ActiveRecordSpannerAdapter
   class ForeignKey
-    attr_accessor :table_schema, :table_name, :name, :columns, :ref_schema, :ref_table, :ref_columns,
-                  :on_delete, :on_update
+    attr_accessor :table_schema
+    attr_accessor :table_name
+    attr_accessor :name
+    attr_accessor :columns
+    attr_accessor :ref_schema
+    attr_accessor :ref_table
+    attr_accessor :ref_columns
+    attr_accessor :on_delete
+    attr_accessor :on_update
 
     def initialize \
         table_name,

data/lib/activerecord_spanner_adapter/index/column.rb

@@ -7,7 +7,12 @@
 module ActiveRecordSpannerAdapter
   class Index
     class Column
-      attr_accessor :table_name, :schema_name, :index_name, :name, :order, :ordinal_position
+      attr_accessor :table_name
+      attr_accessor :schema_name
+      attr_accessor :index_name
+      attr_accessor :name
+      attr_accessor :order
+      attr_accessor :ordinal_position
 
       def initialize \
           table_name,

data/lib/activerecord_spanner_adapter/index.rb

@@ -8,8 +8,16 @@ require "activerecord_spanner_adapter/index/column"
 
 module ActiveRecordSpannerAdapter
   class Index
-    attr_accessor :schema, :table, :name, :columns, :type, :unique, :null_filtered,
-                  :interleave_in, :storing, :state
+    attr_accessor :schema
+    attr_accessor :table
+    attr_accessor :name
+    attr_accessor :columns
+    attr_accessor :type
+    attr_accessor :unique
+    attr_accessor :null_filtered
+    attr_accessor :interleave_in
+    attr_accessor :storing
+    attr_accessor :state
 
     def initialize \
         table,

data/lib/activerecord_spanner_adapter/information_schema.rb

@@ -32,7 +32,7 @@ module ActiveRecordSpannerAdapter
 
       rows = execute_query(
         sql,
-        schema_name: (schema_name || ""), table_name: table_name
+        schema_name: schema_name || "", table_name: table_name
       )
 
       rows.map do |row|

data/lib/activerecord_spanner_adapter/primary_key.rb

@@ -18,8 +18,8 @@ module ActiveRecord
         end
 
         def fetch_primary_and_parent_key
-          return connection.spanner_schema_cache.primary_and_parent_keys table_name \
-            if ActiveRecord::Base != self && table_exists?
+          connection.spanner_schema_cache.primary_and_parent_keys table_name \
+            if self != ActiveRecord::Base && table_exists?
         end
 
         def primary_and_parent_key= value

data/lib/activerecord_spanner_adapter/table/column.rb

@@ -7,9 +7,18 @@
 module ActiveRecordSpannerAdapter
   class Table
     class Column
-      attr_accessor :schema_name, :table_name, :name, :type, :limit, :ordinal_position,
-                    :allow_commit_timestamp, :default, :default_function, :generated,
-                    :primary_key, :nullable
+      attr_accessor :schema_name
+      attr_accessor :table_name
+      attr_accessor :name
+      attr_accessor :type
+      attr_accessor :limit
+      attr_accessor :ordinal_position
+      attr_accessor :allow_commit_timestamp
+      attr_accessor :default
+      attr_accessor :default_function
+      attr_accessor :generated
+      attr_accessor :primary_key
+      attr_accessor :nullable
 
       def initialize \
           table_name,

data/lib/activerecord_spanner_adapter/table.rb

@@ -30,8 +30,14 @@ require "activerecord_spanner_adapter/table/column"
 
 module ActiveRecordSpannerAdapter
   class Table
-    attr_accessor :name, :on_delete, :parent_table, :schema_name, :catalog,
-                  :indexes, :columns, :foreign_keys
+    attr_accessor :name
+    attr_accessor :on_delete
+    attr_accessor :parent_table
+    attr_accessor :schema_name
+    attr_accessor :catalog
+    attr_accessor :indexes
+    attr_accessor :columns
+    attr_accessor :foreign_keys
 
     # parent_table == interleave_in
     def initialize \

data/lib/activerecord_spanner_adapter/transaction.rb

@@ -123,7 +123,7 @@ module ActiveRecordSpannerAdapter
 
     def shoot_and_forget_rollback
       @connection.session.rollback @grpc_transaction.transaction_id if @committable
-    rescue StandardError # rubocop:disable Lint/HandleExceptions
+    rescue StandardError
       # Ignored
     end
 

data/lib/activerecord_spanner_adapter/version.rb

@@ -5,5 +5,5 @@
 # https://opensource.org/licenses/MIT.
 
 module ActiveRecordSpannerAdapter
-  VERSION = "1.6.3".freeze
+  VERSION = "2.0.0".freeze
 end

data/lib/arel/visitors/spanner.rb

@@ -35,9 +35,7 @@ module Arel # :nodoc: all
         sql = collector.hints[:statement_hint].value + sql if collector.hints[:statement_hint]
 
         if binds
-          binds << collector.hints[:staleness] if collector.hints[:staleness]
-          binds << collector.hints[:request_options] if collector.hints[:request_options]
-          [sql, binds]
+          compile_with_binds collector, sql, binds
         else
           sql
         end
@@ -45,6 +43,12 @@ module Arel # :nodoc: all
 
       private
 
+      def compile_with_binds collector, sql, binds
+        binds << collector.hints[:staleness] if collector.hints[:staleness]
+        binds << collector.hints[:request_options] if collector.hints[:request_options]
+        [sql, binds]
+      end
+
       BIND_BLOCK = proc { |i| "@p#{i}" }
       private_constant :BIND_BLOCK
 
@@ -62,43 +66,44 @@ module Arel # :nodoc: all
       end
 
       def visit_statement_hint v, collector
-        collector.hints[:statement_hint] = \
+        collector.hints[:statement_hint] =
           StatementHint.new v.delete_prefix("statement_hint:")
       end
 
-      # rubocop:disable Naming/MethodName
+      # rubocop:disable Naming/MethodName, Metrics/AbcSize
       def visit_Arel_Nodes_OptimizerHints o, collector
         o.expr.each do |v|
           visit_table_hint v, collector if v.start_with? "table_hint:"
           visit_statement_hint v, collector if v.start_with? "statement_hint:"
           if v.start_with? "max_staleness:"
-            collector.hints[:staleness] = \
+            collector.hints[:staleness] =
               StalenessHint.new max_staleness: v.delete_prefix("max_staleness:").to_f
             next
           end
           if v.start_with? "exact_staleness:"
-            collector.hints[:staleness] = \
+            collector.hints[:staleness] =
               StalenessHint.new exact_staleness: v.delete_prefix("exact_staleness:").to_f
             next
           end
           if v.start_with? "min_read_timestamp:"
             time = Time.xmlschema v.delete_prefix("min_read_timestamp:")
-            collector.hints[:staleness] = \
+            collector.hints[:staleness] =
               StalenessHint.new min_read_timestamp: time
             next
           end
           next unless v.start_with? "read_timestamp:"
           time = Time.xmlschema v.delete_prefix("read_timestamp:")
-          collector.hints[:staleness] = \
+          collector.hints[:staleness] =
             StalenessHint.new read_timestamp: time
         end
         collector
       end
+      # rubocop:enable Metrics/AbcSize
 
       def visit_Arel_Nodes_Comment o, collector
-        o.values.each do |v|
+        o.values.each do |v| # rubocop:disable Style/HashEachMethods
           if v.start_with?("request_tag:") || v.start_with?("transaction_tag:")
-            collector.hints[:request_options] ||= \
+            collector.hints[:request_options] ||=
               Google::Cloud::Spanner::V1::RequestOptions.new
           end
 

data/lib/spanner_client_ext.rb

@@ -66,8 +66,8 @@ module Google
           ensure_service!
 
           snp_grpc = service.create_snapshot \
-            path, timestamp: (timestamp || read_timestamp),
-            staleness: (staleness || exact_staleness)
+            path, timestamp: timestamp || read_timestamp,
+            staleness: staleness || exact_staleness
           num_args = Snapshot.method(:from_grpc).arity
           if num_args == 3
             Snapshot.from_grpc snp_grpc, self, nil
@@ -105,7 +105,8 @@ module Google
       end
 
       class Transaction
-        attr_accessor :seqno, :commit
+        attr_accessor :seqno
+        attr_accessor :commit
       end
     end
   end