sunstone 7.0.0 → 7.1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 02df1d75e40c2ef207e6e1f329068c95098f5b99758d1bcea603e157ed2c1f40
-  data.tar.gz: 4807c8a530f9c7f09448a08bea1dbe015724f2afb53d81b86cf5cef6d6b49dcf
+  metadata.gz: 3956ea045dce2994b10bcac8535462bdf08597b85d7e15fc325110149a576aa6
+  data.tar.gz: 02be730df372f32557112e9fb618befb5aafd7a8ef15ce1e12a866f8c18c2ed7
 SHA512:
-  metadata.gz: e884525eda7c249da0f4decbadff3d27ff97859eac4874e1c20b4b0e10c80d6d96ee49419d27bd2f6d429c55c93485bfe1961451ff8396d101e37752ec39ac6d
-  data.tar.gz: 4323252706192a940b6f730a6c46324d4c40729df5864a5d1aafc4283764ef159284ddefe9b1335a7d9174b6716d11a2d0da4aa59dbdfbc3ac7cdccc537b06f8
+  metadata.gz: c978ff5919d301007ccd326a632ed915cce129584e0ff9c25c199bddb9a65e517361f95a7d3a8af4ea70546acd1bb16fbc1118ff050a0c209f4168f9ec71feb9
+  data.tar.gz: 3a24f347b5ca8ccf2816e8d50a28ca3effedea79a897ab3692801b5cd8095d9fc324f37f792ffba621a9669eb7ea92f58be762b62d2a1e9096a9306fc1d46be9

data/ext/active_record/associations/collection_association.rb

@@ -1,3 +1,5 @@
+# The last ref that this code was synced with Rails
+# ref: 9269f634d471ad6ca46752421eabd3e1c26220b5
 module ActiveRecord
   module Associations
     class CollectionAssociation
@@ -8,7 +10,7 @@ module ActiveRecord
 
         if owner.new_record?
           replace_records(other_array, original_target)
-        elsif owner.class.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter) && owner.instance_variable_defined?(:@updating) && owner.instance_variable_get(:@updating)
+        elsif owner.class.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter) && owner.instance_variable_defined?(:@sunstone_updating) && owner.instance_variable_get(:@sunstone_updating)
           replace_common_records_in_memory(other_array, original_target)
 
           # Remove from target
@@ -41,7 +43,7 @@ module ActiveRecord
       end
 
       def insert_record(record, validate = true, raise = false, &block)
-        if record.class.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter) && owner.instance_variable_defined?(:@updating) && owner.instance_variable_get(:@updating)
+        if record.class.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter) && owner.instance_variable_defined?(:@sunstone_updating) && owner.instance_variable_get(:@sunstone_updating)
           true
         elsif raise
           record.save!(validate: validate, &block)
@@ -70,27 +72,3 @@ module ActiveRecord
 
   end
 end
-
-module ActiveRecord
-  module Persistence
-    
-    # Updates the attributes of the model from the passed-in hash and saves the
-    # record, all wrapped in a transaction. If the object is invalid, the saving
-    # will fail and false will be returned.
-    def update(attributes)
-      @updating = :updating
-      Thread.current[:sunstone_updating_model] = self
-      
-      # The following transaction covers any possible database side-effects of the
-      # attributes assignment. For example, setting the IDs of a child collection.
-      with_transaction_returning_status do
-        assign_attributes(attributes)
-        save
-      end
-    ensure
-      @updating = false
-      Thread.current[:sunstone_updating_model] = nil
-    end
-    
-  end
-end

data/ext/active_record/associations.rb

@@ -1,5 +1,9 @@
+# The last ref that this code was synced with Rails
+# ref: 9269f634d471ad6ca46752421eabd3e1c26220b5
+
 require 'active_record'
 require 'active_record/associations'
+
 module ActiveRecord
   module Associations
     module ClassMethods
@@ -44,4 +48,4 @@ module ActiveRecord
       end
     end
   end
-end
+end

data/ext/active_record/attribute_methods.rb

@@ -1,14 +1,15 @@
+# The last ref that this code was synced with Rails
+# ref: 9269f634d471ad6ca46752421eabd3e1c26220b5
+
 module ActiveRecord
   module AttributeMethods
-    
+
     protected
-    
+
     # Returns a Hash of the Arel::Attributes and attribute values that have been
     # typecasted for use in an Arel insert/update method.
     def attributes_with_values(attribute_names)
-      attrs = attribute_names.index_with do |name|
-        _read_attribute(name)
-      end
+      attrs = attribute_names.index_with { |name| @attributes[name] }
 
       if self.class.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
         self.class.reflect_on_all_associations.each do |reflection|
@@ -25,17 +26,17 @@ module ActiveRecord
           end
         end
       end
-      
+
       attrs
     end
-    
+
     def add_attributes_for_belongs_to_association(reflection, attrs)
       key = :"add_attributes_for_belongs_to_association_#{reflection.name}"
       @_already_called ||= {}
       return if @_already_called[key]
       @_already_called[key]=true
       @_already_called[:"autosave_associated_records_for_#{reflection.name}"] = true
-      
+
       association = association_instance_get(reflection.name)
       record      = association && association.load_target
       if record && !record.destroyed?
@@ -51,14 +52,14 @@ module ActiveRecord
         end
       end
     end
-    
+
     def add_attributes_for_has_one_association(reflection, attrs)
       key = :"add_attributes_for_has_one_association#{reflection.name}"
       @_already_called ||= {}
       return if @_already_called[key]
       @_already_called[key]=true
       @_already_called[:"autosave_associated_records_for_#{reflection.name}"] = true
-      
+
       association = association_instance_get(reflection.name)
       record      = association && association.load_target
 
@@ -80,7 +81,7 @@ module ActiveRecord
         end
       end
     end
-    
+
     def add_attributes_for_collection_association(reflection, attrs, arel_table=nil)
       key = :"add_attributes_for_collection_association#{reflection.name}"
       @_already_called ||= {}
@@ -106,7 +107,7 @@ module ActiveRecord
                 )
             end
           end
-        
+
           association.instance_variable_set(:@sunstone_changed, false)
         end
 
@@ -114,6 +115,6 @@ module ActiveRecord
         association.reset_scope if association.respond_to?(:reset_scope)
       end
     end
-    
+
   end
 end

data/ext/active_record/callbacks.rb

@@ -1,3 +1,6 @@
+# The last ref that this code was synced with Rails
+# ref: 9269f634d471ad6ca46752421eabd3e1c26220b5
+
 module ActiveRecord
   module Callbacks
     private
@@ -14,4 +17,4 @@ module ActiveRecord
       end
 
   end
-end
+end

data/ext/active_record/finder_methods.rb

@@ -1,14 +1,24 @@
+# The last ref that this code was synced with Rails
+# ref: 9269f634d471ad6ca46752421eabd3e1c26220b5
+
 module ActiveRecord
   class PredicateBuilder # :nodoc:
 
     def expand_from_hash(attributes, &block)
       return ["1=0"] if attributes.empty?
-  
+
       attributes.flat_map do |key, value|
-        if value.is_a?(Hash) && !table.has_column?(key)
+        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)
+            expand_from_hash(key.zip(ids_set).to_h)
+          end
+          grouping_queries(queries)
+        elsif value.is_a?(Hash) && !table.has_column?(key)
           ka = table.associated_table(key, &block)
-                 .predicate_builder.expand_from_hash(value.stringify_keys)
-          if self.send(:table).instance_variable_get(:@klass).connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
+            .predicate_builder.expand_from_hash(value.stringify_keys)
+
+          if self.table.instance_variable_get(:@klass).connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
             ka.each { |k|
               if k.left.is_a?(Arel::Attributes::Attribute) || k.left.is_a?(Arel::Attributes::Relation)
                 k.left = Arel::Attributes::Relation.new(k.left, key)

data/ext/active_record/persistence.rb

@@ -6,10 +6,12 @@ module ActiveRecord
       def rpc(name)
         define_method("#{name}!") do
           req = Net::HTTP::Post.new("/#{self.class.table_name}/#{CGI.escape(id.to_s)}/#{CGI.escape(name.to_s)}")
-          self.class.connection.instance_variable_get(:@connection).send_request(req) do |response|
-            JSON.parse(response.body).each do |k,v|
-              if self.class.column_names.include?(k)
-                @attributes.write_from_database(k, v)
+          self.class.connection.send(:with_raw_connection) do |conn|
+            conn.send_request(req) do |response|
+              JSON.parse(response.body).each do |k,v|
+                if self.class.column_names.include?(k)
+                  @attributes.write_from_database(k, v)
+                end
               end
             end
           end
@@ -17,7 +19,25 @@ module ActiveRecord
         end
       end
     end
-    
+
+    # Updates the attributes of the model from the passed-in hash and saves the
+    # record, all wrapped in a transaction. If the object is invalid, the saving
+    # will fail and false will be returned.
+    def update(attributes)
+      @sunstone_updating = :updating
+      Thread.current[:sunstone_updating_model] = self
+
+      # The following transaction covers any possible database side-effects of the
+      # attributes assignment. For example, setting the IDs of a child collection.
+      with_transaction_returning_status do
+        assign_attributes(attributes)
+        save
+      end
+    ensure
+      @sunstone_updating = false
+      Thread.current[:sunstone_updating_model] = nil
+    end
+
     def update!(attributes)
       @no_save_transaction = true
       with_transaction_returning_status do
@@ -33,14 +53,14 @@ module ActiveRecord
     def create_or_update(**, &block)
       _raise_readonly_record_error if readonly?
       return false if destroyed?
-      
-      @updating = new_record? ? :creating : :updating
+
+      @sunstone_updating = new_record? ? :creating : :updating
       Thread.current[:sunstone_updating_model] = self
 
       result = new_record? ? _create_record(&block) : _update_record(&block)
 
       if self.class.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter) && result != 0
