mini_sql 1.0.1 → 1.1.0

data/bench/topic_wide_perf.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+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 'draper'
+  gem 'pry'
+end
+
+require 'sequel'
+require 'active_record'
+require 'memory_profiler'
+require 'benchmark/ips'
+require 'mini_sql'
+
+require '../mini_sql/bench/shared/generate_data'
+
+ar_connection, conn_config = GenerateData.new(count_records: 1_000).call
+PG_CONN = ar_connection.raw_connection
+MINI_SQL = MiniSql::Connection.get(PG_CONN)
+DB = Sequel.connect(ar_connection.instance_variable_get(:@config).slice(:database, :user, :password, :host, :adapter))
+
+class Topic < ActiveRecord::Base
+end
+
+class TopicSequel < Sequel::Model(:topics)
+end
+
+def wide_topic_ar
+  Topic.first
+end
+
+def wide_topic_pg
+  r = PG_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
+  PG_CONN.query("select * from topics limit 1").first
+end
+
+Benchmark.ips do |r|
+  r.report("wide topic ar") do |n|
+    while n > 0
+      wide_topic_ar
+      n -= 1
+    end
+  end
+  r.report("wide topic sequel") do |n|
+    while n > 0
+      wide_topic_sequel
+      n -= 1
+    end
+  end
+  r.report("wide topic pg") do |n|
+    while n > 0
+      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
+  r.compare!
+end
+
+
+#
+# Comparison:
+#        wide topic pg:     6974.6 i/s
+#  wide topic mini sql:     6760.9 i/s - same-ish: difference falls within error
+#    wide topic sequel:     5050.5 i/s - 1.38x  (± 0.00) slower
+#        wide topic ar:     1565.4 i/s - 4.46x  (± 0.00) slower

data/lib/mini_sql.rb

@@ -15,24 +15,33 @@ require_relative "mini_sql/result"
 module MiniSql
   if RUBY_ENGINE == 'jruby'
     module Postgres
-      autoload :Connection, "mini_sql/postgres_jdbc/connection"
+      autoload :Connection,        "mini_sql/postgres_jdbc/connection"
       autoload :DeserializerCache, "mini_sql/postgres_jdbc/deserializer_cache"
     end
   else
     module Postgres
-      autoload :Coders, "mini_sql/postgres/coders"
-      autoload :Connection, "mini_sql/postgres/connection"
-      autoload :DeserializerCache, "mini_sql/postgres/deserializer_cache"
+      autoload :Coders,             "mini_sql/postgres/coders"
+      autoload :Connection,         "mini_sql/postgres/connection"
+      autoload :DeserializerCache,  "mini_sql/postgres/deserializer_cache"
+      autoload :PreparedConnection, "mini_sql/postgres/prepared_connection"
+      autoload :PreparedCache,      "mini_sql/postgres/prepared_cache"
+      autoload :PreparedBinds,      "mini_sql/postgres/prepared_binds"
     end
 
     module Sqlite
-      autoload :Connection, "mini_sql/sqlite/connection"
-      autoload :DeserializerCache, "mini_sql/sqlite/deserializer_cache"
+      autoload :Connection,         "mini_sql/sqlite/connection"
+      autoload :DeserializerCache,  "mini_sql/sqlite/deserializer_cache"
+      autoload :PreparedCache,      "mini_sql/sqlite/prepared_cache"
+      autoload :PreparedBinds,      "mini_sql/sqlite/prepared_binds"
+      autoload :PreparedConnection, "mini_sql/sqlite/prepared_connection"
     end
 
     module Mysql
-      autoload :Connection, "mini_sql/mysql/connection"
-      autoload :DeserializerCache, "mini_sql/mysql/deserializer_cache"
+      autoload :Connection,         "mini_sql/mysql/connection"
+      autoload :DeserializerCache,  "mini_sql/mysql/deserializer_cache"
+      autoload :PreparedCache,      "mini_sql/mysql/prepared_cache"
+      autoload :PreparedBinds,      "mini_sql/mysql/prepared_binds"
+      autoload :PreparedConnection, "mini_sql/mysql/prepared_connection"
     end
   end
 end

