activerecord-spanner-adapter 0.7.0 → 1.1.0

data/acceptance/cases/type/all_types_test.rb

@@ -30,19 +30,19 @@ module ActiveRecord
         AllTypes.create col_string: "string", col_int64: 100, col_float64: 3.14, col_numeric: 6.626, col_bool: true,
           col_bytes: StringIO.new("bytes"), col_date: ::Date.new(2021, 6, 23),
           col_timestamp: ::Time.new(2021, 6, 23, 17, 8, 21, "+02:00"),
-          col_json: ENV["SPANNER_EMULATOR_HOST"] ? "" : { kind: "user_renamed", change: %w[jack john]},
+          col_json: { kind: "user_renamed", change: %w[jack john]},
           col_array_string: ["string1", nil, "string2"],
-          col_array_int64: [100, nil, 200],
-          col_array_float64: [3.14, nil, 2.0/3.0],
-          col_array_numeric: [6.626, nil, 3.20],
-          col_array_bool: [true, nil, false],
+          col_array_int64: [100, nil, 200, "300"],
+          col_array_float64: [3.14, nil, 2.0/3.0, "3.14"],
+          col_array_numeric: [6.626, nil, 3.20, "400"],
+          col_array_bool: [true, nil, false, "false"],
           col_array_bytes: [StringIO.new("bytes1"), nil, StringIO.new("bytes2")],
-          col_array_date: [::Date.new(2021, 6, 23), nil, ::Date.new(2021, 6, 24)],
+          col_array_date: [::Date.new(2021, 6, 23), nil, ::Date.new(2021, 6, 24), "2021-06-25"],
           col_array_timestamp: [::Time.new(2021, 6, 23, 17, 8, 21, "+02:00"), nil, \
-                                ::Time.new(2021, 6, 24, 17, 8, 21, "+02:00")],
-          col_array_json: ENV["SPANNER_EMULATOR_HOST"] ? [""] : \
-                            [{ kind: "user_renamed", change: %w[jack john]}, nil, \
-                             { kind: "user_renamed", change: %w[alice meredith]}]
+                                ::Time.new(2021, 6, 24, 17, 8, 21, "+02:00"), "2021-06-25 17:08:21 +02:00"],
+          col_array_json: [{ kind: "user_renamed", change: %w[jack john]}, nil, \
+                             { kind: "user_renamed", change: %w[alice meredith]},
+                             "{\"kind\":\"user_renamed\",\"change\":[\"bob\",\"carol\"]}"]
       end
 
       def test_create_record
@@ -66,24 +66,25 @@ module ActiveRecord
           assert_equal ::Date.new(2021, 6, 23), record.col_date
           assert_equal ::Time.new(2021, 6, 23, 17, 8, 21, "+02:00").utc, record.col_timestamp.utc
           assert_equal ({"kind" => "user_renamed", "change" => %w[jack john]}),
-                       record.col_json unless ENV["SPANNER_EMULATOR_HOST"]
+                       record.col_json
 
           assert_equal ["string1", nil, "string2"], record.col_array_string
-          assert_equal [100, nil, 200], record.col_array_int64
-          assert_equal [3.14, nil, 2.0/3.0], record.col_array_float64
-          assert_equal [6.626, nil, 3.20], record.col_array_numeric
-          assert_equal [true, nil, false], record.col_array_bool
+          assert_equal [100, nil, 200, 300], record.col_array_int64
+          assert_equal [3.14, nil, 2.0/3.0, 3.14], record.col_array_float64
+          assert_equal [6.626, nil, 3.20, 400], record.col_array_numeric
+          assert_equal [true, nil, false, false], record.col_array_bool
           assert_equal [StringIO.new("bytes1"), nil, StringIO.new("bytes2")].map { |bytes| bytes&.read },
                        record.col_array_bytes.map { |bytes| bytes&.read }
