simple-sql 0.4.23 → 0.4.24

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 27cc3b86bf4e72218ecc962cea6700d9a58e6a8ef594e15bfad16125bba792aa
-  data.tar.gz: c4642ed511a3dd94511d6a56b9c22e5bce830e15a6ecb3e2ed3a74d192253e56
+  metadata.gz: 11f161fabbc3c7a0079e8e82288ed819bd75ac07f37a0c8a378032c9a9ca0b4c
+  data.tar.gz: 1792494b7417826ef4fe16523d3afb1bbd670d23db69be55ffeebc00adbcee6b
 SHA512:
-  metadata.gz: 886016b412df3e5ad6d3eead65a1c1c81fe8c6eb98d868f2ae479a6c18b333d68f7661a21e17a566e7cfc151d8c844fca297c86bb7170ca423ff3d97a6bace12
-  data.tar.gz: a651642b76dea15fe5d56c2311576a24d2992aa07d255aab244735c392fe7d9465a93aa255479ba2544e115162bf54b15378d718af40849d3645fbe8338eb051
+  metadata.gz: df9ac5a0c455dc17fc20e36c79e5905667f37c9dfe3a3b11debdbcd612ff4d64c84b8ebcf1a4e1a2c0e585a83623ca052c92a2e22dfb042a19be4bf553a7e40b
+  data.tar.gz: fcfe42ddfad18c3d0a019a07b3bd124595d0db5e64ac16e3c8244ac00ae3faad4e851915c74fd5418fb8b8285045c0338cf548638ad4446b8d3f683d3c87f180

data/lib/simple/sql/connection_adapter.rb

@@ -32,29 +32,36 @@ module Simple::SQL::ConnectionAdapter
   # end
 
   def all(sql, *args, into: nil, &block)
-    pg_result = exec_logged(sql, *args)
+    raise ArgumentError, "all no longer support blocks, use each instead." if block
+    rows = []
+    my_pg_source_oid = nil
 
-    # enumerate the rows in pg_result. This returns either an Array of Hashes
-    # (if into is set), or an array of row arrays or of singular values.
-    #
-    # 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_ary). This is to allow to fill in
-    # more entries later on.
-    records = enumerate(pg_result, into: into)
+    each_without_conversion(sql, *args, into: into) do |row, pg_source_oid|
+      rows << row
+      my_pg_source_oid = pg_source_oid
+    end
 
-    # optimization: If we wouldn't clear here the GC would do this later.
-    pg_result.clear unless pg_result.autoclear?
+    record_set = convert_rows_to_result rows, into: into, pg_source_oid: my_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?(Scope) && sql.paginated?
-      records.send(:set_pagination_info, sql)
+      record_set.send(:set_pagination_info, sql)
     end
 
-    records.each(&block) if block
-    records
+    record_set
+  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
+      yield record
+    end
+
+    self
   end
 
   # Runs a query and prints the results via "table_print"
@@ -76,7 +83,7 @@ module Simple::SQL::ConnectionAdapter
   #   returns an array <tt>[ <id>, <email> ]</tt> (or +nil+)
   def ask(sql, *args, into: nil)
     catch(:ok) do
-      all(sql, *args, into: into) { |row| throw :ok, row }
+      each(sql, *args, into: into) { |row| throw :ok, row }
       nil
     end
   end
@@ -88,16 +95,16 @@ module Simple::SQL::ConnectionAdapter
   #
   # - <tt>Simple::SQL.locked(4711) { puts 'do work while locked' }
   def locked(lock_id)
-    begin
-      ask("SELECT pg_advisory_lock(#{lock_id})")
-      yield
-    ensure
-      ask("SELECT pg_advisory_unlock(#{lock_id})")
-    end
+    ask("SELECT pg_advisory_lock(#{lock_id})")
+    yield
+  ensure
+    ask("SELECT pg_advisory_unlock(#{lock_id})")
   end
 
   private
 
+  Result = ::Simple::SQL::Result
+  Decoder = ::Simple::SQL::Helpers::Decoder
   Encoder = ::Simple::SQL::Helpers::Encoder
 
   def exec_logged(sql_or_scope, *args)
@@ -115,20 +122,28 @@ module Simple::SQL::ConnectionAdapter
     end
   end
 
-  Result = ::Simple::SQL::Result
-  Decoder = ::Simple::SQL::Helpers::Decoder
-
-  def enumerate(pg_result, into:)
-    records = []
-    pg_source_oid = nil
+  def each_without_conversion(sql, *args, into: nil)
+    pg_result = exec_logged(sql, *args)
 
     if pg_result.ntuples > 0 && pg_result.nfields > 0
       decoder = Decoder.new(self, pg_result, into: (into ? Hash : nil))
-      pg_result.each_row { |row| records << decoder.decode(row) }
       pg_source_oid = pg_result.ftable(0)
+
+      pg_result.each_row do |row|
+        yield decoder.decode(row), pg_source_oid
+      end
     end
 
-    Result.build(records, target_type: into, pg_source_oid: pg_source_oid)
+    # optimization: If we wouldn't clear here the GC would do this later.
+    pg_result.clear unless 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
+  end
+
+  def convert_rows_to_result(rows, into:, pg_source_oid:)
+    Result.build(rows, target_type: into, pg_source_oid: pg_source_oid)
   end
 
   public

data/lib/simple/sql/version.rb

@@ -1,5 +1,5 @@
 module Simple
   module SQL
