activerecord-spanner-adapter 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9a2ada6b62b88752f24052c1071bb3df30e1057e711045d26ecf1403b891d5b7
-  data.tar.gz: 831ec65b5bb4b25ce13970213a5f626e327d9ab6972f86f21076363218fc3ef7
+  metadata.gz: 9b467bf41466950098792dc720fd39065b59cefa8c8bdd211e6f4cd4a3a4e816
+  data.tar.gz: ad927b97190f98d4aa9f6af41b0b32684ae3c1477266a30254a0133586370c31
 SHA512:
-  metadata.gz: 781bb93f7a9d505864b7b242088b51921df1386c4859e112057bd8b1d3c7bcbee1e3f941af2bcf99324537c136b667464c6328630aa6bd7a769fb9ee52ace690
-  data.tar.gz: 485369ec08bd2d3dac01edb57425dd003cace09581bf01fd4d7300a1d4142bc8a701a4d83f18b56c740c7b52f9d2c58d7af0eb3683bafb3e4e81afc59e2e2dc5
+  metadata.gz: 6a954866b8f423ad0f4784026c9564cd2f3b551a03c3eff215b77d824fb066df987bf65e53d9e030a0347110ff94f3e7e2e8b754398a577573cd9a573cece8ff
+  data.tar.gz: 808eb7c9f202667c01fe0870ee09714b9d1ca04f75eb260940ae75766958b99137c29d72ff86e519d01d4cc0f52c0d92084aa19bb2ddb5e02e688caecc8bbfda

data/.github/CODEOWNERS

@@ -4,4 +4,4 @@
 # For syntax help see:
 # https://help.github.com/en/github/creating-cloning-and-archiving-repositories/about-code-owners#codeowners-syntax
 
-*     @jiren @skuruppu @dazuma @hengfengli @olavloite @xiangshen-dk
+*     @googleapis/yoshi-ruby @skuruppu @hengfengli @olavloite @xiangshen-dk

data/.release-please-manifest.json

