sunstone 6.1.3 → 7.1.0.1

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

@@ -27,19 +27,8 @@ module ActiveRecord
             return @definitions[table_name]
           end
 
-          response = @connection.get("/#{table_name}/schema")
-
-          version = Gem::Version.create(response['StandardAPI-Version'] || '5.0.0.4')
-
-          @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 }
-          end
+          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"
         end
@@ -50,8 +39,8 @@ 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:
-          # First check for attributes and then for the deprecated columns field
-          # TODO: Remove after 0.3
+          # 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
 
@@ -62,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
@@ -75,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)
@@ -93,6 +82,35 @@ module ActiveRecord
         def column_name_for_operation(operation, node) # :nodoc:
           visitor.accept(node, collector).first[operation.to_sym]
         end
+        
+        # Given a set of columns and an ORDER BY clause, returns the columns for a SELECT DISTINCT.
+        # PostgreSQL, MySQL, and Oracle override this for custom DISTINCT syntax - they
+        # require the order columns appear in the SELECT.
+        #
+        #   columns_for_distinct("posts.id", ["posts.created_at desc"])
+        #
+        def columns_for_distinct(columns, orders) # :nodoc:
+          columns
+        end
+
+        def distinct_relation_for_primary_key(relation) # :nodoc:
+          values = columns_for_distinct(
+            relation.table[relation.primary_key],
+            relation.order_values
+          )
+
+          limited = relation.reselect(values).distinct!
+          limited_ids = select_rows(limited.arel, "SQL").map(&:last)
+
+          if limited_ids.empty?
+            relation.none!
+          else
+            relation.where!(relation.primary_key => limited_ids)
+          end
+
+          relation.limit_value = relation.offset_value = nil
+          relation
+        end
 
         # TODO: def encoding
 

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
+
+        # 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
 
-        # @type_map = Type::HashLookupTypeMap.new
-        # initialize_type_map(type_map)
+      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,45 +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
 
-      # 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
+      # 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
 
-      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))
+      # 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 reload_type_map
+        if @type_map
+          type_map.clear
+        else
+          @type_map = Type::HashLookupTypeMap.new
         end
-        m.register_type 'integer' do |_, options|
-          Type::Integer.new(**options.slice(:limit))
+
+        initialize_type_map
+      end
+
+      private
+      
+      def initialize_type_map(m = nil)
+        self.class.initialize_type_map(m || @type_map)
+      end
+
+      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/collectors/sunstone.rb

@@ -24,7 +24,14 @@ module Arel
       def substitute_binds hash, bvs
         if hash.is_a?(Array)
           hash.map do |v|
-            if v.is_a?(Arel::Nodes::BindParam)
+            if v.is_a?(ActiveRecord::Relation::QueryAttribute)
+              new_v = bvs.shift
+              if new_v.is_a?(ActiveRecord::Relation::QueryAttribute)
+                new_v.value_for_database
+              else
+                v.type.serialize(new_v)
+              end
+            elsif v.is_a?(Arel::Nodes::BindParam)
               bvs.shift#.value_for_database
             elsif v.is_a?(Hash) || v.is_a?(Array)
               substitute_binds(v, bvs)
@@ -35,7 +42,14 @@ module Arel
         elsif hash.is_a?(Hash)
           newhash = {}
           hash.each do |k, v|
-            if v.is_a?(Arel::Nodes::BindParam)
+            if v.is_a?(ActiveRecord::Relation::QueryAttribute)
+              new_v = bvs.shift
+              newhash[k] = if new_v.is_a?(ActiveRecord::Relation::QueryAttribute)
+                new_v.value_for_database
+              else
+                v.type.serialize(new_v)
+              end
+            elsif v.is_a?(Arel::Nodes::BindParam)
               newhash[k] = bvs.shift || v.value.value_for_database
             elsif v.is_a?(Hash)
               newhash[k] = substitute_binds(v, bvs)
@@ -47,9 +61,16 @@ module Arel
           end
           newhash
         elsif hash.is_a?(Arel::Nodes::BindParam)
-          bvs.shift || hash.value.value_for_database
+          bvs.shift
+        elsif hash.is_a?(ActiveRecord::Relation::QueryAttribute)
+          new_v = bvs.shift
+          if new_v.is_a?(ActiveRecord::Relation::QueryAttribute)
+            new_v.value_for_database
+          else
+            v.type.serialize(new_v)
+          end
         else
-          bvs.shift || hash.value.value_for_database
+          bvs.shift
         end
       end