activerecord-spanner-adapter 2.5.1 → 2.7.0

data/acceptance/cases/interleaved_associations/has_many_associations_using_interleaved_test.rb

@@ -1,221 +0,0 @@
-# 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.
-
-# frozen_string_literal: true
-
-# ActiveRecord 7.1 introduced native support for composite primary keys.
-# This deprecates the https://github.com/composite-primary-keys/composite_primary_keys gem that was previously used in
-# this library to support composite primary keys, which again are needed for interleaved tables. These tests use the
-# third-party composite primary key gem and are therefore not executed for Rails 7.1 and higher.
-return if ActiveRecord::gem_version >= Gem::Version.create('7.1.0')
-
-require "test_helper"
-require "models/singer"
-require "models/album"
-require "models/track"
-
-module ActiveRecord
-  module Associations
-    class HasManyUsingInterleavedTest < SpannerAdapter::TestCase
-      include SpannerAdapter::Associations::TestHelper
-
-      attr_accessor :singer, :album1, :album2
-
-      def setup
-        super
-        @original_verbosity = $VERBOSE
-        $VERBOSE = nil
-
-        @singer = Singer.create first_name: "FirstName1", last_name: "LastName1"
-
-        @album2 = Album.create title: "Title2", singer: singer
-        @album1 = Album.create title: "Title1", singer: singer
-
-        @track2_1 = Track.create title: "Title2_1", album: album2, duration: 3.6
-        @track2_2 = Track.create title: "Title2_2", album: album2, duration: 3.3
-        @track1_1 = Track.create title: "Title1_1", album: album1, duration: 4.5
-        @track1_2 = Track.create title: "Title1_2", album: album1
-      end
-
-      def teardown
-        Album.destroy_all
-        Singer.destroy_all
-
-        $VERBOSE = @original_verbosity
-      end
-
-      def test_has_many
-        assert_equal 2, singer.albums.count
-        assert_equal singer.albums.pluck(:title).sort, %w[Title1 Title2]
-
-        assert_equal 4, singer.tracks.count
-        assert_equal singer.tracks.pluck(:title).sort, %w[Title1_1 Title1_2 Title2_1 Title2_2]
-
-        assert_equal 2, album1.tracks.count
-        assert_equal album1.tracks.pluck(:title).sort, %w[Title1_1 Title1_2]
-        assert_equal 2, album2.tracks.count
-        assert_equal album2.tracks.pluck(:title).sort, %w[Title2_1 Title2_2]
-      end
-
-      def test_finding_using_associated_fields
-        assert_equal Album.where(singerid: singer.id).to_a, singer.albums.to_a
-        assert_equal Track.where(singerid: singer.id).to_a, singer.tracks.to_a
-      end
-
-      def test_successful_build_association
-        album = singer.albums.build title: "New Title"
-        assert album.save
-
-        singer.reload
-        assert_equal album, singer.albums.find(album.id)
-      end
-
-      def test_successful_build_nested_association
-        track = album1.tracks.build title: "New Title", duration: 4.45
-        assert track.save
-
-        album1.reload
-        assert_equal track, album1.tracks.find(track.id)
-      end
-
-      def test_create_and_destroy_associated_records
-        singer2 = Singer.new first_name: "First", last_name: "Last"
-        singer2.albums.build title: "New Title 1", albumid: Album.next_sequence_value
-        singer2.albums.build title: "New Title 2", albumid: Album.next_sequence_value
-        singer2.save!
-
-        singer2.reload
-
-        assert_equal 2, singer2.albums.count
-        assert_equal 4, Album.count
-
-        singer2.albums.destroy_all
-        singer2.reload
-
-        assert_equal 0, singer2.albums.count
-        assert_equal 2, Album.count
-      end
-
-      def test_create_and_destroy_nested_associated_records
-        album3 = Album.new singer: singer, title: "Title 3"
-        album3.tracks.build title: "Title3_1", duration: 2.5, singer: singer, trackid: Track.next_sequence_value
-        album3.tracks.build title: "Title3_2", singer: singer, trackid: Track.next_sequence_value
-        album3.save!
-
-        album3.reload
-
-        assert_equal 2, album3.tracks.count
-        assert_equal 6, singer.tracks.count
-        assert_equal 6, Track.count
-
-        album3.tracks.destroy_all
-        album3.reload
-
-        assert_equal 0, album3.tracks.count
-        assert_equal 4, Track.count
-      end
-
-      def test_create_and_delete_associated_records
-        singer2 = Singer.new first_name: "First", last_name: "Last"
-        singer2.albums.build title: "Album - 11", albumid: Album.next_sequence_value
-        singer2.albums.build title: "Album - 12", albumid: Album.next_sequence_value
-        singer2.save!
-
-        singer2.reload
-
-        assert_equal 2, singer2.albums.count
-        assert_equal 4, Album.count
-
-        assert_equal 2, singer2.albums.delete_all
-        singer2.reload
-
-        assert_equal 0, singer2.albums.count
-        assert_equal 2, Album.count
-      end
-
-      def test_create_and_delete_nested_associated_records
-        album3 = Album.new title: "Album 3", singer: singer
-        album3.tracks.build title: "Track - 31", singer: singer, trackid: Track.next_sequence_value
-        album3.tracks.build title: "Track - 32", singer: singer, trackid: Track.next_sequence_value
-        album3.save!
-
-        album3.reload
-
-        assert_equal 2, album3.tracks.count
-        assert_equal 6, Track.count
-
-        assert_equal 2, album3.tracks.delete_all
-        album3.reload
-
-        assert_equal 0, album3.tracks.count
-        assert_equal 4, Track.count
-      end
-
-      def test_update_associated_records
-        count = singer.albums.update_all title: "Title - Update"
-        assert_equal singer.albums.count, count
-
-        singer.reload
-        singer.albums.each do |album|
-          assert_equal "Title - Update", album.title
-        end
-      end
-
-      def test_update_nested_associated_records
-        count = album1.tracks.update_all title: "Title - Update", duration: 6.626
-        assert_equal album1.tracks.count, count
-
-        album1.reload
-        album1.tracks.each do |track|
-          assert_equal "Title - Update", track.title
-          assert_equal 6.626, track.duration
-        end
-      end
-
-      def test_fetch_associated_record_with_order
-        albums = singer.albums.order title: :desc
-        assert_equal %w[Title2 Title1], albums.pluck(:title)
-
-        albums = singer.albums.order title: :asc
-        assert_equal %w[Title1 Title2], albums.pluck(:title)
-      end
-
-      def test_fetch_nested_associated_record_with_order
-        tracks = album1.tracks.order duration: :desc
-        assert_equal [4.5, nil], tracks.pluck(:duration)
-
-        tracks = album1.tracks.order duration: :asc
-        assert_equal [nil, 4.5], tracks.pluck(:duration)
-      end
-
-      def test_set_counter_cache
-        singer.tracks.create! title: "New Title 1", album: album1
-        singer.tracks.create! title: "New Title 2", album: album2
-
-        singer.reload
-        assert_equal 6, singer.tracks_count
-      end
-
-      def test_cascade_destroy
-        assert_equal 4, singer.tracks.count
-
-        assert album1.destroy
-
-        singer.reload
-        assert_equal 2, singer.tracks.count
-      end
-
-      def test_cascade_delete
-        assert_equal 4, singer.tracks.count
-
-        assert album1.delete
-
-        singer.reload
-        assert_equal 2, singer.tracks.count
-      end
-    end
-  end
-end

