sunstone 5.0.0.beta3 → 5.0.0.1

data/ext/active_record/relation.rb

@@ -5,16 +5,24 @@ module ActiveRecord
       @to_sql ||= begin
                     relation   = self
                     connection = klass.connection
-                    visitor    = connection.visitor.is_a?(Arel::Visitors::Sunstone) ? Arel::Visitors::ToSql.new(connection) : connection.visitor
+                    visitor    = if connection.visitor.is_a?(Arel::Visitors::Sunstone)
+                        Arel::Visitors::ToSql.new(connection)
+                      else
+                        connection.visitor
+                      end
 
                     if eager_loading?
                       find_with_associations { |rel| relation = rel }
                     end
 
-                    arel  = relation.arel
-                    binds = connection.prepare_binds_for_database(arel.bind_values + relation.bound_attributes)
-                    binds.map! { |bv| connection.quote(bv) }
-                    collect = visitor.accept(arel.ast, Arel::Collectors::Bind.new)
+                    binds = if connection.visitor.is_a?(Arel::Visitors::Sunstone)
+                      relation.arel.bind_values + relation.bound_attributes
+                    else
+                      relation.bound_attributes
+                    end
+                    binds = connection.prepare_binds_for_database(binds)
+                    binds.map! { |value| connection.quote(value) }
+                    collect = visitor.accept(relation.arel.ast, Arel::Collectors::Bind.new)
                     collect.substitute_binds(binds).join
                   end
     end

data/ext/active_record/relation/calculations.rb

@@ -0,0 +1,25 @@
+module ActiveRecord
+  module Calculations
+    
+    def pluck(*column_names)
+      if loaded? && (column_names.map(&:to_s) - @klass.attribute_names - @klass.attribute_aliases.keys).empty?
+        return @records.pluck(*column_names)
+      end
+
+      if has_include?(column_names.first)
+        construct_relation_for_association_calculations.pluck(*column_names)
+      elsif klass.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
+        load
+        return @records.pluck(*column_names.map{|n| n.sub(/^#{klass.table_name}\./, "")})
+      else
+        relation = spawn
+        relation.select_values = column_names.map { |cn|
+          @klass.has_attribute?(cn) || @klass.attribute_alias?(cn) ? arel_attribute(cn) : cn
+        }
+        result = klass.connection.select_all(relation.arel, nil, bound_attributes)
+        result.cast_values(klass.attribute_types)
+      end
+    end
+    
+  end
+end

data/ext/active_record/statement_cache.rb

@@ -22,7 +22,7 @@ module ActiveRecord
           @values.compile(binds)
         else
           val = @values.dup
-          @indexes.each { |i| val[i] = connection.quote(*binds.shift.reverse) }
+          @indexes.each { |i| val[i] = connection.quote(binds.shift) }
           val.join
         end
       end
@@ -30,7 +30,8 @@ module ActiveRecord
 
     def self.partial_query(visitor, ast, collector)
       collected = visitor.accept(ast, collector)
-      PartialQuery.new(visitor.is_a?(Arel::Visitors::Sunstone) ? collected : collected.value, visitor.is_a?(Arel::Visitors::Sunstone))
+      collected = collected.value if !visitor.is_a?(Arel::Visitors::Sunstone)
+      PartialQuery.new(collected, visitor.is_a?(Arel::Visitors::Sunstone))
     end
 
   end

data/ext/active_record/transactions.rb

@@ -0,0 +1,60 @@
+module ActiveRecord
+  # See ActiveRecord::Transactions::ClassMethods for documentation.
+  module Transactions
+
+    # # See ActiveRecord::Transactions::ClassMethods for detailed documentation.
+    # def transaction(options = {}, &block)
+    #   self.class.transaction(options, &block)
+    # end
+    #
+    # def destroy #:nodoc:
+    #   with_transaction_returning_status { super }
+    # end
+    #
+    # def save(*) #:nodoc:
+    #   rollback_active_record_state! do
+    #     with_transaction_returning_status { super }
+    #   end
+    # end
+    #
+    # def save!(*) #:nodoc:
+    #   with_transaction_returning_status { super }
+    # end
+    #
+    # def touch(*) #:nodoc:
+    #   with_transaction_returning_status { super }
+    # end
+
+    def with_transaction_returning_status
+      if self.class.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter) && @updating
+        begin
+          status = yield
+        rescue ActiveRecord::Rollback
+          clear_transaction_record_state
+          status = nil
+        end
+        return status
+      end
+      
+      status = nil
+      self.class.transaction do
+        add_to_transaction
+        begin
+          status = yield
+        rescue ActiveRecord::Rollback
+          clear_transaction_record_state
+          status = nil
+        end
+        
+        raise ActiveRecord::Rollback unless status
+      end
+      status
+    ensure
+      if @transaction_state && @transaction_state.committed?
+        clear_transaction_record_state
+      end
+    end
+
+
+  end
+end

data/ext/arel/attributes/empty_relation.rb

@@ -0,0 +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

data/ext/arel/attributes/relation.rb

@@ -2,12 +2,13 @@ module Arel
   module Attributes
     class Relation < Attribute
       
-      attr_accessor :collection
+      attr_accessor :collection, :for_write
       
-      def initialize(relation, name, collection = false)
+      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?

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

@@ -15,13 +15,24 @@ module ActiveRecord
 
         def exec_query(arel, name = 'SAR', binds = [], prepare: false)
           sar = to_sar(arel, binds)
-          result = exec(sar, name)
+          
+          log_mess = sar.path.split('?', 2)
+          result = log("#{sar.method} #{log_mess[0]} #{(log_mess[1] && !log_mess[1].empty?) ? MessagePack.unpack(CGI.unescape(log_mess[1])) : '' }", name) {
+            response = @connection.send_request(sar)
+            if response.is_a?(Net::HTTPNoContent)
+              nil
+            else
+              JSON.parse(response.body)
+            end
+          }
 
           if sar.instance_variable_get(:@sunstone_calculation)
             # this is a count, min, max.... yea i know..
             ActiveRecord::Result.new(['all'], [result], {:all => type_map.lookup('integer')})
-          else
+          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])
           end
         end
         

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

