occams-record 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: dd652d5b028ca9870438dd907b3d5fba86eec92f
+  data.tar.gz: bb9033890d9f488deeb6d077b35d76b17b78fc4e
+SHA512:
+  metadata.gz: ebf6b5a27af8b77beab59ef971b2b53f5909bd586f461fb05c240e384f13705016fe5a71a5e5a772d7511ea8c10042a874cf284a7074eb00b35f277c15fc509d
+  data.tar.gz: b822de2b3cc6c0402e7ffc3b35c2424851d2b4c44e1316f05924c8a7489b2fb7a4cd2b20c7f0a4ba4c0e89806a0204ae155c1ce04d66352114cd1e24b7d37f7e

data/README.md

@@ -0,0 +1,131 @@
+# Occam's Record
+
+> Do not multiply entities beyond necessity. -- Occam's Razor
+
+EXPERIMENTAL. Occam's Record is a high-efficiency API for querying large sets with ActiveRecord. When loading thousands of records, ActiveRecord wastes a lot of RAM and CPU cycles on *things you'll never use.* Additionally, eagerly-loaded associations are forced to load each and every column, even if you only need a few.
+
+For those stuck with ActiveRecord, OccamsRecord seeks to solve these issues by making some very specific trade-offs:
+
+* OccamsRecord results are **read-only**.
+* OccamsRecord objects are **purely database rows** - they don't have any instance methods from your Rails models.
+
+**What does this buy you?**
+
+* OccamsRecord results are **one-thid the size** of ActiveRecord results.
+* OccamsRecord queries run **three times faster** than ActiveRecord queries, or more.
+* When you're eager loading associations you may specify which columns to `SELECT`. (This can be a significant performance boost to both your database and Rails app, on top of the above numbers.)
+
+**What don't you give up?**
+
+* You can still write your queries using ActiveRecord's query builder, as well as your existing models' associations & scopes.
+* You can still use ActiveRecord for everything else - small queries, creating, updating, and deleting records.
+* You can still inject some instance methods into your results, if you must. See below.
+
+**Is there evidence to back any of this up?**
+
+Glad you asked. [Look over the results yourself.](https://github.com/jhollinger/occams-record/wiki/Measurements)
+
+## Examples
+
+**Simple example**
+
+    widgets = OccamsRecord.
+      query(Widget.order("name")).
+      eager_load(:category).
+      run
+
+    widgets[0].id
+    => 1000
+
+    widgets[0].name
+    => "Widget 1000"
+
+    widgets[0].category.name
+    => "Category 1"
+
+**More complicated example**
+
+Notice that we're eager loading splines, but *only the fields that we need*. If that's a wide table, your DBA will thank you.
+
+    widgets = OccamsRecord.
+      query(Widget.order("name")).
+      eager_load(:category).
+      eager_load(:splines, -> { select("widget_id, description") }).
+      run
+
+    widgets[0].splines.map { |s| s.description }
+    => ["Spline 1", "Spline 2", "Spline 3"]
+
+    widgets[1].splines.map { |s| s.description }
+    => ["Spline 4", "Spline 5"]
+
+**An insane example, but only half as insane as the one that prompted the creation of this library**
+
+In addition to custom eager loading queries, we're also adding nested eager loading (and customizing those queries!).
+
+    widgets = OccamsRecord.
+      query(Widget.order("name")).
+      eager_load(:category).
+
+      # load order_items, but only the fields needed to identify which orders go with which widgets
+      eager_load(:order_items, -> { select("widget_id, order_id") }) {
+
+        # load the orders
+        eager_load(:orders) {
+
+          # load the customers who made the orders, but only their names
+          eager_load(:customer, -> { select("id, name") })
+        }
+      }.
+      run
+
+## Injecting instance methods
+
+By default your results will only have getters for selected columns and eager-loaded associations. If you must, you *can* inject extra methods into your results by putting those methods into a Module. NOTE this is discouraged, as you should try to maintain a clear separation between your persistence layer and your domain.
+
+    module MyWidgetMethods
+      def to_s
+        name
+      end
+
+      def expensive?
+        price_per_unit > 100
+      end
+    end
+
+    module MyOrderMethods
+      def description
+        "#{order_number} - #{date}"
+      end
+    end
+
+    widgets = OccamsRecord.
+      query(Widget.order("name"), use: MyWidgetMethods).
+      eager_load(:orders, use: MyOrderMethods).
+      run
+
+    widgets[0].to_s
+    => "Widget A"
+
+    widgets[0].price_per_unit
+    => 57.23
+
+    widgets[0].expensive?
+    => false
+
+    widgets[0].orders[0].description
+    => "O839SJZ98B 1/8/2017"
+
+## Testing
+
+To run the tests, simply run:
+
+    bundle install
+    bundle exec rake test
+
+By default, bundler will install the latest (supported) version of ActiveRecord. To specify a version to test against, run:
+
+    AR=4.2 bundle update activerecord
+    bundle exec rake test
+
+Look inside `Gemfile` to see all testable versions.

data/lib/occams-record.rb

@@ -0,0 +1,5 @@
+require 'active_record'
+require 'occams-record/version'
+require 'occams-record/eager_loaders'
+require 'occams-record/result_row'
+require 'occams-record/query'

data/lib/occams-record/batches.rb

@@ -0,0 +1,72 @@
+module OccamsRecord
+  #
+  # Methods for building batch finding methods.
+  #
+  module Batches
+    #
+    # Load records in batches of N and yield each record to a block if given.
+    # If no block is given, returns an Enumerator.
+    #
+    # @param batch_size [Integer]
+    # @return [Enumerator] will yield each record
+    #
+    def find_each(batch_size: 1000)
+      enum = Enumerator.new { |y|
+        batches(of: batch_size).each { |batch|
+          batch.each { |record| y.yield record }
+        }
+      }
+      if block_given?
+        enum.each { |record| yield record }
+      else
+        enum
+      end
+    end
+
+    #
+    # Load records in batches of N and yield each batch to a block if given.
+    # If no block is given, returns an Enumerator.
+    #
+    # @param batch_size [Integer]
+    # @return [Enumerator] will yield each batch
+    #
+    def find_in_batches(batch_size: 1000)
+      enum = batches(of: batch_size)
+      if block_given?
+        enum.each { |batch| yield batch }
+      else
+        enum
+      end
+    end
+
+    private
+
+    #
+    # Returns an Enumerator that yields batches of records, of size "of".
+    # NOTE ActiveRecord 5+ provides the 'in_batches' method to do something
+    # similiar, but 4.2 doesn't have it, so...
+    #
+    # @param of [Integer] batch size
+    # @return [Enumerator] yields batches
+    #
+    def batches(of:)
+      limit = scope.limit_value
+      batch_size = limit && limit < of ? limit : of
+      Enumerator.new do |y|
+        offset = scope.offset_value || 0
+        out_of_records, count = false, 0
+
+        until out_of_records
+          l = limit && batch_size > limit - count ? limit - count : batch_size
+          q = scope.offset(offset).limit(l)
+          results = Query.new(q, use: @use, query_logger: @query_logger, eager_loaders: @eager_loaders).run
+
+          y.yield results if results.any?
+          count += results.size
+          offset += count
+          out_of_records = results.size < batch_size || (limit && count >= limit)
+        end
+      end
+    end
+  end
+end

data/lib/occams-record/eager_loaders.rb

@@ -0,0 +1,29 @@
+module OccamsRecord
+  #
+  # Contains eager loaders for various kinds of associations.
+  #
+  module EagerLoaders
+    autoload :Base, 'occams-record/eager_loaders/base'
+    autoload :BelongsTo, 'occams-record/eager_loaders/belongs_to'
+    autoload :PolymorphicBelongsTo, 'occams-record/eager_loaders/polymorphic_belongs_to'
+    autoload :HasOne, 'occams-record/eager_loaders/has_one'
+    autoload :HasMany, 'occams-record/eager_loaders/has_many'
+    autoload :Habtm, 'occams-record/eager_loaders/habtm'
+
+    # Fetch the appropriate eager loader for the given association type.
+    def self.fetch!(ref)
+      case ref.macro
+      when :belongs_to
+        ref.options[:polymorphic] ? PolymorphicBelongsTo : BelongsTo
+      when :has_one
+        HasOne
+      when :has_many
+        HasMany
+      when :has_and_belongs_to_many
+        EagerLoaders::Habtm
+      else
+        raise "Unsupported association type `#{macro}`"
+      end
+    end
+  end
+end

data/lib/occams-record/eager_loaders/base.rb

@@ -0,0 +1,61 @@
+module OccamsRecord
+  module EagerLoaders
+    #
+    # Base class for eagoer loading an association.
+    #
+    class Base
+      # @return [String] association name
+      attr_reader :name
+      # @return [Module] optional Module to include in the result class
+      attr_reader :use
+      # @return [Proc] optional Proc for eager loading things on this association
+      attr_reader :eval_block
+
+      #
+      # @param ref [ActiveRecord::Association] the ActiveRecord association
+      # @param scope [Proc] a scope to apply to the query (optional)
+      # @param use [Module] optional Module to include in the result class
+      # @param eval_block [Proc] a block where you may perform eager loading on *this* association (optional)
+      #
+      def initialize(ref, scope = nil, use = nil, &eval_block)
+        @ref, @scope, @use, @eval_block = ref, scope, use, eval_block
+        @name, @model = ref.name.to_s, ref.klass
+        @assign = "#{@name}="
+      end
+
+      #
+      # Yield one or more ActiveRecord::Relation objects to a given block.
+      #
+      # @param rows [Array<OccamsRecord::ResultRow>] Array of rows used to calculate the query.
+      #
+      def query(rows)
+        raise 'Not Implemented'
+      end
+
+      #
+      # Merges the associated rows into the parent rows.
+      #
+      # @param assoc_rows [Array<OccamsRecord::ResultRow>]
+      # @param rows [Array<OccamsRecord::ResultRow>]
+      #
+      def merge!(assoc_rows, rows)
+        raise 'Not Implemented'
+      end
+
+      private
+
+      #
+      # Returns the base scope for the relation, including any scope defined on the association itself,
+      # and any optional scope passed into the eager loader.
+      #
+      # @return [ActiveRecord::Relation]
+      #
+      def base_scope
+        q = @ref.klass.all
+        q = q.instance_exec(&@ref.scope) if @ref.scope
+        q = q.instance_exec(&@scope) if @scope
+        q
+      end
+    end
+  end
+end

data/lib/occams-record/eager_loaders/belongs_to.rb

@@ -0,0 +1,36 @@
+module OccamsRecord
+  module EagerLoaders
+    # Eager loader for belongs_to associations.
+    class BelongsTo < Base
+      #
+      # Yield one or more ActiveRecord::Relation objects to a given block.
+      #
+      # @param rows [Array<OccamsRecord::ResultRow>] Array of rows used to calculate the query.
+      #
+      def query(rows)
+        ids = rows.map { |r| r.send @ref.foreign_key }.compact.uniq
+        yield base_scope.where(@ref.active_record_primary_key => ids)
+      end
+
+      #
+      # Merge the association rows into the given rows.
+      #
+      # @param assoc_rows [Array<OccamsRecord::ResultRow>] rows loaded from the association
+      # @param rows [Array<OccamsRecord::ResultRow>] rows loaded from the main model
+      #
+      def merge!(assoc_rows, rows)
+        pkey_col = @model.primary_key.to_s
+        assoc_rows_by_id = assoc_rows.reduce({}) { |a, assoc_row|
+          id = assoc_row.send pkey_col
+          a[id] = assoc_row
+          a
+        }
+
+        rows.each do |row|
+          fkey = row.send @ref.foreign_key
+          row.send @assign, fkey ? assoc_rows_by_id[fkey] : nil
+        end
+      end
+    end
+  end
+end

data/lib/occams-record/eager_loaders/habtm.rb

@@ -0,0 +1,66 @@
+module OccamsRecord
+  module EagerLoaders
+    # Eager loader for has_and_belongs_to_many associations.
+    class Habtm < Base
+      #
+      # Yield one or more ActiveRecord::Relation objects to a given block.
+      #
+      # @param rows [Array<OccamsRecord::ResultRow>] Array of rows used to calculate the query.
+      #
+      def query(rows)
+        assoc_ids = join_rows(rows).map { |row| row[1] }.compact.uniq
+        yield base_scope.where(@ref.association_primary_key => assoc_ids)
+      end
+
+      #
+      # Merge the association rows into the given rows.
+      #
+      # @param assoc_rows [Array<OccamsRecord::ResultRow>] rows loaded from the association
+      # @param rows [Array<OccamsRecord::ResultRow>] rows loaded from the main model
+      #
+      def merge!(assoc_rows, rows)
+        joins_by_id = join_rows(rows).reduce({}) { |a, join|
+          id = join[0]
+          a[id] ||= []
+          a[id] << join[1]
+          a
+        }
+
+        assoc_rows_by_id = assoc_rows.reduce({}) { |a, row|
+          id = row.send @ref.association_primary_key
+          a[id] = row
+          a
+        }
+
+        rows.each do |row|
+          id = row.send @ref.active_record_primary_key
+          assoc_fkeys = (joins_by_id[id] || []).uniq
+          associations = assoc_rows_by_id.values_at(*assoc_fkeys).compact.uniq
+          row.send @assign, associations
+        end
+      end
+
+      private
+
+      #
+      # Fetches (and caches) an array of rows from the join table. The rows are [fkey, assoc_fkey].
+      #
+      # @param rows [Array<OccamsRecord::ResultRow>]
+      # @return [Array<Array<String>>]
+      #
+      def join_rows(rows)
+        return @join_rows if defined? @join_rows
+
+        conn = @model.connection
+        join_table = conn.quote_table_name @ref.join_table
+        assoc_fkey = conn.quote_column_name @ref.association_foreign_key
+        fkey = conn.quote_column_name @ref.foreign_key
+        quoted_ids = rows.map { |r| conn.quote r.send @ref.active_record_primary_key }
+
+        @join_rows = conn.
+          exec_query("SELECT #{fkey}, #{assoc_fkey} FROM #{join_table} WHERE #{fkey} IN (#{quoted_ids.join ','})").
+          rows
+      end
+    end
+  end
+end

data/lib/occams-record/eager_loaders/has_many.rb

@@ -0,0 +1,20 @@
+module OccamsRecord
+  module EagerLoaders
+    # Eager loader for has_many associations.
+    class HasMany < HasOne
+      #
+      # Merge the association rows into the given rows.
+      #
+      # @param assoc_rows [Array<OccamsRecord::ResultRow>] rows loaded from the association
+      # @param rows [Array<OccamsRecord::ResultRow>] rows loaded from the main model
+      #
+      def merge!(assoc_rows, rows)
+        assoc_rows_by_fkey = assoc_rows.group_by(&@ref.foreign_key.to_sym)
+        rows.each do |row|
+          pkey = row.send @ref.active_record_primary_key
+          row.send @assign, assoc_rows_by_fkey[pkey] || []
+        end
+      end
+    end
+  end
+end

data/lib/occams-record/eager_loaders/has_one.rb

@@ -0,0 +1,39 @@
+module OccamsRecord
+  module EagerLoaders
+    # Eager loader for has_one associations.
+    class HasOne < Base
+      #
+      # Yield one or more ActiveRecord::Relation objects to a given block.
+      #
+      # @param rows [Array<OccamsRecord::ResultRow>] Array of rows used to calculate the query.
+      #
+      def query(rows)
+        ids = rows.map { |r| r.send @ref.active_record_primary_key }.compact.uniq
+        q = base_scope.where(@ref.foreign_key => ids)
+        q.where!(@ref.type => rows[0].class.try!(:model_name)) if @ref.options[:as]
+        yield q
+      end
+
+      #
+      # Merge the association rows into the given rows.
+      #
+      # @param assoc_rows [Array<OccamsRecord::ResultRow>] rows loaded from the association
+      # @param rows [Array<OccamsRecord::ResultRow>] rows loaded from the main model
+      #
+      def merge!(assoc_rows, rows)
+        fkey_col = @ref.foreign_key.to_s
+        assoc_rows_by_fkey = assoc_rows.reduce({}) { |a, assoc_row|
+          fid = assoc_row.send fkey_col
+          a[fid] = assoc_row
+          a
+        }
+
+        pkey_col = @ref.active_record_primary_key.to_s
+        rows.each do |row|
+          pkey = row.send pkey_col
+          row.send @assign, pkey ? assoc_rows_by_fkey[pkey] : nil
+        end
+      end
+    end
+  end
+end

data/lib/occams-record/eager_loaders/polymorphic_belongs_to.rb

@@ -0,0 +1,74 @@
+module OccamsRecord
+  module EagerLoaders
+    # Eager loader for polymorphic belongs tos
+    class PolymorphicBelongsTo
+      # @return [String] association name
+      attr_reader :name
+      # @return [Module] optional Module to include in the result class
+      attr_reader :use
+      # @return [Proc] optional Proc for eager loading things on this association
+      attr_reader :eval_block
+
+      #
+      # @param ref [ActiveRecord::Association] the ActiveRecord association
+      # @param scope [Proc] a scope to apply to the query (optional)
+      # @param use [Module] optional Module to include in the result class
+      # @param eval_block [Proc] a block where you may perform eager loading on *this* association (optional)
+      #
+      def initialize(ref, scope = nil, use = nil, &eval_block)
+        @ref, @name, @scope, @eval_block = ref, ref.name.to_s, scope, eval_block
+        @foreign_type = @ref.foreign_type.to_sym
+        @foreign_key = @ref.foreign_key.to_sym
+        @use = use
+        @assign = "#{@name}="
+      end
+
+      #
+      # Yield ActiveRecord::Relations to the given block, one for every "type" represented in the given rows.
+      #
+      # @param rows [Array<OccamsRecord::ResultRow>] Array of rows used to calculate the query.
+      #
+      def query(rows)
+        rows_by_type = rows.group_by(&@foreign_type)
+        rows_by_type.each do |type, rows_of_type|
+          model = type.constantize
+          ids = rows_of_type.map(&@foreign_key).uniq
+          q = base_scope(model).where(model.primary_key => ids)
+          yield q
+        end
+      end
+
+      #
+      # Merge associations of type N into rows of model N.
+      #
+      def merge!(assoc_rows_of_type, rows)
+        type = assoc_rows_of_type[0].class.try!(:model_name) || return
+        rows_of_type = rows.select { |r| r.send(@foreign_type) == type }
+        merge_model!(assoc_rows_of_type, rows_of_type, type.constantize)
+      end
+
+      private
+
+      def base_scope(model)
+        q = model.all
+        q = q.instance_exec(&@ref.scope) if @ref.scope
+        q = q.instance_exec(&@scope) if @scope
+        q
+      end
+
+      def merge_model!(assoc_rows, rows, model)
+        pkey_col = model.primary_key.to_s
+        assoc_rows_by_id = assoc_rows.reduce({}) { |a, assoc_row|
+          id = assoc_row.send pkey_col
+          a[id] = assoc_row
+          a
+        }
+
+        rows.each do |row|
+          fkey = row.send @ref.foreign_key
+          row.send @assign, fkey ? assoc_rows_by_id[fkey] : nil
+        end
+      end
+    end
+  end
+end

data/lib/occams-record/query.rb

@@ -0,0 +1,101 @@
+require 'occams-record/batches'
+
+module OccamsRecord
+  #
+  # Starts building a OccamsRecord::Query. Pass it a scope from any of ActiveRecord's query builder
+  # methods or associations. If you want to eager loaded associations, do NOT us ActiveRecord for it.
+  # Instead, use OccamsRecord::Query#eager_load. Finally, call `run` to run the query and get back an
+  # array of objects.
+  #
+  #  results = OccamsRecord.
+  #    query(Widget.order("name")).
+  #    eager_load(:category).
+  #    eager_load(:order_items, ->(q) { q.select("widget_id, order_id") }) {
+  #      eager_load(:orders) {
+  #        eager_load(:customer, ->(q) { q.select("name") })
+  #      }
+  #    }.
+  #    run
+  #
+  # @param query [ActiveRecord::Relation]
+  # @param use [Module] optional Module to include in the result class
+  # @param query_logger [Array] (optional) an array into which all queries will be inserted for logging/debug purposes
+  # @return [OccamsRecord::Query]
+  #
+  def self.query(scope, use: nil, query_logger: nil)
+    Query.new(scope, use: use, query_logger: query_logger)
+  end
+
+  #
+  # Represents a query to be run and eager associations to be loaded. Use OccamsRecord.query to create your queries
+  # instead of instantiating objects directly.
+  #
+  class Query
+    # @return [ActiveRecord::Base]
+    attr_reader :model
+    # @return [ActiveRecord::Relation] scope for building the main SQL query
+    attr_reader :scope
+    # @return [ActiveRecord::Connection]
+    attr_reader :conn
+
+    include Batches
+
+    #
+    # Initialize a new query.
+    #
+    # @param scope [ActiveRecord::Relation]
+    # @param use [Module] optional Module to include in the result class
+    # @param query_logger [Array] (optional) an array into which all queries will be inserted for logging/debug purposes
+    # @param eager_loaders [OccamsRecord::EagerLoaders::Base]
+    # @param eval_block [Proc] block that will be eval'd on this instance. Can be used for eager loading. (optional)
+    #
+    def initialize(scope, use: nil, query_logger: nil, eager_loaders: [], &eval_block)
+      @model = scope.klass
+      @scope = scope
+      @eager_loaders = eager_loaders
+      @conn = model.connection
+      @use = use
+      @query_logger = query_logger
+      instance_eval(&eval_block) if eval_block
+    end
+
+    #
+    # Specify an association to be eager-loaded. You may optionally pass a block that accepts a scope
+    # which you may modify to customize the query. For maximum memory savings, always `select` only
+    # the colums you actually need.
+    #
+    # @param assoc [Symbol] name of association
+    # @param scope [Proc] a scope to apply to the query (optional)
+    # @param use [Module] optional Module to include in the result class
+    # @param eval_block [Proc] a block where you may perform eager loading on *this* association (optional)
+    #
+    def eager_load(assoc, scope = nil, use: nil, &eval_block)
+      ref = model.reflections[assoc.to_s]
+      raise "OccamsRecord: No assocation `:#{assoc}` on `#{model.name}`" if ref.nil?
+      @eager_loaders << EagerLoaders.fetch!(ref).new(ref, scope, use, &eval_block)
+      self
+    end
+
+    #
+    # Run the query and return the results.
+    #
+    # @return [Array<OccamsRecord::ResultRow>]
+    #
+    def run
+      sql = scope.to_sql
+      @query_logger << sql if @query_logger
+      result = conn.exec_query sql
+      row_class = OccamsRecord.build_result_row_class(model, result.columns, @eager_loaders.map(&:name), @use)
+      rows = result.rows.map { |row| row_class.new row }
+
+      @eager_loaders.each { |loader|
+        loader.query(rows) { |scope|
+          assoc_rows = Query.new(scope, use: loader.use, query_logger: @query_logger, &loader.eval_block).run
+          loader.merge! assoc_rows, rows
+        }
+      }
+
+      rows
+    end
+  end
+end

data/lib/occams-record/result_row.rb

@@ -0,0 +1,91 @@
+module OccamsRecord
+  # ActiveRecord's internal type casting API changes from version to version.
+  TYPE_CAST_METHOD = case ActiveRecord::VERSION::MAJOR
+                     when 4 then :type_cast_from_database
+                     when 5 then :deserialize
+                     end
+
+  #
+  # Dynamically build a class for a specific set of result rows. It inherits from OccamsRecord::ResultRow, and optionall includes
+  # a user-defined module.
+  #
+  # @param model [ActiveRecord::Base] the AR model representing the table (it holds column & type info).
+  # @param column_names [Array<String>] the column names in the result set. The order MUST match the order returned by the query.
+  # @param association_names [Array<String>] names of associations that will be eager loaded into the results.
+  # @param included_module [Module] (optional)
+  # @return [OccamsRecord::ResultRow] a class customized for this result set
+  #
+  def self.build_result_row_class(model, column_names, association_names, included_module = nil)
+    Class.new(ResultRow) do
+      include included_module if included_module
+
+      self.columns = column_names.map(&:to_s)
+      self.associations = association_names.map(&:to_s)
+      self.model_name = model.name
+
+      # Build getters & setters for associations. (We need setters b/c they're set AFTER the row is initialized
+      attr_accessor(*association_names)
+
+      # Build a getter for each attribute returned by the query. The values will be type converted on demand.
+      column_names.each_with_index do |col, idx|
+        type = model.attributes_builder.types[col.to_s] || raise("OccamsRecord: Column `#{col}` does not exist on model `#{model.name}`")
+        define_method col do
+          @cast_values_cache[idx] ||= type.send(TYPE_CAST_METHOD, @raw_values[idx])
+        end
+      end
+    end
+  end
+
+  #
+  # Abstract class for result rows.
+  #
+  class ResultRow
+    class << self
+      # Array of column names
+      attr_accessor :columns
+      # Array of associations names
+      attr_accessor :associations
+      # Name of Rails model
+      attr_accessor :model_name
+    end
+    self.columns = []
+    self.associations = []
+
+    #
+    # Initialize a new result row.
+    #
+    # @param raw_values [Array] array of raw values from db
+    #
+    def initialize(raw_values)
+      @raw_values = raw_values
+      @cast_values_cache = {}
+    end
+
+    #
+    # Return row as a Hash (recursive).
+    #
+    # @param symbolize_names [Boolean] if true, make Hash keys Symbols instead of Strings
+    # @return [Hash] a Hash with String or Symbol keys
+    #
+    def to_h(symbolize_names: false)
+      hash = self.class.columns.reduce({}) { |a, col_name|
+        key = symbolize_names ? col_name.to_sym : col_name
+        a[key] = send col_name
+        a
+      }
+
+      self.class.associations.reduce(hash) { |a, assoc_name|
+        key = symbolize_names ? assoc_name.to_sym : assoc_name
+        assoc = send assoc_name
+        a[key] = if assoc.is_a? Array
+                   assoc.map { |x| x.to_h(symbolize_names: symbolize_names) }
+                 elsif assoc
+                   assoc.to_h(symbolize_names: symbolize_names)
+                 end
+        a
+      }
+    end
+
+    alias_method :to_hash, :to_h
+  end
+end

data/lib/occams-record/version.rb

@@ -0,0 +1,7 @@
+#
+# Main entry point for using OccamsRecord.
+#
+module OccamsRecord
+  # Library version
+  VERSION = '0.1.0'.freeze
+end

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification
+name: occams-record
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Jordan Hollinger
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-08-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.2'
+description: A faster, lower-memory querying API for ActiveRecord that returns results
+  as unadorned, read-only objects.
+email: jordan.hollinger@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/occams-record.rb
+- lib/occams-record/batches.rb
+- lib/occams-record/eager_loaders.rb
+- lib/occams-record/eager_loaders/base.rb
+- lib/occams-record/eager_loaders/belongs_to.rb
+- lib/occams-record/eager_loaders/habtm.rb
+- lib/occams-record/eager_loaders/has_many.rb
+- lib/occams-record/eager_loaders/has_one.rb
+- lib/occams-record/eager_loaders/polymorphic_belongs_to.rb
+- lib/occams-record/query.rb
+- lib/occams-record/result_row.rb
+- lib/occams-record/version.rb
+homepage: https://github.com/jhollinger/occams-record
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.2
+signing_key: 
+specification_version: 4
+summary: The missing high-efficiency query API for ActiveRecord
+test_files: []