simple-sql 0.5.7 → 0.5.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0d0a4a51efce9ee15d5162be03fc204009535caab84adbec768090dc1b33358a
-  data.tar.gz: 161edc1c790492df3c7fec4a0933826adcd6757d1a267fa119dbe75cab856416
+  metadata.gz: 8db783548f20bfc4902ecdc7e94c79f8ae8eceeb99c46c4f65dd9b9d55b6c6ea
+  data.tar.gz: 357f8228c7b215b5e17eddb9b8bc935ce0e82c54ccac910876df0c428a4759cd
 SHA512:
-  metadata.gz: 67be2270fd3b1e456bc573aca3c6afa25bbb070766edbf11bdf4bece2037fd91f636d12b1861f8899106874e995808e876f5fa13f697dc24508ea66bac7ff8f8
-  data.tar.gz: f06e19bd48a24dded429f6155442748944ee3f61e0e1e5cfb58248a64fa2f0133781d9bd49a90897271cb759a6f1fe1c86d55b8e88d162cdda96f8f9a90e4420
+  metadata.gz: a096a8c2837b8e4d0066e99f637751dcdf08cb649465f6eef051cb5955475211199a07ca0f7e6e8792f7c1ca104655883038d6f682ded67dfc408898ebd4aec7
+  data.tar.gz: 188763bbe50ccc364f8a159b56f9c173024e46db5ad314fba0878fcb7dbbb758602c0551d484be9fa3e1e15f7d3036cd211cec048e1cd23489549aa9c3d8fe7c

data/lib/simple/sql/{connection_adapter.rb → connection/base.rb}

@@ -1,10 +1,12 @@
+# rubocop:disable Metrics/AbcSize
+
 # This module implements an adapter between the Simple::SQL interface
 # (i.e. ask, all, first, transaction) and a raw connection.
 #
 # This module can be mixed onto objects that implement a raw_connection
 # method, which must return a Pg::Connection.
 
-module Simple::SQL::ConnectionAdapter
+class Simple::SQL::Connection
   Logging = ::Simple::SQL::Logging
 
   # execute one or more sql statements. This method does not allow to pass in
@@ -33,31 +35,25 @@ module Simple::SQL::ConnectionAdapter
   def all(sql, *args, into: nil, &block)
     raise ArgumentError, "all no longer support blocks, use each instead." if block
 
-    rows = []
-    my_pg_source_oid = nil
-
-    each_without_conversion(sql, *args, into: into) do |row, pg_source_oid|
-      rows << row
-      my_pg_source_oid = pg_source_oid
-    end
+    rows, pg_source_oid, column_info = each_without_conversion(sql, *args, into: into)
 
-    record_set = convert_rows_to_result rows, into: into, pg_source_oid: my_pg_source_oid
+    result = convert_rows_to_result rows, into: into, pg_source_oid: pg_source_oid
 
     # [TODO] - resolve associations. Note that this is only possible if the type
     # is not an Array (i.e. into is nil)
 
-    if sql.is_a?(::Simple::SQL::Connection::Scope) && sql.paginated?
-      record_set.send(:set_pagination_info, sql)
-    end
-
-    record_set
+    result.pagination_scope = sql if sql.is_a?(::Simple::SQL::Connection::Scope) && sql.paginated?
+    result.column_info      = column_info
+    result
   end
 
   def each(sql, *args, into: nil)
     raise ArgumentError, "Missing block" unless block_given?
 
-    each_without_conversion sql, *args, into: into do |row, pg_source_oid|
-      record = convert_row_to_record row, into: into, pg_source_oid: pg_source_oid
+    rows, pg_source_oid, _column_info = each_without_conversion sql, *args, into: into
+
+    rows.each do |row|
+      record = convert_rows_to_result([row], into: into, pg_source_oid: pg_source_oid).first
       yield record
     end
 
@@ -134,34 +130,45 @@ module Simple::SQL::ConnectionAdapter
     end
   end
 
+  # returns an array of decoded entries, if any
   def each_without_conversion(sql, *args, into: nil)
     pg_result = exec_logged(sql, *args)
 
+    column_info = collect_column_info(pg_result)
+    rows = []
+    pg_source_oid = nil
+
     if pg_result.ntuples > 0 && pg_result.nfields > 0
-      decoder = Decoder.new(self, pg_result, into: (into ? Hash : nil))
+      decoder = Decoder.new(pg_result, into: (into ? Hash : nil), column_info: column_info)
       pg_source_oid = pg_result.ftable(0)
 
       pg_result.each_row do |row|
