simple-sql 0.4.11 → 0.4.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA256:
-  metadata.gz: 4f506a9925d4e81450d698169f04c60b69ca2191e1a353bbaa13b76a0ca48055
-  data.tar.gz: c2e9f14973dfdab36c1e49da800f4ae2e6e571e567338ebcc2be627f114938c3
+SHA1:
+  metadata.gz: 219be87ab80103dce585c2c71a8be92dc8274448
+  data.tar.gz: aacb51c639d27d3348695c075a9e1e12c27fe915
 SHA512:
-  metadata.gz: 73d9bf9e990411871d8ed7d4f7a6a7d803aab52466387000441bcd777a35073ec6a6a9f5ff878e96e35d6ce469e5ddfcae5ec3de625b0024b5f6522dce1c8c9b
-  data.tar.gz: 75e21099aa4181e6fec9b7aa5919dd964ad271b4d20e0908f32de8fd7b6b150a7647162b946f376473303aa7d11bfc58a1132d91db19fa6a18f4f23a014bfd36
+  metadata.gz: 1f8250eac83d27aa869fdc01814f1c565e71470d8805b876eac12c875466f780341259ee9e6f10f84e27a0f3dada384a2044c109267c5c8bcf34d4eb2d14ffcd
+  data.tar.gz: 4260387271f5c4ab8e25d6bdc4d457a94412453598f0e4ce876800a89db0862871950efe9849ed1f5823c1bce8727f47d81df81f4c28ed4c0851c8cefe6c8405

data/lib/simple/sql/connection_adapter.rb

@@ -41,7 +41,7 @@ module Simple::SQL::ConnectionAdapter
     #
     # Even if into is set to something different than a Hash, we'll convert
     # each row into a Hash initially, and only later convert it to the final
-    # target type (via RowConverter.convert). This is to allow to fill in
+    # target type (via RowConverter.convert_ary). This is to allow to fill in
     # more entries later on.
     records = enumerate(pg_result, into: into)
 

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

@@ -1,14 +1,46 @@
-module Simple::SQL::Helpers::RowConverter
+module Simple::SQL::Helpers::RowConverter # :private:
+  SELF = self
+
   # returns an array of converted records
-  def self.convert(records, into:)
+  def self.convert_ary(records, into:)
     hsh = records.first
     return records unless hsh
 
-    if into == :struct
-      converter = StructConverter.for(attributes: hsh.keys)
-      records.map { |record| converter.convert(record) }
-    else
-      records.map { |record| into.new(record) }
+    converter = if into == :struct
+                  StructConverter.for(attributes: hsh.keys)
+                else
+                  TypeConverter.for(type: into)
+                end
+
+    records.map { |record| converter.convert_ary(record) }
+  end
+
+  def self.convert(record, into:) # :nodoc:
+    ary = convert_ary([record], into: into)
+    ary.first
+  end
+
+  class TypeConverter #:nodoc:
+    def self.for(type:)
+      new(type: type)
+    end
+
+    def initialize(type:)
+      @type = type
+    end
+
+    def convert_ary(hsh)
+      updates = {}
+      hsh.each do |key, value|
+        case value
+        when Hash   then updates[key] = SELF.convert(value, into: @type)
+        when Array  then updates[key] = SELF.convert_ary(value, into: @type)
+        end
+      end
+
+      hsh = hsh.merge(updates)
+
+      @type.new hsh
     end
   end
 
@@ -18,16 +50,25 @@ module Simple::SQL::Helpers::RowConverter
       @cache[attributes] ||= new(attributes)
     end
 
-    private
-
     def initialize(attributes)
       @klass = Struct.new(*attributes)
     end
 
-    public
-
-    def convert(hsh)
+    def convert_ary(hsh)
       values = hsh.values_at(*@klass.members)
+      updates = {}
+
+      values.each_with_index do |value, idx|
+        case value
+        when Hash   then updates[idx] = SELF.convert(value, into: :struct)
+        when Array  then updates[idx] = SELF.convert_ary(value, into: :struct)
+        end
+      end
+
+      updates.each do |idx, updated_value|
+        values[idx] = updated_value
+      end
+
       @klass.new(*values)
     end
   end

data/lib/simple/sql/result.rb

@@ -1,27 +1,69 @@
+# rubocop:disable Metrics/AbcSize
+# rubocop:disable Naming/AccessorMethodName
+
 require_relative "helpers"
 
 class ::Simple::SQL::Result < Array
 end
 
