sunstone 6.0.0.4 → 6.1.0.2

data/ext/active_record/transactions.rb

@@ -20,7 +20,7 @@ module ActiveRecord
     #   end
     # end
     #
-    def save!(*) #:nodoc:
+    def save!(**) #:nodoc:
       if instance_variable_defined?(:@no_save_transaction) && @no_save_transaction
         super
       else
@@ -35,29 +35,22 @@ module ActiveRecord
 
     def with_transaction_returning_status
       status = nil
+      connection = self.class.connection
       
-      if self.class.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter) && instance_variable_defined?(:@updating) && @updating
+      if connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter) && instance_variable_defined?(:@updating) && @updating
         status = yield
-        status
       else
-        self.class.transaction do
-          if has_transactional_callbacks?
-            add_to_transaction
-          else
-            sync_with_transaction_state if @transaction_state&.finalized?
-            @transaction_state = self.class.connection.transaction_state
-          end
+        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
-        status
-      end
-    ensure
-      if @transaction_state && @transaction_state.committed?
-        clear_transaction_record_state
       end
+      
+      status
     end
 
 

data/ext/arel/attributes/empty_relation.rb

@@ -1,31 +1,31 @@
-module Arel
-  module Attributes
-    class EmptyRelation < Attribute
-
-      attr_accessor :collection, :for_write
-
-      def initialize(relation, name, collection = false, for_write=false)
-        self[:relation] = relation
-        self[:name] = name
-        @collection = collection
-        @for_write = for_write
-      end
-
-      def able_to_type_cast?
-        false
-      end
-
-      def table_name
-        nil
-      end
-
-      def eql? other
-        self.class == other.class &&
-          self.relation == other.relation &&
-          self.name == other.name &&
-          self.collection == other.collection
-      end
-
-    end
-  end
-end
+# module Arel
+#   module Attributes
+#     class EmptyRelation < Attribute
+#
+#       attr_accessor :collection, :for_write
+#
+#       def initialize(relation, name, collection = false, for_write=false)
+#         self[:relation] = relation
+#         self[:name] = name
+#         @collection = collection
+#         @for_write = for_write
+#       end
+#
+#       def able_to_type_cast?
+#         false
+#       end
+#
+#       def table_name
+#         nil
+#       end
+#
+#       def eql? other
+#         self.class == other.class &&
+#           self.relation == other.relation &&
+#           self.name == other.name &&
+#           self.collection == other.collection
+#       end
+#
+#     end
+#   end
+# end

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
@@ -731,6 +703,7 @@ module Arel
           {key => value}
         end
       end
+      alias_method :visit_Arel_Nodes_HomogeneousIn, :visit_Arel_Nodes_In
       
       def visit_Arel_Nodes_NotIn o, collector
         key = visit(o.left, collector)
@@ -947,9 +920,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 +948,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