chore: Benchmark db lookups

.github/workflows/benchmark.yml

@@ -0,0 +1,49 @@
+name: Benchmark
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+  workflow_dispatch:
+
+jobs:
+  benchmark:
+    runs-on: ubuntu-latest
+
+    services:
+      postgres:
+        image: postgres:13
+        env:
+          POSTGRES_PASSWORD: postgres
+        ports:
+          - 5432:5432
+        options: >-
+          --health-cmd pg_isready
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
+
+    steps:
+    - uses: actions/checkout@v3
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: 3.1.0
+        bundler-cache: true
+    - name: Install dependencies
+      run: |
+        sudo apt-get update
+        sudo apt-get install -y postgresql-client
+    - name: Set up database
+      run: |
+        createdb -h localhost -U postgres cool_id_benchmark
+      env:
+        PGPASSWORD: postgres
+    - name: Run benchmark
+      run: |
+        bundle exec ruby benchmark/cool_id_benchmark.rb 1000000
+      env:
+        PGHOST: localhost
+        PGUSER: postgres
+        PGPASSWORD: postgres

Gemfile

@@ -11,4 +11,7 @@ group :development, :test do
   gem "standard", "~> 1.3"
   gem "yard", "~> 0.9.28"
   gem "sqlite3", "~> 1.4"
+  gem "pg", "~> 1.2"
+  gem "faker", "~> 2.18"
+  gem "benchmark", "~> 0.2.0"
 end

Gemfile.lock

@@ -28,11 +28,14 @@ GEM
       tzinfo (~> 2.0, >= 2.0.5)
     ast (2.4.2)
     base64 (0.2.0)
+    benchmark (0.2.1)
     bigdecimal (3.1.8)
     concurrent-ruby (1.3.4)
     connection_pool (2.4.1)
     diff-lcs (1.5.1)
     drb (2.2.1)
+    faker (2.23.0)
+      i18n (>= 1.8.11, < 2)
     i18n (1.14.5)
       concurrent-ruby (~> 1.0)
     json (2.7.2)
@@ -46,6 +49,7 @@ GEM
     parser (3.3.4.2)
       ast (~> 2.4.1)
       racc
+    pg (1.5.8)
     racc (1.8.1)
     rainbow (3.1.1)
     rake (13.2.1)
@@ -111,7 +115,10 @@ PLATFORMS
   ruby
 
 DEPENDENCIES
+  benchmark (~> 0.2.0)
   cool_id!
+  faker (~> 2.18)
+  pg (~> 1.2)
   rake (~> 13.0)
   rspec (~> 3.0)
   sqlite3 (~> 1.4)

README.md

