simple-sql 0.5.36 → 0.9.0

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

@@ -19,55 +19,113 @@ class Simple::SQL::Connection::Scope
   #
   def enumerate_groups(sql_fragment)
     sql = order_by(nil).to_sql(pagination: false)
+    @connection.all "SELECT DISTINCT #{sql_fragment} FROM (#{sql}) sq", *args
+  end
 
-    cost = @connection.estimate_cost "SELECT MIN(#{sql_fragment}) FROM (#{sql}) sq", *args
-
-    # cost estimates are good, but are hard to check against a hard coded value.
-    # see https://issues.mediafellows.com/issues/75232
-    #
-    # if cost > 10_000
-    #   raise "enumerate_groups(#{sql_fragment.inspect}) takes too much time. Make sure to create a suitable index"
-    # end
+  def count_by(sql_fragment)
+    expect! sql_fragment => String
 
-    groups = []
-    var_name = "$#{@args.count + 1}"
-    cur = @connection.ask "SELECT MIN(#{sql_fragment}) FROM (#{sql}) sq", *args
+    sql = order_by(nil).to_sql(pagination: false)
 
-    while cur
-      groups << cur
-      cur = @connection.ask "SELECT MIN(#{sql_fragment}) FROM (#{sql}) sq"" WHERE #{sql_fragment} > #{var_name}", *args, cur
+    recs = @connection.all "SELECT COUNT(*) AS count, #{sql_fragment} AS group FROM (#{sql}) sq GROUP BY #{sql_fragment}", *args
+
+    # if we count by a single value (e.g. `count_by("role_id")`) each entry in recs consists of an array [group_value, count].
+    # The resulting Hash will have entries of group_value => count.
+    if recs.first&.length == 2
+      recs.each_with_object({}) do |count_and_group, hsh|
+        count, group = *count_and_group
+        hsh[group] = count
+      end
+    else
+      recs.each_with_object({}) do |count_and_group, hsh|
+        count, *group = *count_and_group
+        hsh[group] = count
+      end
     end
-
-    groups
   end
 
-  def count_by(sql_fragment)
-    sql = order_by(nil).to_sql(pagination: false)
+  private
 
-    recs = @connection.all "SELECT #{sql_fragment} AS group, COUNT(*) AS count FROM (#{sql}) sq GROUP BY #{sql_fragment}", *args
-    Hash[recs]
+  # cost estimate threshold for count_by method. Can be set to false, true, or
+  # a number.
+  #
+  # Note that cost estimates are problematic, since they are not reported in
+  # any "real" unit, meaning any comparison really is a bit pointless.
+  COUNT_BY_ESTIMATE_COST_THRESHOLD = 10_000
+
+  # estimates the cost to run a sql query. If COUNT_BY_ESTIMATE_COST_THRESHOLD
+  # is set and the cost estimate is less than COUNT_BY_ESTIMATE_COST_THRESHOLD
+  # \a count_by_estimate is using the estimating code path.
+  def use_count_by_estimate?(sql_group_by_fragment)
+    case COUNT_BY_ESTIMATE_COST_THRESHOLD
+    when true then true
+    when false then false
+    else
+      # estimate the effort to exact counting over all groups.
+      base_sql  = order_by(nil).to_sql(pagination: false)
+      count_sql = "SELECT COUNT(*) FROM (#{base_sql}) sq GROUP BY #{sql_group_by_fragment}"
+      cost      = @connection.estimate_cost count_sql, *args
+
+      cost >= COUNT_BY_ESTIMATE_COST_THRESHOLD
+    end
   end
 
+  public
+
   def count_by_estimate(sql_fragment)
-    return count_by(sql_fragment)
+    expect! sql_fragment => String
 
-    # The code below runs an estimate on the effort to count by a group. This is currently
-    # disabled (see https://issues.mediafellows.com/issues/75237).
+    return count_by(sql_fragment) unless use_count_by_estimate?(sql_fragment)
 
