sunstone 7.2.0 → 8.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d280487f58777eebd36b07eb69f9492b77370ea3def7b05321bb2d4fd8e55626
-  data.tar.gz: a34f616483aca20b1207f12538e08fafb19b16ac01db6c19977b902cd1cd1537
+  metadata.gz: dd0eae0dbdee21a95ca29317302b67b50647f7d6654af15553425f55d1d11aed
+  data.tar.gz: b0cdc960489411360b1ee4f2cb4cdcce93b7df2464dabdafa2bc26955be002b3
 SHA512:
-  metadata.gz: 0211de6c05fded268d04e00af2e0f16e9f4ee0650307288ea890c343e1b20f0a2fcf924631e2c0c3e72b602af7e964c8663a6df51f22cce9bd85798b26d12604
-  data.tar.gz: 62e9b986925a43ca27c172499bca956ea20e6b8ca237d94dbcb1b07f52772ad1ffc9d5a0fe68d9ef6560e9a3df5ccc7bc27a8a78b56aad4fcccc44604f2a9060
+  metadata.gz: ce768f425153db1d5a2242f845bc3de221a4d0d0d8a30a1428c128d2bb1e4353ef986020283fdd1d17e7652937c38d03eb1f42478acbc694da32135f335cab22
+  data.tar.gz: ece020a27e0554bad07f0e831919e8969cebdd6970adc344fb4f018b3a45032588dcd7c4eb512d9fcb8ff4acfc09ef27d9fe6124fa2b9db0d5eeff659885d800

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/relation/calculations.rb

@@ -4,6 +4,27 @@
 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
@@ -25,20 +46,20 @@ module ActiveRecord
       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!(flattened_args(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(async: @async)
           else
-            klass.with_connection do |c|
-              c.select_all(relation.arel, "#{klass.name} Pluck", async: @async)
+            model.with_connection do |c|
+              c.select_all(relation.arel, "#{model.name} Pluck", async: @async)
             end
           end
         end

data/ext/active_record/relation/query_methods.rb

@@ -4,7 +4,7 @@ module ActiveRecord
 
     def assert_modifiable!
       raise UnmodifiableRelation if @loaded
-      raise UnmodifiableRelation if @arel && !klass.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
+      raise UnmodifiableRelation if @arel && !model.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
     end
 
   end

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

@@ -30,6 +30,7 @@ module ActiveRecord
         end
         
         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
           end
@@ -40,10 +41,13 @@ module ActiveRecord
                 "The values must be stored on the AST directly"
             end
             
-            sar = visitor.accept(arel_or_sar_string, collector)
+            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, allow_retry]
+            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
         
@@ -115,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)
-          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)
           
@@ -137,50 +141,73 @@ 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 = [], returning: nil)
           sar, binds = to_sar_and_binds(arel, binds)
@@ -190,13 +217,18 @@ module ActiveRecord
 
           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_adapter.rb

@@ -92,18 +92,30 @@ module ActiveRecord
       end
 
       def active?
-        @raw_connection&.active?
+        @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:
@@ -111,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
@@ -189,17 +195,6 @@ 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

data/lib/sunstone/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sunstone
 version: !ruby/object:Gem::Version
-  version: 7.2.0
+  version: 8.0.0
 platform: ruby
 authors:
 - Jon Bracy
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-09-13 00:00:00.000000000 Z
+date: 2025-01-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -226,14 +226,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 7.2.0
+        version: 8.0.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 7.2.0
+        version: 8.0.1
 - !ruby/object:Gem::Dependency
   name: arel-extensions
   requirement: !ruby/object:Gem::Requirement
@@ -324,7 +324,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.11
+rubygems_version: 3.5.21
 signing_key:
 specification_version: 4
 summary: A library for interacting with REST APIs