sunstone 2.0.4 → 5.0.0.beta3

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

@@ -3,28 +3,70 @@ module ActiveRecord
     module Sunstone
       module Type
         class Array < ActiveRecord::Type::Value
-          include ActiveRecord::Type::Mutable
+          include ActiveRecord::Type::Helpers::Mutable
           
           attr_reader :subtype
-          delegate :type, to: :subtype
+          delegate :type, :user_input_in_time_zone, :limit, to: :subtype
           
           def initialize(subtype)
             @subtype = subtype
           end
           
-          def type_cast_for_database(value)
-            super(value).to_json if value
+          def deserialize(value)
+            if value.is_a?(String)
+              type_cast_array(JSON.parse(value), :deserialize)
+            else
+              super
+            end
           end
           
-          def cast_value(string)
-            return string unless string.is_a?(::String)
-            return if string.empty?
-
-            JSON.parse(string)
+          def cast(value)
+            if value.is_a?(::String)
+              value = JSON.parse(value)
+            end
+            type_cast_array(value, :cast)
+          end
+          
+          def serialize(value)
+            if value.is_a?(::Array)
+              type_cast_array(value, :serialize)
+            else
+              super
+            end
+          end
+          
+          def ==(other)
+            other.is_a?(Array) && subtype == other.subtype
+          end
+          
+          # def type_cast_for_schema(value)
+          #   return super unless value.is_a?(::Array)
+          #   "[" + value.map { |v| subtype.type_cast_for_schema(v) }.join(", ") + "]"
+          # end
+          
+          def map(value, &block)
+            value.map(&block)
+          end
+          
+          # def cast_value(string)
+          #   return string unless string.is_a?(::String)
+          #   return if string.empty?
+          #
+          #   JSON.parse(string)
+          # end
+          
+          private
+          
+          def type_cast_array(value, method)
+            if value.is_a?(::Array)
+              value.map { |item| type_cast_array(item, method) }
+            else
+              @subtype.public_send(method, value)
+            end
           end
          
         end
       end
     end
   end
-end
+end

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

@@ -4,7 +4,7 @@ module ActiveRecord
       module Type
         class DateTime < ActiveRecord::Type::DateTime
           
-          def type_cast_for_database(value)
+          def serialize(value)
             super(value).iso8601(3) if value
           end
           

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

@@ -10,7 +10,7 @@ module ActiveRecord
             :ewkb
           end
           
-          def type_cast_for_database(value)
+          def serialize(value)
             if value
               ::RGeo::WKRep::WKBGenerator.new(hex_format: true, type_format: :ewkb, emit_ewkb_srid: true).generate(value)
             end

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

@@ -0,0 +1,15 @@
+module ActiveRecord
+  module ConnectionAdapters
+    class SunstoneSQLTypeMetadata < DelegateClass(SqlTypeMetadata)
+      attr_reader :array
+
+      def initialize(type_metadata, options = {})
+        super(type_metadata)
+        @type_metadata = type_metadata
+        @primary_key = (options['primary_key'] == true)
+        @array = !!options['array']
+      end
+
+    end
+  end
+end

data/lib/active_record/connection_adapters/sunstone_adapter.rb

@@ -34,7 +34,7 @@ module ActiveRecord
       end
       
       # Forward only valid config params to PGconn.connect.
-      conn_params.keep_if { |k, _| VALID_SUNSTONE_CONN_PARAMS.include?(k) }
+      conn_params.slice!(*VALID_SUNSTONE_CONN_PARAMS)
 
       # The postgres drivers don't allow the creation of an unconnected PGconn object,
       # so just pass a nil connection object for the time being.
@@ -54,7 +54,7 @@ module ActiveRecord
     # * <tt>:encoding</tt> - An optional client encoding that is used in a <tt>SET client_encoding TO
     #   <encoding></tt> call on the connection.
     class SunstoneAPIAdapter < AbstractAdapter
-      ADAPTER_NAME = 'Sunstone'
+      ADAPTER_NAME = 'Sunstone'.freeze
 
       NATIVE_DATABASE_TYPES = {
         string:      { name: "string" },
@@ -63,8 +63,12 @@ module ActiveRecord
         boolean:     { name: "boolean" }
       }
 
