brainstem 1.1.0 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9bf2b0cdf9ecd18e7a90f8484238fe6e7f63ad43
-  data.tar.gz: 7be99f891a90e26715f553fcf0971931bf51c404
+  metadata.gz: 6284bb9b32ad35fb5e88a28ada0cb128a533dbae
+  data.tar.gz: 3f1624b6bde3c0703b3540b70a77566c6312bd7b
 SHA512:
-  metadata.gz: 138e7db36bf3692bde7fac6c61777ea8695195d32769dec30555bc2d4b5124679dd8f22e08624503ba3148e64c058bcad31f72b24842f2bf864bb4291ca8e052
-  data.tar.gz: 37760c56b41a4fbf8dbb5e19b543229c878e61fd88a7a8400f961140565b70c9b738b1882b7aeee1dc3c41e651695e02ab43ed95efd1483a80eafbdf38abf50c
+  metadata.gz: '06469a9fd4016afafc4c169208eecf714bfc0159ff11a1f3442eefdcfe7406a5017288f146e25f5d4bdc203705fe3b26986ac8adac1d6112e05775898c7b33d4'
+  data.tar.gz: 2fccd29843c5b613e288520a9897f3c0dac7a02bcaf5953bf5dfa4bdeacf876711bf3d07cc65c4f1f14dc725b389c4541a1e002dc865ebc435507521686e474a

data/CHANGELOG.md

@@ -1,5 +1,8 @@
 # Changelog
 
++ **1.1.1 - _01/15/2017_
+  - Add `Brainstem.mysql_use_calc_found_rows` boolean config option to utilize MySQL's [FOUND_ROWS()](https://dev.mysql.com/doc/refman/5.7/en/information-functions.html#function_found-rows) functionality to avoid issuing a new query to calculate the record count, which has the potential to up to double the response time of the endpoint. 
+
 + **1.1.0 - _12/18/2017_
   - Add `meta` key to API responses which includes `page_number`, `page_count`, and `page_size` keys.
 

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    brainstem (1.1.0)
+    brainstem (1.1.1)
       activerecord (>= 4.1)
       activesupport (>= 4.1)
 
@@ -30,21 +30,22 @@ GEM
     i18n (0.9.1)
       concurrent-ruby (~> 1.0)
     method_source (0.9.0)
-    minitest (5.10.3)
+    minitest (5.11.1)
+    mysql2 (0.3.18)
     pry (0.9.12.6)
       coderay (~> 1.0)
       method_source (~> 0.8)
       slop (~> 3.4)
     pry-nav (0.2.4)
       pry (>= 0.9.10, < 0.11.0)
-    rake (12.2.1)
+    rake (12.3.0)
     redcarpet (3.4.0)
     rr (1.2.1)
     rspec (3.7.0)
       rspec-core (~> 3.7.0)
       rspec-expectations (~> 3.7.0)
       rspec-mocks (~> 3.7.0)
-    rspec-core (3.7.0)
+    rspec-core (3.7.1)
       rspec-support (~> 3.7.0)
     rspec-expectations (3.7.0)
       diff-lcs (>= 1.2.0, < 2.0)
@@ -58,7 +59,7 @@ GEM
     thread_safe (0.3.6)
     tzinfo (1.2.4)
       thread_safe (~> 0.1)
-    yard (0.9.9)
+    yard (0.9.12)
 
 PLATFORMS
   ruby
@@ -67,6 +68,7 @@ DEPENDENCIES
   brainstem!
   database_cleaner
   db-query-matchers
+  mysql2
   pry
   pry-nav
   rake

data/README.md

@@ -184,6 +184,11 @@ Rails.application.config.to_prepare do
   # Set the current default API namespace.
   Brainstem.default_namespace = :v1
 
