sunstone 6.0.0.4 → 6.1.0.1

data/ext/arel/nodes/select_statement.rb

@@ -4,7 +4,7 @@ module Arel
 
       attr_accessor :eager_load
 
-      def initialize cores = [SelectCore.new]
+      def initialize(cores = [SelectCore.new])
         super()
         @cores          = cores
         @orders         = []

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

@@ -2,8 +2,7 @@ module ActiveRecord
   module ConnectionAdapters
     # Sunstone-specific extensions to column definitions in a table.
     class SunstoneColumn < Column #:nodoc:
-      delegate :array, to: :sql_type_metadata
-      alias :array? :array
+      attr_reader :array
       
       def initialize(name, sql_type_metadata, options={})
         @name = name.freeze
@@ -14,6 +13,7 @@ module ActiveRecord
         @collation = nil
         @table_name = nil
         @primary_key = (options['primary_key'] == true)
+        @array = options['array']
       end
       
       def primary_key?

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

@@ -47,15 +47,15 @@ module ActiveRecord
         # can be used to query the database repeatedly.
         def cacheable_query(klass, arel) # :nodoc:
           if prepared_statements
-            sql, binds = visitor.accept(arel.ast, collector).value
+            sql, binds = visitor.compile(arel.ast, collector)
             query = klass.query(sql)
           elsif self.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
             collector = SunstonePartialQueryCollector.new(self.collector)
-            parts, binds = visitor.accept(arel.ast, collector).value
+            parts, binds = visitor.compile(arel.ast, collector)
             query = StatementCache::PartialQuery.new(parts, true)
           else
-            collector = PartialQueryCollector.new
-            parts, binds = visitor.accept(arel.ast, collector).value
+            collector = klass.partial_query_collector
+            parts, binds = visitor.compile(arel.ast, collector)
             query = klass.partial_query(parts)
           end
           [query, binds]
@@ -142,7 +142,7 @@ 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

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

@@ -31,7 +31,11 @@ module ActiveRecord
 
           version = Gem::Version.create(response['StandardAPI-Version'] || '5.0.0.4')
 
-          @definitions[table_name] = if (version >= Gem::Version.create('5.0.0.5'))
+          @definitions[table_name] = if (version >= Gem::Version.create('6.0.0.29'))
+            schema = JSON.parse(response.body)
+            schema['columns'] = schema.delete('attributes')
+            schema
+          elsif (version >= Gem::Version.create('5.0.0.5'))
             JSON.parse(response.body)
           else
             { 'columns' => JSON.parse(response.body), 'limit' => nil }
@@ -46,7 +50,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']
+          # First check for attributes and then for the deprecated columns field
+          # TODO: Remove after 0.3
+          definition(table_name)['attributes'] || definition(table_name)['columns']
         end
 
         # Returns the limit definition of the table (the maximum limit that can
@@ -58,28 +64,32 @@ module ActiveRecord
         def tables
           JSON.parse(@connection.get('/tables').body)
         end
-        
+
         def views
           []
         end
-        
+
         def new_column(name, options)
           sql_type_metadata = fetch_type_metadata(options)
           SunstoneColumn.new(name, sql_type_metadata, options)
         end
-        
+
+        def lookup_cast_type(options)
+          type_map.lookup(options['type'], options.symbolize_keys)
+        end
+
         def fetch_type_metadata(options)
-          cast_type = lookup_cast_type(options['type'])
+          cast_type = lookup_cast_type(options)
           simple_type = SqlTypeMetadata.new(
             sql_type: options['type'],
             type: cast_type.type,
             limit: cast_type.limit,
             precision: cast_type.precision,
-            scale: cast_type.scale,
+            scale: cast_type.scale
           )
           SunstoneSQLTypeMetadata.new(simple_type, options)
         end
-        
+
         def column_name_for_operation(operation, node) # :nodoc:
           visitor.accept(node, collector).first[operation.to_sym]
         end

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