-require_relative "result/rows"
 require_relative "result/records"
 
 # The result of SQL.all
 #
-# This class implements the interface of a Result.
+# This class implements the basic interface of a Result set. Record result sets
+# support the conversion of a record into a custom type of the callers choice,
+# via the :into option for <tt>SQL.all</tt> and <tt>SQL.ask</tt>.
+#
+#
 class ::Simple::SQL::Result < Array
   # A Result object is requested via ::Simple::SQL::Result.build, which then
   # chooses the correct implementation, based on the <tt>target_type:</tt>
   # parameter.
   def self.build(records, target_type:, pg_source_oid:) # :nodoc:
     if target_type.nil?
-      Rows.new(records)
+      new(records)
     else
       Records.new(records, target_type: target_type, pg_source_oid: pg_source_oid)
     end
   end
 
+  def initialize(records) # :nodoc:
+    replace(records)
+  end
+
+  # returns the total_count of search hits
+  #
+  # This is filled in when resolving a paginated scope.
   attr_reader :total_count
+
+  # returns the total number of pages of search hits
+  #
+  # This is filled in when resolving a paginated scope. It takes
+  # into account the scope's "per" option.
   attr_reader :total_pages
+
+  # returns the current page number in a paginated search
+  #
+  # This is filled in when resolving a paginated scope.
   attr_reader :current_page
+
+  private
+
+  def set_pagination_info(scope)
+    raise ArgumentError, "per must be > 0" unless scope.per > 0
+
+    if scope.page <= 1 && empty?
+      # This branch is an optimization: the call to the database to count is
+      # not necessary if we know that there are not even any results on the
+      # first page.
+      @total_count  = 0
+      @current_page = 1
+    else
+      sql = "SELECT COUNT(*) FROM (#{scope.order_by(nil).to_sql(pagination: false)}) simple_sql_count"
+      @total_count = ::Simple::SQL.ask(sql, *scope.args)
+      @current_page = scope.page
+    end
+
+    @total_pages = (@total_count * 1.0 / scope.per).ceil
+  end
 end

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

@@ -103,17 +103,16 @@ module ::Simple::SQL::Result::AssociationLoader # :nodoc:
 
   # preloads a has_one or has_many association.
   def preload_has_one_or_many(records, relation, as:, order_by:, limit:)
-    if limit
-      # To really make sense limit must be implemented using window
-      # functions, because one (or, at lieast, I) would expect this code
-      #
-      #   organizations = SQL.all "SELECT * FROM organizations", into: Hash
-      #   organizations.preload :users, limit: 2, order_by: "id DESC"
-      #
-      # to return up to two users **per organization**.
-      #
-      raise "Support for limit: is not implemented yet!"
-    end
+    # To really make sense limit must be implemented using window
+    # functions, because one (or, at lieast, I) would expect this code
+    #
+    #   organizations = SQL.all "SELECT * FROM organizations", into: Hash
+    #   organizations.preload :users, limit: 2, order_by: "id DESC"
+    #
+    # to return up to two users **per organization**.
+    #
+    raise "Support for limit: is not implemented yet!" if limit
+    raise "Support for order_by: is not implemented yet!" if order_by && as.to_s.singularize == as.to_s
 
     belonging_column  = relation.belonging_column.to_sym
     having_column     = relation.having_column.to_sym

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

@@ -2,7 +2,7 @@
 
 require_relative "association_loader"
 
-class ::Simple::SQL::Result::Records < ::Simple::SQL::Result::Rows
+class ::Simple::SQL::Result::Records < ::Simple::SQL::Result
   def initialize(records, target_type:, pg_source_oid:) # :nodoc:
     expect! records.first => Hash unless records.empty?
 
@@ -64,8 +64,7 @@ class ::Simple::SQL::Result::Records < ::Simple::SQL::Result::Rows
 
   def materialize
     records = @hash_records