@@ -6,6 +6,10 @@ gem for rails apps to generate string ids with a prefix, followed by a [nanoid](
 
 ### basic id generation
 
+## usage
+
+### basic id generation
+
 ```ruby
 class User < ActiveRecord::Base
   include CoolId::Model

benchmark/cool_id_benchmark.rb

@@ -0,0 +1,215 @@
+# frozen_string_literal: true
+
+require "benchmark"
+require "active_record"
+require_relative "../lib/cool_id"
+require "faker"
+
+# Configure ActiveRecord to use PostgreSQL
+ActiveRecord::Base.establish_connection(
+  adapter: "postgresql",
+  host: ENV["PGHOST"] || "localhost",
+  username: ENV["PGUSER"] || "postgres",
+  password: ENV["PGPASSWORD"] || "postgres",
+  database: "cool_id_benchmark"
+)
+
+# Models for cool_id primary key
+class CoolIdUser < ActiveRecord::Base
+  include CoolId::Model
+  cool_id prefix: "usr"
+  has_one :cool_id_profile
+end
+
+class CoolIdProfile < ActiveRecord::Base
+  belongs_to :cool_id_user
+end
+
+# Models for bigint primary key with cool_id as public_id
+class BigIntUser < ActiveRecord::Base
+  include CoolId::Model
+  cool_id prefix: "usr", id_field: :public_id
+  has_one :big_int_profile
+end
+
+class BigIntProfile < ActiveRecord::Base
+  belongs_to :big_int_user
+end
+
+# Models for UUID primary key
+class UuidUser < ActiveRecord::Base
+  has_one :uuid_profile
+end
+
+class UuidProfile < ActiveRecord::Base
+  belongs_to :uuid_user
+end
+
+# Set up database schema
+ActiveRecord::Schema.define do
+  create_table :cool_id_users, id: :string, force: true do |t|
+    t.string :name
+  end
+
+  create_table :cool_id_profiles, force: true do |t|
+    t.string :cool_id_user_id
+    t.string :bio
+  end
+
+  create_table :big_int_users, force: true do |t|
+    t.string :public_id
+    t.string :name
+  end
+
+  create_table :big_int_profiles, force: true do |t|
+    t.bigint :big_int_user_id
+    t.string :bio
+  end
+
+  create_table :uuid_users, id: :uuid, default: -> { "gen_random_uuid()" }, force: true do |t|
+    t.string :name
+  end
+
+  create_table :uuid_profiles, force: true do |t|
+    t.uuid :uuid_user_id
+    t.string :bio
+  end
+end
+
+BATCH_SIZE = 1000
+
+# Generate sample data
+def generate_sample_data(count)
+  total_batches = count / BATCH_SIZE
+  ActiveRecord::Base.transaction do
+    (count / BATCH_SIZE).times do |batch|
+      puts "Preparing batch #{batch + 1} of #{total_batches}..."
+
+      cool_id_users = BATCH_SIZE.times.map { {id: CoolIdUser.generate_cool_id(skip_existence_check: true), name: Faker::Name.name} }
+      big_int_users = BATCH_SIZE.times.map { {name: Faker::Name.name, public_id: BigIntUser.generate_cool_id(skip_existence_check: true)} }
+      uuid_users = BATCH_SIZE.times.map { {name: Faker::Name.name} }
+
+      cool_id_user_ids = CoolIdUser.insert_all!(cool_id_users).rows.flatten
+      big_int_user_ids = BigIntUser.insert_all!(big_int_users).rows.flatten
+      uuid_user_ids = UuidUser.insert_all!(uuid_users).rows.flatten
+
+      cool_id_profiles = cool_id_user_ids.map { |id| {cool_id_user_id: id, bio: Faker::Lorem.paragraph} }
+      big_int_profiles = big_int_user_ids.map { |id| {big_int_user_id: id, bio: Faker::Lorem.paragraph} }
+      uuid_profiles = uuid_user_ids.map { |id| {uuid_user_id: id, bio: Faker::Lorem.paragraph} }
+
+      CoolIdProfile.insert_all!(cool_id_profiles)
+      BigIntProfile.insert_all!(big_int_profiles)
+      UuidProfile.insert_all!(uuid_profiles)
+    end
+  end
+end
+
+# Prepare sample IDs for benchmarking
+def prepare_sample_ids(count)
+  {
+    big_int: BigIntUser.pluck(:id).sample(count),
+    uuid: UuidUser.pluck(:id).sample(count),
+    cool_id: CoolIdUser.pluck(:id).sample(count)
+  }.transform_values { |ids| ids.compact }
+end
+
+# Benchmark queries
+def run_benchmark(iterations, sample_ids)
+  Benchmark.bm(20) do |x|
+    [:big_int, :uuid, :cool_id].each do |id_type|
+      x.report("#{id_type.to_s.capitalize} Query:") do
+        if sample_ids[id_type].empty?
+          puts "No sample IDs for #{id_type}. Skipping benchmark."
+        else
+          iterations.times do |i|
+            case id_type
+            when :big_int
+              BigIntUser.joins(:big_int_profile).where(id: sample_ids[id_type].sample).first
+            when :uuid
+              UuidUser.joins(:uuid_profile).where(id: sample_ids[id_type].sample).first
+            when :cool_id
+              CoolIdUser.joins(:cool_id_profile).where(id: sample_ids[id_type].sample).first
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+# Clean up existing data
+def clean_up_data
+  ActiveRecord::Base.connection.drop_table :cool_id_users, if_exists: true
+  ActiveRecord::Base.connection.drop_table :cool_id_profiles, if_exists: true
+  ActiveRecord::Base.connection.drop_table :big_int_users, if_exists: true
+  ActiveRecord::Base.connection.drop_table :big_int_profiles, if_exists: true
+  ActiveRecord::Base.connection.drop_table :uuid_users, if_exists: true
+  ActiveRecord::Base.connection.drop_table :uuid_profiles, if_exists: true
+end
+
+# Parse command-line arguments for sample data size and iterations
+sample_size = ARGV[0] ? ARGV[0].to_i : 10_000
+iterations = ARGV[1] ? ARGV[1].to_i : [10_000, sample_size].min
+
+# Ensure iterations is not larger than sample size and at least 1
+iterations = iterations.clamp(1, sample_size)
+
+# Main execution
+clean_up_data
+
+puts "Setting up schema..."
+ActiveRecord::Schema.define do
+  create_table :cool_id_users, id: :string, force: true do |t|
+    t.string :name
+    t.index :id, unique: true
+  end
+
+  create_table :cool_id_profiles, force: true do |t|
+    t.string :cool_id_user_id
+    t.string :bio
+    t.index :cool_id_user_id
+  end
+
+  create_table :big_int_users, force: true do |t|
+    t.string :public_id
+    t.string :name
+    t.index :public_id, unique: true
+  end
+
+  create_table :big_int_profiles, force: true do |t|
+    t.bigint :big_int_user_id
+    t.string :bio
+    t.index :big_int_user_id
+  end
+
+  create_table :uuid_users, id: :uuid, default: -> { "gen_random_uuid()" }, force: true do |t|
+    t.string :name
+    t.index :id, unique: true
+  end
+
+  create_table :uuid_profiles, force: true do |t|
+    t.uuid :uuid_user_id
+    t.string :bio
+    t.index :uuid_user_id
+  end
+end
+
+puts "Generating sample data (#{sample_size} records)..."
+generate_sample_data(sample_size)
+
+puts "Running VACUUM..."
+ActiveRecord::Base.connection.execute("VACUUM ANALYZE")
+
+puts "Preparing sample IDs for benchmarks..."
+sample_ids = prepare_sample_ids(10_000)
+
+puts "Running benchmarks..."
+run_benchmark(iterations, sample_ids)
+
+
+sample_ids = prepare_sample_ids(10_000)
+puts "Running benchmarks again..."
+run_benchmark(iterations, sample_ids)
+
+# Clean up
+clean_up_data

lib/cool_id.rb

@@ -69,9 +69,10 @@ def registry
 
     # Generates a unique ID based on the given configuration.
     # @param config [Config] The configuration for ID generation.
+    # @param skip_existence_check [Boolean] Whether to skip the existence check (default: false).
     # @return [String] A unique ID.
     # @raise [MaxRetriesExceededError] If unable to generate a unique ID within the maximum number of retries.
-    def generate_id(config)
+    def generate_id(config, skip_existence_check: false)
       alphabet = config.alphabet || @alphabet
       length = config.length || @length
       max_retries = config.max_retries || @max_retries
@@ -80,7 +81,8 @@ def generate_id(config)
       loop do
         nano_id = Nanoid.generate(size: length, alphabet: alphabet)
         full_id = "#{config.prefix}#{separator}#{nano_id}"
-        if !config.model_class.exists?(id: full_id)
+
+        if skip_existence_check || !config.model_class.exists?(id: full_id)
           return full_id
         end
 
@@ -226,9 +228,10 @@ def cool_id(options)
       end
 
       # Generates a new CoolId for this model.
+      # @param skip_existence_check [Boolean] Whether to skip the existence check (default: false).
       # @return [String] A new CoolId.
-      def generate_cool_id
-        CoolId.generate_id(@cool_id_config)
+      def generate_cool_id(skip_existence_check: false)
+        CoolId.generate_id(@cool_id_config, skip_existence_check: skip_existence_check)
       end
 
       # Enforces CoolId setup for all descendants of this model.

spec/cool_id_spec.rb

@@ -131,6 +131,13 @@ class Customer < ActiveRecord::Base
       expect(user.id).to match(/^usr_[0-9a-z]{12}$/)
     end
 
+    it "generates a cool_id without existence check" do
+      allow(User).to receive(:exists?).and_return(true) # Simulate all IDs exist
+      id = User.generate_cool_id(skip_existence_check: true)
+      expect(id).to match(/^usr_[0-9a-z]{12}$/)
+      expect(User).not_to have_received(:exists?)
+    end
+
     it "does not overwrite an existing id" do
       user = User.create(id: "custom-id", name: "Jane Doe")
       expect(user.id).to eq("custom-id")