mini_sql 0.2.1 → 0.3

data/lib/mini_sql/mysql/deserializer_cache.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module MiniSql
+  module Mysql
+    class DeserializerCache
+
+      DEFAULT_MAX_SIZE = 500
+
+      def initialize(max_size = nil)
+        @cache = {}
+        @max_size = max_size || DEFAULT_MAX_SIZE
+      end
+
+      def materialize(result, decorator_module = nil)
+        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
+
+        materializer.include(decorator_module) if decorator_module
+
+        result.map do |data|
+          materializer.materialize(data)
+        end
+      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(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/postgres/coders.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module MiniSql
   module Postgres
     module Coders

data/lib/mini_sql/postgres/connection.rb

@@ -39,6 +39,7 @@ module MiniSql
         @raw_connection = raw_connection
         @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]
       end
 
       def type_map
@@ -78,6 +79,14 @@ module MiniSql
         result.clear if result
       end
 
+      def query_array(sql, *params)
+        result = run(sql, params)
+        result.type_map = type_map
+        result.values
+      ensure
+         result.clear if result
+      end
+
       def query(sql, *params)
         result = run(sql, params)
         result.type_map = type_map
@@ -86,6 +95,80 @@ 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
+        @deserializer_cache.materialize(result, decorator)
+      ensure
+        result.clear if result
+      end
+
       def exec(sql, *params)
         result = run(sql, params)
         result.cmd_tuples

data/lib/mini_sql/postgres/deserializer_cache.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module MiniSql
   module Postgres
     class DeserializerCache
@@ -9,8 +11,21 @@ module MiniSql
         @max_size = max_size || DEFAULT_MAX_SIZE
       end
 
-      def materialize(result)
+      def materializer(result)
+        key = result.fields
+
+        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
+
+        materializer
+      end
 
+      def materialize(result, decorator_module = nil)
         return [] if result.ntuples == 0
 
         key = result.fields
@@ -24,6 +39,8 @@ module MiniSql
           @cache.shift if @cache.length > @max_size
         end
 
+        materializer.include(decorator_module) if decorator_module
+
         i = 0
         r = []
         # quicker loop
@@ -39,6 +56,15 @@ module MiniSql
       def new_row_matrializer(result)
         fields = result.fields
 
+        i = 0
+        while i < fields.length
+          # special handling for unamed column
+          if fields[i] == "?column?"
+            fields[i] = "column#{i}"
+          end
+          i += 1
+        end
+
         Class.new do
           attr_accessor(*fields)
 
@@ -48,7 +74,7 @@ module MiniSql
           def to_h
             r = {}
             instance_variables.each do |f|
-              r[f.to_s.sub('@','').to_sym] = instance_variable_get(f)
+              r[f.to_s.sub('@', '').to_sym] = instance_variable_get(f)
             end
             r
           end
@@ -56,7 +82,7 @@ module MiniSql
           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("; ")}
+              #{col = -1; fields.map { |f| "r.#{f} = pg_result.getvalue(index, #{col += 1})" }.join("; ")}
               r
             end
           RUBY

data/lib/mini_sql/postgres_jdbc/connection.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module MiniSql
+  module Postgres
+    class Connection < MiniSql::Connection
+      class NumericCoder
+        def decode(string)
+          BigDecimal(string)
+        end
+      end
+
+      class IPAddrCoder
+        def decode(string)
+          IPAddr.new(string)
+        end
+      end
+
+      attr_reader :raw_connection, :type_map, :param_encoder
+
+      def self.default_deserializer_cache
+        @deserializer_cache ||= DeserializerCache.new
+      end
+
+      def self.typemap
+        @type_map ||= {
+            "numeric" => NumericCoder.new,
+            "inet" => IPAddrCoder.new,
+            "cidr" => IPAddrCoder.new
+        }
+      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
+
+      # 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)
+        if result.length == 1
+          result.values[0]
+        else
+          result.values.each_with_object([]) { |value, array| array.concat value }
+        end
+      end
+
+      def query(sql, *params)
+        result = run(sql, params)
+        @deserializer_cache.materialize(result)
+      end
+
+      def query_decorator(decorator, sql, *params)
+        result = run(sql, params)
+        @deserializer_cache.materialize(result, decorator)
+      end
+
+      def exec(sql, *params)
+        result = run(sql, params)
+        if result.kind_of? Integer
+          result
+        else
+          result.length
+        end
+      end
+
+      def query_hash(sql, *params)
+        run(sql, params).to_a
+      end
+
+      def build(sql)
+        Builder.new(self, sql)
+      end
+
+      def escape_string(str)
+        raw_connection.escape_string(str)
+      end
+
+      private
+
+      def run(sql, params)
+        sql = param_encoder.encode(sql, *params) if params && params.length > 0
+        conn = raw_connection
+        conn.typemap = self.class.typemap
+        conn.execute(sql)
+      ensure
+        # Force unsetting of typemap since we don't want mixed AR usage to continue to use these extra converters.
+        conn.typemap = nil
+      end
+    end
+  end
+end

data/lib/mini_sql/postgres_jdbc/deserializer_cache.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+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, decorator_module = nil)
+
+        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
+
+        materializer.include(decorator_module) if decorator_module
+
+        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

@@ -26,6 +26,10 @@ module MiniSql
         r
       end
 
+      def query_array(sql, *params)
+        run(sql, *params)
+      end
+
       def exec(sql, *params)
 
         start = raw_connection.total_changes
@@ -46,8 +50,14 @@ module MiniSql
         end
       end
 
+      def query_decorator(decorator, sql, *params)
+        run(sql, *params) do |set|
+          deserializer_cache.materialize(set, decorator)
+        end
+      end
+
       def escape_string(str)
-        str.gsub("'","''")
+        str.gsub("'", "''")
       end
 
       private

data/lib/mini_sql/sqlite/deserializer_cache.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module MiniSql
   module Sqlite
     class DeserializerCache
@@ -9,7 +11,7 @@ module MiniSql
         @max_size = max_size || DEFAULT_MAX_SIZE
       end
 
-      def materialize(result)
+      def materialize(result, decorator_module = nil)
 
         key = result.columns
 
@@ -22,6 +24,8 @@ module MiniSql
           @cache.shift if @cache.length > @max_size
         end
 
+        materializer.include(decorator_module) if decorator_module
+
         r = []
         # quicker loop
         while !result.eof?
@@ -47,7 +51,7 @@ module MiniSql
           def to_h
             r = {}
             instance_variables.each do |f|
-              r[f.to_s.sub('@','').to_sym] = instance_variable_get(f)
+              r[f.to_s.sub('@', '').to_sym] = instance_variable_get(f)
             end
             r
           end
@@ -55,7 +59,7 @@ module MiniSql
           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