praxis-mapper 3.4.0 → 4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e7b9f2ce4f066cc2efacc2305788cb72c6e7b263
-  data.tar.gz: c1c76b006d57dac6e868e43109f37db79931b9b4
+  metadata.gz: 04a36d68c2385426a0b0aed2295c41299b0c3943
+  data.tar.gz: 5eca3e994f89a94f67a7c1f0d9ec3ed64c274793
 SHA512:
-  metadata.gz: 5f4e0bc3f8e16c1b73a6268c5f73b4c57a692aefaa600f5113280b44f37c7543535be23717b90ca5e79c99e9fa7ade59e4205a829c1035ffd9f0b023409df882
-  data.tar.gz: ca517a3d90bbf750aacc028bd6a1b6f0ee22bb82c632a1777933ca68e2714a73f7e64311d337f975a7d4b02c1fe35fbca02a6eccc1bf182d8d716203027c6a79
+  metadata.gz: 9604920ffc4719206ee8dd41cb2e3a642bb87f8efd64fa44c310d1e6db6f4a702a94c9965724bd98d27984336d745d06b131f766752b989ccfbeb127b754bf9e
+  data.tar.gz: 88a2a5c4c87f99701c955e4f1063e8d5169363f6250cf06b992b53f978581b6cc35cbd645c4d2c34229146e8ada75534ad5b338598038c870a2ace98f214b895

data/.travis.yml

@@ -1,4 +1,5 @@
 language: ruby
 rvm:
-  - "2.1.2"
+  - 2.1.2
+  - 2.2.2
 script: bundle exec rspec spec

data/CHANGELOG.md

@@ -1,6 +1,25 @@
 # praxis-mapper changelog
 