-      include Sunstone::DatabaseStatements
+      # include PostgreSQL::Quoting
+      # include PostgreSQL::ReferentialIntegrity
       include Sunstone::SchemaStatements
+      include Sunstone::DatabaseStatements
+      # include PostgreSQL::ColumnDumper
+      # include Savepoints
       
       # Returns 'SunstoneAPI' as adapter name for identification purposes.
       def adapter_name
@@ -80,7 +84,7 @@ module ActiveRecord
 
       # Initializes and connects a SunstoneAPI adapter.
       def initialize(connection, logger, connection_parameters, config)
-        super(connection, logger)
+        super(connection, logger, config)
 
         @visitor = Arel::Visitors::Sunstone.new
         @connection_parameters, @config = connection_parameters, config
@@ -149,6 +153,15 @@ module ActiveRecord
       def server_config
         Wankel.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
+      end
+      
 
       private
 
@@ -158,7 +171,7 @@ module ActiveRecord
           m.register_type 'integer',    Type::Integer.new
           m.register_type 'decimal',    Type::Decimal.new
           m.register_type 'datetime',   Sunstone::Type::DateTime.new
-          m.register_type 'hash',       Type::Value.new
+          m.register_type 'json',       Type::Internal::AbstractJson.new
           m.register_type 'ewkb',       Sunstone::Type::EWKB.new
         end
 
@@ -186,6 +199,9 @@ module ActiveRecord
         def create_table_definition(name, temporary, options, as = nil) # :nodoc:
           SunstoneAPI::TableDefinition.new native_database_types, name, temporary, options, as
         end
+        
+        ActiveRecord::Type.add_modifier({ array: true }, Sunstone::Type::Array, adapter: :sunstone)
+        # ActiveRecord::Type.add_modifier({ range: true }, OID::Range, adapter: :postgresql)
     end
   end
 end

data/lib/arel/collectors/sunstone.rb

@@ -4,21 +4,41 @@ module Arel
 
       attr_accessor :request_type, :table, :where, :limit, :offset, :order, :operation, :columns, :updates, :eager_loads, :id
 
+      def cast_attribute(v)
+        if (v.is_a?(ActiveRecord::Attribute))
+          v.value_for_database
+        else
+          v
+        end
+      end
+
       def substitute_binds hash, bvs
         if hash.is_a?(Array)
-          hash.map { |w| substitute_binds(w, bvs) }
-        else
+          hash.map do |v|
+            if v.is_a?(Arel::Nodes::BindParam)
+              cast_attribute(bvs.last.is_a?(Array) ? bvs.shift.last : bvs.shift)
+            elsif v.is_a?(Hash) || v.is_a?(Array)
+              substitute_binds(v, bvs)
+            else
+              v
+            end
+          end
+        elsif hash.is_a?(Hash)
           newhash = {}
           hash.each do |k, v|
-            if Arel::Nodes::BindParam === v
-              newhash[k] = (bvs.last.is_a?(Array) ? bvs.shift.last : bvs.shift)
+            if v.is_a?(Arel::Nodes::BindParam)
+              newhash[k] = cast_attribute(bvs.last.is_a?(Array) ? bvs.shift.last : bvs.shift)
             elsif v.is_a?(Hash)
               newhash[k] = substitute_binds(v, bvs)
+            elsif v.is_a?(Array)
+              newhash[k] = substitute_binds(v, bvs)
             else
               newhash[k] = v
             end
           end
           newhash
+        else
+          cast_attribute(bvs.last.is_a?(Array) ? bvs.shift.last : bvs.shift)
         end
       end
 
@@ -55,9 +75,9 @@ module Arel
           get_params[:include] = eager_loads.clone
         end
 
-        get_params[:limit] = limit if limit
-        get_params[:offset] = offset if offset
-        get_params[:order] = order if order
+        get_params[:limit] = substitute_binds(limit, bvs) if limit
+        get_params[:offset] = substitute_binds(offset, bvs) if offset
+        get_params[:order] = substitute_binds(order, bvs) if order
 
         case operation
         when :count
@@ -69,9 +89,9 @@ module Arel
           path += "/#{get_params[:where]['id']}"
           get_params.delete(:where)
         end