+  # (Optional) Utilize MySQL's [FOUND_ROWS()](https://dev.mysql.com/doc/refman/5.7/en/information-functions.html#function_found-rows) 
+  # functionality to avoid issuing a new query to calculate the record count, 
+  # which has the potential to up to double the response time of the endpoint.
+  Brainstem.mysql_use_calc_found_rows = true 
+
   # (Optional) Load a default base helper into all presenters. You could use
   # this to bring in a concept like `current_user`.  # While not necessarily the
   # best approach, something like http://stackoverflow.com/a/11670283 can

data/brainstem.gemspec

@@ -27,6 +27,7 @@ Gem::Specification.new do |gem|
   gem.add_development_dependency "rr"
   gem.add_development_dependency "rspec", "~> 3.5"
   gem.add_development_dependency "sqlite3"
+  gem.add_development_dependency "mysql2"
   gem.add_development_dependency "database_cleaner"
   gem.add_development_dependency "yard"
   gem.add_development_dependency "pry"

data/lib/brainstem.rb

@@ -21,6 +21,19 @@ module Brainstem
     @default_namespace || "none"
   end
 
+  # Sets {mysql_use_calc_found_rows} to a new value.
+  # @param [Boolean] bool
+  # @return [Boolean] the new mysql_use_calc_found_rows setting
+  def self.mysql_use_calc_found_rows=(bool)
+    @mysql_use_calc_found_rows = bool
+  end
+
+  # Whether or not to use MYSQL_CALC_FOUND_ROWS to calculate the result set count instead of issuing two queries.
+  # @return [Boolean] the mysql_use_calc_found_rows setting
+  def self.mysql_use_calc_found_rows
+    @mysql_use_calc_found_rows || false
+  end
+
   # @param [String] namespace
   # @return [PresenterCollection] the {PresenterCollection} for the given namespace.
   def self.presenter_collection(namespace = nil)
@@ -73,5 +86,6 @@ module Brainstem
 
     @presenter_collection = {}
     @default_namespace = nil
+    @mysql_use_calc_found_rows = false
   end
 end

data/lib/brainstem/query_strategies/base_strategy.rb

@@ -6,6 +6,7 @@ module Brainstem
     class BaseStrategy
       def initialize(options)
         @options = options
+        @last_count = nil
       end
 
       def execute(scope)
@@ -13,19 +14,24 @@ module Brainstem
       end
 
       def evaluate_scope(scope)
+        @last_count = nil
+
         # Load models!
         # On complex queries, MySQL can sometimes handle 'SELECT id FROM ... ORDER BY ...' much faster than
         # 'SELECT * FROM ...', so we pluck the ids, then find those specific ids in a separate query.
-        if(ActiveRecord::Base.connection.instance_values["config"][:adapter] =~ /mysql|sqlite/i)
-          ids = scope.pluck("#{scope.table_name}.id")
-          id_lookup = {}
-          ids.each.with_index { |id, index| id_lookup[id] = index }
-          primary_models = scope.klass.where(id: id_lookup.keys).sort_by { |model| id_lookup[model.id] }
+        if ActiveRecord::Base.connection.instance_values["config"][:adapter] =~ /mysql|sqlite/i
+          get_ids_sql(scope)
         else
-          primary_models = scope.to_a
+          scope.to_a
         end
       end
 
+      def evaluate_count(count_scope)
+        ret = @last_count || count_scope.count
+        @last_count = nil
+        ret
+      end
+
       def calculate_per_page
         per_page = [(@options[:params][:per_page] || @options[:per_page] || @options[:default_per_page]).to_i, (@options[:max_per_page] || @options[:default_max_per_page]).to_i].min
         per_page = @options[:default_per_page] if per_page < 1
@@ -34,6 +40,19 @@ module Brainstem
 
       private
 