-        row_hash = result.rows.first
+        row_hash = result[0]
 
         seen = Hash.new { |h, parent_klass|
           h[parent_klass] = Hash.new { |i, parent_id|
@@ -51,10 +71,13 @@ module ActiveRecord
         model_cache = Hash.new { |h,klass| h[klass] = {} }
         parents = model_cache[self.class.base_class]
         
-        self.assign_attributes(row_hash.select{|k,v| self.class.column_names.include?(k.to_s) })
-        row_hash.select{|k,v| !self.class.column_names.include?(k.to_s) }.each do |relation_name, value|
-          assc = association(relation_name.to_sym)
-          assc.reset if assc.reflection.collection?
+        row_hash.each do |key, value|
+          if self.class.column_names.include?(key.to_s)
+            _write_attribute(key, value)
+          else
+            assc = association(key.to_sym)
+            assc.reset if assc.reflection.collection? # TODO: can load here if included
+          end
         end
 
         construct(self, row_hash.select{|k,v| !self.class.column_names.include?(k.to_s) }, seen, model_cache)
@@ -72,39 +95,50 @@ module ActiveRecord
       end
       raise ActiveRecord::RecordInvalid
     ensure
-      @updating = false
+      @sunstone_updating = false
       Thread.current[:sunstone_updating_model] = nil
     end
-    
+
     # Creates a record with values matching those of the instance attributes
     # and returns its id.
     def _create_record(attribute_names = self.attribute_names)
       attribute_names = attributes_for_create(attribute_names)
-      attributes_values = attributes_with_values(attribute_names)
-      
-      new_id = self.class._insert_record(attributes_values)
+      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
+      end
 
-      self.id ||= new_id if @primary_key
       @new_record = false
       @previously_new_record = true
       
       yield(self) if block_given?
       
       if self.class.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
-        new_id
+        returning_values
       else
         id
       end
     end
-    
+
     def _update_record(attribute_names = self.attribute_names)
+      attribute_names = attributes_for_update(attribute_names)
       attribute_values = attributes_with_values(attribute_names)
 
       if attribute_values.empty?
         affected_rows = 0
         @_trigger_update_callback = true
       else
-        affected_rows = self.class._update_record( attribute_values, self.class.primary_key => id_in_database )
+        affected_rows = self.class._update_record(attribute_values, _query_constraints_hash)
         @_trigger_update_callback = affected_rows == 1
       end
 

data/ext/active_record/relation/calculations.rb

@@ -1,6 +1,9 @@
+# The last ref that this code was synced with Rails
+# ref: 9269f634d471ad6ca46752421eabd3e1c26220b5
+
 module ActiveRecord
   module Calculations
-    
+
     def pluck(*column_names)
       if loaded? && all_attributes?(column_names)
         return records.pluck(*column_names)

data/ext/active_record/transactions.rb

@@ -36,8 +36,8 @@ module ActiveRecord
     def with_transaction_returning_status
       status = nil
       connection = self.class.connection
-      
-      if connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter) && instance_variable_defined?(:@updating) && @updating
+
+      if connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter) && instance_variable_defined?(:@sunstone_updating) && @sunstone_updating
         status = yield
       else
         ensure_finalize = !connection.transaction_open?

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

@@ -2,6 +2,8 @@ module ActiveRecord
   module ConnectionAdapters
     # Sunstone-specific extensions to column definitions in a table.
     class SunstoneColumn < Column #:nodoc:
+      NONE = Object.new
+
       attr_reader :array
       
       def initialize(name, sql_type_metadata, options={})
@@ -14,12 +16,20 @@ module ActiveRecord
         @table_name = nil
         @primary_key = (options['primary_key'] == true)
         @array = options['array']
+        @auto_populated = options.has_key?('auto_populated') ? options['auto_populated'] : NONE
       end
       
       def primary_key?
         @primary_key
       end
       
+      def auto_populated?
+        # TODO: when retuning is working we can do the following to only
+        # return autopulated fields from StandardAPI
+        # @auto_populated == NONE ? @primary_key : @auto_populated
+        true
+      end
+      
     end
   end
 end

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

@@ -25,22 +25,35 @@ module ActiveRecord
           else
             sar = arel_or_sar_string
           end
+
           sar.compile(binds)
         end
         
         def to_sar_and_binds(arel_or_sar_string, binds = [], preparable = nil) # :nodoc:
+          # Arel::TreeManager -> Arel::Node
           if arel_or_sar_string.respond_to?(:ast)
+            arel_or_sar_string = arel_or_sar_string.ast
+          end
+
+          if Arel.arel_node?(arel_or_sar_string) && !(String === arel_or_sar_string)
             unless binds.empty?
               raise "Passing bind parameters with an arel AST is forbidden. " \
                 "The values must be stored on the AST directly"
             end
-            sar = visitor.accept(arel_or_sar_string.ast, collector)
+            
+            sar = visitor.accept(arel_or_sar_string, collector)
             [sar.freeze, sar.binds, false]
           else
             [arel_or_sar_string.dup.freeze, binds, false]
           end
         end
         
+        def sar_for_insert(sql, pk, binds, returning)
+          # TODO: when StandardAPI supports returning we can do this; it might
+          # already need to investigate
+          to_sar_and_binds(sql, binds)
+        end
+        
         # This is used in the StatementCache object. It returns an object that
         # can be used to query the database repeatedly.
         def cacheable_query(klass, arel) # :nodoc:
@@ -80,11 +93,26 @@ module ActiveRecord
         def select_all(arel, name = nil, binds = [], preparable: nil, async: false)
           arel = arel_from_relation(arel)
           sar, binds, preparable = to_sar_and_binds(arel, binds, preparable)
-          
+
           select(sar, name, binds, prepare: prepared_statements && preparable, async: async && FutureResult::SelectAll)