-        
+
         if get_params.size > 0
-          path += '?' + get_params.to_param
+          path += '?m=' + URI.escape(CGI.escape(MessagePack.pack(get_params)))
         end
 
         request = request_type.new(path)

data/lib/arel/visitors/sunstone.rb

@@ -18,8 +18,12 @@ module Arel
         accept(node, Arel::Collectors::SQLString.new, &block).value
       end
 
+      def preparable
+        false
+      end
+      
       private
-
+      
       def visit_Arel_Nodes_SelectStatement o, collector
         collector = o.cores.inject(collector) { |c,x|
           visit_Arel_Nodes_SelectCore(x, c)
@@ -64,17 +68,76 @@ module Arel
         collector
       end
       
+      def visit_Arel_Nodes_Overlaps o, collector
+        { visit(o.left, collector) => {overlaps: o.left.type_cast_for_database(o.right) }}
+      end
+      
       def visit_Arel_Nodes_InsertStatement o, collector
         collector.request_type  = Net::HTTP::Post
         collector.table         = o.relation.name
         collector.operation     = :insert
         
         if o.values
-          collector.updates = o.values.right.map { |x| visit(x, collector) }.zip(o.values.left).to_h
+          keys = o.values.right.map { |x| visit(x, collector) }
+          values = o.values.left
+          collector.updates = {}
+          
+
+          keys.each_with_index do |k, i|
+            if k.is_a?(Hash)
+              add_to_bottom_of_hash_or_array(k, values[i])
+              collector.updates.deep_merge!(k) { |key, v1, v2|
+                if (v1.is_a?(Array) && v2.is_a?(Array))
+                  v2.each_with_index do |v, i|
+                    if v1[i].nil?
+                      v1[i] = v2[i]
+                    else
+                      v1[i].deep_merge!(v2[i]) unless v2[i].nil?
+                    end
+                  end
+                  v1
+                else
+                  v2
+                end
+              }
+            else
+              collector.updates[k] = values[i]
+            end
+          end
         end
         
         collector
       end
+      
+      def find_bottom(hash)
+        if hash.is_a?(Hash)
+          if hash.values.first.is_a?(Array) || hash.values.first.is_a?(Hash)
+            find_bottom(hash.values.first)
+          else
+            hash
+          end
+        elsif hash.is_a?(Array)
+          fnn = hash.find { |i| !i.nil? }
+          if fnn.is_a?(Array) || fnn.is_a?(Hash)
+            fnn
+          else
+            hash
+          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
+          hash[nkey] = { nvalue => value }
+        elsif hash.is_a?(Array)
+          fnni = hash.find_index { |i| !i.nil? }
+          nvalue = hash[fnni]
+          hash[fnni] = { nvalue => value }
+        end
+      end
 
 
       private
@@ -112,22 +175,50 @@ module Arel
         collector.request_type  = Net::HTTP::Patch
         collector.table         = o.relation.name
         collector.operation     = :update
-
-        wheres = o.wheres.map { |x| visit(x, collector) }.inject([]) { |c, w|
-          w.is_a?(Array) ? c += w : c << w
-        }
-        if wheres.size != 1 && wheres.first.size != 1 && !wheres['id']
-          raise 'Upsupported'
-        else
-          collector.where = wheres
+        
+        # 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
         
-        collector.id = wheres.first['id']
+        if collector.where.size != 1 && collector.where.first.size != 1 && !collector.where.first['id']
+          raise 'Upsupported'
+        end
+        if !collector.where.first['id']
+          collector.table = collector.where.first.keys.first
+          collector.where[0] = {'id' => collector.where.first.values.first.values.first}
+        end
         
         if o.values
-          collector.updates = o.values.map { |x| visit(x, collector) }.inject({}){|c,v| c.merge(v) }#.zip(o.values).to_h
+          collector.updates = {}
+          
+          o.values.map { |x| visit(x, collector) }.each do |value|
+            value.each do |key, v|
+              if key.is_a?(Hash)
+                add_to_bottom_of_hash_or_array(key, v)
+                collector.updates.deep_merge!(key) { |key, v1, v2|
+                  if (v1.is_a?(Array) && v2.is_a?(Array))
+                    v2.each_with_index do |v, i|
+                      if v1[i].nil?
+                        v1[i] = v2[i]
+                      else
+                        v1[i].deep_merge!(v2[i]) unless v2[i].nil?
+                      end
+                    end
+                    v1
+                  else
+                    v2
+                  end
+                }
+              else
+                collector.updates[key] = v
+              end
+            end
+          end
         end
-
+        
         collector
       end
       #
@@ -457,31 +548,63 @@ module Arel
       #   collector << " BETWEEN "
       #   visit o.right, collector
       # end
-      #
-      # def visit_Arel_Nodes_GreaterThanOrEqual o, collector
-      #   collector = visit o.left, collector
-      #   collector << " >= "
-      #   visit o.right, collector
-      # end
-      #
+
+      def visit_Arel_Nodes_GreaterThanOrEqual o, collector
+        key = visit(o.left, collector)
+        value = { :gte => visit(o.right, collector) }
+        if key.is_a?(Hash)
+          if o.left.is_a?(Arel::Attributes::Cast)
+            merge_to_bottom_hash(key, value)
+          else
+            add_to_bottom_of_hash(key, value)
+          end
+        else
+          { key => value }
+        end
+      end
+
       def visit_Arel_Nodes_GreaterThan o, collector
-        {
-          visit(o.left, collector) => { :greater_than => visit(o.right, collector) }
-        }
+        key = visit(o.left, collector)
+        value = { :gt => visit(o.right, collector) }
+        if key.is_a?(Hash)
+          if o.left.is_a?(Arel::Attributes::Cast)
+            merge_to_bottom_hash(key, value)
+          else
+            add_to_bottom_of_hash(key, value)
+          end
+        else
+          { key => value }
+        end
+      end
+
+      def visit_Arel_Nodes_LessThanOrEqual o, collector
+        key = visit(o.left, collector)
+        value = { :lte => visit(o.right, collector) }
+        if key.is_a?(Hash)
+          if o.left.is_a?(Arel::Attributes::Cast)
+            merge_to_bottom_hash(key, value)
+          else
+            add_to_bottom_of_hash(key, value)
+          end
+        else
+          { key => value }
+        end
+      end
+
+      def visit_Arel_Nodes_LessThan o, collector
+        key = visit(o.left, collector)
+        value = { :lte => visit(o.right, collector) }
+        if key.is_a?(Hash)
+          if o.left.is_a?(Arel::Attributes::Cast)
+            merge_to_bottom_hash(key, value)
+          else
+            add_to_bottom_of_hash(key, value)
+          end
+        else
+          { key => value }
+        end
       end
 
-      # def visit_Arel_Nodes_LessThanOrEqual o, collector
-      #   collector = visit o.left, collector
-      #   collector << " <= "
-      #   visit o.right, collector
-      # end
-      #
-      # def visit_Arel_Nodes_LessThan o, collector
-      #   collector = visit o.left, collector
-      #   collector << " < "
-      #   visit o.right, collector
-      # end
-      #
       # def visit_Arel_Nodes_Matches o, collector
       #   collector = visit o.left, collector
       #   collector << " LIKE "
@@ -561,15 +684,11 @@ module Arel
         end
       end
 
-      # def visit_Arel_Nodes_In o, collector
-      #   if Array === o.right && o.right.empty?
-      #     collector << '1=0'
-      #   else
-      #     collector = visit o.left, collector
-      #     collector << " IN ("
-      #     visit(o.right, collector) << ")"
-      #   end
-      # end
+      def visit_Arel_Nodes_In o, collector
+        {
+          visit(o.left, collector) => {in: visit(o.right, collector)}
+        }
+      end
       #
       # def visit_Arel_Nodes_NotIn o, collector
       #   if Array === o.right && o.right.empty?
@@ -587,10 +706,11 @@ module Arel
         ors << o.children.inject({}) do |c, x|
           value = visit(x, collector)
           if value.is_a?(Hash)
-            c.deep_merge(value)
+            c.deep_merge!(value)
           elsif value.is_a?(Array)
             value.size == 1 ? ors << value : ors += value
           end
+          c
         end
         ors
       end
@@ -605,8 +725,10 @@ module Arel
       end
 
       def visit_Arel_Nodes_Assignment o, collector
-        case o.right
-        when Arel::Nodes::UnqualifiedColumn, Arel::Attributes::Attribute, Arel::Nodes::BindParam
+        case o.left
+        when Arel::Nodes::UnqualifiedColumn
+          { visit(o.left.expr, collector) => visit(o.right, collector) }
+        when Arel::Attributes::Attribute, Arel::Nodes::BindParam
           { visit(o.left, collector) => visit(o.right, collector) }
         else
           collector = visit o.left, collector
@@ -615,20 +737,91 @@ module Arel
         end
       end
 
+      def merge_to_bottom_hash(hash, value)
+        okey = hash
+        while okey.values.first.is_a?(Hash)
+          okey = okey.values.first
+        end
+        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))
+          if okey.is_a?(Array)
+            okey = okey.find { |i| !i.nil? }
+          else
+            okey = okey.values.first
+          end
+        end
+        nkey = okey.keys.first
+        nvalue = okey.values.first
+        okey[nkey] = { nvalue => value }
+        hash
+      end
+      
       def visit_Arel_Nodes_Equality o, collector