-    sql = order_by(nil).to_sql(pagination: false)
-    cost = @connection.estimate_cost "SELECT COUNT(*) FROM (#{sql}) sq GROUP BY #{sql_fragment}", *args
+    # iterate over all groups, estimating the count for each.
+    #
+    # For larger groups we'll use that estimate - preventing a full table scan.
+    # Groups smaller than EXACT_COUNT_THRESHOLD are counted exactly - in the
+    # hope that this query can be answered from an index.
+
+    #
+    # Usually Simple::SQL.all normalizes each result row into its first value,
+    # if the row only consists of a single value. Here, however, we don't
+    # know the width of a group; so to understand this we just add a dummy
+    # value to the sql_fragment and then remove it again.
+    #
+    groups = enumerate_groups("1 AS __dummy__, #{sql_fragment}")
+    groups = groups.each(&:shift)
 
-    return count_by(sql_fragment) if cost < 10_000
+    # no groups? well, then...
+    return {} if groups.empty?
 
-    # 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}"
+    #
+    # The estimating code only works for groups of size 1. This is a limitation
+    # of simple-sql - for larger groups we would have to be able to encode arrays
+    # of arrays on their way to the postgres server. We are not able to do that
+    # currently.
+    #
+    group_size = groups.first&.length
+    if group_size > 1
+      return count_by(sql_fragment)
+    end
+
+    # The code below only works for groups of size 1
+    groups = groups.map(&:first)
+
+    #
+    # Now we estimate the count of entries in each group. For large groups we
+    # just use the estimate - because it is usually pretty close to being correct.
+    # Small groups are collected in the `sparse_groups` array, to be counted
+    # exactly later on.
+    #
 
     counts = {}
+
     sparse_groups = []
-    enumerate_groups(sql_fragment).each do |group|
-      scope = @connection.scope("SELECT * FROM (#{sql}) sq WHERE #{sql_fragment}=#{var_name}", *args, group)
+    base_sql = order_by(nil).to_sql(pagination: false)
+
+    var_name = "$#{@args.count + 1}"
+
+    groups.each do |group|
+      scope = @connection.scope("SELECT * FROM (#{base_sql}) sq WHERE #{sql_fragment}=#{var_name}", args + [group])
+
       estimated_count = scope.send(:estimated_count)
       counts[group] = estimated_count
       sparse_groups << group if estimated_count < EXACT_COUNT_THRESHOLD
@@ -77,7 +135,7 @@ class Simple::SQL::Connection::Scope
     unless sparse_groups.empty?
       sparse_counts = @connection.all <<~SQL, *args, sparse_groups
         SELECT #{sql_fragment} AS group, COUNT(*) AS count
