active_record-mti 0.2.1 → 0.3.0.pre.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 83f66dc4e6bb45b2ca6a075be93334d2f9e761f3
-  data.tar.gz: 4e4f3ec52bf515e9d9ffdfaab67306b480bbbdd1
+  metadata.gz: aed8fa7772f145269a995f4e2d139ebbb8670023
+  data.tar.gz: c40c16ae6a90a66aa9dc3aa6839fe9678761218b
 SHA512:
-  metadata.gz: 0d08825e3d3f51e944963bcf9cf64cf27c16a9b3319fe2ccd50022d26ece1f608cae5f23d6ea8576b2fc98c4859726e72ee39a544aad33d8ebf38b4621528efc
-  data.tar.gz: babb8e13a0371b408f3670059bb5482c4db455dd881c801c4ef1f62ddec542b36d79e0592a5e067a203cc3b2ee7b02e7fe9856bef3a0cc8aee1b1752f22cf696
+  metadata.gz: 520d9654c833f837d3cb93e2320cfb44e86c18802f3d4df1e4b2edccbbec9b9621b257c372eb0ac0dfe288c92135d07593cb3af80c910bd3679a50319efd1562
+  data.tar.gz: 7e51e4286a33db38af13e12ee6a5bb05f43519b4d8cb7e2be1bbfeef71c46caa370a25d691e80eccf9f61871717c0d130f4861f370c7d4aadcbd8e1639edb1ee

data/.travis.yml

@@ -1,11 +1,6 @@
 language: ruby
 sudo: false
-rvm:
-  - 2.0
-  - 2.1
-  - 2.2
-  - 2.3.1
-  - 2.4.0
+
 cache: bundler
 script:
   - bundle exec rspec
@@ -16,6 +11,33 @@ after_success:
 addons:
   postgresql: "9.3"
 
-env:
-  - RSPEC_VERSION="<2.99"
-  - RSPEC_VERSION="~>3.0
+rvm:
+  - 2.0
+  - 2.1
+  - 2.2
+  - 2.3
+  - 2.4
+
+gemfile:
+  - gemfiles/activerecord-4.0.Gemfile
+  - gemfiles/activerecord-4.1.Gemfile
+  - gemfiles/activerecord-4.2.Gemfile
+  - gemfiles/activerecord-5.0.Gemfile
+  - gemfiles/activerecord-5.1.Gemfile
+
+matrix:
+  exclude:
+  - rvm: 2.0
+    gemfile: gemfiles/activerecord-5.0.Gemfile
+  - rvm: 2.0
+    gemfile: gemfiles/activerecord-5.1.Gemfile
+
+  - rvm: 2.1
+    gemfile: gemfiles/activerecord-5.0.Gemfile
+  - rvm: 2.1
+    gemfile: gemfiles/activerecord-5.1.Gemfile
+
+  - rvm: 2.4
+    gemfile: gemfiles/activerecord-4.0.Gemfile
+  - rvm: 2.4
+    gemfile: gemfiles/activerecord-4.1.Gemfile

data/CHANGELOG.md

@@ -0,0 +1,35 @@
+# ActiveRecord::MTI
+
+## 0.3.0 _(November 7th 2017)_
+- Greatly improved future-proofing injection strategy.
+  - No longer overwriting (and maintaining) ActiveRecord Calculation sub-routines.
+- Instead of injecting at `build_select`, we're injecting at `build_arel` with one additional new sub-routine (`build_mti`)
+  - `build_mti` sub-routine detects if an MTI projection is needed based on grouping and selecting from query being built.
+
+## 0.2.1 _(September 20th 2017)_
+- More reliable class discrimination
+- Improved view support
+
+## 0.1.1 _(June 23rd 2017)_
+- Fixes issue where inheritance check is called multiple times.
+- Can handle a (simple) view that references a table that uses MTI
+
+## 0.1.0 _(May 12th 2017)_
+- PSQL Adapter now responds to version
+- Improved column pulls from DB
+
+## 0.0.7 _(May 11th 2017)_
+- Specs!
+- Breaking Change: must call `uses_mti` in models
+- MTI class discrimination happens before STI
+- More reliable projection/unprojection
+- Improved table_name inference
+
+## 0.0.6 _(March 28th 2017)_
+- Improve how `ActiveRecord::MTI` is injected into Rails
+
+## 0.0.5 _(September 27th 2016)_
+- Allow SQL calculations (like `sum` and `count`) to execute by removing unneeded MTI projections
+
+## 0.0.2 _(September 21st 2016)_
+- Default value to return when finding MTI class

data/Gemfile

@@ -1,3 +1,20 @@
 source 'https://rubygems.org'
 
 gemspec
+
+group :test do
+
+  # Generates coverage stats of specs
+  gem 'simplecov'
+
+  # Publishes coverage to codeclimate
+  gem 'codeclimate-test-reporter'
+
+  # Gives CircleCI more perspective on our tests
+  gem 'rspec_junit_formatter'
+
+  gem 'rspec'
+
+  gem 'database_cleaner'
+
+end