@@ -0,0 +1,34 @@
+require 'base64'
+
+module ActiveRecord
+  module ConnectionAdapters
+    module Sunstone
+      module Type
+        class Binary < ActiveRecord::Type::Binary
+          
+          # Converts a value from database input to the appropriate ruby type. The
+          # return value of this method will be returned from
+          # ActiveRecord::AttributeMethods::Read#read_attribute. The default
+          # implementation just calls Value#cast.
+          #
+          # +value+ The raw input, as provided from the database.
+          def deserialize(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
+          # +String+, +Numeric+, +Date+, +Time+, +Symbol+, +true+, +false+, or
+          # +nil+.
+          def serialize(value)
+            if limit && value.bytesize > limit
+              raise ActiveModel::RangeError, "value is out of range for #{self.class} with limit #{limit} bytes"
+            end
+            Base64.strict_encode64(value)
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/sunstone_adapter.rb

@@ -1,6 +1,7 @@
 require 'active_record/connection_adapters/abstract_adapter'
 
-#require 'active_record/connection_adapters/statement_pool'
+require 'arel/nodes/relation'
+require 'arel/visitors/to_sql_extensions'
 
 require 'active_record/connection_adapters/sunstone/database_statements'
 require 'active_record/connection_adapters/sunstone/schema_statements'
@@ -9,6 +10,7 @@ require 'active_record/connection_adapters/sunstone/column'
 
 require 'active_record/connection_adapters/sunstone/type/date_time'
 require 'active_record/connection_adapters/sunstone/type/array'
+require 'active_record/connection_adapters/sunstone/type/binary'
 require 'active_record/connection_adapters/sunstone/type/uuid'
 require 'active_record/connection_adapters/sunstone/type/json'
 
@@ -30,7 +32,7 @@ module ActiveRecord
         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)
 
@@ -78,9 +80,9 @@ module ActiveRecord
 
       # Initializes and connects a SunstoneAPI adapter.
       def initialize(connection, logger, connection_parameters, config)
-        super(connection, logger, config)
+        super(connection, logger, config.reverse_merge(prepared_statements: false))
 
-        @prepared_statements = false
+        @prepared_statement_status = Concurrent::ThreadLocalVar.new(false)
         @connection_parameters = connection_parameters
 
         # @type_map = Type::HashLookupTypeMap.new
@@ -95,12 +97,12 @@ module ActiveRecord
         super
         @connection.reconnect!
       end
-      
+
       def disconnect!
         super
         @connection.disconnect!
       end
-      
+
       # Executes the delete statement and returns the number of rows affected.
       def delete(arel, name = nil, binds = [])
         r = exec_delete(arel, name, binds)
@@ -122,27 +124,28 @@ module ActiveRecord
       def update_table_definition(table_name, base) #:nodoc:
         SunstoneAPI::Table.new(table_name, base)
       end
-      
+
       def arel_visitor
         Arel::Visitors::Sunstone.new
       end
-      
+
       def collector
         Arel::Collectors::Sunstone.new
       end
-      
+
       def server_config
         JSON.parse(@connection.get("/configuration").body)
       end
-      
+
       def lookup_cast_type_from_column(column) # :nodoc:
-        if column.array
-          Sunstone::Type::Array.new(type_map.lookup(column.sql_type))
-        else
-          type_map.lookup(column.sql_type)
-        end
+        cast_type = type_map.lookup(column.sql_type, {
+          limit: column.limit,
+          precision: column.precision,
+          scale: column.scale
+        })
+        column.array ? Sunstone::Type::Array.new(cast_type) : cast_type
       end
-      
+
       def transaction(requires_new: nil, isolation: nil, joinable: true)
         Thread.current[:sunstone_transaction_count] ||= 0
         Thread.current[:sunstone_request_sent] = nil if Thread.current[:sunstone_transaction_count] == 0
@@ -159,7 +162,7 @@ module ActiveRecord
       rescue ActiveRecord::Rollback
         # rollbacks are silently swallowed
       end
-      
+
       def supports_json?
         true
       end
@@ -176,33 +179,43 @@ module ActiveRecord
         exec_insert(arel, name, binds, pk, sequence_name)
       end
       alias create insert
-      
+
       # Should be the defuat insert, but rails escapes if for SQL so we'll just
       # catch the string "DEFATUL VALUES" in the visitor
       # def empty_insert_statement_value
       #   {}
       # end
-      
+
       private
 
       def initialize_type_map(m) # :nodoc:
         m.register_type 'boolean',    Type::Boolean.new