data/lib/mini_sql/abstract/prepared_binds.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module MiniSql
+  module Abstract
+    class PreparedBinds
+
+      # For compatibility with Active Record
+      BindName = Struct.new(:name)
+
+      def bind(sql, *params)
+        if Hash === (hash = params[0])
+          bind_hash(sql, hash)
+        else
+          bind_array(sql, params)
+        end
+      end
+
+      def bind_hash(sql, hash)
+        sql = sql.dup
+        binds = []
+        bind_names = []
+        i = 0
+
+        hash.each do |k, v|
+          sql.gsub!(":#{k}") do
+            # ignore ::int and stuff like that
+            # $` is previous to match
+            if $` && $`[-1] != ":"
+              array_wrap(v).map do |vv|
+                binds << vv
+                bind_names << [BindName.new(k)]
+                bind_output(i += 1)
+              end.join(', ')
+            else
+              ":#{k}"
+            end
+          end
+        end
+        [sql, binds, bind_names]
+      end
+
+      def bind_array(sql, array)
+        sql = sql.dup
+        param_i = 0
+        i = 0
+        binds = []
+        bind_names = []
+        sql.gsub!("?") do
+          param_i += 1
+          array_wrap(array[param_i - 1]).map do |vv|
+            binds << vv
+            i += 1
+            bind_names << [BindName.new("$#{i}")]
+            bind_output(i)
+          end.join(', ')
+        end
+        [sql, binds, bind_names]
+      end
+
+      def array_wrap(object)
+        if object.respond_to?(:to_ary)
+          object.to_ary || [object]
+        else
+          [object]
+        end
+      end
+
+      def bind_output(_)
+        raise NotImplementedError, "must be implemented by specific database driver"
+      end
+
+    end
+  end
+end

data/lib/mini_sql/abstract/prepared_cache.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module MiniSql
+  module Abstract
+    class PreparedCache
+
+      DEFAULT_MAX_SIZE = 500
+
+      def initialize(connection, max_size = nil)
+        @connection = connection
+        @max_size = max_size || DEFAULT_MAX_SIZE
+        @cache = {}
+        @counter = 0
+      end
+
+      def prepare_statement(sql)
+        stm_key = "#{@connection.object_id}-#{sql}"
+        statement = @cache.delete(stm_key)
+        if statement
+          @cache[stm_key] = statement
+        else
+          statement = @cache[stm_key] = alloc(sql)
+          dealloc(@cache.shift.last) if @cache.length > @max_size
+        end
+
+        statement
+      end
+
+      private
+
+      def next_key
+        "s#{@counter += 1}"
+      end
+
+      def alloc(_)
+        raise NotImplementedError, "must be implemented by specific database driver"
+      end
+
+      def dealloc(_)
+        raise NotImplementedError, "must be implemented by specific database driver"
+      end
+
+    end
+  end
+end

data/lib/mini_sql/builder.rb

@@ -3,27 +3,71 @@
 class MiniSql::Builder
 
   def initialize(connection, template)
-    @args = nil
+    @args = {}
     @sql = template
     @sections = {}
     @connection = connection
+    @count_variables = 1
+    @is_prepared = false
   end
 
-  [:set, :where2, :where, :order_by, :limit, :left_join, :join, :offset, :select].each do |k|
-    define_method k do |data, *args|
-      if args && (args.length == 1) && (Hash === args[0])
-        @args ||= {}
+  [:set, :where2, :where, :order_by, :left_join, :join, :select, :group_by].each do |k|
+    define_method k do |sql_part, *args|
+      if Hash === args[0]
         @args.merge!(args[0])
-      elsif args && args.length > 0
-        data = @connection.param_encoder.encode(data, *args)
+      else # convert simple params to hash
+        args.each do |v|
+          param = "_m_#{@count_variables += 1}"
+          sql_part = sql_part.sub('?', ":#{param}")
+          @args[param] = v
+        end
       end
+
       @sections[k] ||= []
-      @sections[k] << data
+      @sections[k] << sql_part
       self
     end
   end
 
-  def to_sql
+  [:limit, :offset].each do |k|
+    define_method k do |value|
+      @args["_m_#{k}"] = value
+      @sections[k] = true
+      self
+    end
+  end
+
+  [:query, :query_single, :query_hash, :query_array, :exec].each do |m|
+    class_eval <<~RUBY
+      def #{m}(hash_args = nil)
+        connection_switcher.#{m}(parametrized_sql, union_parameters(hash_args))
+      end
+    RUBY
+  end
+
+  def query_decorator(decorator, hash_args = nil)
+    connection_switcher.query_decorator(decorator, parametrized_sql, union_parameters(hash_args))
+  end
+
+  def prepared(condition = true)
+    @is_prepared = condition
+
+    self
+  end
+
+  def to_sql(hash_args = nil)
+    @connection.param_encoder.encode(parametrized_sql, union_parameters(hash_args))
+  end
+
+  private def connection_switcher
+    if @is_prepared
+      @connection.prepared
+    else
+      @connection
+    end
+  end
+
+  private def parametrized_sql
     sql = @sql.dup
 
     @sections.each do |k, v|
