diff --git a/acceptance/cases/models/preventing_writes_test.rb b/acceptance/cases/models/preventing_writes_test.rb new file mode 100644 index 00000000..93d8c376 --- /dev/null +++ b/acceptance/cases/models/preventing_writes_test.rb @@ -0,0 +1,91 @@ +# Copyright 2026 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 + +require "test_helper" +require "models/author" + +module ActiveRecord + module Model + class PreventingWritesTest < SpannerAdapter::TestCase + include SpannerAdapter::Associations::TestHelper + + def setup + super + @author = Author.create! name: "Original" + end + + def teardown + super + Author.destroy_all + end + + def test_reads_succeed_while_preventing_writes + ActiveRecord::Base.while_preventing_writes do + found = Author.find @author.id + assert_equal "Original", found.name + + hinted = Author.optimizer_hints("statement_hint: @{USE_ADDITIONAL_PARALLELISM=true}").find @author.id + assert_equal "Original", hinted.name + + ActiveRecord::Base.transaction isolation: :read_only do + assert_equal "Original", Author.find(@author.id).name + end + end + end + + def test_mutations_and_dml_and_ddl_raise_read_only_error_without_modifying_data + ActiveRecord::Base.while_preventing_writes do + assert_raises ActiveRecord::ReadOnlyError do + Author.create! name: "Created" + end + + assert_raises ActiveRecord::ReadOnlyError do + @author.update! name: "Updated" + end + + assert_raises ActiveRecord::ReadOnlyError do + @author.destroy! + end + + assert_raises ActiveRecord::ReadOnlyError do + Author.delete_all + end + + assert_raises ActiveRecord::ReadOnlyError do + Author.where(id: @author.id).update_all name: "DmlUpdated" + end + + assert_raises ActiveRecord::ReadOnlyError do + Author + .optimizer_hints("statement_hint: @{USE_ADDITIONAL_PARALLELISM=true}") + .where(id: @author.id) + .update_all name: "HintedUpdated" + end + + assert_raises ActiveRecord::ReadOnlyError do + ActiveRecord::Base.connection.truncate "authors" + end + + assert_raises ActiveRecord::ReadOnlyError do + ActiveRecord::Base.connection.execute_ddl "CREATE TABLE `blocked_table` (`id` INT64) PRIMARY KEY (`id`)" + end + + assert_raises ActiveRecord::ReadOnlyError do + ActiveRecord::Base.transaction isolation: :pdml do + Author.where(id: @author.id).update_all name: "PdmlUpdated" + end + end + end + + assert_equal [@author.id], Author.where(id: @author.id).pluck(:id) + assert_equal "Original", Author.find(@author.id).name + refute ActiveRecord::Base.connection.table_exists?("blocked_table") + end + end + end +end diff --git a/lib/active_record/connection_adapters/spanner/database_statements.rb b/lib/active_record/connection_adapters/spanner/database_statements.rb index 622fd470..60bf4f74 100644 --- a/lib/active_record/connection_adapters/spanner/database_statements.rb +++ b/lib/active_record/connection_adapters/spanner/database_statements.rb @@ -43,16 +43,13 @@ def internal_exec_query sql, name = "SQL", binds = [], prepare: false, async: fa def internal_execute sql, name = "SQL", binds = [], prepare: false, async: false, allow_retry: false # rubocop:disable Lint/UnusedMethodArgument - statement_type = sql_statement_type sql # Call `transform` to invoke any query transformers that might have been registered. sql = transform sql - append_request_tag_from_query_logs sql, binds - - if preventing_writes? && [:dml, :ddl].include?(statement_type) - raise ActiveRecord::ReadOnlyError( - "Write query attempted while in readonly mode: #{sql}" - ) + statement_type = sql_statement_type sql + if preventing_writes? && (statement_type != :dql || write_query?(sql)) + ensure_writes_allowed sql end + append_request_tag_from_query_logs sql, binds if statement_type == :ddl execute_ddl sql @@ -162,6 +159,7 @@ def _has_pk_binding pk, binds end def exec_mutation mutation + ensure_writes_allowed "MUTATION (#{mutation.operation})" @connection.current_transaction.buffer mutation end @@ -202,6 +200,7 @@ def exec_update sql, name = "SQL", binds = [] alias exec_delete exec_update def truncate table_name, name = nil + ensure_writes_allowed "TRUNCATE #{Array(table_name).join(', ')}" Array(table_name).each do |t| log "TRUNCATE #{t}", name do @connection.truncate t @@ -210,10 +209,13 @@ def truncate table_name, name = nil end def write_query? sql - sql_statement_type(sql) == :dml + !READ_QUERY.match? sql + rescue ArgumentError + !READ_QUERY.match? sql.b end def execute_ddl statements + ensure_writes_allowed Array(statements).join("; ") log "MIGRATION", "SCHEMA" do ActiveSupport::Dependencies.interlock.permit_concurrent_loads do @connection.execute_ddl statements @@ -283,6 +285,8 @@ def transaction_isolation_levels end def begin_db_transaction + ensure_writes_allowed "BEGIN PDML" if @connection.isolation_level == :pdml + log "BEGIN" do opts = @_spanner_begin_transaction_options || {} @connection.begin_transaction nil, **opts @@ -311,16 +315,8 @@ def begin_isolated_db_transaction isolation opts = @_spanner_begin_transaction_options || {} # If isolation level is specified in the options, use that instead of the default isolation level. isolation_option = opts[:isolation] || isolation - if isolation_option.is_a? Hash - raise "Unsupported isolation level: #{isolation_option}" unless - isolation_option[:timestamp] || isolation_option[:staleness] || isolation_option[:strong] - raise "Only one option is supported. It must be one of `timestamp`, `staleness` or `strong`." \ - if isolation_option.count != 1 - else - raise "Unsupported isolation level: #{isolation_option}" unless - [:serializable, :repeatable_read, :read_only, :buffered_mutations, :pdml, - :fallback_to_pdml].include? isolation_option - end + validate_isolation_level! isolation_option + ensure_writes_allowed "BEGIN PDML" if isolation_option == :pdml log "BEGIN #{isolation_option}" do @connection.begin_transaction isolation_option, **opts.except(:isolation) @@ -328,6 +324,8 @@ def begin_isolated_db_transaction isolation end def commit_db_transaction + ensure_writes_allowed "COMMIT" if preventing_writes? && @connection.current_transaction&.mutations? + log "COMMIT" do @connection.commit_transaction end @@ -339,8 +337,29 @@ def rollback_db_transaction end end + def ensure_writes_allowed sql # :nodoc: + return unless preventing_writes? + + raise ActiveRecord::ReadOnlyError, + "Write query attempted while in readonly mode: #{sql}" + end + private + def validate_isolation_level! isolation_option + if isolation_option.is_a? Hash + unless isolation_option[:timestamp] || isolation_option[:staleness] || isolation_option[:strong] + raise "Unsupported isolation level: #{isolation_option}" + end + if isolation_option.count != 1 + raise "Only one option is supported. It must be one of `timestamp`, `staleness` or `strong`." + end + elsif ![:serializable, :repeatable_read, :read_only, :buffered_mutations, :pdml, + :fallback_to_pdml].include?(isolation_option) + raise "Unsupported isolation level: #{isolation_option}" + end + end + # Translates binds to Spanner types and params. def to_types_and_params binds # rubocop:disable Metrics/AbcSize return [{}, {}] if binds.empty? @@ -417,27 +436,45 @@ def create_delete_all_mutation arel ) end - COMMENT_REGEX = %r{(?:--.*\n)*|/\*(?:[^*]|\*[^/])*\*/}m \ + COMMENT_REGEX = %r{(?:--.*\n)|/\*(?>[^*]++|\*(?!/))*\*/} \ unless defined? ActiveRecord::ConnectionAdapters::AbstractAdapter::COMMENT_REGEX COMMENT_REGEX = ActiveRecord::ConnectionAdapters::AbstractAdapter::COMMENT_REGEX \ if defined? ActiveRecord::ConnectionAdapters::AbstractAdapter::COMMENT_REGEX + HASH_COMMENT_REGEX = /#.*\n/ + private_constant :HASH_COMMENT_REGEX + + STATEMENT_HINT_REGEX = %r(@\{(?>[^}'"]++|'(?>\\.|[^'\\])*'|"(?>\\.|[^"\\])*")*\}) + private_constant :STATEMENT_HINT_REGEX + private_class_method def self.build_sql_statement_regexp *parts # :nodoc: - parts = parts.map { |part| /#{part}/i } - /\A(?:[(\s]|#{COMMENT_REGEX})*#{Regexp.union(*parts)}/ + parts = parts.map { |part| /#{part}\b/i } + /\A(?>(?:[(\s]|#{COMMENT_REGEX}|#{HASH_COMMENT_REGEX}|#{STATEMENT_HINT_REGEX})*)#{Regexp.union(*parts)}/ end - DDL_REGX = build_sql_statement_regexp(:create, :alter, :drop).freeze + DDL_REGX = build_sql_statement_regexp(:create, :alter, :drop, :rename, :grant, :revoke, :analyze).freeze private_constant :DDL_REGX DML_REGX = build_sql_statement_regexp(:insert, :delete, :update).freeze private_constant :DML_REGX + # Mirrors ActiveRecord's DEFAULT_READ_QUERY so read-only transactions (BEGIN/COMMIT/ROLLBACK/SAVEPOINT/RELEASE) + # and read queries (including Spanner FROM/GRAPH/SHOW syntax) are permitted in read-only mode. + READ_QUERY = build_sql_statement_regexp( + :begin, :commit, :explain, :from, :graph, :release, :rollback, :savepoint, :select, :show, :with + ).freeze + private_constant :READ_QUERY + def sql_statement_type sql - case sql - when DDL_REGX + match_statement_type sql + rescue ArgumentError + match_statement_type sql.b + end + + def match_statement_type sql + if DDL_REGX.match? sql :ddl - when DML_REGX + elsif DML_REGX.match? sql :dml else :dql diff --git a/lib/active_record/connection_adapters/spanner_adapter.rb b/lib/active_record/connection_adapters/spanner_adapter.rb index 87c6ef9e..e542e6fa 100644 --- a/lib/active_record/connection_adapters/spanner_adapter.rb +++ b/lib/active_record/connection_adapters/spanner_adapter.rb @@ -139,10 +139,34 @@ def spanner_schema_cache end # Spanner Connection API - delegate :dml_batch, :dml_batch?, :start_batch_dml, - :ddl_batch, :ddl_batch?, :start_batch_ddl, :abort_batch, :run_batch, + delegate :dml_batch?, :ddl_batch?, :abort_batch, :isolation_level, :isolation_level=, to: :@connection + def dml_batch(&) + ensure_writes_allowed "DML BATCH" + @connection.dml_batch(&) + end + + def start_batch_dml + ensure_writes_allowed "START BATCH DML" + @connection.start_batch_dml + end + + def ddl_batch(&) + ensure_writes_allowed "DDL BATCH" + @connection.ddl_batch(&) + end + + def start_batch_ddl + ensure_writes_allowed "START BATCH DDL" + @connection.start_batch_ddl + end + + def run_batch + ensure_writes_allowed "RUN BATCH" + @connection.run_batch + end + def current_spanner_transaction @connection.current_transaction end diff --git a/lib/activerecord_spanner_adapter/base.rb b/lib/activerecord_spanner_adapter/base.rb index 8f5e7829..4200fbc6 100644 --- a/lib/activerecord_spanner_adapter/base.rb +++ b/lib/activerecord_spanner_adapter/base.rb @@ -84,16 +84,18 @@ def self._insert_record *args return super end - # Mutations cannot be used in combination with an auto-generated primary key, - # as mutations do not support a THEN RETURN clause. - if buffered_mutations? \ - && has_auto_generated_primary_key? \ - && !_has_all_primary_key_values?(primary_key, values) \ - && !connection.use_client_side_id_for_mutations - raise StatementInvalid, "Mutations cannot be used to create records that use an auto-generated primary key." - end + if buffered_mutations? + connection.ensure_writes_allowed "MUTATION (insert)" + # Mutations cannot be used in combination with an auto-generated primary key, + # as mutations do not support a THEN RETURN clause. + if has_auto_generated_primary_key? \ + && !_has_all_primary_key_values?(primary_key, values) \ + && !connection.use_client_side_id_for_mutations + raise StatementInvalid, "Mutations cannot be used to create records that use an auto-generated primary key." + end - return _buffer_record values, :insert, returning if buffered_mutations? + return _buffer_record values, :insert, returning + end _insert_record_dml values, returning end @@ -199,6 +201,8 @@ def self.upsert_all attributes, returning: nil, unique_by: nil, **kwargs end def self._buffer_record values, method, returning + connection.ensure_writes_allowed "MUTATION (#{method})" + primary_key_value = if primary_key.is_a? Array _set_composite_primary_key_values primary_key, values, true @@ -217,7 +221,7 @@ def self._buffer_record values, method, returning mutation = Google::Cloud::Spanner::V1::Mutation.new( "#{method}": write ) - connection.current_spanner_transaction.buffer mutation + connection.exec_mutation mutation _convert_primary_key primary_key_value, returning end @@ -350,6 +354,7 @@ def self._create_grpc_values_for_insert metadata, values def _update_row attribute_names, attempted_action = "update" return super unless self.class.buffered_mutations? + self.class.connection.ensure_writes_allowed "MUTATION (update)" if locking_enabled? _execute_version_check attempted_action attribute_names << self.class.locking_column @@ -367,7 +372,7 @@ def _update_row attribute_names, attempted_action = "update" values: [grpc_values.list_value] ) ) - self.class.connection.current_spanner_transaction.buffer mutation + self.class.connection.exec_mutation mutation 1 # Affected rows end @@ -407,6 +412,8 @@ def destroy_row def _delete_row return super unless self.class.buffered_mutations? + + self.class.connection.ensure_writes_allowed "MUTATION (delete)" if locking_enabled? _execute_version_check "destroy" end @@ -425,7 +432,7 @@ def _delete_row key_set: { keys: [list_value] } ) ) - self.class.connection.current_spanner_transaction.buffer mutation + self.class.connection.exec_mutation mutation 1 # Affected rows end diff --git a/lib/activerecord_spanner_adapter/transaction.rb b/lib/activerecord_spanner_adapter/transaction.rb index 34986ef2..5e82a9ac 100644 --- a/lib/activerecord_spanner_adapter/transaction.rb +++ b/lib/activerecord_spanner_adapter/transaction.rb @@ -37,6 +37,10 @@ def buffer mutation @mutations << mutation end + def mutations? + !@mutations.empty? + end + # Begins the transaction. # # Read-only and PDML transactions are started by executing a BeginTransaction RPC. diff --git a/test/activerecord_spanner_adapter/database_statements_test.rb b/test/activerecord_spanner_adapter/database_statements_test.rb index 3fd99a12..594e4618 100644 --- a/test/activerecord_spanner_adapter/database_statements_test.rb +++ b/test/activerecord_spanner_adapter/database_statements_test.rb @@ -140,4 +140,92 @@ def test_append_request_tag_ignores_unmatched_sql assert_empty binds end + + def test_write_query_allows_read_statements_and_hinted_reads + [ + "SELECT * FROM users", + " @{USE_ADDITIONAL_PARALLELISM=true}SELECT * FROM users", + "@{OPTIMIZER_STATISTICS_PACKAGE='a}b'} SELECT * FROM users", + "/* comment */ -- line\n # hash comment\n @{FORCE_INDEX=idx} (SELECT 1)", + "# hash comment\nSELECT * FROM users", + "SELECT 1 /* \xFF */".dup.force_encoding(Encoding::UTF_8), + "WITH cte AS (SELECT 1) SELECT * FROM cte", + "GRAPH FinGraph MATCH (n) RETURN n.id", + "FROM Singers |> SELECT Id", + "SHOW TABLES", + "EXPLAIN SELECT 1", + "BEGIN", + "COMMIT", + "ROLLBACK" + ].each do |sql| + refute @adapter.write_query?(sql), "Expected write_query? to be false for: #{sql}" + end + end + + def test_write_query_detects_dml_ddl_hinted_writes_and_unknown_writes + [ + "INSERT INTO users (id) VALUES (1)", + "UPDATE users SET name = 'a'", + "DELETE FROM users WHERE id = 1", + "# hash comment\nUPDATE users SET name = 'a'", + " @{USE_ADDITIONAL_PARALLELISM=true}UPDATE users SET name = 'a'", + "@{OPTIMIZER_STATISTICS_PACKAGE='a}b'} DELETE FROM users WHERE id = 1", + "/* tag */ @{a=1} (INSERT INTO users (id) VALUES (1))", + "UPDATE users SET name = '\xFF'".dup.force_encoding(Encoding::UTF_8), + "CREATE TABLE users (id INT64) PRIMARY KEY (id)", + "ALTER TABLE users ADD COLUMN name STRING(MAX)", + "DROP TABLE users", + "RENAME TABLE users TO people", + "GRANT SELECT ON TABLE users TO ROLE reader", + "REVOKE SELECT ON TABLE users FROM ROLE reader", + "ANALYZE", + "TRUNCATE TABLE users", + "UPDATE_CUSTOM SELECT 1" + ].each do |sql| + assert @adapter.write_query?(sql), "Expected write_query? to be true for: #{sql}" + end + end + + def test_sql_statement_type_with_statement_hints_and_ddl_keywords + assert_equal :dql, @adapter.send(:sql_statement_type, " @{USE_ADDITIONAL_PARALLELISM=true}SELECT * FROM users") + assert_equal :dql, @adapter.send(:sql_statement_type, "# hash comment\nSELECT * FROM users") + assert_equal :dml, @adapter.send(:sql_statement_type, " @{USE_ADDITIONAL_PARALLELISM=true}UPDATE users SET name = 'a'") + assert_equal :dml, @adapter.send(:sql_statement_type, "# hash comment\nUPDATE users SET name = 'a'") + assert_equal :dml, @adapter.send(:sql_statement_type, "@{a='}'} DELETE FROM users WHERE id = 1") + assert_equal :dml, @adapter.send(:sql_statement_type, "/* c */ @{a=1} INSERT INTO users (id) VALUES (1)") + assert_equal :dml, @adapter.send(:sql_statement_type, "UPDATE users SET name = '\xFF'".dup.force_encoding(Encoding::UTF_8)) + assert_equal :ddl, @adapter.send(:sql_statement_type, "CREATE TABLE users (id INT64) PRIMARY KEY (id)") + assert_equal :ddl, @adapter.send(:sql_statement_type, "RENAME TABLE users TO people") + assert_equal :ddl, @adapter.send(:sql_statement_type, "GRANT SELECT ON TABLE users TO ROLE reader") + assert_equal :ddl, @adapter.send(:sql_statement_type, "REVOKE SELECT ON TABLE users FROM ROLE reader") + assert_equal :ddl, @adapter.send(:sql_statement_type, "ANALYZE") + end + + def test_internal_execute_raises_read_only_error_when_preventing_writes + @adapter.stub :preventing_writes?, true do + [ + "UPDATE users SET name = 'a' WHERE id = 1", + "/*request_tag:true,write_tag*/ @{USE_ADDITIONAL_PARALLELISM=true}UPDATE users SET name = 'a' WHERE id = 1", + "CREATE TABLE users (id INT64) PRIMARY KEY (id)" + ].each do |sql| + binds = [] + error = assert_raises ActiveRecord::ReadOnlyError do + @adapter.send :internal_execute, sql, "SQL", binds + end + assert_match(/Write query attempted while in readonly mode/, error.message) + assert_empty binds + end + end + end + + def test_replica_config_enables_preventing_writes + replica_adapter = ActiveRecord::ConnectionAdapters::SpannerAdapter.new( + connection, nil, nil, { project: project_id, instance: instance_id, database: database_id, replica: true } + ) + assert replica_adapter.preventing_writes? + error = assert_raises ActiveRecord::ReadOnlyError do + replica_adapter.execute "UPDATE users SET name = 'a' WHERE id = 1" + end + assert_match(/Write query attempted while in readonly mode/, error.message) + end end diff --git a/test/activerecord_spanner_mock_server/preventing_writes_test.rb b/test/activerecord_spanner_mock_server/preventing_writes_test.rb new file mode 100644 index 00000000..986579c7 --- /dev/null +++ b/test/activerecord_spanner_mock_server/preventing_writes_test.rb @@ -0,0 +1,391 @@ +# Copyright 2026 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 + +require_relative "./base_spanner_mock_server_test" + +module MockServerTests + class ValidatedSinger < ActiveRecord::Base + self.table_name = "singers" + validates :first_name, presence: true + end + + class PreventingWritesTest < BaseSpannerMockServerTest + def test_reads_succeed_while_preventing_writes + sql = "SELECT `singers`.* FROM `singers` WHERE `singers`.`id` = @p1 LIMIT @p2" + @mock.put_statement_result sql, MockServerTests.create_random_singers_result(1) + + hinted_sql = " @{USE_ADDITIONAL_PARALLELISM=true}SELECT `singers`.* FROM `singers` WHERE `singers`.`id` = @p1 LIMIT @p2" + @mock.put_statement_result hinted_sql, MockServerTests.create_random_singers_result(1) + + ActiveRecord::Base.while_preventing_writes do + singer = Singer.find_by id: 1 + refute_nil singer + + hinted_singer = Singer.optimizer_hints("statement_hint: @{USE_ADDITIONAL_PARALLELISM=true}").find_by id: 1 + refute_nil hinted_singer + + ActiveRecord::Base.transaction isolation: :read_only do + assert_equal singer.id, Singer.find_by(id: 1).id + end + + ActiveRecord::Base.transaction isolation: { strong: true } do + assert_equal singer.id, Singer.find_by(id: 1).id + end + + ActiveRecord::Base.transaction do + assert_equal singer.id, Singer.find_by(id: 1).id + end + + with_sql = "WITH s AS (SELECT `singers`.* FROM `singers` WHERE `singers`.`id` = @p1) SELECT * FROM s" + @mock.put_statement_result with_sql, MockServerTests.create_random_singers_result(1) + assert_equal 1, Singer.connection.select_all(with_sql, "WITH", [1]).rows.length + + graph_sql = "GRAPH SingersGraph MATCH (s:Singer) RETURN s.id" + @mock.put_statement_result graph_sql, MockServerTests.create_random_singers_result(1) + assert_equal 1, Singer.connection.select_all(graph_sql).rows.length + + from_sql = "FROM `singers` |> SELECT `id`" + @mock.put_statement_result from_sql, MockServerTests.create_random_singers_result(1) + assert_equal 1, Singer.connection.select_all(from_sql).rows.length + end + end + + def test_buffered_mutation_writes_raise_read_only_error + select_sql = "SELECT `singers`.* FROM `singers` WHERE `singers`.`id` = @p1 LIMIT @p2" + @mock.put_statement_result select_sql, MockServerTests.create_random_singers_result(1) + existing_singer = Singer.find_by id: 1 + @mock.requests.clear + + ActiveRecord::Base.while_preventing_writes do + assert_raises ActiveRecord::ReadOnlyError do + Singer.create! first_name: "Alice", last_name: "Smith" + end + + assert_raises ActiveRecord::ReadOnlyError do + Singer.create first_name: "Alice", last_name: "Smith" + end + + assert_raises ActiveRecord::ReadOnlyError do + Singer.insert!({ id: 10, first_name: "Alice", last_name: "Smith" }) + end + + assert_raises ActiveRecord::ReadOnlyError do + Singer.insert_all! [{ id: 11, first_name: "Alice", last_name: "Smith" }] + end + + assert_raises ActiveRecord::ReadOnlyError do + Singer.upsert({ id: 12, first_name: "Alice", last_name: "Smith" }) + end + + assert_raises ActiveRecord::ReadOnlyError do + Singer.upsert_all [{ id: 13, first_name: "Alice", last_name: "Smith" }] + end + + assert_raises ActiveRecord::ReadOnlyError do + existing_singer.update first_name: "Updated" + end + + assert_raises ActiveRecord::ReadOnlyError do + existing_singer.destroy + end + + assert_raises ActiveRecord::ReadOnlyError do + Singer.delete_all + end + + assert_raises ActiveRecord::ReadOnlyError do + mutation = Google::Cloud::Spanner::V1::Mutation.new( + delete: Google::Cloud::Spanner::V1::Mutation::Delete.new( + table: "singers", + key_set: { all: true } + ) + ) + ActiveRecord::Base.connection.exec_mutation mutation + end + end + + assert_no_write_requests + end + + def test_validation_failure_does_not_raise_read_only_error + select_sql = "SELECT `singers`.* FROM `singers` WHERE `singers`.`id` = @p1 LIMIT @p2" + @mock.put_statement_result select_sql, MockServerTests.create_random_singers_result(1) + validated_singer = ValidatedSinger.find_by id: 1 + @mock.requests.clear + + ActiveRecord::Base.while_preventing_writes do + refute validated_singer.update(first_name: nil) + assert_includes validated_singer.errors[:first_name], "can't be blank" + end + + assert_no_write_requests + end + + def test_dml_and_statement_hinted_dml_raise_read_only_error + select_sql = "SELECT `singers`.* FROM `singers` WHERE `singers`.`id` = @p1 LIMIT @p2" + @mock.put_statement_result select_sql, MockServerTests.create_random_singers_result(1) + existing_singer = Singer.find_by id: 1 + @mock.requests.clear + + ActiveRecord::Base.while_preventing_writes do + assert_raises ActiveRecord::ReadOnlyError do + TableWithIdentity.create! name: "Foo" + end + + assert_raises ActiveRecord::ReadOnlyError do + TableWithIdentity.create name: "Foo" + end + + assert_raises ActiveRecord::ReadOnlyError do + TableWithIdentity.transaction do + TableWithIdentity.create! name: "Foo" + end + end + + assert_raises ActiveRecord::ReadOnlyError do + existing_singer.update_columns first_name: "DirectDml" + end + + assert_raises ActiveRecord::ReadOnlyError do + existing_singer.first_name = "SavedDml" + existing_singer.save! + end + + assert_raises ActiveRecord::ReadOnlyError do + Singer.where(id: 1).update_all first_name: "Updated" + end + + assert_raises ActiveRecord::ReadOnlyError do + Singer.update_all first_name: "UpdatedAll" + end + + assert_raises ActiveRecord::ReadOnlyError do + Singer.where(id: 1).delete_all + end + + assert_raises ActiveRecord::ReadOnlyError do + Singer.insert({ id: 19, first_name: "Alice", last_name: "Smith" }) + end + + assert_raises ActiveRecord::ReadOnlyError do + Singer.insert_all [{ id: 20, first_name: "Alice", last_name: "Smith" }] + end + + assert_raises ActiveRecord::ReadOnlyError do + Singer + .optimizer_hints("statement_hint: @{USE_ADDITIONAL_PARALLELISM=true}") + .where(id: 1) + .update_all first_name: "Hinted" + end + + assert_raises ActiveRecord::ReadOnlyError do + ActiveRecord::Base.connection.execute( + " @{USE_ADDITIONAL_PARALLELISM=true}UPDATE `singers` SET `first_name` = 'Hinted' WHERE `id` = 1" + ) + end + + assert_raises ActiveRecord::ReadOnlyError do + ActiveRecord::Base.transaction isolation: :pdml do + Singer.where(id: 1).update_all first_name: "Pdml" + end + end + + original_isolation = ActiveRecord::Base.connection.isolation_level + begin + ActiveRecord::Base.connection.isolation_level = :pdml + assert_raises ActiveRecord::ReadOnlyError do + ActiveRecord::Base.transaction do + Singer.where(id: 1).update_all first_name: "DefaultPdml" + end + end + ensure + ActiveRecord::Base.connection.isolation_level = original_isolation + end + end + + assert_no_write_requests + end + + def test_truncate_and_ddl_raise_read_only_error + ActiveRecord::Base.while_preventing_writes do + assert_raises ActiveRecord::ReadOnlyError do + ActiveRecord::Base.connection.truncate "singers" + end + + assert_raises ActiveRecord::ReadOnlyError do + ActiveRecord::Base.connection.execute_ddl "CREATE TABLE `foo` (`id` INT64) PRIMARY KEY (`id`)" + end + + assert_raises ActiveRecord::ReadOnlyError do + ActiveRecord::Base.connection.execute "CREATE TABLE `foo` (`id` INT64) PRIMARY KEY (`id`)" + end + + assert_raises ActiveRecord::ReadOnlyError do + ActiveRecord::Base.connection.create_table :foo do |t| + t.string :name + end + end + end + + assert_no_write_requests + end + + def test_batches_and_pre_buffered_mutations_raise_read_only_error + connection = ActiveRecord::Base.connection + + ActiveRecord::Base.while_preventing_writes do + assert_raises ActiveRecord::ReadOnlyError do + connection.ddl_batch do + connection.execute_ddl "CREATE TABLE `foo` (`id` INT64) PRIMARY KEY (`id`)" + end + end + + assert_raises ActiveRecord::ReadOnlyError do + connection.dml_batch do + connection.execute "UPDATE `singers` SET `first_name` = 'Batch' WHERE `id` = 1" + end + end + + assert_raises ActiveRecord::ReadOnlyError do + ActiveRecord::Base.dml_batch do + connection.execute "UPDATE `singers` SET `first_name` = 'Batch' WHERE `id` = 1" + end + end + + assert_raises ActiveRecord::ReadOnlyError do + connection.start_batch_ddl + end + + assert_raises ActiveRecord::ReadOnlyError do + connection.start_batch_dml + end + end + + # Starting a batch before while_preventing_writes should reject execution and run_batch inside it. + connection.start_batch_dml + begin + ActiveRecord::Base.while_preventing_writes do + assert_raises ActiveRecord::ReadOnlyError do + connection.execute "UPDATE `singers` SET `first_name` = 'Batch' WHERE `id` = 1" + end + + assert_raises ActiveRecord::ReadOnlyError do + connection.run_batch + end + end + ensure + connection.abort_batch + end + + connection.start_batch_ddl + begin + ActiveRecord::Base.while_preventing_writes do + assert_raises ActiveRecord::ReadOnlyError do + connection.execute_ddl "CREATE TABLE `foo` (`id` INT64) PRIMARY KEY (`id`)" + end + + assert_raises ActiveRecord::ReadOnlyError do + connection.run_batch + end + end + ensure + connection.abort_batch + end + + # Pre-buffered mutations cannot be committed while preventing writes. + connection.begin_isolated_db_transaction :buffered_mutations + begin + mutation = Google::Cloud::Spanner::V1::Mutation.new( + delete: Google::Cloud::Spanner::V1::Mutation::Delete.new( + table: "singers", + key_set: { all: true } + ) + ) + connection.exec_mutation mutation + assert_raises ActiveRecord::ReadOnlyError do + ActiveRecord::Base.while_preventing_writes do + connection.commit_db_transaction + end + end + ensure + connection.rollback_db_transaction + end + + assert_no_write_requests + end + + def test_optimistic_locking_mutations_raise_read_only_error_without_version_check_query + select_sql = "SELECT `versioned_singers`.* FROM `versioned_singers` WHERE `versioned_singers`.`id` = @p1 LIMIT @p2" + @mock.put_statement_result select_sql, MockServerTests.create_random_singers_result(1, 2) + versioned_singer = VersionedSinger.find 1 + @mock.requests.clear + + ActiveRecord::Base.while_preventing_writes do + assert_raises ActiveRecord::ReadOnlyError do + versioned_singer.update last_name: "Updated" + end + + assert_raises ActiveRecord::ReadOnlyError do + versioned_singer.destroy + end + end + + assert_equal 2, versioned_singer.lock_version + sql_requests = @mock.requests.select { |request| request.is_a? Google::Cloud::Spanner::V1::ExecuteSqlRequest } + assert_empty sql_requests + assert_no_write_requests + end + + def test_replica_connection_prevents_model_writes + ActiveRecord::Base.establish_connection( + adapter: "spanner", + emulator_host: "localhost:#{@port}", + project: "test-project", + instance: "test-instance", + database: "testdb", + default_sequence_kind: "BIT_REVERSED_POSITIVE", + replica: true + ) + + sql = "SELECT `singers`.* FROM `singers` WHERE `singers`.`id` = @p1 LIMIT @p2" + @mock.put_statement_result sql, MockServerTests.create_random_singers_result(1) + refute_nil Singer.find_by(id: 1) + @mock.requests.clear + + assert_raises ActiveRecord::ReadOnlyError do + Singer.create! first_name: "Replica", last_name: "Blocked" + end + + assert_no_write_requests + end + + private + + def assert_no_write_requests + commit_requests = @mock.requests.select { |request| request.is_a? Google::Cloud::Spanner::V1::CommitRequest } + assert_empty commit_requests + + batch_dml_requests = @mock.requests.select do |request| + request.is_a? Google::Cloud::Spanner::V1::ExecuteBatchDmlRequest + end + assert_empty batch_dml_requests + + write_begin_requests = @mock.requests.select do |request| + request.is_a?(Google::Cloud::Spanner::V1::BeginTransactionRequest) && + (request.options&.read_write || request.options&.partitioned_dml) + end + assert_empty write_begin_requests + + dml_requests = @mock.requests.select do |request| + request.is_a?(Google::Cloud::Spanner::V1::ExecuteSqlRequest) && + request.sql !~ /\A(?:SELECT|WITH|GRAPH|FROM)\b/i + end + assert_empty dml_requests + end + end +end