+        rescue ::RangeError
+          ActiveRecord::Result.empty(async: async)
+        end
+        
+        # Executes insert +sql+ statement in the context of this connection using
+        # +binds+ as the bind substitutes. +name+ is logged along with
+        # the executed +sql+ statement.
+        # Some adapters support the `returning` keyword argument which allows to control the result of the query:
+        # `nil` is the default value and maintains default behavior. If an array of column names is passed -
+        # the result will contain values of the specified columns from the inserted row.
+        #
+        # TODO: Add support for returning
+        def exec_insert(arel, name = nil, binds = [], pk = nil, sequence_name = nil, returning: nil)
+          sar, binds = sar_for_insert(arel, pk, binds, returning)
+          internal_exec_query(sar, name, binds)
         end
 
-        def exec_query(arel, name = 'SAR', binds = [], prepare: false)
+        def internal_exec_query(arel, name = 'SAR', binds = [], prepare: false, async: false, allow_retry: false, materialize_transactions: true)
           sars = []
           multiple_requests = arel.is_a?(Arel::Collectors::Sunstone)
           type_casted_binds = binds#type_casted_binds(binds)
@@ -112,11 +140,13 @@ module ActiveRecord
             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
-              response = @connection.send_request(sar)
-              if response.is_a?(Net::HTTPNoContent)
-                nil
-              else
-                JSON.parse(response.body)
+              with_raw_connection do |conn|
+                response = conn.send_request(sar)
+                if response.is_a?(Net::HTTPNoContent)
+                  nil
+                else
+                  JSON.parse(response.body)
+                end
               end
             end
           }
@@ -141,21 +171,21 @@ module ActiveRecord
           
           if sars[0].instance_variable_defined?(:@sunstone_calculation) && sars[0].instance_variable_get(:@sunstone_calculation)
             # this is a count, min, max.... yea i know..
-            ActiveRecord::Result.new(['all'], [result], {:all => type_map.lookup('integer', {})})
+            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})
           else
-            ActiveRecord::Result.new(result.keys, [result])
+            ActiveRecord::Result.new(result.keys, [result.values])
           end
         end
         
         def insert(arel, name = nil, pk = nil, id_value = nil, sequence_name = nil, binds = [])
           sar, binds = to_sar_and_binds(arel, binds)
           value = exec_insert(sar, name, binds, pk, sequence_name)
+
+          return returning_column_values(value) unless returning.nil?
+
           id_value || last_inserted_id(value)
-          
-          # value = exec_insert(arel, name, binds, pk, sequence_name)
-          # id_value || last_inserted_id(value)
         end
         
         def update(arel, name = nil, binds = [])
@@ -171,6 +201,10 @@ module ActiveRecord
           row && row['id']
         end
 
+        def returning_column_values(result)
+          result.rows.first
+        end
+
       end
     end
   end

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

@@ -27,8 +27,7 @@ module ActiveRecord
             return @definitions[table_name]
           end
 
-          response = @connection.get("/#{table_name}/schema")
-
+          response = with_raw_connection { |conn| conn.get("/#{table_name}/schema") }
           @definitions[table_name] = JSON.parse(response.body)
         rescue ::Sunstone::Exception::NotFound
           raise ActiveRecord::StatementInvalid, "Table \"#{table_name}\" does not exist"
@@ -40,7 +39,9 @@ module ActiveRecord
         #  - format_type includes the column size constraint, e.g. varchar(50)
         #  - ::regclass is a function that gives the id for a table name
         def column_definitions(table_name) # :nodoc:
-          definition(table_name)['columns']
+          # TODO: settle on schema, I think we've switched to attributes, so
+          # columns can be removed soon?
+          definition(table_name)['attributes'] || definition(table_name)['columns']
         end
 
         # Returns the limit definition of the table (the maximum limit that can
@@ -50,7 +51,7 @@ module ActiveRecord
         end
 
         def tables
-          JSON.parse(@connection.get('/tables').body)
+          JSON.parse(with_raw_connection { |conn| conn.get('/tables').body })
         end
 
         def views
@@ -63,7 +64,7 @@ module ActiveRecord
         end
 
         def lookup_cast_type(options)
-          type_map.lookup(options['type'], options.symbolize_keys)
+          @type_map.lookup(options['type'], options.symbolize_keys)
         end
 
         def fetch_type_metadata(options)

data/lib/active_record/connection_adapters/sunstone/type/binary.rb

@@ -13,11 +13,11 @@ module ActiveRecord
           #
           # +value+ The raw input, as provided from the database.
           def deserialize(value)
-            value.nil? ? nil : Base64.strict_decode64(value)            
+            value.nil? ? nil : Base64.strict_decode64(value)
           end
           
-          # Casts a value from the ruby type to a type that the database knows how
-          # to understand. The returned value from this method should be a
+          # Casts a value from the ruby type to a type that the database knows
+          # how to understand. The returned value from this method should be a
           # +String+, +Numeric+, +Date+, +Time+, +Symbol+, +true+, +false+, or
           # +nil+.
           def serialize(value)

data/lib/active_record/connection_adapters/sunstone_adapter.rb

@@ -17,27 +17,14 @@ require 'active_record/connection_adapters/sunstone/type/json'
 module ActiveRecord
   module ConnectionHandling # :nodoc:
 
