sequel 4.22.0 → 4.23.0

data/spec/model/spec_helper.rb

@@ -5,27 +5,9 @@ unless Object.const_defined?('Sequel') && Sequel.const_defined?('Model')
 end
 Sequel::Deprecation.backtrace_filter = lambda{|line, lineno| lineno < 4 || line =~ /_spec\.rb/}
 
-require File.join(File.dirname(File.expand_path(__FILE__)), "../rspec_helper.rb")
-
-RSPEC_EXAMPLE_GROUP.class_eval do
-  if ENV['SEQUEL_DEPRECATION_WARNINGS']
-    class << self
-      alias qspecify specify
-    end
-  else
-    def self.qspecify(*a, &block)
-      specify(*a) do
-        begin
-          output = Sequel::Deprecation.output
-          Sequel::Deprecation.output = false
-          instance_exec(&block)
-        ensure
-          Sequel::Deprecation.output = output 
-        end
-      end
-    end
-  end
-end
+gem 'minitest'
+require 'minitest/autorun'
+require 'minitest/hooks/default'
 
 Sequel.quote_identifiers = false
 Sequel.identifier_input_method = nil

data/spec/model/validations_spec.rb

@@ -5,81 +5,79 @@ describe Sequel::Model::Errors do
     @errors = Sequel::Model::Errors.new
   end
   
-  specify "should be clearable using #clear" do
+  it "should be clearable using #clear" do
     @errors.add(:a, 'b')
-    @errors.should == {:a=>['b']}
+    @errors.must_equal(:a=>['b'])
     @errors.clear
-    @errors.should == {}
+    @errors.must_equal({})
   end
   
-  specify "should be empty if there are no errors" do
-    @errors.should be_empty
+  it "should be empty if there are no errors" do
+    @errors.must_be :empty?
   end
   
-  specify "should not be empty if there are errors" do
+  it "should not be empty if there are errors" do
     @errors.add(:blah, "blah")
-    @errors.should_not be_empty
+    @errors.wont_be :empty?
   end
   
-  specify "should return an array of errors for a specific attribute using #on if there are errors" do
+  it "should return an array of errors for a specific attribute using #on if there are errors" do
     @errors.add(:blah, 'blah')
-    @errors.on(:blah).should == ['blah']
+    @errors.on(:blah).must_equal ['blah']
   end
   
-  specify "should return nil using #on if there are no errors for that attribute" do
-    @errors.on(:blah).should == nil
+  it "should return nil using #on if there are no errors for that attribute" do
+    @errors.on(:blah).must_equal nil
   end
   
-  specify "should accept errors using #add" do
+  it "should accept errors using #add" do
     @errors.add :blah, 'zzzz'
-    @errors[:blah].should == ['zzzz']
+    @errors[:blah].must_equal ['zzzz']
   end
   
-  specify "should return full messages using #full_messages" do
-    @errors.full_messages.should == []
+  it "should return full messages using #full_messages" do
+    @errors.full_messages.must_equal []
     
     @errors.add(:blow, 'blieuh')
     @errors.add(:blow, 'blich')
     @errors.add(:blay, 'bliu')
     msgs = @errors.full_messages
-    msgs.size.should == 3
-    msgs.should include('blow blieuh', 'blow blich', 'blay bliu')
+    msgs.sort.must_equal ['blay bliu', 'blow blich', 'blow blieuh']
   end
 
-  specify "should not add column names for LiteralStrings" do
-    @errors.full_messages.should == []
+  it "should not add column names for LiteralStrings" do
+    @errors.full_messages.must_equal []
     
     @errors.add(:blow, 'blieuh')
     @errors.add(:blow, Sequel.lit('blich'))
     @errors.add(:blay, 'bliu')
     msgs = @errors.full_messages
-    msgs.size.should == 3
-    msgs.should include('blow blieuh', 'blich', 'blay bliu')
+    msgs.sort.must_equal ['blay bliu', 'blich', 'blow blieuh']
   end
 
-  specify "should return the number of error messages using #count" do
-    @errors.count.should == 0
+  it "should return the number of error messages using #count" do
+    @errors.count.must_equal 0
     @errors.add(:a, 'b')
-    @errors.count.should == 1
+    @errors.count.must_equal 1
     @errors.add(:a, 'c')
-    @errors.count.should == 2
+    @errors.count.must_equal 2
     @errors.add(:b, 'c')
-    @errors.count.should == 3
+    @errors.count.must_equal 3
   end
 
