sunstone 7.0.0 → 7.2.0

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

@@ -0,0 +1,19 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module Sunstone
+      module Quoting
+        extend ActiveSupport::Concern
+
+        module ClassMethods # :nodoc:
+
+          # Quotes column names for use in SQL queries.
+          def quote_column_name(name) # :nodoc:
+            name
+          end
+
+        end
+
+      end
+    end
+  end
+end

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

@@ -27,8 +27,7 @@ module ActiveRecord
             return @definitions[table_name]
           end
 
-          response = @connection.get("/#{table_name}/schema")
-
+          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"
@@ -40,7 +39,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']
+          # 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
 
         # Returns the limit definition of the table (the maximum limit that can
@@ -50,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
@@ -63,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)

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

@@ -3,6 +3,7 @@ require 'active_record/connection_adapters/abstract_adapter'
 require 'arel/nodes/relation'
 require 'arel/visitors/to_sql_extensions'
 
+require 'active_record/connection_adapters/sunstone/quoting'
 require 'active_record/connection_adapters/sunstone/database_statements'
 require 'active_record/connection_adapters/sunstone/schema_statements'
 require 'active_record/connection_adapters/sunstone/schema_dumper'
@@ -15,32 +16,6 @@ require 'active_record/connection_adapters/sunstone/type/uuid'
 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]
-
-    # 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)
-    end
-  end
-
   module ConnectionAdapters
     # The SunstoneAPI adapter.
     #
@@ -54,6 +29,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,8 +37,14 @@ 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 Sunstone::Quoting
       # include PostgreSQL::ReferentialIntegrity
       include Sunstone::SchemaStatements
       include Sunstone::DatabaseStatements
@@ -72,35 +54,61 @@ 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
 
-        @type_map = Type::HashLookupTypeMap.new
-        initialize_type_map(@type_map)
+        # 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
 
