activerecord-spanner-adapter 1.5.1 → 1.6.0

data/acceptance/cases/transactions/read_write_transactions_test.rb

@@ -11,6 +11,7 @@ require "models/author"
 require "models/post"
 require "models/comment"
 require "models/organization"
+require "models/table_with_sequence"
 
 module ActiveRecord
   module Transactions
@@ -243,6 +244,29 @@ module ActiveRecord
 
         assert_equal 0, Comment.count
       end
+
+      def test_create_record_with_sequence
+        record = TableWithSequence.create name: "Some name", age: 40
+        assert record.id, "ID should be generated and returned by the database"
+        assert record.id > 0, "ID should be positive" unless ENV["SPANNER_EMULATOR_HOST"]
+      end
+
+      def test_create_record_with_sequence_in_transaction
+        record = TableWithSequence.transaction do
+          TableWithSequence.create name: "Some name", age: 40
+        end
+        assert record.id, "ID should be generated and returned by the database"
+        assert record.id > 0, "ID should be positive" unless ENV["SPANNER_EMULATOR_HOST"]
+      end
+
+      def test_create_record_with_sequence_using_mutations
+        err = assert_raises ActiveRecord::StatementInvalid do
+          TableWithSequence.transaction isolation: :buffered_mutations do
+            TableWithSequence.create name: "Foo", age: 50
+          end
+        end
+        assert_equal "Mutations cannot be used to create records that use a sequence to generate the primary key. TableWithSequence uses test_sequence.", err.message
+      end
     end
   end
 end

data/acceptance/models/table_with_sequence.rb

@@ -0,0 +1,10 @@
+# Copyright 2023 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 TableWithSequence < ActiveRecord::Base
+  self.table_name = :table_with_sequence
+  self.sequence_name = :test_sequence
+end

data/acceptance/schema/schema.rb

@@ -6,6 +6,11 @@
 
 # frozen_string_literal: true
 
+
+def is_7_1_or_higher?
+  ActiveRecord::gem_version >= Gem::Version.create('7.1.0')
+end
+
 def create_tables_in_test_schema
   ActiveRecord::Schema.define(version: 1) do
     ActiveRecord::Base.connection.ddl_batch do
@@ -122,29 +127,70 @@ def create_tables_in_test_schema
         t.virtual :full_name, type: :string, as: "COALESCE(first_name || ' ', '') || last_name", stored: true
       end
 
-      create_table :albums, id: false do |t|
-        t.interleave_in :singers
-        t.primary_key :albumid
-        # `singerid` is part of the primary key in the table definition, but it is not visible to ActiveRecord as part of
-        # the primary key, to prevent ActiveRecord from considering this to be an entity with a composite primary key.
-        t.parent_key :singerid
-        t.string :title
-        t.integer :lock_version
-      end
-
-      create_table :tracks, id: false do |t|
-        # `:cascade` causes all tracks that belong to an album to automatically be deleted when an album is deleted.
-        t.interleave_in :albums, :cascade
-        t.primary_key :trackid
-        t.parent_key :singerid
-        t.parent_key :albumid
-        t.string :title
-        t.numeric :duration
-        t.integer :lock_version
+      if is_7_1_or_higher?
+        create_table :albums, primary_key: [:singerid, :albumid] do |t|
+          t.interleave_in :singers
+          t.integer :singerid, null: false
+          t.integer :albumid, null: false
+          t.string :title
+          t.integer :lock_version
+        end
+      else
+        create_table :albums, id: false do |t|
+          t.interleave_in :singers
+          t.primary_key :albumid
+          # `singerid` is part of the primary key in the table definition, but it is not visible to ActiveRecord as part of
+          # the primary key, to prevent ActiveRecord from considering this to be an entity with a composite primary key.
+          t.parent_key :singerid
+          t.string :title
+          t.integer :lock_version
+        end
+      end
+
+      if is_7_1_or_higher?
+        create_table :tracks, primary_key: [:singerid, :albumid, :trackid] do |t|
+          # `:cascade` causes all tracks that belong to an album to automatically be deleted when an album is deleted.
+          t.interleave_in :albums, :cascade
+          t.integer :singerid, null: false
+          t.integer :albumid, null: false
+          t.integer :trackid, null: false
+          t.string :title
+          t.numeric :duration
+          t.integer :lock_version
+        end
+      else
+        create_table :tracks, id: false do |t|
+          # `:cascade` causes all tracks that belong to an album to automatically be deleted when an album is deleted.
+          t.interleave_in :albums, :cascade
+          t.primary_key :trackid
+          t.parent_key :singerid
+          t.parent_key :albumid
+          t.string :title
+          t.numeric :duration
+          t.integer :lock_version
+        end
       end
 
       add_index :tracks, [:singerid, :albumid, :title], interleave_in: :albums, null_filtered: true, unique: false
 
