quick_count 0.1.2.pre.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 438a66bd87229dd94820af384fc47b94ebc75d1648eec942aa0c9d840810cd2c
-  data.tar.gz: 9f89c4f42d931cab0ef6b84539f7850a2f0f36ddb373ea0d1d363cbd331392a2
+  metadata.gz: 669ba9aac319e6ac283367c7c11e5f2ab072df5ca4b3ed7feab47dd08b5924b2
+  data.tar.gz: 4c0dd5bf2e1396deeed732e4c7161ff1e4545feaee472062f3a52077926dfb0f
 SHA512:
-  metadata.gz: 6d8f36f586cc38b6637f0254dd306c586bb58216ea5dfa908d0572803a0ebd636fe40fad06d0bae6114f22c90c0472af79fcbc74177749010621530ed2c35cfa
-  data.tar.gz: 775faee06a5eac39fa5d311633dcd7ae263ec5396fa668f5bb0ae1f69d6006524481a5d6609625fc7ac4556943864f00988c1a07572eba0dce13b462996bb567
+  metadata.gz: ea9041fa37e956fc824227301d59bb77472cf840c7d5897937b064a3124205c254a38b623c133f14e62fe4e7dd891fb988e66ce4eaf0067b970c77c1a6b05735
+  data.tar.gz: '0099de6a90ca27ec4e9d157fe32e7ab8830298fedc996617dd29d410c9e5c1504ab3981bf7f06e2e20348cb18030a0718e0de661468bbd7a398eebd9b4d4caff'

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 # QuickCount
 
+## 0.2.0 _(March 9th 2026)_
+- **Breaking:** Dropped support for Rails 4.x
+- Expanded support for Rails 5.0 through 8.0
+- Zero-config: removed SQL function install/uninstall infrastructure
+- Refactored to adapter pattern architecture
+- Fixed SQL injection vulnerability in table name interpolation
+- Enhanced estimation using `pg_stat_user_tables` with `pg_class` fallback
+- Added support for partitioned tables
+
+## 0.1.2 _(January 7th 2020)_
+- Allows for multiple database support
+
 ## 0.1.1 _(November 27th 2018)_
 - Fix for table names with special characters
 

data/README.md