-      def active?
-        @connection.active?
+      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 reconnect!
+      def active?
+        @raw_connection&.active?
+      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 +142,18 @@ 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, {
+        verify! if type_map.nil?
+        cast_type = @type_map.lookup(column.sql_type, {
           limit: column.limit,
           precision: column.precision,
           scale: column.scale
@@ -167,55 +182,67 @@ 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
 
+      # 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
+
+      def reconnect
+        @raw_connection&.reconnect!
+        connect unless @raw_connection
+      end
+
+      # 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
+        super
+        
+        reload_type_map
+      end
+
       def reload_type_map
-        type_map.clear
+        if @type_map
+          type_map.clear
+        else
+          @type_map = Type::HashLookupTypeMap.new
+        end
+
         initialize_type_map
       end
 
       private
 
-      def type_map
-        @type_map ||= Type::HashLookupTypeMap.new.tap do |mapping|
-          initialize_type_map(mapping)
-        end
-      end
-      
-      def initialize_type_map(m = type_map)
-        self.class.initialize_type_map(m)
-        load_additional_types
+      attr_reader :type_map
+
+      def initialize_type_map(m = nil)
+        self.class.initialize_type_map(m || @type_map)
       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))
-        end
-        m.register_type 'integer' do |_, options|
-          Type::Integer.new(**options.slice(:limit))
+      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/visitors/sunstone.rb

@@ -3,24 +3,24 @@ require 'arel/visitors/visitor'
 module Arel
   module Visitors
     class Sunstone < Arel::Visitors::Visitor
-      
+
       def compile(node, collector = Arel::Collectors::Sunstone.new)
         accept(node, collector).value
       end
-      
+
       private
-      
+
       def visit_Arel_Nodes_SelectStatement o, collector
         collector.table = o.cores.first.source.left.name
 
         collector = o.cores.inject(collector) { |c,x|
           visit_Arel_Nodes_SelectCore(x, c)
         }
-        
+
         if !o.orders.empty?
           collector.order = o.orders.map { |x| visit(x, collector) }
         end
-        
+
         collector = maybe_visit o.limit, collector
         collector = maybe_visit o.offset, collector
         collector = maybe_visit o.eager_load, collector
@@ -61,27 +61,36 @@ module Arel
         collector.request_type  = Net::HTTP::Post
         collector.table         = o.relation.name
         collector.operation     = :insert
-        
+
         if o.values
           if o.values.is_a?(Arel::Nodes::SqlLiteral) && o.values == 'DEFAULT VALUES'
             collector.updates = {}
           else
-            collector.updates = {}
-            
-            o.columns.map(&:name).zip(o.values.expr.first).to_h.each do |k, v|
-              collector.updates[k] = case v
-              when Nodes::SqlLiteral, Nodes::BindParam, ActiveModel::Attribute
-                visit(v, collector)
-              else
-                v
-              end
-            end
+            values = visit(o.values, collector)
+            collector.updates = o.columns.map(&:name).zip(values).to_h
           end
         end
-        
+
         collector
       end
-      
+
+      def visit_Arel_Nodes_ValuesList o, collector
+        o.rows[0].map do |v|
+          visit_subrelation v, collector
+        end
+      end
+
+      def visit_subrelation v, collector
+        case v
+        when Array
+          v.map { |v2| visit_subrelation v2, collector }
+        when Hash
+          v.transform_values { |v2| visit_subrelation v2, collector }
+        else
+          visit(v, collector)
+        end
+      end
+
       def find_bottom(hash)
         if hash.is_a?(Hash)
           if hash.values.first.is_a?(Array) || hash.values.first.is_a?(Hash)
@@ -98,10 +107,10 @@ module Arel
           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
@@ -147,26 +156,26 @@ module Arel
       #
       def visit_Arel_Nodes_UpdateStatement o, collector
         collector.request_type  = Net::HTTP::Patch
-        
+
         collector.table = o.relation.name
         collector.operation     = :update
-        
+
         # 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
-        
+
         if collector.where.size != 1 && collector.where.first.size != 1 && !collector.where.first['id']
           raise 'Upsupported'
         end
-        
+
         collector.where = collector.where.first
-        
+
         if o.values
           collector.updates = {}
-          
+
           o.values.map { |x| visit(x, collector) }.each do |value|
             value.each do |key, v|
               if key.is_a?(Hash)
@@ -191,7 +200,7 @@ module Arel
             end
           end
         end
-        
+
         collector
       end
       #
@@ -426,7 +435,7 @@ module Arel
       def visit_Arel_Nodes_Descending o, collector
         { visit(o.expr, collector) => :desc }
       end
-      
+
       def visit_Arel_Nodes_RandomOrdering o, collector
         :random
       end
@@ -468,7 +477,7 @@ module Arel
       #
       def visit_Arel_Nodes_Count o, collector
         collector.operation = :calculate
-        
+
         collector.columns   ||= []
         collector.columns   << {:count => (o.expressions.first.is_a?(Arel::Attributes::Attribute) ? o.expressions.first.name : o.expressions.first) }
         # collector.columns   = visit o.expressions.first, collector
@@ -476,7 +485,7 @@ module Arel
 
       def visit_Arel_Nodes_Sum o, collector
         collector.operation = :calculate
-        
+
         collector.columns   ||= []
         collector.columns   << {:sum => (o.expressions.first.is_a?(Arel::Attributes::Attribute) ? o.expressions.first.name : o.expressions.first) }
         # collector.columns   = visit o.expressions.first, collector
@@ -484,7 +493,7 @@ module Arel
 
       def visit_Arel_Nodes_Max o, collector
         collector.operation = :calculate
-        
+
         collector.columns   ||= []
         if o.expressions.first.is_a?(Arel::Attributes::Attribute)
           relation = o.expressions.first.relation
@@ -686,11 +695,11 @@ module Arel
         end
       end
       alias_method :visit_Arel_Nodes_HomogeneousIn, :visit_Arel_Nodes_In
-      
+
       def visit_Arel_Nodes_NotIn o, collector
         key = visit(o.left, collector)
         value = {not_in: visit(o.right, collector)}
-        
+
         if hash.is_a?(Hash)
           add_to_bottom_of_hash_or_array(key, value)
           key
@@ -698,10 +707,10 @@ module Arel
           {key => value}
         end
       end
-      
+
       # You merge a into b if a keys do not colid with b keys
       def mergeable?(hash_a, hash_b)
-        
+
         hash_a.each do |key, value_a|
           #TODO: one day maybe just use symbols for all keys?
           if hash_b.has_key?(key.to_sym) || hash_b.has_key?(key.to_s)
@@ -715,7 +724,7 @@ module Arel
         end
         true
       end
-      
+
       def visit_Arel_Nodes_And o, collector
         ors = []
 
@@ -730,16 +739,16 @@ module Arel
             ors << value
           end
         end
-        
+
         result = []
         ors.each_with_index do |c, i|
           result << c
           result << 'AND' if ors.size != i + 1
         end
-        
+
         result.size == 1 ? result.first : result
       end
-      
+
       def visit_Arel_Nodes_Or o, collector
         [visit(o.left, collector), 'OR', visit(o.right, collector)]
       end
@@ -748,10 +757,12 @@ module Arel
         case o.left
         when Arel::Nodes::UnqualifiedColumn
           case o.right
-          when Arel::Attributes::Attribute, Arel::Nodes::BindParam, ActiveModel::Attribute
-            { visit(o.left.expr, collector) => visit(o.right, collector) }
+          when Array
+            { visit(o.left.expr, collector) => o.right.map { |i| i.transform_values { |v| visit(v, collector) } } }
+          when Hash
+            { visit(o.left.expr, collector) => o.right.transform_values { |v| visit(v, collector) } }
           else
-            { visit(o.left.expr, collector) => o.right }
+            { visit(o.left.expr, collector) => visit(o.right, collector) }
           end
         when Arel::Attributes::Attribute, Arel::Nodes::BindParam, ActiveModel::Attribute
           { visit(o.left, collector) => visit(o.right, collector) }
@@ -770,7 +781,7 @@ module Arel
         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))