-          assert_equal [::Date.new(2021, 6, 23), nil, ::Date.new(2021, 6, 24)], record.col_array_date
+          assert_equal [::Date.new(2021, 6, 23), nil, ::Date.new(2021, 6, 24), ::Date.new(2021, 06, 25)], record.col_array_date
           assert_equal [::Time.new(2021, 6, 23, 17, 8, 21, "+02:00"), \
                             nil, \
-                            ::Time.new(2021, 6, 24, 17, 8, 21, "+02:00")].map { |timestamp| timestamp&.utc },
+                            ::Time.new(2021, 6, 24, 17, 8, 21, "+02:00"), ::Time.new(2021, 6, 25, 17, 8, 21, "+02:00")].map { |timestamp| timestamp&.utc },
                        record.col_array_timestamp.map { |timestamp| timestamp&.utc}
           assert_equal [{"kind" => "user_renamed", "change" => %w[jack john]}, \
                         nil, \
-                        {"kind" => "user_renamed", "change" => %w[alice meredith]}],
-                       record.col_array_json unless ENV["SPANNER_EMULATOR_HOST"]
+                        {"kind" => "user_renamed", "change" => %w[alice meredith]}, \
+                        "{\"kind\":\"user_renamed\",\"change\":[\"bob\",\"carol\"]}"],
+                       record.col_array_json
         end
       end
 
@@ -98,7 +99,7 @@ module ActiveRecord
                           col_bool: false, col_bytes: StringIO.new("new bytes"),
                           col_date: ::Date.new(2021, 6, 28),
                           col_timestamp: ::Time.new(2021, 6, 28, 11, 22, 21, "+02:00"),
-                          col_json: ENV["SPANNER_EMULATOR_HOST"] ? "" : { kind: "user_created", change: %w[jack alice]},
+                          col_json: { kind: "user_created", change: %w[jack alice]},
                           col_array_string: ["new string 1", "new string 2"],
                           col_array_int64: [300, 200, 100],
                           col_array_float64: [1.1, 2.2, 3.3],
@@ -107,9 +108,7 @@ module ActiveRecord
                           col_array_bytes: [StringIO.new("new bytes 1"), StringIO.new("new bytes 2")],
                           col_array_date: [::Date.new(2021, 6, 28)],
                           col_array_timestamp: [::Time.utc(2020, 12, 31, 0, 0, 0)],
-                          col_array_json: ENV["SPANNER_EMULATOR_HOST"] ?
-                                            [""] : \
-                                            [{ kind: "user_created", change: %w[jack alice]}]
+                          col_array_json: [{ kind: "user_created", change: %w[jack alice]}]
           end
 
           # Verify that the record was updated.
@@ -123,7 +122,7 @@ module ActiveRecord
           assert_equal ::Date.new(2021, 6, 28), record.col_date
           assert_equal ::Time.new(2021, 6, 28, 11, 22, 21, "+02:00").utc, record.col_timestamp.utc
           assert_equal ({"kind" => "user_created", "change" => %w[jack alice]}),
-                       record.col_json unless ENV["SPANNER_EMULATOR_HOST"]
+                     record.col_json
 
           assert_equal ["new string 1", "new string 2"], record.col_array_string
           assert_equal [300, 200, 100], record.col_array_int64
@@ -135,7 +134,7 @@ module ActiveRecord
           assert_equal [::Date.new(2021, 6, 28)], record.col_array_date
           assert_equal [::Time.utc(2020, 12, 31, 0, 0, 0)], record.col_array_timestamp.map(&:utc)
           assert_equal [{"kind" => "user_created", "change" => %w[jack alice]}],
-                       record.col_array_json unless ENV["SPANNER_EMULATOR_HOST"]
+                       record.col_array_json
         end
       end
 

data/acceptance/cases/type/json_test.rb

@@ -18,8 +18,6 @@ module ActiveRecord
       end
 
       def test_set_json
-        return if ENV["SPANNER_EMULATOR_HOST"]
-
         expected_hash = {"key"=>"value", "array_key"=>%w[value1 value2]}
         record = TestTypeModel.new details: {key: "value", array_key: %w[value1 value2]}
 

data/acceptance/schema/schema.rb

@@ -17,8 +17,7 @@ ActiveRecord::Schema.define do
       t.column :col_bytes, :binary
       t.column :col_date, :date
       t.column :col_timestamp, :datetime
-      t.column :col_json, :json unless ENV["SPANNER_EMULATOR_HOST"]
-      t.column :col_json, :string if ENV["SPANNER_EMULATOR_HOST"]
+      t.column :col_json, :json
 
       t.column :col_array_string, :string, array: true
       t.column :col_array_int64, :bigint, array: true
@@ -28,8 +27,7 @@ ActiveRecord::Schema.define do
       t.column :col_array_bytes, :binary, array: true
       t.column :col_array_date, :date, array: true
       t.column :col_array_timestamp, :datetime, array: true