-        FROM (#{sql}) sq
+        FROM (#{base_sql}) sq
         WHERE #{sql_fragment} = ANY(#{var_name})
         GROUP BY #{sql_fragment}
       SQL

data/lib/simple/sql/connection/scope/search.rb

@@ -57,7 +57,7 @@ module Simple::SQL::Connection::Scope::Search
     return scope if filters.empty?
 
     filters.inject(scope) do |scp, (k, v)|
-      scp.where k => resolve_static_matches(v, column_type: column_types.fetch(k))
+      scp.where({ k => resolve_static_matches(v, column_type: column_types.fetch(k)) })
     end
   end
 
@@ -78,6 +78,7 @@ module Simple::SQL::Connection::Scope::Search
   def empty_filter?(_key, value)
     return true if value.nil?
     return true if value.is_a?(Enumerable) && value.empty? # i.e. Hash, Array
+
     false
   end
 

data/lib/simple/sql/connection/scope/where.rb

@@ -23,11 +23,9 @@ class Simple::SQL::Connection::Scope
   # scope = scope.where(metadata: { uid: 1 }, jsonb: false)
   #
   def where(sql_fragment, arg = :__dummy__no__arg, placeholder: "?", jsonb: true)
-    duplicate.send(:where!, sql_fragment, arg, placeholder: placeholder, jsonb: jsonb)
+    duplicate.where!(sql_fragment, arg, placeholder: placeholder, jsonb: jsonb)
   end
 
-  private
-
   def where!(first_arg, arg = :__dummy__no__arg, placeholder: "?", jsonb: true)
     if arg != :__dummy__no__arg
       where_sql_with_argument!(first_arg, arg, placeholder: placeholder)
@@ -40,6 +38,8 @@ class Simple::SQL::Connection::Scope
     self
   end
 
+  private
+
   def where_sql!(sql_fragment)
     @where << sql_fragment
   end

data/lib/simple/sql/connection.rb

@@ -57,6 +57,7 @@ class Simple::SQL::Connection
 
   def disconnect!
     return unless @connection_class && @connection_class != ::ActiveRecord::Base
+
     @connection_class.remove_connection
   end
 

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

@@ -7,6 +7,7 @@ module Simple::SQL::Helpers::Decoder
   # rubocop:disable Metrics/AbcSize
   # rubocop:disable Metrics/CyclomaticComplexity
   # rubocop:disable Naming/UncommunicativeMethodParamName
+  # rubocop:disable Style/MultipleComparison
   def decode_value(type, s)
     case type
     when :unknown                       then s
@@ -18,8 +19,8 @@ module Simple::SQL::Helpers::Decoder
     when :'integer[]'                   then s.scan(/-?\d+/).map { |part| Integer(part) }
     when :"character varying[]"         then parse_pg_array(s)
     when :"text[]"                      then parse_pg_array(s)
-    when :"timestamp without time zone" then ::Time.parse(s)
-    when :"timestamp with time zone"    then ::Time.parse(s)
+    when :"timestamp without time zone" then decode_time(s)
+    when :"timestamp with time zone"    then decode_time(s)
     when :hstore                        then HStore.parse(s)
     when :json                          then ::JSON.parse(s)
     when :jsonb                         then ::JSON.parse(s)
@@ -36,6 +37,12 @@ module Simple::SQL::Helpers::Decoder
   require "pg_array_parser"
   extend PgArrayParser
 
+  def decode_time(s)
+    return s if s.is_a?(Time)
+
+    ::Time.parse(s)
+  end
+
   # HStore parsing
   module HStore
     extend self
@@ -68,6 +75,7 @@ end
 
 module Simple::SQL::Helpers::Decoder
   def self.new(result, into:, column_info:)
+    # rubocop:disable Lint/ElseLayout
     if into == Hash           then HashRecord.new(column_info)
     elsif result.nfields == 1 then SingleColumn.new(column_info)
     else                           MultiColumns.new(column_info)

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

@@ -27,7 +27,7 @@ module Simple::SQL::Helpers::RowConverter
     ary.first
   end
 
-  class TypeConverter #:nodoc:
+  class TypeConverter # :nodoc:
     def initialize(type:, associations:)
       @type         = type
       @associations = associations
@@ -57,7 +57,7 @@ module Simple::SQL::Helpers::RowConverter
     end
   end
 
-  class ImmutableConverter < TypeConverter #:nodoc:
+  class ImmutableConverter < TypeConverter # :nodoc:
     Immutable = ::Simple::Immutable
 
     def build_row_in_target_type(hsh)
@@ -65,7 +65,7 @@ module Simple::SQL::Helpers::RowConverter
     end
   end
 
-  class TypeConverter2 < TypeConverter #:nodoc:
+  class TypeConverter2 < TypeConverter # :nodoc:
     def initialize(type:, associations:, fq_table_name:)
       super(type: type, associations: associations)
       @fq_table_name = fq_table_name

data/lib/simple/sql/monkey_patches.rb

@@ -1,5 +1,7 @@
 # This file contains some monkey patches
 
+# rubocop:disable Lint/DuplicateMethods
+
 module Simple::SQL::MonkeyPatches
   def self.warn(msg)
     return if ENV["SIMPLE_SQL_SILENCE"] == "1"
@@ -29,6 +31,7 @@ when /^5.2/
   class ActiveRecord::ConnectionAdapters::ConnectionPool::Reaper
     def run
       return unless frequency && frequency > 0
+
       Simple::SQL::MonkeyPatches.warn "simple-sql disables reapers for all connection pools, see https://github.com/rails/rails/issues/33600"
     end
   end
@@ -45,6 +48,7 @@ when /^6/
   class ActiveRecord::ConnectionAdapters::ConnectionPool::Reaper
     def run
       return unless frequency && frequency > 0
+
       Simple::SQL::MonkeyPatches.warn "simple-sql disables reapers for all connection pools, see https://github.com/rails/rails/issues/33600"
     end
   end

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

@@ -92,8 +92,8 @@ module ::Simple::SQL::Result::AssociationLoader # :nodoc:
 
     foreign_ids = H.pluck(records, belonging_column).uniq.compact
 
-    scope = connection.scope(table: relation.having_table)
-    scope = scope.where(having_column => foreign_ids)
+    scope = connection.scope({ table: relation.having_table })
+    scope = scope.where({ having_column => foreign_ids })
 
     recs = connection.all(scope, into: Hash)
     recs_by_id = H.by_key(recs, having_column)
@@ -122,7 +122,7 @@ module ::Simple::SQL::Result::AssociationLoader # :nodoc:
     host_ids  = H.pluck(records, having_column).uniq.compact
 
     scope     = connection.scope(table: relation.belonging_table)
-    scope     = scope.where(belonging_column => host_ids)
+    scope     = scope.where({ belonging_column => host_ids })
     scope     = scope.order_by(order_by) if order_by
 
     recs      = connection.all(scope, into: Hash)

data/lib/simple/sql/result.rb

@@ -31,6 +31,7 @@ class ::Simple::SQL::Result < Array
   attr_reader :connection
 
   def initialize(connection, records) # :nodoc:
+    super()
     @connection = connection
     replace(records)
   end

data/lib/simple/sql/version.rb

@@ -6,6 +6,7 @@ module Simple
       def version(name)
         spec = Gem.loaded_specs[name]
         return "unreleased" unless spec
+
         version = spec.version.to_s
         version += "+unreleased" if unreleased?(spec)
         version
@@ -17,6 +18,7 @@ module Simple
         return false unless defined?(Bundler::Source::Gemspec)
         return true if spec.source.is_a?(::Bundler::Source::Gemspec)
         return true if spec.source.is_a?(::Bundler::Source::Path)
+
         false
       end
     end

data/scripts/integration_tests

@@ -0,0 +1,49 @@
+#!/bin/bash
+
+set -eu -o pipefail
+
+echo "Starting integration tests. We log into log/integration_tests.log"
+
+rm log/integration_tests.log
+touch log/integration_tests.log
+
+export SIMPLE_SQL_SILENCE=1
+
+run_test() {
+  local activerecord_spec=$1
+  local pg_spec=$2
+
+  export SIMPLE_SQL_ACTIVERECORD_SPECS="$activerecord_spec"
+  export SIMPLE_SQL_PG_SPECS="$pg_spec"
+
+  printf "=== Running test w/SIMPLE_SQL_ACTIVERECORD_SPECS='%s' SIMPLE_SQL_PG_SPECS='%s'\n" "$SIMPLE_SQL_ACTIVERECORD_SPECS" "$SIMPLE_SQL_PG_SPECS" | tee -a log/integration_tests.log
+
+  if ! bundle update >> log/integration_tests.log ; then
+    echo "Bundling failed"
+    set -xv
+    bundle update
+    exit 1
+  fi
+  
+  if ! bundle exec rspec >> log/integration_tests.log ; then
+    echo "Tests failed"
+    set -xv
+    bundle exec rspec
+    exit 1
+  fi
+}
+
+run_test "> 5,< 6" "~> 0.20"
+run_test "> 5,< 6" "~> 1.0.0"
+run_test "> 5,< 6" "~> 1.1.0"
+run_test "> 5,< 6" "~> 1.2.0"
+run_test "> 5,< 6" "~> 1.3.0"
+
+run_test "> 6,< 7" "~> 1.1.0"
+run_test "> 6,< 7" "~> 1.2.0"
+run_test "> 6,< 7" "~> 1.3.0"
+
+run_test "> 7,< 8" "~> 1.1.0"
+run_test "> 7,< 8" "~> 1.2.0"
+run_test "> 7,< 8" "~> 1.3.0"
+

data/simple-sql.gemspec

@@ -21,29 +21,19 @@ Gem::Specification.new do |gem|
   # executables are used for development purposes only
   gem.executables   = []
 
-  gem.required_ruby_version = '~> 2.3'
+  gem.required_ruby_version = '~> 3.3'
 
   gem.add_dependency 'pg_array_parser', '~> 0', '>= 0.0.9'
-  gem.add_dependency 'pg', '~> 0.20'
   gem.add_dependency 'expectation', '~> 1'
 
   gem.add_dependency 'digest-crc', '~> 0'
   gem.add_dependency 'simple-immutable', '~> 1.0'
 
+  pg_specs = ENV["SIMPLE_SQL_PG_SPECS"] || '~> 1.0'
+  gem.add_dependency 'pg', *(pg_specs.split(","))
+
   # during tests we check the SIMPLE_SQL_ACTIVERECORD_SPECS environment setting.
   # Run make tests to run all tests
-  if ENV["SIMPLE_SQL_ACTIVERECORD_SPECS"]
-    gem.add_dependency 'activerecord', '>= 5.2.4.5', *(ENV["SIMPLE_SQL_ACTIVERECORD_SPECS"].split(","))
-  else
-    gem.add_dependency 'activerecord', '>= 5.2.4.5', '< 6.1'
-  end
-
-  # optional gems (required by some of the parts)
-
-  # development gems
-  gem.add_development_dependency 'pg', '0.20'
-  gem.add_development_dependency 'rake', '>= 12.3.3'
-  gem.add_development_dependency 'rspec', '~> 3.7'
-  gem.add_development_dependency 'rubocop', '~> 0.61.1'
-  gem.add_development_dependency 'simplecov', '~> 0'
+  activerecord_specs = ENV["SIMPLE_SQL_ACTIVERECORD_SPECS"] || '< 6.1'
+  gem.add_dependency 'activerecord', '>= 5.2.4.5', *(activerecord_specs.split(","))
 end

data/spec/simple/sql/config_spec.rb

@@ -2,7 +2,7 @@ require "spec_helper"
 
 describe "Simple::SQL::Config" do
   describe ".determine_url" do
-    it "reads config/database.yml" do
+    xit "reads config/database.yml" do
       expect(SQL::Config.determine_url).to eq "postgres://127.0.0.1/simple-sql-test"
     end
   end

data/spec/simple/sql/count_by_groups_spec.rb

@@ -1,44 +1,63 @@
 require "spec_helper"
 
 describe "Simple::SQL::Connection::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("SELECT * FROM users") }
+  let!(:users)                  { 1.upto(10).map { |i| create(:user, role_id: i) } }
+  let(:scope)                   { SQL.scope("SELECT * FROM users") }
+
+  let(:all_role_ids)            { 1.upto(10).to_a }
+  let(:all_role_ids_w_squares)  { all_role_ids.map { |role_id| [role_id, role_id*role_id] } } 
+
+  before do
+    # initially we have 10 users, one per role_id in the range 1 .. 10
+    # This adds another 3 users with role_id of 1.
+    create(:user, role_id: 1)
+    create(:user, role_id: 1)
+    create(:user, role_id: 1)
+  end
 
   describe "enumerate_groups" do
-    it "returns all groups" do
+    it "returns all groups by a single column" 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
+
+    it "obeys where conditions" do
+      expect(scope.where("role_id < $1", 4).enumerate_groups("role_id")).to contain_exactly(1,2,3)
+    end
+
+    it "counts all groups by multiple columns" do
+      expect(scope.where("role_id < $1", 4).enumerate_groups("role_id, role_id * role_id")).to contain_exactly([1, 1], [2, 4], [3, 9])
     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)
-
+    it "counts all groups by a single column" do
       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
+
+    it "counts all groups by multiple columns" do
+      expect(scope.where("role_id < $1", 4).count_by("role_id, role_id * role_id")).to include([1,1] => 4)
+      expect(scope.where("role_id < $1", 4).count_by("role_id, role_id * role_id")).to include([2, 4] => 1)
+      expect(scope.where("role_id < $1", 4).count_by("role_id, role_id * role_id").keys).to contain_exactly([1, 1], [2, 4], [3, 9])
+    end
   end
 
   describe "count_by_estimate" 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])