+      def get_ids_sql(scope)
+        if Brainstem.mysql_use_calc_found_rows && ActiveRecord::Base.connection.instance_values["config"][:adapter] =~ /mysql/i
+          ids = scope.pluck("SQL_CALC_FOUND_ROWS #{scope.table_name}.id")
+          @last_count = ActiveRecord::Base.connection.execute("SELECT FOUND_ROWS()").first.first
+        else
+          ids = scope.pluck("#{scope.table_name}.id")
+        end
+
+        id_lookup = {}
+        ids.each.with_index { |id, index| id_lookup[id] = index }
+        scope.klass.where(id: id_lookup.keys).sort_by { |model| id_lookup[model.id] }
+      end
+
       def calculate_limit
         [[@options[:params][:limit].to_i, 1].max, (@options[:max_per_page] || @options[:default_max_per_page]).to_i].min
       end

data/lib/brainstem/query_strategies/filter_and_search.rb

@@ -6,10 +6,11 @@ module Brainstem
         scope = @options[:primary_presenter].apply_filters_to_scope(scope, @options[:params], @options)
 
         if ordering?
-          count = scope.count
+          count_scope = scope
           scope = paginate(scope)
           scope = @options[:primary_presenter].apply_ordering_to_scope(scope, @options[:params])
           primary_models = evaluate_scope(scope)
+          count = evaluate_count(count_scope)
         else
           filtered_ids = scope.pluck(:id)
           count = filtered_ids.size

data/lib/brainstem/query_strategies/filter_or_search.rb

@@ -18,18 +18,18 @@ module Brainstem
 
           if @options[:params][:only].present?
             # Handle Only
-            scope, count = handle_only(scope, @options[:params][:only])
+            scope, count_scope = handle_only(scope, @options[:params][:only])
           else
             # Paginate
-            scope, count = paginate scope
+            scope, count_scope = paginate scope
           end
 
-          count = count.keys.length if count.is_a?(Hash)
-
           # Ordering
           scope = @options[:primary_presenter].apply_ordering_to_scope(scope, @options[:params])
 
           primary_models = evaluate_scope(scope)
+          count = evaluate_count(count_scope)
+          count = count.keys.length if count.is_a?(Hash)
         end
 
         [primary_models, count]
@@ -69,12 +69,12 @@ module Brainstem
 
       def paginate(scope)
         limit, offset = calculate_limit_and_offset
-        [scope.limit(limit).offset(offset).distinct, scope.select("distinct #{scope.connection.quote_table_name @options[:table_name]}.id").count]
+        [scope.limit(limit).offset(offset).distinct, scope.select("distinct #{scope.connection.quote_table_name @options[:table_name]}.id")]
       end
 
       def handle_only(scope, only)
         ids = (only || "").split(",").select {|id| id =~ /\A\d+\z/}.uniq
-        [scope.where(:id => ids), scope.where(:id => ids).count]
+        [scope.where(:id => ids), scope.where(:id => ids)]
       end
     end
   end

data/lib/brainstem/version.rb

@@ -1,3 +1,3 @@
 module Brainstem
-  VERSION = "1.1.0"
+  VERSION = "1.1.1"
 end

data/spec/brainstem/presenter_spec.rb

@@ -747,7 +747,8 @@ describe Brainstem::Presenter do
         end
 
         sql = presenter.apply_ordering_to_scope(scope, 'order' => 'title').to_sql