-  specify "should return the array of error messages for a given attribute using #on" do
+  it "should return the array of error messages for a given attribute using #on" do
     @errors.add(:a, 'b')
-    @errors.on(:a).should == ['b']
+    @errors.on(:a).must_equal ['b']
     @errors.add(:a, 'c')
-    @errors.on(:a).should == ['b', 'c']
+    @errors.on(:a).must_equal ['b', 'c']
     @errors.add(:b, 'c')
-    @errors.on(:a).should == ['b', 'c']
+    @errors.on(:a).must_equal ['b', 'c']
   end
 
-  specify "should return nil if there are no error messages for a given attribute using #on" do
-    @errors.on(:a).should == nil
+  it "should return nil if there are no error messages for a given attribute using #on" do
+    @errors.on(:a).must_equal nil
     @errors.add(:b, 'b')
-    @errors.on(:a).should == nil
+    @errors.on(:a).must_equal nil
   end
 end
 
@@ -95,48 +93,48 @@ describe Sequel::Model do
     @o = @c.new
   end
   
-  specify "should supply a #valid? method that returns true if validations pass" do
+  it "should supply a #valid? method that returns true if validations pass" do
     @o.score = 50
-    @o.should_not be_valid
+    @o.wont_be :valid?
     @o.score = 100
-    @o.should be_valid
+    @o.must_be :valid?
   end
   
-  specify "should provide an errors object" do
+  it "should provide an errors object" do
     @o.score = 100
-    @o.should be_valid
-    @o.errors.should be_empty
+    @o.must_be :valid?
+    @o.errors.must_be :empty?
     
     @o.score = 86
-    @o.should_not be_valid
-    @o.errors[:score].should == ['too low']
-    @o.errors.on(:blah).should be_nil
+    @o.wont_be :valid?
+    @o.errors[:score].must_equal ['too low']
+    @o.errors.on(:blah).must_equal nil
   end
   
-  specify "should allow raising of ValidationFailed with a Model instance with errors" do
+  it "should allow raising of ValidationFailed with a Model instance with errors" do
     @o.errors.add(:score, 'is too low')
     begin
       raise Sequel::ValidationFailed, @o
     rescue Sequel::ValidationFailed => e
     end
-    e.model.should equal(@o)
-    e.errors.should equal(@o.errors)
-    e.message.should == 'score is too low'
+    e.model.must_be_same_as(@o)
+    e.errors.must_be_same_as(@o.errors)
+    e.message.must_equal 'score is too low'
   end
   
-  specify "should allow raising of ValidationFailed with an Errors instance" do
+  it "should allow raising of ValidationFailed with an Errors instance" do
     @o.errors.add(:score, 'is too low')
     begin
       raise Sequel::ValidationFailed, @o.errors
     rescue Sequel::ValidationFailed => e
     end
-    e.model.should be_nil
-    e.errors.should equal(@o.errors)
-    e.message.should == 'score is too low'
+    e.model.must_equal nil
+    e.errors.must_be_same_as(@o.errors)
+    e.message.must_equal 'score is too low'
   end
 
-  specify "should allow raising of ValidationFailed with a string" do
-    proc{raise Sequel::ValidationFailed, "no reason"}.should raise_error(Sequel::ValidationFailed, "no reason")
+  it "should allow raising of ValidationFailed with a string" do
+    proc{raise Sequel::ValidationFailed, "no reason"}.must_raise(Sequel::ValidationFailed, "no reason")
   end
 end
 
@@ -153,39 +151,43 @@ describe "Model#save" do
     DB.reset
   end
 
-  specify "should save only if validations pass" do
+  it "should save only if validations pass" do
     @m.raise_on_save_failure = false
-    @m.should_not be_valid
+    @m.wont_be :valid?
     @m.save
-    DB.sqls.should be_empty
+    DB.sqls.must_be :empty?
     
     @m.x = 7
-    @m.should be_valid
-    @m.save.should_not == false
-    DB.sqls.should == ['UPDATE people SET x = 7 WHERE (id = 4)']
+    @m.must_be :valid?
+    @m.save.wont_equal false
+    DB.sqls.must_equal ['UPDATE people SET x = 7 WHERE (id = 4)']
   end
   
-  specify "should skip validations if the :validate=>false option is used" do
+  it "should skip validations if the :validate=>false option is used" do
     @m.raise_on_save_failure = false
-    @m.should_not be_valid
+    @m.wont_be :valid?
     @m.save(:validate=>false)