-    VERSION = "0.4.23"
+    VERSION = "0.4.24"
   end
 end

data/simple-sql.gemspec

@@ -42,4 +42,6 @@ Gem::Specification.new do |gem|
   gem.add_development_dependency 'database_cleaner', '~> 1'
   gem.add_development_dependency 'simplecov', '~> 0'
   gem.add_development_dependency 'awesome_print', '~> 0'
+
+  gem.add_development_dependency 'memory_profiler', '~> 0.9.12'
 end

data/spec/simple/sql/all_into_spec.rb

@@ -15,23 +15,6 @@ describe "Simple::SQL.ask into: :struct" 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

data/spec/simple/sql/each_spec.rb

@@ -0,0 +1,148 @@
+require "spec_helper"
+
+describe "Simple::SQL.each" do
+  context "when called without a block " do
+    it "raises an ArgumentError" do
+      expect {
+        SQL.each("SELECT id FROM users", into: Hash)
+      }.to raise_error(ArgumentError)
+    end
+  end
+
+  def generate_users!
+    1.upto(USER_COUNT).map { create(:user) }
+  end
+  
+  def each!(sql, into: nil)
+    @received = nil
+    SQL.each(sql, into: into) do |id|
+      @received ||= []
+      @received << id
+    end
+  end
+
+  let(:received) { @received }
+
+  describe "each into: nil" do
+    before { generate_users! }
+    context "when called with matches" do
+      it "receives rows as arrays" do
+        each! "SELECT id, id FROM users ORDER BY id"
+
+        expect(received).to eq(1.upto(USER_COUNT).map { |i| [ i,i ]})
+      end
+
+      it "receives single item row as individual objects" do
+        each! "SELECT id FROM users ORDER BY id"
+
+        expect(received).to eq(1.upto(USER_COUNT).to_a)
+      end
+    end
+
+    context 'when called with no matches' do
+      it "does not yield" do
+        each! "SELECT id FROM users WHERE FALSE"
+        expect(received).to be_nil
+      end
+    end
+  end
+  
+  describe "each into: <something>" do
+    before { generate_users! }
+
+    it "receives rows as Hashes" do
+      each! "SELECT id, id AS dupe FROM users ORDER BY id", into: Hash
+
+      expect(received).to eq(1.upto(USER_COUNT).map { |i| { id: i, dupe: i }})
+    end
+
+    it "receives rows as immutable" do
+      each! "SELECT id, id AS dupe FROM users ORDER BY id", into: :immutable
+
+      expect(received.first.id).to eq(1)
+      expect(received[1].dupe).to eq(2)
+      expect(received.map(&:class).uniq).to eq([Simple::SQL::Helpers::Immutable])
+    end
+  end
+  
+  xdescribe "memory usage: pending due to inconclusive results" do
+    it "generates a series" do
+      each! "SELECT a.n from generate_series(1, 100) as a(n)"
+      expect(received).to eq((1..100).to_a)
+    end
+
+    require 'memory_profiler'
+    
+    def measure_retained_objects(msg, &block)
+      r = nil
+      report = MemoryProfiler.report do
+        r = yield
+      end
+      
+      STDERR.puts "#{msg} Total allocated: #{report.total_allocated_memsize} bytes (#{report.total_allocated} objects)"
+      STDERR.puts "#{msg} Total retained:  #{report.total_retained_memsize} bytes (#{report.total_retained} objects)"
+
+      report.total_retained_memsize
+    end
+
+    it "is using less memory than .all" do
+      sql_warmup = "SELECT a.n from generate_series(10000, 100) as a(n)"
+
+        SQL.all(sql_warmup, into: Hash)
+
+        SQL.each(sql_warmup) do |id|
+          :nop
+        end
+
+      cnt = 1000000
+      sql = "SELECT a.n from generate_series(#{cnt}, #{cnt}) as a(n)"
+
+      r = nil
+      retained_objects_all = measure_retained_objects "all" do
+        r = SQL.all(sql, into: Hash)
+      end
+
+      retained_objects_each = measure_retained_objects "each"  do
+        r = SQL.each(sql) do |id|
+          :nop
+        end
+      end
+      
+      expect(0).to eq "one"
+    end
+  end
+end
+
+__END__
+
+  describe "each 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
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: simple-sql
 version: !ruby/object:Gem::Version
-  version: 0.4.23
+  version: 0.4.24
 platform: ruby
 authors:
 - radiospiel
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-11-29 00:00:00.000000000 Z
+date: 2018-12-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg_array_parser
@@ -165,6 +165,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: memory_profiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.12
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.12
 description: SQL with a simple interface. Postgres only.
 email: eno@radiospiel.org
 executables: []
@@ -218,6 +232,7 @@ files:
 - spec/simple/sql/conversion_spec.rb
 - spec/simple/sql/duplicate_spec.rb
 - spec/simple/sql/duplicate_unique_spec.rb
+- spec/simple/sql/each_spec.rb
 - spec/simple/sql/insert_spec.rb
 - spec/simple/sql/reflection_spec.rb
 - spec/simple/sql/scope_spec.rb
@@ -262,6 +277,7 @@ test_files:
 - spec/simple/sql/conversion_spec.rb
 - spec/simple/sql/duplicate_spec.rb
 - spec/simple/sql/duplicate_unique_spec.rb
+- spec/simple/sql/each_spec.rb
 - spec/simple/sql/insert_spec.rb
 - spec/simple/sql/reflection_spec.rb
 - spec/simple/sql/scope_spec.rb