mini_sql 0.2.4 → 1.1.0

data/Gemfile

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 source "https://rubygems.org"
 
-git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
 
 # Specify your gem's dependencies in mini_sql.gemspec
 gemspec

data/Guardfile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 guard :minitest do
   watch(%r{^test/(.*)_test\.rb$})
   watch(%r{^lib/(.*/)?([^/]+)\.rb$})     { |m| "test/#{m[1]}#{m[2]}_test.rb" }

data/README.md

@@ -32,11 +32,28 @@ conn.query("select 1 id, 'bob' name").each do |user|
   puts user.id # 1
 end
 
+# extend result objects with additional method
+module ProductDecorator
+  def amount_price
+    price * quantity
+  end
+end
+
+conn.query_decorator(ProductDecorator, "select 20 price, 3 quantity").each do |user|
+  puts user.amount_price # 60
+end
+
 p conn.query_single('select 1 union select 2')
 # [1,2]
 
 p conn.query_hash('select 1 as a, 2 as b union select 3, 4')
 # [{"a" => 1, "b"=> 1},{"a" => 3, "b" => 4}
+ 
+p conn.query_array("select 1 as a, '2' as b union select 3, 'e'")
+# [[1, '2'], [3, 'e']]
+ 
+p conn.query_array("select 1 as a, '2' as b union select 3, 'e'").to_h
+# {1 => '2', 3 => 'e'}
 ```
 
 ## The query builder
@@ -63,9 +80,18 @@ end
 The builder allows for `order_by`, `where`, `select`, `set`, `limit`, `join`, `left_join` and `offset`.
 
 ## Is it fast?
-
 Yes, it is very fast. See benchmarks in [the bench directory](https://github.com/discourse/mini_sql/tree/master/bench).
 
+**Comparison mini_sql methods**
+```
+query_array     1351.6 i/s
+      query      963.8 i/s - 1.40x  slower
+ query_hash      787.4 i/s - 1.72x  slower
+
+query_single('select id from topics limit 1000')             2368.9 i/s
+ query_array('select id from topics limit 1000').flatten     1350.1 i/s - 1.75x  slower
+```
+
 As a rule it will outperform similar naive PG code while remaining safe.
 
 ```ruby
@@ -98,6 +124,83 @@ MiniSql is careful to always clear results as soon as possible.
 
 MiniSql's default type mapper prefers treating `timestamp without time zone` columns as utc. This is done to ensure widest amount of compatability and is a departure from the default in the PG 1.0 gem. If you wish to amend behavior feel free to pass in a custom type_map.
 
