mini_sql 0.1.9 → 0.1.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: abb973879fc47b098296d28aff0023d3c3a734acff63da3f59cde4c3129ea08d
-  data.tar.gz: 6283be1e1037e203a1c842e8371f6a0b4eef1b506c2ef1a7b260a6ffe89aa9ac
+  metadata.gz: c66544eb3a8d9b5067dc3ba1fb1df6a542e4adeabc2f4b08d4392fab7955b382
+  data.tar.gz: c3701417f3667ae360470d24a2bdd60b002350a1690a28cb1e9c95b0040d9c96
 SHA512:
-  metadata.gz: 2ef6234f201e71933e61fa965fa718fad2c4db88c70e9ef724b3de754105b519b45ffc415fe0df72a2c8dfb1e4c9f29fe9b0ae304a0c6658a6aa7ca9944ecbb0
-  data.tar.gz: 67a511de5b14d5b28265a273bf0a0cb706027c49da8d1885328eab9cbc6c8443ea69aacadb77dc2eba8a5159864b8f05be1ccdbd9586f97b2ae993128d39d1e9
+  metadata.gz: d8b474bc10bd5570a2b4932f5182e97ad5c242885d2e3e68e8fa5246d21bf908b57044daf107b1968cf4895cb0e32af1af05f649c6049cd0747ddd43d2647836
+  data.tar.gz: 9c98da1a59f650541955b435f34fdbc3d4ed2ee7245d254d6d7decf9edbb25c8436b98a0dd0f3f4017e2f003ee51ae5f8f38e294c74f826be160d661bd361bac

data/README.md

