ar-ondemand 1.0.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    Yjk2ZDkxMGM4MDFkY2E4MmVhY2U0ZjVhNDFiZjE5YmMyZmY2ZjkyYw==
+  data.tar.gz: !binary |-
+    MGYwY2ZlNzZkYjZhMjYxNGVkYTUyZjljMTQwZDVkMDQyYTVhNWNhNg==
+SHA512:
+  metadata.gz: !binary |-
+    NDA3ZmVlZDQxNzgyZDUwYjE2MmQwZWNiNjJkYmIyNGJhMjQyMmY0ZGRmMDY5
+    MWQ0ZWNmZWVjNTFjNzk0N2M0NjRlNzg0NTFjMzgxMTAyNjUwMzliMzQzZjJl
+    ZTRkZjYzNDVjOWI5N2YzZmQ3ZTU4NjRjMWY2NWJmMjIxZjA5MTE=
+  data.tar.gz: !binary |-
+    MzA3Yjc4YmQ3ODA4NTIxMTFjNzIyY2M4MjhkMGM0MTQ4YTM3YTJlMTgxNWQy
+    ZWNhZDFiNjQ0OTA3YzczODE5ZDcwMGRkODhhODU5NDVhMDU3ZGMyODkwODll
+    OTkxMTgwMzFmYjY4MTJlYmYzZGJiYWFkOTZmN2Y2NTZkODMwZTM=

data/README.md

@@ -0,0 +1 @@
+# ar-ondemand

data/ar-ondemand.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path('../lib', __FILE__)
+require File.dirname(__FILE__) + '/lib/ar-ondemand/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'ar-ondemand'
+  s.version     = ::ArOnDemand::VERSION
+  s.date        = '2015-01-06'
+  s.summary     = 'ActiveRecord On-demand'
+  s.description = 'Fast access to database results without the memory overhead of ActiveRecord objects'
+  s.authors     = ['Steve Frank']
+  s.email       = %w(steve@cloudhealthtech.com lardcanoe@gmail.com)
+  s.homepage    = 'https://github.com/CloudHealth/ar-ondemand'
+  s.license     = 'MIT'
+
+  s.files       = `git ls-files`.split("\n")
+
+  s.test_files  = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+
+  s.require_paths = %w(lib)
+
+  s.add_dependency 'activesupport', '>= 3.2'
+  s.add_dependency 'activerecord',  '>= 3.2'
+end

data/lib/ar-ondemand/for_reading.rb

@@ -0,0 +1,63 @@
+require 'active_support/concern'
+require 'ar-ondemand/result'
+require 'ar-ondemand/record'
+
+module ActiveRecord
+  module OnDemand
+    module ForReadingExtension
+      extend ::ActiveSupport::Concern
+
+      # Ripped from the find_in_batches function, but customized to return an ::ActiveRecord::OnDemand::ResultSet
+      def for_reading(options = {})
+        return query(self) if options.empty?
+
+        relation = self
+
+        unless arel.orders.blank? && arel.taken.blank?
+          ActiveRecord::Base.logger.warn("Scoped order and limit are ignored, it's forced to be batch order and batch size")
+        end
+
+        if (finder_options = options.except(:start, :batch_size)).present?
+          raise "You can't specify an order, it's forced to be #{batch_order}" if options[:order].present?
+          raise "You can't specify a limit, it's forced to be the batch_size"  if options[:limit].present?
+
+          relation = apply_finder_options(finder_options)
+        end
+
+        start = options.delete(:start)
+        batch_size = options.delete(:batch_size) || 1000
+
+        relation = relation.reorder(batch_order).limit(batch_size)
+        records = start ? query(relation.where(table[primary_key].gteq(start))) : query(relation)
+
+        while records.any?
+          records_size = records.size
+          primary_key_offset = records.last.id
+
+          yield records
+
+          break if records_size < batch_size
+
+          if primary_key_offset
+            records = query relation.where(table[primary_key].gt(primary_key_offset))
+          else
+            raise "Primary key not included in the custom select clause"
+          end
+        end
+      end
+
+      private
+
+      def query(ar)
+        results = ::ActiveRecord::Base.connection.exec_query ar.to_sql
+        ::ActiveRecord::OnDemand::ResultSet.new self.arel.engine, results
+      end
+
+      def batch_order
+        "#{quoted_table_name}.#{quoted_primary_key} ASC"
+      end
+    end
+  end
+end
+
+::ActiveRecord::Relation.send(:include, ::ActiveRecord::OnDemand::ForReadingExtension)

data/lib/ar-ondemand/on_demand.rb

@@ -0,0 +1,58 @@
+require 'active_support/concern'
+require 'ar-ondemand/result'
+require 'ar-ondemand/record'
+
+module ActiveRecord
+  module OnDemand
+    class Result < ResultSet
+      include ::Enumerable
+
+      def initialize(model, results, key_column, defaults)
+        super(model, results)
+
+        raise "Key column cannot be blank." if key_column.blank?
+        raise "Defaults cannot be empty." if defaults.empty?
+
+        @key_column = key_column.to_s
+        @defaults = defaults
+
+        @key_index = @col_indexes[@key_column]
+        raise "Unknown index #{key_column}" if @key_index.nil?
+
+        @find_by_method = "find_or_initialize_by_#{(@defaults.keys + [@key_column]).join('_and_')}"
+        @has_any_assets = !ids.empty? || @model.unscoped.where(@defaults).exists?
+        @new_params = @defaults.dup
+        @new_params[@key_column.to_sym] = nil
+      end
+
+      def [](key)
+        raise "Search key cannot be blank." if key.blank?
+        rec = @results.rows.find { |x| x[@key_index] == key }
+        if rec.nil?
+          if @has_any_assets
+            args = @defaults.values + [key]
+            @model.unscoped.send(@find_by_method, *args)
+          else
+            @new_params[@key_column.to_sym] = key
+            @model.new @new_params
+          end
+        else
+          ::ActiveRecord::OnDemand::Record.new convert_to_hash(rec), @model, @defaults
+        end
+      end
+    end
+
+    module Extension
+      extend ::ActiveSupport::Concern
+
+      module ClassMethods
+        def on_demand(keys, defaults = {})
+          results = ::ActiveRecord::Base.connection.exec_query self.where(defaults).to_sql
+          ::ActiveRecord::OnDemand::Result.new self, results, keys, defaults
+        end
+      end
+    end
+  end
+end
+
+::ActiveRecord::Base.send(:include, ::ActiveRecord::OnDemand::Extension)