-## next
+## 4.0
+
+* Optimization on handling repeated ids (especially noticeable when using subloads)
+* Refactored `ConnectionManager` repository handling to improve integration with other connection-pooling (specifically Sequel's at present).
+* Added two types of connection factory under `Praxis::Mapper::ConnectionFactories::`:
+  * `Simple`: Takes a `connection:` option to specify the raw object to return for all `checkout`. Also, preserves current behavior with proc-based uses when `ConnectionManager.repository` is given a block. This is the default factory type if one is not specified for the repository.
+  * `Sequel`: Takes `connection:` option to specify a `Sequel::Database`, or hash of options to pass to `Sequel.connect`. 
+* `IdentityMap#finalize!` now calls `ConnectionManager#release` to ensure any connections are returned to their respective pools, if applicable.
+* Added `SequelCompat` module, which provides support for using `Sequel::Model` objects with an `IdentityMap` when included in model class. 
+  * This overrides the association accessors on instances associated with an `IdentityMap` (see below for more on this) to query the map instead of database.
+  * See (spec/support/spec_sequel_models.rb) for example definition.
+* Added prototype for write-path support to `IdentityMap` (for `Sequel::Model` models):
+  * `IdentityMap#attach(record)`: adds the record to the identity map, saving it to the database first if it does not have a value for its primary key (or other identities).
+  * `IdentityMap#detatch(record)`: removes the record from the identity map
+  * `IdentityMap#flush!(record_or_class=nil)`: depending on the value of `record_or_class` it:
+    * with no argument, or nil, given it saves all modified records in the identity map.
+    * with an instance of a model, it saves just that record.
+    * with a model class, it saves all modified records for that class in the identity map.
+  * `IdentityMap#remove`: calls `detatch` with the record, and then calls`record.delete` to delete it. 
+
 
 ## 3.4.0
 

data/lib/praxis-mapper.rb

@@ -45,12 +45,19 @@ end
 require 'praxis-mapper/finalizable'
 require 'praxis-mapper/logging'
 
+require 'praxis-mapper/identity_map_extensions/persistence'
 require 'praxis-mapper/identity_map'
 
 require 'praxis-mapper/model'
 require 'praxis-mapper/query_statistics'
+
+require 'praxis-mapper/sequel_compat' 
+
 require 'praxis-mapper/connection_manager'
 
+require 'praxis-mapper/connection_factories/simple'
+require 'praxis-mapper/connection_factories/sequel'
+
 require 'praxis-mapper/resource'
 
 require 'praxis-mapper/query/base'

data/lib/praxis-mapper/connection_factories/sequel.rb

@@ -0,0 +1,66 @@
+module Praxis::Mapper
+  module ConnectionFactories
+
+    class Sequel
+
+      def initialize(connection:nil, **opts)
+        raise ArgumentError, 'May not provide both a connection and opts' if connection && !opts.empty?
+
+        if connection
+          @connection = connection
+        else
+          @connection = ::Sequel.connect(**opts)
+        end
+
+        # steal timeout values so we can replicate the same timeout behavior
+        @timeout = @connection.pool.instance_variable_get(:@timeout)
+        @sleep_time = @connection.pool.instance_variable_get(:@sleep_time)
+
+        # connections that we created explicitly
+        @owned_connections = Hash.new
+      end
+
+      def checkout(connection_manager)
+        # copied from Sequel's ThreadedConnectionPool#hold
+        # to ensure consistent behavior
+        unless acquire(connection_manager.thread)
+          time = Time.now
+          timeout = time + @timeout
+          sleep_time = @sleep_time
+          sleep sleep_time
+          until acquire(connection_manager.thread)
+            raise(::Sequel::PoolTimeout) if Time.now > timeout
+            sleep sleep_time
+          end
+        end
+
+        @connection
+      end
+
+      def release(connection_manager, connection)
+        # ensure we only release connections we own, in case
+        # we've acquired a connection from Sequel that 
+        # is likely still in use.
+        if (@owned_connections.delete(connection_manager.thread))
+          @connection.pool.send(:sync) do
+            @connection.pool.send(:release,connection_manager.thread)
+          end
+        end
+      end
+
+      def acquire(thread)
+        # check connection's pool to see if it already has a connection
+        # if so, re-use it. otherwise, acquire a new one and mark that we 
+        # "own" it for future releasing.
+        if (owned = @connection.pool.send(:owned_connection, thread))
+          return true
+        else
+          conn = @connection.pool.send(:acquire, thread)
+          @owned_connections[thread] = conn
+          true
+        end
+      end
+
+    end
+  end
+end

data/lib/praxis-mapper/connection_factories/simple.rb

@@ -0,0 +1,27 @@
+module Praxis::Mapper
+  module ConnectionFactories
+    class Simple
+      def initialize(connection: nil, &block)
+        @connection = connection if connection
+        if block
+          @checkout = block
+        end
+
+        if @connection && @checkout
+          raise ArgumentError, 'May not provide both a connection and block'
+        end
+      end
+
+      def checkout(connection_manager)
+        return @connection if @connection
+        
+        @checkout.call        
+      end
+
+      def release(connection_manager, connection)
+        true
+      end
+
+    end
+  end
+end

data/lib/praxis-mapper/connection_manager.rb

@@ -1,61 +1,39 @@
 module Praxis::Mapper
   class ConnectionManager
 
-    # Configures a data store.
-    def self.setup(config_data={}, &block)
-      config_data.each do |repository_name, data|
-        klass_name = data.delete(:connection_factory)
-        connection_factory_class = Object.const_get(klass_name)
-        repositories[repository_name][:connection_factory] = connection_factory_class.new(data[:connection_opts])
+    @repositories = {}
+    class << self
+      attr_accessor :repositories
+    end
 
-        if (query_klass_name = data.delete(:query))
-          query_klass = Object.const_get(query_klass_name)
-          repositories[repository_name][:query] = query_klass
-        end
-      end
+    def self.setup(&block)
       if block_given?
         self.instance_eval(&block)
       end
     end
 
-    def self.repository(repository_name, data=nil,&block)
-      return repositories[repository_name] if data.nil? && !block_given?
+    def self.repository(repository_name, **data, &block)
+      return repositories[repository_name] if data.empty? && !block_given?
 
-      if data && data[:query]
-        query_klass = case data[:query]
-        when String
-          query_klass_name = data[:query]
-          Object.const_get(query_klass_name) #FIXME: won't really work consistently
-        when Class
-          data[:query]
-        when Symbol
-          raise "symbol support is not implemented yet"
-        else
-          raise "unknown type for query: #{data[:query].inspect} has type #{data[:query].class}"
-        end
-        repositories[repository_name][:query] = query_klass
-      end
+      query = data[:query] || Praxis::Mapper::Query::Sql
+      factory_class = data[:factory] || ConnectionFactories::Simple
       
-      if block_given?
-        # TODO: ? complain if data.has_key?(:connection_factory)
-        repositories[repository_name][:connection_factory] = block
-      elsif data
-        klass_name = data.delete(:connection_factory)
-        connection_factory_class = Object.const_get(klass_name) #FIXME: won't really work consistently
-        repositories[repository_name][:connection_factory] = connection_factory_class.new(data[:connection_opts])
+      opts = data[:opts] || {}
+      if query.kind_of? String
+        query = query.constantize
       end
-    end
-
 
-    def self.repositories
-      @repositories ||= Hash.new do |hash,key|
-        hash[key] = {
-          :connection_factory => nil,
-          :query => Praxis::Mapper::Query::Sql
-        }
+      if factory_class.kind_of? String
+        factory_class = factory_class.constantize
       end
+      
+      repositories[repository_name] = {
+        query: query,
+        factory: factory_class.new(**opts, &block)
+      }
     end
 
+    
     def repositories
       self.class.repositories
     end
@@ -66,26 +44,27 @@ module Praxis::Mapper
 
     def initialize
       @connections = {}
+      @thread = Thread.current
+    end
+
+    def thread
+      return @thread if @thread == Thread.current
+      raise 'threading violation in ConnectionManager. Calling Thread is different from Thread that owns this instance.'
     end
 
     def checkout(name)
       connection = @connections[name]
       return connection if connection
 
-      factory = repositories[name][:connection_factory]
-      connection = if factory.kind_of?(Proc)
-        factory.call
-      else
-        factory.checkout
-      end
+      factory = repositories[name][:factory]
+      connection = factory.checkout(self)
 
       @connections[name] = connection
     end
 
     def release_one(name)
       if (connection = @connections.delete(name))
-        return true if repositories[name][:connection_factory].kind_of? Proc
-        repositories[name][:connection_factory].release(connection)
+        repositories[name][:factory].release(self, connection)
       end
     end
 

data/lib/praxis-mapper/identity_map.rb

@@ -4,7 +4,8 @@
 # The scope can be thought of as a set of named filters.
 module Praxis::Mapper
   class IdentityMap
-
+    include IdentityMapExtensions::Persistence
+    
     class UnloadedRecordException < StandardError; end;
     class UnsupportedModel < StandardError; end;
     class UnknownIdentity < StandardError; end;
@@ -69,6 +70,11 @@ module Praxis::Mapper
       @connection_manager = ConnectionManager.new
       @scope = scope
       clear!
+
+      # Ensure we clean up open connections
+      ObjectSpace.define_finalizer(self) do
+        @connection_manager.release
+      end
     end
 
     def clear!
@@ -104,7 +110,9 @@ module Praxis::Mapper
       end
 
       # TODO: rework this so it's a hash with default values and simplify #index
-      @secondary_indexes =  Hash.new
+      @secondary_indexes = Hash.new do |hash, model|
+        hash[model] = Hash.new
+      end
     end
 
 
@@ -184,9 +192,16 @@ module Praxis::Mapper
         finalize_model!(model).any?
       end
 
-      finalize! if did_something
+      if did_something
+        finalize!
+      else
+        release
+      end
     end
 
+    def release
+      @connection_manager.release
+    end
 
     # don't doc. never ever use yourself!
     # FIXME: make private and fix specs that break?
@@ -293,8 +308,6 @@ module Praxis::Mapper
 
 
     def index(model, key, value)
-      @secondary_indexes[model] ||= Hash.new
-
       unless @secondary_indexes[model].has_key? key
         @secondary_indexes[model][key] ||= Hash.new
         reindex!(model, key)
@@ -311,6 +324,7 @@ module Praxis::Mapper
         else
           row.send(key)
         end
+        # FIXME: make this a set? or handle duplicates better
         index(model, key, val) << row
       end
     end
@@ -325,7 +339,8 @@ module Praxis::Mapper
       if values.size == 1
         value = values[0]
         if @row_keys[model].has_key?(key)
-          res = row_by_key(model, key, value)
+          res = @row_keys[model][key][value]
+          
           if res
             [res]
           else
@@ -337,7 +352,7 @@ module Praxis::Mapper
       else
         if @row_keys[model].has_key?(key)
           values.collect do |value|
-            row_by_key(model, key, value)
+            @row_keys[model][key][value]
           end.compact
         else
           values.each_with_object(Array.new) do |value, results|
@@ -375,20 +390,19 @@ module Praxis::Mapper
       end
     end
 
-
     def connection(name)
       @connection_manager.checkout(name)
     end
 
     def extract_keys(field, records)
-      row_keys = []
+      row_keys = Set.new
       if field.kind_of?(Array) # composite identities
         records.each do |record|
           row_key = field.collect { |col| record.send(col) }
           row_keys << row_key unless row_key.include?(nil)
         end
       else
-        row_keys.push *records.collect(&field).compact
+        row_keys.merge records.collect(&field).compact
       end
       row_keys
     end
@@ -418,9 +432,9 @@ module Praxis::Mapper
       key = tracked_association[:key]
       primary_key = tracked_association[:primary_key] || :id
 
-      row_keys = []
+      row_keys = Set.new
       records.collect(&key).each do |keys|
-        row_keys.push *keys
+        row_keys.merge keys
       end
 
       row_keys.reject! do |row_key|
@@ -438,7 +452,7 @@ module Praxis::Mapper
 
 
     def add_records(records)
-      return [] if records.empty? 
+      return [] if records.empty?
 
       to_stage = Hash.new do |hash,staged_model|
         hash[staged_model] = Hash.new do |identities, identity_name|
@@ -497,6 +511,16 @@ module Praxis::Mapper
         @row_keys[model][identity][key] = record
       end
 
+      @secondary_indexes[model].each do |key, indexed_values|
+        val = if key.kind_of? Array
+          key.collect { |k| record.send(k) }
+        else
+          record.send(key)
+        end
+
+        indexed_values[val] << record
+      end
+
       record.identity_map = self
       @rows[model] << record
       record

data/lib/praxis-mapper/identity_map_extensions/persistence.rb

@@ -0,0 +1,83 @@
+module Praxis::Mapper
+  module IdentityMapExtensions
+    module Persistence
+
+      def deindex(record)
+        model = record.class
+
+        # delete from full set of rows
+        rows_for(model).delete record 
+
+        # remove record from identity indexes
+        @row_keys[model].each do |identity, index|
+          index.delete_if {|k,v| v == record }
+        end
+
+        # remove any secondary indexes
+        @secondary_indexes[model].each do |key, index|
+          index.each do |index_key, indexed_values|
+            indexed_values.delete record
+          end
+        end
+      end
+
+      def reindex(record)
+        # fully remove the record from any indexes it may be part of
+        deindex(record)
+
+        # hack to update any indexes as applicable
+        add_record(record)
+      end
+
+      # attach record to the identity map.
+      # save the record if, and only if, we need to
+      def attach(record)
+        # save unless it has all identities populated
+        unless record.identities.all? { |identity, value| value }
+          record.save
+        end
+
+        # raise if still don't have full identities
+        unless record.identities.all? { |identity, value| value }
+          raise "can not attach #{record.inspect} without a full set of identities."
+        end
+
+        add_record(record)
+
+        # TODO: what to do with related records?
+      end
+
+      def flush!(object=nil)
+        if object.nil?
+          return @rows.keys.each { |klass| self.flush!(klass) }
+        end
+
+        case object
+        when Class
+          @rows[object].select(&:modified?).each do |record|
+            record.save
+            reindex(record)
+          end
+        when Sequel::Model
+          if object.modified?
+            object.save
+            reindex(object)
+          end
+        end
+      end
+
+      def remove(record)
+        detach(record)
+
+        record.delete
+      end
+
+      def detach(record)
+        record.identity_map = nil
+        deindex(record)
+      end
+    end
+
+
+  end
+end