@@ -785,11 +796,11 @@ module Arel
         okey[nkey] = { nvalue => value }
         hash
       end
-      
+
       def visit_Arel_Nodes_Equality o, collector
         key = visit(o.left, collector)
         value = (o.right.nil? ? nil : visit(o.right, collector))
-        
+
         if key.is_a?(Hash)
           add_to_bottom_of_hash(key, {eq: value})
         elsif o.left.class.name == 'Arel::Attributes::Key'
@@ -798,7 +809,7 @@ module Arel
           { key => value }
         end
       end
-      
+
       def visit_Arel_Nodes_TSMatch(o, collector)
         key = visit(o.left, collector)
         value = { ts_match: (o.right.nil? ? nil : visit(o.right, collector)) }
@@ -814,11 +825,11 @@ module Arel
           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)]
@@ -826,11 +837,11 @@ module Arel
           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)
@@ -847,7 +858,7 @@ module Arel
       def visit_Arel_Nodes_HasKeys o, collector
         key = visit(o.left, collector)
         value = { has_keys: visit(o.right, collector) }
-        
+
         if key.is_a?(Hash)
           okey = key
           while okey.values.first.is_a?(Hash)
@@ -864,7 +875,7 @@ module Arel
       def visit_Arel_Nodes_HasAnyKey o, collector
         key = visit(o.left, collector)
         value = { has_any_key: visit(o.right, collector) }
-        
+
         if key.is_a?(Hash)
           okey = key
           while okey.values.first.is_a?(Hash)
@@ -894,11 +905,11 @@ module Arel
       def visit_Arel_Nodes_UnqualifiedColumn o, collector
         o.name
       end
-      
+
       def visit_Arel_Attributes_Cast(o, collector)
         visit(o.relation, collector) # No casting yet
       end
-      
+
       def visit_Arel_Attributes_Key o, collector
         "#{visit(o.relation, collector)}.#{o.name}"
       end
@@ -938,7 +949,7 @@ module Arel
       # 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
 
@@ -963,7 +974,7 @@ module Arel
           o.value_for_database
         end
       end
-      
+
       def visit_Arel_Nodes_BindParam o, collector
         a = collector.add_bind(o.value)
         o.is_a?(Arel::Nodes::BindParam) ? o : a
@@ -1060,11 +1071,11 @@ module Arel
           collector
         end
       end
-      
+
       def maybe_visit thing, collector
         return collector unless thing
         visit thing, collector
       end
     end
   end
-end
+end