data/acceptance/cases/models/interleave_test.rb

@@ -1,113 +0,0 @@
-# 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.
-
-# frozen_string_literal: true
-
-# ActiveRecord 7.1 introduced native support for composite primary keys.
-# This deprecates the https://github.com/composite-primary-keys/composite_primary_keys gem that was previously used in
-# this library to support composite primary keys, which again are needed for interleaved tables. These tests use the
-# third-party composite primary key gem and are therefore not executed for Rails 7.1 and higher.
-return if ActiveRecord::gem_version >= Gem::Version.create('7.1.0')
-
-require "test_helper"
-require "test_helpers/with_separate_database"
-
-module ActiveRecord
-  module Model
-    class InterleaveTest
-      class WithPartialInsertsDisabledTest < SpannerAdapter::TestCase
-        include SpannerAdapter::Associations::TestHelper
-
-        class Singer < ActiveRecord::Base
-          has_many :albums, foreign_key: :singerid, dependent: :delete_all
-          has_many :tracks, foreign_key: :singerid
-        end
-
-        class Album < ActiveRecord::Base
-          self.primary_keys = :singerid, :albumid
-
-          belongs_to :singer, foreign_key: :singerid
-
-          if ActiveRecord::VERSION::MAJOR >= 7
-            self.partial_inserts = false
-          end
-        end
-
-        attr_accessor :singer
-
-        def setup
-          super
-
-          @singer = Singer.create first_name: "FirstName", last_name: "LastName"
-        end
-
-        def teardown
-          Album.destroy_all
-          Singer.destroy_all
-        end
-
-        def test_with_partial_inserts_disabled
-          Album.create! title: "Title3", singer: singer
-        end
-      end
-
-      class StringParentKeyTest < SpannerAdapter::TestCase
-        include TestHelpers::WithSeparateDatabase
-
-        class Singer < ActiveRecord::Base
-          has_many :albums, foreign_key: :singer_id
-        end
-
-        class Album < ActiveRecord::Base
-          self.primary_keys = [:singer_id, :album_id]
-          belongs_to :singer, foreign_key: :singer_id
-        end
-
-        def setup
-          super
-
-          connection.ddl_batch do
-            connection.create_table :singers, id: false do |t|
-              t.string :singer_id, limit: 36, primary_key: true, null: false
-              t.string :name, null: false
-            end
-
-            connection.create_table :albums, id: false do |t|
-              t.interleave_in :singers
-              t.string :singer_id, limit: 36, parent_key: true, primary_key: true, null: false
-              t.integer :album_id, primary_key: true, null: false
-              t.string :title, null: false
-            end
-          end
-
-          @singer = Singer.create!(id: SecureRandom.uuid, name: "a singer")
-        end
-
-        def test_create_album
-          Album.create!(singer: @singer, title: "an album")
-        end
-
-        def test_update_album
-          album = Album.create!(singer: @singer, title: "an album")
-          album.update!(title: "an album 2")
-        end
-
-        def test_get_album
-          album = Album.create!(singer: @singer, title: "an album")
-          got_album = Album.find([@singer.singer_id, album.album_id])
-          assert_equal(album, got_album)
-        end
-
-        def test_get_albums_as_children
-          album1 = Album.create!(singer: @singer, title: "album1")
-          album2 = Album.create!(singer: @singer, title: "album2")
-          albums = @singer.albums.order(:title)
-          assert_equal([album1, album2], albums)
-        end
-      end
-    end
-  end
-end

