simple-sql 0.4.9 → 0.4.10

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

@@ -0,0 +1,72 @@
+# xrubocop:disable Metrics/ParameterLists
+
+require_relative "association_loader"
+
+class ::Simple::SQL::Result::Records < ::Simple::SQL::Result::Rows
+  def initialize(records, target_type:, pg_source_oid:) # :nodoc:
+    expect! records.first => Hash unless records.empty?
+
+    super(records)
+
+    @hash_records   = records
+    @target_type    = target_type
+    @pg_source_oid  = pg_source_oid
+
+    materialize
+  end
+
+  # -- preload associations -------------------------------------------------
+
+  AssociationLoader = ::Simple::SQL::Result::AssociationLoader
+
+
+  # Preloads an association.
+  #
+  # This can now be used as follows:
+  #
+  #     scope = SQL::Scope.new("SELECT * FROM users")
+  #     results = SQL.all scope, into: :struct
+  #     results.preload(:organization)
+  #
+  # The preload method uses foreign key definitions in the database to figure out
+  # which table to load from.
+  #
+  # This method is only available if <tt>into:</tt> was set in the call to <tt>SQL.all</tt>.
+  # It raises an error otherwise.
+  #
+  # Parameters:
+  #
+  # - association: the name of the association.
+  # - as: the target name of the association.
+  # - order_by: if set describes ordering; see Scope#order_by.
+  # - limit: if set describes limits; see Scope#order_by.
+  def preload(association, as: nil, order_by: nil, limit: nil)
+    expect! association => Symbol
+    expect! as => [nil, Symbol]
+
+    # resolve oid into table and schema name.
+    schema, host_table = SQL.ask <<~SQL, @pg_source_oid
+      SELECT nspname AS schema, relname AS host_table
+      FROM pg_class
+      JOIN pg_namespace ON pg_namespace.oid=pg_class.relnamespace
+      WHERE pg_class.oid=$1
+    SQL
+
+    AssociationLoader.preload @hash_records, association,
+                              host_table: host_table, schema: schema, as: as,
+                              order_by: order_by, limit: limit
+    materialize
+  end
+
+  private
+
+  # convert the records into the target type.
+  RowConverter = ::Simple::SQL::Helpers::RowConverter
+
+  def materialize
+    records = @hash_records
+    records = RowConverter.convert(records, into: @target_type) if @target_type != Hash
+
+    replace(records)
+  end
+end

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

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

data/lib/simple/sql/scope.rb

@@ -14,15 +14,51 @@ class Simple::SQL::Scope
   attr_reader :per, :page
 
   # Build a scope object
+  #
+  # This call supports a few variants:
+  #
+  #     Simple::SQL::Scope.new("SELECT * FROM mytable")
+  #     Simple::SQL::Scope.new(table: "mytable", select: "*")
+  #
+  # The second option also allows one to pass in more options, like the following:
+  #
+  #     Simple::SQL::Scope.new(table: "mytable", select: "*", where: { id: 1, foo: "bar" }, order_by: "id desc")
+  #
   def initialize(sql)
-    @sql = sql
-    @args = []
+    expect! sql => [String, Hash]
+
+    @sql     = nil
+    @args    = []
     @filters = []
-    @order_by = nil
+
+    case sql
+    when String then @sql = sql
+    when Hash then initialize_from_hash(sql)
+    end
   end
 
   private
 
+  # rubocop:disable Metrics/AbcSize
+  def initialize_from_hash(hsh)
+    actual_keys = hsh.keys
+    valid_keys = [:table, :select, :where, :order_by]
+    extra_keys = actual_keys - valid_keys
+    raise ArgumentError, "Extra keys #{extra_keys.inspect}; allowed are #{valid_keys.inspect}" unless extra_keys.empty?
+
+    # -- set table and select -------------------------------------------------
+
+    table = hsh[:table] || raise(ArgumentError, "Missing :table option")
+    select = hsh[:select] || "*"
+
+    @sql = "SELECT #{Array(select).join(', ')} FROM #{table}"
+
+    # -- apply conditions, if any ---------------------------------------------
+
+    where!(hsh[:where]) unless hsh[:where].nil?
+    order_by!(hsh[:order_by]) unless hsh[:order_by].nil?
+  end
+
   def duplicate
     dupe = SELF.new(@sql)
     dupe.instance_variable_set :@args, @args.dup
@@ -30,6 +66,7 @@ class Simple::SQL::Scope
     dupe.instance_variable_set :@per, @per
     dupe.instance_variable_set :@page, @page
     dupe.instance_variable_set :@order_by_fragment, @order_by_fragment
+    dupe.instance_variable_set :@limit, @limit
     dupe
   end
 
@@ -41,23 +78,9 @@ class Simple::SQL::Scope
 
     sql = @sql
     sql = apply_filters(sql)