@@ -1,3 +1,3 @@
 {
-  ".": "1.1.0"
+  ".": "1.2.0"
 }

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+### 1.2.0 (2022-08-03)
+
+#### Features
+
+* support composite primary keys for interleaved tables ([#175](https://github.com/googleapis/ruby-spanner-activerecord/issues/175)) 
+
 ### 1.1.0 (2022-06-24)
 
 #### Features

data/Gemfile

@@ -8,6 +8,9 @@ gem "minitest", "~> 5.15.0"
 gem "pry", "~> 0.13.0"
 gem "pry-byebug", "~> 3.9.0"
 
+# Required for samples and testing.
+gem "composite_primary_keys"
+
 # Required for samples
-gem 'docker-api'
+gem "docker-api"
 gem "sinatra-activerecord"

data/acceptance/cases/interleaved_associations/has_many_associations_using_interleaved_test.rb

@@ -20,6 +20,8 @@ module ActiveRecord
 
       def setup
         super
+        @original_verbosity = $VERBOSE
+        $VERBOSE = nil
 
         @singer = Singer.create first_name: "FirstName1", last_name: "LastName1"
 
@@ -35,6 +37,8 @@ module ActiveRecord
       def teardown
         Album.destroy_all
         Singer.destroy_all
+
+        $VERBOSE = @original_verbosity
       end
 
       def test_has_many
@@ -73,8 +77,8 @@ module ActiveRecord
 
       def test_create_and_destroy_associated_records
         singer2 = Singer.new first_name: "First", last_name: "Last"
-        singer2.albums.build title: "New Title 1"
-        singer2.albums.build title: "New Title 2"
+        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
@@ -91,8 +95,8 @@ module ActiveRecord
 
       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
-        album3.tracks.build title: "Title3_2", singer: singer
+        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
@@ -110,8 +114,8 @@ module ActiveRecord
 
       def test_create_and_delete_associated_records
         singer2 = Singer.new first_name: "First", last_name: "Last"
-        singer2.albums.build title: "Album - 11"
-        singer2.albums.build title: "Album - 12"
+        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
@@ -128,8 +132,8 @@ module ActiveRecord
 
       def test_create_and_delete_nested_associated_records
         album3 = Album.new title: "Album 3", singer: singer
-        album3.tracks.build title: "Track - 31", singer: singer
-        album3.tracks.build title: "Track - 32", 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

data/acceptance/cases/transactions/optimistic_locking_test.rb

@@ -19,6 +19,9 @@ module ActiveRecord
       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
@@ -30,6 +33,8 @@ module ActiveRecord
         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

data/acceptance/models/album.rb

@@ -4,9 +4,14 @@
 # license that can be found in the LICENSE file or at
 # https://opensource.org/licenses/MIT.
 
+require "composite_primary_keys"
+
 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: "albumid", dependent: :delete_all
+  belongs_to :singer, foreign_key: :singerid
+  has_many :tracks, foreign_key: [:singerid, :albumid], dependent: :delete_all
 end

data/acceptance/models/singer.rb

@@ -5,6 +5,6 @@
 # https://opensource.org/licenses/MIT.
 
 class Singer < ActiveRecord::Base
-  has_many :albums, foreign_key: "singerid", dependent: :delete_all
-  has_many :tracks, foreign_key: "singerid"
+  has_many :albums, foreign_key: :singerid, dependent: :delete_all
+  has_many :tracks, foreign_key: :singerid
 end

data/acceptance/models/track.rb

@@ -5,8 +5,11 @@
 # https://opensource.org/licenses/MIT.
 
 class Track < ActiveRecord::Base
-  belongs_to :album, foreign_key: "albumid"
-  belongs_to :singer, foreign_key: "singerid", counter_cache: true
+  # 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

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

@@ -0,0 +1,164 @@
+# Sample - Interleaved Tables
+
+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_key` 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
+```

data/examples/snippets/interleaved-tables/Rakefile

@@ -0,0 +1,13 @@
+# Copyright 2022 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_relative "../config/environment"
+require "sinatra/activerecord/rake"
+
+desc "Sample showing how to work with interleaved tables in ActiveRecord."
+task :run do
+  Dir.chdir("..") { sh "bundle exec rake run[interleaved-tables]" }
+end

data/examples/snippets/interleaved-tables/application.rb

@@ -0,0 +1,126 @@
+# Copyright 2022 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/singer"
+require_relative "models/album"
+require_relative "models/track"
+
+class Application
+  def self.run
+    # List all singers, albums and tracks.
+    list_singers_albums_tracks
+
+    # Create a new album with some tracks.
+    create_new_album
+
+    # Try to update the singer of an album. This is not possible as albums are interleaved in singers.
+    update_singer_of_album
+
+    # Try to delete a singer that has at least one album. This is NOT possible as albums is NOT marked with
+    # ON DELETE CASCADE.
+    delete_singer_with_albums
+
+    # Try to delete an album that has at least one track. This IS possible as tracks IS marked with
+    # ON DELETE CASCADE.
+    delete_album_with_tracks
+
+    puts ""
+    puts "Press any key to end the application"
+    STDIN.getch
+  end
+
+  def self.find_singer
+    singerid = Singer.all.sample.singerid
+
+    singer = Singer.find singerid
+    puts "Found singer: #{singer.first_name} #{singer.last_name}"
+  end
+
+  def self.find_album
+    singer = Singer.all.sample
+    albumid = singer.albums.sample.albumid
+
+    album = Album.find [singer.singerid, albumid]
+    puts "Found album: #{album.title}"
+  end
+
+  def self.list_singers_albums_tracks
+    puts ""
+    puts "Listing all singers with corresponding albums and tracks"
+    Singer.all.order("last_name, first_name").each do |singer|
+      puts "#{singer.first_name} #{singer.last_name} has #{singer.albums.count} albums:"
+      singer.albums.order("title").each do |album|
+        puts "  #{album.title} has #{album.tracks.count} tracks:"
+        album.tracks.each do |track|
+          puts "    #{track.title}"
+        end
+      end
+    end
+  end
+
+  def self.create_new_album
+    # Create a new album with some tracks.
+    puts ""
+    singer = Singer.all.sample
+    puts "Creating a new album for #{singer.first_name} #{singer.last_name}"
+    album = singer.albums.build title: "New Title"
+    # NOTE: When adding multiple elements to a collection, you *MUST* set the primary key value (i.e. trackid).
+    # Otherwise, ActiveRecord thinks that you are adding the same record multiple times and will only add one.
+    album.tracks.build title: "Track 1", duration: 3.5, singer: singer, trackid: Track.next_sequence_value
+    album.tracks.build title: "Track 2", duration: 3.6, singer: singer, trackid: Track.next_sequence_value
+    # This will save the album and corresponding tracks in one transaction.
+    album.save!
+
+    album.reload
+    puts "Album #{album.title} has #{album.tracks.count} tracks:"
+    album.tracks.order("title").each do |track|
+      puts "  #{track.title} with duration #{track.duration}"
+    end
+  end
+
+  def self.update_singer_of_album
+    # It is not possible to change the singer of an album or the album of a track. This is because the associations
+    # between these are not traditional foreign keys, but an immutable parent-child relationship.
+    album = Album.all.sample
+    new_singer = Singer.all.where.not(singerid: album.singer).sample
+    # This will fail as we cannot assign a new singer to an album as it is an INTERLEAVE IN PARENT relationship.
+    begin
+      album.update! singer: new_singer
+      raise StandardError, "Unexpected error: Updating the singer of an album should not be possible."
+    rescue ActiveRecord::StatementInvalid
+      puts ""
+      puts "Failed to update the singer of an album. This is expected."
+    end
+  end
+
+  def self.delete_singer_with_albums
+    # Deleting a singer that has albums is not possible, as the INTERLEAVE IN PARENT of albums is not marked with
+    # ON DELETE CASCADE.
+    singer = Album.all.sample.singer
+    begin
+      singer.delete
+      raise StandardError, "Unexpected error: Updating the singer of an album should not be possible."
+    rescue ActiveRecord::StatementInvalid
+      puts ""
+      puts "Failed to delete a singer that has #{singer.albums.count} albums. This is expected."
+    end
+  end
+
+  def self.delete_album_with_tracks
+    # Deleting an album with tracks is supported, as the INTERLEAVE IN PARENT relationship between tracks and albums is
+    # marked with ON DELETE CASCADE.
+    puts ""
+    puts "Total track count: #{Track.count}"
+    album = Track.all.sample.album
+    puts "Deleting album #{album.title} with #{album.tracks.count} tracks"
+    album.delete
+    puts "Total track count after deletion: #{Track.count}"
+  end
+end
+
+Application.run

data/examples/snippets/interleaved-tables/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/interleaved-tables/db/migrate/01_create_tables.rb

@@ -0,0 +1,44 @@
+# Copyright 2022 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
+    # Execute the entire migration as one DDL batch.
+    connection.ddl_batch do
+      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
+        # `trackid` is considered the only primary key column by ActiveRecord.
+        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
+    end
+  end
+end

data/examples/snippets/interleaved-tables/db/schema.rb

@@ -0,0 +1,32 @@
+# 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 `bin/rails
+# db:schema:load`. When creating a new database, `bin/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 "albums", primary_key: "albumid", id: { limit: 8 }, force: :cascade do |t|
+    t.integer "singerid", limit: 8, null: false
+    t.string "title"
+  end
+
+  create_table "singers", primary_key: "singerid", id: { limit: 8 }, force: :cascade do |t|
+    t.string "first_name"
+    t.string "last_name"
+  end
+
+  create_table "tracks", primary_key: "trackid", id: { limit: 8 }, force: :cascade do |t|
+    t.integer "singerid", limit: 8, null: false
+    t.integer "albumid", limit: 8, null: false
+    t.string "title"
+    t.decimal "duration"
+  end
+
+end

data/examples/snippets/interleaved-tables/db/seeds.rb

@@ -0,0 +1,40 @@
+# Copyright 2022 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_relative "../../config/environment.rb"
+require_relative "../models/singer"
+require_relative "../models/album"
+require_relative "../models/track"
+
+first_names = %w[Pete Alice John Ethel Trudy Naomi Wendy Ruben Thomas Elly]
+last_names = %w[Wendelson Allison Peterson Johnson Henderson Ericsson Aronson Tennet Courtou]
+
+adjectives = %w[daily happy blue generous cooked bad open]
+nouns = %w[windows potatoes bank street tree glass bottle]
+
+verbs = %w[operate waste package chew yield express polish stress slip want cough campaign cultivate report park refer]
+adverbs = %w[directly right hopefully personally economically privately supposedly consequently fully later urgently]
+
+durations = [3.14, 5.4, 3.3, 4.1, 5.0, 3.2, 3.0, 3.5, 4.0, 4.5, 5.5, 6.0]
+
+# This ensures all the records are inserted using one read/write transaction that will use mutations instead of DML.
+ActiveRecord::Base.transaction isolation: :buffered_mutations do
+  singers = []
+  5.times do
+    singers << Singer.create(first_name: first_names.sample, last_name: last_names.sample)
+  end
+
+  albums = []
+  20.times do
+    singer = singers.sample
+    albums << Album.create(title: "#{adjectives.sample} #{nouns.sample}", singer: singer)
+  end
+
+  200.times do
+    album = albums.sample
+    Track.create title: "#{verbs.sample} #{adverbs.sample}", duration: durations.sample, album: album
+  end
+end

data/examples/snippets/interleaved-tables/models/album.rb

@@ -0,0 +1,20 @@
+# Copyright 2022 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 "composite_primary_keys"
+
+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

data/examples/snippets/interleaved-tables/models/singer.rb

@@ -0,0 +1,18 @@
+# Copyright 2022 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 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

data/examples/snippets/interleaved-tables/models/track.rb

@@ -0,0 +1,28 @@
+# Copyright 2022 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
+  # 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 should 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

data/lib/activerecord_spanner_adapter/base.rb

@@ -4,6 +4,8 @@
 # license that can be found in the LICENSE file or at
 # https://opensource.org/licenses/MIT.
 
+require "activerecord_spanner_adapter/relation"
+
 module ActiveRecord
   class TableMetadata # :nodoc:
     # This attr_reader is private in ActiveRecord 6.0.x and public in 6.1.x. This makes sure it is always available in
@@ -41,6 +43,30 @@ module ActiveRecord
       spanner_adapter? && connection&.current_spanner_transaction&.isolation == :buffered_mutations
     end
 
+    def self._insert_record values
+      return super unless buffered_mutations? || (primary_key && values.is_a?(Hash))
+
+      return _buffer_record values, :insert if buffered_mutations?
+
+      primary_key_value =
+        if primary_key.is_a? Array
+          _set_composite_primary_key_values primary_key, values
+        else
+          _set_single_primary_key_value primary_key, values
+        end
+      if ActiveRecord::VERSION::MAJOR >= 7
+        im = Arel::InsertManager.new arel_table
+        im.insert(values.transform_keys { |name| arel_table[name] })
+      else
+        im = arel_table.compile_insert _substitute_values(values)
+      end
+      connection.insert(im, "#{self} Create", primary_key || false, primary_key_value)
+    end
+
+    def self._upsert_record values
+      _buffer_record values, :insert_or_update
+    end
+
     def self.insert_all _attributes, _returning: nil, _unique_by: nil
       raise NotImplementedError, "Cloud Spanner does not support skip_duplicates."
     end
@@ -87,29 +113,13 @@ module ActiveRecord
       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
-          values[primary_key] = primary_key_value
+      primary_key_value =
+        if primary_key.is_a? Array
+          _set_composite_primary_key_values primary_key, values
+        else
+          _set_single_primary_key_value primary_key, values
         end
-      end
 
       metadata = TableMetadata.new self, arel_table
       columns, grpc_values = _create_grpc_values_for_insert metadata, values
@@ -128,6 +138,43 @@ module ActiveRecord
       primary_key_value
     end
 
+    def self._set_composite_primary_key_values primary_key, values
+      primary_key_value = []
+      primary_key.each do |col|
+        value = values[col]
+
+        if !value && prefetch_primary_key?
+          value =
+            if ActiveRecord::VERSION::MAJOR >= 7
+              ActiveModel::Attribute.from_database col, next_sequence_value, ActiveModel::Type::BigInteger.new
+            else
+              next_sequence_value
+            end
+          values[col] = value
+        end
+        if value.is_a? ActiveModel::Attribute
+          value = value.value
+        end
+        primary_key_value.append value
+      end
+      primary_key_value
+    end
+
+    def self._set_single_primary_key_value primary_key, values
+      primary_key_value = values[primary_key] || values[primary_key.to_sym]
+
+      if !primary_key_value && prefetch_primary_key?
+        primary_key_value = next_sequence_value
+        if ActiveRecord::VERSION::MAJOR >= 7
+          values[primary_key] = ActiveModel::Attribute.from_database primary_key, primary_key_value,
+                                                                     ActiveModel::Type::BigInteger.new
+        else
+          values[primary_key] = primary_key_value
+        end
+      end
+      primary_key_value
+    end
+
     # Deletes all records of this class. 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.
     def self.delete_all
@@ -289,15 +336,34 @@ module ActiveRecord
       serialized_values
     end
 
-    def _execute_version_check attempted_action
+    def _execute_version_check attempted_action # rubocop:disable Metrics/AbcSize
       locking_column = self.class.locking_column
       previous_lock_value = read_attribute_before_type_cast locking_column
 
+      primary_key = self.class.primary_key
+      if primary_key.is_a? Array
+        pk_sql = ""
+        params = {}
+        param_types = {}
+        id = id_in_database
+        primary_key.each_with_index do |col, idx|
+          pk_sql.concat "`#{col}`=@id#{idx}"
+          pk_sql.concat " AND " if idx < primary_key.length - 1
+
+          params["id#{idx}"] = id[idx]
+          param_types["id#{idx}"] = :INT64
+        end
+        params["lock_version"] = previous_lock_value
+        param_types["lock_version"] = :INT64
+      else
+        pk_sql = "`#{self.class.primary_key}` = @id"
+        params = { "id" => id_in_database, "lock_version" => previous_lock_value }
+        param_types = { "id" => :INT64, "lock_version" => :INT64 }
+      end
+
       # 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 `#{self.class.primary_key}` = @id AND `#{locking_column}` = @lock_version"
-      params = { "id" => id_in_database, "lock_version" => previous_lock_value }
-      param_types = { "id" => :INT64, "lock_version" => :INT64 }
+              "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/relation.rb

@@ -0,0 +1,21 @@
+# Copyright 2022 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.
+
+module ActiveRecord
+  module CpkExtension
+    def cpk_subquery stmt
+      return super unless spanner_adapter?
+      # The composite_primary_key gem will by default generate WHERE clauses using an IN clause with a multi-column
+      # sub select, e.g.: SELECT * FROM my_table WHERE (id1, id2) IN (SELECT id1, id2 FROM my_table WHERE ...).
+      # This is not supported in Cloud Spanner. Instead, composite_primary_key should generate an EXISTS clause.
+      cpk_exists_subquery stmt
+    end
+  end
+
+  class Relation
+    prepend CpkExtension
+  end
+end

data/lib/activerecord_spanner_adapter/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-spanner-adapter
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Google LLC
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-06-24 00:00:00.000000000 Z
+date: 2022-08-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: google-cloud-spanner
@@ -387,6 +387,16 @@ files:
 - examples/snippets/hints/db/seeds.rb
 - examples/snippets/hints/models/album.rb
 - examples/snippets/hints/models/singer.rb
+- examples/snippets/interleaved-tables/README.md
+- examples/snippets/interleaved-tables/Rakefile
+- examples/snippets/interleaved-tables/application.rb
+- examples/snippets/interleaved-tables/config/database.yml
+- examples/snippets/interleaved-tables/db/migrate/01_create_tables.rb
+- examples/snippets/interleaved-tables/db/schema.rb
+- examples/snippets/interleaved-tables/db/seeds.rb
+- examples/snippets/interleaved-tables/models/album.rb
+- examples/snippets/interleaved-tables/models/singer.rb
+- examples/snippets/interleaved-tables/models/track.rb
 - examples/snippets/migrations/README.md
 - examples/snippets/migrations/Rakefile
 - examples/snippets/migrations/application.rb
@@ -492,6 +502,7 @@ files:
 - lib/activerecord_spanner_adapter/index/column.rb
 - lib/activerecord_spanner_adapter/information_schema.rb
 - lib/activerecord_spanner_adapter/primary_key.rb
+- lib/activerecord_spanner_adapter/relation.rb
 - lib/activerecord_spanner_adapter/table.rb
 - lib/activerecord_spanner_adapter/table/column.rb
 - lib/activerecord_spanner_adapter/transaction.rb