[ruby/rack] Don't use Sequel ORM

Just use the raw `pg` adapter.
For JRuby fallback to Sequel as it's a lot easier.

Author: p8

frameworks/Ruby/rack/Gemfile

@@ -7,13 +7,18 @@ puts "Platform: #{Gem::Platform.local}"
 
 gem 'rack', '~> 3.0'
 gem 'connection_pool'
-gem 'jdbc-postgres', '~> 42.2', platforms: :jruby, require: 'jdbc/postgres'
 gem 'json', '~> 2.10'
-gem 'pg', '~> 1.5', platforms: %i[ruby windows]
-gem 'sequel'
-gem 'sequel_pg', platforms: %i[ruby windows], require: 'sequel'
 gem 'tzinfo-data', '1.2023.3'
 
+platforms :ruby, :windows do
+  gem 'pg', '~> 1.5', platforms: %i[ruby windows]
+end
+
+platforms :jruby do
+  gem 'jdbc-postgres', '~> 42.2', require: 'jdbc/postgres'
+  gem 'sequel'
+end
+
 group :falcon, optional: true do
   gem 'falcon', '~> 0.52', platforms: %i[ruby windows]
 end

frameworks/Ruby/rack/config/pitchfork.rb

@@ -1,12 +1,7 @@
 # frozen_string_literal: true
 
 require 'etc'
-require 'sequel'
 
 worker_processes (Etc.nprocessors * 1.5).to_i
 
-before_fork do |_server|
-  Sequel::DATABASES.each(&:disconnect)
-end
-
 listen "/tmp/.sock", :backlog => 4096

frameworks/Ruby/rack/config/puma.rb

@@ -1,7 +1,4 @@
 if ENV.fetch('WEB_CONCURRENCY').to_i > 1
-  before_fork do
-    Sequel::DATABASES.each(&:disconnect)
-  end
 else
   workers ENV.fetch('WEB_CONCURRENCY')
   require 'concurrent/utility/processor_counter'

frameworks/Ruby/rack/db.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'pg'
+require 'connection_pool'
+
+def connect(url)
+  if defined?(Puma) || defined?(Itsi)
+    max_connections = ENV.fetch('MAX_THREADS')
+  elsif defined?(Iodine)
+    max_connections = ENV.fetch('THREADS')
+  else
+    max_connections = 512
+  end
+  ConnectionPool.new(size: max_connections, timeout: 5) do
+    PGConnection.new(url)
+  end
+end
+
+class PGConnection
+  attr_reader :connection
+
+  def initialize(connection_string)
+    @connection = PG::Connection.new(connection_string)
+    @connection.set_error_verbosity(PG::PQERRORS_VERBOSE)
+    @connection.prepare('select_world', 'SELECT id, randomNumber FROM world WHERE id = $1')
+  end
+
+  def select_world(id)
+    @connection.exec_prepared('select_world', [id]).first
+  end
+
+  def select_fortunes
+    @connection.exec('SELECT id, message FROM fortune')
+  end
+
+  def exec(query)
+    @connection.exec(query)
+  end
+end

frameworks/Ruby/rack/db_jruby.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'sequel'
+
+def connect(url)
+  JDBCConnection.new("jdbc:" + url, max_connections: 512)
+end
+
+class JDBCConnection
+  attr_reader :connection
+
+  def initialize(connection_string, max_connections:)
+    @connection = Sequel.connect(connection_string, max_connections: max_connections)
+    @world_select = @connection['SELECT id, randomNumber FROM World WHERE id = ?', :$id].prepare(:select, :select_by_id)
+    @fortune_select = @connection['SELECT id, message FROM Fortune'].prepare(:select, :select_all)
+  end
+
+  def select_world(id)
+    @world_select.call(id: id).first.transform_keys(&:to_s)
+  end
+
+  def select_fortunes
+    @fortune_select.call.map { it.transform_keys(&:to_s) }
+  end
+
+  def exec(query)
+    @connection[query].update
+  end
+
+  def with
+    yield(self)
+  end
+end

frameworks/Ruby/rack/hello_world.rb

@@ -2,17 +2,19 @@
 
 # Our Rack application to be executed by rackup
 
-require_relative 'pg_db'
+if RUBY_PLATFORM == 'java'
+  require_relative 'db_jruby'
+else
+  require_relative 'db'
+end
 require_relative 'config/auto_tune'
 require 'rack'
 require 'json'
+require 'time'
 require 'erb'
 