@@ -0,0 +1,16 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module Sunstone
+      module ColumnDumper
+
+        # Adds +:array+ option to the default set
+        def prepare_column_options(column)
+          spec = super
+          spec[:array] = 'true' if column.array?
+          spec
+        end
+
+      end
+    end
+  end
+end

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

@@ -25,13 +25,13 @@ 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:
-          Wankel.parse(@connection.get("/#{table_name}/schema").body)
+          JSON.parse(@connection.get("/#{table_name}/schema").body)
         rescue ::Sunstone::Exception::NotFound
           raise ActiveRecord::StatementInvalid, "Table \"#{table_name}\" does not exist"
         end
         
         def tables
-          Wankel.parse(@connection.get('/tables').body)
+          JSON.parse(@connection.get('/tables').body)
         end
         
         def views

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

@@ -0,0 +1,21 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module Sunstone
+      module Type # :nodoc:
+        class Uuid < ActiveRecord::Type::Value # :nodoc:
+          ACCEPTABLE_UUID = %r{\A\{?([a-fA-F0-9]{4}-?){8}\}?\z}x
+
+          alias_method :serialize, :deserialize
+
+          def type
+            :uuid
+          end
+
+          def cast(value)
+            value.to_s[ACCEPTABLE_UUID, 0]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/sunstone_adapter.rb

@@ -1,19 +1,20 @@
 require 'active_record/connection_adapters/abstract_adapter'
-require 'active_record/connection_adapters/statement_pool'
 
+#require 'active_record/connection_adapters/statement_pool'
 
 require 'active_record/connection_adapters/sunstone/database_statements'
 require 'active_record/connection_adapters/sunstone/schema_statements'
+require 'active_record/connection_adapters/sunstone/schema_dumper'
 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/ewkb'
+require 'active_record/connection_adapters/sunstone/type/uuid'
 
 module ActiveRecord
   module ConnectionHandling # :nodoc:
 
-    VALID_SUNSTONE_CONN_PARAMS = [:site, :host, :port, :api_key, :use_ssl, :user_agent, :ca_cert]
+    VALID_SUNSTONE_CONN_PARAMS = [:url, :host, :port, :api_key, :use_ssl, :user_agent, :ca_cert]
 
     # Establishes a connection to the database that's used by all Active Record
     # objects
@@ -25,8 +26,8 @@ module ActiveRecord
       # Map ActiveRecords param names to PGs.
       conn_params[:user] = conn_params.delete(:username) if conn_params[:username]
       conn_params[:dbname] = conn_params.delete(:database) if conn_params[:database]
-      if conn_params[:site]
-        uri = URI.parse(conn_params.delete(:site))
+      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
@@ -67,7 +68,7 @@ module ActiveRecord
       # include PostgreSQL::ReferentialIntegrity
       include Sunstone::SchemaStatements
       include Sunstone::DatabaseStatements
-      # include PostgreSQL::ColumnDumper
+      include Sunstone::ColumnDumper
       # include Savepoints
       
       # Returns 'SunstoneAPI' as adapter name for identification purposes.
@@ -75,17 +76,11 @@ module ActiveRecord
         ADAPTER_NAME
       end
       
-      # Adds `:array` option to the default set provided by the AbstractAdapter
-      def prepare_column_options(column, types) # :nodoc:
-        spec = super
-        spec[:array] = 'true' if column.respond_to?(:array) && column.array
-        spec
-      end
-
       # Initializes and connects a SunstoneAPI adapter.
       def initialize(connection, logger, connection_parameters, config)
         super(connection, logger, config)
 
+        @prepared_statements = false
         @visitor = Arel::Visitors::Sunstone.new
         @connection_parameters, @config = connection_parameters, config
 
@@ -151,7 +146,7 @@ module ActiveRecord
       end
 
       def server_config
-        Wankel.parse(@connection.get("/configuration").body)
+        JSON.parse(@connection.get("/configuration").body)
       end
       
       def lookup_cast_type_from_column(column) # :nodoc:
@@ -162,7 +157,47 @@ module ActiveRecord
         end
       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
+        Thread.current[:sunstone_transaction_count] += 1
+        begin
+          yield
+        ensure
+          Thread.current[:sunstone_transaction_count] -= 1
+          if Thread.current[:sunstone_transaction_count] == 0
+            Thread.current[:sunstone_transaction_count] = nil
+            Thread.current[:sunstone_request_sent] = nil
+          end
+        end
+      rescue ActiveRecord::Rollback
+        # rollbacks are silently swallowed
+      end
+      
+      def supports_json?
+        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 = [])
+        sql, binds, pk, sequence_name = sql_for_insert(to_sql(arel, binds), pk, id_value, sequence_name, binds)
+        value = exec_insert(sql, 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:
@@ -172,22 +207,11 @@ module ActiveRecord
           m.register_type 'decimal',    Type::Decimal.new
           m.register_type 'datetime',   Sunstone::Type::DateTime.new
           m.register_type 'json',       Type::Internal::AbstractJson.new
-          m.register_type 'ewkb',       Sunstone::Type::EWKB.new
-        end
-
-        def exec(arel, name='SAR', binds=[])
-          # result = without_prepared_statement?(binds) ? exec_no_cache(sql, name, binds) :
-          #                                               exec_cache(sql, name, binds)
-          sar = to_sar(arel, binds)
-
-          log(sar.is_a?(String) ? sar : "#{sar.class} #{CGI.unescape(sar.path)}", name) {
-            response = @connection.send_request(sar)
-            if response.is_a?(Net::HTTPNoContent)
-              nil
-            else
-              Wankel.parse(response.body)
-            end
-          }
+          m.register_type 'uuid',       Sunstone::Type::Uuid.new
+          
+          if defined?(Sunstone::Type::EWKB)
+            m.register_type 'ewkb',       Sunstone::Type::EWKB.new
+          end
         end
 
         # Connects to a Sunstone API server and sets up the adapter depending on

data/lib/arel/collectors/sunstone.rb

@@ -89,13 +89,15 @@ module Arel
           path += "/#{get_params[:where]['id']}"
           get_params.delete(:where)
         end
-
         if get_params.size > 0
-          path += '?m=' + URI.escape(CGI.escape(MessagePack.pack(get_params)))
+          path += "?#{CGI.escape(MessagePack.pack(get_params))}"
         end
-
+        
         request = request_type.new(path)
-        request.instance_variable_set(:@sunstone_calculation, true) if [:calculate, :update, :delete, :insert].include?(operation)
+        if get_params.size > 0
+          request['Query-Encoding'] = 'application/msgpack'
+        end
+        request.instance_variable_set(:@sunstone_calculation, true) if [:calculate, :delete].include?(operation)
 
         if updates
           request.body = body

data/lib/arel/visitors/sunstone.rb

@@ -78,30 +78,35 @@ module Arel
         collector.operation     = :insert
         
         if o.values
-          keys = o.values.right.map { |x| visit(x, collector) }
-          values = o.values.left
-          collector.updates = {}
+          
+          if o.values.is_a?(Arel::Nodes::SqlLiteral) && o.values == 'DEFAULT VALUES'
+            collector.updates = {}
+          else
+            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?
+            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, j|
+                      if v1[j].nil?
+                        v1[j] = v2[j]
+                      else
+                        v1[j].deep_merge!(v2[j]) unless v2[j].nil?
+                      end
                     end
+                    v1
+                  else
+                    v2
                   end
-                  v1
-                else
-                  v2
-                end
-              }
-            else
-              collector.updates[k] = values[i]
+                }
+              else
+                collector.updates[k] = values[i]
+              end
             end
           end
         end