-    DB.sqls.should == ['UPDATE people SET x = 6 WHERE (id = 4)']
+    DB.sqls.must_equal ['UPDATE people SET x = 6 WHERE (id = 4)']
   end
 
-  specify "should raise error if validations fail and raise_on_save_failure is true" do
-    proc{@m.save}.should(raise_error(Sequel::ValidationFailed) do |e|
-      e.model.should equal(@m)
-      e.errors.should equal(@m.errors)
-    end)
+  it "should raise error if validations fail and raise_on_save_failure is true" do
+    begin
+      @m.save
+    rescue Sequel::ValidationFailed => e
+      e.model.must_be_same_as(@m)
+      e.errors.must_be_same_as(@m.errors)
+    else
+      raise
+    end
   end
 
-  specify "should raise error if validations fail and :raise_on_failure option is true" do
+  it "should raise error if validations fail and :raise_on_failure option is true" do
     @m.raise_on_save_failure = false
-    proc{@m.save(:raise_on_failure => true)}.should raise_error(Sequel::ValidationFailed)
+    proc{@m.save(:raise_on_failure => true)}.must_raise(Sequel::ValidationFailed)
   end
 
-  specify "should return nil if validations fail and raise_on_save_faiure is false" do
+  it "should return nil if validations fail and raise_on_save_faiure is false" do
     @m.raise_on_save_failure = false
-    @m.save.should == nil
+    @m.save.must_equal nil
   end
 end

data/spec/spec_config.rb

@@ -1,2 +1,10 @@
 ENV['SEQUEL_POSTGRES_URL'] ||= 'postgres:///sequel_test?user=sequel_test&password=2a9db12d8f993248'
 ENV['SEQUEL_SQLITE_URL'] ||= 'sqlite:/'
+gem 'minitest'
+require 'minitest'
+if Minitest.respond_to?(:before_parallel_fork)
+  if SEQUEL_ADAPTER_TEST.to_s == 'postgres'
+    Minitest.before_parallel_fork{DB.disconnect}
+    Minitest.after_parallel_fork{|i|DB.opts[:database] += (i+1).to_s; DB.extension :pg_array, :pg_hstore}
+  end
+end

metadata

@@ -1,17 +1,45 @@
 --- !ruby/object:Gem::Specification
 name: sequel
 version: !ruby/object:Gem::Version
-  version: 4.22.0
+  version: 4.23.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-01 00:00:00.000000000 Z
+date: 2015-06-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.7.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.7.0
+- !ruby/object:Gem::Dependency
+  name: minitest-hooks
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest-shared_description
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -195,6 +223,7 @@ extra_rdoc_files:
 - doc/release_notes/4.20.0.txt
 - doc/release_notes/4.21.0.txt
 - doc/release_notes/4.22.0.txt
+- doc/release_notes/4.23.0.txt
 files:
 - CHANGELOG
 - MIT-LICENSE
@@ -305,6 +334,7 @@ files:
 - doc/release_notes/4.20.0.txt
 - doc/release_notes/4.21.0.txt
 - doc/release_notes/4.22.0.txt
+- doc/release_notes/4.23.0.txt
 - doc/release_notes/4.3.0.txt
 - doc/release_notes/4.4.0.txt
 - doc/release_notes/4.5.0.txt
@@ -333,7 +363,6 @@ files:
 - lib/sequel/adapters/do/mysql.rb
 - lib/sequel/adapters/do/postgres.rb
 - lib/sequel/adapters/do/sqlite3.rb
-- lib/sequel/adapters/fdbsql.rb
 - lib/sequel/adapters/firebird.rb
 - lib/sequel/adapters/ibmdb.rb
 - lib/sequel/adapters/informix.rb
@@ -342,7 +371,6 @@ files:
 - lib/sequel/adapters/jdbc/cubrid.rb
 - lib/sequel/adapters/jdbc/db2.rb
 - lib/sequel/adapters/jdbc/derby.rb
-- lib/sequel/adapters/jdbc/fdbsql.rb
 - lib/sequel/adapters/jdbc/firebirdsql.rb
 - lib/sequel/adapters/jdbc/h2.rb
 - lib/sequel/adapters/jdbc/hsqldb.rb
@@ -364,13 +392,12 @@ files:
 - lib/sequel/adapters/odbc/db2.rb
 - lib/sequel/adapters/odbc/mssql.rb
 - lib/sequel/adapters/odbc/progress.rb
