deep_pluck 1.1.1 → 1.1.6

data/Rakefile

@@ -1,10 +1,10 @@
-require "bundler/gem_tasks"
-require "rake/testtask"
+require 'bundler/gem_tasks'
+require 'rake/testtask'
 
 Rake::TestTask.new(:test) do |t|
-  t.libs << "test"
-  t.libs << "lib"
+  t.libs << 'test'
+  t.libs << 'lib'
   t.test_files = FileList['test/**/*_test.rb']
 end
 
-task :default => :test
+task default: :test

data/bin/console

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 
-require "bundler/setup"
-require "deep_pluck"
+require 'bundler/setup'
+require 'deep_pluck'
 
 # You can add fixtures and/or initialization code here to make experimenting
 # with your gem easier. You can also use a different console, if you like.
@@ -10,5 +10,5 @@ require "deep_pluck"
 # require "pry"
 # Pry.start
 
-require "irb"
+require 'irb'
 IRB.start

data/bin/setup

@@ -1,8 +1,8 @@
-#!/usr/bin/env bash
-set -euo pipefail
-IFS=$'\n\t'
-set -vx
-
-bundle install --gemfile=gemfiles/4.2.gemfile
-
-# Do any other automated setup that you need to do here
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install --gemfile=gemfiles/4.2.gemfile
+
+# Do any other automated setup that you need to do here

data/deep_pluck.gemspec

@@ -1,38 +1,45 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'deep_pluck/version'
-
-Gem::Specification.new do |spec|
-  spec.name          = "deep_pluck"
-  spec.version       = DeepPluck::VERSION
-  spec.authors       = ["khiav reoy"]
-  spec.email         = ["mrtmrt15xn@yahoo.com.tw"]
-
-  spec.summary       = %q{Use deep_pluck as a shortcut to select one or more attributes and include associated models without loading a bunch of records.}
-  spec.description   = %q{Use deep_pluck as a shortcut to select one or more attributes and include associated models without loading a bunch of records. And DRY up your code when using #as_json.}
-  spec.homepage      = "https://github.com/khiav223577/deep_pluck"
-  spec.license       = "MIT"
-
-  # Prevent pushing this gem to RubyGems.org by setting 'allowed_push_host', or
-  # delete this section to allow pushing this gem to any host.
-  #if spec.respond_to?(:metadata)
-  #  spec.metadata['allowed_push_host'] = "TODO: Set to 'http://mygemserver.com'"
-  #else
-  #  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.add_development_dependency "bundler", "~> 1.11"
-  spec.add_development_dependency "rake", "~> 12.0"
-  spec.add_development_dependency "sqlite3", "~> 1.3"
-  spec.add_development_dependency "minitest", "~> 5.0"
-
-  spec.add_dependency "activerecord", ">= 3"
-  spec.add_dependency "pluck_all", ">= 1.2.3"
-
-end
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'deep_pluck/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'deep_pluck'
+  spec.version       = DeepPluck::VERSION
+  spec.authors       = ['khiav reoy']
+  spec.email         = ['mrtmrt15xn@yahoo.com.tw']
+
+  spec.summary       = 'Use deep_pluck as a shortcut to select one or more attributes and include associated models without loading a bunch of records.'
+  spec.description   = 'Use deep_pluck as a shortcut to select one or more attributes and include associated models without loading a bunch of records. And DRY up your code when using #as_json.'
+  spec.homepage      = 'https://github.com/khiav223577/deep_pluck'
+  spec.license       = 'MIT'
+
+  # Prevent pushing this gem to RubyGems.org by setting 'allowed_push_host', or
+  # delete this section to allow pushing this gem to any host.
+  # if spec.respond_to?(:metadata)
+  #  spec.metadata['allowed_push_host'] = "TODO: Set to 'http://mygemserver.com'"
+  # else
+  #  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.metadata      = {
+    'homepage_uri'      => 'https://github.com/khiav223577/deep_pluck',
+    'changelog_uri'     => 'https://github.com/khiav223577/deep_pluck/blob/master/CHANGELOG.md',
+    'source_code_uri'   => 'https://github.com/khiav223577/deep_pluck',
+    'documentation_uri' => 'https://www.rubydoc.info/gems/deep_pluck',
+    'bug_tracker_uri'   => 'https://github.com/khiav223577/deep_pluck/issues',
+  }
+
+  spec.add_development_dependency 'bundler', '>= 1.17', '< 3.x'
+  spec.add_development_dependency 'rake', '~> 12.0'
+  spec.add_development_dependency 'sqlite3', '~> 1.3'
+  spec.add_development_dependency 'minitest', '~> 5.0'
+
+  spec.add_dependency 'activerecord', '>= 3'
+  spec.add_dependency 'pluck_all', '>= 1.2.3'
+  spec.add_dependency 'rails_compatibility', '>= 0.0.3'
+end