data/README.md

@@ -5,9 +5,11 @@
 
 # ActiveRecord::MTI
 
-Allows for true native inheritance of tables in PostgreSQL
+ActiveRecord support for PostgreSQL's native inherited tables (multi-table inheritance)
 
-Currently requires Rails 4.2
+Compatible with ActiveRecord `4.0`, `4.1`, `4.2`, `5.0`, `5.1`
+
+Confirmed production use in `4.2`
 
 ## Usage
 
@@ -25,6 +27,11 @@ Or install it yourself as:
 
 ### Application Code
 
+ActiveRecord queries work as usual with the following differences:
+
+* You need to specify which model represents the base of your multi table inheritance tree. To do so, add `uses_mti` to the model definition of the base class.
+* The default query of "*" is changed to include the OID of each row for subclass discrimination. The default select will be `SELECT "accounts"."tableoid" AS tableoid, "accounts".*` (for example)
+
 ```ruby
 class Account < ::ActiveRecord::Base
   uses_mti
@@ -40,11 +47,6 @@ class Developer < Account
 end
 ```
 
-ActiveRecord queries work as usual with the following differences:
-
-* You need to specify which model represents the base of your multi table inheritance tree. To do so, insert `uses_mti` in the model definition of the base class.
-* The default query of "*" is changed to include the OID of each row for subclass discrimination. The default select will be `SELECT cast("accounts"."tableoid"::regclass AS text), "accounts".*` (for example)
-
 ### Migrations
 
 In your migrations define a table to inherit from another table:

data/Rakefile

@@ -1,2 +1,6 @@
 require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
 
+RSpec::Core::RakeTask.new
+
+task default: :spec

data/active_record-mti.gemspec

@@ -10,8 +10,8 @@ Gem::Specification.new do |spec|
   spec.email         = ["dale@twilightcoders.net"]
 
   spec.summary       = %q{Multi Table Inheritance for PostgreSQL in Rails}