-        key = visit(o.left, collector).to_s.split('.')
+        key = visit(o.left, collector)
         value = (o.right.nil? ? nil : visit(o.right, collector))
         
-        hash = {
-          key.pop => value
-        }
-        
-        while key.size > 0
-          hash = { key.pop => hash }
+        if key.is_a?(Hash)
+          add_to_bottom_of_hash(key, {eq: value})
+        else
+          key = key.to_s.split('.')
+          hash = { key.pop => value }
+          while key.size > 0
+            hash = { key.pop => hash }
+          end
+          hash
         end
-        hash
       end
+      
+      def visit_Arel_Nodes_TSMatch(o, collector)
+        key = visit(o.left, collector)
+        value = { ts_match: (o.right.nil? ? nil : visit(o.right, collector)) }
 
+        if key.is_a?(Hash)
+          add_to_bottom_of_hash(key, value)
+        else
+          key = key.to_s.split('.')
+          hash = { key.pop => value }
+          while key.size > 0
+            hash = { key.pop => hash }
+          end
+          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)]
+        else
+          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)
+            okey = okey.values.first
+          end
+          nkey = okey.keys.first
+          nvalue = okey.values.first
+          okey[nkey] = { nvalue => value }
+        else
+          { key => value }
+        end
+      end
+      
       def visit_Arel_Nodes_NotEqual o, collector
         {
           visit(o.left, collector) => { :not => visit(o.right, collector) }
@@ -645,11 +838,47 @@ module Arel
       def visit_Arel_Nodes_UnqualifiedColumn o, collector
         o.name
       end
+      
+      def visit_Arel_Attributes_Cast(o, collector)
+        key = visit(o.relation, collector)
+        value = { :cast => o.name }
+        if key.is_a?(Hash)
+          add_to_bottom_of_hash(key, value)
+        else
+          { key => value }
+        end
+      end
+      
+      def visit_Arel_Attributes_Key o, collector
+        key = visit(o.relation, collector)
+        if key.is_a?(Hash)
+          okey = key
+          while okey.values.first.is_a?(Hash)
+            okey = okey.values.first
+          end
+          nkey = okey.keys.first
+          value = okey.values.first
+          okey[nkey] = {value => o.name}
+          key
+        else
+          { key => o.name }
+        end
+      end
 
+      def visit_Arel_Attributes_Relation o, collector
+        if o.collection
+          ary = []
+          ary[o.collection] = visit(o.relation, collector).to_s.split('.').last
+          {"#{o.name}_attributes" => ary}
+        else
+          {"#{o.name}_attributes" => visit(o.relation, collector).to_s.split('.').last}
+        end
+      end
+      
       def visit_Arel_Attributes_Attribute o, collector
         join_name = o.relation.table_alias || o.relation.name
-        # collector <<
         collector.table == join_name ? o.name : "#{join_name}.#{o.name}"
+        # o.name
       end
       alias :visit_Arel_Attributes_Integer :visit_Arel_Attributes_Attribute
       alias :visit_Arel_Attributes_Float :visit_Arel_Attributes_Attribute