-        yield decoder.decode(row), pg_source_oid
+        rows << decoder.decode(row)
       end
     end
 
+    [rows, pg_source_oid, column_info]
+  ensure
     # optimization: If we wouldn't clear here the GC would do this later.
-    pg_result.clear unless pg_result.autoclear?
+    pg_result.clear if pg_result && !pg_result.autoclear?
   end
 
-  def convert_row_to_record(row, into:, pg_source_oid:)
-    convert_rows_to_result([row], into: into, pg_source_oid: pg_source_oid).first
+  def collect_column_info(pg_result)
+    return unless pg_result.nfields > 0
+
+    (0...pg_result.nfields).map do |idx|
+      ftype = pg_result.ftype(idx)
+      fmod = pg_result.fmod(idx)
+
+      {
+        name: pg_result.fname(idx).to_sym,
+        pg_type_name: type_info.pg_type_name(ftype: ftype, fmod: fmod),
+        type_name: type_info.type_name(ftype: ftype, fmod: fmod)
+      }
+    end
   end
 
   def convert_rows_to_result(rows, into:, pg_source_oid:)
     Result.build(self, rows, target_type: into, pg_source_oid: pg_source_oid)
   end
-
-  public
-
-  def resolve_type(ftype, fmod)
-    @resolved_types ||= {}
-    @resolved_types[[ftype, fmod]] ||= raw_connection.exec("SELECT format_type($1,$2)", [ftype, fmod]).getvalue(0, 0)
-  end
 end

data/lib/simple/sql/connection/type_info.rb

@@ -0,0 +1,66 @@
+# rubocop:disable Style/SymbolLiteral
+# rubocop:disable Layout/AlignHash
+# rubocop:disable Style/HashSyntax
+
+# This module implements an adapter between the Simple::SQL interface
+# (i.e. ask, all, first, transaction) and a raw connection.
+#
+# This module can be mixed onto objects that implement a raw_connection
+# method, which must return a Pg::Connection.
+
+class Simple::SQL::Connection
+  def type_info
+    @type_info ||= TypeInfo.new(self)
+  end
+
+  class TypeInfo
+    def initialize(connection)
+      @connection = connection
+    end
+
+    # returns a Symbol
+    def pg_type_name(ftype:, fmod:)
+      @pg_type_names ||= {}
+      @pg_type_names[[ftype, fmod]] ||= _pg_type_name(ftype, fmod)
+    end
+
+    # returns a Symbol
+    def type_name(ftype:, fmod:)
+      @type_names ||= {}
+      @type_names[[ftype, fmod]] ||= _type_name(ftype, fmod)
+    end
+
+    private
+
+    TYPE_NAMES = {
+      :unknown                       => :"string",
+      :"character varying"           => :"string",
+      :integer                       => :"integer",
+      :bigint                        => :"integer",
+      :numeric                       => :"float",
+      :"double precision"            => :"float",
+      :"integer[]"                   => :"integer[]",
+      :"character varying[]"         => :"string[]",
+      :"text[]"                      => :"string[]",
+      :"timestamp without time zone" => :"time",
+      :"timestamp with time zone"    => :"time",
+      :hstore                        => :"object",
+      :json                          => :"object",
+      :jsonb                         => :"object",
+      :boolean                       => :"boolean"
+    }
+
+    def _pg_type_name(ftype, fmod)
+      @connection.raw_connection.exec("SELECT format_type($1,$2)", [ftype, fmod]).getvalue(0, 0).to_sym
+    end
+
+    def _type_name(ftype, fmod)
+      pg_type_name = pg_type_name(ftype: ftype, fmod: fmod)
+      TYPE_NAMES[pg_type_name] || _custom_type_name(ftype, fmod, pg_type_name)
+    end
+
+    def _custom_type_name(_ftype, _fmod, pg_type_name)
+      "UNKNWON #{pg_type_name.inspect}".to_sym
+    end
+  end
+end

data/lib/simple/sql/connection.rb

@@ -4,10 +4,12 @@ end
 require_relative "connection/raw_connection"
 require_relative "connection/active_record_connection"
 
+require_relative "connection/base"
 require_relative "connection/scope"
 require_relative "connection/reflection"
 require_relative "connection/insert"
 require_relative "connection/duplicate"
+require_relative "connection/type_info"
 
 # A Connection object.
 #
@@ -32,8 +34,6 @@ class Simple::SQL::Connection
     end
   end
 
-  include Simple::SQL::ConnectionAdapter
-
   extend Forwardable
   delegate [:wait_for_notify] => :raw_connection
 end

