mini_sql 1.0.1 → 1.1.0

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

data/lib/mini_sql/postgres/connection.rb

@@ -40,12 +40,18 @@ module MiniSql
         @deserializer_cache = (args && args[:deserializer_cache]) || self.class.default_deserializer_cache
         @param_encoder = (args && args[:param_encoder]) || InlineParamEncoder.new(self)
         @type_map = args && args[:type_map]
+
+        @prepared = PreparedConnection.new(self, @deserializer_cache)
       end
 
       def type_map
         @type_map ||= self.class.type_map(raw_connection)
       end
 
+      def prepared(condition = true)
+        condition ? @prepared : self
+      end
+
       # Returns a flat array containing all results.
       # Note, if selecting multiple columns array will be flattened
       #

data/lib/mini_sql/postgres/deserializer_cache.rb

@@ -12,13 +12,13 @@ module MiniSql
       end
 
       def materializer(result)
-        key = result.fields
+        key = result.fields.join(',')
 
         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
 
@@ -28,14 +28,14 @@ module MiniSql
       def materialize(result, decorator_module = nil)
         return [] if result.ntuples == 0
 
-        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
 
@@ -55,7 +55,7 @@ module MiniSql
 
       private
 
-      def new_row_matrializer(result)
+      def new_row_materializer(result)
         fields = result.fields
 
         i = 0

data/lib/mini_sql/postgres/prepared_binds.rb

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

data/lib/mini_sql/postgres/prepared_cache.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "mini_sql/abstract/prepared_cache"
+
+module MiniSql
+  module Postgres
+    class PreparedCache < ::MiniSql::Abstract::PreparedCache
+
+      private
+
+      def alloc(sql)
+        alloc_key = next_key
+        @connection.prepare(alloc_key, sql)
+
+        alloc_key
+      end
+
+      def dealloc(key)
+        @connection.query "DEALLOCATE #{key}" if @connection.status == PG::CONNECTION_OK
+      rescue PG::Error
+      end
+
+    end
+  end
+end

data/lib/mini_sql/postgres/prepared_connection.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module MiniSql
+  module Postgres
+    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
+        @type_map           = unprepared_connection.type_map
+        @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, params)
+        prepared_sql, binds, _bind_names = @param_binder.bind(sql, *params)
+        prepare_statement_key = @prepared_cache.prepare_statement(prepared_sql)
+        raw_connection.exec_prepared(prepare_statement_key, binds)
+      end
+
+    end
+  end
+end

data/lib/mini_sql/postgres_jdbc/deserializer_cache.rb

@@ -15,14 +15,14 @@ module MiniSql
 
         return [] if result.ntuples == 0
 
-        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
 
@@ -44,7 +44,7 @@ module MiniSql
 
       private
 
-      def new_row_matrializer(result)
+      def new_row_materializer(result)
         fields = result.fields
 
         Class.new do

data/lib/mini_sql/result.rb

@@ -16,5 +16,15 @@ module MiniSql
     def values
       instance_variables.map { |f| instance_variable_get(f) }
     end
+
+    def ==(other_result)
+      self.class.decorator == other_result.class.decorator &&
+      self.instance_variables == other_result.instance_variables &&
+      self.values == other_result.values
+    end
+
+    def eql?(other_result)
+      self == other_result
+    end
   end
 end

data/lib/mini_sql/serializer.rb

@@ -1,26 +1,40 @@
 # frozen_string_literal: true
 
 module MiniSql
-  module Serializer
+  class Serializer < Array
     MAX_CACHE_SIZE = 500
 
-    def self.to_json(result)
-      wrapper =
-        if result.length == 0
-          {}
-        else
-          {
-            "decorator" => result[0].class.decorator.to_s,
-            "fields" => result[0].to_h.keys,
-            "data" => result.map(&:values),
-          }
-        end
+    def initialize(result)
+      replace(result)
+    end
+
+    def self.marshallable(result)
+      new(result)
+    end
+
+    def marshal_dump
+      serialize
+    end
 
-      JSON.generate(wrapper)
+    def marshal_load(wrapper)
+      replace self.class.materialize(wrapper)
+    end
+
+    private
+
+    def serialize
+      if length == 0
+        {}
+      else
+        {
+          "decorator" => first.class.decorator.to_s,
+          "fields" => first.to_h.keys,
+          "data" => map(&:values),
+        }
+      end
     end
 
-    def self.from_json(json)
-      wrapper = JSON.parse(json)
+    def self.materialize(wrapper)
       if !wrapper["data"]
         []
       else

data/lib/mini_sql/sqlite/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)
@@ -68,7 +74,9 @@ module MiniSql
         end
         if block_given?
           stmt = SQLite3::Statement.new(raw_connection, sql)
-          yield stmt.execute
+          result = yield stmt.execute
+          stmt.close
+          result
         else
           raw_connection.execute(sql)
         end

data/lib/mini_sql/sqlite/deserializer_cache.rb

@@ -13,14 +13,14 @@ module MiniSql
 
       def materialize(result, decorator_module = nil)
 
-        key = result.columns
+        key = result.columns.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
 
@@ -41,7 +41,7 @@ module MiniSql
 
       private
 
-      def new_row_matrializer(result)
+      def new_row_materializer(result)
         fields = result.columns
 
         Class.new do

data/lib/mini_sql/sqlite/prepared_binds.rb

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

data/lib/mini_sql/sqlite/prepared_cache.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "mini_sql/abstract/prepared_cache"
+
+module MiniSql
+  module Sqlite
+    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/sqlite/prepared_connection.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module MiniSql
+  module Sqlite
+    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, params)
+        prepared_sql, binds, _bind_names = @param_binder.bind(sql, params)
+        statement = @prepared_cache.prepare_statement(prepared_sql)
+        statement.bind_params(binds)
+        if block_given?
+          yield statement.execute
+        else
+          statement.execute.to_a
+        end
+      end
+
+    end
+  end
+end