mini_sql 0.2.3 → 1.0.1

data/bin/console

@@ -1,4 +1,5 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
 require "bundler/setup"
 require "mini_sql"

data/lib/mini_sql.rb

@@ -8,6 +8,9 @@ require_relative "mini_sql/connection"
 require_relative "mini_sql/deserializer_cache"
 require_relative "mini_sql/builder"
 require_relative "mini_sql/inline_param_encoder"
+require_relative "mini_sql/decoratable"
+require_relative "mini_sql/serializer"
+require_relative "mini_sql/result"
 
 module MiniSql
   if RUBY_ENGINE == 'jruby'

data/lib/mini_sql/builder.rb

@@ -66,5 +66,14 @@ class MiniSql::Builder
     RUBY
   end
 
-end
+  def query_decorator(decorator, hash_args = nil)
+    hash_args = @args.merge(hash_args) if hash_args && @args
+    hash_args ||= @args
+    if hash_args
+      @connection.query_decorator(decorator, to_sql, hash_args)
+    else
+      @connection.query_decorator(decorator, to_sql)
+    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)
@@ -50,19 +48,19 @@ module MiniSql
 
     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 Date, Time then "'#{quoted_date(value)}'"
+      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 "'#{escape_string(value.to_s)}'"
       else raise TypeError, "can't quote #{value.class.name}"
       end
     end

data/lib/mini_sql/mysql/connection.rb

@@ -20,6 +20,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 +34,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 +54,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,7 +11,7 @@ module MiniSql
         @max_size = max_size || DEFAULT_MAX_SIZE
       end
 
-      def materialize(result)
+      def materialize(result, decorator_module = nil)
         key = result.fields
 
         # trivial fast LRU implementation
@@ -21,6 +23,10 @@ module MiniSql
           @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
@@ -32,23 +38,15 @@ module MiniSql
         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/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,10 @@ module MiniSql
           @cache.shift if @cache.length > @max_size
         end
 
+        if decorator_module
+          materializer = materializer.decorated(decorator_module)
+        end
+
         i = 0
         r = []
         # quicker loop
@@ -39,24 +58,25 @@ module MiniSql
       def new_row_matrializer(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_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
 
-      # 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_matrializer(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_matrializer(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