@@ -46,6 +46,8 @@ You can use the simple query builder interface to compose queries.
 ```ruby
 builder = conn.build("select * from topics /*where*/ /*limit*/")
 
+builder.where('created_at > ?', Time.now - 400)
+
 if look_for_something
   builder.where("title = :title", title: 'something')
 end
@@ -58,6 +60,8 @@ builder.query.each do |t|
 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).
@@ -85,11 +89,20 @@ end
 
 ## Safety
 
-In current version of the PG gem you should be careful to clear results. If you do not you risk memory bloat.
+In PG gem version 1.0 and below you should be careful to clear results. If you do not you risk memory bloat.
 See: [Sam's blog post](https://samsaffron.com/archive/2018/06/13/ruby-x27-s-external-malloc-problem).
 
 MiniSql is careful to always clear results as soon as possible.
 
+## Timestamp decoding
+
+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.
+
+
+## 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.
+
 ## 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).

data/bench/timestamp_perf.rb

@@ -0,0 +1,249 @@
+require 'bundler/inline'
+
+gemfile do
+  source 'https://rubygems.org'
+  gem 'pg', github: 'ged/ruby-pg'
+  gem 'mini_sql', path: '../'
+  gem 'activesupport'
+  gem 'activerecord'
+  gem 'activemodel'
+  gem 'memory_profiler'
+  gem 'benchmark-ips'
+  gem 'sequel', github: 'jeremyevans/sequel'
+  gem 'sequel_pg', github: 'jeremyevans/sequel_pg', require: 'sequel'
+  gem 'swift-db-postgres', github: 'deepfryed/swift-db-postgres'
+end
+
+require 'sequel'
+require 'active_record'
+require 'memory_profiler'
+require 'benchmark/ips'
+require 'mini_sql'
+
+ActiveRecord::Base.establish_connection(
+  :adapter => "postgresql",
+  :database => "test_db"
+)
+
+Sequel.default_timezone = :utc
+DB = Sequel.postgres('test_db')
+
+pg = ActiveRecord::Base.connection.raw_connection
+
+pg.async_exec <<SQL
+drop table if exists timestamps
+SQL
+
+pg.async_exec <<SQL
+CREATE TABLE timestamps (
+    id int primary key,
+    time1 timestamp without time zone NOT NULL,
+    time2 timestamp without time zone NOT NULL,
+    time3 timestamp without time zone NOT NULL,
+    time4 timestamp without time zone NOT NULL
+)
+SQL
+
+class Timestamp < ActiveRecord::Base
+end
+
+class TimestampSequel< Sequel::Model(:timestamps)
+end
+
+
+Timestamp.transaction do
+  stamps = {
+  }
+  Timestamp.columns.each do |c|
+    stamps[c.name.to_sym] = case c.type
+                           when :integer then 1
+                           when :datetime then Time.now
+                           when :boolean then false
+                           else "HELLO WORLD" * 2
+                           end
+  end
+
+  1000.times do |id|
+    stamps[:id] = id
+    Timestamp.create!(stamps)
+  end
+end
+
+$conn = ActiveRecord::Base.connection.raw_connection
+
+def ar_pluck_times(l=1000)
+  s = +""
+  Timestamp.limit(l).order(:id).pluck(:time1, :time2).each do |time1, time2|
+    s << time1.iso8601
+    s << time2.iso8601
+  end
+  s
+end
+
+def ar_select_times(l=1000)
+  s = +""
+  Timestamp.limit(l).order(:id).select(:time1, :time2).each do |t|
+    s << t.time1.iso8601
+    s << t.time2.iso8601
+  end
+  s
+end
+
+$mini_sql = MiniSql::Connection.new($conn)
+
+def pg_times(l=1000)
+  s = +""
+  # use the safe pattern here
+  r = $conn.async_exec_params(-"select time1, time2 from timestamps order by id limit $1", [l])
+  r.type_map = $mini_sql.type_map
+  r.each do |row|
+    s << row["time1"].iso8601
+    s << row["time2"].iso8601
+  end
+  r.clear
+  s
+end
+
+
+def mini_sql_times(l=1000)
+  s = +""
+  $mini_sql.query(-"select time1, time2 from timestamps order by id limit ?", l).each do |t|
+    s << t.time1.iso8601
+    s << t.time2.iso8601
+  end
+  s
+end
+
+def sequel_times(l=1000)
+  s = +""
+  TimestampSequel.limit(l).order(:id).select(:time1, :time2).each do |t|
+    s << t.time1.iso8601
+    s << t.time2.iso8601
+  end
+  s
+end
+
+def sequel_pluck_times(l=1000)
+  s = +""
+  TimestampSequel.limit(l).order(:id).select_map([:time1, :time2]).each do |t|
+    s << t[0].iso8601
+    s << t[1].iso8601
+  end
+  s
+end
+
+# usage is not really recommended but just to compare to pluck lets have it
+def mini_sql_times_single(l=1000)
+  s = +""
+  i = 0
+  r = $mini_sql.query_single(-"select time1, time2 from timestamps order by id limit ?", l)
+  while i < r.length
+    s << r[i].iso8601
+    s << r[i+1].iso8601
+    i += 2
+  end
+  s
+end
+
+$swift = Swift::DB::Postgres.new(db: "test_db", user: 'sam', password: 'password')
+
+def swift_select_times(l=1000)
+  s = ""
+  r = $swift.execute("select time1, time2 from timestamps order by id limit $1", l)
+  r.each do |row|
+    s << row[:time1].iso8601
+    s << row[:time2].iso8601
+  end
+  s
+end
+
+
+results = [
+  ar_select_times,
+  ar_pluck_times,
+  pg_times,
+  mini_sql_times,
+  mini_sql_times_single,
+  sequel_times,
+  sequel_pluck_times,
+]
+
+exit(-1) unless results.uniq.length == 1
+
+Benchmark.ips do |r|
+  r.report("ar select times") do |n|
+    while n > 0
+      ar_select_times
+      n -= 1
+    end
+  end
+  r.report("ar pluck times") do |n|
+    while n > 0
+      ar_pluck_times
+      n -= 1
+    end
+  end
+  r.report("sequel times") do |n|
+    while n > 0
+      sequel_times
+      n -= 1
+    end
+  end
+  r.report("pg times") do |n|
+    while n > 0
+      pg_times
+      n -= 1
+    end
+  end
+  r.report("mini sql times") do |n|
+    while n > 0
+      mini_sql_times
+      n -= 1
+    end
+  end
+  r.report("sequel pluck times") do |n|
+    while n > 0
+      sequel_pluck_times
+      n -= 1
+    end
+  end
+  r.report("mini_sql query_single times") do |n|
+    while n > 0
+      mini_sql_times_single
+      n -= 1
+    end
+  end
+  r.report("swift_select_times") do |n|
+    while n > 0
+      swift_select_times
+      n -= 1
+    end
+  end
+  r.compare!
+end
+
+# Comparison:
+#   swift_select_times:      222.4 i/s
+# mini_sql query_single times:       99.8 i/s - 2.23x  slower
+#       mini sql times:       97.1 i/s - 2.29x  slower
+#             pg times:       87.0 i/s - 2.56x  slower
+#       ar pluck times:       31.5 i/s - 7.05x  slower
+#      ar select times:       22.5 i/s - 9.89x  slower
+#   sequel pluck times:       10.9 i/s - 20.42x  slower
+#         sequel times:       10.4 i/s - 21.37x  slower
+#
+# NOTE PG version 1.0.0 has a slower time materializer
+#
+# if we force it we get:
+# 
+#   swift_select_times:      222.7 i/s
+# mini_sql query_single times:       48.4 i/s - 4.60x  slower
+#       mini sql times:       46.4 i/s - 4.80x  slower
+#             pg times:       44.2 i/s - 5.03x  slower
+#       ar pluck times:       32.5 i/s - 6.85x  slower
+#      ar select times:       22.1 i/s - 10.06x  slower
+#   sequel pluck times:       10.9 i/s - 20.50x  slower
+#         sequel times:       10.4 i/s - 21.43x  slower
+#
+# swift has a super fast implementation, still need to determine
+# why pg is so far behind

data/lib/mini_sql/coders.rb

@@ -5,10 +5,27 @@ module MiniSql
         BigDecimal.new(string)
       end
     end
+
     class IPAddrCoder < PG::SimpleDecoder
       def decode(string, tuple = nil, field = nil)
         IPAddr.new(string)
       end
     end
+
+    class TimestampUtc < PG::SimpleDecoder
+      # exact same implementation as Rails here
+      ISO_DATETIME = /\A(\d{4})-(\d\d)-(\d\d) (\d\d):(\d\d):(\d\d)(\.\d+)?\z/
+
+      def decode(string, tuple = nil, field = nil)
+        if string =~ ISO_DATETIME
+          microsec = ($7.to_r * 1_000_000).to_i
+          Time.utc $1.to_i, $2.to_i, $3.to_i, $4.to_i, $5.to_i, $6.to_i, microsec
+        else
+          STDERR.puts "unexpected date time format #{string}"
+          string
+        end
+      end
+    end
+
   end
 end

data/lib/mini_sql/connection.rb

@@ -16,6 +16,16 @@ module MiniSql
           map.add_coder(MiniSql::Coders::IPAddrCoder.new(name: "inet", oid: 869, format: 0))
           map.add_coder(MiniSql::Coders::IPAddrCoder.new(name: "cidr", oid: 650, format: 0))
           map.add_coder(PG::TextDecoder::String.new(name: "tsvector", oid: 3614, format: 0))
+
+          map.rm_coder(0, 1114)
+          if defined? PG::TextDecoder::TimestampUtc
+            # treat timestamp without zone as utc
+            # new to PG 1.1
+            map.add_coder(PG::TextDecoder::TimestampUtc.new(name: "timestamp", oid: 1114, format: 0))
+          else
+            map.add_coder(MiniSql::Coders::TimestampUtc.new(name: "timestamp", oid: 1114, format: 0))
+          end
+          map
         end
     end
 

data/lib/mini_sql/version.rb

@@ -1,3 +1,3 @@
 module MiniSql
-  VERSION = "0.1.9"
+  VERSION = "0.1.10"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mini_sql
 version: !ruby/object:Gem::Version
-  version: 0.1.9
+  version: 0.1.10
 platform: ruby
 authors:
 - Sam Saffron
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-06-20 00:00:00.000000000 Z
+date: 2018-06-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -123,6 +123,7 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- bench/timestamp_perf.rb
 - bench/topic_perf.rb
 - bin/console
 - bin/setup