-    VALID_SUNSTONE_CONN_PARAMS = [:url, :host, :port, :api_key, :use_ssl, :user_agent, :ca_cert]
-
+    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)
-      conn_params = config.symbolize_keys
-      conn_params.delete_if { |_, v| v.nil? }
-
-      if conn_params[:url]
-        uri = URI.parse(conn_params.delete(:url))
-        conn_params[:api_key] ||= (uri.user ? CGI.unescape(uri.user) : nil)
-        conn_params[:host]    ||= uri.host
-        conn_params[:port]    ||= uri.port
-        conn_params[:use_ssl] ||= (uri.scheme == 'https')
-      end
-
-      # Forward only valid config params to Sunstone::Connection
-      conn_params.slice!(*VALID_SUNSTONE_CONN_PARAMS)
-
-      client = ::Sunstone::Connection.new(conn_params)
-      ConnectionAdapters::SunstoneAPIAdapter.new(client, logger, conn_params, config)
+      sunstone_adapter_class.new(config)
     end
   end
 
@@ -54,6 +41,7 @@ module ActiveRecord
     #   <encoding></tt> call on the connection.
     class SunstoneAPIAdapter < AbstractAdapter
       ADAPTER_NAME = 'Sunstone'.freeze
+      VALID_SUNSTONE_CONN_PARAMS = [:url, :host, :port, :api_key, :use_ssl, :user_agent, :ca_cert]
 
       NATIVE_DATABASE_TYPES = {
         string:      { name: "string" },
@@ -61,6 +49,12 @@ module ActiveRecord
         json:        { name: "json" },
         boolean:     { name: "boolean" }
       }
+      
+      class << self
+        def new_client(conn_params)
+          ::Sunstone::Connection.new(conn_params)
+        end
+      end
 
       # include PostgreSQL::Quoting
       # include PostgreSQL::ReferentialIntegrity
@@ -72,35 +66,66 @@ module ActiveRecord
       def supports_statement_cache?
         false
       end
+      
+      def default_prepared_statements
+        false
+      end
 
-      def clear_cache!
+      def clear_cache!(new_connection: false)
         # TODO move @definitions to using @schema_cache
         @definitions = {}
       end
 
       # Initializes and connects a SunstoneAPI adapter.
-      def initialize(connection, logger, connection_parameters, config)
-        super(connection, logger, config.reverse_merge(prepared_statements: false))
+      def initialize(...)
+        super
 
-        @prepared_statement_status = Concurrent::ThreadLocalVar.new(false)
-        @connection_parameters = connection_parameters
+        conn_params = @config.compact
+        if conn_params[:url]
+          uri = URI.parse(conn_params.delete(:url))
+          conn_params[:api_key] ||= (uri.user ? CGI.unescape(uri.user) : nil)
+          conn_params[:host]    ||= uri.host
+          conn_params[:port]    ||= uri.port
+          conn_params[:use_ssl] ||= (uri.scheme == 'https')
+        end
 
-        @type_map = Type::HashLookupTypeMap.new
-        initialize_type_map(@type_map)
+        # Forward only valid config params to Sunstone::Connection
+        conn_params.slice!(*VALID_SUNSTONE_CONN_PARAMS)
+
+        @connection_parameters = conn_params
+
+        @max_identifier_length = nil
+        @type_map = nil
+        @raw_connection = nil
+      end
+
+      def url(path=nil)
+        "http#{@connection_parameters[:use_ssl] ? 's' : ''}://#{@connection_parameters[:host]}#{@connection_parameters[:port] != 80 ? (@connection_parameters[:port] == 443 && @connection_parameters[:use_ssl] ? '' : ":#{@connection_parameters[:port]}") : ''}#{path}"
       end
 
       def active?
-        @connection.active?
+        @raw_connection&.active?
       end
 
-      def reconnect!
+      def load_type_map
+        @type_map = Type::HashLookupTypeMap.new
+        initialize_type_map(@type_map)
+      end
+      
+      def reconnect
         super
-        @connection.reconnect!
+        @raw_connection&.reconnect!
       end
 
       def disconnect!
         super
-        @connection.disconnect!
+        @raw_connection&.disconnect!
+        @raw_connection = nil
+      end
+
+      def discard! # :nodoc:
+        super
+        @raw_connection = nil
       end
 
       # Executes the delete statement and returns the number of rows affected.
@@ -134,11 +159,17 @@ module ActiveRecord
       end
 
       def server_config
-        JSON.parse(@connection.get("/configuration").body)
+        with_raw_connection do |conn|
+          JSON.parse(conn.get("/configuration").body)
+        end
+      end
+
+      def return_value_after_insert?(column) # :nodoc:
+        column.auto_populated?
       end
 
       def lookup_cast_type_from_column(column) # :nodoc:
-        cast_type = type_map.lookup(column.sql_type, {
+        cast_type = @type_map.lookup(column.sql_type, {
           limit: column.limit,
           precision: column.precision,
           scale: column.scale
@@ -167,55 +198,63 @@ module ActiveRecord
         true
       end
 
-      # Executes an INSERT query and returns the new record's ID
-      #
-      # +id_value+ will be returned unless the value is nil, in
-      # which case the database will attempt to calculate the last inserted
-      # id and return that value.
-      #
-      # If the next id was calculated in advance (as in Oracle), it should be
-      # passed in as +id_value+.
-      def insert(arel, name = nil, pk = nil, id_value = nil, sequence_name = nil, binds = [])
-        exec_insert(arel, name, binds, pk, sequence_name)
+      # Executes an INSERT query and returns a hash of the object and
+      # any updated relations. This is different from AR which returns an ID
+      def insert(arel, name = nil, pk = nil, id_value = nil, sequence_name = nil, binds = [], returning: nil)
+        exec_insert(arel, name, binds, pk, sequence_name, returning: returning)
       end
       alias create insert
 
-      def reload_type_map
-        type_map.clear
-        initialize_type_map
+      # 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
 
-      private
+      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
+        reload_type_map
+      end
 
-      def type_map
-        @type_map ||= Type::HashLookupTypeMap.new.tap do |mapping|
-          initialize_type_map(mapping)
+      def reload_type_map
+        if @type_map
+          type_map.clear
+        else
+          @type_map = Type::HashLookupTypeMap.new
         end
+
+        initialize_type_map
       end
+
+      private
       
-      def initialize_type_map(m = type_map)
-        self.class.initialize_type_map(m)
-        load_additional_types
+      def initialize_type_map(m = nil)
+        self.class.initialize_type_map(m || @type_map)
       end
 
-      def initialize_type_map(m) # :nodoc:
-        m.register_type 'boolean',    Type::Boolean.new
-        m.register_type 'string' do |_, options|
-          Type::String.new(**options.slice(:limit))
-        end
-        m.register_type 'integer' do |_, options|
-          Type::Integer.new(**options.slice(:limit))
+      def self.initialize_type_map(m) # :nodoc:
+        m.register_type               'boolean',    Type::Boolean.new
+        m.register_type               'binary'      do |_, options|
+          Sunstone::Type::Binary.new(**options.slice(:limit))
         end
-        m.register_type 'decimal' do |_, options|
+        m.register_type               'datetime',   Sunstone::Type::DateTime.new
+        m.register_type               'decimal'     do |_, options|
           Type::Decimal.new(**options.slice(:precision, :scale))
         end
-        m.register_type 'binary' do |_, options|
-          Sunstone::Type::Binary.new(**options.slice(:limit))
+        m.register_type               'integer'     do |_, options|
+          Type::Integer.new(**options.slice(:limit))
         end
-
-        m.register_type 'datetime',   Sunstone::Type::DateTime.new
-        m.register_type 'json',       Sunstone::Type::Json.new
-        m.register_type 'uuid',       Sunstone::Type::Uuid.new
+        m.register_type               'json',       Sunstone::Type::Json.new
+        m.register_type               'string'      do |_, options|
+          Type::String.new(**options.slice(:limit))
+        end
+        m.register_type               'uuid',       Sunstone::Type::Uuid.new
 
         if defined?(Sunstone::Type::EWKB)
           m.register_type 'ewkb',       Sunstone::Type::EWKB.new

data/lib/arel/visitors/sunstone.rb

@@ -3,24 +3,24 @@ require 'arel/visitors/visitor'
 module Arel
   module Visitors
     class Sunstone < Arel::Visitors::Visitor
-      
+
       def compile(node, collector = Arel::Collectors::Sunstone.new)
         accept(node, collector).value
       end
-      
+
       private
-      
+
       def visit_Arel_Nodes_SelectStatement o, collector
         collector.table = o.cores.first.source.left.name
 
         collector = o.cores.inject(collector) { |c,x|
           visit_Arel_Nodes_SelectCore(x, c)
         }
-        
+
         if !o.orders.empty?
           collector.order = o.orders.map { |x| visit(x, collector) }
         end
-        
+
         collector = maybe_visit o.limit, collector
         collector = maybe_visit o.offset, collector
         collector = maybe_visit o.eager_load, collector
@@ -61,27 +61,36 @@ module Arel
         collector.request_type  = Net::HTTP::Post
         collector.table         = o.relation.name
         collector.operation     = :insert
-        
+
         if o.values
           if o.values.is_a?(Arel::Nodes::SqlLiteral) && o.values == 'DEFAULT VALUES'
             collector.updates = {}
           else
-            collector.updates = {}
-            
-            o.columns.map(&:name).zip(o.values.expr.first).to_h.each do |k, v|
-              collector.updates[k] = case v
-              when Nodes::SqlLiteral, Nodes::BindParam, ActiveModel::Attribute
-                visit(v, collector)
-              else
-                v
-              end
-            end
+            values = visit(o.values, collector)
+            collector.updates = o.columns.map(&:name).zip(values).to_h
           end
         end
-        
+
         collector
       end
-      
+
+      def visit_Arel_Nodes_ValuesList o, collector
+        o.rows[0].map do |v|
+          visit_subrelation v, collector
+        end
+      end
+
+      def visit_subrelation v, collector
+        case v
+        when Array
+          v.map { |v2| visit_subrelation v2, collector }
+        when Hash
+          v.transform_values { |v2| visit_subrelation v2, collector }
+        else
+          visit(v, collector)
+        end
+      end
+
       def find_bottom(hash)
         if hash.is_a?(Hash)
           if hash.values.first.is_a?(Array) || hash.values.first.is_a?(Hash)
@@ -98,10 +107,10 @@ module Arel
           end
         end
       end
-      
+
       def add_to_bottom_of_hash_or_array(hash, value)
         hash = find_bottom(hash)
-        
+
         if hash.is_a?(Hash)
           nkey = hash.keys.first
           nvalue = hash.values.first
@@ -147,26 +156,26 @@ module Arel
       #
       def visit_Arel_Nodes_UpdateStatement o, collector
         collector.request_type  = Net::HTTP::Patch
-        
+
         collector.table = o.relation.name
         collector.operation     = :update
-        
+
         # collector.id = o.wheres.first.children.first.right
         if !o.wheres.empty?
           collector.where = o.wheres.map { |x| visit(x, collector) }.inject([]) { |c, w|
             w.is_a?(Array) ? c += w : c << w
           }
         end
-        
+
         if collector.where.size != 1 && collector.where.first.size != 1 && !collector.where.first['id']
           raise 'Upsupported'
         end
-        
+
         collector.where = collector.where.first
-        
+
         if o.values
           collector.updates = {}
-          
+
           o.values.map { |x| visit(x, collector) }.each do |value|
             value.each do |key, v|
               if key.is_a?(Hash)
@@ -191,7 +200,7 @@ module Arel
             end
           end
         end
-        
+
         collector
       end
       #
@@ -426,7 +435,7 @@ module Arel
       def visit_Arel_Nodes_Descending o, collector
         { visit(o.expr, collector) => :desc }
       end
-      
+
       def visit_Arel_Nodes_RandomOrdering o, collector
         :random
       end
@@ -468,7 +477,7 @@ module Arel
       #
       def visit_Arel_Nodes_Count o, collector
         collector.operation = :calculate
-        
+
         collector.columns   ||= []
         collector.columns   << {:count => (o.expressions.first.is_a?(Arel::Attributes::Attribute) ? o.expressions.first.name : o.expressions.first) }
         # collector.columns   = visit o.expressions.first, collector
@@ -476,7 +485,7 @@ module Arel
 
       def visit_Arel_Nodes_Sum o, collector
         collector.operation = :calculate
-        
+
         collector.columns   ||= []
         collector.columns   << {:sum => (o.expressions.first.is_a?(Arel::Attributes::Attribute) ? o.expressions.first.name : o.expressions.first) }
         # collector.columns   = visit o.expressions.first, collector
@@ -484,7 +493,7 @@ module Arel
 
       def visit_Arel_Nodes_Max o, collector
         collector.operation = :calculate
-        
+
         collector.columns   ||= []
         if o.expressions.first.is_a?(Arel::Attributes::Attribute)
           relation = o.expressions.first.relation
@@ -686,11 +695,11 @@ module Arel
         end
       end
       alias_method :visit_Arel_Nodes_HomogeneousIn, :visit_Arel_Nodes_In
-      
+
       def visit_Arel_Nodes_NotIn o, collector
         key = visit(o.left, collector)
         value = {not_in: visit(o.right, collector)}
-        
+
         if hash.is_a?(Hash)
           add_to_bottom_of_hash_or_array(key, value)
           key
@@ -698,10 +707,10 @@ module Arel
           {key => value}
         end
       end
-      
+
       # You merge a into b if a keys do not colid with b keys
       def mergeable?(hash_a, hash_b)
-        
+
         hash_a.each do |key, value_a|
           #TODO: one day maybe just use symbols for all keys?
           if hash_b.has_key?(key.to_sym) || hash_b.has_key?(key.to_s)
@@ -715,7 +724,7 @@ module Arel
         end
         true
       end
-      
+
       def visit_Arel_Nodes_And o, collector
         ors = []
 
@@ -730,16 +739,16 @@ module Arel
             ors << value
           end
         end
-        
+
         result = []
         ors.each_with_index do |c, i|
           result << c
           result << 'AND' if ors.size != i + 1
         end
-        
+
         result.size == 1 ? result.first : result
       end
-      
+
       def visit_Arel_Nodes_Or o, collector
         [visit(o.left, collector), 'OR', visit(o.right, collector)]
       end
@@ -748,10 +757,12 @@ module Arel
         case o.left
         when Arel::Nodes::UnqualifiedColumn
           case o.right
-          when Arel::Attributes::Attribute, Arel::Nodes::BindParam, ActiveModel::Attribute
-            { visit(o.left.expr, collector) => visit(o.right, collector) }
+          when Array
+            { visit(o.left.expr, collector) => o.right.map { |i| i.transform_values { |v| visit(v, collector) } } }
+          when Hash
+            { visit(o.left.expr, collector) => o.right.transform_values { |v| visit(v, collector) } }
           else
-            { visit(o.left.expr, collector) => o.right }
+            { visit(o.left.expr, collector) => visit(o.right, collector) }
           end
         when Arel::Attributes::Attribute, Arel::Nodes::BindParam, ActiveModel::Attribute
           { visit(o.left, collector) => visit(o.right, collector) }
@@ -770,7 +781,7 @@ module Arel
         okey.merge!(value)
         hash
       end
-      
+
       def add_to_bottom_of_hash(hash, value)
         okey = hash
         while okey.is_a?(Hash) && (okey.values.first.is_a?(Hash) || okey.values.first.is_a?(Array))
@@ -785,11 +796,11 @@ module Arel
         okey[nkey] = { nvalue => value }
         hash
       end
-      
+
       def visit_Arel_Nodes_Equality o, collector
         key = visit(o.left, collector)
         value = (o.right.nil? ? nil : visit(o.right, collector))
-        
+
         if key.is_a?(Hash)
           add_to_bottom_of_hash(key, {eq: value})
         elsif o.left.class.name == 'Arel::Attributes::Key'
@@ -798,7 +809,7 @@ module Arel
           { key => value }
         end
       end
-      
+
       def visit_Arel_Nodes_TSMatch(o, collector)
         key = visit(o.left, collector)
         value = { ts_match: (o.right.nil? ? nil : visit(o.right, collector)) }
@@ -814,11 +825,11 @@ module Arel
           hash
         end
       end
-      
+
       def visit_Arel_Nodes_TSVector(o, collector)
         visit(o.attribute, collector)
       end
-      
+
       def visit_Arel_Nodes_TSQuery(o, collector)
         if o.language
           [visit(o.expression, collector), visit(o.language, collector)]
@@ -826,11 +837,11 @@ module Arel
           visit(o.expression, collector)
         end
       end
-      
+
       def visit_Arel_Nodes_HasKey o, collector
         key = visit(o.left, collector)
         value = {has_key: (o.right.nil? ? nil : o.right.to_s)}
-        
+
         if key.is_a?(Hash)
           okey = key
           while okey.values.first.is_a?(Hash)
@@ -847,7 +858,7 @@ module Arel
       def visit_Arel_Nodes_HasKeys o, collector
         key = visit(o.left, collector)
         value = { has_keys: visit(o.right, collector) }
-        
+
         if key.is_a?(Hash)
           okey = key
           while okey.values.first.is_a?(Hash)
@@ -864,7 +875,7 @@ module Arel
       def visit_Arel_Nodes_HasAnyKey o, collector
         key = visit(o.left, collector)
         value = { has_any_key: visit(o.right, collector) }
-        
+
         if key.is_a?(Hash)
           okey = key
           while okey.values.first.is_a?(Hash)
@@ -894,11 +905,11 @@ module Arel
       def visit_Arel_Nodes_UnqualifiedColumn o, collector
         o.name
       end
-      
+
       def visit_Arel_Attributes_Cast(o, collector)
         visit(o.relation, collector) # No casting yet
       end
-      
+
       def visit_Arel_Attributes_Key o, collector
         "#{visit(o.relation, collector)}.#{o.name}"
       end
@@ -938,7 +949,7 @@ module Arel
       # def visit_Arel_Attributes_EmptyRelation o, collector, top=true
       #   o.for_write ? "#{o.name}_attributes" : o.name
       # end
-      
+
       def visit_Arel_Attributes_Attribute o, collector
         join_name = o.relation.table_alias || o.relation.name
 
@@ -963,7 +974,7 @@ module Arel
           o.value_for_database
         end
       end
-      
+
       def visit_Arel_Nodes_BindParam o, collector
         a = collector.add_bind(o.value)
         o.is_a?(Arel::Nodes::BindParam) ? o : a
@@ -1060,11 +1071,11 @@ module Arel
           collector
         end
       end
-      
+
       def maybe_visit thing, collector
         return collector unless thing
         visit thing, collector
       end
     end
   end
-end
+end

data/lib/sunstone/connection.rb

@@ -4,7 +4,7 @@
 module Sunstone
   class Connection
 
-    attr_reader :api_key, :host, :port, :use_ssl
+    attr_reader :api_key, :host, :port, :use_ssl, :prefix
 
     # Initialize a connection a Sunstone API server.
     #
@@ -31,7 +31,7 @@ module Sunstone
         self.instance_variable_set(:"@#{key}", config[key])
       end
 
-      @connection = Net::HTTP.new(host, port)
+      @connection = Net::HTTP.new(host, port || (use_ssl ? 443 : 80))
       @connection.max_retries         = 0
       @connection.open_timeout        = 5
       @connection.read_timeout        = 30
@@ -142,7 +142,7 @@ module Sunstone
           message << "  #{request.method} #{path_and_query[0]}"
           if path_and_query[1]
             if request['Query-Encoding'] == 'application/msgpack'
-              message << " " << MessagePack.unpack(CGI.unescape(path_and_query[1]))
+              message << " " << MessagePack.unpack(CGI.unescape(path_and_query[1])).inspect
             else
               message << " " << CGI.unescape(path_and_query[1])
             end

data/lib/sunstone/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sunstone
 version: !ruby/object:Gem::Version
-  version: 7.0.0
+  version: 7.1.0.1
 platform: ruby
 authors:
 - Jon Bracy
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-12-07 00:00:00.000000000 Z
+date: 2023-12-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -184,14 +184,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 7.0.0
+        version: 7.1.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 7.0.0
+        version: 7.1.0
 - !ruby/object:Gem::Dependency
   name: msgpack
   requirement: !ruby/object:Gem::Requirement
@@ -226,42 +226,42 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 7.0.0
+        version: 7.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 7.0.0
+        version: 7.1.0
 - !ruby/object:Gem::Dependency
   name: arel-extensions
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 6.1.0
+        version: 7.0.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 6.1.0
+        version: 7.0.1
 - !ruby/object:Gem::Dependency
   name: activerecord-filter
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 6.1.0
+        version: 7.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 6.1.0
+        version: 7.0.0
 description: A library for interacting with REST APIs. Similar to ActiveResource
 email:
 - jonbracy@gmail.com
@@ -323,7 +323,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.22
+rubygems_version: 3.4.13
 signing_key:
 specification_version: 4
 summary: A library for interacting with REST APIs