sunstone 7.1.0.1 → 8.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3956ea045dce2994b10bcac8535462bdf08597b85d7e15fc325110149a576aa6
-  data.tar.gz: 02be730df372f32557112e9fb618befb5aafd7a8ef15ce1e12a866f8c18c2ed7
+  metadata.gz: dd0eae0dbdee21a95ca29317302b67b50647f7d6654af15553425f55d1d11aed
+  data.tar.gz: b0cdc960489411360b1ee4f2cb4cdcce93b7df2464dabdafa2bc26955be002b3
 SHA512:
-  metadata.gz: c978ff5919d301007ccd326a632ed915cce129584e0ff9c25c199bddb9a65e517361f95a7d3a8af4ea70546acd1bb16fbc1118ff050a0c209f4168f9ec71feb9
-  data.tar.gz: 3a24f347b5ca8ccf2816e8d50a28ca3effedea79a897ab3692801b5cd8095d9fc324f37f792ffba621a9669eb7ea92f58be762b62d2a1e9096a9306fc1d46be9
+  metadata.gz: ce768f425153db1d5a2242f845bc3de221a4d0d0d8a30a1428c128d2bb1e4353ef986020283fdd1d17e7652937c38d03eb1f42478acbc694da32135f335cab22
+  data.tar.gz: ece020a27e0554bad07f0e831919e8969cebdd6970adc344fb4f018b3a45032588dcd7c4eb512d9fcb8ff4acfc09ef27d9fe6124fa2b9db0d5eeff659885d800

data/ext/active_record/associations/collection_association.rb

@@ -6,7 +6,7 @@ module ActiveRecord
 
       def replace(other_array)
         other_array.each { |val| raise_on_type_mismatch!(val) }
-        original_target = load_target.dup
+        original_target = skip_strict_loading { load_target }.dup
 
         if owner.new_record?
           replace_records(other_array, original_target)
@@ -52,7 +52,6 @@ module ActiveRecord
         end
       end
 
-
     end
 
     class HasManyThroughAssociation

data/ext/active_record/associations.rb