+      if ENV["SPANNER_EMULATOR_HOST"]
+        create_table :table_with_sequence, id: false do |t|
+          # The emulator does not yet support bit-reversed sequences, so we emulate a sequence value
+          # by hashing a UUID instead.
+          t.integer :id, primary_key: true, null: false, default: -> { "FARM_FINGERPRINT(GENERATE_UUID())" }
+          t.string :name, null: false
+          t.integer :age, null: false
+        end
+      else
+        connection.execute "create sequence test_sequence OPTIONS (sequence_kind = 'bit_reversed_positive')"
+
+        create_table :table_with_sequence, id: false do |t|
+          t.integer :id, primary_key: true, null: false, default: -> { "GET_NEXT_SEQUENCE_VALUE(SEQUENCE test_sequence)" }
+          t.string :name, null: false
+          t.integer :age, null: false
+        end
+      end
+
     end
   end
 end

data/acceptance/test_helper.rb

@@ -15,7 +15,7 @@ require "active_support/testing/stream"
 require "activerecord-spanner-adapter"
 require "active_record/connection_adapters/spanner_adapter"
 require "securerandom"
-require "composite_primary_keys"
+require "composite_primary_keys" if ActiveRecord::gem_version < Gem::Version.create('7.1.0')
 
 # rubocop:disable Style/GlobalVars
 

data/activerecord-spanner-adapter.gemspec

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

data/examples/snippets/bit-reversed-sequence/README.md

