mini_sql 0.2.5 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c8f5bcd09064cc2353fb1c2f172845cb738c72f9da2ff44786fdf1f119f7c36c
-  data.tar.gz: 1d7abcda16fa7d972aa0ae6b64bc1f23532feda03daf0098dcbff00f1e2e0d49
+  metadata.gz: df275ffff82e8f6fc97b466178d50bcb8e3d5af55167f811abce10356e248770
+  data.tar.gz: 7b943e8a2dca0d546c0140d0957d4712d4f11610f169caefcd01aa7ea8e75e9a
 SHA512:
-  metadata.gz: a84dca1674849011cd77e796046d0ece93e7952603470a51b959332180a1533fb1d15f1d3e3b69cb6f5bcc2f43e4f80c6902d85c0709443bc9004a15bc721921
-  data.tar.gz: 4433947c712bcf6c9346fa2b0df792bc95c7fdaa453e5ae19b649241c24ba7ab3b57397cb66114b68ba4e622dfcc6242e6631beed129f5a8cd08bc618e13381d
+  metadata.gz: 5fda186dcae83e032b1f120782edd86c8d1d7e276afeb040479fca4e5cc6a52e40499f45df5c9a3303c7823e0e9fed128c17b422bdd12903fa50c4198732c25b
+  data.tar.gz: affcf46e3c8cfffd001fbef3c5d49f938c694a7b85412df7855938fb1326330a386d0557021bd2b1156f7e0bd10a6c1c560cc171190e0ff21e5a06e3375ee984

data/.github/workflows/ci.yml

@@ -0,0 +1,66 @@
+name: Mini SQL Tests
+
+on:
+  pull_request:
+  push:
+    branches:
+      - master
+
+env:
+  PGHOST: localhost
+  PGPORT: 5432
+  PGPASSWORD: postgres
+  PGUSER: postgres
+  MINI_SQL_MYSQL_HOST: 127.0.0.1
+  MINI_SQL_MYSQL_PORT: 3306
+  MINI_SQL_MYSQL_PASSWORD: mysql
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    name: Ruby ${{ matrix.ruby }}
+    services:
+      postgres:
+        image: postgres:10
+        env:
+          POSTGRES_PASSWORD: postgres
+        ports:
+          - 5432:5432
+        options: --health-cmd pg_isready --health-interval 10s --health-timeout 5s --health-retries 5
+      mysql:
+        image: mysql:5.7
+        env:
+          MYSQL_ROOT_PASSWORD: mysql
+        ports:
+          - 3306:3306
+        options: --health-cmd="mysqladmin ping" --health-interval=10s --health-timeout=5s --health-retries=3
+    strategy:
+      matrix:
+        ruby: ["2.7", "2.6", "2.5"]
+        experimental: [false]
+        include:
+          - ruby: ruby-head
+            experimental: true
+    steps:
+      - uses: actions/checkout@v2
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+      - name: Bundler cache
+        uses: actions/cache@v2
+        with:
+          path: vendor/bundle
+          key: ${{ runner.os }}-${{ matrix.ruby }}-gems-${{ hashFiles('**/Gemfile.lock') }}
+          restore-keys: |
+            ${{ runner.os }}-${{ matrix.ruby }}-gems-
+      - name: Create Databases
+        run: |
+          createdb test_mini_sql
+          mysql --host=127.0.0.1 --port=3306 --user=root --password=mysql -e 'CREATE DATABASE test_mini_sql'
+      - name: Setup gems
+        run: |
+          bundle config path vendor/bundle
+          bundle install --jobs 4
+      - name: Tests
+        run: bundle exec rake test
+      - name: Rubocop
+        run: bundle exec rubocop

data/.rubocop.yml

@@ -1,5 +1,8 @@
-inherit_from: https://raw.githubusercontent.com/discourse/discourse/master/.rubocop.yml
-
+inherit_gem:
+  rubocop-discourse: default.yml
+inherit_mode:
+  merge:
+    - Exclude
 AllCops:
   Exclude:
     - 'bench/**/*'

data/CHANGELOG

@@ -1,3 +1,25 @@
+2021-03-22 - 1.1.1
+
+- FIX: compatability with ActiveRecord param encoder
+
+2021-03-22 - 1.1.0
+
+- FEATURE: added new APIs to support prepared statements
+
+2020-12-31 - 1.0.1
+
+- FIX: revert perf fix broke param_encoder interface, we were expecting never to be called if no encoding was to happen
+
+2020-12-30 - 1.0
+
+- Added serialization support using MiniSql::Serializer.to_json / .from_json
+- Fixed minor issue with cache poisoning when using query_decorator
+- Version 1.0 to reflect the stability of the interfaces and project, used in productions for almost 2 years now
+
+2020-06-25 - 0.3
+
+- Added support for query_each and query_each_hash, which lazily queries rows and enables selecting large result sets by streaming
+
 2020-04-07 - 0.2.5
 
 - Added support for custom type maps with Postgres connections

data/README.md

@@ -130,10 +130,12 @@ When using Postgres, native type mapping implementation is used. This is roughly
 implemented as:
 
 ```ruby
-type_map = PG::BasicTypeMapForResults.new(conn)
+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:
 
@@ -158,6 +160,48 @@ mini_sql_cnn = MiniSql::Connection.get(pg_cnn, type_map: pg_cnn.type_map_for_res
 
 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!
 
 MiniSql is designed to be very minimal. Even though the query builder and type materializer give you a lot of mileage, it is not intended to be a fully fledged ORM. If you are looking for an ORM I recommend investigating ActiveRecord or Sequel which provide significantly more features.
@@ -165,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/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