data/gemfiles/3.2.gemfile

@@ -1,14 +1,11 @@
-source 'https://rubygems.org'
-
-# Specify your gem's dependencies in pluck_all.gemspec
-
-gem "activerecord", "~> 3.2.0"
-gem "pluck_all", "~> 1.2.2"
-
-group :test do
-  gem "simplecov"
-  gem "codeclimate-test-reporter", "~> 1.0.0"
-end
-
-gemspec :path => "../"
-
+source 'https://rubygems.org'
+
+gem 'activerecord', '~> 3.2.0'
+gem 'pluck_all', '~> 1.2.2'
+
+group :test do
+  gem 'simplecov', '< 0.18'
+  gem 'sqlite3', '~> 1.3.6'
+end
+
+gemspec path: '../'

data/gemfiles/4.2.gemfile

@@ -1,14 +1,11 @@
-source 'https://rubygems.org'
-
-# Specify your gem's dependencies in pluck_all.gemspec
-
-gem "activerecord", "~> 4.2.0"
-gem "pluck_all", "~> 1.2.2"
-
-group :test do
-  gem "simplecov"
-  gem "codeclimate-test-reporter", "~> 1.0.0"
-end
-
-gemspec :path => "../"
-
+source 'https://rubygems.org'
+
+gem 'activerecord', '~> 4.2.0'
+gem 'pluck_all', '~> 1.2.2'
+
+group :test do
+  gem 'simplecov', '< 0.18'
+  gem 'sqlite3', '~> 1.3.6'
+end
+
+gemspec path: '../'

data/gemfiles/5.0.gemfile

@@ -1,14 +1,11 @@
-source 'https://rubygems.org'
-
-# Specify your gem's dependencies in pluck_all.gemspec
-
-gem "activerecord", "~> 5.0.0"
-gem "pluck_all", "~> 1.2.2"
-
-group :test do
-  gem "simplecov"
-  gem "codeclimate-test-reporter", "~> 1.0.0"
-end
-
-gemspec :path => "../"
-
+source 'https://rubygems.org'
+
+gem 'activerecord', '~> 5.0.0'
+gem 'pluck_all', '~> 1.2.2'
+
+group :test do
+  gem 'simplecov', '< 0.18'
+  gem 'sqlite3', '~> 1.3.6'
+end
+
+gemspec path: '../'

data/gemfiles/5.1.gemfile

@@ -1,14 +1,11 @@
-source 'https://rubygems.org'
-
-# Specify your gem's dependencies in pluck_all.gemspec
-
-gem "activerecord", "~> 5.1.0"
-gem "pluck_all", "~> 1.2.2"
-
-group :test do
-  gem "simplecov"
-  gem "codeclimate-test-reporter", "~> 1.0.0"
-end
-
-gemspec :path => "../"
-
+source 'https://rubygems.org'
+
+gem 'activerecord', '~> 5.1.0'
+gem 'pluck_all', '~> 1.2.2'
+
+group :test do
+  gem 'simplecov', '< 0.18'
+  gem 'sqlite3', '~> 1.3.6'
+end
+
+gemspec path: '../'

data/gemfiles/5.2.gemfile

@@ -1,14 +1,11 @@
-source 'https://rubygems.org'
-
-# Specify your gem's dependencies in pluck_all.gemspec
-
-gem "activerecord", "~> 5.2.0"
-gem "pluck_all", "~> 1.2.2"
-
-group :test do
-  gem "simplecov"
-  gem "codeclimate-test-reporter", "~> 1.0.0"
-end
-
-gemspec :path => "../"
-
+source 'https://rubygems.org'
+
+gem 'activerecord', '~> 5.2.0'
+gem 'pluck_all', '~> 1.2.2'
+
+group :test do
+  gem 'simplecov', '< 0.18'
+  gem 'sqlite3', '~> 1.3.6'
+end
+
+gemspec path: '../'

data/gemfiles/6.0.gemfile