-  spec.description   = %q{Allows use of native inherited tables in PostgreSQL}
-  spec.homepage      = ""
+  spec.description   = %q{Gives ActiveRecord support for PostgreSQL's native inherited tables}
+  spec.homepage      = "https://github.com/twilightcoders/active_record-mti"
   spec.license       = "MIT"
 
   # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
@@ -22,23 +22,20 @@ Gem::Specification.new do |spec|
     raise 'RubyGems 2.0 or newer is required to protect against public gem pushes.'
   end
 
-  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
-  spec.bindir        = 'exe'
-  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ['lib']
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.bindir        = 'bin'
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib', 'spec']
 
-  rails_versions = ['>= 4.1', '< 5']
-  spec.required_ruby_version = '>= 2.0.0'
+  rails_versions = ['>= 4', '< 6']
+  spec.required_ruby_version = '>= 2.0'
 
   spec.add_runtime_dependency 'pg', '~> 0'
   spec.add_runtime_dependency 'activerecord', rails_versions
 
-  spec.add_development_dependency 'pry-byebug'
+  spec.add_development_dependency 'pry-byebug', '~> 3'
   spec.add_development_dependency 'bundler', '~> 1.3'
   spec.add_development_dependency 'rake', '~> 10.0'
-  spec.add_development_dependency 'rspec', '~> 3.0'
-  spec.add_development_dependency 'simplecov', '~> 0.1'
-  spec.add_development_dependency 'codeclimate-test-reporter', '~> 1.0'
-  spec.add_development_dependency 'database_cleaner', '~> 1.6'
 
 end

data/gemfiles/activerecord-4.0.Gemfile

@@ -0,0 +1,3 @@
+eval_gemfile File.join(File.dirname(__FILE__), "../Gemfile")
+
+gem 'activerecord', '~> 4.0.0'

data/gemfiles/activerecord-4.1.Gemfile

@@ -0,0 +1,3 @@
+eval_gemfile File.join(File.dirname(__FILE__), "../Gemfile")
+
+gem 'activerecord', '~> 4.1.0'

data/gemfiles/activerecord-4.2.Gemfile

@@ -0,0 +1,3 @@
+eval_gemfile File.join(File.dirname(__FILE__), "../Gemfile")
+
+gem 'activerecord', '~> 4.2.0'

data/gemfiles/activerecord-5.0.Gemfile

@@ -0,0 +1,3 @@
+eval_gemfile File.join(File.dirname(__FILE__), "../Gemfile")
+
+gem 'activerecord', '~> 5.0.0'

data/gemfiles/activerecord-5.1.Gemfile

@@ -0,0 +1,3 @@
+eval_gemfile File.join(File.dirname(__FILE__), "../Gemfile")
+
+gem 'activerecord', '~> 5.1.0'

data/lib/active_record/mti/calculations.rb

@@ -1,121 +1,22 @@
 module ActiveRecord
   module MTI
     module Calculations
+      extend ActiveSupport::Concern
 
       private
 
-      def execute_grouped_calculation(operation, column_name, distinct) #:nodoc:
-        group_attrs = group_values
-
-        if group_attrs.first.respond_to?(:to_sym)
-          association  = @klass._reflect_on_association(group_attrs.first)
-          associated   = group_attrs.size == 1 && association && association.belongs_to? # only count belongs_to associations
-          group_fields = Array(associated ? association.foreign_key : group_attrs)
-        else
-          group_fields = group_attrs
+      def perform_calculation(*args)
+        result = swap_and_restore_tableoid_cast(true) do
+          super
         end
-        group_fields = arel_columns(group_fields)
-
-        group_aliases = group_fields.map { |field|
-          column_alias_for(field)
-        }
-        group_columns = group_aliases.zip(group_fields).map { |aliaz,field|
-          [aliaz, field]
-        }
-
-        group = group_fields
-
-        if operation == 'count' && column_name == :all
-          aggregate_alias = 'count_all'
-        else
-          aggregate_alias = column_alias_for([operation, column_name].join(' '))
-        end
-
-        select_values = [
-          operation_over_aggregate_column(
-            aggregate_column(column_name),
-            operation,
-            distinct).as(aggregate_alias)
-        ]
-        select_values += select_values unless having_values.empty?
-
-        select_values.concat group_fields.zip(group_aliases).map { |field,aliaz|
-          if field.respond_to?(:as)
-            field.as(aliaz)
-          else
-            "#{field} AS #{aliaz}"
-          end
-        }
-
-        relation = except(:group)
-        relation.group_values  = group
-        relation.select_values = select_values
-
-        # Remove our cast otherwise PSQL will insist that it be included in the GROUP
-        relation.arel.projections.select!{ |p| p.to_s != tableoid_cast(klass) } if @klass.using_multi_table_inheritance?
-
-        calculated_data = @klass.connection.select_all(relation, nil, relation.arel.bind_values + bind_values)
-
-        if association
-          key_ids     = calculated_data.collect { |row| row[group_aliases.first] }
-          key_records = association.klass.base_class.find(key_ids)
-          key_records = Hash[key_records.map { |r| [r.id, r] }]
-        end
-
-        Hash[calculated_data.map do |row|
-          key = group_columns.map { |aliaz, col_name|
-            column = calculated_data.column_types.fetch(aliaz) do
-              type_for(col_name)
-            end
-            type_cast_calculated_value(row[aliaz], column)
-          }
-          key = key.first if key.size == 1
-          key = key_records[key] if associated
-
-          column_type = calculated_data.column_types.fetch(aggregate_alias) { type_for(column_name) }
-          [key, type_cast_calculated_value(row[aggregate_alias], column_type, operation)]
-        end]
       end
 
-      def execute_simple_calculation(operation, column_name, distinct) #:nodoc:
-        # Postgresql doesn't like ORDER BY when there are no GROUP BY
-        relation = unscope(:order)
-
-        column_alias = column_name
-
-        bind_values = nil
-
-        if operation == "count" && (relation.limit_value || relation.offset_value)
-          # Shortcut when limit is zero.
-          return 0 if relation.limit_value == 0
-
-          query_builder = build_count_subquery(relation, column_name, distinct)
-          bind_values = query_builder.bind_values + relation.bind_values
-        else
-          column = aggregate_column(column_name)
-
-          select_value = operation_over_aggregate_column(column, operation, distinct)
-
-          column_alias = select_value.alias
-          column_alias ||= @klass.connection.column_name_for_operation(operation, select_value)
-          relation.select_values = [select_value]
-
-          # Remove our cast otherwise PSQL will insist that it be included in the GROUP
-          # Somewhere between line 82 and 101 relation.arel.projections gets reset :/
-          relation.arel.projections.select!{ |p| p != tableoid_cast(klass) } if @klass.using_multi_table_inheritance?
-
-          query_builder = relation.arel
-          bind_values = query_builder.bind_values + relation.bind_values
-        end
-
-        result = @klass.connection.select_all(query_builder, nil, bind_values)
-        row    = result.first
-        value  = row && row.values.first
-        column = result.column_types.fetch(column_alias) do
-          type_for(column_name)
-        end
-
-        type_cast_calculated_value(value, column, operation)
+      def swap_and_restore_tableoid_cast(value, &block)
+        orignal_value = Thread.current['skip_tableoid_cast']
+        Thread.current['skip_tableoid_cast'] = value
+        return_value = yield
+        Thread.current['skip_tableoid_cast'] = orignal_value
+        return return_value
       end
 
     end

data/lib/active_record/mti/connection_adapters/postgresql/schema_statements.rb

@@ -27,43 +27,18 @@ module ActiveRecord
               table_name = %Q("#{schema}"."#{table_name}")
             end
 
-            if parent_table = options.delete(:inherits)
-              options[:options] = [%Q(INHERITS ("#{parent_table}")), options[:options]].compact.join
+            if inherited_table = options.delete(:inherits)
+              # options[:options] = options[:options].sub("INHERITS", "() INHERITS") if td.columns.empty?
+              options[:options] = [%Q(INHERITS ("#{inherited_table}")), options[:options]].compact.join
             end
 
-            td = create_table_definition table_name, options[:temporary], options[:options], options[:as]
-
-            if options[:id] != false && !options[:as]
-              pk = options.fetch(:primary_key) do
-                Base.get_primary_key table_name.to_s.singularize
-              end
-
-              if pk.is_a?(Array)
-                td.primary_keys pk
-              else
-                td.primary_key pk, options.fetch(:id, :primary_key), options
-              end
-            end
-
-            yield td if block_given?
-
-            if options[:force] && data_source_exists?(table_name)
-              drop_table(table_name, options)
-            end
-
-            # Rails 5 wont create an empty column list which we might have if we're
-            # working with inherited tables.  So we need to do that manually
-            sql = schema_creation.accept(td)
-            # sql = sql.sub("INHERITS", "() INHERITS") if td.columns.empty?
-
-            result = execute sql
-
-            if parent_table
-              parent_table_primary_key = primary_key(parent_table)
-              execute %Q(ALTER TABLE "#{table_name}" ADD PRIMARY KEY ("#{parent_table_primary_key}"))
+            results = super(table_name, options)
 
+            if inherited_table
+              inherited_table_primary_key = primary_key(inherited_table)
+              execute %Q(ALTER TABLE "#{table_name}" ADD PRIMARY KEY ("#{inherited_table_primary_key}"))
 
-              indexes(parent_table).each do |index|
+              indexes(inherited_table).each do |index|
                 attributes = index.to_h.slice(:unique, :using, :where, :orders)
 
                 # Why rails insists on being inconsistant with itself is beyond me.
@@ -71,14 +46,9 @@ module ActiveRecord
 
                 add_index table_name, index.columns, attributes
               end
-              # triggers_for_table(parent_table).each do |trigger|
-              #   name = trigger.first
-              #   definition = trigger.second.merge(on: table_name)
-              #   create_trigger name, definition
-              # end
             end
 
-            td.indexes.each_pair { |c,o| add_index table_name, c, o }
+            results
           end
 
           # Parent of inherited table

data/lib/active_record/mti/inheritance.rb

@@ -1,32 +1,13 @@
 require 'active_support/concern'
 
 module ActiveRecord
-  # == Multi table inheritance
-  #
-  # PostgreSQL allows for table inheritance. To enable this in ActiveRecord, ensure that the
-  # inheritance_column is named "tableoid" (can be changed by setting <tt>Base.inheritance_column</tt>).
-  # This means that an inheritance looking like this:
-  #
-  #   class Company < ActiveRecord::Base;
-  #     self.inheritance_column = 'tableoid'
-  #   end
-  #   class Firm < Company; end
-  #   class Client < Company; end
-  #   class PriorityClient < Client; end
-  #
-  # When you do <tt>Firm.create(name: "37signals")</tt>, this record will be saved in
-  # the firms table which inherits from companies. You can then fetch this row again using
-  # <tt>Company.where(name: '37signals').first</tt> and it will return a Firm object.
-  #
-  # Note, all the attributes for all the cases are kept in the same table. Read more:
-  # http://www.martinfowler.com/eaaCatalog/singleTableInheritance.html
-  #
+  # == Multi-Table Inheritance
   module MTI
     module Inheritance
       extend ActiveSupport::Concern
-      @mti_tableoids = {}
 
       included do
+        @@mti_tableoids = {}
         scope :discern_inheritance, -> {
 
         }
@@ -34,12 +15,14 @@ module ActiveRecord
 
       module ClassMethods
 
+        @uses_mti = nil
+        @mti_setup = false
+        @mti_type_column = nil
+
         def uses_mti(custom_table_name = nil, inheritance_column = nil)
           self.inheritance_column = inheritance_column
 
           @uses_mti = true
-          @mti_setup = false
-          @mti_tableoid_projection = nil
           @tableoid_column = nil
         end
 
@@ -48,8 +31,14 @@ module ActiveRecord
         end
 
         def uses_mti?
-          inheritence_check = check_inheritence_of(@table_name) unless @mti_setup
-          @uses_mti = inheritence_check if @uses_mti.nil?
+          inheritance_check = check_inheritance_of(@table_name) unless @mti_setup
+
+          if @uses_mti.nil? && @uses_mti = inheritance_check
+            descendants.each do |d|
+              d.uses_mti?
+            end
+          end
+
           @uses_mti
         end
 
@@ -57,17 +46,17 @@ module ActiveRecord
           @tableoid_column != false
         end
 
-        def mti_tableoid_projection
-          @mti_tableoid_projection
+        def mti_type_column
+          @mti_type_column
         end
 
-        def mti_tableoid_projection=(value)
-          @mti_tableoid_projection = value
+        def mti_type_column=(value)
+          @mti_type_column = value
         end
 
         private
 
-        def check_inheritence_of(table_name)
+        def check_inheritance_of(table_name)
           ActiveRecord::MTI.logger.debug "Trying to check inheritance of table with no table name (#{self})" unless table_name
           return nil unless table_name
 
@@ -82,21 +71,23 @@ module ActiveRecord
               LEFT JOIN pg_catalog.pg_class    AS cl_d ON cl_d.oid   = d.refobjid
               WHERE inhrelid  = COALESCE(cl_d.relname, 'public.#{table_name}')::regclass::oid
               OR    inhparent = COALESCE(cl_d.relname, 'public.#{table_name}')::regclass::oid
-            );
+            ) AS uses_inheritance;
           SQL
 
