mini_sql 0.2.4 → 1.1.0

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
+
+  [:limit, :offset].each do |k|
+    define_method k do |value|
+      @args["_m_#{k}"] = value
+      @sections[k] = true
       self
     end
   end
 
-  def to_sql
+  [: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,33 +82,29 @@ 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
+  private def union_parameters(hash_args)
+    if hash_args
+      @args.merge(hash_args)
+    else
+      @args
+    end
   end
 
 end
-

data/lib/mini_sql/connection.rb

@@ -4,7 +4,7 @@ module MiniSql
   class Connection
 
     def self.get(raw_connection, options = {})
-      if (defined? ::PG::Connection) && (PG::Connection === raw_connection) 
+      if (defined? ::PG::Connection) && (PG::Connection === raw_connection)
         Postgres::Connection.new(raw_connection, options)
       elsif (defined? ::ArJdbc)
         Postgres::Connection.new(raw_connection, options)
@@ -31,11 +31,23 @@ module MiniSql
       raise NotImplementedError, "must be implemented by child connection"
     end
 
-    def exec(sql, *params)
+    def query_hash(sql, *params)
       raise NotImplementedError, "must be implemented by child connection"
     end
 
-    def query_hash(sql, *params)
+    def query_decorator(sql, *params)
+      raise NotImplementedError, "must be implemented by child connection"
+    end
+
+    def query_each(sql, *params)
+      raise NotImplementedError, "must be implemented by child connection"
+    end
+
+    def query_each_hash(sql, *params)
+      raise NotImplementedError, "must be implemented by child connection"
+    end
+
+    def exec(sql, *params)
       raise NotImplementedError, "must be implemented by child connection"
     end
 

data/lib/mini_sql/decoratable.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module MiniSql
+  module Decoratable
+    def decorated(mod)
+      @decoratorated_classes ||= {}
+      @decoratorated_classes[mod] ||=
+        Class.new(self) do
+          include(mod)
+          instance_eval <<~RUBY
+            def decorator
+              #{mod}
+            end
+          RUBY
+        end
+    end
+
+    def decorator
+      nil
+    end
+  end
+end

data/lib/mini_sql/deserializer_cache.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module MiniSql
   class DeserializerCache
     # method takes a raw result and converts to proper objects

data/lib/mini_sql/inline_param_encoder.rb

@@ -9,8 +9,6 @@ module MiniSql
     end
 
     def encode(sql, *params)
-      return sql unless params && params.length > 0
-
       if Hash === (hash = params[0])
         raise ArgumentError, "Only one hash param is allowed, multiple were sent" if params.length > 1
         encode_hash(sql, hash)
@@ -38,31 +36,32 @@ 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
 
     def quote_val(value)
       case value
+      when String     then "'#{conn.escape_string(value.to_s)}'"
+      when Numeric    then value.to_s
+      when BigDecimal then value.to_s("F")
+      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"
+      when nil        then "NULL"
+      when []         then "NULL"
       when Array
         value.map do |v|
           quote_val(v)
         end.join(', ')
-      when String
-        "'#{conn.escape_string(value.to_s)}'"
-      when true       then "true"
-      when false      then "false"
-      when nil        then "NULL"
-      when BigDecimal then value.to_s("F")
-      when Numeric then value.to_s
-      when Date, Time then "'#{quoted_date(value)}'"
-      when Symbol     then "'#{conn.escape_string(value.to_s)}'"
       else raise TypeError, "can't quote #{value.class.name}"
       end
     end

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)
@@ -20,6 +26,10 @@ module MiniSql
         result.to_a
       end
 
+      def query_array(sql, *params)
+        run(sql, :array, params).to_a
+      end
+
       def exec(sql, *params)
         run(sql, :array, params)
         raw_connection.affected_rows
@@ -30,6 +40,11 @@ module MiniSql
         @deserializer_cache.materialize(result)
       end
 
