mini_sql 0.1.10 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c66544eb3a8d9b5067dc3ba1fb1df6a542e4adeabc2f4b08d4392fab7955b382
-  data.tar.gz: c3701417f3667ae360470d24a2bdd60b002350a1690a28cb1e9c95b0040d9c96
+  metadata.gz: 8b9e4f7f96a77f3eaead87f509583b9bf604d49eec6e3caaf8a0234646eb208a
+  data.tar.gz: 94cac1f8ef8a82860686b1001761ef1b06a8be5228299427dc41d6be92d5a1c5
 SHA512:
-  metadata.gz: d8b474bc10bd5570a2b4932f5182e97ad5c242885d2e3e68e8fa5246d21bf908b57044daf107b1968cf4895cb0e32af1af05f649c6049cd0747ddd43d2647836
-  data.tar.gz: 9c98da1a59f650541955b435f34fdbc3d4ed2ee7245d254d6d7decf9edbb25c8436b98a0dd0f3f4017e2f003ee51ae5f8f38e294c74f826be160d661bd361bac
+  metadata.gz: 04a54bb044404c6ed17bd425b0f7779afa130002850592ad1e91a249504c0b4b46e17453a59dab0e5e816a131669079742ca1baaae013259917bfec6dedab83f
+  data.tar.gz: fd4ceaf5f7e46efb8e5b067a54304c5a5eaa5d4216ff4c405bb64688b57b7844d7106dc3568e059b912994b193e197b83f9e81bfb1d5e91611b8c3ce5b65033f

data/CHANGELOG

@@ -0,0 +1,3 @@
+2019-02-25 - 0.2.1
+
+- Handle `BigDecimal.new` deprecation by using `BigDecimal()` instead

data/Guardfile

@@ -2,4 +2,5 @@ guard :minitest do
   watch(%r{^test/(.*)_test\.rb$})
   watch(%r{^lib/(.*/)?([^/]+)\.rb$})     { |m| "test/#{m[1]}#{m[2]}_test.rb" }
   watch(%r{^test/test_helper\.rb$})      { 'test' }
+  watch("test/mini_sql/builder_tests.rb") { ['test/mini_sql/postgres/builder_test.rb', 'test/mini_sql/sqlite/builder_test.rb'] }
 end

data/README.md

@@ -18,11 +18,11 @@ Or install it yourself as:
 
 ## Usage
 