@@ -198,9 +203,9 @@ module Arel
             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|
+                collector.updates.deep_merge!(key) { |k, v1, v2|
                   if (v1.is_a?(Array) && v2.is_a?(Array))
-                    v2.each_with_index do |v, i|
+                    v2.each_with_index do |v2k, i|
                       if v1[i].nil?
                         v1[i] = v2[i]
                       else
@@ -689,18 +694,13 @@ module Arel
           visit(o.left, collector) => {in: visit(o.right, collector)}
         }
       end
-      #
-      # def visit_Arel_Nodes_NotIn o, collector
-      #   if Array === o.right && o.right.empty?
-      #     collector << '1=1'
-      #   else
-      #     collector = visit o.left, collector
-      #     collector << " NOT IN ("
-      #     collector = visit o.right, collector
-      #     collector << ")"
-      #   end
-      # end
-      #
+      
+      def visit_Arel_Nodes_NotIn o, collector
+        {
+          visit(o.left, collector) => {not_in: visit(o.right, collector)}
+        }
+      end
+      
       def visit_Arel_Nodes_And o, collector
         ors = []
         ors << o.children.inject({}) do |c, x|
@@ -865,20 +865,42 @@ module Arel
         end
       end
 
-      def visit_Arel_Attributes_Relation o, collector
+      def visit_Arel_Attributes_Relation o, collector, top=true
+        value = if o.relation.is_a?(Arel::Attributes::Relation)
+          visit_Arel_Attributes_Relation(o.relation, collector, false)
+        else
+          visit(o.relation, collector)
+        end
+        value = value.to_s.split('.').last if !value.is_a?(Hash)
+
         if o.collection
           ary = []
-          ary[o.collection] = visit(o.relation, collector).to_s.split('.').last
-          {"#{o.name}_attributes" => ary}
+          ary[o.collection] = value
+          if top && o.name == collector.table
+            ary
+          elsif o.for_write
+            {"#{o.name}_attributes" => ary}
+          else
+            {o.name => ary}
+          end
         else
-          {"#{o.name}_attributes" => visit(o.relation, collector).to_s.split('.').last}
+          if top && o.name == collector.table
+            value
+          elsif o.for_write
+            {"#{o.name}_attributes" => value}
+          else
+            {o.name => value}
+          end
         end
       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
         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