-        m.register_type 'string',     Type::String.new
-        m.register_type 'integer',    Type::Integer.new
-        m.register_type 'decimal',    Type::Decimal.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))
+        end
+        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))
+        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
-          
+
         if defined?(Sunstone::Type::EWKB)
           m.register_type 'ewkb',       Sunstone::Type::EWKB.new
         end
       end
 
-      def create_table_definition(name, temporary, options, as = nil) # :nodoc:
-        SunstoneAPI::TableDefinition.new native_database_types, name, temporary, options, as
+      def create_table_definition(name, **options)
+        SunstoneAPI::TableDefinition.new(self, name, **options)
       end
-        
+
       ActiveRecord::Type.add_modifier({ array: true }, Sunstone::Type::Array, adapter: :sunstone)
       # ActiveRecord::Type.add_modifier({ range: true }, OID::Range, adapter: :postgresql)
     end

data/lib/arel/visitors/sunstone.rb

@@ -1,19 +1,13 @@
 require 'arel/visitors/visitor'
-class Arel::Visitors::Dot
-  def visit_Arel_Nodes_Casted o
-    # collector << quoted(o.val, o.attribute).to_s
-    visit_String o.val
-  end
-end
 
 module Arel
   module Visitors
     class Sunstone < Arel::Visitors::Visitor
       
-      def compile node, &block
-        accept(node, Arel::Collectors::SQLString.new, &block).value
+      def compile(node, collector = Arel::Collectors::Sunstone.new)
+        accept(node, collector).value
       end
-
+      
       def preparable
         false
       end
@@ -67,28 +61,6 @@ module Arel
         collector
       end
 
-      def visit_Arel_Nodes_Overlaps o, collector
-        key = visit(o.left, collector)
-        value = { overlaps: visit(o.right, collector) }
-        if key.is_a?(Hash)
-          add_to_bottom_of_hash_or_array(key, value)
-          key
-        else
-          {key => value}
-        end
-      end
-
-      def visit_Arel_Nodes_NotOverlaps o, collector
-        key = visit(o.left, collector)
-        value = { not_overlaps: visit(o.right, collector) }
-        if key.is_a?(Hash)
-          add_to_bottom_of_hash_or_array(key, value)
-          key
-        else
-          {key => value}
-        end
-      end
-
       def visit_Arel_Nodes_InsertStatement o, collector
         collector.request_type  = Net::HTTP::Post
         collector.table         = o.relation.name
@@ -255,7 +227,7 @@ module Arel
       #
       def visit_Arel_Nodes_Casted o, collector
         # collector << quoted(o.val, o.attribute).to_s
-        o.val
+        o.value
       end
 
       def visit_Arel_Nodes_Quoted o, collector
@@ -947,9 +919,12 @@ module Arel
         value = if o.relation.is_a?(Arel::Attributes::Relation)
           { o.name => visit_Arel_Attributes_Relation(o.relation, collector, false) }
         else
-          visit(o.relation, collector)
+          if o.relation.is_a?(Arel::Attributes::Attribute)
+            { o.name => o.relation.name }
+          else
+            visit(o.relation, collector)
+          end
         end
-        # value = value.to_s.split('.').last if !value.is_a?(Hash)
 
         if o.collection
           ary = []
@@ -972,9 +947,9 @@ module Arel
         end
       end
 
-      def visit_Arel_Attributes_EmptyRelation o, collector, top=true
-        o.for_write ? "#{o.name}_attributes" : o.name
-      end
+      # 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

data/lib/sunstone.rb