@@ -0,0 +1,11 @@
+source 'https://rubygems.org'
+
+gem 'activerecord', '~> 6.0.0'
+gem 'pluck_all', '~> 2.0.4'
+
+group :test do
+  gem 'simplecov', '< 0.18'
+  gem 'sqlite3', '~> 1.4.1'
+end
+
+gemspec path: '../'

data/gemfiles/6.1.gemfile

@@ -0,0 +1,11 @@
+source 'https://rubygems.org'
+
+gem 'activerecord', '~> 6.1.1'
+gem 'pluck_all', '~> 2.2.1'
+
+group :test do
+  gem 'simplecov', '< 0.18'
+  gem 'sqlite3', '~> 1.4.1'
+end
+
+gemspec path: '../'

data/lib/deep_pluck.rb

@@ -1,24 +1,23 @@
-require "deep_pluck/version"
-require 'deep_pluck/model'
-require 'active_record'
-require 'pluck_all'
-
-class ActiveRecord::Relation
-  def deep_pluck(*args)
-    DeepPluck::Model.new(self).add(args).load_all
-  end
-end
-
-class ActiveRecord::Base
-  def self.deep_pluck(*args)
-    self.where('').deep_pluck(*args)
-  end
-
-  def deep_pluck(*args)
-    hash_args, other_args = args.partition { |s| s.is_a?(Hash) }
-    preloaded_model = DeepPluck::PreloadedModel.new(self, other_args)
-    model = DeepPluck::Model.new(self.class.where(id: id), preloaded_model: preloaded_model)
-    model.add(*hash_args) if hash_args.any?
-    return model.load_all.first
-  end
-end
+require 'deep_pluck/version'
+require 'deep_pluck/model'
+require 'active_record'
+require 'pluck_all'
+
+class ActiveRecord::Relation
+  def deep_pluck(*args)
+    DeepPluck::Model.new(self).add(args).load_all
+  end
+end
+
+class ActiveRecord::Base
+  def self.deep_pluck(*args)
+    where('').deep_pluck(*args)
+  end
+
+  def deep_pluck(*args)
+    hash_args, other_args = args.partition{|s| s.is_a?(Hash) }
+    model = DeepPluck::Model.new(self, need_columns: other_args)
+    model.add(*hash_args) if hash_args.any?
+    return model.load_all.first
+  end
+end

data/lib/deep_pluck/data_combiner.rb

@@ -12,7 +12,7 @@ module DeepPluck
       private
 
       def make_data_hash(collection, parent, primary_key, column_name)
-        return parent.map{|s| [s[primary_key], s]}.to_h if !collection
+        return parent.map{|s| [s[primary_key], s] }.to_h if !collection
         hash = {}
         parent.each do |model_hash|
           key = model_hash[primary_key]
@@ -26,8 +26,8 @@ module DeepPluck
       def assign_values_to_parent(collection, parent, children_hash, column_name, foreign_key, reverse: false)
         parent.each do |s|
           next if (id = s[foreign_key]) == nil
-          left   =  reverse ? children_hash[id] : s
-          right  = !reverse ? children_hash[id] : s
+          left = reverse ? children_hash[id] : s
+          right = !reverse ? children_hash[id] : s
           if collection
             left[column_name] << right
           else

data/lib/deep_pluck/model.rb