-- lib/sequel/adapters/openbase.rb
 - lib/sequel/adapters/oracle.rb
 - lib/sequel/adapters/postgres.rb
+- lib/sequel/adapters/postgresql.rb
 - lib/sequel/adapters/shared/access.rb
 - lib/sequel/adapters/shared/cubrid.rb
 - lib/sequel/adapters/shared/db2.rb
-- lib/sequel/adapters/shared/fdbsql.rb
 - lib/sequel/adapters/shared/firebird.rb
 - lib/sequel/adapters/shared/informix.rb
 - lib/sequel/adapters/shared/mssql.rb
@@ -510,6 +537,7 @@ files:
 - lib/sequel/plugins/csv_serializer.rb
 - lib/sequel/plugins/dataset_associations.rb
 - lib/sequel/plugins/defaults_setter.rb
+- lib/sequel/plugins/delay_add_association.rb
 - lib/sequel/plugins/dirty.rb
 - lib/sequel/plugins/eager_each.rb
 - lib/sequel/plugins/error_splitter.rb
@@ -556,6 +584,8 @@ files:
 - lib/sequel/plugins/unlimited_update.rb
 - lib/sequel/plugins/update_or_create.rb
 - lib/sequel/plugins/update_primary_key.rb
+- lib/sequel/plugins/update_refresh.rb
+- lib/sequel/plugins/validate_associated.rb
 - lib/sequel/plugins/validation_class_methods.rb
 - lib/sequel/plugins/validation_helpers.rb
 - lib/sequel/plugins/xml_serializer.rb
@@ -563,7 +593,6 @@ files:
 - lib/sequel/timezones.rb
 - lib/sequel/version.rb
 - spec/adapters/db2_spec.rb
-- spec/adapters/fdbsql_spec.rb
 - spec/adapters/firebird_spec.rb
 - spec/adapters/informix_spec.rb
 - spec/adapters/mssql_spec.rb
@@ -614,6 +643,7 @@ files:
 - spec/extensions/dataset_source_alias_spec.rb
 - spec/extensions/date_arithmetic_spec.rb
 - spec/extensions/defaults_setter_spec.rb
+- spec/extensions/delay_add_association_spec.rb
 - spec/extensions/dirty_spec.rb
 - spec/extensions/eager_each_spec.rb
 - spec/extensions/empty_array_ignore_nulls_spec.rb
@@ -705,6 +735,8 @@ files:
 - spec/extensions/unlimited_update_spec.rb
 - spec/extensions/update_or_create_spec.rb
 - spec/extensions/update_primary_key_spec.rb
+- spec/extensions/update_refresh_spec.rb
+- spec/extensions/validate_associated_spec.rb
 - spec/extensions/validation_class_methods_spec.rb
 - spec/extensions/validation_helpers_spec.rb
 - spec/extensions/xml_serializer_spec.rb
@@ -752,6 +784,7 @@ files:
 - spec/files/uppercase_timestamped_migrations/1273253849_CREATE_SESSIONS.RB
 - spec/files/uppercase_timestamped_migrations/1273253851_CREATE_NODES.RB
 - spec/files/uppercase_timestamped_migrations/1273253853_3_CREATE_USERS.RB
+- spec/guards_helper.rb
 - spec/integration/associations_test.rb
 - spec/integration/database_test.rb
 - spec/integration/dataset_test.rb
@@ -778,7 +811,6 @@ files:
 - spec/model/record_spec.rb
 - spec/model/spec_helper.rb
 - spec/model/validations_spec.rb
-- spec/rspec_helper.rb
 - spec/sequel_coverage.rb
 - spec/spec_config.rb
 homepage: http://sequel.jeremyevans.net

data/lib/sequel/adapters/fdbsql.rb