-    sql = apply_order(sql)
+    sql = apply_order_and_limit(sql)
     sql = apply_pagination(sql, pagination: pagination)
 
     sql
   end
-
-  # The Scope::PageInfo module can be mixed into other objects to
-  # hold total_count, total_pages, and current_page.
-  module PageInfo
-    attr_reader :total_count, :total_pages, :current_page
-
-    def self.attach(results, total_count:, per:, page:)
-      results.extend(self)
-      results.instance_variable_set :@total_count, total_count
-      results.instance_variable_set :@total_pages, (total_count + (per - 1)) / per
-      results.instance_variable_set :@current_page, page
-      results
-    end
-  end
 end

data/lib/simple/sql/scope/order.rb

@@ -5,6 +5,10 @@ class Simple::SQL::Scope
     duplicate.send(:order_by!, sql_fragment)
   end
 
+  def limit(count)
+    duplicate.send(:limit!, count)
+  end
+
   private
 
   # Adjust sort order
@@ -13,9 +17,17 @@ class Simple::SQL::Scope
     self
   end
 
+  # Adjust sort order
+  def limit!(count)
+    @limit = count
+    self
+  end
+
   # called from to_sql
-  def apply_order(sql)
-    return sql unless @order_by_fragment
-    "#{sql} ORDER BY #{@order_by_fragment}"
+  def apply_order_and_limit(sql)
+    sql = "#{sql} ORDER BY #{@order_by_fragment}" if @order_by_fragment
+    sql = "#{sql} LIMIT #{@limit}" if @limit
+
+    sql
   end
 end

data/lib/simple/sql/simple_transactions.rb

@@ -1,4 +1,3 @@
-# rubocop:disable Metrics/MethodLength
 # rubocop:disable Style/IfUnlessModifier
 
 # private

data/lib/simple/sql/version.rb

@@ -1,5 +1,5 @@
 module Simple
   module SQL
-    VERSION = "0.4.9"
+    VERSION = "0.4.10"
   end
 end

data/simple-sql.gemspec

@@ -29,6 +29,7 @@ Gem::Specification.new do |gem|
 
   gem.add_dependency 'pg_array_parser', '~> 0'
   gem.add_dependency 'pg', '~> 0.20'
+  gem.add_dependency 'expectation', '~> 1'
 
   # optional gems (required by some of the parts)
 

data/spec/simple/sql_all_into_spec.rb

@@ -1,17 +1,76 @@
 require "spec_helper"
 
-describe "Simple::SQL.all into: argument" do
+describe "Simple::SQL.ask into: :struct" do
   let!(:users) { 1.upto(USER_COUNT).map { create(:user) } }
 
-  it "calls the database" do
-    r = SQL.all("SELECT * FROM users", into: Hash)
-    expect(r).to be_a(Array)
-    expect(r.length).to eq(USER_COUNT)
-    expect(r.map(&:class).uniq).to eq([Hash])
+  describe "all into: X" do
+    it "calls the database" do
+      r = SQL.all("SELECT id FROM users", into: Hash)
+      expect(r).to be_a(Array)
+      expect(r.length).to eq(USER_COUNT)
+      expect(r.map(&:class).uniq).to eq([Hash])
+    end
+
+    it "returns an empty array when there is no match" do
+      r = SQL.all("SELECT * FROM users WHERE FALSE", into: Hash)
+      expect(r).to eq([])
+    end
+
+    it "yields the results into a block" do
+      received = []
+      SQL.all("SELECT id FROM users", into: Hash) do |hsh|
+        received << hsh
+      end
+      expect(received.length).to eq(USER_COUNT)
+      expect(received.map(&:class).uniq).to eq([Hash])
+    end
+
+    it "does not yield if there is no match" do
+      received = []
+      SQL.all("SELECT id FROM users WHERE FALSE", into: Hash) do |hsh|
+        received << hsh
+      end
+      expect(received.length).to eq(0)
+    end
+  end
+
+  describe "into: :struct" do
+    it "calls the database" do
+      r = SQL.ask("SELECT COUNT(*) AS count FROM users", into: :struct)
+      expect(r.count).to eq(2)
+      expect(r.class.members).to eq([:count])
+    end
+
+    it "reuses the struct Class" do
+      r1 = SQL.ask("SELECT COUNT(*) AS count FROM users", into: :struct)
+      r2 = SQL.ask("SELECT COUNT(*) AS count FROM users", into: :struct)
+      expect(r1.class.object_id).to eq(r2.class.object_id)
+    end
+  end
+  
+  describe "into: Hash" do
+    it "calls the database" do
+      r = SQL.ask("SELECT COUNT(*) AS count FROM users", into: Hash)
+      expect(r).to eq({count: 2}) 
+    end
+
+    it "returns nil when there is no match" do
+      r = SQL.ask("SELECT * FROM users WHERE FALSE", into: Hash)
+      expect(r).to be_nil
+    end
   end