-    records = RowConverter.convert(records, into: @target_type) if @target_type != Hash
-
+    records = RowConverter.convert_ary(records, 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.11"
+    VERSION = "0.4.12"
   end
 end

data/spec/simple/sql_associations_spec.rb

@@ -66,7 +66,7 @@ describe "Simple::SQL::Result#preload" do
     it "detects a has_one association" do
       organizations = SQL.all "SELECT * FROM organizations", into: Hash
       organizations.preload :user
-  
+
       organization = organizations.first
       users_of_organization = SQL.all "SELECT * FROM users WHERE organization_id=$1", organization[:id], into: Hash
       expect(users_of_organization).to include(organization[:user])
@@ -94,13 +94,48 @@ describe "Simple::SQL::Result#preload" do
       organizations = SQL.all "SELECT * FROM organizations", into: Hash
       organizations.preload :user, as: :usr
       expect(organizations.first.keys).not_to include(:user)
-  
+
       organization = organizations.first
       users_of_organization = SQL.all "SELECT * FROM users WHERE organization_id=$1", organization[:id], into: Hash
       expect(users_of_organization).to include(organization[:usr])
     end
   end
 
+
+  describe ":into option" do
+    it "creates a :struct for singular association" do
+      users = SQL.all "SELECT * FROM users WHERE organization_id=$1", org1.id, into: :struct
+      users.preload :organization
+
+      expect(users.first.class.superclass).to eq(Struct)
+      expect(users.first.organization.class.superclass).to eq(Struct)
+    end
+
+    it "creates a :struct for array associations" do
+      organizations = SQL.all "SELECT * FROM organizations", into: :struct
+      organizations.preload :users
+      expect(organizations.first.class.superclass).to eq(Struct)
+
+      expect(organizations.first.users.first.class.superclass).to eq(Struct)
+    end
+
+    it "creates a OpenStruct for singular association" do
+      users = SQL.all "SELECT * FROM users WHERE organization_id=$1", org1.id, into: OpenStruct
+      users.preload :organization
+
+      expect(users.first).to be_a(OpenStruct)
+      expect(users.first.organization).to be_a(OpenStruct)
+    end
+
+    it "creates a OpenStruct for array associations" do
+      organizations = SQL.all "SELECT * FROM organizations", into: OpenStruct
+      organizations.preload :users
+      expect(organizations.first).to be_a(OpenStruct)
+
+      expect(organizations.first.users.first).to be_a(OpenStruct)
+    end
+  end
+
   describe ":order_by" do
     it "supports order_by" do
       organizations = SQL.all "SELECT * FROM organizations", into: Hash
@@ -110,11 +145,11 @@ describe "Simple::SQL::Result#preload" do
       ordered_user_ids = SQL.all("SELECT id FROM users WHERE organization_id=$1 ORDER BY id", organizations.first[:id])
       expect(users.pluck(:id)).to eq(ordered_user_ids)
     end
-    
+
     it "supports order_by DESC" do
       organizations = SQL.all "SELECT * FROM organizations", into: Hash
       organizations.preload :users, order_by: "id DESC"
-      users = organizations.first[:users] 
+      users = organizations.first[:users]
 
       ordered_user_ids = SQL.all("SELECT id FROM users WHERE organization_id=$1 ORDER BY id", organizations.first[:id])
       expect(users.pluck(:id)).to eq(ordered_user_ids.reverse)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: simple-sql
 version: !ruby/object:Gem::Version
-  version: 0.4.11
+  version: 0.4.12
 platform: ruby
 authors:
 - radiospiel
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-08-10 00:00:00.000000000 Z
+date: 2018-08-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg_array_parser
@@ -196,7 +196,6 @@ files:
 - lib/simple/sql/result.rb
 - lib/simple/sql/result/association_loader.rb
 - lib/simple/sql/result/records.rb
-- lib/simple/sql/result/rows.rb
 - lib/simple/sql/scope.rb
 - lib/simple/sql/scope/filters.rb
 - lib/simple/sql/scope/order.rb
@@ -244,7 +243,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.7
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: SQL with a simple interface

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

@@ -1,30 +0,0 @@
-# rubocop:disable Metrics/AbcSize
-# rubocop:disable Naming/AccessorMethodName
-
-class ::Simple::SQL::Result::Rows < ::Simple::SQL::Result
-  def initialize(records)
-    replace(records)
-  end
-
-  # -- pagination info ------------------------------------------------------
-
-  private
-
-  def set_pagination_info(scope)
-    raise ArgumentError, "per must be > 0" unless scope.per > 0
-
-    if scope.page <= 1 && empty?
-      # This branch is an optimization: the call to the database to count is
-      # not necessary if we know that there are not even any results on the
-      # first page.
-      @total_count  = 0
-      @current_page = 1
-    else
-      sql = "SELECT COUNT(*) FROM (#{scope.order_by(nil).to_sql(pagination: false)}) simple_sql_count"
-      @total_count = ::Simple::SQL.ask(sql, *scope.args)
-      @current_page = scope.page
-    end
-
-    @total_pages = (@total_count * 1.0 / scope.per).ceil
-  end
-end