data/acceptance/cases/transactions/optimistic_locking_test.rb

@@ -1,152 +0,0 @@
-# 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.
-
-# frozen_string_literal: true
-
-# ActiveRecord 7.1 introduced native support for composite primary keys.
-# This deprecates the https://github.com/composite-primary-keys/composite_primary_keys gem that was previously used in
-# this library to support composite primary keys, which again are needed for interleaved tables. These tests use the
-# third-party composite primary key gem and are therefore not executed for Rails 7.1 and higher.
-return if ActiveRecord::gem_version >= Gem::Version.create('7.1.0')
-
-require "test_helper"
-require "models/singer"
-require "models/album"
-require "models/track"
-
-module ActiveRecord
-  module Transactions
-    class OptimisticLockingTest < SpannerAdapter::TestCase
-      include SpannerAdapter::Associations::TestHelper
-
-      def setup
-        super
-
-        @original_verbosity = $VERBOSE
-        $VERBOSE = nil
-
-        singer = Singer.create first_name: "Pete", last_name: "Allison"
-        album = Album.create title: "Musical Jeans", singer: singer
-        Track.create title: "Increased Headline", album: album, singer: singer
-      end
-
-      def teardown
-        super
-
-        Track.delete_all
-        Album.delete_all
-        Singer.delete_all
-
-        $VERBOSE = @original_verbosity
-      end
-
-      # Runs the given block in a transaction with the given isolation level, or without a transaction if isolation is
-      # nil.
-      def run_in_transaction isolation
-        if isolation
-          Base.transaction isolation: isolation do
-            yield
-          end
-        else
-          yield
-        end
-      end
-
-      def test_update_single_record_increases_version_number
-        [nil, :serializable, :buffered_mutations].each do |isolation|
-          singer = Singer.all.sample
-          original_version = singer.lock_version
-
-          run_in_transaction isolation do
-            singer.update last_name: "Peterson-#{singer.last_name}"
-          end
-
-          singer.reload
-          assert_equal original_version + 1, singer.lock_version
-        end
-      end
-
-      def test_update_multiple_records_increases_version_numbers
-        singer = Singer.all.sample
-        album = Album.all.sample
-        track = Track.all.sample
-        [nil, :serializable, :buffered_mutations].each do |isolation|
-          original_singer_version = singer.reload.lock_version
-          original_album_version = album.reload.lock_version
-          original_track_version = track.reload.lock_version
-
-          run_in_transaction isolation do
-            singer.update last_name: "Peterson-#{singer.last_name}"
-            singer.albums.each { |album| album.update title: "Updated: #{album.title}" }
-            singer.tracks.each { |track| track.update title: "Updated: #{track.title}" }
-          end
-
-          singer.reload
-          assert_equal original_singer_version + 1, singer.lock_version
-          singer.albums.each { |album| assert_equal original_album_version + 1, album.lock_version }
-          singer.tracks.each { |track| assert_equal original_track_version + 1, track.lock_version }
-        end
-      end
-
-      def test_concurrent_update_single_record_fails
-        [nil, :serializable, :buffered_mutations].each do |isolation|
-          singer = Singer.all.sample
-          original_version = singer.lock_version
-
-          # Update the singer in a separate thread to simulate a concurrent update.
-          t = Thread.new do
-            singer2 = Singer.find singer.id
-            singer2.update last_name: "Henderson-#{singer2.last_name}"
-          end
-          t.join
-
-          run_in_transaction isolation do
-            assert_raises ActiveRecord::StaleObjectError do
-              singer.update last_name: "Peterson-#{singer.last_name}"
-            end
-          end
-
-          singer.reload
-          assert_equal original_version + 1, singer.lock_version
-          assert singer.last_name.start_with?("Henderson-")
-        end
-      end
-
-      def test_concurrent_update_multiple_records_fails
-        singer = Singer.all.sample
-        album = Album.all.sample
-        track = Track.all.sample
-        [nil, :serializable, :buffered_mutations].each do |isolation|
-          original_singer_version = singer.reload.lock_version
-          original_album_version = album.reload.lock_version
-          original_track_version = track.reload.lock_version
-
-          # Update the singer in a separate thread to simulate a concurrent update.
-          t = Thread.new do
-            singer2 = Singer.find singer.id
-            singer2.update last_name: "Henderson-#{singer2.last_name}"
-          end
-          t.join
-
-          run_in_transaction isolation do
-            assert_raises ActiveRecord::StaleObjectError do
-              singer.update last_name: "Peterson-#{singer.last_name}"
-            end
-            singer.albums.each { |album| album.update title: "Updated: #{album.title}" }
-            singer.tracks.each { |track| track.update title: "Updated: #{track.title}" }
-          end
-
-          singer.reload
-          # The singer should be updated, but only by the separate thread.
-          assert_equal original_singer_version + 1, singer.lock_version
-          assert singer.last_name.start_with? "Henderson-"
-          singer.albums.each { |album| assert_equal original_album_version + 1, album.lock_version }
-          singer.tracks.each { |track| assert_equal original_track_version + 1, track.lock_version }
-        end
-      end
-    end
-  end
-end

