simple-sql 0.4.12 → 0.4.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 219be87ab80103dce585c2c71a8be92dc8274448
-  data.tar.gz: aacb51c639d27d3348695c075a9e1e12c27fe915
+  metadata.gz: f577e360eaff0f4796c8bbb52026e6ad135bf0bf
+  data.tar.gz: 91bb7c60f202bdc03021f8baccf060f116f78cf3
 SHA512:
-  metadata.gz: 1f8250eac83d27aa869fdc01814f1c565e71470d8805b876eac12c875466f780341259ee9e6f10f84e27a0f3dada384a2044c109267c5c8bcf34d4eb2d14ffcd
-  data.tar.gz: 4260387271f5c4ab8e25d6bdc4d457a94412453598f0e4ce876800a89db0862871950efe9849ed1f5823c1bce8727f47d81df81f4c28ed4c0851c8cefe6c8405
+  metadata.gz: 3b7844945f0fe1f7befd22015813693dd908744a8c97d8a8a1e9351c91a85148a844df8c8bffd97cf5099cb81461d941fa214145dc8310fbfed186c14654d64a
+  data.tar.gz: 5d5fe7b5ec335edc2d0e95abe0a13e1e14e48c0bec0c64ae78fd7ad967289e470863191ae00854426a4300db92bdd036a39f281e37c27779ad8f6499672db754

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

@@ -1,75 +1,85 @@
-module Simple::SQL::Helpers::RowConverter # :private:
+module Simple::SQL::Helpers::RowConverter
   SELF = self
 
   # returns an array of converted records
-  def self.convert_ary(records, into:)
+  def self.convert_row(records, into:, associations: nil)
     hsh = records.first
     return records unless hsh
 
     converter = if into == :struct
-                  StructConverter.for(attributes: hsh.keys)
+                  StructConverter.for(attributes: hsh.keys, associations: associations)
                 else
-                  TypeConverter.for(type: into)
+                  TypeConverter.for(type: into, associations: associations)
                 end
 
-    records.map { |record| converter.convert_ary(record) }
+    records.map { |record| converter.convert_row(record) }
   end
 
   def self.convert(record, into:) # :nodoc:
-    ary = convert_ary([record], into: into)
+    ary = convert_row([record], into: into)
     ary.first
   end
 
   class TypeConverter #:nodoc:
-    def self.for(type:)
-      new(type: type)
+    def self.for(type:, associations:)
+      new(type: type, associations: associations)
     end
 
-    def initialize(type:)
-      @type = type
+    def initialize(type:, associations:)
+      @type         = type
+      @associations = associations
     end
 
-    def convert_ary(hsh)
+    def convert_row(hsh)
+      hsh = convert_associations(hsh) if @associations
+      @type.new hsh
+    end
+
+    def convert_associations(hsh)
       updates = {}
-      hsh.each do |key, value|
+
+      @associations.each do |key|
+        value = hsh.fetch(key)
         case value
         when Hash   then updates[key] = SELF.convert(value, into: @type)
-        when Array  then updates[key] = SELF.convert_ary(value, into: @type)
+        when Array  then updates[key] = SELF.convert_row(value, into: @type)
         end
       end
 
-      hsh = hsh.merge(updates)
-
-      @type.new hsh
+      hsh.merge(updates)
     end
   end
 
   class StructConverter # :nodoc:
-    def self.for(attributes:)
+    def self.for(attributes:, associations:)
       @cache ||= {}
-      @cache[attributes] ||= new(attributes)
+      @cache[[attributes, associations]] ||= new(attributes: attributes, associations: associations)
     end
 
-    def initialize(attributes)
+    def initialize(attributes:, associations:)
+      @attributes          = attributes
+      @associations        = associations
+      @association_indices = associations.map { |association| attributes.index(association) } if associations
+
       @klass = Struct.new(*attributes)
     end
 
-    def convert_ary(hsh)
-      values = hsh.values_at(*@klass.members)
-      updates = {}
+    def convert_row(hsh)
+      values = hsh.values_at(*@attributes)
 
-      values.each_with_index do |value, idx|
+      convert_associations(values) if @associations
+      @klass.new(*values)
+    end
+
+    # convert values at the <tt>@association_indices</tt>.
+    def convert_associations(values)
+      @association_indices.each do |idx|
+        value = values[idx]
         case value
-        when Hash   then updates[idx] = SELF.convert(value, into: :struct)
-        when Array  then updates[idx] = SELF.convert_ary(value, into: :struct)
+        when Hash   then values[idx] = SELF.convert(value, into: :struct)
+        when Array  then values[idx] = SELF.convert_row(value, into: :struct)
         end
       end
-
-      updates.each do |idx, updated_value|
-        values[idx] = updated_value
-      end
-
-      @klass.new(*values)
     end
   end
 end

data/lib/simple/sql/result/records.rb

@@ -11,6 +11,7 @@ class ::Simple::SQL::Result::Records < ::Simple::SQL::Result
     @hash_records   = records
     @target_type    = target_type
     @pg_source_oid  = pg_source_oid
+    @associations   = []
 
     materialize
   end
@@ -54,6 +55,9 @@ class ::Simple::SQL::Result::Records < ::Simple::SQL::Result
     AssociationLoader.preload @hash_records, association,
                               host_table: host_table, schema: schema, as: as,
                               order_by: order_by, limit: limit
+
+    @associations << association
+
     materialize
   end
 
@@ -64,7 +68,7 @@ class ::Simple::SQL::Result::Records < ::Simple::SQL::Result
 
   def materialize
     records = @hash_records
-    records = RowConverter.convert_ary(records, into: @target_type) if @target_type != Hash
+    records = RowConverter.convert_row(records, associations: @associations, into: @target_type) if @target_type != Hash
     replace(records)
   end
 end

data/lib/simple/sql/version.rb

@@ -1,5 +1,5 @@
 module Simple
   module SQL
-    VERSION = "0.4.12"
+    VERSION = "0.4.13"
   end
 end

data/spec/simple/sql_associations_spec.rb

@@ -134,6 +134,16 @@ describe "Simple::SQL::Result#preload" do
 
       expect(organizations.first.users.first).to be_a(OpenStruct)
     end
+
+    it "only touches associations, leaving non-associated hashes and arrays alone" do
+      organizations = SQL.all "SELECT id, ARRAY[10000] AS ary FROM organizations", into: OpenStruct
+      expect(organizations.first.ary).to eq([10000])
+    end
+
+    it "only touches associations, leaving non-associated hashes and arrays alone" do
+      organizations = SQL.all "SELECT id, ARRAY[10000] AS ary FROM organizations", into: :struct
+      expect(organizations.first.ary).to eq([10000])
+    end
   end
 
   describe ":order_by" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: simple-sql
 version: !ruby/object:Gem::Version
-  version: 0.4.12
+  version: 0.4.13
 platform: ruby
 authors:
 - radiospiel