-if RUBY_PLATFORM == 'java'
-  DEFAULT_DATABASE_URL = 'jdbc:postgresql://tfb-database/hello_world?user=benchmarkdbuser&password=benchmarkdbpass'
-else
-  DEFAULT_DATABASE_URL = 'postgresql://tfb-database/hello_world?user=benchmarkdbuser&password=benchmarkdbpass'
-end
+DATABASE_URL = 'postgresql://tfb-database/hello_world?user=benchmarkdbuser&password=benchmarkdbpass'
+$db = connect(DATABASE_URL)
 
 class HelloWorld
   QUERY_RANGE = (1..10_000).freeze # range of IDs in the Fortune DB
@@ -42,30 +44,6 @@ class HelloWorld
     </body>
   </html>'
 
-  def initialize
-    if defined?(Puma) || defined?(Itsi)
-      max_connections = ENV.fetch('MAX_THREADS')
-    elsif defined?(Iodine)
-      max_connections = ENV.fetch('THREADS')
-    else
-      max_connections = 512
-    end
-    @db = PgDb.new(DEFAULT_DATABASE_URL, max_connections)
-  end
-
-  def fortunes
-    fortunes = @db.select_fortunes
-    fortunes << { id: 0, message: 'Additional fortune added at request time.' }
-    fortunes.sort_by! { |item| item[:message] }
-    buffer = String.new
-    buffer << TEMPLATE_PREFIX
-
-    fortunes.each do |item|
-      buffer << "<tr><td>#{item[:id]}</td><td>#{ERB::Escape.html_escape(item[:message])}</td></tr>"
-    end
-    buffer << TEMPLATE_POSTFIX
-  end
-
   def call(env)
     case env['PATH_INFO']
     when '/json'
@@ -74,20 +52,19 @@ def call(env)
               { message: 'Hello, World!' }.to_json
     when '/db'
       # Test type 2: Single database query
-      respond JSON_TYPE, @db.select_random_world.to_json
+      id = random_id
+      respond JSON_TYPE, $db.with{ _1.select_world(id) }.to_json
     when '/queries'
       # Test type 3: Multiple database queries
-      params = Rack::Utils.parse_query(env['QUERY_STRING'])
-      queries = params['queries']
-      respond JSON_TYPE, @db.select_worlds(queries).to_json
+      queries = bounded_queries(env)
+      respond JSON_TYPE, select_worlds(queries).to_json
     when '/fortunes'
       # Test type 4: Fortunes
       respond HTML_TYPE, fortunes
     when '/updates'
       # Test type 5: Database updates
-      params = Rack::Utils.parse_query(env['QUERY_STRING'])
-      queries = params['queries']
-      respond JSON_TYPE, @db.update_worlds(queries).to_json
+      queries = bounded_queries(env)
+      respond JSON_TYPE, update_worlds(queries).to_json
     when '/plaintext'
       # Test type 6: Plaintext
       respond PLAINTEXT_TYPE, 'Hello, World!'
@@ -120,4 +97,51 @@ def headers(content_type)
       }
     end
   end
+
+  def fortunes
+    fortunes = $db.with(&:select_fortunes).map(&:to_h)
+    fortunes << { 'id' => 0, 'message' => 'Additional fortune added at request time.' }
+    fortunes.sort_by! { |item| item['message'] }
+    buffer = String.new
+    buffer << TEMPLATE_PREFIX
+
+    fortunes.each do |item|
+      buffer << "<tr><td>#{item['id']}</td><td>#{ERB::Escape.html_escape(item['message'])}</td></tr>"
+    end
+    buffer << TEMPLATE_POSTFIX
+  end
+
+  def update_worlds(count)
+    results = select_worlds(count)
+    ids = []
+    sql = String.new("UPDATE world SET randomnumber = CASE id ")
+    results.each do |r|
+      r['randomnumber'] = random_id
+      ids << r['id']
+      sql << "when #{r['id']} then #{r['randomnumber']} "
+    end
+    sql << "ELSE randomnumber END WHERE id IN ( #{ids.join(',')})"
+    $db.with{ _1.exec(sql) }
+    results
+  end
+
+  def select_worlds(count)
+    ids = ALL_IDS.sample(count)
+    $db.with do |conn|
+      ids.map do |id|
+        conn.select_world(id)
+      end
+    end
+  end
+
+  def random_id
+    Random.rand(QUERY_RANGE)
+  end
+
+  def bounded_queries(env)
+    params = Rack::Utils.parse_query(env['QUERY_STRING'])
+
+    queries = params['queries'].to_i
+    queries.clamp(MIN_QUERIES, MAX_QUERIES)
+  end
 end