+## Custom type maps
+
+When using Postgres, native type mapping implementation is used. This is roughly
+implemented as:
+
+```ruby
+type_map ||= PG::BasicTypeMapForResults.new(conn)
+# additional specific decoders
+```
+
+The type mapper instansitated once on-demand at boot and reused by all mini_sql connections.
+
+Initializing the basic type map for Postgres can be a costly operation. You may
+wish to amend the type mapper so for example you only return strings:
+
+```
+# maybe you do not want Integer
+p cnn.query("select a 1").first.a
+"1"
+```
+
+To specify a different type mapper for your results use:
+
+```
+MiniSql::Connections.get(pg_connection, type_map: custom_type_map)
+```
+
+In the case of Rails you can opt to use the type mapper Rails uses with:
+
+```
+pg_cnn = ActiveRecord::Base.connection.raw_connection
+mini_sql_cnn = MiniSql::Connection.get(pg_cnn, type_map: pg_cnn.type_map_for_results)
+```
+
+Note the type mapper for Rails may miss some of the mapping MiniSql ships with such as `IPAddr`, MiniSql is also careful to use the very efficient TimestampUtc decoders where available.
+
+## Streaming support
+
+In some exceptional cases you may want to stream results directly from the database. This enables selection of 100s of thousands of rows with limited memory impact.
+
+Two interfaces exists for this:
+
+`query_each` : which can be used to get materialized objects  
+`query_each_hash` : which can be used to iterate through Hash objects
+
+Usage:
+
+```ruby
+mini_sql_cnn.query_each("SELECT * FROM tons_of_cows limit :limit", limit: 1_000_000) do |row|
+  puts row.cow_name
+  puts row.cow_age
+end
+
+mini_sql_cnn.query_each_hash("SELECT * FROM one_million_cows") do |row|
+  puts row["cow_name"]
+  puts row["cow_age"]
+end
+```
+
+Note, in Postgres streaming is going to be slower than non-streaming options due to internal implementation in the pq gem, each row gets a full result object and additional bookkeeping is needed. Only use it if you need to optimize memory usage.
+
+Streaming support is only implemented in the postgres backend at the moment, PRs welcome to add to other backends.
+
+## Prepared Statements
+See [benchmark mini_sql](https://github.com/discourse/mini_sql/tree/master/bench/prepared_perf.rb)
+[benchmark mini_sql vs rails](https://github.com/discourse/mini_sql/tree/master/bench/bilder_perf.rb).
+
+By default prepared cache size is 500 queries. Use prepared queries only for frequent queries.
+
+```ruby
+conn.prepared.query("select * from table where id = ?", id: 10)
+
+ids = rand(100) < 90 ? [1] : [1, 2]
+builder = conn.build("select * from table /*where*/")
+builder.where("id IN (?)", ids)
+builder.prepared(ids.size == 1).query # most frequent query
+```
 
 ## I want more features!
 
@@ -106,6 +209,27 @@ MiniSql is designed to be very minimal. Even though the query builder and type m
 ## Development
 
 To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+### Local testing
+```bash
+  docker run --name mini-sql-mysql --rm -it -p 33306:3306 -e MYSQL_DATABASE=test_mini_sql -e MYSQL_ALLOW_EMPTY_PASSWORD=yes -d mysql:5.7
+  export MINI_SQL_MYSQL_HOST=127.0.0.1
+  export MINI_SQL_MYSQL_PORT=33306
+  
+  docker run --name mini-sql-postgres --rm -it -p 55432:5432 -e POSTGRES_DB=test_mini_sql -e POSTGRES_HOST_AUTH_METHOD=trust -d postgres
+  export MINI_SQL_PG_USER=postgres
+  export MINI_SQL_PG_HOST=127.0.0.1
+  export MINI_SQL_PG_PORT=55432
+
+  sleep 10 # waiting for up databases
+
+  bundle exec rake
+
+  # end working on mini-sql
+  docker stop mini-sql-postgres mini-sql-mysql
+```
+
+Sqlite tests rely on the SQLITE_STMT view existing. This is enabled by default on most systems, however some may
+opt for a leaner install. See: https://bugs.archlinux.org/task/70072. You may have to recompile sqlite on such systems.
 
 ## Contributing
 

data/Rakefile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "bundler/gem_tasks"
 require "rake/testtask"
 
@@ -13,4 +15,4 @@ Rake::TestTask.new(:test) do |t|
   t.test_files = FileList[test_glob]
 end
 
-task :default => :test
+task default: :test

data/bench/builder_perf.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require 'bundler/inline'
+
+gemfile do
+  source 'https://rubygems.org'
+  gem 'mini_sql', path: '../'
+  gem 'pg'
+  gem 'activerecord'
+  gem 'activemodel'
+  gem 'benchmark-ips'
+end
+
+require 'active_record'
+require 'benchmark/ips'
+require 'mini_sql'
+
+require '../mini_sql/bench/shared/generate_data'
+
+ar_connection, _ = GenerateData.new(count_records: 10_000).call
+MINI_SQL = MiniSql::Connection.get(ar_connection.raw_connection)
+
+def mini_sql(is_prepared, user_id)
+  MINI_SQL
+    .build(<<~SQL)
+      /*select*/ from topics /*join*/ /*where*/ /*group_by*/
+    SQL
+    .select('users.first_name, count(distinct topics.id) topics_count')
+    .join('users on user_id = users.id')
+    .join('categories on category_id = categories.id')
+    .where('users.id = ?', user_id)
+    .group_by('users.id')
+    .prepared(is_prepared)
+    .query
+end
+
+def mini_sql_optim(is_prepared, user_id)
+  @builder ||=
+    MINI_SQL
+      .build(<<~SQL)
+        /*select*/ from topics /*join*/ /*where*/ /*group_by*/
+      SQL
+      .select('users.first_name, count(distinct topics.id) topics_count')
+      .join('users on user_id = users.id')
+      .join('categories on category_id = categories.id')
+      .where('users.id = :user_id')
+      .group_by('users.id')
+
+  @builder
+    .prepared(is_prepared)
+    .query(user_id: user_id)
+end
+
+def ar_prepared(user_id)
+  Topic
+    .select(User.arel_table[:first_name] , Topic.arel_table[:id].count)
+    .joins(:user, :category)
+    .where(user_id: user_id)
+    .group(User.arel_table[:id])
+    .load
+end
+
+def ar_prepared_optim(user_id)
+  @rel ||= Topic
+    .select(User.arel_table[:first_name] , Topic.arel_table[:id].count)
+    .joins(:user, :category)
+    .group(User.arel_table[:id])
+
+  @rel
+    .where(user_id: user_id)
+    .load
+end
+
+def ar_unprepared(user_id)
+  Topic
+    .select('users.first_name, count(distinct topics.id) topics_count')
+    .joins(:user, :category)
+    .where(user_id: user_id)
+    .group('users.id')
+    .load
+end
+
+Benchmark.ips do |x|
+  x.report("mini_sql_prepared") do |n|
+    while n > 0
+      mini_sql(true, rand(100))
+      n -= 1
+    end
+  end
+  x.report("mini_sql") do |n|
+    while n > 0
+      mini_sql(false, rand(100))
+      n -= 1
+    end
+  end
+
+  x.report("mini_sql_prepared_optim") do |n|
+    while n > 0
+      mini_sql_optim(true, rand(100))
+      n -= 1
+    end
+  end
+  x.report("mini_sql_optim") do |n|
+    while n > 0
+      mini_sql_optim(false, rand(100))
+      n -= 1
+    end
+  end
+
+  x.report("ar_prepared") do |n|
+    while n > 0
+      ar_prepared(rand(100))
+      n -= 1
+    end
+  end
+
+  x.report("ar_prepared_optim") do |n|
+    while n > 0
+      ar_prepared_optim(rand(100))
+      n -= 1
+    end
+  end
+
+  x.report("ar_unprepared") do |n|
+    while n > 0
+      ar_unprepared(rand(100))
+      n -= 1
+    end
+  end
+
+  x.compare!
+end
+
+# Comparison:
+#    mini_sql_prepared:     8386.2 i/s
+#             mini_sql:     2742.3 i/s - 3.06x  (± 0.00) slower
+#          ar_prepared:     1599.3 i/s - 5.24x  (± 0.00) slower
+#        ar_unprepared:      868.9 i/s - 9.65x  (± 0.00) slower

data/bench/decorator_perf.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require 'bundler/inline'
+
+gemfile do
+  source 'https://rubygems.org'
+  gem 'pg', github: 'ged/ruby-pg'
+  gem 'mini_sql', path: '../'
+  gem 'activerecord'
+  gem 'activemodel'
+  gem 'benchmark-ips'
+  gem 'sequel', github: 'jeremyevans/sequel'
+  gem 'sequel_pg', github: 'jeremyevans/sequel_pg', require: 'sequel'
+  gem 'draper'
+  gem 'pry'
+end
+
+require 'active_record'
+require 'benchmark/ips'
+require 'mini_sql'
+
+require '../mini_sql/bench/shared/generate_data'
+
+ar_connection, conn_config = GenerateData.new(count_records: 1_000).call
+MINI_SQL = MiniSql::Connection.get(ar_connection.raw_connection)
+DB = Sequel.connect(ar_connection.instance_variable_get(:@config).slice(:database, :user, :password, :host, :adapter))
+
+
+# https://github.com/drapergem/draper
+class TopicDraper < Draper::Decorator
+  delegate :id
+
+  def title_bang
+    object.title + '!!!'
+  end
+end
+
+# https://ruby-doc.org/stdlib-2.5.1/libdoc/delegate/rdoc/SimpleDelegator.html
+class TopicSimpleDelegator < SimpleDelegator
+  def title_bang
+    title + '!!!'
+  end
+end
+
+class TopicSequel < Sequel::Model(DB[:topics]); end
+class TopicDecoratorSequel < TopicSequel
+  def title_bang
+    title + '!!!'
+  end
+end
+
+class Topic < ActiveRecord::Base;end
+class TopicArModel < Topic
+  def title_bang
+    title + '!!!'
+  end
+end
+
+module TopicDecorator
+  def title_bang
+    title + '!!!'
+  end
+end
+
+Benchmark.ips do |r|
+  r.report('query_decorator') do |n|
+    while n > 0
+      MINI_SQL.query_decorator(TopicDecorator, 'select id, title from topics order by id limit 1000').each do |obj|
+        obj.title_bang
+        obj.id
+      end
+      n -= 1
+    end
+  end
+  r.report('extend') do |n|
+    while n > 0
+      MINI_SQL.query('select id, title from topics order by id limit 1000').each do |obj|
+        d_obj = obj.extend(TopicDecorator)
+        d_obj.title_bang
+        d_obj.id
+      end
+      n -= 1
+    end
+  end
+  r.report('draper') do |n|
+    while n > 0
+      MINI_SQL.query('select id, title from topics order by id limit 1000').each do |obj|
+        d_obj = TopicDraper.new(obj)
+        d_obj.title_bang
+        d_obj.id
+      end
+      n -= 1
+    end
+  end
+  r.report('simple_delegator') do |n|
+    while n > 0
+      MINI_SQL.query('select id, title from topics order by id limit 1000').each do |obj|
+        d_obj = TopicSimpleDelegator.new(obj)
+        d_obj.title_bang
+        d_obj.id
+      end
+      n -= 1
+    end
+  end
+  r.report('query') do |n|
+    while n > 0
+      MINI_SQL.query('select id, title from topics order by id limit 1000').each do |obj|
+        obj.title + '!!!'
+        obj.id
+      end
+      n -= 1
+    end
+  end
+  r.report('ar model') do |n|
+    while n > 0
+      TopicArModel.limit(1000).order(:id).select(:id, :title).each do |obj|
+        obj.title_bang
+        obj.id
+      end
+      n -= 1
+    end
+  end
+  r.report('sequel model') do |n|
+    while n > 0
+      TopicDecoratorSequel.limit(1000).order(:id).select(:id, :title).each do |obj|
+        obj.title_bang
+        obj.id
+      end
+      n -= 1
+    end
+  end
+
+  r.compare!
+end
+
+# Comparison:
+#                query:     1102.9 i/s
+#      query_decorator:     1089.0 i/s - same-ish: difference falls within error
+#         sequel model:      860.2 i/s - 1.28x  (± 0.00) slower
+#     simple_delegator:      679.8 i/s - 1.62x  (± 0.00) slower
+#               extend:      678.1 i/s - 1.63x  (± 0.00) slower
+#               draper:      587.2 i/s - 1.88x  (± 0.00) slower
+#             ar model:      172.5 i/s - 6.39x  (± 0.00) slower