-MiniSql is a very simple, safe and fast SQL executor and mapper for PG.
+MiniSql is a very simple, safe and fast SQL executor and mapper for PG and Sqlite.
 
 ```ruby
 pg_conn = PG.connect(db_name: 'my_db')
-conn = MiniSql::Connection.new(pg_conn)
+conn = MiniSql::Connection.get(pg_conn)
 
 puts conn.exec('update table set column = 1 where id in (1,2)')
 # returns 2 if 2 rows changed
@@ -79,7 +79,7 @@ end
 # ideally you want to remember to run r.clear here
 
 # this is faster and safer
-conn = MiniSql::Connection.new(pg_conn)
+conn = MiniSql::Connection.get(pg_conn)
 r = conn.query('select * from table')
 
 r.each do |row|

data/bench/timestamp_perf.rb

@@ -11,7 +11,7 @@ gemfile do
   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'
+  # gem 'swift-db-postgres', github: 'deepfryed/swift-db-postgres'
 end
 
 require 'sequel'
@@ -74,8 +74,8 @@ $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
+    s << time1.to_f.to_s
+    s << time2.to_f.to_s
   end
   s
 end
@@ -83,33 +83,57 @@ 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
+    s << t.time1.to_f.to_s
+    s << t.time2.to_f.to_s
   end
   s
 end
 
 $mini_sql = MiniSql::Connection.new($conn)
 
-def pg_times(l=1000)
+def pg_times_params(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
+
+  i = 0
+  a = r.values
+  n = a.length
+
+  while i < n
+    s << a[i][0].to_f.to_s
+    s << a[i][1].to_f.to_s
+    i += 1
   end
   r.clear
   s
 end
 
+def pg_times(l=1000)
+  s = +""
+  # use the safe pattern here
+  r = $conn.async_exec("select time1, time2 from timestamps order by id limit #{l}")
+  r.type_map = $mini_sql.type_map
+
+  i = 0
+  a = r.values
+  n = a.length
+
+  while i < n
+    s << a[i][0].to_f.to_s
+    s << a[i][1].to_f.to_s
+    i += 1
+  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
+    s << t.time1.to_f.to_s
+    s << t.time2.to_f.to_s
   end
   s
 end
@@ -117,8 +141,8 @@ 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
+    s << t.time1.to_f.to_s
+    s << t.time2.to_f.to_s
   end
   s
 end
@@ -126,8 +150,17 @@ 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
+    s << t[0].to_f.to_s
+    s << t[1].to_f.to_s
+  end
+  s
+end
+
+def sequel_raw_times(l=1000)
+  s = +""
+  DB[-"select time1, time2 from timestamps order by id limit ?", l].map([:time1, :time2]).each do |time1, time2|
+    s << time1.to_f.to_s
+    s << time2.to_f.to_s
   end
   s
 end
@@ -138,58 +171,65 @@ def mini_sql_times_single(l=1000)
   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
+    s << r[i].to_f.to_s
+    s << r[i+1].to_f.to_s
     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
+# $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].to_f.to_s
+#     s << row[:time2].to_f.to_s
+#   end
+#   s
+# end
 
 
 results = [
   ar_select_times,
   ar_pluck_times,
   pg_times,
+  pg_times_params,
   mini_sql_times,
   mini_sql_times_single,
   sequel_times,
   sequel_pluck_times,
+  sequel_raw_times,
+  # can not compare correctly as it is returning DateTime not Time
+  # swift_select_times.gsub("+00:00", "Z")
 ]
 
 exit(-1) unless results.uniq.length == 1
 
 Benchmark.ips do |r|
-  r.report("ar select times") do |n|
+  r.warmup = 10
+  r.time = 5
+
+  r.report("mini_sql query_single times") do |n|
     while n > 0
-      ar_select_times
+      mini_sql_times_single
       n -= 1
     end
   end
-  r.report("ar pluck times") do |n|
+  r.report("sequel times") do |n|
     while n > 0
-      ar_pluck_times
+      sequel_times
       n -= 1
     end
   end
-  r.report("sequel times") do |n|
+  r.report("pg times async_exec values") do |n|
     while n > 0
-      sequel_times
+      pg_times_params
       n -= 1
     end
   end
-  r.report("pg times") do |n|
+  r.report("pg times async_exec_params values") do |n|
     while n > 0
       pg_times
       n -= 1
@@ -207,43 +247,40 @@ Benchmark.ips do |r|
       n -= 1
     end
   end
-  r.report("mini_sql query_single times") do |n|
+  r.report("sequel raw times") do |n|
     while n > 0
-      mini_sql_times_single
+      sequel_raw_times
       n -= 1
     end
   end
-  r.report("swift_select_times") do |n|
+  r.report("ar select times") do |n|
     while n > 0
-      swift_select_times
+      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.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
+# Linux x64 numbers
 #
-# 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
+# pg times async_exec values:      441.6 i/s
+# pg times async_exec_params values:      438.5 i/s - same-ish: difference falls within error
+# mini_sql query_single times:      436.3 i/s - same-ish: difference falls within error
+#     sequel raw times:      426.1 i/s - same-ish: difference falls within error
+#       mini sql times:      417.1 i/s - 1.06x  slower
+#   sequel pluck times:      414.0 i/s - 1.07x  slower
+#         sequel times:      378.5 i/s - 1.17x  slower
+#       ar pluck times:       30.8 i/s - 14.35x  slower
+#      ar select times:       22.7 i/s - 19.44x  slower
 #
-# swift has a super fast implementation, still need to determine
-# why pg is so far behind
+
+# NOTE PG version 1.0.0 has a much slower time materializer
+# NOTE 2: on Mac numbers are far closer Time parsing on mac is slow

data/bench/topic_perf.rb

@@ -2,15 +2,16 @@ require 'bundler/inline'
 
 gemfile do
   source 'https://rubygems.org'
-  gem 'pg'
+  gem 'pg', github: 'ged/ruby-pg'
   gem 'mini_sql', path: '../'
   gem 'activesupport'
   gem 'activerecord'
   gem 'activemodel'
   gem 'memory_profiler'
   gem 'benchmark-ips'
-  gem 'sequel'
-  gem 'sequel_pg', require: 'sequel'
+  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'
@@ -131,9 +132,17 @@ def pg_title_id
   s = +""
   # use the safe pattern here
   r = $conn.async_exec(-"select id, title from topics order by id limit 1000")
-  r.each do |row|
-    s << row["id"].to_s
-    s << row["title"]
+
+  # this seems fastest despite extra arrays, cause array of arrays is generated
+  # in c code
+  values = r.values
+
+  i = 0
+  l = values.length
+  while i < l
+    s << values[i][0].to_s
+    s << values[i][1]
+    i += 1
   end
   r.clear
   s
@@ -181,6 +190,21 @@ def mini_sql_title_id_query_single
   s
 end
 
+# connects over unix socket
+$swift = Swift::DB::Postgres.new(db: "test_db")
+
+def swift_select_title_id(l=1000)
+  s = ""
+  i = 0
+  r = $swift.execute("select id, title from topics order by id limit 1000")
+  while i < r.selected_rows
+    s << r.get(i, 0).to_s
+    s << r.get(i, 1)
+    i += 1
+  end
+  s
+end
+
 results = [
   ar_title_id,
   ar_title_id_pluck,
@@ -188,101 +212,108 @@ results = [
   mini_sql_title_id,
   sequel_pluck_title_id,
   sequel_select_title_id,
-  mini_sql_title_id_query_single
+  mini_sql_title_id_query_single,
+  swift_select_title_id
 ]
 
 exit(-1) unless results.uniq.length == 1
 
 
-def wide_topic_ar
-  Topic.first
-end
-
-def wide_topic_pg
-  r = $conn.async_exec("select * from topics limit 1")
-  row = r.first
-  r.clear
-  row
-end
-
-def wide_topic_sequel
-  TopicSequel.first
-end
-
-def wide_topic_mini_sql
-  $conn.query("select * from topics limit 1").first
-end
-
 Benchmark.ips do |r|
-  r.report("wide topic ar") do |n|
+  r.report("ar select title id") do |n|
     while n > 0
-      wide_topic_ar
+      ar_title_id
       n -= 1
     end
   end
-  r.report("wide topic sequel") do |n|
+  r.report("ar select title id pluck") do |n|
     while n > 0
-      wide_topic_sequel
+      ar_title_id_pluck
       n -= 1
     end
   end
-  r.report("wide topic pg") do |n|
+  r.report("sequel title id select") do |n|
     while n > 0
-      wide_topic_pg
+      sequel_select_title_id
       n -= 1
     end
   end
-  r.report("wide topic mini sql") do |n|
+  r.report("pg select title id") do |n|
     while n > 0
-      wide_topic_mini_sql
+      pg_title_id
       n -= 1
     end
   end
-  r.compare!
-end
-
-
-
-Benchmark.ips do |r|
-  r.report("ar select title id") do |n|
+  r.report("mini_sql select title id") do |n|
     while n > 0
-      ar_title_id
+      mini_sql_title_id
       n -= 1
     end
   end
-  r.report("ar select title id pluck") do |n|
+  r.report("sequel title id pluck") do |n|
     while n > 0
-      ar_title_id_pluck
+      sequel_pluck_title_id
       n -= 1
     end
   end
-  r.report("sequel title id select") do |n|
+  r.report("mini_sql query_single title id") do |n|
     while n > 0
-      sequel_select_title_id
+      mini_sql_title_id_query_single
       n -= 1
     end
   end
-  r.report("pg select title id") do |n|
+  r.report("swift title id") do |n|
     while n > 0
-      pg_title_id
+      swift_select_title_id
       n -= 1
     end
   end
-  r.report("mini_sql select title id") do |n|
+  r.compare!
+end
+
+
+
+def wide_topic_ar
+  Topic.first
+end
+
+def wide_topic_pg
+  r = $conn.async_exec("select * from topics limit 1")
+  row = r.first
+  r.clear
+  row
+end
+
+def wide_topic_sequel
+  TopicSequel.first
+end
+
+def wide_topic_mini_sql
+  $conn.query("select * from topics limit 1").first
+end
+
+Benchmark.ips do |r|
+  r.report("wide topic ar") do |n|
     while n > 0
-      mini_sql_title_id
+      wide_topic_ar
       n -= 1
     end
   end
-  r.report("sequel title id pluck") do |n|
+  r.report("wide topic sequel") do |n|
     while n > 0
-      sequel_pluck_title_id
+      wide_topic_sequel
       n -= 1
     end
   end
-  r.report("mini_sql query_single title id") do |n|
+  r.report("wide topic pg") do |n|
     while n > 0
-      mini_sql_title_id_query_single
+      wide_topic_pg
+      n -= 1
+    end
+  end
+  r.report("wide topic mini sql") do |n|
+    while n > 0
+      wide_topic_mini_sql
       n -= 1
     end
   end
@@ -290,41 +321,24 @@ Benchmark.ips do |r|
 end
 
 
-# Calculating -------------------------------------
-#        wide topic ar      2.383k (± 4.9%) i/s -     12.005k in   5.050490s
-#    wide topic sequel      3.449k (± 3.2%) i/s -     17.591k in   5.104951s
-#        wide topic pg      7.345k (± 1.2%) i/s -     37.352k in   5.086015s
-#  wide topic mini sql      7.536k (± 1.4%) i/s -     38.220k in   5.072834s
-#
 # Comparison:
-#  wide topic mini sql:     7535.8 i/s
-#        wide topic pg:     7345.1 i/s - same-ish: difference falls within error
-#    wide topic sequel:     3449.4 i/s - 2.18x  slower
-#        wide topic ar:     2382.9 i/s - 3.16x  slower
+#   pg select title id:     1519.7 i/s
+# mini_sql query_single title id:     1335.0 i/s - 1.14x  slower
+# sequel title id pluck:     1261.6 i/s - 1.20x  slower
+# mini_sql select title id:     1188.6 i/s - 1.28x  slower
+#       swift title id:     1077.5 i/s - 1.41x  slower
+# sequel title id select:      969.7 i/s - 1.57x  slower
+# ar select title id pluck:      738.7 i/s - 2.06x  slower
+#   ar select title id:      149.6 i/s - 10.16x  slower
 #
-# Calculating -------------------------------------
-#   ar select title id    131.572  (± 3.8%) i/s -    658.000  in   5.008231s
-# ar select title id pluck
-#                         696.233  (± 3.7%) i/s -      3.519k in   5.061335s
-# sequel title id select
-#                         916.841  (± 3.7%) i/s -      4.655k in   5.084499s
-#   pg select title id      1.002k (± 4.0%) i/s -      5.044k in   5.040584s
-# mini_sql select title id
-#                           1.106k (± 2.4%) i/s -      5.618k in   5.084423s
-# sequel title id pluck
-#                           1.181k (± 3.5%) i/s -      5.980k in   5.069815s
-# mini_sql query_single title id
-#                           1.171k (± 3.1%) i/s -      5.880k in   5.025793s
 #
 # Comparison:
-# sequel title id pluck:     1181.0 i/s
-# mini_sql query_single title id:     1171.1 i/s - same-ish: difference falls within error
-# mini_sql select title id:     1105.6 i/s - 1.07x  slower
-#   pg select title id:     1002.2 i/s - 1.18x  slower
-# sequel title id select:      916.8 i/s - 1.29x  slower
-# ar select title id pluck:      696.2 i/s - 1.70x  slower
-#   ar select title id:      131.6 i/s - 8.98x  slower
-#
+#        wide topic pg:     7474.0 i/s
+#  wide topic mini sql:     7355.2 i/s - same-ish: difference falls within error
+#    wide topic sequel:     5696.8 i/s - 1.31x  slower
+#        wide topic ar:     2515.0 i/s - 2.97x  slower
+
+
 
 # to run deep analysis run
 # MemoryProfiler.report do

data/lib/mini_sql.rb

@@ -10,5 +10,14 @@ require_relative "mini_sql/builder"
 require_relative "mini_sql/inline_param_encoder"
 
 module MiniSql
-  autoload :Coders, "mini_sql/coders"
+  module Postgres
+    autoload :Coders, "mini_sql/postgres/coders"
+    autoload :Connection, "mini_sql/postgres/connection"
+    autoload :DeserializerCache, "mini_sql/postgres/deserializer_cache"
+  end
+
+  module Sqlite
+    autoload :Connection, "mini_sql/sqlite/connection"
+    autoload :DeserializerCache, "mini_sql/sqlite/deserializer_cache"
+  end
 end

data/lib/mini_sql/connection.rb

@@ -2,47 +2,15 @@
 
 module MiniSql
   class Connection
-    attr_reader :raw_connection, :type_map, :param_encoder
 
-    def self.default_deserializer_cache
-      @deserializer_cache ||= DeserializerCache.new
-    end
-
-    def self.type_map(conn)
-      @type_map ||=
-        begin
-          map = PG::BasicTypeMapForResults.new(conn)
-          map.add_coder(MiniSql::Coders::NumericCoder.new(name: "numeric", oid: 1700, format: 0))
-          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
-
-    # Initialize a new MiniSql::Connection object
-    #
-    # @param raw_connection [PG::Connection] an active connection to PG
-    # @param deserializer_cache [MiniSql::DeserializerCache] a cache of field names to deserializer, can be nil
-    # @param type_map [PG::TypeMap] a type mapper for all results returned, can be nil
-    def initialize(raw_connection, deserializer_cache: nil, param_encoder: nil)
-      # TODO adapter to support other databases
-      @raw_connection = raw_connection
-      @deserializer_cache = deserializer_cache || Connection.default_deserializer_cache
-      @param_encoder = param_encoder || InlineParamEncoder.new(self)
-    end
-
-    def type_map
-      @type_map ||= self.class.type_map(raw_connection)
+    def self.get(raw_connection, options = {})
+      if (defined? ::PG::Connection) && (PG::Connection === raw_connection)
+        Postgres::Connection.new(raw_connection, options)
+      elsif (defined? ::SQLite3::Database) && (SQLite3::Database === raw_connection)
+        Sqlite::Connection.new(raw_connection, options)
+      else
+        raise ArgumentError, 'unknown connection type!'
+      end
     end
 
     # Returns a flat array containing all results.
@@ -52,49 +20,19 @@ module MiniSql
     # @param params [Array or Hash], params to apply to query
     # @return [Object] a flat array containing all results
     def query_single(sql, *params)
-      result = run(sql, params)
-      result.type_map = type_map
-      if result.nfields == 1
-        result.column_values(0)
-      else
-        array = []
-        f = 0
-        row = 0
-        while row < result.ntuples
-          while f < result.nfields
-            array << result.getvalue(row, f)
-            f += 1
-          end
-          f = 0
-          row += 1
-        end
-        array
-      end
-    ensure
-      result.clear if result
+      raise NotImplementedError, "must be implemented by child connection"
     end
 
     def query(sql, *params)
-      result = run(sql, params)
-      result.type_map = type_map
-      @deserializer_cache.materialize(result)
-    ensure
-      result.clear if result
+      raise NotImplementedError, "must be implemented by child connection"
     end
 
     def exec(sql, *params)
-      result = run(sql, params)
-      result.cmd_tuples
-    ensure
-      result.clear if result
+      raise NotImplementedError, "must be implemented by child connection"
     end
 
     def query_hash(sql, *params)
-      result = run(sql, params)
-      result.type_map = type_map
-      result.to_a
-    ensure
-      result.clear
+      raise NotImplementedError, "must be implemented by child connection"
     end
 
     def build(sql)
@@ -102,16 +40,7 @@ module MiniSql
     end
 
     def escape_string(str)
-      raw_connection.escape_string(str)
-    end
-
-    private
-
-    def run(sql, params)
-      if params && params.length > 0
-        sql = param_encoder.encode(sql, *params)
-      end
-      raw_connection.async_exec(sql)
+      raise NotImplementedError, "must be implemented by child connection"
     end
 
   end

data/lib/mini_sql/deserializer_cache.rb

@@ -1,65 +1,8 @@
 module MiniSql
   class DeserializerCache
-
-    DEFAULT_MAX_SIZE = 500
-
-    def initialize(max_size = nil)
-      @cache = {}
-      @max_size = max_size || DEFAULT_MAX_SIZE
-    end
-
+    # method takes a raw result and converts to proper objects
     def materialize(result)
-
-      return [] if result.ntuples == 0
-
-      key = result.fields
-
-      # trivial fast LRU implementation
-      materializer = @cache.delete(key)
-      if materializer
-        @cache[key] = materializer
-      else
-        materializer = @cache[key] = new_row_matrializer(result)
-        @cache.shift if @cache.length > @max_size
-      end
-
-      i = 0
-      r = []
-      # quicker loop
-      while i < result.ntuples
-        r << materializer.materialize(result, i)
-        i += 1
-      end
-      r
-    end
-
-    private
-
-    def new_row_matrializer(result)
-      fields = result.fields
-
-      Class.new do
-        attr_accessor(*fields)
-
-        # AM serializer support
-        alias :read_attribute_for_serialization :send
-
-        def to_h
-          r = {}
-          instance_variables.each do |f|
-            r[f.to_s.sub('@','').to_sym] = instance_variable_get(f)
-          end
-          r
-        end
-
-        instance_eval <<~RUBY
-          def materialize(pg_result, index)
-            r = self.new
-            #{col=-1; fields.map{|f| "r.#{f} = pg_result.getvalue(index, #{col+=1})"}.join("; ")}
-            r
-          end
-        RUBY
-      end
+      raise NotImplementedError, "must be implemented by child"
     end
   end
 end

data/lib/mini_sql/postgres/coders.rb

@@ -0,0 +1,32 @@
+module MiniSql
+  module Postgres
+    module Coders
+      class NumericCoder < PG::SimpleDecoder
+        def decode(string, tuple = nil, field = nil)
+          BigDecimal(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
+end

data/lib/mini_sql/postgres/connection.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module MiniSql
+  module Postgres
+    class Connection < MiniSql::Connection
+      attr_reader :raw_connection, :type_map, :param_encoder
+
+      def self.default_deserializer_cache
+        @deserializer_cache ||= DeserializerCache.new
+      end
+
+      def self.type_map(conn)
+        @type_map ||=
+          begin
+            map = PG::BasicTypeMapForResults.new(conn)
+            map.add_coder(MiniSql::Postgres::Coders::NumericCoder.new(name: "numeric", oid: 1700, format: 0))
+            map.add_coder(MiniSql::Postgres::Coders::IPAddrCoder.new(name: "inet", oid: 869, format: 0))
+            map.add_coder(MiniSql::Postgres::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::Postgres::Coders::TimestampUtc.new(name: "timestamp", oid: 1114, format: 0))
+            end
+            map
+          end
+      end
+
+      # Initialize a new MiniSql::Postgres::Connection object
+      #
+      # @param raw_connection [PG::Connection] an active connection to PG
+      # @param deserializer_cache [MiniSql::DeserializerCache] a cache of field names to deserializer, can be nil
+      # @param type_map [PG::TypeMap] a type mapper for all results returned, can be nil
+      def initialize(raw_connection, args = nil)
+        @raw_connection = raw_connection
+        @deserializer_cache = (args && args[:deserializer_cache]) || self.class.default_deserializer_cache
+        @param_encoder = (args && args[:param_encoder]) || InlineParamEncoder.new(self)
+      end
+
+      def type_map
+        @type_map ||= self.class.type_map(raw_connection)
+      end
+
+      # Returns a flat array containing all results.
+      # Note, if selecting multiple columns array will be flattened
+      #
+      # @param sql [String] the query to run
+      # @param params [Array or Hash], params to apply to query
+      # @return [Object] a flat array containing all results
+      def query_single(sql, *params)
+        result = run(sql, params)
+        result.type_map = type_map
+        if result.nfields == 1
+          result.column_values(0)
+        else
+          tuples = result.ntuples
+          fields = result.nfields
+
+          array = []
+          f = 0
+          row = 0
+
+          while row < tuples
+            while f < fields
+              array << result.getvalue(row, f)
+              f += 1
+            end
+            f = 0
+            row += 1
+          end
+          array
+        end
+      ensure
+        result.clear if result
+      end
+
+      def query(sql, *params)
+        result = run(sql, params)
+        result.type_map = type_map
+        @deserializer_cache.materialize(result)
+      ensure
+        result.clear if result
+      end
+
+      def exec(sql, *params)
+        result = run(sql, params)
+        result.cmd_tuples
+      ensure
+        result.clear if result
+      end
+
+      def query_hash(sql, *params)
+        result = run(sql, params)
+        result.type_map = type_map
+        result.to_a
+      ensure
+        result.clear if result
+      end
+
+      def build(sql)
+        Builder.new(self, sql)
+      end
+
+      def escape_string(str)
+        raw_connection.escape_string(str)
+      end
+
+      private
+
+      def run(sql, params)
+        if params && params.length > 0
+          sql = param_encoder.encode(sql, *params)
+        end
+        raw_connection.async_exec(sql)
+      end
+
+    end
+  end
+end

data/lib/mini_sql/postgres/deserializer_cache.rb

@@ -0,0 +1,67 @@
+module MiniSql
+  module Postgres
+    class DeserializerCache
+
+      DEFAULT_MAX_SIZE = 500
+
+      def initialize(max_size = nil)
+        @cache = {}
+        @max_size = max_size || DEFAULT_MAX_SIZE
+      end
+
+      def materialize(result)
+
+        return [] if result.ntuples == 0
+
+        key = result.fields
+
+        # trivial fast LRU implementation
+        materializer = @cache.delete(key)
+        if materializer
+          @cache[key] = materializer
+        else
+          materializer = @cache[key] = new_row_matrializer(result)
+          @cache.shift if @cache.length > @max_size
+        end
+
+        i = 0
+        r = []
+        # quicker loop
+        while i < result.ntuples
+          r << materializer.materialize(result, i)
+          i += 1
+        end
+        r
+      end
+
+      private
+
+      def new_row_matrializer(result)
+        fields = result.fields
+
+        Class.new do
+          attr_accessor(*fields)
+
+          # AM serializer support
+          alias :read_attribute_for_serialization :send
+
+          def to_h
+            r = {}
+            instance_variables.each do |f|
+              r[f.to_s.sub('@','').to_sym] = instance_variable_get(f)
+            end
+            r
+          end
+
+          instance_eval <<~RUBY
+            def materialize(pg_result, index)
+              r = self.new
+              #{col=-1; fields.map{|f| "r.#{f} = pg_result.getvalue(index, #{col+=1})"}.join("; ")}
+              r
+            end
+          RUBY
+        end
+      end
+    end
+  end
+end

data/lib/mini_sql/sqlite/connection.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module MiniSql
+  module Sqlite
+    class Connection < MiniSql::Connection
+      attr_reader :param_encoder, :raw_connection, :deserializer_cache
+
+      def initialize(raw_connection, args = nil)
+        @raw_connection = raw_connection
+        @param_encoder = (args && args[:param_encoder]) || InlineParamEncoder.new(self)
+        @deserializer_cache = (args && args[:deserializer_cache]) || DeserializerCache.new
+      end
+
+      def query_single(sql, *params)
+        # a bit lazy can be optimized
+        run(sql, *params).flatten!
+      end
+
+      def query_hash(sql, *params)
+        r = []
+        run(sql, *params) do |set|
+          set.each_hash do |h|
+            r << h
+          end
+        end
+        r
+      end
+
+      def exec(sql, *params)
+
+        start = raw_connection.total_changes
+
+        r = run(sql, *params)
+        # this is not safe for multithreading, also for DELETE from TABLE will return
+        # incorrect data
+        if r.length > 0
+          r.length
+        else
+          raw_connection.total_changes - start
+        end
+      end
+
+      def query(sql, *params)
+        run(sql, *params) do |set|
+          deserializer_cache.materialize(set)
+        end
+      end
+
+      def escape_string(str)
+        str.gsub("'","''")
+      end
+
+      private
+
+      def run(sql, *params)
+        if params && params.length > 0
+          sql = param_encoder.encode(sql, *params)
+        end
+        if block_given?
+          stmt = SQLite3::Statement.new(raw_connection, sql)
+          yield stmt.execute
+        else
+          raw_connection.execute(sql)
+        end
+      end
+    end
+  end
+end

data/lib/mini_sql/sqlite/deserializer_cache.rb

@@ -0,0 +1,66 @@
+module MiniSql
+  module Sqlite
+    class DeserializerCache
+
+      DEFAULT_MAX_SIZE = 500
+
+      def initialize(max_size = nil)
+        @cache = {}
+        @max_size = max_size || DEFAULT_MAX_SIZE
+      end
+
+      def materialize(result)
+
+        key = result.columns
+
+        # trivial fast LRU implementation
+        materializer = @cache.delete(key)
+        if materializer
+          @cache[key] = materializer
+        else
+          materializer = @cache[key] = new_row_matrializer(result)
+          @cache.shift if @cache.length > @max_size
+        end
+
+        r = []
+        # quicker loop
+        while !result.eof?
+          data = result.next
+          if data
+            r << materializer.materialize(data)
+          end
+        end
+        r
+      end
+
+      private
+
+      def new_row_matrializer(result)
+        fields = result.columns
+
+        Class.new do
+          attr_accessor(*fields)
+
+          # AM serializer support
+          alias :read_attribute_for_serialization :send
+
+          def to_h
+            r = {}
+            instance_variables.each do |f|
+              r[f.to_s.sub('@','').to_sym] = instance_variable_get(f)
+            end
+            r
+          end
+
+          instance_eval <<~RUBY
+            def materialize(data)
+              r = self.new
+              #{col=-1; fields.map{|f| "r.#{f} = data[#{col+=1}]"}.join("; ")}
+              r
+            end
+          RUBY
+        end
+      end
+    end
+  end
+end

data/lib/mini_sql/version.rb

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

data/mini_sql.gemspec

@@ -22,11 +22,12 @@ Gem::Specification.new do |spec|
   end
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency "bundler", "~> 1.16"
+  spec.add_development_dependency "bundler", "> 1.16"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "minitest", "~> 5.0"
-  spec.add_development_dependency "pg", "~> 1.0.0"
+  spec.add_development_dependency "pg", "> 1"
   spec.add_development_dependency "guard", "~> 2.14"
   spec.add_development_dependency "guard-minitest", "~> 2.4"
   spec.add_development_dependency "activesupport", "~> 5.2"
+  spec.add_development_dependency "sqlite3", "~> 1.3"
 end

metadata

@@ -1,27 +1,27 @@
 --- !ruby/object:Gem::Specification
 name: mini_sql
 version: !ruby/object:Gem::Version
-  version: 0.1.10
+  version: 0.2.1
 platform: ruby
 authors:
 - Sam Saffron
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-06-24 00:00:00.000000000 Z
+date: 2019-02-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">"
       - !ruby/object:Gem::Version
         version: '1.16'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">"
       - !ruby/object:Gem::Version
         version: '1.16'
 - !ruby/object:Gem::Dependency
@@ -56,16 +56,16 @@ dependencies:
   name: pg
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">"
       - !ruby/object:Gem::Version
-        version: 1.0.0
+        version: '1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">"
       - !ruby/object:Gem::Version
-        version: 1.0.0
+        version: '1'
 - !ruby/object:Gem::Dependency
   name: guard
   requirement: !ruby/object:Gem::Requirement
@@ -108,6 +108,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '5.2'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
 description: A fast, safe, simple direct SQL executor for PG
 email:
 - sam.saffron@gmail.com
@@ -117,6 +131,7 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".travis.yml"
+- CHANGELOG
 - CODE_OF_CONDUCT.md
 - Gemfile
 - Guardfile
@@ -129,10 +144,14 @@ files:
 - bin/setup
 - lib/mini_sql.rb
 - lib/mini_sql/builder.rb
-- lib/mini_sql/coders.rb
 - lib/mini_sql/connection.rb
 - lib/mini_sql/deserializer_cache.rb
 - lib/mini_sql/inline_param_encoder.rb
+- lib/mini_sql/postgres/coders.rb
+- lib/mini_sql/postgres/connection.rb
+- lib/mini_sql/postgres/deserializer_cache.rb
+- lib/mini_sql/sqlite/connection.rb
+- lib/mini_sql/sqlite/deserializer_cache.rb
 - lib/mini_sql/version.rb
 - mini_sql.gemspec
 homepage: https://discourse.org
@@ -154,8 +173,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 3.0.1
 signing_key: 
 specification_version: 4
 summary: A fast, safe, simple direct SQL executor

data/lib/mini_sql/coders.rb

@@ -1,31 +0,0 @@
-module MiniSql
-  module Coders
-    class NumericCoder < PG::SimpleDecoder
-      def decode(string, tuple = nil, field = nil)
-        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