+      expect_any_instance_of(Simple::SQL::Connection).to receive(:estimate_cost).at_least(:once).and_return(10_000)
     end
-    
-    it "counts all groups" do
-      create(:user, role_id: 1)
-      create(:user, role_id: 1)
-      create(:user, role_id: 1)
 
+    it "counts all groups by a single column" do
       expect(scope.count_by_estimate("role_id")).to include(1 => 4)
       expect(scope.count_by_estimate("role_id")).to include(2 => 1)
       expect(scope.count_by_estimate("role_id").keys).to contain_exactly(*all_role_ids)
     end
+
+    it "counts all groups by multiple columns and conditions" do
+      expect(scope.where("role_id < $1", 4).count_by_estimate("role_id, role_id * role_id")).to include([1,1] => 4)
+      expect(scope.where("role_id < $1", 4).count_by_estimate("role_id, role_id * role_id")).to include([2, 4] => 1)
+      expect(scope.where("role_id < $1", 4).count_by_estimate("role_id, role_id * role_id").keys).to contain_exactly([1, 1], [2, 4], [3, 9])
+    end
   end
 end

data/spec/simple/sql/insert_spec.rb

@@ -7,7 +7,7 @@ describe "Simple::SQL.insert" do
     let!(:initial_ids) { SQL.all("SELECT id FROM users") }
 
     it "inserts a single user" do