-        expect(sql).to match(/order by workspaces.title desc, workspaces.id desc, "workspaces"."id" ASC/i)
+        # match SQLite and MySQL quotes
+        expect(sql).to match(/order by workspaces\.title desc, workspaces.id desc, [`"]workspaces[`"]\.[`"]id[`"] ASC/i)
         # this should be ok, since the first id sort will never have a tie
       end
 
@@ -757,7 +758,8 @@ describe Brainstem::Presenter do
         end
 
         sql = presenter.apply_ordering_to_scope(scope, 'order' => 'title').to_sql
-        expect(sql).to match(/order by workspaces.title desc, "workspaces"."id" ASC/i)
+        # match SQLite and MySQL quotes
+        expect(sql).to match(/order by workspaces\.title desc, [`"]workspaces[`"]\.[`"]id[`"] ASC/i)
       end
     end
 
@@ -772,7 +774,8 @@ describe Brainstem::Presenter do
 
         it 'applies the named ordering in the given direction and adds the primary key as a fallback sort' do
           sql = presenter.apply_ordering_to_scope(scope, order).to_sql
-          expect(sql).to match(/ORDER BY workspaces.title asc, "workspaces"."id" ASC/i)
+          # match SQLite and MySQL quotes
+          expect(sql).to match(/ORDER BY workspaces\.title asc, [`"]workspaces[`"]\.[`"]id[`"] ASC/i)
         end
       end
 
@@ -781,7 +784,8 @@ describe Brainstem::Presenter do
 
         it 'applies the named ordering in the given direction and adds the primary key as a fallback sort' do
           sql = presenter.apply_ordering_to_scope(scope, order).to_sql
-          expect(sql).to match(/order by workspaces.title asc, "workspaces"."id" ASC/i)
+          # match SQLite and MySQL quotes
+          expect(sql).to match(/order by workspaces\.title asc, [`"]workspaces[`"]\.[`"]id[`"] ASC/i)
         end
       end
     end
@@ -791,7 +795,8 @@ describe Brainstem::Presenter do
 
       it 'orders by the primary key' do
         sql = presenter.apply_ordering_to_scope(scope, order).to_sql
-        expect(sql).to match(/order by "workspaces"."id" ASC/i)
+        # match SQLite and MySQL quotes
+        expect(sql).to match(/order by [`"]workspaces[`"]\.[`"]id[`"] ASC/i)
       end
     end
 
@@ -809,7 +814,7 @@ describe Brainstem::Presenter do
 
       it 'does not add a fallback deterministic sort, and you deserve whatever fate befalls you' do
         sql = presenter.apply_ordering_to_scope(scope, order).to_sql.squish
-        expect(sql).to eq("SELECT \"workspaces\".* FROM \"workspaces\" WHERE \"workspaces\".\"type\" IN ('Cthulhu') ORDER BY workspaces.updated_at asc")
+        expect(sql).to match(/SELECT [`"]workspaces[`"]\.\* FROM [`"]workspaces[`"] WHERE [`"]workspaces[`"]\.[`"]type[`"] IN \('Cthulhu'\) ORDER BY workspaces\.updated_at asc/i)
       end
     end
   end

data/spec/brainstem/query_strategies/filter_and_search_spec.rb

@@ -75,6 +75,50 @@ describe Brainstem::QueryStrategies::FilterAndSearch do
           expect(results.map(&:id)).to eq(expected_paginated_ids)
         end
       end
+
+      if(ActiveRecord::Base.connection.instance_values["config"][:adapter] =~ /mysql/i)
+        describe 'mysql_use_calc_found_rows' do
+          context 'when using mysql_use_calc_found_rows' do
+            before do
+              Brainstem.mysql_use_calc_found_rows = true
+              expect(Brainstem.mysql_use_calc_found_rows).to eq(true)
+            end
+
+            after do
+              Brainstem.mysql_use_calc_found_rows = false
+            end
+
+            it 'returns the results without issuing a second query' do
+              expect { run_query }.
+                  not_to make_database_queries({ count: 1, matching: "SELECT COUNT(*) FROM" })
+
+              expect { run_query }.
+                to make_database_queries({ count: 1, matching: "SELECT  DISTINCT SQL_CALC_FOUND_ROWS cheeses.id FROM" }).
+                and make_database_queries({ count: 1, matching: "SELECT FOUND_ROWS()" })
+
+              _, count = run_query
+              expect(count).to eq(owned_by_bob.count)
+            end
+          end
+
+          context 'when not using mysql_use_calc_found_rows' do
+            before do
+              expect(Brainstem.mysql_use_calc_found_rows).to eq(false)
+            end
+
+            it 'returns the results by issuing a count query' do
+              expect { run_query }.
+                to make_database_queries({ count: 1, matching: "SELECT COUNT(*) FROM" })
+
+              expect { run_query }.
+                not_to make_database_queries({ count: 1, matching: "SELECT  DISTINCT SQL_CALC_FOUND_ROWS cheeses.id FROM" })
+
+              expect { run_query }.
+                not_to make_database_queries({ count: 1, matching: "SELECT FOUND_ROWS()" })
+            end
+          end
+        end
+      end
     end
 
     context 'when no order is specified' do

data/spec/brainstem/query_strategies/filter_or_search_spec.rb

@@ -29,19 +29,64 @@ describe Brainstem::QueryStrategies::FilterOrSearch do
     end
 
     context 'we are not searching' do
-      let(:subject) { described_class.new(@options) }
-
-      before do
-        @options = { primary_presenter: WorkspacePresenter.new,
-                     table_name: 'workspaces',
-                     default_per_page: 20,
-                     default_max_per_page: 200,
-                     params: { } }
+      let(:options) do
+        {
+          primary_presenter: WorkspacePresenter.new,
+          table_name: 'workspaces',
+          default_per_page: 20,
+          default_max_per_page: 200,
+          params: {}
+        }
       end
+      let(:subject) { described_class.new(options) }
 
       it 'returns the primary models and count' do
         expect(subject.execute(Workspace.unscoped)).to eq([Workspace.unscoped.to_a, Workspace.count])
       end
+
+      if(ActiveRecord::Base.connection.instance_values["config"][:adapter] =~ /mysql/i)
+        describe 'mysql_use_calc_found_rows' do
+          context 'when using mysql_use_calc_found_rows' do
+            before do
+              Brainstem.mysql_use_calc_found_rows = true
+              expect(Brainstem.mysql_use_calc_found_rows).to eq(true)
+            end
+
+            after do
+              Brainstem.mysql_use_calc_found_rows = false
+            end
+
+            it 'returns the results without issuing a second query' do
+              expect { subject.execute(Workspace.unscoped) }.
+                not_to make_database_queries({ count: 1, matching: "SELECT COUNT(*) FROM" })
+
+              expect { subject.execute(Workspace.unscoped) }.
+                to make_database_queries({ count: 1, matching: "SELECT  DISTINCT SQL_CALC_FOUND_ROWS workspaces.id FROM" }).
+                and make_database_queries({ count: 1, matching: "SELECT FOUND_ROWS()" })
+
+              _, count = subject.execute(Workspace.unscoped)
+              expect(count).to eq(Workspace.count)
+            end
+          end
+
+          context 'when not using mysql_use_calc_found_rows' do
+            before do
+              expect(Brainstem.mysql_use_calc_found_rows).to eq(false)
+            end
+
+            it 'returns the results by issuing a count query' do
+              expect { subject.execute(Workspace.unscoped) }.
+                to make_database_queries({ count: 1, matching: "SELECT COUNT(distinct `workspaces`.id) FROM" })
+
+              expect { subject.execute(Workspace.unscoped) }.
+                not_to make_database_queries({ count: 1, matching: "SELECT  DISTINCT SQL_CALC_FOUND_ROWS workspaces.id FROM" })
+
+              expect { subject.execute(Workspace.unscoped) }.
+                not_to make_database_queries({ count: 1, matching: "SELECT FOUND_ROWS()" })
+            end
+          end
+        end
+      end
     end
   end
 end

data/spec/brainstem_spec.rb

@@ -12,6 +12,17 @@ describe Brainstem do
     end
   end
 
+  describe "mysql_use_calc_found_rows attribute" do
+    it "can be set and read" do
+      Brainstem.mysql_use_calc_found_rows = true
+      expect(Brainstem.mysql_use_calc_found_rows).to eq(true)
+    end
+
+    it "returns false if unset" do
+      expect(Brainstem.mysql_use_calc_found_rows).to eq(false)
+    end
+  end
+
   describe "presenter collection method" do
     it "returns an instance of PresenterCollection" do
       expect(Brainstem.presenter_collection).to be_a(Brainstem::PresenterCollection)

data/spec/shared/base_strategy.rb

@@ -3,6 +3,52 @@ require "spec_helper"
 shared_examples_for Brainstem::QueryStrategies::BaseStrategy do
   let(:strategy) { described_class.new(options) }
 
+  if(ActiveRecord::Base.connection.instance_values["config"][:adapter] =~ /mysql/i)
+    describe 'mysql_use_calc_found_rows' do
+      let(:options) {{}}
+
+      context 'when using mysql_use_calc_found_rows' do
+        before do
+          Brainstem.mysql_use_calc_found_rows = true
+          expect(Brainstem.mysql_use_calc_found_rows).to eq(true)
+        end
+
+        after do
+          Brainstem.mysql_use_calc_found_rows = false
+        end
+
+        it 'returns the results without issuing a second query' do
+          expect { strategy.evaluate_scope(Workspace.unscoped) }.
+            to make_database_queries({ count: 1, matching: "SELECT SQL_CALC_FOUND_ROWS workspaces.id FROM" }).
+            and make_database_queries({ count: 1, matching: "SELECT FOUND_ROWS()" })
+
+          count_scope_that_should_not_be_used = Workspace.none
+          count_expected = Workspace.count
+
+          expect {
+            expect(strategy.evaluate_count(count_scope_that_should_not_be_used)).to eq(count_expected)
+          }.not_to make_database_queries
+        end
+      end
+
+      context 'when not using mysql_use_calc_found_rows' do
+        before do
+          expect(Brainstem.mysql_use_calc_found_rows).to eq(false)
+        end
+
+        it 'returns the results by issuing a count query' do
+          expect { strategy.evaluate_scope(Workspace.unscoped) }.
+            not_to make_database_queries({ count: 1, matching: "SELECT SQL_CALC_FOUND_ROWS workspaces.id FROM" })
+          expect { strategy.evaluate_scope(Workspace.unscoped) }.
+            not_to make_database_queries({ count: 1, matching: "SELECT FOUND_ROWS()" })
+
+          expect { strategy.evaluate_count(Workspace.unscoped) }.
+            to make_database_queries({ count: 1, matching: "SELECT COUNT(*) FROM" })
+        end
+      end
+    end
+  end
+
   describe "#calculate_per_page" do
     let(:result) { strategy.calculate_per_page }
 

data/spec/spec_helper.rb

@@ -2,7 +2,11 @@ require 'active_record'
 require 'logger'
 require 'rr'
 require 'rspec'
-require 'sqlite3'
+if ENV['USE_MYSQL']
+  require 'mysql2'
+else
+  require 'sqlite3'
+end
 require 'database_cleaner'
 require 'pry'
 require 'pry-nav'

data/spec/spec_helpers/schema.rb

@@ -1,4 +1,9 @@
-ActiveRecord::Base.establish_connection(:adapter => 'sqlite3', :database => ':memory:')
+if ENV['USE_MYSQL']
+  ActiveRecord::Base.establish_connection(:adapter => 'mysql2', :database => 'test', :username => 'root', :password => '', :host => '127.0.0.1')
+else
+  ActiveRecord::Base.establish_connection(:adapter => 'sqlite3', :database => ':memory:')
+end
+
 ActiveRecord::Schema.define do
   self.verbose = false
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: brainstem
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.1.1
 platform: ruby
 authors:
 - Mavenlink
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-01-03 00:00:00.000000000 Z
+date: 2018-01-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -108,6 +108,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: mysql2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: database_cleaner
   requirement: !ruby/object:Gem::Requirement