Enhance README and ORM comparison examples for clarity and performance

- Update README to include database URI export instructions and improve setup verification steps
- Modify ORM comparison benchmarks to increase warmup and run times for more accurate results
- Refine SQL queries in benchmarks to avoid duplicate key errors and improve index usage
- Add new examples for index-friendly queries to highlight performance differences between leading and trailing wildcards

Author: jonatas

README.md

@@ -54,12 +54,16 @@ Then test if it's working:
 psql -h 0.0.0.0 -d workshop_db
 ```
 
-```ruby
+After the test you can export the database URI that will be used for all
+exercises.
+
+```bash
 # In your terminal
 export DATABASE_URL="postgres://${USER}@0.0.0.0:5432/workshop_db"
 ```
 
-3. Verify your setup:
+3. Verify your setup running the first example:
+
 ```ruby
 ruby examples/01_storage/practice_storage.rb
 # If you see table creation outputs, you're good to go! 🎉
@@ -123,9 +127,9 @@ Optimize Ruby and ActiveRecord usage:
 - Query optimization
 - Connection pooling
 
-## 🎮 Interactive Learning Tips
+## 🎮 Interactive Learning
 
-1. **Experiment Freely**
+**Experiment Freely**
 
 ```ruby
 def learning_approach
@@ -137,18 +141,6 @@ def learning_approach
 end
 ```
 
-2. **Break Things Purposefully**
-
-```ruby
-def controlled_chaos
-  begin
-    push_the_limits
-  rescue PostgreSQL::Error => e
-    understand_why_it_failed(e)
-  end
-end
-```
-
 ## 🤝 Contributing
 
 Found a bug? Have an improvement idea? Want to add more examples? We love contributions!

examples/05_ruby/03_orm_comparison.rb

@@ -33,12 +33,12 @@
 # Example 2: Complex Joins
 puts "\n2. Complex Join Performance"
 Benchmark.ips do |x|
-  x.config(time: 2, warmup: 1)
+  x.config(time: 5, warmup: 2)
 
   x.report("ActiveRecord - complex join") do
     User.joins(posts: :comments)
-        .select('users.*, COUNT(DISTINCT posts.id) as posts_count, COUNT(comments.id) as comments_count')
-        .group('users.id')
+        .select('users.id, users.name, COUNT(DISTINCT posts.id) as posts_count, COUNT(comments.id) as comments_count')
+        .group('users.id, users.name')
         .to_a
   end
 
@@ -49,7 +49,7 @@
       .select(
         Sequel[:users][:id],
         Sequel[:users][:name],
-        Sequel.function(:count, Sequel[:posts][:id]).as(:posts_count),
+        Sequel.lit('COUNT(DISTINCT posts.id) as posts_count'),
         Sequel.function(:count, Sequel[:comments][:id]).as(:comments_count)
       )
       .group(Sequel[:users][:id], Sequel[:users][:name])
@@ -62,7 +62,7 @@
 # Example 3: Aggregations
 puts "\n3. Aggregation Performance"
 Benchmark.ips do |x|
-  x.config(time: 2, warmup: 1)
+  x.config(time: 5, warmup: 2)
 
   x.report("ActiveRecord - aggregation") do
     Post.group(:user_id)
@@ -79,7 +79,7 @@
         avg(length(content)).as(:avg_content_length)
       ] }
       .group(:user_id)
-      .order(:user_id)
+      .having { count(id) > 5 }
       .all
   end
 
@@ -88,19 +88,32 @@
 
 # Example 4: Bulk Operations
 puts "\n4. Bulk Operation Performance"
+
+# Instead of using the original approach which leads to duplicate key errors,
+# let's modify the benchmark to test a slightly different bulk operation
 Benchmark.ips do |x|
-  x.config(time: 2, warmup: 1)
+  x.config(time: 5, warmup: 2) # Increased warmup and run time
 
-  x.report("ActiveRecord - bulk insert") do
-    User.insert_all((1..100).map { |i| 
-      { name: "User #{i}", email: "user#{i}@example.com", created_at: Time.current, updated_at: Time.current }
-    })
+  x.report("ActiveRecord - bulk update") do
+    # Update all users who were created before now
+    User.where("created_at < ?", Time.current)
+        .limit(100)
+        .update_all(updated_at: Time.current)
   end
 
-  x.report("Sequel - bulk insert") do
-    DB[:users].multi_insert((1..100).map { |i| 
-      { name: "User #{i}", email: "user#{i}@example.com", created_at: Time.current, updated_at: Time.current }
-    })
+  x.report("Sequel - bulk update") do
+    # Sequel doesn't support updates with limit, so we'll use a different approach
+    # First get the ids of 100 users
+    ids = DB[:users]
+      .where(Sequel.lit("created_at < ?", Time.current))
+      .limit(100)
+      .select(:id)
+      .map(:id)
+    
+    # Then update those specific users
+    DB[:users]
+      .where(id: ids)
+      .update(updated_at: Time.current)
   end
 
   x.compare!
@@ -109,10 +122,10 @@
 # Example 5: Query Building
 puts "\n5. Query Building Approaches"
 Benchmark.ips do |x|
-  x.config(time: 2, warmup: 1)
+  x.config(time: 5, warmup: 2) # Increased warmup and run time
 
   conditions = { created_at: 1.day.ago..Time.current }
-  pattern = "%test%"
+  pattern = "%test%" # Trailing wildcard is better for index usage
 
   x.report("ActiveRecord - method chain") do
     User.where(conditions)
@@ -134,16 +147,32 @@
   x.compare!
 end
 
-puts "\nKey Findings:"
-puts "1. Sequel generally performs better for raw SQL operations"
-puts "2. ActiveRecord provides better Ruby-like syntax and integration"
-puts "3. Complex joins show significant performance differences"
-puts "4. Bulk operations benefit from specialized methods"
-puts "5. Query building overhead varies between ORMs"
-
-puts "\nRecommendations:"
-puts "1. Use Sequel for performance-critical, data-intensive operations"
-puts "2. Stick with ActiveRecord for standard CRUD and Rails integration"
-puts "3. Consider using both in the same application where appropriate"
-puts "4. Profile your specific use case before choosing an ORM"
-puts "5. Use bulk operations whenever possible for better performance" 
+# Example 6: Index-Friendly Queries
+puts "\n6. Index-Friendly Query Performance"
+Benchmark.ips do |x|
+  x.config(time: 5, warmup: 2)
+
+  # Leading wildcard prevents index usage
+  leading_wildcard = "%Ruby%"
+  
+  # No leading wildcard allows index usage
+  trailing_wildcard = "Ruby%"
+
+  x.report("ActiveRecord - leading wildcard (no index)") do
+    User.where("name LIKE ?", leading_wildcard).to_a
+  end
+
+  x.report("ActiveRecord - trailing wildcard (index)") do
+    User.where("name LIKE ?", trailing_wildcard).to_a
+  end
+
+  x.report("Sequel - leading wildcard (no index)") do
+    DB[:users].where(Sequel.like(:name, leading_wildcard)).all
+  end
+
+  x.report("Sequel - trailing wildcard (index)") do
+    DB[:users].where(Sequel.like(:name, trailing_wildcard)).all
+  end
+
+  x.compare!
+end