-      t.column :col_array_json, :json, array: true unless ENV["SPANNER_EMULATOR_HOST"]
-      t.column :col_array_json, :string, array: true if ENV["SPANNER_EMULATOR_HOST"]
+      t.column :col_array_json, :json, array: true
     end
 
     create_table :firms do |t|

data/acceptance/test_helper.rb

@@ -208,7 +208,7 @@ module SpannerAdapter
           t.date :start_date
           t.datetime :start_datetime
           t.time :start_time
-          t.json :details unless ENV["SPANNER_EMULATOR_HOST"]
+          t.json :details
         end
       end
 

data/activerecord-spanner-adapter.gemspec

@@ -25,7 +25,7 @@ Gem::Specification.new do |spec|
   spec.required_ruby_version = ">= 2.5"
 
   spec.add_dependency "google-cloud-spanner", "~> 2.10"
-  spec.add_runtime_dependency "activerecord", "~> 6.1.4"
+  spec.add_runtime_dependency "activerecord", [">= 6.0.0", "< 7.1"]
 
   spec.add_development_dependency "autotest-suffix", "~> 1.1"
   spec.add_development_dependency "bundler", "~> 2.0"

data/examples/rails/README.md

@@ -142,17 +142,17 @@ Replace `[PROJECT_ID]` with the project id you are currently using.
 ### Create database
 
 You now can run the following command to create the database:
-    ```shell
-    ./bin/rails db:create
-    ```
-    You should see output like the following:
-    ```
-    Created database 'blog_dev'
-    ```
+
+```shell
+./bin/rails db:create
+```
+    
+You should see output like the following: `Created database 'blog_dev'`
+    
 ### Generate a Model and apply the migration
 1. Use the model generato to define a model:
     ```shell
-    bin/rails generate model Article title:string body:text
+    ./bin/rails generate model Article title:string body:text
     ```
 1. Apply the migration:
     ```shell

data/lib/active_record/connection_adapters/spanner/schema_creation.rb

@@ -10,14 +10,20 @@ module ActiveRecord
       class SchemaCreation < SchemaCreation
         private
 
-        # rubocop:disable Naming/MethodName, Metrics/AbcSize
+        # rubocop:disable Naming/MethodName, Metrics/AbcSize, Metrics/PerceivedComplexity
 
         def visit_TableDefinition o
           create_sql = +"CREATE TABLE #{quote_table_name o.name} "
           statements = o.columns.map { |c| accept c }
 
-          o.foreign_keys.each do |to_table, options|
-            statements << foreign_key_in_create(o.name, to_table, options)
+          if ActiveRecord::VERSION::MAJOR >= 7
+            o.foreign_keys.each do |fk|
+              statements << accept(fk)
+            end
+          else
+            o.foreign_keys.each do |to_table, options|
+              statements << foreign_key_in_create(o.name, to_table, options)
+            end
           end
 
           create_sql << "(#{statements.join ', '}) " if statements.any?
@@ -106,7 +112,7 @@ module ActiveRecord
           sql
         end
 
-        # rubocop:enable Naming/MethodName, Metrics/AbcSize
+        # rubocop:enable Naming/MethodName, Metrics/AbcSize, Metrics/PerceivedComplexity
 
         def add_column_options! sql, options
           if options[:null] == false || options[:primary_key] == true

data/lib/active_record/connection_adapters/spanner_adapter.rb

@@ -8,6 +8,7 @@ require "securerandom"
 require "google/cloud/spanner"
 require "spanner_client_ext"
 require "active_record/connection_adapters/abstract_adapter"
+require "active_record/connection_adapters/abstract/connection_pool"
 require "active_record/connection_adapters/spanner/database_statements"
 require "active_record/connection_adapters/spanner/schema_statements"
 require "active_record/connection_adapters/spanner/schema_cache"
@@ -43,9 +44,9 @@ module ActiveRecord
   module ConnectionAdapters
     module AbstractPool
       def get_schema_cache connection
-        @schema_cache ||= SpannerSchemaCache.new connection
-        @schema_cache.connection = connection
-        @schema_cache
+        self.schema_cache ||= SpannerSchemaCache.new connection
+        schema_cache.connection = connection
+        schema_cache
       end
     end
 
@@ -178,41 +179,73 @@ module ActiveRecord
         Arel::Visitors::Spanner.new self
       end
 
-      private
+      def build_insert_sql insert
+        if current_spanner_transaction&.isolation == :buffered_mutations
+          raise "ActiveRecordSpannerAdapter does not support insert_sql with buffered_mutations transaction."
+        end
 
-      def initialize_type_map m = type_map
-        m.register_type "BOOL", Type::Boolean.new
-        register_class_with_limit(
-          m, %r{^BYTES}i, ActiveRecord::Type::Spanner::Bytes
-        )
-        m.register_type "DATE", Type::Date.new
-        m.register_type "FLOAT64", Type::Float.new
-        m.register_type "NUMERIC", Type::Decimal.new
-        m.register_type "INT64", Type::Integer.new(limit: 8)
-        register_class_with_limit m, %r{^STRING}i, Type::String
-        m.register_type "TIMESTAMP", ActiveRecord::Type::Spanner::Time.new
-        m.register_type "JSON", ActiveRecord::Type::Json.new
+        if insert.skip_duplicates? || insert.update_duplicates?
+          raise NotImplementedError, "CloudSpanner does not support skip_duplicates and update_duplicates."
+        end
 
-        register_array_types m
+        values_list, = insert.values_list
+        "INSERT #{insert.into} #{values_list}"
       end
 
-      def register_array_types m
-        m.register_type %r{^ARRAY<BOOL>}i, Type::Spanner::Array.new(Type::Boolean.new)
-        m.register_type %r{^ARRAY<BYTES\((MAX|d+)\)>}i, Type::Spanner::Array.new(Type::Binary.new)
-        m.register_type %r{^ARRAY<DATE>}i, Type::Spanner::Array.new(Type::Date.new)
-        m.register_type %r{^ARRAY<FLOAT64>}i, Type::Spanner::Array.new(Type::Float.new)
-        m.register_type %r{^ARRAY<NUMERIC>}i, Type::Spanner::Array.new(Type::Decimal.new)
-        m.register_type %r{^ARRAY<INT64>}i, Type::Spanner::Array.new(Type::Integer.new(limit: 8))
-        m.register_type %r{^ARRAY<STRING\((MAX|d+)\)>}i, Type::Spanner::Array.new(Type::String.new)
-        m.register_type %r{^ARRAY<TIMESTAMP>}i, Type::Spanner::Array.new(ActiveRecord::Type::Spanner::Time.new)
-        m.register_type %r{^ARRAY<JSON>}i, Type::Spanner::Array.new(ActiveRecord::Type::Json.new)
+      module TypeMapBuilder
+        private
+
+        def initialize_type_map m = type_map
+          m.register_type "BOOL", Type::Boolean.new
+          register_class_with_limit(
+            m, %r{^BYTES}i, ActiveRecord::Type::Spanner::Bytes
+          )
+          m.register_type "DATE", Type::Date.new
+          m.register_type "FLOAT64", Type::Float.new
+          m.register_type "NUMERIC", Type::Decimal.new
+          m.register_type "INT64", Type::Integer.new(limit: 8)
+          register_class_with_limit m, %r{^STRING}i, Type::String
+          m.register_type "TIMESTAMP", ActiveRecord::Type::Spanner::Time.new
+          m.register_type "JSON", ActiveRecord::Type::Json.new
+
+          register_array_types m
+        end
+
+        def register_array_types m
+          m.register_type %r{^ARRAY<BOOL>}i, Type::Spanner::Array.new(Type::Boolean.new)
+          m.register_type %r{^ARRAY<BYTES\((MAX|d+)\)>}i,
+                          Type::Spanner::Array.new(ActiveRecord::Type::Spanner::Bytes.new)
+          m.register_type %r{^ARRAY<DATE>}i, Type::Spanner::Array.new(Type::Date.new)
+          m.register_type %r{^ARRAY<FLOAT64>}i, Type::Spanner::Array.new(Type::Float.new)
+          m.register_type %r{^ARRAY<NUMERIC>}i, Type::Spanner::Array.new(Type::Decimal.new)
+          m.register_type %r{^ARRAY<INT64>}i, Type::Spanner::Array.new(Type::Integer.new(limit: 8))
+          m.register_type %r{^ARRAY<STRING\((MAX|d+)\)>}i, Type::Spanner::Array.new(Type::String.new)
+          m.register_type %r{^ARRAY<TIMESTAMP>}i, Type::Spanner::Array.new(ActiveRecord::Type::Spanner::Time.new)
+          m.register_type %r{^ARRAY<JSON>}i, Type::Spanner::Array.new(ActiveRecord::Type::Json.new)
+        end
+
+        def extract_limit sql_type
+          value = /\((.*)\)/.match sql_type
+          return unless value
+
+          value[1] == "MAX" ? "MAX" : value[1].to_i
+        end
       end
 
-      def extract_limit sql_type
-        value = /\((.*)\)/.match sql_type
-        return unless value
+      if ActiveRecord::VERSION::MAJOR >= 7
+        class << self
+          include TypeMapBuilder
+        end
+
+        TYPE_MAP = Type::TypeMap.new.tap { |m| initialize_type_map m }
+
+        private
 
-        value[1] == "MAX" ? "MAX" : value[1].to_i
+        def type_map
+          TYPE_MAP
+        end
+      else
+        include TypeMapBuilder
       end
 
       def translate_exception exception, message:, sql:, binds:

data/lib/active_record/type/spanner/array.rb

@@ -15,15 +15,29 @@ module ActiveRecord
           @element_type = element_type
         end
 
-        def serialize value
+        def cast value
           return super if value.nil?
-          return super unless @element_type.is_a? Type::Decimal
           return super unless value.respond_to? :map
 
-          # Convert a decimal (NUMERIC) array to a String array to prevent it from being encoded as a FLOAT64 array.
           value.map do |v|
-            next if v.nil?
-            v.to_s
+            @element_type.cast v
+          end
+        end
+
+        def serialize value
+          return super if value.nil?
+          return super unless value.respond_to? :map
+
+          if @element_type.is_a? ActiveRecord::Type::Decimal
+            # Convert a decimal (NUMERIC) array to a String array to prevent it from being encoded as a FLOAT64 array.
+            value.map do |v|
+              next if v.nil?
+              v.to_s
+            end
+          else
+            value.map do |v|
+              @element_type.serialize v
+            end
           end
         end
       end

data/lib/activerecord_spanner_adapter/base.rb

@@ -41,14 +41,69 @@ module ActiveRecord
       spanner_adapter? && connection&.current_spanner_transaction&.isolation == :buffered_mutations
     end
 
+    def self.insert_all _attributes, _returning: nil, _unique_by: nil
+      raise NotImplementedError, "Cloud Spanner does not support skip_duplicates."
+    end
+
+    def self.insert_all! attributes, returning: nil
+      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.
+      if active_transaction?
+        attributes.each do |record|
+          _insert_record record
+        end
+      else
+        transaction isolation: :buffered_mutations do
+          attributes.each do |record|
+            _insert_record record
+          end
+        end
+      end
+    end
+
+    def self.upsert_all attributes, returning: nil, unique_by: nil
+      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
+
+      # 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.
+      if active_transaction?
+        attributes.each do |record|
+          _upsert_record record
+        end
+      else
+        transaction isolation: :buffered_mutations do
+          attributes.each do |record|
+            _upsert_record record
+          end
+        end
+      end
+    end
+
     def self._insert_record values
       return super unless buffered_mutations?
 
+      _buffer_record values, :insert
+    end
+
+    def self._upsert_record values
+      _buffer_record values, :insert_or_update
+    end
+
+    def self._buffer_record values, method
       primary_key = self.primary_key
       primary_key_value = nil
 
       if primary_key && values.is_a?(Hash)
         primary_key_value = values[primary_key]
+        primary_key_value ||= values[:"#{primary_key}"]
 
         if !primary_key_value && prefetch_primary_key?
           primary_key_value = next_sequence_value
@@ -59,13 +114,15 @@ module ActiveRecord
       metadata = TableMetadata.new self, arel_table
       columns, grpc_values = _create_grpc_values_for_insert metadata, values
 
+      write = Google::Cloud::Spanner::V1::Mutation::Write.new(
+        table: arel_table.name,
+        columns: columns,
+        values: [grpc_values.list_value]
+      )
       mutation = Google::Cloud::Spanner::V1::Mutation.new(
-        insert: Google::Cloud::Spanner::V1::Mutation::Write.new(
-          table: arel_table.name,
-          columns: columns,
-          values: [grpc_values.list_value]
-        )
+        "#{method}": write
       )
+
       connection.current_spanner_transaction.buffer mutation
 
       primary_key_value
@@ -87,6 +144,14 @@ module ActiveRecord
       !(current_transaction.nil? || current_transaction.is_a?(ConnectionAdapters::NullTransaction))
     end
 
+    def self.unwrap_attribute attr_or_value
+      if attr_or_value.is_a? ActiveModel::Attribute
+        attr_or_value.value
+      else
+        attr_or_value
+      end
+    end
+
     # Updates the given attributes of the object in 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
     # isolation: :buffered_mutations.
@@ -117,6 +182,7 @@ module ActiveRecord
       serialized_values = []
       columns = []
       values.each_pair do |k, v|
+        v = unwrap_attribute v
         type = metadata.type k
         serialized_values << (type.method(:serialize).arity < 0 ? type.serialize(v, :mutation) : type.serialize(v))
         columns << metadata.arel_table[k].name
@@ -168,6 +234,7 @@ module ActiveRecord
       all_values.each do |h|
         h.each_pair do |k, v|
           type = metadata.type k
+          v = self.class.unwrap_attribute v
           has_serialize_options = type.method(:serialize).arity < 0
           all_serialized_values << (has_serialize_options ? type.serialize(v, :mutation) : type.serialize(v))
           all_columns << metadata.arel_table[k].name

data/lib/activerecord_spanner_adapter/connection.rb

@@ -208,27 +208,53 @@ module ActiveRecordSpannerAdapter
         self.current_transaction = nil
       end
 
-      begin
-        session.execute_query \
-          sql,
-          params: converted_params,
-          types: types,
-          transaction: transaction_selector || single_use_selector,
-          seqno: (current_transaction&.next_sequence_number)
-      rescue Google::Cloud::AbortedError
-        # Mark the current transaction as aborted to prevent any unnecessary further requests on the transaction.
-        current_transaction&.mark_aborted
-        raise
-      rescue Google::Cloud::NotFoundError => e
-        if session_not_found?(e) || transaction_not_found?(e)
-          reset!
-          # Force a retry of the entire transaction if this statement was executed as part of a transaction.
-          # Otherwise, just retry the statement itself.
-          raise_aborted_err if current_transaction&.active?
-          retry
-        end
-        raise
+      selector = transaction_selector || single_use_selector
+      execute_sql_request sql, converted_params, types, selector
+    end
+
+    def execute_sql_request sql, converted_params, types, selector
+      res = session.execute_query \
+        sql,
+        params: converted_params,
+        types: types,
+        transaction: selector,
+        seqno: (current_transaction&.next_sequence_number)
+      current_transaction.grpc_transaction = res.metadata.transaction \
+          if current_transaction && res&.metadata&.transaction
+      res
+    rescue Google::Cloud::AbortedError
+      # Mark the current transaction as aborted to prevent any unnecessary further requests on the transaction.
+      current_transaction&.mark_aborted
+      raise
+    rescue Google::Cloud::NotFoundError => e
+      if session_not_found?(e) || transaction_not_found?(e)
+        reset!
+        # Force a retry of the entire transaction if this statement was executed as part of a transaction.
+        # Otherwise, just retry the statement itself.
+        raise_aborted_err if current_transaction&.active?
+        retry
+      end
+      raise
+    rescue Google::Cloud::Error => e
+      # Check if it was the first statement in a transaction that included a BeginTransaction
+      # option in the request. If so, execute an explicit BeginTransaction and then retry the
+      # request without the BeginTransaction option.
+      if current_transaction && selector&.begin&.read_write
+        selector = create_transaction_after_failed_first_statement e
+        retry
       end
+      # It was not the first statement, so propagate the error.
+      raise
+    end
+
+    # 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.
+    def create_transaction_after_failed_first_statement original_error
+      transaction = current_transaction.force_begin_read_write
+      Google::Spanner::V1::TransactionSelector.new id: transaction.transaction_id
+    rescue Google::Cloud::Error
+      # Raise the original error if the BeginTransaction RPC also fails.
+      raise original_error
     end
 
     # Transactions

data/lib/activerecord_spanner_adapter/information_schema.rb

@@ -62,7 +62,8 @@ module ActiveRecordSpannerAdapter
     end
 
     def table_columns table_name, column_name: nil
-      sql = +"SELECT COLUMN_NAME, SPANNER_TYPE, IS_NULLABLE, COLUMN_DEFAULT, ORDINAL_POSITION"
+      sql = +"SELECT COLUMN_NAME, SPANNER_TYPE, IS_NULLABLE,"
+      sql << " CAST(COLUMN_DEFAULT AS STRING) AS COLUMN_DEFAULT, ORDINAL_POSITION"
       sql << " FROM INFORMATION_SCHEMA.COLUMNS"
       sql << " WHERE TABLE_NAME=%<table_name>s"
       sql << " AND COLUMN_NAME=%<column_name>s" if column_name