+  
+  describe "into: OpenStruct" do
+    it "returns a OpenStruct with into: OpenStruct" do
+      r = SQL.ask("SELECT COUNT(*) AS count FROM users", into: OpenStruct)
+      expect(r).to be_a(OpenStruct)
+      expect(r).to eq(OpenStruct.new(count: 2))
+    end
 
-  it "returns an empty array when there is no match" do
-    r = SQL.all("SELECT * FROM users WHERE FALSE", into: Hash)
-    expect(r).to eq([])
+    it "supports the into: option even with parameters" do
+      r = SQL.ask("SELECT $1::integer AS count FROM users", 2, into: OpenStruct)
+      expect(r).to be_a(OpenStruct)
+      expect(r).to eq(OpenStruct.new(count: 2))
+    end
   end
 end

data/spec/simple/sql_associations_spec.rb

@@ -0,0 +1,142 @@
+require "spec_helper"
+
+module ArrayPluck
+  refine Array do
+    def pluck(key)
+      map { |e| e.fetch(key) }
+    end
+  end
+end
+
+using ArrayPluck
+
+describe "Simple::SQL::Result#preload" do
+  let!(:org1)     { create(:organization) }
+  let!(:users1)   { 1.upto(USER_COUNT).map { create(:user, organization_id: org1.id) } }
+  let!(:org2)     { create(:organization) }
+  let!(:users2)   { 1.upto(USER_COUNT).map { create(:user, organization_id: org2.id) } }
+  let!(:users)    { 1.upto(USER_COUNT).map { create(:user) } }
+
+  # The block below checks that the factories are set up correctly.
+  describe "factories used in spec" do
+    it "builds correct objects" do
+      expect(org1.id).not_to eq(org2.id)
+      expect(users1.map(&:organization_id).uniq).to eq([org1.id])
+      expect(users2.map(&:organization_id).uniq).to eq([org2.id])
+      expect(users.map(&:organization_id).uniq).to eq([nil])
+    end
+  end
+
+  # describe "correctness" do
+  #   it "resolves a belongs_to association" do
+  #     users = SQL.all "SELECT * FROM users WHERE organization_id=$1", org1.id, into: Hash
+  #     users.preload :organization
+  #     expect(users.first[:organization]).to eq(org1.to_h)
+  #   end
+  #
+  #   it "resolves a has_many association" do
+  #     organizations = SQL.all "SELECT * FROM organizations", into: Hash
+  #     organizations.preload :users
+  #     expect(organizations.first[:users]).to eq(users1.map(&:to_h))
+  #   end
+  #
+  #   it "resolves 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])
+  #   end
+  # end
+
+  describe "automatic detection via foreign keys" do
+    it "detects a belongs_to association" do
+      users = SQL.all "SELECT * FROM users WHERE organization_id=$1", org1.id, into: Hash
+      users.preload :organization
+      expect(users.first[:organization]).to eq(org1.to_h)
+    end
+
+    it "detects a has_many association" do
+      organizations = SQL.all "SELECT * FROM organizations", into: Hash
+      organizations.preload :users
+      expect(organizations.first[:users]).to eq(users1.map(&:to_h))
+    end
+
+    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])
+    end
+  end
+
+  describe ":as option" do
+    it "renames a belongs_to association" do
+      users = SQL.all "SELECT * FROM users WHERE organization_id=$1", org1.id, into: Hash
+      users.preload :organization, as: :org
+
+      expect(users.first.keys).not_to include(:organization)
+      expect(users.first[:org]).to eq(org1.to_h)
+    end
+
+    it "renames a has_many association" do
+      organizations = SQL.all "SELECT * FROM organizations", into: Hash
+      organizations.preload :users, as: :members
+
+      expect(organizations.first.keys).not_to include(:users)
+      expect(organizations.first[:members]).to eq(users1.map(&:to_h))
+    end
+
+    it "detects a has_one association" 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 ":order_by" do
+    it "supports order_by" do
+      organizations = SQL.all "SELECT * FROM organizations", into: Hash
+      organizations.preload :users, order_by: "id"
+      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)
+    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] 
+
+      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)
+    end
+  end
+
+  describe ":limit" do
+    xit "limits the number of returned records" do
+      organizations = SQL.all "SELECT * FROM organizations", into: Hash
+      organizations.preload :users, limit: 1
+
+      expect(organizations.first[:users].length).to eq(1)
+    end
+
+    xit "limits the number of returned records" do
+      organizations = SQL.all "SELECT * FROM organizations", into: Hash
+      organizations.preload :users, limit: 2, order_by: "id"
+      users = organizations.first[:users]
+      expect(users.length).to eq(2)
+
+      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
+  end
+end