activerecord-spanner-adapter 0.3.0 → 0.5.0

data/examples/snippets/timestamp-data-type/application.rb

@@ -0,0 +1,42 @@
+# Copyright 2021 Google LLC
+#
+# Use of this source code is governed by an MIT-style
+# license that can be found in the LICENSE file or at
+# https://opensource.org/licenses/MIT.
+
+require "io/console"
+require_relative "../config/environment"
+require_relative "models/meeting"
+
+class Application
+  def self.run
+    # Set the default local timezone.
+    Time.zone = "Europe/Lisbon"
+
+    # Create a meeting using the local timezone. The timezone information will not be stored in the `meeting_time`
+    # column in the database, which is why we also include a separate column where we can store the timezone name.
+    meeting_time = Time.zone.local 2021, 7, 1, 10, 30, 0
+    meeting = Meeting.create title: "Standup", meeting_time: meeting_time, meeting_timezone: Time.zone.name
+
+    # The meeting_time is saved in UTC in Cloud Spanner. Reloading it will therefore lose the timezone information in
+    # the meeting_time attribute. It is however stored in the separate meeting_timezone attribute, and that can be used
+    # to reconstruct the meeting_time in the timezone where the meeting was planned.
+    # The Meeting model class also contains two helper methods:
+    # 1. `local_meeting_time`: Returns the meeting_time in the local timezone.
+    # 2. `meeting_time_in_planned_zone`: Returns the meeting_time in the timezone where it is planned.
+    meeting.reload
+    puts ""
+    puts "#{'Meeting time in UTC:'.ljust 60} #{meeting.meeting_time}"
+    puts "#{'Meeting time in the timezone where it was planned:'.ljust 60} #{meeting.meeting_time_in_planned_zone}"
+
+    # Simulate that the application is now running in the timezone America/Los_Angeles.
+    Time.zone = "America/Los_Angeles"
+    puts "#{'Meeting time in the local timezone (America/Los_Angeles):'.ljust 60} #{meeting.local_meeting_time}"
+
+    puts ""
+    puts "Press any key to end the application"
+    STDIN.getch
+  end
+end
+
+Application.run

data/examples/snippets/timestamp-data-type/config/database.yml

@@ -0,0 +1,8 @@
+development:
+  adapter: spanner
+  emulator_host: localhost:9010
+  project: test-project
+  instance: test-instance
+  database: testdb
+  pool: 5
+  timeout: 5000

data/examples/snippets/timestamp-data-type/db/migrate/01_create_tables.rb

@@ -0,0 +1,21 @@
+# Copyright 2021 Google LLC
+#
+# Use of this source code is governed by an MIT-style
+# license that can be found in the LICENSE file or at
+# https://opensource.org/licenses/MIT.
+
+class CreateTables < ActiveRecord::Migration[6.0]
+  def change
+    connection.ddl_batch do
+      create_table :meetings do |t|
+        t.string :title
+        # A `TIMESTAMP` column in Cloud Spanner contains a date/time value that designates a specific point in time. The
+        # value is always stored in UTC. If you specify a date/time value in a different timezone, the value is
+        # converted to UTC when saving it to the database. You can use a separate column to store the timezone of the
+        # timestamp if that is vital for your application, and use that information when the timestamp is read back.
+        t.datetime :meeting_time
+        t.string   :meeting_timezone
+      end
+    end
+  end
+end

data/examples/snippets/timestamp-data-type/db/schema.rb

@@ -0,0 +1,21 @@
+# This file is auto-generated from the current state of the database. Instead
+# of editing this file, please use the migrations feature of Active Record to
+# incrementally modify your database, and then regenerate this schema definition.
+#
+# This file is the source Rails uses to define your schema when running `rails
+# db:schema:load`. When creating a new database, `rails db:schema:load` tends to
+# be faster and is potentially less error prone than running all of your
+# migrations from scratch. Old migrations may fail to apply correctly if those
+# migrations use external dependencies or application code.
+#
+# It's strongly recommended that you check this file into your version control system.
+
+ActiveRecord::Schema.define(version: 1) do
+
+  create_table "meetings", force: :cascade do |t|
+    t.string "title"
+    t.time "meeting_time"
+    t.string "meeting_timezone"
+  end
+
+end