@@ -0,0 +1,103 @@
+# Sample - Bit-reversed Sequence
+
+This example shows how to use a bit-reversed sequence to generate the primary key of a model.
+
+See https://cloud.google.com/spanner/docs/primary-key-default-value#bit-reversed-sequence for more information
+about bit-reversed sequences in Cloud Spanner.
+
+## Creating Tables with Bit-Reversed Sequences in ActiveRecord
+You can create bit-reversed sequences using migrations in ActiveRecord by executing a SQL statement using the underlying
+connection.
+
+```ruby
+connection.execute "create sequence singer_sequence OPTIONS (sequence_kind = 'bit_reversed_positive')"
+```
+
+The sequence can be used to generate a default value for the primary key column of a table:
+
+```ruby
+create_table :singers, id: false do |t|
+  t.integer :singerid, primary_key: true, null: false, default: -> { "GET_NEXT_SEQUENCE_VALUE(SEQUENCE singer_sequence)" }
+  t.string :first_name
+  t.string :last_name
+end
+```
+
+## Example Data Model
+This example uses the following table schema:
+
+```sql
+CREATE SEQUENCE singer_sequence (OPTIONS sequence_kind="bit_reversed_positive")
+
+CREATE TABLE singers (
+    singerid INT64 NOT NULL DEFAULT GET_NEXT_SEQUENCE_VALUE(SEQUENCE singer_sequence),
+    first_name STRING(MAX),
+    last_name STRING(MAX)
+) PRIMARY KEY (singerid);
+
+CREATE TABLE albums (
+    singerid INT64 NOT NULL,
+    albumid INT64 NOT NULL,
+    title STRING(MAX)
+) PRIMARY KEY (singerid, albumid), INTERLEAVE IN PARENT singers;
+```
+
+This schema can be created in ActiveRecord 7.1 and later as follows:
+
+```ruby
+# Execute the entire migration as one DDL batch.
+connection.ddl_batch do
+  connection.execute "create sequence singer_sequence OPTIONS (sequence_kind = 'bit_reversed_positive')"
+  
+  # Explicitly define the primary key.
+  create_table :singers, id: false, primary_key: :singerid do |t|
+    t.integer :singerid, primary_key: true, null: false, default: -> { "GET_NEXT_SEQUENCE_VALUE(SEQUENCE singer_sequence)" } 
+    t.string :first_name
+    t.string :last_name
+  end
+
+  create_table :albums, primary_key: [:singerid, :albumid], id: false do |t|
+    # Interleave the `albums` table in the parent table `singers`.
+    t.interleave_in :singers
+    t.integer :singerid
+    t.integer :albumid
+    t.string :title
+  end
+end
+```
+
+## Models for Tables with a Sequence
+The models for tables that use a sequence to generate the primary key must include the sequence name. This instructs
+the Cloud Spanner ActiveRecord provider to let the database generate the primary key value, instead of generating one
+in memory.
+
+### Example Models
+
+```ruby
+class Singer < ActiveRecord::Base
+  self.sequence_name = :singer_sequence
+  
+  # `albums` is defined as INTERLEAVE IN PARENT `singers`.
+  # The primary key of `albums` is (`singerid`, `albumid`).
+  has_many :albums, foreign_key: :singerid
+end
+
+class Album < ActiveRecord::Base
+  # `albums` is defined as INTERLEAVE IN PARENT `singers`.
+  # The primary key of `singers` is `singerid`.
+  belongs_to :singer, foreign_key: :singerid
+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 following commands:
+
+```bash
+export AR_VERSION="~> 7.1.2"
+bundle install
+bundle exec rake run
+```

data/examples/snippets/bit-reversed-sequence/Rakefile

@@ -0,0 +1,13 @@
+# Copyright 2023 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 bit-reversed sequences."
+task :run do
+  Dir.chdir("..") { sh "bundle exec rake run[bit-reversed-sequence]" }
+end

data/examples/snippets/bit-reversed-sequence/application.rb

@@ -0,0 +1,68 @@
+# Copyright 2023 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"
+
+class Application
+  def self.run
+    # Create a new singer.
+    singer = create_new_singer
+
+    # Create a new album.
+    album = create_new_album singer
+
+    # Verify that the album exists.
+    find_album singer.singerid, album.albumid
+
+    # List all singers, albums and tracks.
+    list_singers_albums
+
+    puts ""
+    puts "Press any key to end the application"
+    STDIN.getch
+  end
+
+  def self.find_album singerid, albumid
+    album = Album.find [singerid, albumid]
+    puts "Found album: #{album.title}"
+  end
+
+  def self.list_singers_albums
+    puts ""
+    puts "Listing all singers with corresponding albums"
+    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}"
+      end
+    end
+  end
+
+  def self.create_new_singer
+    # Create a new singer. The singerid is generated by the bit-reversed sequence in the database and returned.
+    puts ""
+    singer = Singer.create first_name: "Melissa", last_name: "Garcia"
+    puts "Created a new singer '#{singer.first_name} #{singer.last_name}' with id #{singer.singerid}"
+
+    singer
+  end
+
+  def self.create_new_album singer
+    # Create a new album.
+    puts ""
+    puts "Creating a new album for #{singer.first_name} #{singer.last_name}"
+    # The albumid is not generated by a sequence in the database.
+    album = singer.albums.build albumid: 1, title: "New Title"
+    album.save!
+
+    album
+  end
+end
+
+Application.run

data/examples/snippets/bit-reversed-sequence/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/bit-reversed-sequence/db/migrate/01_create_tables.rb

@@ -0,0 +1,33 @@
+# Copyright 2023 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[7.1]
+  def change
+    # Execute the entire migration as one DDL batch.
+    connection.ddl_batch do
+      # TODO: Uncomment when bit-reversed sequences are supported in the emulator.
+      # connection.execute "create sequence singer_sequence OPTIONS (sequence_kind = 'bit_reversed_positive')"
+
+      # Explicitly define the primary key.
+      create_table :singers, id: false, primary_key: :singerid do |t|
+        # TODO: Uncomment when bit-reversed sequences are supported in the emulator.
+        # t.integer :singerid, primary_key: true, null: false,
+        #           default: -> { "GET_NEXT_SEQUENCE_VALUE(SEQUENCE singer_sequence)" }
+        t.integer :singerid, primary_key: true, null: false, default: -> { "FARM_FINGERPRINT(GENERATE_UUID())" }
+        t.string :first_name
+        t.string :last_name
+      end
+
+      create_table :albums, primary_key: [:singerid, :albumid], id: false do |t|
+        # Interleave the `albums` table in the parent table `singers`.
+        t.interleave_in :singers
+        t.integer :singerid, null: false
+        t.integer :albumid, null: false
+        t.string :title
+      end
+    end
+  end
+end

data/examples/snippets/bit-reversed-sequence/db/schema.rb

@@ -0,0 +1,31 @@
+# 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[7.1].define(version: 1) do
+  connection.start_batch_ddl
+
+  create_table "albums", primary_key: ["singerid", "albumid"], force: :cascade do |t|
+    t.integer "singerid", limit: 8, null: false
+    t.integer "albumid", limit: 8, null: false
+    t.string "title"
+  end
+
+  create_table "singers", primary_key: "singerid", default: -> { "FARM_FINGERPRINT(GENERATE_UUID())" }, force: :cascade do |t|
+    t.string "first_name"
+    t.string "last_name"
+  end
+
+  connection.run_batch
+rescue
+  abort_batch
+  raise
+end

data/examples/snippets/bit-reversed-sequence/db/seeds.rb

@@ -0,0 +1,31 @@
+# Copyright 2023 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"
+
+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]
+
+# Note: We do not use mutations to insert these rows, because letting the database generate the primary key means that
+# we rely on a `THEN RETURN id` clause in the insert statement. This is only supported for DML statements, and not for
+# mutations.
+ActiveRecord::Base.transaction 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
+end

data/examples/snippets/bit-reversed-sequence/models/album.rb

@@ -0,0 +1,11 @@
+# Copyright 2023 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
+  # `albums` is defined as INTERLEAVE IN PARENT `singers`.
+  # The primary key of `singers` is `singerid`.
+  belongs_to :singer, foreign_key: :singerid
+end

data/examples/snippets/bit-reversed-sequence/models/singer.rb

@@ -0,0 +1,15 @@
+# Copyright 2023 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
+  # Set the sequence name so the ActiveRecord provider knows that it should let the database generate the primary key
+  # value and return it using a `THEN RETURN id` clause.
+  self.sequence_name = :singer_sequence
+
+  # `albums` is defined as INTERLEAVE IN PARENT `singers`.
+  # The primary key of `albums` is (`singerid`, `albumid`).
+  has_many :albums, foreign_key: :singerid
+end

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

@@ -1,9 +1,10 @@
 # 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.
+__NOTE__: This example requires Rails 7.1 or later.
+
+This example shows how to use interleaved tables with the Spanner ActiveRecord adapter in Rails 7.1 and later.
+Interleaved tables use composite primary keys. This is only supported by Rails 7.1 and later. For older versions,
+you need to use the third-party gem `composite_primary_key` (https://github.com/composite-primary-keys/composite_primary_keys).
 
 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.
@@ -13,8 +14,6 @@ You can create interleaved tables using migrations in ActiveRecord by using the
 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
@@ -32,62 +31,55 @@ CREATE TABLE singers (
 ) PRIMARY KEY (singerid);
 
 CREATE TABLE albums (
-    albumid INT64 NOT NULL,
     singerid INT64 NOT NULL,
+    albumid 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,
+    trackid 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:
+This schema can be created in ActiveRecord 7.1 and later 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
+# Execute the entire migration as one DDL batch.
+connection.ddl_batch do
+  # Explicitly define the primary key.
+  create_table :singers, id: false, primary_key: :singerid do |t|
+    t.integer :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 :albums, primary_key: [:singerid, :albumid], id: false do |t|
+    # Interleave the `albums` table in the parent table `singers`.
+    t.interleave_in :singers
+    t.integer :singerid
+    t.integer :albumid
+    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
+  create_table :tracks, primary_key: [:singerid, :albumid, :trackid], 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
+    t.integer :singerid
+    t.integer :albumid
+    t.integer :trackid
+    t.string :title
+    t.numeric :duration
+  end
 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
+An interleaved table parent/child relationship can 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.
 
@@ -108,7 +100,7 @@ class Singer < ActiveRecord::Base
   has_many :albums, foreign_key: :singerid
 
   # `tracks` is defined as INTERLEAVE IN PARENT `albums`.
-  # The primary key of `tracks` is (`singerid`, `albumid`, `trackid`).
+  # 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`).
@@ -116,24 +108,21 @@ class Singer < ActiveRecord::Base
 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]
+  # Rails 7.1 requires using query_constraints to define a composite foreign key.
+  has_many :tracks, query_constraints: [: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` is defined as INTERLEAVE IN PARENT `albums`.
+  # The primary key of `albums` is (`singerid`, `albumid`).
+  # Rails 7.1 requires a composite primary key in a belongs_to relationship to be specified as query_constraints.
+  belongs_to :album, query_constraints: [: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
@@ -157,8 +146,10 @@ end
 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
+Run the application with the following commands:
 
 ```bash
+export AR_VERSION="~> 7.1.2"
+bundle install
 bundle exec rake run
 ```