@@ -38,41 +82,28 @@ class MiniSql::Builder
       when :left_join
         joined = v.map { |item| (+"LEFT JOIN ") << item }.join("\n")
       when :limit
-        joined = (+"LIMIT ") << v.last.to_i.to_s
+        joined = (+"LIMIT :_m_limit")
       when :offset
-        joined = (+"OFFSET ") << v.last.to_i.to_s
+        joined = (+"OFFSET :_m_offset")
       when :order_by
         joined = (+"ORDER BY ") << v.join(" , ")
+      when :group_by
+        joined = (+"GROUP BY ") << v.join(" , ")
       when :set
         joined = (+"SET ") << v.join(" , ")
       end
 
       sql.sub!("/*#{k}*/", joined)
     end
-    sql
-  end
 
-  [:query, :query_single, :query_hash, :exec].each do |m|
-    class_eval <<~RUBY
-      def #{m}(hash_args = nil)
-        hash_args = @args.merge(hash_args) if hash_args && @args
-        hash_args ||= @args
-        if hash_args
-          @connection.#{m}(to_sql, hash_args)
-        else
-          @connection.#{m}(to_sql)
-        end
-      end
-    RUBY
+    sql
   end
 
-  def query_decorator(decorator, hash_args = nil)
-    hash_args = @args.merge(hash_args) if hash_args && @args
-    hash_args ||= @args
+  private def union_parameters(hash_args)
     if hash_args
-      @connection.query_decorator(decorator, to_sql, hash_args)
+      @args.merge(hash_args)
     else
-      @connection.query_decorator(decorator, to_sql)
+      @args
     end
   end
 

data/lib/mini_sql/inline_param_encoder.rb

@@ -36,13 +36,13 @@ module MiniSql
 
     def encode_array(sql, array)
       i = -1
-      sql.gsub("?") do |p|
+      sql.gsub("?") do
         i += 1
         quote_val(array[i])
       end
     end
 
-    def quoted_date(value)
+    def quoted_time(value)
       value.utc.iso8601
     end
 
@@ -51,7 +51,8 @@ module MiniSql
       when String     then "'#{conn.escape_string(value.to_s)}'"
       when Numeric    then value.to_s
       when BigDecimal then value.to_s("F")
-      when Date, Time then "'#{quoted_date(value)}'"
+      when Time       then "'#{quoted_time(value)}'"
+      when Date       then "'#{value.to_s}'"
       when Symbol     then "'#{conn.escape_string(value.to_s)}'"
       when true       then "true"
       when false      then "false"

data/lib/mini_sql/mysql/connection.rb

@@ -9,6 +9,12 @@ module MiniSql
         @raw_connection = raw_connection
         @param_encoder = (args && args[:param_encoder]) || InlineParamEncoder.new(self)
         @deserializer_cache = (args && args[:deserializer_cache]) || DeserializerCache.new
+
+        @prepared = PreparedConnection.new(self, @deserializer_cache)
+      end
+
+      def prepared(condition = true)
+        condition ? @prepared : self
       end
 
       def query_single(sql, *params)

data/lib/mini_sql/mysql/deserializer_cache.rb

@@ -12,14 +12,14 @@ module MiniSql
       end
 
       def materialize(result, decorator_module = nil)
-        key = result.fields
+        key = result.fields.join(',')
 
         # trivial fast LRU implementation
         materializer = @cache.delete(key)
         if materializer
           @cache[key] = materializer
         else
-          materializer = @cache[key] = new_row_matrializer(result)
+          materializer = @cache[key] = new_row_materializer(result)
           @cache.shift if @cache.length > @max_size
         end
 
@@ -34,7 +34,7 @@ module MiniSql
 
       private
 
-      def new_row_matrializer(result)
+      def new_row_materializer(result)
         fields = result.fields
 
         Class.new do