-      id = SQL.insert :users, first_name: "foo", last_name: "bar"
+      id = SQL.insert :users, { first_name: "foo", last_name: "bar" }
       expect(id).to be_a(Integer)
       expect(initial_ids).not_to include(id)
       expect(SQL.ask("SELECT count(*) FROM users")).to eq(USER_COUNT+1)
@@ -19,7 +19,7 @@ describe "Simple::SQL.insert" do
     end
 
     it "returns the id" do
-      id = SQL.insert :users, first_name: "foo", last_name: "bar"
+      id = SQL.insert :users, { first_name: "foo", last_name: "bar" }
       expect(id).to be_a(Integer)
       expect(initial_ids).not_to include(id)
     end

data/spec/simple/sql/scope_spec.rb

@@ -33,36 +33,36 @@ describe "Simple::SQL::Connection::Scope" do
 
     context "that do not match" do
       it "does not match with string keys" do
-        expect(SQL.ask(scope.where(id: -1))).to be_nil
+        expect(SQL.ask(scope.where({id: -1}))).to be_nil
       end
 
       it "does not match with symbol keys" do
-        expect(SQL.ask(scope.where("id" => -1))).to be_nil
+        expect(SQL.ask(scope.where({"id" => -1}))).to be_nil
       end
     end
 
     context "that match" do
       it "matches with string keys" do