@@ -1,173 +1,229 @@
-require 'deep_pluck/preloaded_model'
-require 'deep_pluck/data_combiner'
-module DeepPluck
-  class Model
-    # ----------------------------------------------------------------
-    # ● Initialize
-    # ----------------------------------------------------------------
-    def initialize(relation, parent_association_key = nil, parent_model = nil, preloaded_model: nil)
-      @relation = relation
-      @preloaded_model = preloaded_model
-      @parent_association_key = parent_association_key
-      @parent_model = parent_model
-      @need_columns = (preloaded_model ? preloaded_model.need_columns : [])
-      @associations = {}
-    end
-
-    # ----------------------------------------------------------------
-    # ● Reader
-    # ----------------------------------------------------------------
-    def get_reflect(association_key)
-      @relation.klass.reflect_on_association(association_key.to_sym) || # add to_sym since rails 3 only support symbol
-        fail(ActiveRecord::ConfigurationError, "ActiveRecord::ConfigurationError: Association named \
-          '#{association_key}' was not found on #{@relation.klass.name}; perhaps you misspelled it?"
-        )
-    end
-
-    def with_conditions(reflect, relation)
-      options = reflect.options
-      relation = relation.instance_exec(&reflect.scope) if reflect.respond_to?(:scope) and reflect.scope
-      relation = relation.where(options[:conditions]) if options[:conditions]
-      return relation
-    end
-
-    def get_join_table(reflect)
-      options = reflect.options
-      return options[:through] if options[:through]
-      return (options[:join_table] || reflect.send(:derive_join_table)) if reflect.macro == :has_and_belongs_to_many
-      return nil
-    end
-
-    def get_primary_key(reflect)
-      return (reflect.belongs_to? ? reflect.klass : reflect.active_record).primary_key
-    end
-
-    def get_foreign_key(reflect, reverse: false, with_table_name: false)
-      if reverse and (table_name = get_join_table(reflect)) # reverse = parent
-        key = reflect.chain.last.foreign_key
-      else
-        key = (reflect.belongs_to? == reverse ? get_primary_key(reflect) : reflect.foreign_key)
-        table_name = (reverse ? reflect.klass : reflect.active_record).table_name
-      end
-      return "#{table_name}.#{key}" if with_table_name
-      return key.to_s # key may be symbol if specify foreign_key in association options
-    end
-
-    # ----------------------------------------------------------------
-    # ● Contruction OPs
-    # ----------------------------------------------------------------
-
-    private
-
-    def add_need_column(column)
-      @need_columns << column.to_s
-    end
-
-    def add_association(hash)
-      hash.each do |key, value|
-        model = (@associations[key] ||= Model.new(get_reflect(key).klass.where(''), key, self))
-        model.add(value)
-      end
-    end
-
-    public
-
-    def add(args)
-      return self if args == nil
-      args = [args] if not args.is_a?(Array)
-      args.each do |arg|
-        case arg
-        when Hash ; add_association(arg)
-        else      ; add_need_column(arg)
-        end
-      end
-      return self
-    end
-
-    # ----------------------------------------------------------------
-    # ● Load
-    # ----------------------------------------------------------------
-    private
-
-    def do_query(parent, reflect, relation)
-      parent_key = get_foreign_key(reflect)
-      relation_key = get_foreign_key(reflect, reverse: true, with_table_name: true)
-      ids = parent.map{|s| s[parent_key]}
-      ids.uniq!
-      ids.compact!
-      relation = with_conditions(reflect, relation)
-      query = { relation_key => ids }
-      query[reflect.type] = reflect.active_record.to_s if reflect.type
-      return relation.joins(get_join_table(reflect)).where(query)
-    end
-
-    def set_includes_data(parent, column_name, model)
-      reflect = get_reflect(column_name)
-      reverse = !reflect.belongs_to?
-      foreign_key = get_foreign_key(reflect, reverse: reverse)
-      primary_key = get_primary_key(reflect)
-      children = model.load_data{|relation| do_query(parent, reflect, relation) }
-      # reverse = false: Child.where(:id => parent.pluck(:child_id))
-      # reverse = true : Child.where(:parent_id => parent.pluck(:id))
-      return DataCombiner.combine_data(
-        parent,
-        children,
-        primary_key,
-        column_name,
-        foreign_key,
-        reverse,
-        reflect.collection?,
-      )
-    end
-
-    def get_query_columns
-      if @parent_model
-        parent_reflect = @parent_model.get_reflect(@parent_association_key)
-        prev_need_columns = @parent_model.get_foreign_key(parent_reflect, reverse: true, with_table_name: true)
-      end
-      next_need_columns = @associations.map{|key, _| get_foreign_key(get_reflect(key), with_table_name: true) }.uniq
-      return [*prev_need_columns, *next_need_columns, *@need_columns].uniq(&Helper::TO_KEY_PROC)
-    end
-
-    public
-
-    def load_data
-      columns = get_query_columns
-      key_columns = columns.map(&Helper::TO_KEY_PROC)
-      @relation = yield(@relation) if block_given?
-      @data = @preloaded_model ? [@preloaded_model.get_hash_data(key_columns)] : @relation.pluck_all(*columns)
-      if @data.size != 0
-        # for delete_extra_column_data!
-        @extra_columns = key_columns - @need_columns.map(&Helper::TO_KEY_PROC)
-        @associations.each do |key, model|
-          set_includes_data(@data, key, model)
-        end
-      end
-      return @data
-    end
-
-    def load_all
-      load_data
-      delete_extra_column_data!
-      return @data
-    end
-
-    def delete_extra_column_data!
-      return if @data.blank?
-      @data.each{|s| s.except!(*@extra_columns) }
-      @associations.each{|_, model| model.delete_extra_column_data! }
-    end
-
-    # ----------------------------------------------------------------
-    # ● Helper methods
-    # ----------------------------------------------------------------
-    module Helper
-      TO_KEY_PROC = proc{|s| Helper.column_to_key(s) }
-      def self.column_to_key(key) # user_achievements.user_id => user_id
-        key = key[/(\w+)[^\w]*\z/]
-        key.gsub!(/[^\w]+/, '')
-        return key
-      end
-    end
-  end
-end
+require 'rails_compatibility'
+require 'rails_compatibility/unscope_where'
+require 'rails_compatibility/build_joins'
+require 'deep_pluck/data_combiner'
+
+module DeepPluck
+  class Model
+    # ----------------------------------------------------------------
+    # ● Initialize
+    # ----------------------------------------------------------------
+    def initialize(relation, parent_association_key = nil, parent_model = nil, need_columns: [])
+      if relation.is_a?(ActiveRecord::Base)
+        @model = relation
+        @relation = nil
+        @klass = @model.class
+      else
+        @model = nil
+        @relation = relation
+        @klass = @relation.klass
+      end
+
+      @parent_association_key = parent_association_key
+      @parent_model = parent_model
+      @need_columns = need_columns
+      @associations = {}
+    end
+
+    # ----------------------------------------------------------------
+    # ● Reader
+    # ----------------------------------------------------------------
+    def get_reflect(association_key)
+      @klass.reflect_on_association(association_key.to_sym) || # add to_sym since rails 3 only support symbol
+        fail(ActiveRecord::ConfigurationError, "ActiveRecord::ConfigurationError: Association named \
+          '#{association_key}' was not found on #{@klass.name}; perhaps you misspelled it?"
+        )
+    end
+
+    def with_conditions(reflect, relation)
+      options = reflect.options
+      relation = relation.instance_exec(&reflect.scope) if reflect.respond_to?(:scope) and reflect.scope
+      relation = relation.where(options[:conditions]) if options[:conditions]
+      return relation
+    end
+
+    def get_join_table(reflect)
+      options = reflect.options
+      return options[:through] if options[:through]
+      return (options[:join_table] || reflect.send(:derive_join_table)) if reflect.macro == :has_and_belongs_to_many
+      return nil
+    end
+
+    def get_primary_key(reflect)
+      return (reflect.belongs_to? ? reflect.klass : reflect.active_record).primary_key
+    end
+
+    def get_foreign_key(reflect, reverse: false, with_table_name: false)
+      reflect = reflect.chain.last
+      if reverse and (table_name = get_join_table(reflect)) # reverse = parent
+        key = reflect.chain.last.foreign_key
+      else
+        key = (reflect.belongs_to? == reverse ? get_primary_key(reflect) : reflect.foreign_key)
+        table_name = (reverse ? reflect.klass : reflect.active_record).table_name
+      end
+      return "#{table_name}.#{key}" if with_table_name
+      return key.to_s # key may be symbol if specify foreign_key in association options
+    end
+
+    def get_association_scope(reflect)
+      RailsCompatibility.unscope_where(reflect.association_class.new({}, reflect).send(:association_scope))
+    end
+
+    def use_association_to_query?(reflect)
+      reflect.through_reflection && reflect.chain.first.macro == :has_one
+    end
+
+    # ----------------------------------------------------------------
+    # ● Contruction OPs
+    # ----------------------------------------------------------------
+
+    private
+
+    def add_need_column(column)
+      @need_columns << column
+    end
+
+    def add_association(hash)
+      hash.each do |key, value|
+        model = (@associations[key] ||= Model.new(get_reflect(key).klass.where(''), key, self))
+        model.add(value)
+      end
+    end
+
+    public
+
+    def add(args)
+      return self if args == nil
+      args = [args] if not args.is_a?(Array)
+      args.each do |arg|
+        case arg
+        when Hash ; add_association(arg)
+        else      ; add_need_column(arg)
+        end
+      end
+      return self
+    end
+
+    # ----------------------------------------------------------------
+    # ● Load
+    # ----------------------------------------------------------------
+    private
+
+    def do_query(parent, reflect, relation)
+      parent_key = get_foreign_key(reflect)
+      relation_key = get_foreign_key(reflect, reverse: true, with_table_name: true)
+      ids = parent.map{|s| s[parent_key] }
+      ids.uniq!
+      ids.compact!
+      relation = with_conditions(reflect, relation)
+      query = { relation_key => ids }
+      query[reflect.type] = reflect.active_record.to_s if reflect.type
+
+      return get_association_scope(reflect).where(query) if use_association_to_query?(reflect)
+
+      joins = if reflect.macro == :has_and_belongs_to_many
+                RailsCompatibility.build_joins(reflect, relation)[0]
+              else
+                backtrace_possible_association(relation, get_join_table(reflect))
+              end
+
+      return relation.joins(joins).where(query)
+    end
+
+    # Let city has_many :users, through: :schools
+    # And the query is: City.deep_pluck('users' => :name)
+    # We want to get the users data via `User.joins(:school).where(city_id: city_ids)`
+    # But get_join_table(reflect) returns `:schools` not :school
+    # No idea how to get the right association, so we try singularize or pluralize it.
+    def backtrace_possible_association(relation, join_table)
+      return join_table if relation.reflect_on_association(join_table)
+      join_table.to_s.singularize.to_sym.tap{|s| return s if relation.reflect_on_association(s) }
+      join_table.to_s.pluralize.to_sym.tap{|s| return s if relation.reflect_on_association(s) }
+      return nil
+    end
+
+    def set_includes_data(parent, column_name, model)
+      reflect = get_reflect(column_name)
+      reverse = !reflect.belongs_to?
+      foreign_key = get_foreign_key(reflect, reverse: reverse)
+      primary_key = get_foreign_key(reflect, reverse: !reverse)
+      children = model.load_data{|relation| do_query(parent, reflect, relation) }
+      # reverse = false: Child.where(:id => parent.pluck(:child_id))
+      # reverse = true : Child.where(:parent_id => parent.pluck(:id))
+      return DataCombiner.combine_data(
+        parent,
+        children,
+        primary_key,
+        column_name,
+        foreign_key,
+        reverse,
+        reflect.collection?,
+      )
+    end
+
+    def get_query_columns
+      if @parent_model
+        parent_reflect = @parent_model.get_reflect(@parent_association_key)
+        prev_need_columns = @parent_model.get_foreign_key(parent_reflect, reverse: true, with_table_name: true)
+      end
+      next_need_columns = @associations.map{|key, _| get_foreign_key(get_reflect(key), with_table_name: true) }.uniq
+      return [*prev_need_columns, *next_need_columns, *@need_columns].uniq(&Helper::TO_KEY_PROC)
+    end
+
+    def pluck_values(columns)
+      includes_values = @relation.includes_values
+      @relation.includes_values = []
+
+      result = @relation.pluck_all(*columns)
+
+      @relation.includes_values = includes_values
+      return result
+    end
+
+    def loaded_models
+      return [@model] if @model
+      return @relation if @relation.loaded
+    end
+
+    public
+
+    def load_data
+      columns = get_query_columns
+      key_columns = columns.map(&Helper::TO_KEY_PROC)
+      @relation = yield(@relation) if block_given?
+      @data = loaded_models ? loaded_models.as_json(root: false, only: key_columns) : pluck_values(columns)
+      if @data.size != 0
+        # for delete_extra_column_data!
+        @extra_columns = key_columns - @need_columns.map(&Helper::TO_KEY_PROC)
+        @associations.each do |key, model|
+          set_includes_data(@data, key, model)
+        end
+      end
+      return @data
+    end
+
+    def load_all
+      load_data
+      delete_extra_column_data!
+      return @data
+    end
+
+    def delete_extra_column_data!
+      return if @data.blank?
+      @data.each{|s| s.except!(*@extra_columns) }
+      @associations.each{|_, model| model.delete_extra_column_data! }
+    end
+
+    # ----------------------------------------------------------------
+    # ● Helper methods
+    # ----------------------------------------------------------------
+    module Helper
+      TO_KEY_PROC = proc{|s| Helper.column_to_key(s) }
+      def self.column_to_key(key) # user_achievements.user_id => user_id
+        key = key[/(\w+)[^\w]*\z/]
+        key.gsub!(/[^\w]+/, '')
+        return key
+      end
+    end
+  end
+end