data/acceptance/models/album.rb

@@ -1,15 +0,0 @@
-# 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 Album < ActiveRecord::Base
-  # Register both primary key columns with composite_primary_keys
-  self.primary_keys = :singerid, :albumid
-
-  # The relationship with singer is not really a foreign key, but an INTERLEAVE IN relationship. We still need to
-  # use the `foreign_key` attribute to indicate which column to use for the relationship.
-  belongs_to :singer, foreign_key: :singerid
-  has_many :tracks, foreign_key: [:singerid, :albumid], dependent: :delete_all
-end

data/acceptance/models/track.rb

@@ -1,23 +0,0 @@
-# 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 Track < ActiveRecord::Base
-  # Register both primary key columns with composite_primary_keys
-  self.primary_keys = :singerid, :albumid, :trackid
-
-  belongs_to :album, foreign_key: [:singerid, :albumid]
-  belongs_to :singer, foreign_key: :singerid, counter_cache: true
-
-  def initialize attributes = nil
-    super
-    self.singer ||= self.album&.singer
-  end
-
-  def album=value
-    super
-    self.singer = value&.singer
-  end
-end

data/examples/snippets/interleaved-tables-before-7.1/README.md

@@ -1,167 +0,0 @@
-# Sample - Interleaved Tables - Before Rails 7.1.0
-
-__NOTE__: This example uses the third-party gem `composite_primary_keys`. This is only supported with
-Rails version < `7.1.0`.
-
-This example shows how to use interleaved tables with the Spanner ActiveRecord adapter.
-Interleaved tables use composite primary keys. This is not natively supported by ActiveRecord.
-It is therefore necessary to use the `composite_primary_keys` (https://github.com/composite-primary-keys/composite_primary_keys)
-gem to enable the use of interleaved tables.
-
-See https://cloud.google.com/spanner/docs/schema-and-data-model#creating-interleaved-tables for more information
-on interleaved tables if you are not familiar with this concept.
-
-## Creating Interleaved Tables in ActiveRecord
-You can create interleaved tables using migrations in ActiveRecord by using the following Spanner ActiveRecord specific
-methods that are defined on `TableDefinition`:
-* `interleave_in`: Specifies which parent table a child table should be interleaved in and optionally whether
-  deletes of a parent record should automatically cascade delete all child records.
-* `parent_key`: Creates a column that is a reference to (a part of) the primary key of the parent table. Each child
-  table must include all the primary key columns of the parent table as a `parent_key`.
-
-Cloud Spanner requires a child table to include the exact same primary key columns as the parent table in addition to
-the primary key column(s) of the child table. This means that the default `id` primary key column of ActiveRecord is
-not usable in combination with interleaved tables. Instead each primary key column should be prefixed with the table
-name of the table that it references, or use some other unique name.
-
-## Example Data Model
-This example uses the following table schema:
-
-```sql
-CREATE TABLE singers (
-    singerid INT64 NOT NULL,
-    first_name STRING(MAX),
-    last_name STRING(MAX)
-) PRIMARY KEY (singerid);
-
-CREATE TABLE albums (
-    albumid INT64 NOT NULL,
-    singerid INT64 NOT NULL,
-    title STRING(MAX)
-) PRIMARY KEY (singerid, albumid), INTERLEAVE IN PARENT singers;
-
-CREATE TABLE tracks (
-    trackid INT64 NOT NULL,
-    singerid INT64 NOT NULL,
-    albumid INT64 NOT NULL,
-    title STRING(MAX),
-    duration NUMERIC
-) PRIMARY KEY (singerid, albumid, trackid), INTERLEAVE IN PARENT albums ON DELETE CASCADE;
-```
-
-This schema can be created in ActiveRecord as follows:
-
-```ruby
-create_table :singers, id: false do |t|
-  # Explicitly define the primary key with a custom name to prevent all primary key columns from being named `id`.
-  t.primary_key :singerid
-  t.string :first_name
-  t.string :last_name
-end
-
-create_table :albums, id: false do |t|
-  # Interleave the `albums` table in the parent table `singers`.
-  t.interleave_in :singers
-  t.primary_key :albumid
-  # `singerid` is defined as a `parent_key` which makes it a part of the primary key in the table definition, but
-  # it is not presented to ActiveRecord as part of the primary key, to prevent ActiveRecord from considering this
-  # to be an entity with a composite primary key (which is not supported by ActiveRecord).
-  t.parent_key :singerid
-  t.string :title
-end
-
-create_table :tracks, id: false do |t|
-  # Interleave the `tracks` table in the parent table `albums` and cascade delete all tracks that belong to an
-  # album when an album is deleted.
-  t.interleave_in :albums, :cascade
-  # Add `trackid` as the primary key in the table definition. Add the other key parts as
-  # a `parent_key`.
-  t.primary_key :trackid
-  # `singerid` and `albumid` form the parent key of `tracks`. These are part of the primary key definition in the
-  # database, but are presented as parent keys to ActiveRecord.
-  t.parent_key :singerid
-  t.parent_key :albumid
-  t.string :title
-  t.numeric :duration
-end
-```
-
-## Models for Interleaved Tables
-The model definition for an interleaved table (a child table) must use the `primary_keys=col1, col2, ...`
-function from the `composite_primary_keys` gem.
-
-An interleaved table parent/child relationship must be modelled as a `belongs_to`/`has_many` association in
-ActiveRecord. As the columns that are used to reference a parent record use a custom column name, it is required to also
-include the custom column name(s) in the `belongs_to` and `has_many` definitions.
-
-Instances of these models can be used in the same way as any other association in ActiveRecord, but with a couple of
-inherent limitations:
-* It is not possible to change the parent record of a child record. For instance, changing the singer of an album in the
-  above example is impossible, as Cloud Spanner does not allow such an update.
-* It is not possible to de-reference a parent record by setting it to null.
-* It is only possible to delete a parent record with existing child records, if the child records are also deleted. This
-  can be done by enabling ON DELETE CASCADE in Cloud Spanner, or by deleting the child records using ActiveRecord.
-
-### Example Models
-
-```ruby
-class Singer < ActiveRecord::Base
-  # `albums` is defined as INTERLEAVE IN PARENT `singers`.
-  # The primary key of `albums` is (`singerid`, `albumid`).
-  has_many :albums, foreign_key: :singerid
-
-  # `tracks` is defined as INTERLEAVE IN PARENT `albums`.
-  # The primary key of `tracks` is (`singerid`, `albumid`, `trackid`).
-  # The `singerid` column can be used to associate tracks with a singer without the need to go through albums.
-  # Note also that the inclusion of `singerid` as a column in `tracks` is required in order to make `tracks` a child
-  # table of `albums` which has primary key (`singerid`, `albumid`).
-  has_many :tracks, foreign_key: :singerid
-end
-
-class Album < ActiveRecord::Base
-  # Use the `composite_primary_key` gem to create a composite primary key definition for the model.
-  self.primary_keys = :singerid, :albumid
-
-  # `albums` is defined as INTERLEAVE IN PARENT `singers`.
-  # The primary key of `singers` is `singerid`.
-  belongs_to :singer, foreign_key: :singerid
-
-  # `tracks` is defined as INTERLEAVE IN PARENT `albums`.
-  # The primary key of `albums` is (`singerid`, `albumid`).
-  has_many :tracks, foreign_key: [:singerid, :albumid]
-end
-
-class Track < ActiveRecord::Base
-  # Use the `composite_primary_key` gem to create a composite primary key definition for the model.
-  self.primary_keys = :singerid, :albumid, :trackid
-
-  # `tracks` is defined as INTERLEAVE IN PARENT `albums`. The primary key of `albums` is (`singerid`, `albumid`).
-  belongs_to :album, foreign_key: [:singerid, :albumid]
-
-  # `tracks` also has a `singerid` column that can be used to associate a Track with a Singer.
-  belongs_to :singer, foreign_key: :singerid
-
-  # Override the default initialize method to automatically set the singer attribute when an album is given.
-  def initialize attributes = nil
-    super
-    self.singer ||= album&.singer
-  end
-
-  def album=value
-    super
-    # Ensure the singer of this track is equal to the singer of the album that is set.
-    self.singer = value&.singer
-  end
-end
-```
-
-## Running the Sample
-
-The sample will automatically start a Spanner Emulator in a docker container and execute the sample
-against that emulator. The emulator will automatically be stopped when the application finishes.
-
-Run the application with the command
-
-```bash
-bundle exec rake run
-```