@@ -1,286 +0,0 @@
-require 'pg'
-
-Sequel.require 'adapters/utils/pg_types'
-Sequel.require 'adapters/shared/fdbsql'
-Sequel::Deprecation.deprecate 'The fdbsql adapter is deprecated and will be removed in a future version of Sequel.'
-
-module Sequel
-  module Fdbsql
-    CONVERTED_EXCEPTIONS << PGError
-
-    # Database class for the FoundationDB SQL Layer used with Sequel and the
-    # pg driver
-    class Database < Sequel::Database
-      include Sequel::Fdbsql::DatabaseMethods
-
-      set_adapter_scheme :fdbsql
-
-      # Connects to the database. In addition to the standard database options,
-      # :connect_timeout is a connection timeout in seconds,
-      # :sslmode sets whether to use ssl, and
-      # :notice_receiver handles server notices in a proc.
-      def connect(server)
-        opts = server_opts(server)
-        Connection.new(self, opts)
-      end
-
-      # Execute the given SQL with the given args on an available connection.
-      def execute(sql, opts = {}, &block)
-        res = nil
-        synchronize(opts[:server]) do |conn|
-          res = check_database_errors do
-            if sql.is_a?(Symbol)
-              execute_prepared_statement(conn, sql, opts, &block)
-            else
-              log_yield(sql) do
-                conn.query(sql, opts[:arguments])
-              end
-            end
-          end
-          yield res if block_given?
-          res.cmd_tuples
-        end
-      end
-
-      def server_version
-        return @server_version if @server_version
-
-        version = get{VERSION{}}
-        unless ver = version.match(/(\d+)\.(\d+)\.(\d+)/)
-          raise Error, "No match when checking FDB SQL Layer version: #{version}"
-        end
-
-        @server_version = (100 * ver[1].to_i + ver[2].to_i) * 100 + ver[3].to_i
-      end
-
-      private
-
-      def database_exception_sqlstate(exception, opts)
-        if exception.respond_to?(:result) && (result = exception.result)
-          result.error_field(::PGresult::PG_DIAG_SQLSTATE)
-        end
-      end
-
-      def execute_prepared_statement(conn, name, opts=OPTS, &block)
-        statement = prepared_statement(name)
-        sql = statement.prepared_sql
-        ps_name = name.to_s
-        if args = opts[:arguments]
-          args = args.map{|arg| bound_variable_arg(arg, conn)}
-        end
-        begin
-          # create prepared statement if it doesn't exist, or has new sql
-          unless conn.prepared_statements[ps_name] == sql
-            conn.execute("DEALLOCATE #{ps_name}") if conn.prepared_statements.include?(ps_name)
-            log_yield("PREPARE #{ps_name} AS #{sql}"){conn.prepare(ps_name, sql)}
-            conn.prepared_statements[ps_name] = sql
-          end
-
-          log_sql = "EXECUTE #{ps_name}"
-          if statement.log_sql
-            log_sql << " ("
-            log_sql << sql
-            log_sql << ")"
-          end
-          log_yield(sql, args) do
-            conn.execute_prepared_statement(ps_name, args)
-          end
-        rescue PGError => e
-          if (database_exception_sqlstate(e, opts) == STALE_STATEMENT_SQLSTATE)
-            conn.prepared_statements[ps_name] = nil
-            retry
-          end
-        end
-      end
-    end
-
-    # Dataset class for the FoundationDB SQL Layer that uses the pg driver.
-    class Dataset < Sequel::Dataset
-      include Sequel::Fdbsql::DatasetMethods
-
-      Database::DatasetClass = self
-
-      # Allow use of bind arguments for FDBSQL using the pg driver.
-      module BindArgumentMethods
-
-        include Sequel::Dataset::UnnumberedArgumentMapper
-        include DatasetMethods::PreparedStatementMethods
-
-        private
-
-        # Execute the given SQL with the stored bind arguments.
-        def execute(sql, opts=OPTS, &block)
-          super(sql, {:arguments=>bind_arguments}.merge!(opts), &block)
-        end
-
-        # Same as execute, explicit due to intricacies of alias and super.
-        def execute_dui(sql, opts=OPTS, &block)
-          super(sql, {:arguments=>bind_arguments}.merge!(opts), &block)
-        end
-      end
-
-      # Allow use of server side prepared statements for FDBSQL using the
-      # pg driver.
-      module PreparedStatementMethods
-        include BindArgumentMethods
-
-        # Raise a more obvious error if you attempt to call a unnamed prepared statement.
-        def call(*)
-          raise Error, "Cannot call prepared statement without a name" if prepared_statement_name.nil?
-          super
-        end
-
-        private
-
-        # Execute the stored prepared statement name and the stored bind
-        # arguments instead of the SQL given.
-        def execute(sql, opts=OPTS, &block)
-          super(prepared_statement_name, opts, &block)
-        end
-
-        # Same as execute, explicit due to intricacies of alias and super.
-        def execute_dui(sql, opts=OPTS, &block)
-          super(prepared_statement_name, opts, &block)
-        end
-      end
-
-
-      # Execute the given type of statement with the hash of values.
-      def call(type, bind_vars=OPTS, *values, &block)
-        ps = to_prepared_statement(type, values)
-        ps.extend(BindArgumentMethods)
-        ps.call(bind_vars, &block)
-      end
-
-      # Yield all rows returned by executing the given SQL and converting
-      # the types.
-      def fetch_rows(sql)
-        execute(sql) do |res|
-          columns = set_columns(res)
-          yield_hash_rows(res, columns) {|h| yield h}
-        end
-      end
-
-      # Prepare the given type of statement with the given name, and store
-      # it in the database to be called later.
-      def prepare(type, name=nil, *values)
-        ps = to_prepared_statement(type, values)
-        ps.extend(PreparedStatementMethods)
-        if name
-          ps.prepared_statement_name = name
-          db.set_prepared_statement(name, ps)
-        end
-        ps
-      end
-
-      private
-
-      def set_columns(res)
-        cols = []
-        procs = db.conversion_procs
-        res.nfields.times do |fieldnum|
-          cols << [fieldnum, procs[res.ftype(fieldnum)], output_identifier(res.fname(fieldnum))]
-        end
-        @columns = cols.map{|c| c[2]}
-        cols
-      end
-
-      # For each row in the result set, yield a hash with column name symbol
-      # keys and typecasted values.
-      def yield_hash_rows(res, cols)
-        res.ntuples.times do |recnum|
-          converted_rec = {}
-          cols.each do |fieldnum, type_proc, fieldsym|
-            value = res.getvalue(recnum, fieldnum)
-            converted_rec[fieldsym] = (value && type_proc) ? type_proc.call(value) : value
-          end
-          yield converted_rec
-        end
-      end
-
-    end
-
-    # Connection specific methods for Fdbsql with pg
-    class Connection < PG::Connection
-      # Regular expression for error messages that note that the connection is closed.
-      DISCONNECT_ERROR_RE = /\A(?:could not receive data from server|no connection to the server|connection not open|connection is closed)/
-
-      # Hash of prepared statements for this connection.  Keys are
-      # string names of the server side prepared statement, and values
-      # are SQL strings.
-      attr_accessor :prepared_statements
-
-      # Create a new connection to the FoundationDB SQL Layer. See Database#connect.
-      def initialize(db, opts)
-        connect_opts = {
-          :host => opts[:host] || 'localhost',
-          :port => opts[:port] || 15432,
-          :dbname => opts[:database],
-          :user => opts[:user],
-          :password => opts[:password],
-          :hostaddr => opts[:hostaddr],
-          :connect_timeout => opts[:connect_timeout] || 20,
-          :sslmode => opts[:sslmode]
-        }.delete_if{|key, value| value.nil? or (value.respond_to?(:empty?) and value.empty?)}
-	super(connect_opts)
-
-        @db = db
-        @prepared_statements = {}
-
-        if opts[:notice_receiver]
-          set_notice_receiver(opts[:notice_receiver])
-        else
-          # Swallow warnings
-          set_notice_receiver{|proc| }
-        end
-      end
-
-      # Close the connection.
-      def close
-        super
-      rescue PGError, IOError
-      end
-
-      # Execute the given SQL with this connection.  If a block is given,
-      # yield the results, otherwise, return the number of changed rows.
-      def execute(sql, args=nil)
-        q = query(sql, args)
-        block_given? ? yield(q) : q.cmd_tuples
-      end
-
-      # Execute the prepared statement of the given name, binding the given
-      # args.
-      def execute_prepared_statement(name, args)
-        check_disconnect_errors{exec_prepared(name, args)}
-      end
-
-      # Prepare a statement for later use.
-      def prepare(name, sql)
-        check_disconnect_errors{super}
-      end
-
-      # Execute the given query and return the results.
-      def query(sql, args=nil)
-        args = args.map{|v| @db.bound_variable_arg(v, self)} if args
-        check_disconnect_errors{super}
-      end
-
-      private
-
-      # Raise a Sequel::DatabaseDisconnectError if a PGError is raised and
-      # the connection status cannot be determined or it is not OK.
-      def check_disconnect_errors
-        begin
-          yield
-        rescue PGError => e
-          disconnect = false
-          disconnect ||= e.message =~ DISCONNECT_ERROR_RE
-          disconnect ? raise(Sequel.convert_exception_class(e, Sequel::DatabaseDisconnectError)) : raise
-        rescue IOError, Errno::EPIPE, Errno::ECONNRESET => e
-          disconnect = true
-          raise(Sequel.convert_exception_class(e, Sequel::DatabaseDisconnectError))
-        end
-      end
-    end
-  end
-end