-          uses_inheritence = result.try(:first).try(:values).try(:first) == 't'
+          uses_inheritance = ActiveRecord::MTI.testify(result.try(:first)['uses_inheritance'])
 
-          register_tableoid(table_name, uses_inheritence)
+          register_tableoid(table_name) if uses_inheritance
 
           @mti_setup = true
           # Some versions of PSQL return {"?column?"=>"t"}
           # instead of {"exists"=>"t"}, so we're saying screw it,
           # just give me the first value of whatever is returned
-          return uses_inheritence
+
+          # Ensure a boolean is returned
+          return uses_inheritance == true
         end
 
-        def register_tableoid(table_name, uses_mti=false)
+        def register_tableoid(table_name)
 
           tableoid_query = connection.execute(<<-SQL
             SELECT '#{table_name}'::regclass::oid AS tableoid, (SELECT EXISTS (
@@ -109,13 +100,14 @@ module ActiveRecord
           SQL
           ).first
           tableoid = tableoid_query['tableoid']
-          @tableoid_column = tableoid_query['has_tableoid_column'] == 't'
+          @tableoid_column = ActiveRecord::MTI.testify(tableoid_query['has_tableoid_column'])
 
           if (has_tableoid_column?)
-            ActiveRecord::MTI.logger.debug "#{table_name} has tableoid column!"
-            @mti_tableoid_projection = arel_table[:tableoid].as('tableoid')
+            ActiveRecord::MTI.logger.debug "#{table_name} has tableoid column! (#{tableoid})"
+            add_tableoid_column
+            @mti_type_column = arel_table[:tableoid]
           else
-            @mti_tableoid_projection = nil
+            @mti_type_column = nil
           end
 
           Inheritance.add_mti(tableoid, self)
@@ -156,14 +148,34 @@ module ActiveRecord
             sti_column.in(sti_names)
           end
         end
+
+        def add_tableoid_column
+          if self.respond_to? :attribute
+            self.attribute :tableoid, get_integer_oid_class.new
+          else
+            columns.unshift ActiveRecord::ConnectionAdapters::PostgreSQLColumn.new('tableoid', nil, ActiveRecord::ConnectionAdapters::PostgreSQLAdapter::OID::Integer.new, "oid", false)
+          end
+        end
+
+        # Rails decided to make a breaking change in it's 4.x series :P
+        def get_integer_oid_class
+          ::ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Integer
+        rescue NameError
+          begin
+            ::ActiveRecord::ConnectionAdapters::PostgreSQLAdapter::OID::Integer
+          rescue NameError
+            ::ActiveModel::Type::Integer
+          end
+        end
+
       end
 
       def self.add_mti(tableoid, klass)
-        @mti_tableoids[tableoid.to_s.to_sym] = klass
+        @@mti_tableoids[tableoid.to_s.to_sym] = klass
       end
 
       def self.find_mti(tableoid)
-        @mti_tableoids[tableoid.to_s.to_sym]
+        @@mti_tableoids[tableoid.to_s.to_sym]
       end
 
     end

data/lib/active_record/mti/model_schema.rb

@@ -44,6 +44,14 @@ module ActiveRecord
           end
         end
 
+        def full_table_name_prefix #:nodoc:
+          (parents.detect{ |p| p.respond_to?(:table_name_prefix) } || self).table_name_prefix
+        end
+
+        def full_table_name_suffix #:nodoc:
+          (parents.detect {|p| p.respond_to?(:table_name_suffix) } || self).table_name_suffix
+        end
+
         private
 
         # Guesses the table name, but does not decorate it with prefix and suffix information.

data/lib/active_record/mti/query_methods.rb

@@ -1,26 +1,48 @@
 module ActiveRecord
   module MTI
     module QueryMethods
+      extend ActiveSupport::Concern
 
-      private
+      def build_arel
+        select_by_tableoid = select_values.delete(:tableoid) == :tableoid
+        group_by_tableoid = group_values.delete(:tableoid) == :tableoid
 
-      # Retrieve the OID as well on a default select
-      def build_select(arel)
-        if @klass.using_multi_table_inheritance? && @klass.has_tableoid_column?
-          arel.project(tableoid_cast(@klass))
-        end
+        arel = super
 
-        if select_values.any?
-          arel.project(*arel_columns(select_values.uniq))
-        else
-          arel.project(@klass.arel_table[Arel.star])
+        if tableoid?(@klass) || group_by_tableoid || select_by_tableoid
+          arel.project(tableoid_project(@klass))
+          arel.group(tableoid_group(@klass)) if group_values.any? || group_by_tableoid
         end
+
+        arel
+      end
+
+      private
+
+      def tableoid?(klass)
+        !Thread.current['skip_tableoid_cast'] &&
+        @klass.using_multi_table_inheritance? &&
+        @klass.has_tableoid_column?
       end
 
-      def tableoid_cast(klass)
+      def tableoid_project?(klass)
+        tableoid?(klass) &&
+        (group_values - [:tableoid]).any?
+      end
+
+      def tableoid_group?(klass)
+        tableoid?(klass) &&
+        group_values.any?
+      end
+
+      def tableoid_project(klass)
         # Arel::Nodes::NamedFunction.new('CAST', [klass.arel_table[:tableoid].as('regclass')])
         # Arel::Nodes::NamedFunction.new('CAST', [@klass.arel_table['tableoid::regclass'].as('regclass')])
-        @klass.mti_tableoid_projection
+        @klass.mti_type_column.as('tableoid')
+      end
+
+      def tableoid_group(klass)
+        @klass.mti_type_column
       end
 
     end

data/lib/active_record/mti/railtie.rb

@@ -4,7 +4,7 @@ module ActiveRecord
   module MTI
     class Railtie < Rails::Railtie
       initializer 'active_record-mti.load' do |_app|
-        ActiveRecord::MTI.logger.info "ActiveRecord::MTI railtie initializer"
+        ActiveRecord::MTI.logger.debug "active_record-mti.load"
         ActiveSupport.on_load(:active_record) do
           ActiveRecord::MTI.load
         end

data/lib/active_record/mti/version.rb

@@ -1,5 +1,5 @@
 module ActiveRecord
   module MTI
-    VERSION = '0.2.1'
+    VERSION = '0.3.0-rc1'
   end
 end

data/lib/active_record/mti.rb

@@ -32,11 +32,16 @@ module ActiveRecord
     def self.load
       ::ActiveRecord::Base.send                                  :include, Inheritance
       ::ActiveRecord::Base.send                                  :include, ModelSchema
-      ::ActiveRecord::Relation.send                              :include, QueryMethods
-      ::ActiveRecord::Relation.send                              :include, Calculations
+      ::ActiveRecord::Relation.send                              :prepend, QueryMethods
+      ::ActiveRecord::Relation.send                              :prepend, Calculations
       ::ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.send :prepend, ConnectionAdapters::PostgreSQL::Adapter
       ::ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.send :include, ConnectionAdapters::PostgreSQL::SchemaStatements
       ::ActiveRecord::SchemaDumper.send                          :include, SchemaDumper
     end
+
+    def self.testify(value)
+      value == true || value == 't' || value == 1 || value == '1'
+    end
+
   end
 end

data/spec/active_record/calculations_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe ActiveRecord::MTI::Calculations do
+
+  context "don't project tableoid on" do
+    it "grouping" do
+
+      Admin.create(email: 'foo@bar.baz', god_powers: 3)
+      Admin.create(email: 'foo@bar.baz', god_powers: 3)
+      Admin.create(email: 'foo24@bar.baz', god_powers: 3)
+
+      grouped_count = Admin.group(:email).count
+
+      expect(grouped_count['foo24@bar.baz']).to eq(1)
+      expect(grouped_count['foo@bar.baz']).to eq(2)
+
+    end
+
+    it "count calculations" do
+
+      Admin.create(email: 'foo@bar.baz', god_powers: 3)
+      Admin.create(email: 'foo@bar.baz', god_powers: 3)
+      Admin.create(email: 'foo24@bar.baz', god_powers: 3)
+
+      expect(Admin.count(:email)).to eq(3)
+
+    end
+  end
+
+  context "projects tableoid" do
+    it "and groups tableoid when selecting :tableoid" do
+      sql = Admin.select(:email, :tableoid).group(:email).to_sql
+
+      expect(sql).to match(/SELECT .*, \"admins\".\"tableoid\" AS tableoid FROM \"admins\"/)
+
+      expect(sql).to match(/GROUP BY .*, \"admins\".\"tableoid\"/)
+    end
+
+    it "when grouping :tableoid" do
+      sql = Admin.select(:email).group(:email, :tableoid).to_sql
+
+      expect(sql).to match(/SELECT .*, \"admins\".\"tableoid\" AS tableoid FROM \"admins\"/)
+
+      expect(sql).to match(/GROUP BY .*, \"admins\".\"tableoid\"/)
+    end
+  end
+
+end

data/spec/active_record/mti/inheritence_spec.rb

@@ -0,0 +1,145 @@
+require 'spec_helper'
+
+describe ActiveRecord::MTI::Inheritance do
+
+  xit 'returns non-nil value when checking uses_mti?' do
+    # Mod = Class.new(User)
+    # expect(Mod.uses_mti?).to be(true)
+  end
+
+  context 'class definition' do
+
+    describe 'for classes that use MTI' do
+      it "doesn't check inheritance multiple times" do
+        Admin.instance_variable_set(:@mti_setup, false)
+        expect(Admin).to receive(:check_inheritance_of).and_call_original.exactly(1).times
+
+        Admin.create(email: 'foo@bar.baz', god_powers: 3)
+        Admin.create(email: 'foo2@bar.baz', god_powers: 3)
+        Admin.create(email: 'foo24@bar.baz', god_powers: 3)
+
+      end
+    end
+
+    describe "for classes that don't use MTI" do
+      it "doesn't check inheritance multiple times" do
+        Post.instance_variable_set(:@uses_mti, nil)
+        expect(Post).to receive(:check_inheritance_of).and_call_original.exactly(1).times
+
+        Post.create(title: 'foo@bar.baz')
+        Post.create(title: 'foo2@bar.baz')
+        Post.create(title: 'foo24@bar.baz')
+
+      end
+    end
+
+  end
+
+  context 'default inheritance_column model' do
+    let!(:user) { User.create(email: 'foo@bar.baz') }
+    let!(:admin) { Admin.create(email: 'foo@bar.baz', god_powers: 3) }
+
+    it 'casts properly' do
+      user = User.first
+      expect(user.class).to eq(User)
+    end
+
+    describe 'base class querying' do
+      it 'casts children properly' do
+        users = User.all
+        expect(users.select{ |u| u.is_a?(Admin) }.count).to eql(1)
+      end
+
+      xit 'deserializes children with child specific data' do
+        my_admin = User.find(admin.id)
+        expect(my_admin.god_powers).to eql(3)
+      end
+    end
+
+    describe 'has the correct count for' do
+      it 'parents' do
+        users = User.all
+        expect(users.count).to eq(2)
+      end
+
+      it 'children' do
+        admins = Admin.all
+        expect(admins.count).to eq(1)
+      end
+    end
+
+    describe 'dynamic class creation' do
+      it 'infers the table_name from superclass not base_class' do
+        god = Class.new(Admin)
+        expect(god.table_name).to eql(Admin.table_name)
+      end
+    end
+  end
+
+  describe 'views' do
+    before(:each) do
+      class UserView < User
+        self.table_name = "users_all"
+      end
+
+      UserView.connection.execute <<-SQL
+        CREATE OR REPLACE VIEW "users_all"
+        AS #{ User.all.to_sql }
+      SQL
+    end
+
+    if ActiveRecord::Base.connection.version >= Gem::Version.new('9.4')
+      it 'allows creation pass-through' do
+
+        UserView.create(email: 'dale@twilightcoders.net')
+      end
+    end
+  end
+
+  describe 'dynamic class creation' do
+    it 'infers the table_name from superclass not base_class' do
+      God = Class.new(Admin)
+
+      Hacker = Class.new(Admin) do
+        uses_mti
+      end
+
+      expect(God.table_name).to eql(Admin.table_name)
+      expect(Hacker.table_name).to eql('admin/hackers')
+    end
+  end
+
+  describe 'custom inheritance_column model' do
+    let!(:vehicle) { Transportation::Vehicle.create(color: :red) }
+    let!(:truck) { Transportation::Truck.create(color: :blue, bed_size: 10) }
+
+    describe 'inheritance_column' do
+      xit 'should set the custom column correctly' do
+        expect(vehicle.type).to eql('vehicles')
+        expect(truck.type).to eql('trucks')
+      end
+    end
+
+    describe 'base class querying' do
+      it 'casts children properly' do
+        expect(Transportation::Vehicle.all.select{ |v| v.is_a?(Transportation::Truck) }.count).to eql(1)
+      end
+
+      xit 'deserializes children with child specific data' do
+        my_truck = Transportation::Vehicle.find(truck.id)
+        expect(my_truck.bed_size).to eql(10)
+      end
+    end
+
+    describe 'has the correct count for' do
+      it 'parents' do
+        expect(Transportation::Vehicle.count).to eql(2)
+      end
+
+      it 'children' do
+        expect(Transportation::Truck.count).to eql(1)
+      end
+    end
+  end
+
+end

data/spec/active_record/mti_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe ActiveRecord::MTI do
+
+  context 'helper' do
+
+    describe '#testify' do
+      it "returns true for truthy values" do
+        expect(ActiveRecord::MTI.testify('f')).to eq(false)
+      end
+    end
+
+  end
+
+end

data/spec/schema.rb

@@ -0,0 +1,42 @@
+ActiveRecord::Schema.define do
+  self.verbose = false
+
+  create_table :users, force: true do |t|
+    t.string :email
+    t.timestamps null: false
+  end
+
+  create_table :admins, force: true, inherits: :users do |t|
+    t.integer :god_powers
+  end
+
+  create_table 'admin/hackers', force: true, inherits: :admins do |t|
+    t.integer :god_powers
+  end
+
+  create_table :posts, force: true do |t|
+    t.integer :user_id
+    t.string :title
+    t.timestamps null: false
+  end
+
+  create_table :comments, force: true do |t|
+    t.integer :user_id
+    t.integer :post_id
+    t.timestamps null: false
+  end
+
+  #################################
+  ### Custom Inheritance Column ###
+  #################################
+
+  create_table :vehicles, force: true do |t|
+    t.string :color
+    t.string :type # Inheritance column
+    t.timestamps null: false
+  end
+
+  create_table "vehicles/trucks", force: true, inherits: :vehicles do |t|
+    t.integer :bed_size
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,46 @@
+ENV['RAILS_ENV'] = 'test'
+
+require 'database_cleaner'
+
+require 'simplecov'
+SimpleCov.start do
+  # add_group 'Lib', 'lib'
+  add_filter 'spec'
+end
+
+require 'active_record/mti'
+
+ActiveRecord::MTI.load
+
+db_config = {
+  adapter: 'postgresql', database: 'active_record-mti-test'
+}
+
+db_config_admin = db_config.merge({ database: 'postgres', schema_search_path: 'public' })
+
+ActiveRecord::Base.establish_connection db_config_admin
+ActiveRecord::Base.connection.drop_database(db_config[:database])
+ActiveRecord::Base.connection.create_database(db_config[:database])
+ActiveRecord::Base.establish_connection db_config
+
+load File.dirname(__FILE__) + '/schema.rb'
+
+Dir[File.join(File.dirname(__FILE__), '..', 'spec', 'support', '**', '**.rb')].each do |f|
+  require f
+end
+
+RSpec.configure do |config|
+  config.order = 'random'
+
+  # Configure the DatabaseCleaner
+  config.before(:suite) do
+    DatabaseCleaner.strategy = :transaction
+    DatabaseCleaner.clean_with(:truncation)
+  end
+
+  config.around(:each) do |example|
+    DatabaseCleaner.cleaning do
+      example.run
+    end
+  end
+end

data/spec/support/models.rb

@@ -0,0 +1,34 @@
+require 'active_record'
+
+class Comment < ::ActiveRecord::Base
+  belongs_to :user
+  belongs_to :post
+
+end
+
+class Post < ::ActiveRecord::Base
+  belongs_to :user
+  has_many :comments
+end
+
+class User < ::ActiveRecord::Base
+  uses_mti
+
+  has_many :posts
+  has_many :comments
+
+end
+
+class Admin < User
+  self.table_name = 'admins'
+end
+
+module Transportation
+  class Vehicle < ::ActiveRecord::Base
+    uses_mti
+  end
+
+  class Truck < Vehicle
+    self.table_name = 'vehicles/trucks'
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_record-mti
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0.pre.rc1
 platform: ruby
 authors:
 - Dale Stevens
 autorequire: 
-bindir: exe
+bindir: bin
 cert_chain: []
-date: 2017-09-20 00:00:00.000000000 Z
+date: 2017-11-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg
@@ -30,34 +30,34 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.1'
+        version: '4'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '5'
+        version: '6'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.1'
+        version: '4'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '5'
+        version: '6'
 - !ruby/object:Gem::Dependency
   name: pry-byebug
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -86,63 +86,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
-- !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.0'
-- !ruby/object:Gem::Dependency
-  name: simplecov
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.1'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.1'
-- !ruby/object:Gem::Dependency
-  name: codeclimate-test-reporter
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.0'
-- !ruby/object:Gem::Dependency
-  name: database_cleaner
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.6'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.6'
-description: Allows use of native inherited tables in PostgreSQL
+description: Gives ActiveRecord support for PostgreSQL's native inherited tables
 email:
 - dale@twilightcoders.net
 executables: []
@@ -152,11 +96,17 @@ files:
 - ".gitignore"
 - ".rspec"
 - ".travis.yml"
+- CHANGELOG.md
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - active_record-mti.gemspec
+- gemfiles/activerecord-4.0.Gemfile
+- gemfiles/activerecord-4.1.Gemfile
+- gemfiles/activerecord-4.2.Gemfile
+- gemfiles/activerecord-5.0.Gemfile
+- gemfiles/activerecord-5.1.Gemfile
 - lib/active_record/mti.rb
 - lib/active_record/mti/calculations.rb
 - lib/active_record/mti/connection_adapters/postgresql/adapter.rb
@@ -168,7 +118,13 @@ files:
 - lib/active_record/mti/railtie.rb
 - lib/active_record/mti/schema_dumper.rb
 - lib/active_record/mti/version.rb
-homepage: ''
+- spec/active_record/calculations_spec.rb
+- spec/active_record/mti/inheritence_spec.rb
+- spec/active_record/mti_spec.rb
+- spec/schema.rb
+- spec/spec_helper.rb
+- spec/support/models.rb
+homepage: https://github.com/twilightcoders/active_record-mti
 licenses:
 - MIT
 metadata:
@@ -177,20 +133,27 @@ post_install_message:
 rdoc_options: []
 require_paths:
 - lib
+- spec
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.0.0
+      version: '2.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.6.11
 signing_key: 
 specification_version: 4
 summary: Multi Table Inheritance for PostgreSQL in Rails
-test_files: []
+test_files:
+- spec/active_record/calculations_spec.rb
+- spec/active_record/mti/inheritence_spec.rb
+- spec/active_record/mti_spec.rb
+- spec/schema.rb
+- spec/spec_helper.rb
+- spec/support/models.rb