data/lib/ar-ondemand/record.rb

@@ -0,0 +1,69 @@
+module ActiveRecord
+  module OnDemand
+    class Record
+      #TODO: include ::ActiveModel::Dirty
+      attr_reader :changes
+
+      def initialize(record, model, defaults)
+        @record = record
+        @model = model
+        @defaults = defaults
+        @changes = {}
+      end
+
+      def is_readonly?
+        @defaults.nil?
+      end
+
+      def method_missing(meth, *args, &block)
+        key = meth.to_s
+        if @record.include? key
+          @changes.include?(key) ? @changes[key] : @record[key]
+        elsif key.end_with?('=') && @record.include?(key[0...-1])
+          raise ActiveRecord::ReadOnlyRecord if is_readonly?
+          key = key[0...-1]
+          unless key == 'id'
+            if @record[key] != args[0]
+              return if @record[key] == 1 && args[0] == true
+              return if @record[key] == 0 && args[0] == false
+              return if args[0].is_a?(Time) && !@record[key].blank? && @record[key].to_time.to_i == args[0].to_i
+              @changes[key] = args[0]
+            else
+              # If they changed it, then reverted back, remove from @changes
+              @changes.delete key
+            end
+          end
+        elsif key.end_with?('?') && @record.include?(key[0...-1])
+          key = key[0...-1]
+          v = @changes.include?(key) ? @changes[key] : @record[key]
+          return false if v.nil?
+          return false if v === 0 || v === false
+          return false if v.respond_to?(:blank?) && v.blank?
+          true
+        elsif key.end_with?('_changed?') && @record.include?(key[0...-9])
+          @changes.include?(key[0...-9])
+        else
+          super
+        end
+      end
+
+      def has_attribute?(attr)
+        @record.include? attr
+      end
+
+      def save
+        raise ActiveRecord::ReadOnlyRecord if is_readonly?
+        return nil if @changes.empty?
+        # logger.debug "Loading model to store changes: #{@changes}"
+        rec = @model.allocate.init_with('attributes' => @record)
+        @changes.each_pair do |key, val|
+          next if key == 'id'
+          rec[key] = val
+        end
+        rec.save
+        @changes.clear
+        rec
+      end
+    end
+  end
+end

data/lib/ar-ondemand/result.rb

@@ -0,0 +1,54 @@
+module ActiveRecord
+  module OnDemand
+    class ResultSet
+      include ::Enumerable
+
+      def initialize(model, results)
+        @model = model
+        @results = results
+        @column_types = Hash[@model.columns.map { |x| [x.name, x] }]
+        @col_indexes = HashWithIndifferentAccess[@results.columns.each_with_index.map { |x, i| [x,i] }]
+      end
+
+      def ids
+        id_col = @col_indexes[:id]
+        @results.rows.map { |r| r[id_col] }
+      end
+
+      def length
+        @results.rows.length
+      end
+      alias_method :count, :length
+      alias_method :size, :length
+
+      def each
+        @results.rows.each do |row|
+          yield ::ActiveRecord::OnDemand::Record.new(convert_to_hash(row), @model, nil)
+        end
+      end
+
+      def first
+        row = @results.rows.first
+        return nil if row.nil?
+        ::ActiveRecord::OnDemand::Record.new convert_to_hash(row), @model, nil
+      end
+
+      def last
+        row = @results.rows.last
+        return nil if row.nil?
+        ::ActiveRecord::OnDemand::Record.new convert_to_hash(row), @model, nil
+      end
+
+      protected
+
+      def convert_to_hash(rec)
+        # TODO: Is using HashWithIndifferentAccess[] more efficient?
+        h = {}
+        @col_indexes.each_pair do |k, v|
+          h[k] = @column_types[k].type_cast rec[v]
+        end
+        h.with_indifferent_access
+      end
+    end
+  end
+end

data/lib/ar-ondemand/version.rb

@@ -0,0 +1,3 @@
+module ArOnDemand
+  VERSION = '1.0.1'
+end

data/lib/ar-ondemand.rb

@@ -0,0 +1,2 @@
+require_dependency 'ar-ondemand/on_demand'
+require_dependency 'ar-ondemand/for_reading'

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification
+name: ar-ondemand
+version: !ruby/object:Gem::Version
+  version: 1.0.1
+platform: ruby
+authors:
+- Steve Frank
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-01-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '3.2'
+description: Fast access to database results without the memory overhead of ActiveRecord
+  objects
+email:
+- steve@cloudhealthtech.com
+- lardcanoe@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- ar-ondemand.gemspec
+- lib/ar-ondemand.rb
+- lib/ar-ondemand/for_reading.rb
+- lib/ar-ondemand/on_demand.rb
+- lib/ar-ondemand/record.rb
+- lib/ar-ondemand/result.rb
+- lib/ar-ondemand/version.rb
+homepage: https://github.com/CloudHealth/ar-ondemand
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.3.0
+signing_key: 
+specification_version: 4
+summary: ActiveRecord On-demand
+test_files: []
+has_rdoc: