simple-sql 0.4.41 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 55d19f3d2101b740d88d0e4d668ffbeb40be5ab0e853d9804d2f055e7322b6aa
-  data.tar.gz: b3e5c916d99d64527c0e4e81c50577c4f3d6e9750510e12af93c8682950abea3
+  metadata.gz: f7a208873c084434a4267d43cfd76ccae14aa249e7ce2cd40de78e76fe4d0df8
+  data.tar.gz: c6c961737c2ebd4b57b5ab7946b872f229e63a8c22c275177825a8bcb5301cef
 SHA512:
-  metadata.gz: dfc817694c9c76a10f25879b487c20eeff2bfbef14e206e4dcda17e157e4057542712784328b84b103704d31628a0f4d041cd90f77d8c3683d3af889e32226ee
-  data.tar.gz: b881bf24697cc7b32c55fec07a98cacae2569355cc33cceca0bb023ca7cc19cd69746bad28eea7ee64fbaff0040b9ddea84b3e1c130bc728c953a63709768c84
+  metadata.gz: 2c5c053640e50ba398acf014f855fb28ea369bdd7806ae7a564f69ce87f1d7323dd58ced4ca9a77bd6e7a595266f16754a5de5d0ce6efc0f24fd29b2ea2acb39
+  data.tar.gz: af48f5add33e6330a526ec2d6486579f84f2e1b2fb7ee0d03aff0a0d65723da07ea8c5932978c26db6cf005aee2627c02ebb7c2b4ba273ad909c95fd0fa8b4bb

data/lib/simple/sql.rb

@@ -21,7 +21,7 @@ module Simple
     extend self
 
     extend Forwardable
-    delegate [:ask, :all, :each, :exec, :locked, :print, :transaction, :wait_for_notify, :costs] => :default_connection
+    delegate [:ask, :all, :each, :exec, :locked, :print, :transaction, :wait_for_notify] => :default_connection
 
     delegate [:logger, :logger=] => ::Simple::SQL::Logging
 
@@ -35,11 +35,6 @@ module Simple
       Connection.create(database_url)
     end
 
-    # deprecated
-    def configuration
-      Config.parse_url(Config.determine_url)
-    end
-
     # -- default connection ---------------------------------------------------
 
     DEFAULT_CONNECTION_KEY = :"Simple::SQL.default_connection"

data/lib/simple/sql/connection_adapter.rb

@@ -90,16 +90,6 @@ module Simple::SQL::ConnectionAdapter
     end
   end
 
-  # returns an Array [min_cost, max_cost] based on the database's estimation
-  def costs(sql, *args)
-    explanation_first = Simple::SQL.ask "EXPLAIN #{sql}", *args
-    unless explanation_first =~ /cost=(\d+(\.\d+))\.+(\d+(\.\d+))/
-      raise "Cannot determine cost"
-    end
-
-    [Float($1), Float($3)]
-  end
-
   # Executes a block, usually of db insert code, while holding an
   # advisory lock.
   #

data/lib/simple/sql/logging.rb

@@ -50,7 +50,7 @@ module Simple
       end
 
       def slow_query_treshold=(slow_query_treshold)
-        expect! slow_query_treshold.nil? || slow_query_treshold > 0
+        expect! slow_query_treshold > 0
         @slow_query_treshold = slow_query_treshold
       end
 

data/lib/simple/sql/result.rb

@@ -1,6 +1,5 @@
+# rubocop:disable Metrics/AbcSize
 # rubocop:disable Naming/AccessorMethodName
-# rubocop:disable Style/DoubleNegation
-# rubocop:disable Style/GuardClause
 
 require_relative "helpers"
 
@@ -32,67 +31,39 @@ class ::Simple::SQL::Result < Array
     replace(records)
   end
 
-  # returns the (potentialy estimated) total count of results
+  # returns the total_count of search hits
   #
-  # This is only available for paginated scopes
-  def total_fast_count
-    @total_fast_count ||= pagination_scope.fast_count
-  end
-
-  # returns the (potentialy estimated) total number of pages
-  #
-  # This is only available for paginated scopes
-  def total_fast_pages
-    @total_fast_pages ||= (total_fast_count * 1.0 / pagination_scope.per).ceil
-  end
-
-  # returns the (potentialy slow) exact total count of results
-  #
-  # This is only available for paginated scopes
-  def total_count
-    @total_count ||= pagination_scope.count
-  end
+  # This is filled in when resolving a paginated scope.
+  attr_reader :total_count
 
-  # returns the (potentialy estimated) total number of pages
+  # returns the total number of pages of search hits
   #
-  # This is only available for paginated scopes
-  def total_pages
-    @total_pages ||= (total_count * 1.0 / pagination_scope.per).ceil
-  end
+  # 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 only available for paginated scopes
-  def current_page
-    @current_page ||= pagination_scope.page
-  end
-
-  def paginated?
-    !!@pagination_scope
-  end
+  # This is filled in when resolving a paginated scope.
+  attr_reader :current_page
 
   private
 
-  def pagination_scope
-    raise "Only available only for paginated scopes" unless paginated?
-
-    @pagination_scope
-  end
-
   def set_pagination_info(scope)
     raise ArgumentError, "per must be > 0" unless scope.per > 0
 
-    @pagination_scope = scope
-
-    # 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.
     if scope.page <= 1 && empty?
-      @current_page = 1
+      # 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
-      @total_pages  = 1
-      @total_fast_count  = 0
-      @total_fast_pages  = 1
+      @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

@@ -3,8 +3,6 @@
 require_relative "scope/filters.rb"
 require_relative "scope/order.rb"
 require_relative "scope/pagination.rb"
-require_relative "scope/count.rb"
-require_relative "scope/count_by_groups.rb"
 
 # The Simple::SQL::Scope class helps building scopes; i.e. objects
 # that start as a quite basic SQL query, and allow one to add
@@ -26,11 +24,11 @@ class Simple::SQL::Scope
   #
   #     Simple::SQL::Scope.new(table: "mytable", select: "*", where: { id: 1, foo: "bar" }, order_by: "id desc")
   #
-  def initialize(sql, args = [])
+  def initialize(sql)
     expect! sql => [String, Hash]
 
     @sql     = nil
-    @args    = args
+    @args    = []
     @filters = []
 
     case sql

data/lib/simple/sql/version.rb

@@ -1,5 +1,5 @@
 module Simple
   module SQL
-    VERSION = "0.4.41"
+    VERSION = "0.5.0"
   end
 end

data/spec/spec_helper.rb

@@ -14,9 +14,7 @@ Dir.glob("./spec/support/**/*.rb").sort.each { |path| load path }
 require "simple/sql"
 
 unless ENV["USE_ACTIVE_RECORD"]
-  database_url = Simple::SQL::Config.determine_url
-
-  Simple::SQL.connect! database_url
+  Simple::SQL.connect!
   Simple::SQL.ask "DELETE FROM users"
 end
 

data/tasks/release.rake

@@ -61,7 +61,7 @@ namespace :release do
 
   desc "Push code and tags"
   task :push do
-    sh("git push origin #{$TARGET_BRANCH}")
+    sh('git push origin master')
     sh('git push --tags')
   end
 
@@ -71,37 +71,19 @@ namespace :release do
   end
 
   desc "Push Gem to gemfury"
-  task :publish do
+  task :push_to_rubygems do
     Dir.chdir(GEM_ROOT) { sh("gem push #{Dir.glob('*.gem').first}") }
   end
 
-  task :target_master do
-    $TARGET_BRANCH = 'master'
-  end
-
-  task :target_stable do
-    $TARGET_BRANCH = 'stable'
-  end
-
-  task :checkout do
-    sh "git status --untracked-files=no --porcelain > /dev/null || (echo '*** working dir not clean' && false)"
-    sh "git checkout #{$TARGET_BRANCH}"
-    sh "git pull"
-  end
-
   task default: [
-    'checkout',
     'version',
     'clean',
     'build',
     'commit',
     'push',
-    'publish'
+    'push_to_rubygems'
   ]
-
-  task master: %w(target_master default)
-  task stable: %w(target_stable default)
 end
 
 desc "Clean, build, commit and push"
-task release: 'release:master'
+task release: 'release:default'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: simple-sql
 version: !ruby/object:Gem::Version
-  version: 0.4.41
+  version: 0.5.0
 platform: ruby
 authors:
 - radiospiel
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-03-29 00:00:00.000000000 Z
+date: 2019-03-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg_array_parser
@@ -218,8 +218,6 @@ files:
 - lib/simple/sql/result/association_loader.rb
 - lib/simple/sql/result/records.rb
 - lib/simple/sql/scope.rb
-- lib/simple/sql/scope/count.rb
-- lib/simple/sql/scope/count_by_groups.rb
 - lib/simple/sql/scope/filters.rb
 - lib/simple/sql/scope/order.rb
 - lib/simple/sql/scope/pagination.rb
@@ -234,15 +232,11 @@ files:
 - spec/simple/sql/associations_spec.rb
 - spec/simple/sql/config_spec.rb
 - spec/simple/sql/conversion_spec.rb
-- spec/simple/sql/count_by_groups_spec.rb
-- spec/simple/sql/count_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/logging_spec.rb
 - spec/simple/sql/reflection_spec.rb
-- spec/simple/sql/result_count_spec.rb
 - spec/simple/sql/scope_spec.rb
 - spec/simple/sql/version_spec.rb
 - spec/simple/sql_locked_spec.rb
@@ -273,7 +267,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.2
+rubyforge_project: 
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: SQL with a simple interface
@@ -284,15 +279,11 @@ test_files:
 - spec/simple/sql/associations_spec.rb
 - spec/simple/sql/config_spec.rb
 - spec/simple/sql/conversion_spec.rb
-- spec/simple/sql/count_by_groups_spec.rb
-- spec/simple/sql/count_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/logging_spec.rb
 - spec/simple/sql/reflection_spec.rb
-- spec/simple/sql/result_count_spec.rb
 - spec/simple/sql/scope_spec.rb
 - spec/simple/sql/version_spec.rb
 - spec/simple/sql_locked_spec.rb

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

@@ -1,33 +0,0 @@
-class Simple::SQL::Scope
-  EXACT_COUNT_THRESHOLD = 10_000
-
-  # Returns the exact count of matching records
-  def count
-    sql = order_by(nil).to_sql(pagination: false)
-    ::Simple::SQL.ask("SELECT COUNT(*) FROM (#{sql}) _total_count", *args)
-  end
-
-  # Returns the fast count of matching records
-  #
-  # For counts larger than EXACT_COUNT_THRESHOLD this returns an estimate
-  def fast_count
-    estimate = estimated_count
-    return estimate if estimate > EXACT_COUNT_THRESHOLD
-
-    sql = order_by(nil).to_sql(pagination: false)
-    ::Simple::SQL.ask("SELECT COUNT(*) FROM (#{sql}) _total_count", *args)
-  end
-
-  private
-
-  def estimated_count
-    sql = order_by(nil).to_sql(pagination: false)
-    ::Simple::SQL.each("EXPLAIN #{sql}", *args) do |line|
-      next unless line =~ /\brows=(\d+)/
-
-      return Integer($1)
-    end
-
-    -1
-  end
-end

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

@@ -1,79 +0,0 @@
-# rubocop:disable Metrics/AbcSize
-# rubocop:disable Metrics/MethodLength
-
-class Simple::SQL::Scope
-  # Potentially fast implementation of returning all different values for a specific group.
-  #
-  # For example:
-  #
-  #   Scope.new("SELECT * FROM users").enumerate_groups("gender") -> [ "female", "male" ]
-  #
-  # It is possible to enumerate over multiple attributes, for example:
-  #
-  #   scope.enumerate_groups fragment: "ARRAY[workflow, queue]"
-  #
-  # In any case it is important that an index exists that the database can use to group
-  # by the +sql_fragment+, for example:
-  #
-  #   CREATE INDEX ix3 ON table((ARRAY[workflow, queue]));
-  #
-  def enumerate_groups(sql_fragment)
-    sql = order_by(nil).to_sql(pagination: false)
-
-    _, max_cost = ::Simple::SQL.costs "SELECT MIN(#{sql_fragment}) FROM (#{sql}) sq", *args
-    raise "enumerate_groups: takes too much time. Make sure to create a suitable index" if max_cost > 10_000
-
-    groups = []
-    var_name = "$#{@args.count + 1}"
-    cur = ::Simple::SQL.ask "SELECT MIN(#{sql_fragment}) FROM (#{sql}) sq", *args
-
-    while cur
-      groups << cur
-      cur = ::Simple::SQL.ask "SELECT MIN(#{sql_fragment}) FROM (#{sql}) sq"" WHERE #{sql_fragment} > #{var_name}", *args, cur
-    end
-
-    groups
-  end
-
-  def count_by(sql_fragment)
-    sql = order_by(nil).to_sql(pagination: false)
-
-    recs = ::Simple::SQL.all "SELECT #{sql_fragment} AS group, COUNT(*) AS count FROM (#{sql}) sq GROUP BY #{sql_fragment}", *args
-    Hash[recs]
-  end
-
-  def fast_count_by(sql_fragment)
-    sql = order_by(nil).to_sql(pagination: false)
-
-    _, max_cost = ::Simple::SQL.costs "SELECT COUNT(*) FROM (#{sql}) sq GROUP BY #{sql_fragment}", *args
-
-    return count_by(sql_fragment) if max_cost < 10_000
-
-    # iterate over all groups, estimating the count for each. If the count is
-    # less than EXACT_COUNT_THRESHOLD we ask for the exact count in that and
-    # similarily sparse groups.
-    var_name = "$#{@args.count + 1}"
-
-    counts = {}
-    sparse_groups = []
-    enumerate_groups(sql_fragment).each do |group|
-      scope = ::Simple::SQL::Scope.new("SELECT * FROM (#{sql}) sq WHERE #{sql_fragment}=#{var_name}", *args, group)
-      counts[group] = scope.send(:estimated_count)
-      sparse_groups << group if estimated_count < EXACT_COUNT_THRESHOLD
-    end
-
-    # fetch exact counts in all sparse_groups
-    unless sparse_groups.empty?
-      sparse_counts = ::Simple::SQL.all <<~SQL, *args, sparse_groups
-        SELECT #{sql_fragment} AS group, COUNT(*) AS count
-        FROM (#{sql}) sq
-        WHERE #{sql_fragment} = ANY(#{var_name})
-        GROUP BY #{sql_fragment}
-      SQL
-
-      counts.update Hash[sparse_counts]
-    end
-
-    counts
-  end
-end

data/spec/simple/sql/count_by_groups_spec.rb

@@ -1,44 +0,0 @@
-require "spec_helper"
-
-describe "Simple::SQL::Scope#count_by" do
-  let!(:users)        { 1.upto(10).map { |i| create(:user, role_id: i) } }
-  let(:all_role_ids)  { SQL.all("SELECT DISTINCT role_id FROM users") }
-  let(:scope)         { SQL::Scope.new("SELECT * FROM users") }
-
-  describe "enumerate_groups" do
-    it "returns all groups" do
-      expect(scope.enumerate_groups("role_id")).to contain_exactly(*all_role_ids)
-      expect(scope.where("role_id < 4").enumerate_groups("role_id")).to contain_exactly(*(1.upto(3).to_a))
-    end
-  end
-
-  describe "count_by" do
-    it "counts all groups" do
-      create(:user, role_id: 1)
-      create(:user, role_id: 1)
-      create(:user, role_id: 1)
-
-      expect(scope.count_by("role_id")).to include(1 => 4)
-      expect(scope.count_by("role_id")).to include(2 => 1)
-      expect(scope.count_by("role_id").keys).to contain_exactly(*all_role_ids)
-    end
-  end
-
-  describe "fast_count_by" do
-    before do
-      # 10_000 is chosen "magically". It is large enough to switch to the fast algorithm,
-      # but 
-      allow(::Simple::SQL).to receive(:costs).and_return([0, 10_000])
-    end
-    
-    it "counts all groups" do
-      create(:user, role_id: 1)
-      create(:user, role_id: 1)
-      create(:user, role_id: 1)
-
-      expect(scope.fast_count_by("role_id")).to include(1 => 4)
-      expect(scope.fast_count_by("role_id")).to include(2 => 1)
-      expect(scope.fast_count_by("role_id").keys).to contain_exactly(*all_role_ids)
-    end
-  end
-end

data/spec/simple/sql/count_spec.rb

@@ -1,29 +0,0 @@
-require "spec_helper"
-
-describe "Simple::SQL::Scope#count" do
-  let!(:users)      { 1.upto(USER_COUNT).map { create(:user) } }
-  let(:min_user_id) { SQL.ask "SELECT min(id) FROM users" }
-  let(:scope)       { SQL::Scope.new("SELECT * FROM users") }
-
-  describe "exact count" do
-    it "counts" do
-      expect(scope.count).to eq(USER_COUNT)
-    end
-
-    it "evaluates conditions" do
-      expect(scope.where("id < $1", min_user_id).count).to eq(0)
-      expect(scope.where("id <= $1", min_user_id).count).to eq(1)
-    end
-  end
-
-  describe "fast count" do
-    it "counts" do
-      expect(scope.fast_count).to eq(USER_COUNT)
-    end
-
-    it "evaluates conditions" do
-      expect(scope.where("id < $1", min_user_id).fast_count).to eq(0)
-      expect(scope.where("id <= $1", min_user_id).fast_count).to eq(1)
-    end
-  end
-end

data/spec/simple/sql/logging_spec.rb

@@ -1,16 +0,0 @@
-require "spec_helper"
-
-describe "Simple::SQL logging" do
-  context 'when running a slow query' do
-    before do
-      SQL::Logging.slow_query_treshold = 0.05
-    end
-    after do
-      SQL::Logging.slow_query_treshold = nil
-    end
-
-    it "does not crash" do
-      SQL.ask "SELECT pg_sleep(0.1)"
-    end
-  end
-end

data/spec/simple/sql/result_count_spec.rb

@@ -1,57 +0,0 @@
-require "spec_helper"
-
-describe "Simple::SQL::Result counts" do
-  let!(:users)          { 1.upto(USER_COUNT).map { create(:user) } }
-  let(:min_user_id)     { SQL.ask "SELECT min(id) FROM users" }
-  let(:scope)           { SQL::Scope.new("SELECT * FROM users") }
-  let(:paginated_scope) { scope.paginate(per: 1, page: 1) }
-
-  describe "exact counting" do
-    it "counts" do
-      result = SQL.all(paginated_scope)
-      expect(result.total_count).to eq(USER_COUNT)
-      expect(result.total_pages).to eq(USER_COUNT)
-      expect(result.current_page).to eq(1)
-    end
-  end
-  
-  describe "fast counting" do
-    it "counts fast" do
-      result = SQL.all(paginated_scope)
-
-      expect(result.total_fast_count).to eq(USER_COUNT)
-      expect(result.total_fast_pages).to eq(USER_COUNT)
-      expect(result.current_page).to eq(1)
-    end
-  end
-
-  context 'when running with a non-paginated paginated_scope' do
-    it "raises errors" do
-      result = SQL.all(scope)
-
-      expect { result.total_count }.to raise_error(RuntimeError)
-      expect { result.total_pages }.to raise_error(RuntimeError)
-      expect { result.current_page }.to raise_error(RuntimeError)
-      expect { result.total_fast_count }.to raise_error(RuntimeError)
-      expect { result.total_fast_pages }.to raise_error(RuntimeError)
-    end
-  end
-
-
-  context 'when running with an empty, paginated paginated_scope' do
-    let(:scope)           { SQL::Scope.new("SELECT * FROM users WHERE FALSE") }
-    let(:paginated_scope) { scope.paginate(per: 1, page: 1) }
-
-    it "returns correct results" do
-      result = SQL.all(paginated_scope)
-
-      expect(result.total_count).to eq(0)
-      expect(result.total_pages).to eq(1)
-
-      expect(result.total_fast_count).to eq(0)
-      expect(result.total_fast_pages).to eq(1)
-
-      expect(result.current_page).to eq(1)
-    end
-  end
-end