mini_sql 0.2.5 → 1.1.1

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,18 +12,20 @@ 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
 
-        materializer.include(decorator_module) if decorator_module
+        if decorator_module
+          materializer = materializer.decorated(decorator_module)
+        end
 
         result.map do |data|
           materializer.materialize(data)
@@ -32,22 +34,14 @@ module MiniSql
 
       private
 
-      def new_row_matrializer(result)
+      def new_row_materializer(result)
         fields = result.fields
 
         Class.new do
-          attr_accessor(*fields)
-
-          # AM serializer support
-          alias :read_attribute_for_serialization :send
+          extend MiniSql::Decoratable
+          include MiniSql::Result
 
-          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)

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

@@ -3,7 +3,7 @@
 module MiniSql
   module Postgres
     class Connection < MiniSql::Connection
-      attr_reader :raw_connection, :type_map, :param_encoder
+      attr_reader :raw_connection, :param_encoder
 
       def self.default_deserializer_cache
         @deserializer_cache ||= DeserializerCache.new
@@ -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
       #
@@ -83,8 +89,8 @@ module MiniSql
         result = run(sql, params)
         result.type_map = type_map
         result.values
-       ensure
-         result.clear if result
+      ensure
+        result.clear if result
       end
 
       def query(sql, *params)
@@ -95,6 +101,72 @@ module MiniSql
         result.clear if result
       end
 
+      def query_each(sql, *params)
+        raise StandardError, "Please supply a block when calling query_each" if !block_given?
+        if params && params.length > 0
+          sql = param_encoder.encode(sql, *params)
+        end
+
+        raw_connection.send_query(sql)
+        raw_connection.set_single_row_mode
+
+        loop do
+          result = raw_connection.get_result
+          break if !result
+
+          result.check
+
+          if result.ntuples == 0
+            # skip, this happens at the end when we get totals
+          else
+            materializer ||= @deserializer_cache.materializer(result)
+            result.type_map = type_map
+            i = 0
+            # technically we should only get 1 row here
+            # but protect against future batching changes
+            while i < result.ntuples
+              yield materializer.materialize(result, i)
+              i += 1
+            end
+          end
+
+          result.clear
+        end
+      end
+
+      def query_each_hash(sql, *params)
+        raise StandardError, "Please supply a block when calling query_each_hash" if !block_given?
+        if params && params.length > 0
+          sql = param_encoder.encode(sql, *params)
+        end
+
+        raw_connection.send_query(sql)
+        raw_connection.set_single_row_mode
+
+        loop do
+          result = raw_connection.get_result
+          break if !result
+
+          result.check
+
+          if result.ntuples == 0
+            # skip, this happens at the end when we get totals
+          else
+            result.type_map = type_map
+            i = 0
+
+            # technically we should only get 1 row here
+            # but protect against future batching changes
+            while i < result.ntuples
+              yield result[i]
+              i += 1
+            end
+          end
+
+          result.clear
+        end
+      end
+
       def query_decorator(decorator, sql, *params)
         result = run(sql, params)
         result.type_map = type_map

data/lib/mini_sql/postgres/deserializer_cache.rb

@@ -11,21 +11,37 @@ module MiniSql
         @max_size = max_size || DEFAULT_MAX_SIZE
       end
 
+      def materializer(result)
+        key = result.fields.join(',')
+
+        materializer = @cache.delete(key)
+        if materializer
+          @cache[key] = materializer
+        else
+          materializer = @cache[key] = new_row_materializer(result)
+          @cache.shift if @cache.length > @max_size
+        end
+
+        materializer
+      end
+
       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
 
-        materializer.include(decorator_module) if decorator_module
+        if decorator_module
+          materializer = materializer.decorated(decorator_module)
+        end
 
         i = 0
         r = []
@@ -39,22 +55,23 @@ module MiniSql
 
       private
 
-      def new_row_matrializer(result)
+      def new_row_materializer(result)
         fields = result.fields
 
-        Class.new do
-          attr_accessor(*fields)
+        i = 0
+        while i < fields.length
+          # special handling for unamed column
+          if fields[i] == "?column?"
+            fields[i] = "column#{i}"
+          end
+          i += 1
+        end
 
-          # AM serializer support
-          alias :read_attribute_for_serialization :send
+        Class.new do
+          extend MiniSql::Decoratable
+          include MiniSql::Result
 
-          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(pg_result, index)

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/connection.rb

@@ -89,7 +89,9 @@ module MiniSql
       private
 
       def run(sql, params)
-        sql = param_encoder.encode(sql, *params) if params && params.length > 0
+        if params && params.length > 0
+          sql = param_encoder.encode(sql, *params)
+        end
         conn = raw_connection
         conn.typemap = self.class.typemap
         conn.execute(sql)

data/lib/mini_sql/postgres_jdbc/deserializer_cache.rb

@@ -15,19 +15,23 @@ 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
 
         materializer.include(decorator_module) if decorator_module
 
+        if decorator_module
+          materializer = materializer.decorated(decorator_module)
+        end
+
         i = 0
         r = []
         # quicker loop
@@ -40,22 +44,14 @@ 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(pg_result, index)