-        expect(SQL.ask(scope.where("id" => user_id))).to eq(1)
+        expect(SQL.ask(scope.where({"id" => user_id}))).to eq(1)
       end
 
       it "matches with symbol keys" do
-        expect(SQL.ask(scope.where(id: user_id))).to eq(1)
+        expect(SQL.ask(scope.where({id: user_id}))).to eq(1)
       end
     end
 
     context "with array arguments" do
       it "matches against array arguments" do
-        expect(SQL.ask(scope.where("id" => [-333, user_id]))).to eq(1)
-        expect(SQL.ask(scope.where("id" => [-333, -1]))).to be_nil
-        expect(SQL.ask(scope.where("id" => []))).to be_nil
+        expect(SQL.ask(scope.where({"id" => [-333, user_id]}))).to eq(1)
+        expect(SQL.ask(scope.where({"id" => [-333, -1]}))).to be_nil
+        expect(SQL.ask(scope.where({"id" => []}))).to be_nil
       end
     end
 
     context "with invalid arguments" do
       it "raises an ArgumentError" do
         expect {
-          scope.where(1 => 3)
+          scope.where({1 => 3})
         }.to raise_error(ArgumentError)
       end
     end

data/spec/simple/sql/version_spec.rb

@@ -4,7 +4,7 @@ describe SQL do
   describe "VERSION" do
     it "defines a version string" do
       # Note: this allows for 0.12.34beta
-      expect(SQL::VERSION).to match(/^\d+\.\d+\.\d+/)
+      expect(SQL::VERSION).to match(/^(\d+\.\d+\.\d+|unreleased)/)
     end
   end
 end

data/spec/support/001_database.rb

@@ -1,3 +1,5 @@
+require "logger"
+
 # connect to the database and setup the schema
 require "active_record"
 
@@ -5,14 +7,21 @@ require "active_record"
 require "simple-sql"
 
 require "yaml"
-abc = YAML.load_file("config/database.yml")
+
+path = "config/database.yml"
+abc = if Psych::VERSION > '4.0'
+  YAML.safe_load(File.read(path), aliases: true)
+else
+  YAML.safe_load(File.read(path), [], [], true)
+end
+
 ActiveRecord::Base.establish_connection(abc["test"])
 
 if ActiveRecord::Base.respond_to?(:raise_in_transactional_callbacks=)
   ActiveRecord::Base.raise_in_transactional_callbacks = true
 end
 
-ActiveRecord::Base.logger = Logger.new("log/test.log")
+ActiveRecord::Base.logger = ::Logger.new("log/test.log")
 
 ActiveRecord::Schema.define do
   self.verbose = false