@@ -1,7 +1,6 @@
 [![Version      ](https://img.shields.io/gem/v/quick_count.svg)](https://rubygems.org/gems/quick_count)
-[![Build Status ](https://travis-ci.org/TwilightCoders/quick_count.svg)](https://travis-ci.org/TwilightCoders/quick_count)
-[![Code Climate ](https://api.codeclimate.com/v1/badges/43ba3e038a91b44fba2c/maintainability)](https://codeclimate.com/github/TwilightCoders/quick_count/maintainability)
-[![Test Coverage](https://api.codeclimate.com/v1/badges/43ba3e038a91b44fba2c/test_coverage)](https://codeclimate.com/github/TwilightCoders/quick_count/test_coverage)
+[![CI Status   ](https://github.com/TwilightCoders/quick_count/workflows/CI/badge.svg)](https://github.com/TwilightCoders/quick_count/actions)
+[![Code Quality](https://img.shields.io/badge/code%20quality-qlty-blue)](https://github.com/TwilightCoders/quick_count)
 
 # QuickCount
 
@@ -12,18 +11,16 @@ Luckily, there are [some tricks](https://www.citusdata.com/blog/2016/10/12/count
 **Supports:**
 - PostgreSQL
   - [Multi-table Inheritance](https://github.com/TwilightCoders/active_record-mti)
+- MySQL
 
-| SQL | Version | Result | Accuracy | Time |
-| --- | --- | --- | --- | --- |
-| `SELECT count(*) FROM small_table;` | -- | `2037104` | `100.0000000%` | `4.900s` |
-| `SELECT quick_count('small_table');` | `v0.0.5` | `1988857` | `97.63158877%` | `0.048s` |
-| `SELECT quick_count('small_table');` | `v0.0.6` | `2036407` | `99.96578476%` | `0.050s` |
-| `SELECT count(*) FROM medium_table;` | -- | `81716243` | `100.0000000%` | `257.5s` |
-| `SELECT quick_count('medium_table');` | `v0.0.5` | `79352284` | `97.10711247%` | `0.049s` |
-| `SELECT quick_count('medium_table');` | `v0.0.6` | `81600513` | `99.85837577%` | `0.048s` |
-| `SELECT count(*) FROM large_table;` | -- | `455270802` | `100.0000000%` | `310.6s` |
-| `SELECT quick_count('large_table');` | `v0.0.5` | `448170751` | `98.44047741%` | `0.047s` |
-| `SELECT quick_count('large_table');` | `v0.0.6` | `454448393` | `99.81935828%` | `0.046s` |
+| SQL | Result | Accuracy | Time |
+| --- | --- | --- | --- |
+| `SELECT count(*) FROM small_table;` | `2037104` | `100.0000000%` | `4.900s` |
+| `Post.quick_count` | `2036407` | `99.96578476%` | `0.050s` |
+| `SELECT count(*) FROM medium_table;` | `81716243` | `100.0000000%` | `257.5s` |
+| `Post.quick_count` | `81600513` | `99.85837577%` | `0.048s` |
+| `SELECT count(*) FROM large_table;` | `455270802` | `100.0000000%` | `310.6s` |
+| `Post.quick_count` | `454448393` | `99.81935828%` | `0.046s` |
 
 _These metrics were pulled from real databases being used in a production environment._
 
@@ -39,53 +36,26 @@ And then execute:
 
     $ bundle
 
-Or install it yourself as:
-
-    $ gem install quick_count
-
-To finish the install, in rails console:
-
-    $ QuickCount.install # Install with default (500000) threshold
+That's it. QuickCount automatically integrates with ActiveRecord via a Railtie — no setup step required.
 
 ## Usage
 
 ```ruby
-# user.rb
-
-QuickCount.install # Install with default (500000) threshold
-
-# Change the threshold for when `quick_count` kicks in...
-QuickCount.install(threshold: 500000)
-
-class User < ActiveRecord::Base
-
-end
-
+# Fast estimated count for large tables
 User.quick_count
 
-# Override the default threshold on a case-by-case basis.
-User.quick_count(threshold: 600000)
-
-```
-
-## Uninstallation
-
-Remove this line to your application's Gemfile:
+# Override the default threshold (500,000) on a case-by-case basis
+User.quick_count(threshold: 1_000_000)
 
-```ruby
-gem 'quick_count'
+# Estimate row count for an arbitrary query
+User.where(active: true).count_estimate
 ```
 
-And then execute:
-
-    $ bundle
-
-And in a rails console:
-
-    $ QuickCount.uninstall
+If the estimated count is below the threshold, `quick_count` falls back to an exact `SELECT COUNT(*)`. For tables above the threshold, it returns the estimate directly.
 
 ## License
-Released under the MIT license - http://opensource.org/licenses/MIT
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
 
 ## Development
 
@@ -96,8 +66,3 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/TwilightCoders/quick_count.
-
-
-## License
-
-The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/lib/quick_count/active_record.rb

@@ -5,14 +5,14 @@ module QuickCount
     extend ActiveSupport::Concern
 
     module ClassMethods
-
       def quick_count(threshold: nil)
-        threshold = threshold ? ", #{threshold}" : nil
-        result = connection.execute("SELECT quick_count('#{table_name}'#{threshold})")
-        result[0]["quick_count"].to_i
+        QuickCount.quick_count(table_name, threshold: threshold, connection: connection)
       end
-
     end
 
+    # Instance method for ActiveRecord::Relation
+    def count_estimate
+      QuickCount.count_estimate(to_sql, connection: connection)
+    end
   end
 end

data/lib/quick_count/adapters/base.rb

@@ -0,0 +1,38 @@
+module QuickCount
+  module Adapters
+    class Base
+      attr_reader :connection
+
+      def initialize(connection:)
+        @connection = connection
+      end
+
+      # Abstract methods that must be implemented by adapters
+      def quick_count(table_name, threshold: nil)
+        raise NotImplementedError, "#{self.class} must implement #quick_count"
+      end
+
+      def count_estimate(query)
+        raise NotImplementedError, "#{self.class} must implement #count_estimate"
+      end
+
+      def supported?
+        raise NotImplementedError, "#{self.class} must implement #supported?"
+      end
+
+      private
+
+      def execute_sql(sql)
+        connection.execute(sql)
+      end
+
+      def quote_identifier(identifier)
+        connection.quote_column_name(identifier)
+      end
+
+      def quote_value(value)
+        connection.quote(value)
+      end
+    end
+  end
+end

data/lib/quick_count/adapters/factory.rb

@@ -0,0 +1,32 @@
+require_relative 'postgresql'
+require_relative 'mysql'
+
+module QuickCount
+  module Adapters
+    class Factory
+      ADAPTERS = [Postgresql, Mysql].freeze
+
+      def self.create(connection:)
+        adapter_class = detect_adapter(connection)
+
+        unless adapter_class
+          raise UnsupportedDatabaseError, "Unsupported database: #{connection.adapter_name}"
+        end
+
+        adapter_class.new(connection: connection)
+      end
+
+      def self.detect_adapter(connection)
+        ADAPTERS.find { |adapter_class| adapter_class.new(connection: connection).supported? }
+      end
+
+      def self.supported_databases
+        ADAPTERS.map do |adapter_class|
+          adapter_class.name.split('::').last.downcase
+        end
+      end
+    end
+
+    class UnsupportedDatabaseError < StandardError; end
+  end
+end

data/lib/quick_count/adapters/mysql.rb

@@ -0,0 +1,87 @@
+require_relative 'base'
+
+module QuickCount
+  module Adapters
+    class Mysql < Base
+      def supported?
+        connection.adapter_name.downcase.match?(/mysql/)
+      end
+
+      def quick_count(table_name, threshold: nil)
+        threshold ||= 500_000
+
+        # Get estimated count from INFORMATION_SCHEMA
+        estimated_count = get_table_rows_estimate(table_name)
+
+        if estimated_count < threshold
+          # Use exact count for small tables
+          result = execute_sql("SELECT COUNT(*) as count FROM #{quote_identifier(table_name)}")
+          result[0]['count'].to_i
+        else
+          estimated_count
+        end
+      end
+
+      def count_estimate(query)
+        # Use EXPLAIN to get row estimate
+        result = execute_sql("EXPLAIN #{query}")
+
+        # Parse the rows from EXPLAIN output
+        # MySQL EXPLAIN returns different formats, try to extract rows estimate
+        if result.respond_to?(:each)
+          result.each do |row|
+            if row['rows']
+              return row['rows'].to_i
+            elsif row['Extra'] && row['Extra'].match(/rows=(\d+)/)
+              return $1.to_i
+            end
+          end
+        end
+
+        # Fallback: try to extract from query if it's a simple SELECT
+        if query.match(/FROM\s+(\w+)/i)
+          table_name = $1
+          return get_table_rows_estimate(table_name)
+        end
+
+        # Last resort - return 0
+        0
+      end
+
+      private
+
+      def current_database
+        connection.current_database
+      end
+
+      def get_table_rows_estimate(table_name)
+        database_name = current_database
+
+        # Try INNODB_TABLESTATS first (more accurate for InnoDB)
+        result = execute_sql(<<~SQL)
+          SELECT NUM_ROWS
+          FROM INFORMATION_SCHEMA.INNODB_TABLESTATS
+          WHERE NAME = '#{database_name}/#{table_name}'
+        SQL
+
+        if result && result.first && result.first['NUM_ROWS']
+          return result.first['NUM_ROWS'].to_i
+        end
+
+        # Fallback to INFORMATION_SCHEMA.TABLES
+        result = execute_sql(<<~SQL)
+          SELECT TABLE_ROWS
+          FROM INFORMATION_SCHEMA.TABLES
+          WHERE TABLE_SCHEMA = '#{database_name}'
+          AND TABLE_NAME = '#{table_name}'
+        SQL
+
+        if result && result.first && result.first['TABLE_ROWS']
+          result.first['TABLE_ROWS'].to_i
+        else
+          0
+        end
+      end
+    end
+  end
+end

data/lib/quick_count/adapters/postgresql.rb

@@ -0,0 +1,85 @@
+require_relative 'base'
+
+module QuickCount
+  module Adapters
+    class Postgresql < Base
+      def supported?
+        connection.adapter_name.downcase.match?(/postg/)
+      end
+
+      def quick_count(table_name, threshold: nil)
+        threshold ||= 500_000
+
+        # Use direct SQL estimation without needing functions
+        estimated_count = get_table_estimate(table_name)
+
+        if estimated_count < threshold
+          # Use exact count for small tables
+          result = execute_sql("SELECT COUNT(*) as count FROM #{quote_identifier(table_name)}")
+          result[0]['count'].to_i
+        else
+          estimated_count
+        end
+      end
+
+      def count_estimate(query)
+        # Use EXPLAIN to get row estimate directly
+        result = execute_sql("EXPLAIN #{query}")
+
+        # Parse the rows from EXPLAIN output
+        if result.respond_to?(:each)
+          result.each do |row|
+            if row['QUERY PLAN'] && row['QUERY PLAN'].match(/rows=(\d+)/)
+              return $1.to_i
+            end
+          end
+        end
+
+        # Fallback: return 0 if we can't parse
+        0
+      end
+
+      private
+
+      def get_table_estimate(table_name)
+        quoted_table = quote_value(table_name.to_s)
+
+        # Enhanced estimation using both reltuples and live stats
+        result = execute_sql(<<~SQL)
+          SELECT COALESCE(
+            -- Prefer live statistics when available
+            pg_stat.n_live_tup,
+            -- Fall back to enhanced planner-style estimation
+            CASE
+              WHEN pg_class.reltuples < 0 THEN NULL -- never vacuumed
+              WHEN pg_class.relpages = 0 THEN 0     -- empty table
+              ELSE (pg_class.reltuples / GREATEST(pg_class.relpages, 1)) *
+                   (pg_relation_size(pg_class.oid) / current_setting('block_size')::int)
+            END
+          )::bigint AS estimated_count
+          FROM pg_class
+          LEFT JOIN pg_stat_user_tables pg_stat ON pg_stat.relid = pg_class.oid
+          WHERE pg_class.oid = #{quoted_table}::regclass
+
+          -- Handle partitioned tables
+          UNION ALL
+          SELECT sum(
+            COALESCE(
+              pg_stat.n_live_tup,
+              (pg_class.reltuples/GREATEST(pg_class.relpages,1)) *
+              (pg_relation_size(pg_class.oid)/current_setting('block_size')::int)
+            )
+          )::bigint as estimated_count
+          FROM pg_inherits
+          JOIN pg_class ON pg_inherits.inhrelid = pg_class.oid
+          LEFT JOIN pg_stat_user_tables pg_stat ON pg_stat.relid = pg_class.oid
+          WHERE pg_inherits.inhparent = #{quoted_table}::regclass
+        SQL
+
+        # Get the maximum estimate (handles both regular and partitioned tables)
+        estimates = result.map { |row| row['estimated_count']&.to_i || 0 }
+        estimates.max || 0
+      end
+    end
+  end
+end

data/lib/quick_count/railtie.rb

@@ -1,19 +1,12 @@
 require 'rails/railtie'
 require 'quick_count/active_record'
-require 'count_estimate/active_record'
 
 module QuickCount
   class Railtie < Rails::Railtie
-
-    # rake_tasks do
-    #   load "../tasks/quick_count_tasks.rake"
-    # end
-
     initializer 'quick_count.load' do |app|
       ActiveSupport.on_load(:active_record) do
         QuickCount.load
       end
     end
-
   end
 end

data/lib/quick_count/version.rb

@@ -1,3 +1,3 @@
 module QuickCount
-  VERSION = "0.1.2-2"
+  VERSION = "0.2.0"
 end

data/lib/quick_count.rb

@@ -1,76 +1,35 @@
 require 'quick_count/version'
 require 'quick_count/railtie'
+require 'quick_count/adapters/factory'
 require 'active_record'
 
 module QuickCount
-
   def self.root
     @root ||= Pathname.new(File.dirname(File.expand_path(File.dirname(__FILE__), '/../')))
   end
 
   def self.load
-    ::ActiveRecord::Base.send :include, QuickCount::ActiveRecord
-    ::ActiveRecord::Relation.send :include, CountEstimate::ActiveRecord
+    ::ActiveRecord::Base.include QuickCount::ActiveRecord
+    ::ActiveRecord::Relation.include QuickCount::ActiveRecord
   end
 
-  def self.install(threshold: 500000, schema: 'public', connection: ::ActiveRecord::Base.connection)
-    connection.execute(quick_count_sql(schema: schema, threshold: threshold))
-    connection.execute(count_estimate_sql(schema: schema))
+  def self.quick_count(table_name, threshold: nil, connection: ::ActiveRecord::Base.connection)
+    adapter = create_adapter(connection: connection)
+    adapter.quick_count(table_name, threshold: threshold)
   end
 
-  def self.uninstall(schema: 'public', connection: ::ActiveRecord::Base.connection)
-    connection.execute("DROP FUNCTION IF EXISTS #{schema}.quick_count(text, bigint);")
-    connection.execute("DROP FUNCTION IF EXISTS #{schema}.quick_count(text);")
-    connection.execute("DROP FUNCTION IF EXISTS #{schema}.count_estimate(text);")
+  def self.count_estimate(query, connection: ::ActiveRecord::Base.connection)
+    adapter = create_adapter(connection: connection)
+    adapter.count_estimate(query)
   end
 
-private
-
-  def self.quick_count_sql(threshold: 500000, schema: 'public')
-    <<~SQL
-      CREATE OR REPLACE FUNCTION #{schema}.quick_count(table_name text, threshold bigint default #{threshold}) RETURNS bigint AS
-      $func$
-      DECLARE count bigint;
-      BEGIN
-        EXECUTE 'SELECT
-          CASE
-          WHEN SUM(estimate)::integer < '|| threshold ||' THEN
-            (SELECT COUNT(*) FROM "'|| table_name ||'")
-          ELSE
-            SUM(estimate)::integer
-          END AS count
-        FROM (
-          SELECT
-              ((SUM(child.reltuples::float)/greatest(SUM(child.relpages::float),1))) * (SUM(pg_relation_size(child.oid))::float / (current_setting(''block_size'')::float)) AS estimate
-          FROM pg_inherits
-              JOIN pg_class parent ON pg_inherits.inhparent = parent.oid
-              JOIN pg_class child  ON pg_inherits.inhrelid  = child.oid
-          WHERE parent.relname = '''|| table_name ||'''
-          UNION SELECT (reltuples::float/greatest(relpages::float, 1)) * (pg_relation_size(pg_class.oid)::float / (current_setting(''block_size'')::float)) AS estimate FROM pg_class where relname='''|| table_name ||'''
-        ) AS tables' INTO count;
-        RETURN count;
-      END
-      $func$ LANGUAGE plpgsql;
-    SQL
+  def self.supported_databases
+    Adapters::Factory.supported_databases
   end
 
-  def self.count_estimate_sql(schema: 'public')
-    <<~SQL
-      CREATE OR REPLACE FUNCTION #{schema}.count_estimate(query text) RETURNS integer AS
-      $func$
-      DECLARE
-        rec   record;
-        rows  integer;
-      BEGIN
-        FOR rec IN EXECUTE 'EXPLAIN ' || query LOOP
-          rows := substring(rec."QUERY PLAN" FROM ' rows=([[:digit:]]+)');
-          EXIT WHEN rows IS NOT NULL;
-        END LOOP;
-        RETURN rows;
-      END
-      $func$ LANGUAGE plpgsql;
-    SQL
-  end
+  private
 
+  def self.create_adapter(connection:)
+    Adapters::Factory.create(connection: connection)
+  end
 end
-

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: quick_count
 version: !ruby/object:Gem::Version
-  version: 0.1.2.pre.2
+  version: 0.2.0
 platform: ruby
 authors:
 - Dale Stevens
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-01-07 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg
@@ -30,54 +29,40 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4'
+        version: '5.0'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '6'
+        version: '9'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4'
+        version: '5.0'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '6'
+        version: '9'
 - !ruby/object:Gem::Dependency
   name: railties
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4'
+        version: '5.0'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '6'
+        version: '9'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4'
+        version: '5.0'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '6'
-- !ruby/object:Gem::Dependency
-  name: pry-byebug
-  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'
+        version: '9'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -120,8 +105,8 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: Installs two database functions, `quick_count` and `count_estimate` for
-  getting count estimations on large tables
+description: Fast approximate row counts for large PostgreSQL tables using database
+  statistics instead of COUNT(*)
 email:
 - dale@twilightcoders.net
 executables: []
@@ -131,9 +116,12 @@ files:
 - CHANGELOG.md
 - LICENSE
 - README.md
-- lib/count_estimate/active_record.rb
 - lib/quick_count.rb
 - lib/quick_count/active_record.rb
+- lib/quick_count/adapters/base.rb
+- lib/quick_count/adapters/factory.rb
+- lib/quick_count/adapters/mysql.rb
+- lib/quick_count/adapters/postgresql.rb
 - lib/quick_count/railtie.rb
 - lib/quick_count/version.rb
 homepage: https://github.com/TwilightCoders/quick_count
@@ -141,24 +129,21 @@ licenses:
 - MIT
 metadata:
   allowed_push_host: https://rubygems.org
-post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
-- spec
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.0'
+      version: '2.5'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
-rubygems_version: 3.1.2
-signing_key: 
+rubygems_version: 4.0.5
 specification_version: 4
 summary: Quickly get an accurate count estimation for large tables.
 test_files: []

data/lib/count_estimate/active_record.rb

@@ -1,14 +0,0 @@
-require 'active_support/concern'
-require 'pry'
-
-module CountEstimate
-  module ActiveRecord
-
-    def count_estimate
-      my_statement = connection.quote(to_sql)
-      result = connection.execute("SELECT count_estimate(#{my_statement})")
-      result[0]["count_estimate"].to_i
-    end
-
-  end
-end