data/examples/snippets/timestamp-data-type/db/seeds.rb

@@ -0,0 +1,6 @@
+# Copyright 2021 Google LLC
+#
+# Use of this source code is governed by an MIT-style
+# license that can be found in the LICENSE file or at
+# https://opensource.org/licenses/MIT.
+#

data/examples/snippets/timestamp-data-type/models/meeting.rb

@@ -0,0 +1,19 @@
+# Copyright 2021 Google LLC
+#
+# Use of this source code is governed by an MIT-style
+# license that can be found in the LICENSE file or at
+# https://opensource.org/licenses/MIT.
+
+class Meeting < ActiveRecord::Base
+  # Returns the meeting time in the local timezone.
+  def local_meeting_time
+    return unless meeting_time && Time.zone
+    meeting_time.in_time_zone Time.zone
+  end
+
+  # Returns the time of the meeting in the timezone where the meeting is planned.
+  def meeting_time_in_planned_zone
+    return unless meeting_time && meeting_timezone
+    meeting_time.in_time_zone meeting_timezone
+  end
+end

data/examples/solidus/README.md

@@ -0,0 +1,172 @@
+## activerecord-spanner-adapter on Solidus
+
+This example shows how to use activerecord-spanner-adapter for Cloud Spanner as a backend database for https://solidus.io.
+
+#### Table of contents
+- [Ensure you have a Cloud Spanner database already created](#ensure-you-have-a-Cloud-Spanner-database-already-created)
+- [Create a Rails application and install Solidus](#create-a-rails-application-and-install-solidus)
+- [Update database.yml](#update-database.yml)
+- [Create application database](#create-application-database)
+- [Apply the migrations](#apply-the-migrations)
+- [Go view the results on Cloud Spanner UI](#go-view-the-results-on-Cloud-Spanner-UI)
+- [Run the application](#run-the-application)
+- [References](#references)
+
+### Ensure you have a Cloud Spanner database already created
+If you haven't already, please follow the steps to install [Cloud Spanner](https://cloud.google.com/spanner/docs/getting-started/set-up),
+or visit this [codelab](https://opencensus.io/codelabs/spanner/#0)
+
+**You'll need to ensure that your Google Application Default Credentials are properly downloaded and saved in your environment.**
+
+### Create a Rails application and install Solidus
+
+Create a Rails application.
+```shell
+rails new e-store
+cd e-store
+```
+Add `solidus` and  `activerecord-spanner-adapter` gem to Gemfile.
+
+Gemfile
+```ruby
+gem 'solidus'
+gem 'activerecord-spanner-adapter', git: 'https://github.com/orijtech/activerecord-spanner-adapter.git'
+```
+
+```shell
+bundle install
+```
+
+### Use Cloud Spanner adapter in Gemfile
+Edit Gemfile file and add `activerecord-spanner-adapter` gem.
+
+```ruby
+gem 'activerecord-spanner-adapter', git: 'https://github.com/orijtech/activerecord-spanner-adapter.git'
+```
+
+Install gems.
+
+```shell
+bundle install
+```
+
+After installing gems, you'll have to run the generator to create necessary configuration files and migrations.
+
+```shell
+bin/rails g spree:install
+```
+
+### Update database.yml
+
+Update `db/database.yml` to use `activerecord-spanner-adapter`
+
+After we have a Cloud Spanner database created, we'll need a few variables:
+* Project id
+* Instance id
+* Database name
+* Credential: Credential keyfile path or Export `GOOGLE_CLOUD_KEYFILE`environment variable.
+
+Once in, please edit the file `config/database.yml` and make the section `DATABASES` into the following:
+
+```yml
+default: &default
+  adapter: "spanner"
+  pool: <%= ENV.fetch("RAILS_MAX_THREADS") { 10 } %>
+  project: PROJECT_ID
+  instance: SPANNER_INSTANCE_ID
+  credentials: SPANNER_PROJECT_KEYFILE
+
+development:
+  <<: *default
+  database: e-store-dev
+
+test:
+  <<: *default
+  database: e-store-test
+
+production:
+  <<: *default
+  database: e-store
+```
+
+and for example here is a filled in database where:
+
+* `PROJECT_ID`: spanner-appdev
+* `SPANNER_INSTANCE_ID`: instance
+* `SPANNER_PROJECT_KEYFILE`:  credentials key file path. i.e "/app/keyfile.json".
+
+###  Create application database
+
+Please run:
+```shell
+$ ./bin/rails db:create
+```
+
+```shell
+Created database e-store-dev
+```
+
+### Apply the migrations
+Please run:
+```shell
+$ ./bin/rails db:migrate
+```
+
+and that'll take a while running, it will look like the following
+
+<details>
+
+```shell
+$ ./bin/rails db:migrate
+== 20200410055855 CreateActiveStorageTables: migrating ========================
+-- create_table(:active_storage_blobs, {})
+   -> 0.0011s
+-- create_table(:active_storage_attachments, {})
+   -> 0.0010s
+== 20200410055855 CreateActiveStorageTables: migrated (0.0023s) ===============
+
+..... MANY MORE MIGRATION LOG LINES
+```
+</details>
+
+### Go view the results on Cloud Spanner UI
+
+To double check that the respective tables and migrations were performed, please go visit the page with your database on Cloud Spanner's UI. For example it should look like this
+
+![](/assets/solidus-db.png)
+
+### Run the application
+After those migrations run application server.
+
+```shell
+./bin/rails s
+```
+<details>
+
+```
+./bin/rails s
+Puma starting in single mode...
+* Version 4.3.3 (ruby 2.6.3-p62), codename: Mysterious Traveller
+* Min threads: 5, max threads: 5
+* Environment: development
+* Listening on tcp://127.0.0.1:3000
+* Listening on tcp://[::1]:3000
+Use Ctrl-C to stop
+Started GET "/" for ::1 at 2020-04-10 11:42:00 +0530
+   (563.0ms)  SELECT `schema_migrations`.`version` FROM `schema_migrations` ORDER BY `schema_migrations`.`version` ASC
+Processing by Spree::HomeController#index as HTML
+  Spree::Store Load (507.9ms)  SELECT `spree_stores`.* FROM `spree_stores` WHERE (`spree_stores`.`url` = 'localhost' OR `spree_stores`.`default` = TRUE) ORDER BY `spree_stores`.`default` ASC LIMIT 1
+  Rendering /Users/jiren/work/spanner_orm/solidus/frontend/app/views/spree/home/index.html.erb within spree/layouts/spree_application
+  Spree::Taxonomy Load (571.6ms)  SELECT `spree_taxonomies`.* FROM `spree_taxonomies` ORDER BY `spree_taxonomies`.`position` ASC
+```
+
+</details>
+
+### References
+
+Resource|URL
+---|---
+Solidus application|https://solidus.io/
+Solidus application source code|https://github.com/solidusio/solidus
+Cloud Spanner homepage|https://cloud.google.com/spanner/
+activerecord-spanner-adapter project's source code|https://github.com/orijtech/activerecord-spanner-adapter

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

@@ -1,335 +1,290 @@
+# Copyright 2020 Google LLC
+#
+# Use of this source code is governed by an MIT-style
+# license that can be found in the LICENSE file or at
+# https://opensource.org/licenses/MIT.
+
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module Spanner
       module DatabaseStatements
-        include ConnectionAdapters::DatabaseStatements
-
-        class QueryVisitor < ::Arel::Visitors::ToSql
-          def visit_Arel_Nodes_BindParam(o, collector)
-            collector.add_bind(o) {|bind_idx| "@p#{bind_idx}" }
-          end
-        end
+        # DDL, DML and DQL Statements
 
-        # A mixin which provides ways to resolve rvalues.
-        module RightValueResolveable
-          def visit_Arel_Nodes_BindParam(o)
-            binds.shift
-          end
+        def execute sql, name = nil, binds = []
+          statement_type = sql_statement_type sql
 
-          def visit_Array(o)
-            o.map {|item| accept(item) }
+          if preventing_writes? && [:dml, :ddl].include?(statement_type)
+            raise ActiveRecord::ReadOnlyError(
+              "Write query attempted while in readonly mode: #{sql}"
+            )
           end
 
-          def visit_Arel_Nodes_Casted(o)
-            a = o.attribute
-            if a.able_to_type_cast?
-              a.type_cast_for_database(o.val)
-            else
-              o.val
+          if statement_type == :ddl
+            execute_ddl sql
+          else
+            transaction_required = statement_type == :dml
+            materialize_transactions
+
+            log sql, name do
+              types, params = to_types_and_params binds
+              ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
+                if transaction_required
+                  transaction do
+                    @connection.execute_query sql, params: params, types: types
+                  end
+                else
+                  @connection.execute_query sql, params: params, types: types
+                end
+              end
             end
           end
-
-          private
-          # To be overridden
-          def binds
-            raise NotImplementedError
-          end
         end
 
-        # Converts ASTs of INSERT, UPDATE or DELETE statements into forms
-        # convenient for DatabaseStatements#insert, #update and #delete.
-        class MutationVisitor < ::Arel::Visitors::Visitor
-          include RightValueResolveable
-
-          def initialize(schema_reader, binds)
-            super()
-            @schema_reader = schema_reader
-            @binds = binds
-          end
-
-          attr_reader :binds
-          private :binds
-
-          def visit_Arel_Nodes_InsertStatement(o)
-            raise NotImplementedError, 'INSERT INTO SELECT statement is not supported' if o.select
-            table = o.relation.name
-            columns = if o.columns.any?
-                        o.columns.map(&:name)
-                      else
-                        columns(table).map(&:name)
-                      end
-            values = o.values ? accept(o.values) : []
-
-            [table, columns, values]
-          end
-
-          def visit_Arel_Nodes_UpdateStatement(o)
-            table = o.relation.name
-            values = accept(o.values)
-            pk = @schema_reader.primary_key(table)
+        def query sql, name = nil
+          exec_query sql, name
+        end
 
-            unless o.orders.empty? and o.limit.nil? and o.wheres.size == 1
-              raise NotImplementedError, 'UPDATE statements with ORDER, LIMIT or complex WHERE clause'
-            end
+        def exec_query sql, name = "SQL", binds = [], prepare: false # rubocop:disable Lint/UnusedMethodArgument
+          result = execute sql, name, binds
+          ActiveRecord::Result.new(
+            result.fields.keys.map(&:to_s), result.rows.map(&:values)
+          )
+        end
 
-            ids = WhereVisitor.new(o.relation, pk, binds).accept(o.wheres[0])
-            raise NotImplementedError 'UPDATE statements with complex WHERE clause' unless ids
+        def exec_mutation mutation
+          @connection.current_transaction.buffer mutation
+        end
 
-            [table, ids, values]
+        def update arel, name = nil, binds = []
+          # Add a `WHERE TRUE` if it is an update_all or delete_all call that uses DML.
+          if !should_use_mutation(arel) && arel.respond_to?(:ast) && arel.ast.wheres.empty?
+            arel.ast.wheres << Arel::Nodes::SqlLiteral.new("TRUE")
           end
+          return super unless should_use_mutation arel
 
-          def visit_Arel_Nodes_DeleteStatement(o)
-            table = o.relation.name
+          raise "Unsupported update for use with mutations: #{arel}" unless arel.is_a? Arel::DeleteManager
 
-            # fallback_result lets the caller query the target id set at first and then
-            # delete the ids.
-            fallback_result = [table, nil, o.wheres]
-
-            case o.wheres.size
-            when 0
-              return [table, :all]
-            when 1
-              # it might be a simple "id = ?". Let's check later
-            else
-              return fallback_result
-            end
-
-            pk = @schema_reader.primary_key(table)
-            ids = WhereVisitor.new(o.relation, pk, binds).accept(o.wheres[0])
-
-            if ids
-              return [table, ids]
-            else
-              return fallback_result
-            end
-          end
+          exec_mutation create_delete_all_mutation arel if arel.is_a? Arel::DeleteManager
+          0 # Affected rows (unknown)
+        end
+        alias delete update
+
+        def exec_update sql, name = "SQL", binds = []
+          result = execute sql, name, binds
+          # Make sure that we consume the entire result stream before trying to get the stats.
+          # This is required because the ExecuteStreamingSql RPC is also used for (Partitioned) DML,
+          # and this RPC can return multiple partial result sets for DML as well. Only the last partial
+          # result set will contain the statistics. Although there will never be any rows, this makes
+          # sure that the stream is fully consumed.
+          result.rows.each { |_| }
+          return result.row_count if result.row_count
+
+          raise ActiveRecord::StatementInvalid.new(
+            "DML statement is invalid.", sql: sql
+          )
+        end
+        alias exec_delete exec_update
 
-          def visit_Arel_Nodes_Values o
-            o.expressions.map.with_index do |value|
-              case value
-              when ::Arel::Nodes::SqlLiteral
-                raise NotImplementedError, "mutation with SQL literal is not supported"
-              else
-                accept(value)
-              end
+        def truncate table_name, name = nil
+          Array(table_name).each do |t|
+            log "TRUNCATE #{t}", name do
+              @connection.truncate t
             end
           end
-
-          def visit_Arel_Nodes_Assignment(o)
-            [accept(o.left), accept(o.right)]
-          end
-
-          def visit_Arel_Nodes_UnqualifiedColumn(o)
-            o.name
-          end
         end
 
-        # Tries to convert where clause into a set of ids if it is simple enough.
-        # Returns nil if the clause is not simple.
-        class WhereVisitor < ::Arel::Visitors::Visitor
-          include RightValueResolveable
-
-          NOT_SIMPLE = nil
-
-          def initialize(relation, pk, binds)
-            super()
-            @relation = relation
-            @pk = pk
-            @binds = binds
-          end
-
-          attr_reader :binds
-          private :binds
-
-          def visit_Arel_Nodes_And(o)
-            if o.children.size == 1
-              accept(o.left)
-            else
-              NOT_SIMPLE
-            end
-          end
+        def write_query? sql
+          sql_statement_type(sql) == :dml
+        end
 
-          def visit_Arel_Nodes_Equality(o)
-            if pk_cond?(o)
-              [accept(o.right)]
-            else
-              NOT_SIMPLE
+        def execute_ddl statements
+          log "MIGRATION", "SCHEMA" do
+            ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
+              @connection.execute_ddl statements
             end
           end
+        rescue Google::Cloud::Error => error
+          raise ActiveRecord::StatementInvalid, error
+        end
 
-          def visit_Arel_Nodes_In(o)
-            return nil unless pk_cond?(o)
-
-            if o.kind_of?(Array) and o.empty?
-              []
-            else
-              accept(o.right)
-            end
-          end
+        # Transaction
 
-          def unsupported(o)
-            return NOT_SIMPLE
+        def transaction requires_new: nil, isolation: nil, joinable: true
+          if !requires_new && current_transaction.joinable?
+            return super
           end
 
-          alias visit_Arel_Nodes_Grouping unsupported
-          alias visit_Arel_Nodes_NotIn unsupported
-          alias visit_Arel_Nodes_Or unsupported
-          alias visit_Arel_Nodes_NotEqual unsupported
-          alias visit_Arel_Nodes_Case unsupported
-          alias visit_Arel_Nodes_Between unsupported
-          alias visit_Arel_Nodes_GreaterThanOrEqual unsupported
-          alias visit_Arel_Nodes_GreaterThan unsupported
-          alias visit_Arel_Nodes_LessThanOrEqual unsupported
-          alias visit_Arel_Nodes_LessThan unsupported
-          alias visit_Arel_Nodes_Matches unsupported
-          alias visit_Arel_Nodes_DoesNotMatch unsupported
-
-          private
-          def pk_cond?(o)
-            o.left.kind_of?(Arel::Attributes::Attribute) &&
-              o.left.relation == @relation &&
-              o.left.name == @pk
+          backoff = 0.2
+          begin
+            super
+          rescue ActiveRecord::StatementInvalid => err
+            if err.cause.is_a? Google::Cloud::AbortedError
+              sleep(delay_from_aborted(err) || backoff *= 1.3)
+              retry
+            end
+            raise
           end
         end
 
-        def insert(arel, name = nil, pk = nil, id_value = nil, sequence_name = nil, binds = [])
-          raise NotImplementedError, "INSERT in raw SQL is not supported" unless arel.respond_to?(:ast)
-
-          type_casted_binds = binds.map {|attr| type_cast(attr.value_for_database) }
-          table, columns, values = MutationVisitor.new(self, type_casted_binds).accept(arel.ast)
-          fake_sql = <<~"SQL"
-            INSERT INTO #{table}(#{columns.join(", ")}) VALUES (#{values.join(", ")})
-          SQL
-
-          row = columns.zip(values).inject({}) {|out, (col, value)|
-            out[col] = value
-            out
+        def transaction_isolation_levels
+          {
+            read_uncommitted:   "READ UNCOMMITTED",
+            read_committed:     "READ COMMITTED",
+            repeatable_read:    "REPEATABLE READ",
+            serializable:       "SERIALIZABLE",
+
+            # These are not really isolation levels, but it is the only (best) way to pass in additional
+            # transaction options to the connection.
+            read_only:          "READ_ONLY",
+            buffered_mutations: "BUFFERED_MUTATIONS"
           }
+        end
 
-          log(fake_sql, name) do
-            with_phase_transition {|client| client.insert(table, row) }
+        def begin_db_transaction
+          log "BEGIN" do
+            @connection.begin_transaction
           end
-
-          id_value
         end
 
-        def update(arel, name = nil, binds = [])
-          raise NotImplementedError, "UPDATE statement in raw SQL is not supported" unless arel.respond_to?(:ast)
-
-          type_casted_binds = binds.map {|attr| type_cast(attr.value_for_database) }
-          table, target, values = MutationVisitor.new(self, type_casted_binds.dup).accept(arel.ast)
-
-          fake_set = values.map {|col, val|
-            "#{quote_column_name(col)} = #{quote(val)}"
-          }.join(', ')
-
-          pk = primary_key(table)
-          if target.size > 1
-            fake_sql = "UPDATE #{quote_column_name(table)} SET #{fake_set} WHERE #{pk} IN ?"
-          else
-            fake_sql = "UPDATE #{quote_column_name(table)} SET #{fake_set} WHERE #{pk} = ?"
+        # Begins a transaction on the database with the specified isolation level. Cloud Spanner only supports
+        # isolation level :serializable, but also defines two additional 'isolation levels' that can be used
+        # to start specific types of Spanner transactions:
+        # * :read_only: Starts a read-only snapshot transaction using a strong timestamp bound.
+        # * :buffered_mutations: Starts a read/write transaction that will use mutations instead of DML for single-row
+        #                        inserts/updates/deletes. Mutations are buffered locally until the transaction is
+        #                        committed, and any changes during a transaction cannot be read by the application.
+        # * :pdml: Starts a Partitioned DML transaction. Executing multiple DML statements in one PDML transaction
+        #          block is NOT supported A PDML transaction is not guaranteed to be atomic.
+        #          See https://cloud.google.com/spanner/docs/dml-partitioned for more information.
+        def begin_isolated_db_transaction isolation
+          raise "Unsupported isolation level: #{isolation}" unless \
+              [:serializable, :read_only, :buffered_mutations, :pdml].include? isolation
+
+          log "BEGIN #{isolation}" do
+            @connection.begin_transaction isolation
           end
+        end
 
-          row = values.inject({}) {|r, (col, val)| r[col] = val; r }
-          rows = target.map {|id| row.merge(pk => id) }
-
-          log(fake_sql, name, binds) do
-            with_phase_transition {|client| client.update(table, rows) }
+        def commit_db_transaction
+          log "COMMIT" do
+            @connection.commit_transaction
           end
-          target.size
         end
 
-        def delete(arel, name, binds)
-          raise NotImplementedError, "DELETE statement in raw SQL is not supported" unless arel.respond_to?(:ast)
-
-          type_casted_binds = binds.map {|attr| type_cast(attr.value_for_database) }
-          table, target, wheres = MutationVisitor.new(self, type_casted_binds.dup).accept(arel.ast)
-
-          # TODO(yugui) Support composite primary key?
-          pk = primary_key(table)
-          if target.nil?
-            where_clause = visitor.accept(wheres, collector).compile(binds.dup, self)
-            # TODO(yugui) keep consistency with transaction
-            target = select_values(<<~"SQL", name, binds)
-              SELECT #{quote_column_name(pk)} FROM #{quote_table_name(table)} WHERE #{where_clause}
-            SQL
+        def rollback_db_transaction
+          log "ROLLBACK" do
+            @connection.rollback_transaction
           end
+        end
 
-          if target == :all
-            keyset = []
-            fake_sql = "DELETE FROM #{quote_column_name(table)}"
-          elsif target.size > 1
-            fake_sql = "DELETE FROM #{quote_column_name(table)} WHERE (primary-key) IN ?"
-            keyset = target
-          else
-            fake_sql = "DELETE FROM #{quote_column_name(table)} WHERE (primary-key) = ?"
-            keyset = target
-          end
+        private
 
-          log(fake_sql, name, binds) do
-            with_phase_transition {|client| client.delete(table, keyset) }
-          end
+        # Translates binds to Spanner types and params.
+        def to_types_and_params binds
+          types = binds.enum_for(:each_with_index).map do |bind, i|
+            type = :INT64
+            if bind.respond_to? :type
+              type = ActiveRecord::Type::Spanner::SpannerActiveRecordConverter
+                     .convert_active_model_type_to_spanner(bind.type)
+            end
+            [
+              # Generates binds for named parameters in the format `@p1, @p2, ...`
+              "p#{i + 1}", type
+            ]
+          end.to_h
+          params = binds.enum_for(:each_with_index).map do |bind, i|
+            type = bind.respond_to?(:type) ? bind.type : ActiveModel::Type::Integer
+            value = bind
+            value = type.serialize bind.value, :dml if type.respond_to?(:serialize) && type.method(:serialize).arity < 0
+            value = type.serialize bind.value if type.respond_to?(:serialize) && type.method(:serialize).arity >= 0
+
+            ["p#{i + 1}", value]
+          end.to_h
+          [types, params]
+        end
 
-          keyset.size
+        # An insert/update/delete statement could use mutations in some specific circumstances.
+        # This method returns an indication whether a specific operation should use mutations instead of DML
+        # based on the operation itself, and the current transaction.
+        def should_use_mutation arel
+          !@connection.current_transaction.nil? \
+            && @connection.current_transaction.isolation == :buffered_mutations \
+            && can_use_mutation(arel) \
         end
 
-        def execute(stmt)
-          case stmt
-          when Spanner::DDL
-            execute_ddl(stmt)
-          else
-            super(stmt)
-          end
+        def can_use_mutation arel
+          return true if arel.is_a?(Arel::DeleteManager) && arel.respond_to?(:ast) && arel.ast.wheres.empty?
+          false
         end
 
-        def exec_query(sql, name = 'SQL', binds = [], prepare: :ignored)
-          case
-          when binds.kind_of?(Hash)
-            spanner_binds = binds
-            binds = binds.values
-          when binds.respond_to?(:to_hash)
-            spanner_binds = binds.to_hash
-            binds = spanner_binds.values
-          else
-            spanner_binds = binds.each_with_index.inject({}) {|b, (attr, i)|
-              b["p#{i+1}"] = type_cast(attr.value_for_database)
-              b
-            }
+        def create_delete_all_mutation arel
+          unless arel.is_a? Arel::DeleteManager
+            raise "A delete mutation can only be created from a DeleteManager"
           end
-
-          log(sql, name, binds) do
-            executor = client
-            executor = raw_client if name == 'SCHEMA'
-            results = executor.execute(sql, params: spanner_binds) 
-            columns = results.fields.keys
-            rows = results.rows.map(&:to_a)
-            ActiveRecord::Result.new(columns.map(&:to_s), rows)
+          # Check if it is a delete_all operation.
+          unless arel.ast.wheres.empty?
+            raise "A delete mutation can only be created without a WHERE clause"
+          end
+          table_name = arel.ast.relation.name if arel.ast.relation.is_a? Arel::Table
+          table_name = arel.ast.relation.left.name if arel.ast.relation.is_a? Arel::Nodes::JoinSource
+          unless table_name
+            raise "Could not find table for delete mutation"
           end
-        end
 
-        def begin_db_transaction
-          with_phase_transition {|client| client.begin_transaction }
+          Google::Cloud::Spanner::V1::Mutation.new(
+            delete: Google::Cloud::Spanner::V1::Mutation::Delete.new(
+              table: table_name,
+              key_set: { all: true }
+            )
+          )
         end
 
-        def begin_isolated_db_transaction(isolation)
-          with_phase_transition {|client| client.begin_snapshot(**isolation) }
-        end
+        COMMENT_REGEX = %r{(?:--.*\n)*|/\*(?:[^*]|\*[^/])*\*/}m.freeze \
+            unless defined? ActiveRecord::ConnectionAdapters::AbstractAdapter::COMMENT_REGEX
+        COMMENT_REGEX = ActiveRecord::ConnectionAdapters::AbstractAdapter::COMMENT_REGEX \
+            if defined? ActiveRecord::ConnectionAdapters::AbstractAdapter::COMMENT_REGEX
 
-        def commit_db_transaction
-          with_phase_transition {|client| client.commit }
+        private_class_method def self.build_sql_statement_regexp *parts # :nodoc:
+          parts = parts.map { |part| /#{part}/i }
+          /\A(?:[\(\s]|#{COMMENT_REGEX})*#{Regexp.union(*parts)}/
         end
 
-        def exec_rollback_db_transaction
-          with_phase_transition {|client| client.rollback }
+        DDL_REGX = build_sql_statement_regexp(:create, :alter, :drop).freeze
+
+        DML_REGX = build_sql_statement_regexp(:insert, :delete, :update).freeze
+
+        def sql_statement_type sql
+          case sql
+          when DDL_REGX
+            :ddl
+          when DML_REGX
+            :dml
+          else
+            :dql
+          end
         end
 
-        def with_phase_transition
-          result = yield client
-          @client = client.next
-          result
+        ##
+        # Retrieves the delay value from Google::Cloud::AbortedError or
+        # GRPC::Aborted
+        def delay_from_aborted err
+          return nil if err.nil?
+          if err.respond_to?(:metadata) && err.metadata["google.rpc.retryinfo-bin"]
+            retry_info = Google::Rpc::RetryInfo.decode err.metadata["google.rpc.retryinfo-bin"]
+            seconds = retry_info["retry_delay"].seconds
+            nanos = retry_info["retry_delay"].nanos
+            return seconds if nanos.zero?
+            return seconds + (nanos / 1_000_000_000.0)
+          end
+          # No metadata? Try the inner error
+          delay_from_aborted err.cause
+        rescue StandardError
+          # Any error indicates the backoff should be handled elsewhere
+          nil
         end
       end
     end
   end
 end
-