@@ -25,13 +25,13 @@ module ActiveRecord
 
         include Module.new {
           class_eval <<-RUBY, __FILE__, __LINE__ + 1
-          def destroy_associations
-            if !self.class.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
-              association(:#{middle_reflection.name}).delete_all(:delete_all)
-              association(:#{name}).reset
+            def destroy_associations
+              if !self.class.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
+                association(:#{middle_reflection.name}).delete_all(:delete_all)
+                association(:#{name}).reset
+              end
+              super
             end
-            super
-          end
           RUBY
         }
 
@@ -44,7 +44,7 @@ module ActiveRecord
         end
 
         has_many name, scope, **hm_options, &extension
-        _reflections[name.to_s].parent_reflection = habtm_reflection
+        _reflections[name].parent_reflection = habtm_reflection
       end
     end
   end

data/ext/active_record/finder_methods.rb

@@ -8,6 +8,11 @@ module ActiveRecord
       return ["1=0"] if attributes.empty?
 
       attributes.flat_map do |key, value|
+        if key.is_a?(Array) && key.size == 1
+          key = key.first
+          value = value.flatten
+        end
+        
         if key.is_a?(Array)
           queries = Array(value).map do |ids_set|
             raise ArgumentError, "Expected corresponding value for #{key} to be an Array" unless ids_set.is_a?(Array)

data/ext/active_record/persistence.rb

@@ -104,18 +104,22 @@ module ActiveRecord
     def _create_record(attribute_names = self.attribute_names)
       attribute_names = attributes_for_create(attribute_names)
       attribute_values = attributes_with_values(attribute_names)
-
-      returning_columns = self.class._returning_columns_for_insert
-
-      returning_values = self.class._insert_record(
-        attribute_values,
-        returning_columns
-      )
-
-      if !self.class.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
-        returning_columns.zip(returning_values).each do |column, value|
-          _write_attribute(column, value) if !_read_attribute(column)
-        end if returning_values
+      returning_values = nil
+      
+      self.class.with_connection do |connection|
+        returning_columns = self.class._returning_columns_for_insert(connection)
+
+        returning_values = self.class._insert_record(
+          connection,
+          attribute_values,
+          returning_columns
+        )
+
+        if !self.class.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
+          returning_columns.zip(returning_values).each do |column, value|
+            _write_attribute(column, value) if !_read_attribute(column)
+          end if returning_values
+        end
       end
 
       @new_record = false

data/ext/active_record/relation/calculations.rb

@@ -4,30 +4,68 @@
 module ActiveRecord
   module Calculations
 
+    # Prior to Rails 8 we didn't need this method becuase it would
+    # return the first value if there was just one - so we'll just
+    # do the same as prevously because it doesn't have to be joined
+    def select_for_count
+      if select_values.empty?
+        :all
+      else
+        with_connection do |conn|
+          # Rails compiles this to a string, but we don't have string we
+          # have a hash
+          if model.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
+            sv = arel_columns(select_values)
+            sv.one? ? sv.first : sv
+          else
+            sv = arel_columns(select_values).map { |column| conn.visitor.compile(column) } 
+            sv.one? ? sv.first : sv.join(", ")
+          end
+        end
+      end
+    end
+
     def pluck(*column_names)
+      if @none
+        if @async
+          return Promise::Complete.new([])
+        else
+          return []
+        end
+      end
+
       if loaded? && all_attributes?(column_names)
-        return records.pluck(*column_names)
+        result = records.pluck(*column_names)
+        if @async
+          return Promise::Complete.new(result)
+        else
+          return result
+        end
       end
-      
+
       if has_include?(column_names.first)
         relation = apply_join_dependency
         relation.pluck(*column_names)
-      elsif klass.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
+      elsif model.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
         load
-        return records.pluck(*column_names.map{|n| n.to_s.sub(/^#{klass.table_name}\./, "")})
+        return records.pluck(*column_names.map{|n| n.to_s.sub(/^#{model.table_name}\./, "")})
       else
-        klass.disallow_raw_sql!(column_names)
-        columns = arel_columns(column_names)
+        model.disallow_raw_sql!(flattened_args(column_names))
         relation = spawn
+        columns = relation.arel_columns(column_names)
         relation.select_values = columns
         result = skip_query_cache_if_necessary do
           if where_clause.contradiction?
-            ActiveRecord::Result.empty
+            ActiveRecord::Result.empty(async: @async)
           else
-            klass.connection.select_all(relation.arel, "#{klass.name} Pluck")
+            model.with_connection do |c|
+              c.select_all(relation.arel, "#{model.name} Pluck", async: @async)
+            end
           end
         end
-        type_cast_pluck_values(result, columns)
+        result.then do |result|
+          type_cast_pluck_values(result, columns)
+        end
       end
     end
 

data/ext/active_record/relation/query_methods.rb

@@ -1,9 +1,11 @@
 module ActiveRecord
   module QueryMethods
     private
-      def assert_mutability!
-        raise ImmutableRelation if @loaded
-        raise ImmutableRelation if defined?(@arel) && @arel && !klass.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
-      end
+
+    def assert_modifiable!
+      raise UnmodifiableRelation if @loaded
+      raise UnmodifiableRelation if @arel && !model.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
+    end
+
   end
 end

data/ext/active_record/transactions.rb

@@ -34,23 +34,25 @@ module ActiveRecord
     # end
 
     def with_transaction_returning_status
-      status = nil
-      connection = self.class.connection
-
-      if connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter) && instance_variable_defined?(:@sunstone_updating) && @sunstone_updating
-        status = yield
-      else
-        ensure_finalize = !connection.transaction_open?
-        connection.transaction do
-          add_to_transaction(ensure_finalize || has_transactional_callbacks?)
-          remember_transaction_record_state
+      self.class.with_connection do |connection|
+        status = nil
+        # connection = self.class.connection
 
+        if connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter) && instance_variable_defined?(:@sunstone_updating) && @sunstone_updating
           status = yield
-          raise ActiveRecord::Rollback unless status
+        else
+          ensure_finalize = !connection.transaction_open?
+          connection.transaction do
+            add_to_transaction(ensure_finalize || has_transactional_callbacks?)
+            remember_transaction_record_state
+
+            status = yield
+            raise ActiveRecord::Rollback unless status
+          end
         end
-      end
       
-      status
+        status
+      end
     end
 
 

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

@@ -29,7 +29,7 @@ module ActiveRecord
           sar.compile(binds)
         end
         
-        def to_sar_and_binds(arel_or_sar_string, binds = [], preparable = nil) # :nodoc:
+        def to_sar_and_binds(arel_or_sar_string, binds = [], preparable = nil, allow_retry = false)
           # Arel::TreeManager -> Arel::Node
           if arel_or_sar_string.respond_to?(:ast)
             arel_or_sar_string = arel_or_sar_string.ast
@@ -41,10 +41,13 @@ module ActiveRecord
                 "The values must be stored on the AST directly"
             end
             
-            sar = visitor.accept(arel_or_sar_string, collector)
-            [sar.freeze, sar.binds, false]
+            col = collector()
+            col.retryable = true
+            sar = visitor.compile(arel_or_sar_string, col)
+            [sar.freeze, sar.binds, false, allow_retry]
           else
-            [arel_or_sar_string.dup.freeze, binds, false]
+            arel_or_sar_string = arel_or_sar_string.dup.freeze unless arel_or_sar_string.frozen?
+            [arel_or_sar_string, binds, false, allow_retry]
           end
         end
         
@@ -90,11 +93,15 @@ module ActiveRecord
         end
 
         # Returns an ActiveRecord::Result instance.
-        def select_all(arel, name = nil, binds = [], preparable: nil, async: false)
+        def select_all(arel, name = nil, binds = [], preparable: nil, async: false, allow_retry: false)
           arel = arel_from_relation(arel)
-          sar, binds, preparable = to_sar_and_binds(arel, binds, preparable)
+          sar, binds, preparable, allow_retry = to_sar_and_binds(arel, binds, preparable, allow_retry)
 
-          select(sar, name, binds, prepare: prepared_statements && preparable, async: async && FutureResult::SelectAll)
+          select(sar, name, binds,
+            prepare: prepared_statements && preparable,
+            async: async && FutureResult::SelectAll,
+            allow_retry: allow_retry
+          )
         rescue ::RangeError
           ActiveRecord::Result.empty(async: async)
         end
@@ -112,8 +119,8 @@ module ActiveRecord
           internal_exec_query(sar, name, binds)
         end
 
-        def internal_exec_query(arel, name = 'SAR', binds = [], prepare: false, async: false, allow_retry: false, materialize_transactions: true)
-          sars = []
+        # Lowest level way to execute a query. Doesn't check for illegal writes, doesn't annotate queries, yields a native result object.
+        def raw_execute(arel, name = nil, binds = [], prepare: false, async: false, allow_retry: false, materialize_transactions: true, batch: false)
           multiple_requests = arel.is_a?(Arel::Collectors::Sunstone)
           type_casted_binds = binds#type_casted_binds(binds)
           
@@ -134,66 +141,94 @@ module ActiveRecord
               multiple_requests = true
             end
           end
-
-          send_request = lambda { |req_arel|
+          
+          send_request = lambda { |conn, req_arel, batch|
             sar = to_sar(req_arel, type_casted_binds)
-            sars.push(sar)
             log_mess = sar.path.split('?', 2)
-            log("#{sar.method} #{log_mess[0]} #{(log_mess[1] && !log_mess[1].empty?) ? MessagePack.unpack(CGI.unescape(log_mess[1])) : '' }", name) do
-              with_raw_connection do |conn|
-                response = conn.send_request(sar)
-                if response.is_a?(Net::HTTPNoContent)
-                  nil
+            log("#{sar.method} #{log_mess[0]} #{(log_mess[1] && !log_mess[1].empty?) ? MessagePack.unpack(CGI.unescape(log_mess[1])) : '' }", name) do |notification_payload|
+              result = perform_query(conn, sar, prepare:, notification_payload:, batch: batch)
+              result.instance_variable_set(:@sunstone_calculation, true) if result && sar.instance_variable_get(:@sunstone_calculation)
+              result
+            end
+          }
+          
+          result = with_raw_connection(allow_retry: allow_retry, materialize_transactions: materialize_transactions) do |conn|
+            if multiple_requests
+              binds.delete_at(limit_bind_index) if limit_bind_index
+
+              limit, offset, results = allowed_limit, 0, nil
+              last_affected_rows = 0
+              while requested_limit ? offset < requested_limit : true
+                split_arel = arel.dup
+                split_arel.limit = limit
+                split_arel.offset = offset
+                request_results = send_request.call(conn, split_arel, true)
+                last_affected_rows += @last_affected_rows
+                if results
+                  results.push(*request_results)
                 else
-                  JSON.parse(response.body)
+                  results = request_results
                 end
+                break if request_results.size < limit
+                offset = offset + limit
               end
+              @last_affected_rows = last_affected_rows
+              results
+            else
+              send_request.call(conn, arel, true)
             end
-          }
-
-          result = if multiple_requests
-            binds.delete_at(limit_bind_index) if limit_bind_index
-
-            limit, offset, results = allowed_limit, 0, []
-            while requested_limit ? offset < requested_limit : true
-              split_arel = arel.dup
-              split_arel.limit = limit
-              split_arel.offset = offset
-              request_results = send_request.call(split_arel)
-              results = results + request_results
-              break if request_results.size < limit
-              offset = offset + limit
-            end
-            results
-          else
-            send_request.call(arel)
           end
-          
-          if sars[0].instance_variable_defined?(:@sunstone_calculation) && sars[0].instance_variable_get(:@sunstone_calculation)
+
+          result
+        end
+
+        def perform_query(raw_connection, sar, prepare:, notification_payload:, batch: false)
+          response = raw_connection.send_request(sar)
+          result = response.is_a?(Net::HTTPNoContent) ? nil : JSON.parse(response.body)
+
+          verified!
+          # handle_warnings(result)
+          @last_affected_rows = response['Affected-Rows'] || result&.count || 0
+          notification_payload[:row_count] = @last_affected_rows
+          result
+        end
+        
+        # Receive a native adapter result object and returns an ActiveRecord::Result object.
+        def cast_result(raw_result)
+          if raw_result.instance_variable_defined?(:@sunstone_calculation) && raw_result.instance_variable_get(:@sunstone_calculation)
             # this is a count, min, max.... yea i know..
-            ActiveRecord::Result.new(['all'], [result], {:all => @type_map.lookup('integer', {})})
-          elsif result.is_a?(Array)
-            ActiveRecord::Result.new(result[0] ? result[0].keys : [], result.map{|r| r.values})
+            ActiveRecord::Result.new(['all'], [raw_result], {:all => @type_map.lookup('integer', {})})
+          elsif raw_result.is_a?(Array)
+            ActiveRecord::Result.new(raw_result[0] ? raw_result[0].keys : [], raw_result.map{|r| r.values})
           else
-            ActiveRecord::Result.new(result.keys, [result.values])
+            ActiveRecord::Result.new(raw_result.keys, [raw_result.values])
           end
         end
+
+        def affected_rows(raw_result)
+          @last_affected_rows
+        end
         
-        def insert(arel, name = nil, pk = nil, id_value = nil, sequence_name = nil, binds = [])
+        def insert(arel, name = nil, pk = nil, id_value = nil, sequence_name = nil, binds = [], returning: nil)
           sar, binds = to_sar_and_binds(arel, binds)
-          value = exec_insert(sar, name, binds, pk, sequence_name)
+          value = exec_insert(sar, name, binds, pk, sequence_name, returning: returning)
 
           return returning_column_values(value) unless returning.nil?
 
           id_value || last_inserted_id(value)
         end
-        
+        alias create insert
+
+        # Executes the update statement and returns the number of rows affected.
         def update(arel, name = nil, binds = [])
-          exec_update(arel, name, binds)
+          sar, binds = to_sar_and_binds(arel, binds)
+          internal_exec_query(sar, name, binds)
         end
         
+        # Executes the delete statement and returns the number of rows affected.
         def delete(arel, name = nil, binds = [])
-          exec_delete(arel, name, binds)
+          sql, binds = to_sar_and_binds(arel, binds)
+          exec_delete(sql, name, binds)
         end
 
         def last_inserted_id(result)

data/lib/active_record/connection_adapters/sunstone/quoting.rb

@@ -0,0 +1,19 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module Sunstone
+      module Quoting
+        extend ActiveSupport::Concern
+
+        module ClassMethods # :nodoc:
+
+          # Quotes column names for use in SQL queries.
+          def quote_column_name(name) # :nodoc:
+            name
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/sunstone_adapter.rb

@@ -3,6 +3,7 @@ require 'active_record/connection_adapters/abstract_adapter'
 require 'arel/nodes/relation'
 require 'arel/visitors/to_sql_extensions'
 
+require 'active_record/connection_adapters/sunstone/quoting'
 require 'active_record/connection_adapters/sunstone/database_statements'
 require 'active_record/connection_adapters/sunstone/schema_statements'
 require 'active_record/connection_adapters/sunstone/schema_dumper'
@@ -15,19 +16,6 @@ require 'active_record/connection_adapters/sunstone/type/uuid'
 require 'active_record/connection_adapters/sunstone/type/json'
 
 module ActiveRecord
-  module ConnectionHandling # :nodoc:
-
-    def sunstone_adapter_class
-      ConnectionAdapters::SunstoneAPIAdapter
-    end
-    
-    # Establishes a connection to the database that's used by all Active Record
-    # objects
-    def sunstone_connection(config)
-      sunstone_adapter_class.new(config)
-    end
-  end
-
   module ConnectionAdapters
     # The SunstoneAPI adapter.
     #
@@ -56,7 +44,7 @@ module ActiveRecord
         end
       end
 
-      # include PostgreSQL::Quoting
+      include Sunstone::Quoting
       # include PostgreSQL::ReferentialIntegrity
       include Sunstone::SchemaStatements
       include Sunstone::DatabaseStatements
@@ -104,23 +92,30 @@ module ActiveRecord
       end
 
       def active?
-        @raw_connection&.active?
-      end
-
-      def load_type_map
-        @type_map = Type::HashLookupTypeMap.new
-        initialize_type_map(@type_map)
+        @lock.synchronize do
+          @raw_connection&.active?
+        end
       end
       
-      def reconnect
-        super
-        @raw_connection&.reconnect!
+      # Connects to a StandardAPI server and sets up the adapter depending
+      # on the connected server's characteristics.
+      def connect
+        @raw_connection = self.class.new_client(@connection_parameters)
       end
 
+      def reconnect
+        @lock.synchronize do
+          @raw_connection&.reconnect!
+          connect unless @raw_connection
+        end
+      end
+      
       def disconnect!
-        super
-        @raw_connection&.disconnect!
-        @raw_connection = nil
+        @lock.synchronize do
+          super
+          @raw_connection&.disconnect!
+          @raw_connection = nil
+        end
       end
 
       def discard! # :nodoc:
@@ -128,12 +123,6 @@ module ActiveRecord
         @raw_connection = nil
       end
 
-      # Executes the delete statement and returns the number of rows affected.
-      def delete(arel, name = nil, binds = [])
-        r = exec_delete(arel, name, binds)
-        r.rows.first.to_i
-      end
-
       def native_database_types #:nodoc:
         NATIVE_DATABASE_TYPES
       end
@@ -169,6 +158,7 @@ module ActiveRecord
       end
 
       def lookup_cast_type_from_column(column) # :nodoc:
+        verify! if type_map.nil?
         cast_type = @type_map.lookup(column.sql_type, {
           limit: column.limit,
           precision: column.precision,
@@ -205,20 +195,11 @@ module ActiveRecord
       end
       alias create insert
 
-      # Connects to a StandardAPI server and sets up the adapter depending
-      # on the connected server's characteristics.
-      def connect
-        @raw_connection = self.class.new_client(@connection_parameters)
-      end
-
-      def reconnect
-        @raw_connection&.reconnect!
-        connect unless @raw_connection
-      end
-
       # Configures the encoding, verbosity, schema search path, and time zone of the connection.
       # This is called by #connect and should not be called manually.
       def configure_connection
+        super
+        
         reload_type_map
       end
 
@@ -233,7 +214,9 @@ module ActiveRecord
       end
 
       private
-      
+
+      attr_reader :type_map
+
       def initialize_type_map(m = nil)
         self.class.initialize_type_map(m || @type_map)
       end

data/lib/sunstone/connection.rb

@@ -203,7 +203,7 @@ module Sunstone
         close_connection = false
         @connection.request(request) do |response|
           if response['Deprecation-Notice']
-            ActiveSupport::Deprecation.warn(response['Deprecation-Notice'])
+            ::ActiveRecord.deprecator.warn(response['Deprecation-Notice'])
           end
 
           validate_response_code(response)

data/lib/sunstone/version.rb

@@ -1,3 +1,3 @@
 module Sunstone
-  VERSION = '7.1.0.1'
+  VERSION = '8.0.0'
 end

data/lib/sunstone.rb

@@ -39,17 +39,5 @@ require File.expand_path(File.join(__FILE__, '../../ext/arel/attributes/empty_re
 require File.expand_path(File.join(__FILE__, '../../ext/arel/nodes/select_statement'))
 require File.expand_path(File.join(__FILE__, '../../ext/active_record/finder_methods'))
 
-if ActiveRecord::VERSION::MAJOR == 6 && ActiveRecord::VERSION::MINOR == 1
-  # Patch to allow Rails 6.1 pass url to adapter, all other versions work
-  require 'active_record/database_configurations'
-  class ActiveRecord::DatabaseConfigurations::UrlConfig
-    private
-    def build_url_hash
-      if url.nil? || %w(jdbc: http: https:).any? { |protocol| url.start_with?(protocol) }
-        { url: url }
-      else
-        ConnectionUrlResolver.new(url).to_hash
-      end
-    end
-  end
-end
+
+ActiveRecord::ConnectionAdapters.register("sunstone", "ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter", "active_record/connection_adapters/sunstone_adapter")

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sunstone
 version: !ruby/object:Gem::Version
-  version: 7.1.0.1
+  version: 8.0.0
 platform: ruby
 authors:
 - Jon Bracy
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-12-20 00:00:00.000000000 Z
+date: 2025-01-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -114,14 +114,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 6.5.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 6.5.0
 - !ruby/object:Gem::Dependency
   name: webmock
   requirement: !ruby/object:Gem::Requirement
@@ -184,14 +184,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 7.1.0
+        version: 7.2.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 7.1.0
+        version: 7.2.0
 - !ruby/object:Gem::Dependency
   name: msgpack
   requirement: !ruby/object:Gem::Requirement
@@ -226,14 +226,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 7.1.0
+        version: 8.0.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 7.1.0
+        version: 8.0.1
 - !ruby/object:Gem::Dependency
   name: arel-extensions
   requirement: !ruby/object:Gem::Requirement
@@ -288,6 +288,7 @@ files:
 - ext/arel/select_manager.rb
 - lib/active_record/connection_adapters/sunstone/column.rb
 - lib/active_record/connection_adapters/sunstone/database_statements.rb
+- lib/active_record/connection_adapters/sunstone/quoting.rb
 - lib/active_record/connection_adapters/sunstone/schema_dumper.rb
 - lib/active_record/connection_adapters/sunstone/schema_statements.rb
 - lib/active_record/connection_adapters/sunstone/type/array.rb
@@ -323,7 +324,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.13
+rubygems_version: 3.5.21
 signing_key:
 specification_version: 4
 summary: A library for interacting with REST APIs