mini_sql 0.2.2-java

data/lib/mini_sql/connection.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module MiniSql
+  class Connection
+
+    def self.get(raw_connection, options = {})
+      if (defined? ::PG::Connection) && (PG::Connection === raw_connection) 
+        Postgres::Connection.new(raw_connection, options)
+      elsif (defined? ::ArJdbc)
+        Postgres::Connection.new(raw_connection, options)
+      elsif (defined? ::SQLite3::Database) && (SQLite3::Database === raw_connection)
+        Sqlite::Connection.new(raw_connection, options)
+      else
+        raise ArgumentError, 'unknown connection type!'
+      end
+    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)
+      raise NotImplementedError, "must be implemented by child connection"
+    end
+
+    def query(sql, *params)
+      raise NotImplementedError, "must be implemented by child connection"
+    end
+
+    def exec(sql, *params)
+      raise NotImplementedError, "must be implemented by child connection"
+    end
+
+    def query_hash(sql, *params)
+      raise NotImplementedError, "must be implemented by child connection"
+    end
+
+    def build(sql)
+      Builder.new(self, sql)
+    end
+
+    def escape_string(str)
+      raise NotImplementedError, "must be implemented by child connection"
+    end
+
+  end
+end

data/lib/mini_sql/deserializer_cache.rb

@@ -0,0 +1,8 @@
+module MiniSql
+  class DeserializerCache
+    # method takes a raw result and converts to proper objects
+    def materialize(result)
+      raise NotImplementedError, "must be implemented by child"
+    end
+  end
+end

data/lib/mini_sql/inline_param_encoder.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module MiniSql
+  class InlineParamEncoder
+    attr_reader :conn
+
+    def initialize(conn)
+      @conn = conn
+    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)
+      else
+        encode_array(sql, params)
+      end
+    end
+
+    def encode_hash(sql, hash)
+      sql = sql.dup
+
+      hash.each do |k, v|
+        sql.gsub!(":#{k}") do
+          # ignore ::int and stuff like that
+          # $` is previous to match
+          if $` && $`[-1] != ":"
+            quote_val(v)
+          else
+            ":#{k}"
+          end
+        end
+      end
+      sql
+    end
+
+    def encode_array(sql, array)
+      i = -1
+      sql.gsub("?") do |p|
+        i += 1
+        quote_val(array[i])
+      end
+    end
+
+    def quoted_date(value)
+      value.utc.iso8601
+    end
+
+    def quote_val(value)
+      case value
+      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
+  end
+end

data/lib/mini_sql/postgres/coders.rb

@@ -0,0 +1,32 @@
+module MiniSql
+  module Postgres
+    module Coders
+      class NumericCoder < PG::SimpleDecoder
+        def decode(string, tuple = nil, field = nil)
+          BigDecimal(string)
+        end
+      end
+
+      class IPAddrCoder < PG::SimpleDecoder
+        def decode(string, tuple = nil, field = nil)
+          IPAddr.new(string)
+        end
+      end
+
+      class TimestampUtc < PG::SimpleDecoder
+        # exact same implementation as Rails here
+        ISO_DATETIME = /\A(\d{4})-(\d\d)-(\d\d) (\d\d):(\d\d):(\d\d)(\.\d+)?\z/
+
+        def decode(string, tuple = nil, field = nil)
+          if string =~ ISO_DATETIME
+            microsec = ($7.to_r * 1_000_000).to_i
+            Time.utc $1.to_i, $2.to_i, $3.to_i, $4.to_i, $5.to_i, $6.to_i, microsec
+          else
+            STDERR.puts "unexpected date time format #{string}"
+            string
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mini_sql/postgres/connection.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module MiniSql
+  module Postgres
+    class Connection < MiniSql::Connection
+      attr_reader :raw_connection, :type_map, :param_encoder
+
+      def self.default_deserializer_cache
+        @deserializer_cache ||= DeserializerCache.new
+      end
+
+      def self.type_map(conn)
+        @type_map ||=
+          begin
+            map = PG::BasicTypeMapForResults.new(conn)
+            map.add_coder(MiniSql::Postgres::Coders::NumericCoder.new(name: "numeric", oid: 1700, format: 0))
+            map.add_coder(MiniSql::Postgres::Coders::IPAddrCoder.new(name: "inet", oid: 869, format: 0))
+            map.add_coder(MiniSql::Postgres::Coders::IPAddrCoder.new(name: "cidr", oid: 650, format: 0))
+            map.add_coder(PG::TextDecoder::String.new(name: "tsvector", oid: 3614, format: 0))
+
+            map.rm_coder(0, 1114)
+            if defined? PG::TextDecoder::TimestampUtc
+              # treat timestamp without zone as utc
+              # new to PG 1.1
+              map.add_coder(PG::TextDecoder::TimestampUtc.new(name: "timestamp", oid: 1114, format: 0))
+            else
+              map.add_coder(MiniSql::Postgres::Coders::TimestampUtc.new(name: "timestamp", oid: 1114, format: 0))
+            end
+            map
+          end
+      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
+
+      def type_map
+        @type_map ||= self.class.type_map(raw_connection)
+      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)
+        result.type_map = type_map
+        if result.nfields == 1
+          result.column_values(0)
+        else
+          tuples = result.ntuples
+          fields = result.nfields
+
+          array = []
+          f = 0
+          row = 0
+
+          while row < tuples
+            while f < fields
+              array << result.getvalue(row, f)
+              f += 1
+            end
+            f = 0
+            row += 1
+          end
+          array
+        end
+      ensure
+        result.clear if result
+      end
+
+      def query(sql, *params)
+        result = run(sql, params)
+        result.type_map = type_map
+        @deserializer_cache.materialize(result)
+      ensure
+        result.clear if result
+      end
+
+      def exec(sql, *params)
+        result = run(sql, params)
+        result.cmd_tuples
+      ensure
+        result.clear if result
+      end
+
+      def query_hash(sql, *params)
+        result = run(sql, params)
+        result.type_map = type_map
+        result.to_a
+      ensure
+        result.clear if result
+      end
+
+      def build(sql)
+        Builder.new(self, sql)
+      end
+
+      def escape_string(str)
+        raw_connection.escape_string(str)
+      end
+
+      private
+
+      def run(sql, params)
+        if params && params.length > 0
+          sql = param_encoder.encode(sql, *params)
+        end
+        raw_connection.async_exec(sql)
+      end
+
+    end
+  end
+end

data/lib/mini_sql/postgres/deserializer_cache.rb

@@ -0,0 +1,67 @@
+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)
+
+        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
+
+        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/postgres_jdbc/connection.rb

@@ -0,0 +1,97 @@
+# 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 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