@@ -35,7 +35,20 @@ require File.expand_path(File.join(__FILE__, '../../ext/active_support/core_ext/
 
 require File.expand_path(File.join(__FILE__, '../../ext/arel/select_manager'))
 require File.expand_path(File.join(__FILE__, '../../ext/arel/nodes/eager_load'))
-require File.expand_path(File.join(__FILE__, '../../ext/arel/attributes/relation'))
 require File.expand_path(File.join(__FILE__, '../../ext/arel/attributes/empty_relation'))
 require File.expand_path(File.join(__FILE__, '../../ext/arel/nodes/select_statement'))
-require File.expand_path(File.join(__FILE__, '../../ext/active_record/finder_methods'))
+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
+  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

data/lib/sunstone/connection.rb

@@ -348,7 +348,7 @@ module Sunstone
       headers = Thread.current[:sunstone_headers]&.clone || {}
       headers['Accept'] = 'application/json'
       headers['User-Agent'] = user_agent
-      headers['Api-Version'] = '0.1.0'
+      headers['Api-Version'] = '0.2.0'
       headers['Connection'] = 'keep-alive'
       
       request_api_key = Thread.current[:sunstone_api_key] || api_key

data/lib/sunstone/version.rb

@@ -1,3 +1,3 @@
 module Sunstone
-  VERSION = '6.0.0.4'
+  VERSION = '6.1.0.1'
 end

data/sunstone.gemspec

@@ -30,10 +30,11 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'rgeo'
   s.add_development_dependency 'simplecov'
   s.add_development_dependency 'byebug'
-  s.add_development_dependency 'activesupport', '>= 6.0.0.rc1'
+  s.add_development_dependency 'activesupport', '>= 6.1.0'
   
   # Runtime
   s.add_runtime_dependency 'msgpack'
   s.add_runtime_dependency 'cookie_store'
-  s.add_runtime_dependency 'activerecord', '>= 6.0.0.rc1'
+  s.add_runtime_dependency 'activerecord', '>= 6.1.0'
+  s.add_runtime_dependency 'arel-extensions', '>= 6.1.0'
 end

data/test/active_record/persistance_test.rb

@@ -11,9 +11,10 @@ class ActiveRecord::PersistanceTest < ActiveSupport::TestCase
     create_table "fleets" do |t|
       t.string   "name",                    limit: 255
     end
-    
+
     create_table "sailors" do |t|
       t.string   "name",                    limit: 255
+      t.text     "assignment"
     end
 
     create_table "sailors_ships", id: false do |t|
@@ -22,7 +23,7 @@ class ActiveRecord::PersistanceTest < ActiveSupport::TestCase
     end
 
   end
-  
+
   class Fleet < ActiveRecord::Base
     has_many :ships
   end
@@ -36,16 +37,19 @@ class ActiveRecord::PersistanceTest < ActiveSupport::TestCase
   class Sailor < ActiveRecord::Base
     has_and_belongs_to_many :ships
   end
-  
+
   class TestModelA < ActiveRecord::Base
   end
-  
+
   class TestModelB < ActiveRecord::Base
     before_save do
       TestModelA.create
     end
   end
 
+  class TestModelC < ActiveRecord::Base
+  end
+
   test '#create with errors' do
     req_stub = webmock(:post, "/fleets").with(
       body: { fleet: {} }.to_json
@@ -71,7 +75,7 @@ class ActiveRecord::PersistanceTest < ActiveSupport::TestCase
     assert_requested req_stub
   end
 
-  test '#save w/o changes' do
+  test '#save w/o changes does not trigger a request' do
     webmock(:get, '/fleets', where: {id: 1}, limit: 1).to_return(
       body: [{id: 1, name: 'Armada Duo'}].to_json
     )
@@ -82,9 +86,30 @@ class ActiveRecord::PersistanceTest < ActiveSupport::TestCase
     assert fleet.save
     assert_equal 1, fleet.id
     assert_equal 'Armada Duo', fleet.name
+    
+    
+    webmock(:get, '/sailors', where: {id: 1}, limit: 1).to_return(
+      body: [{id: 1, name: 'Nandor', assignment: 'stay alert'}].to_json
+    )
+
+    fleet = Sailor.find(1)
+    fleet.save
+
+    assert fleet.save
+    assert_equal 1, fleet.id
+    assert_equal 'stay alert', fleet.assignment
   end
 
   test '#save attempts another request while in transaction' do
+    webmock(:get, '/test_model_cs/schema').to_return(
+      body: {
+        attributes: {
+          id: {type: 'integer', primary_key: true, null: false, array: false},
+          name: {type: 'string', primary_key: false, null: true, array: false}
+        }
+      }.to_json,
+      headers: { 'StandardAPI-Version' => '6.0.0.29' }
+    )
     webmock(:get, '/test_model_bs/schema').to_return(
       body: {
         columns: {
@@ -156,4 +181,4 @@ class ActiveRecord::PersistanceTest < ActiveSupport::TestCase
     assert_requested req_stub
   end
 
-end
+end