data/lib/simple/sql/helpers/decoder.rb

@@ -38,7 +38,7 @@ module Simple::SQL::Helpers::Decoder
 
   # HStore parsing
   module HStore
-    module_function
+    extend self
 
     # thanks to https://github.com/engageis/activerecord-postgres-hstore for regexps!
 
@@ -67,17 +67,16 @@ module Simple::SQL::Helpers::Decoder
 end
 
 module Simple::SQL::Helpers::Decoder
-  def self.new(connection, result, into:)
-    if into == Hash           then HashRecord.new(connection, result)
-    elsif result.nfields == 1 then SingleColumn.new(connection, result)
-    else                           MultiColumns.new(connection, result)
+  def self.new(result, into:, column_info:)
+    if into == Hash           then HashRecord.new(column_info)
+    elsif result.nfields == 1 then SingleColumn.new(column_info)
+    else                           MultiColumns.new(column_info)
     end
   end
 
   class SingleColumn
-    def initialize(connection, result)
-      typename = connection.resolve_type(result.ftype(0), result.fmod(0))
-      @field_type = typename.to_sym
+    def initialize(column_info)
+      @field_type = column_info.first.fetch(:pg_type_name)
     end
 
     def decode(row)
@@ -87,11 +86,10 @@ module Simple::SQL::Helpers::Decoder
   end
 
   class MultiColumns
-    def initialize(connection, result)
-      @field_types = 0.upto(result.fields.length - 1).map do |idx|
-        typename = connection.resolve_type(result.ftype(idx), result.fmod(idx))
-        typename.to_sym
-      end
+    H = ::Simple::SQL::Helpers
+
+    def initialize(column_info)
+      @field_types = H.pluck(column_info, :pg_type_name)
     end
 
     def decode(row)
@@ -102,9 +100,11 @@ module Simple::SQL::Helpers::Decoder
   end
 
   class HashRecord < MultiColumns
-    def initialize(connection, result)
-      super(connection, result)
-      @field_names = result.fields.map(&:to_sym)
+    H = ::Simple::SQL::Helpers
+
+    def initialize(column_info)
+      super(column_info)
+      @field_names = H.pluck(column_info, :name)
     end
 
     def decode(row)

data/lib/simple/sql/result.rb

@@ -1,10 +1,10 @@
-# rubocop:disable Naming/AccessorMethodName
 # rubocop:disable Style/DoubleNegation
 # rubocop:disable Style/GuardClause
 
 require_relative "helpers"
 
 class ::Simple::SQL::Result < Array
+  attr_accessor :column_info
 end
 
 require_relative "result/records"
@@ -74,15 +74,13 @@ class ::Simple::SQL::Result < Array
     !!@pagination_scope
   end
 
-  private
-
   def pagination_scope
     raise "Only available only for paginated scopes" unless paginated?
 
     @pagination_scope
   end
 
-  def set_pagination_info(scope)
+  def pagination_scope=(scope)
     raise ArgumentError, "per must be > 0" unless scope.per > 0
 
     @pagination_scope = scope

data/lib/simple/sql/version.rb

@@ -1,5 +1,5 @@
 module Simple
   module SQL
-    VERSION = "0.5.7"
+    VERSION = "0.5.8"
   end
 end

data/lib/simple/sql.rb

@@ -8,7 +8,6 @@ require_relative "sql/helpers"
 require_relative "sql/result"
 require_relative "sql/config"
 require_relative "sql/logging"
-require_relative "sql/connection_adapter"
 require_relative "sql/connection"
 
 module Simple

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: simple-sql
 version: !ruby/object:Gem::Version
-  version: 0.5.7
+  version: 0.5.8
 platform: ruby
 authors:
 - radiospiel
@@ -202,6 +202,7 @@ files:
 - lib/simple/sql/config.rb
 - lib/simple/sql/connection.rb
 - lib/simple/sql/connection/active_record_connection.rb
+- lib/simple/sql/connection/base.rb
 - lib/simple/sql/connection/duplicate.rb
 - lib/simple/sql/connection/insert.rb
 - lib/simple/sql/connection/raw_connection.rb
@@ -212,7 +213,7 @@ files:
 - lib/simple/sql/connection/scope/filters.rb
 - lib/simple/sql/connection/scope/order.rb
 - lib/simple/sql/connection/scope/pagination.rb
-- lib/simple/sql/connection_adapter.rb
+- lib/simple/sql/connection/type_info.rb
 - lib/simple/sql/formatting.rb
 - lib/simple/sql/fragment.rb
 - lib/simple/sql/helpers.rb