+      def query_decorator(decorator, sql, *params)
+        result = run(sql, :array, params)
+        @deserializer_cache.materialize(result, decorator)
+      end
+
       def escape_string(str)
         raw_connection.escape(str)
       end
@@ -45,9 +60,9 @@ module MiniSql
           sql = param_encoder.encode(sql, *params)
         end
         raw_connection.query(
-          sql, 
-          as: as, 
-          database_timezone: :utc, 
+          sql,
+          as: as,
+          database_timezone: :utc,
           application_timezone: :utc,
           cast_booleans: true,
           cast: true,

data/lib/mini_sql/mysql/deserializer_cache.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module MiniSql
   module Mysql
     class DeserializerCache
@@ -9,18 +11,22 @@ module MiniSql
         @max_size = max_size || DEFAULT_MAX_SIZE
       end
 
-      def materialize(result)
-        key = result.fields
+      def materialize(result, decorator_module = nil)
+        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
 
+        if decorator_module
+          materializer = materializer.decorated(decorator_module)
+        end
+
         result.map do |data|
           materializer.materialize(data)
         end
@@ -28,27 +34,19 @@ module MiniSql
 
       private
 
-      def new_row_matrializer(result)
+      def new_row_materializer(result)
         fields = result.fields
 
         Class.new do
-          attr_accessor(*fields)
+          extend MiniSql::Decoratable
+          include MiniSql::Result
 
-          # 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
+          attr_accessor(*fields)
 
           instance_eval <<~RUBY
             def materialize(data)
               r = self.new
-              #{col=-1; fields.map{|f| "r.#{f} = data[#{col+=1}]"}.join("; ")}
+              #{col = -1; fields.map { |f| "r.#{f} = data[#{col += 1}]" }.join("; ")}
               r
             end
           RUBY

data/lib/mini_sql/mysql/prepared_binds.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "mini_sql/abstract/prepared_binds"
+
+module MiniSql
+  module Mysql
+    class PreparedBinds < ::MiniSql::Abstract::PreparedBinds
+
+      def bind_output(i)
+        '?'
+      end
+
+    end
+  end
+end

data/lib/mini_sql/mysql/prepared_cache.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "mini_sql/abstract/prepared_cache"
+
+module MiniSql
+  module Mysql
+    class PreparedCache < ::MiniSql::Abstract::PreparedCache
+
+      private
+
+      def alloc(sql)
+        @connection.prepare(sql)
+      end
+
+      def dealloc(statement)
+        statement.close unless statement.closed?
+      end
+
+    end
+  end
+end

data/lib/mini_sql/mysql/prepared_connection.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module MiniSql
+  module Mysql
+    class PreparedConnection < Connection
+
+      attr_reader :unprepared
+
+      def initialize(unprepared_connection, deserializer_cache)
+        @unprepared         = unprepared_connection
+        @raw_connection     = unprepared_connection.raw_connection
+        @deserializer_cache = deserializer_cache
+        @param_encoder      = unprepared_connection.param_encoder
+
+        @prepared_cache     = PreparedCache.new(@raw_connection)
+        @param_binder       = PreparedBinds.new
+      end
+
+      def build(_)
+        raise 'Builder can not be called on prepared connections, instead of `::MINI_SQL.prepared.build(sql).query` use `::MINI_SQL.build(sql).prepared.query`'
+      end
+
+      def prepared(condition = true)
+        condition ? self : @unprepared
+      end
+
+      private def run(sql, as, params)
+        prepared_sql, binds, _bind_names = @param_binder.bind(sql, *params)
+        statement = @prepared_cache.prepare_statement(prepared_sql)
+        statement.execute(
+          *binds,
+          as: as,
+          database_timezone: :utc,
+          application_timezone: :utc,
+          cast_booleans: true,
+          cast: true,
+          cache_rows: true,
+          symbolize_keys: false
+        )
+      end
+
+    end
+  end
+end