mini_sql 0.2.4 → 1.1.0

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,12 +39,19 @@ 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]
+
+        @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
       #
@@ -78,6 +85,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 +101,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,21 +11,38 @@ module MiniSql
         @max_size = max_size || DEFAULT_MAX_SIZE
       end
 
-      def materialize(result)
+      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
 
+        if decorator_module
+          materializer = materializer.decorated(decorator_module)
+        end
+
         i = 0
         r = []
         # quicker loop
@@ -36,27 +55,28 @@ 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)
               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/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

@@ -60,6 +60,11 @@ module MiniSql
         @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
@@ -84,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

@@ -1,67 +1,67 @@
+# frozen_string_literal: true
+
 module MiniSql
   module Postgres
     class DeserializerCache
 
-    DEFAULT_MAX_SIZE = 500
+      DEFAULT_MAX_SIZE = 500
 
-    def initialize(max_size = nil)
-      @cache = {}
-      @max_size = max_size || DEFAULT_MAX_SIZE
-    end
+      def initialize(max_size = nil)
+        @cache = {}
+        @max_size = max_size || DEFAULT_MAX_SIZE
+      end
 
-    def materialize(result)
+      def materialize(result, decorator_module = nil)
 
-      return [] if result.ntuples == 0
+        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)
-        @cache.shift if @cache.length > @max_size
-      end
+        # trivial fast LRU implementation
+        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
 
-      i = 0
-      r = []
-      # quicker loop
-      while i < result.ntuples
-        r << materializer.materialize(result, i)
-        i += 1
-      end
-      r
-    end
+        materializer.include(decorator_module) if decorator_module
 
-    private
+        if decorator_module
+          materializer = materializer.decorated(decorator_module)
+        end
+
+        i = 0
+        r = []
+        # quicker loop
+        while i < result.ntuples
+          r << materializer.materialize(result, i)
+          i += 1
+        end
+        r
+      end
 
-    def new_row_matrializer(result)
-      fields = result.fields
+      private
 
-      Class.new do
-        attr_accessor(*fields)
+      def new_row_materializer(result)
+        fields = result.fields
 
-        # 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
+          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
+          RUBY
+        end
       end
     end
   end
 end
-end

data/lib/mini_sql/result.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module MiniSql
+  module Result
+    # AM serializer support
+    alias :read_attribute_for_serialization :send
+
+    def to_h
+      r = {}
+      instance_variables.each do |f|
+        r[f.to_s.delete_prefix('@').to_sym] = instance_variable_get(f)
+      end
+      r
+    end
+
+    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