sequel 3.21.0 → 3.39.0

data/lib/sequel/adapters/postgres.rb

@@ -12,7 +12,7 @@ rescue LoadError => e
     class PGconn
       unless method_defined?(:escape_string)
         if self.respond_to?(:escape)
-          # If there is no escape_string instead method, but there is an
+          # If there is no escape_string instance method, but there is an
           # escape class method, use that instead.
           def escape_string(str)
             Sequel::Postgres.force_standard_strings ? str.gsub("'", "''") : self.class.escape(str)
@@ -87,51 +87,16 @@ module Sequel
   Dataset::NON_SQL_OPTIONS << :cursor
   module Postgres
     CONVERTED_EXCEPTIONS << PGError
-    
-    TYPE_TRANSLATOR = tt = Class.new do
-      def boolean(s) s == 't' end
+
+    PG_TYPES[17] = Class.new do
       def bytea(s) ::Sequel::SQL::Blob.new(Adapter.unescape_bytea(s)) end
-      def integer(s) s.to_i end
-      def float(s) s.to_f end
-      def numeric(s) ::BigDecimal.new(s) end
-      def date(s) ::Sequel.string_to_date(s) end
-      def date_iso(s) ::Date.new(*s.split("-").map{|x| x.to_i}) end
-      def time(s) ::Sequel.string_to_time(s) end
-      def timestamp(s) ::Sequel.database_to_application_timestamp(s) end
-    end.new
-
-    # Hash with integer keys and callable values for converting PostgreSQL types.
-    PG_TYPES = {}
-    {
-      [16] => tt.method(:boolean),
-      [17] => tt.method(:bytea),
-      [20, 21, 22, 23, 26] => tt.method(:integer),
-      [700, 701] => tt.method(:float),
-      [790, 1700] => tt.method(:numeric),
-      [1083, 1266] => tt.method(:time),
-      [1114, 1184] => tt.method(:timestamp)
-    }.each do |k,v|
-      k.each{|n| PG_TYPES[n] = v}
-    end
-    
-    class << self
-      # As an optimization, Sequel sets the date style to ISO, so that PostgreSQL provides
-      # the date in a known format that Sequel can parse faster.  This can be turned off
-      # if you require a date style other than ISO.
-      attr_reader :use_iso_date_format
-    end
+    end.new.method(:bytea)
 
-    # Modify the type translator for the date type depending on the value given.
-    def self.use_iso_date_format=(v)
-      PG_TYPES[1082] = TYPE_TRANSLATOR.method(v ? :date_iso : :date)
-      @use_iso_date_format = v
-    end
-    self.use_iso_date_format = true
-    
     # PGconn subclass for connection specific methods used with the
     # pg, postgres, or postgres-pr driver.
     class Adapter < ::PGconn
-      include Sequel::Postgres::AdapterMethods
+      DISCONNECT_ERROR_RE = /\Acould not receive data from server: Software caused connection abort/
+      
       self.translate_results = false if respond_to?(:translate_results=)
       
       # Hash of prepared statements for this connection.  Keys are
@@ -139,31 +104,22 @@ module Sequel
       # are SQL strings.
       attr_reader(:prepared_statements) if SEQUEL_POSTGRES_USES_PG
       
-      # Apply connection settings for this connection.  Current sets
-      # the date style to ISO in order make Date object creation in ruby faster,
-      # if Postgres.use_iso_date_format is true.
-      def apply_connection_settings
-        super
-        if Postgres.use_iso_date_format
-          sql = "SET DateStyle = 'ISO'"
-          execute(sql)
-        end
-        @prepared_statements = {} if SEQUEL_POSTGRES_USES_PG
-      end
-      
       # 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
           begin
             s = status
           rescue PGError
-            raise Sequel.convert_exception_class(e, Sequel::DatabaseDisconnectError)
+            disconnect = true
           end
           status_ok = (s == Adapter::CONNECTION_OK)
-          status_ok ? raise : raise(Sequel.convert_exception_class(e, Sequel::DatabaseDisconnectError))
+          disconnect ||= !status_ok
+          disconnect ||= e.message =~ DISCONNECT_ERROR_RE
+          disconnect ? raise(Sequel.convert_exception_class(e, Sequel::DatabaseDisconnectError)) : raise
         ensure
           block if status_ok
         end
@@ -172,19 +128,21 @@ module Sequel
       # 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 = check_disconnect_errors{@db.log_yield(sql, args){args ? async_exec(sql, args) : async_exec(sql)}}
+        args = args.map{|v| @db.bound_variable_arg(v, self)} if args
+        q = check_disconnect_errors{execute_query(sql, args)}
         begin
           block_given? ? yield(q) : q.cmd_tuples
         ensure
-          q.clear
+          q.clear if q && q.respond_to?(:clear)
         end
       end
 
       private
-      
-      # Return the requested values for the given row.
-      def single_value(r)
-        r.getvalue(0, 0) unless r.nil? || (r.ntuples == 0)
+
+      # Return the PGResult object that is returned by executing the given
+      # sql and args.
+      def execute_query(sql, args)
+        @db.log_yield(sql, args){args ? async_exec(sql, args) : async_exec(sql)}
       end
     end
     
@@ -192,30 +150,72 @@ module Sequel
     # pg, postgres, or postgres-pr driver.
     class Database < Sequel::Database
       include Sequel::Postgres::DatabaseMethods
+
+      INFINITE_TIMESTAMP_STRINGS = ['infinity'.freeze, '-infinity'.freeze].freeze
+      INFINITE_DATETIME_VALUES = ([PLUS_INFINITY, MINUS_INFINITY] + INFINITE_TIMESTAMP_STRINGS).freeze
       
       set_adapter_scheme :postgres
+
+      # Whether infinite timestamps should be converted on retrieval.  By default, no
+      # conversion is done, so an error is raised if you attempt to retrieve an infinite
+      # timestamp.  You can set this to :nil to convert to nil, :string to leave
+      # as a string, or :float to convert to an infinite float.
+      attr_accessor :convert_infinite_timestamps
       
       # Add the primary_keys and primary_key_sequences instance variables,
       # so we can get the correct return values for inserted rows.
       def initialize(*args)
         super
-        @primary_keys = {}
-        @primary_key_sequences = {}
+        @convert_infinite_timestamps = false
+        initialize_postgres_adapter
+      end
+
+      # Convert given argument so that it can be used directly by pg.  Currently, pg doesn't
+      # handle fractional seconds in Time/DateTime or blobs with "\0", and it won't ever
+      # handle Sequel::SQLTime values correctly.  Only public for use by the adapter, shouldn't
+      # be used by external code.
+      def bound_variable_arg(arg, conn)
+        case arg
+        when Sequel::SQL::Blob
+          conn.escape_bytea(arg)
+        when Sequel::SQLTime
+          literal(arg)
+        when DateTime, Time
+          literal(arg)
+        else
+          arg
+        end
       end
 
       # Connects to the database.  In addition to the standard database
       # options, using the :encoding or :charset option changes the
-      # client encoding for the connection.
+      # client encoding for the connection, :connect_timeout is a
+      # connection timeout in seconds, and :sslmode sets whether postgres's
+      # sslmode.  :connect_timeout and :ssl_mode are only supported if the pg
+      # driver is used.
       def connect(server)
         opts = server_opts(server)
-        conn = Adapter.connect(
-          (opts[:host] unless blank_object?(opts[:host])),
-          opts[:port] || 5432,
-          nil, '',
-          opts[:database],
-          opts[:user],
-          opts[:password]
-        )
+        conn = if SEQUEL_POSTGRES_USES_PG
+          connection_params = {
+            :host => opts[:host],
+            :port => opts[:port] || 5432,
+            :dbname => opts[:database],
+            :user => opts[:user],
+            :password => opts[:password],
+            :connect_timeout => opts[:connect_timeout] || 20,
+            :sslmode => opts[:sslmode]
+          }.delete_if { |key, value| blank_object?(value) }
+          Adapter.connect(connection_params)
+        else
+          Adapter.connect(
+            (opts[:host] unless blank_object?(opts[:host])),
+            opts[:port] || 5432,
+            nil, '',
+            opts[:database],
+            opts[:user],
+            opts[:password]
+          )
+        end
         if encoding = opts[:encoding] || opts[:charset]
           if conn.respond_to?(:set_client_encoding)
             conn.set_client_encoding(encoding)
@@ -223,38 +223,220 @@ module Sequel
             conn.async_exec("set client_encoding to '#{encoding}'")
           end
         end
-        conn.db = self
-        conn.apply_connection_settings
+        conn.instance_variable_set(:@db, self)
+        conn.instance_variable_set(:@prepared_statements, {}) if SEQUEL_POSTGRES_USES_PG
+        connection_configuration_sqls.each{|sql| conn.execute(sql)}
         conn
       end
       
-      # Return instance of Sequel::Postgres::Dataset with the given options.
-      def dataset(opts = nil)
-        Postgres::Dataset.new(self, opts)
-      end
-      
       # Execute the given SQL with the given args on an available connection.
       def execute(sql, opts={}, &block)
-        check_database_errors do
-          return execute_prepared_statement(sql, opts, &block) if Symbol === sql
-          synchronize(opts[:server]){|conn| conn.execute(sql, opts[:arguments], &block)}
+        synchronize(opts[:server]){|conn| check_database_errors{_execute(conn, sql, opts, &block)}}
+      end
+
+      if SEQUEL_POSTGRES_USES_PG
+        # +copy_table+ uses PostgreSQL's +COPY TO STDOUT+ SQL statement to return formatted
+        # results directly to the caller.  This method is only supported if pg is the
+        # underlying ruby driver.  This method should only be called if you want
+        # results returned to the client.  If you are using +COPY TO+
+        # with a filename, you should just use +run+ instead of this method.
+        #
+        # The table argument supports the following types:
+        #
+        # String :: Uses the first argument directly as literal SQL. If you are using
+        #           a version of PostgreSQL before 9.0, you will probably want to
+        #           use a string if you are using any options at all, as the syntax
+        #           Sequel uses for options is only compatible with PostgreSQL 9.0+.
+        # Dataset :: Uses a query instead of a table name when copying.
+        # other :: Uses a table name (usually a symbol) when copying.
+        # 
+        # The following options are respected:
+        #
+        # :format :: The format to use.  text is the default, so this should be :csv or :binary.
+        # :options :: An options SQL string to use, which should contain comma separated options.
+        # :server :: The server on which to run the query.
+        #
+        # If a block is provided, the method continually yields to the block, one yield
+        # per row.  If a block is not provided, a single string is returned with all
+        # of the data.
+        def copy_table(table, opts={})
+          sql = if table.is_a?(String)
+            sql = table
+          else
+            if opts[:options] || opts[:format]
+              options = " ("
+              options << "FORMAT #{opts[:format]}" if opts[:format]
+              options << "#{', ' if opts[:format]}#{opts[:options]}" if opts[:options]
+              options << ')'
+            end
+            table = if table.is_a?(::Sequel::Dataset)
+              "(#{table.sql})"
+            else
+              literal(table)
+            end
+           sql = "COPY #{table} TO STDOUT#{options}"
+          end
+          synchronize(opts[:server]) do |conn| 
+            conn.execute(sql)
+            begin
+              if block_given?
+                while buf = conn.get_copy_data
+                  yield buf
+                end
+                nil
+              else
+                b = ''
+                b << buf while buf = conn.get_copy_data
+                b
+              end
+            ensure
+              raise DatabaseDisconnectError, "disconnecting as a partial COPY may leave the connection in an unusable state" if buf
+            end
+          end 
+        end
+
+        # +copy_into+ uses PostgreSQL's +COPY FROM STDIN+ SQL statement to do very fast inserts 
+        # into a table using input preformatting in either CSV or PostgreSQL text format.
+        # This method is only supported if pg is the underlying ruby driver.  This method should only be called if you want
+        # results returned to the client.  If you are using +COPY FROM+
+        # with a filename, you should just use +run+ instead of this method.
+        #
+        # The following options are respected:
+        #
+        # :columns :: The columns to insert into, with the same order as the columns in the
+        #             input data.  If this isn't given, uses all columns in the table.
+        # :data :: The data to copy to PostgreSQL, which should already be in CSV or PostgreSQL
+        #          text format.  This can be either a string, or any object that responds to
+        #          each and yields string.
+        # :format :: The format to use.  text is the default, so this should be :csv or :binary.
+        # :options :: An options SQL string to use, which should contain comma separated options.
+        # :server :: The server on which to run the query.
+        #
+        # If a block is provided and :data option is not, this will yield to the block repeatedly.
+        # The block should return a string, or nil to signal that it is finished.
+        def copy_into(table, opts={})
+          sql = "COPY #{literal(table)}"
+          if cols = opts[:columns]
+            sql << literal(Array(cols))
+          end
+          sql << " FROM STDIN"
+          if opts[:options] || opts[:format]
+            sql << " ("
+            sql << "FORMAT #{opts[:format]}" if opts[:format]
+            sql << "#{', ' if opts[:format]}#{opts[:options]}" if opts[:options]
+            sql << ')'
+          end
+          
+          data = opts[:data]
+          data = Array(data) if data.is_a?(String)
+
+          if block_given? && data
+            raise Error, "Cannot provide both a :data option and a block to copy_into"
+          elsif !block_given? && !data
+            raise Error, "Must provide either a :data option or a block to copy_into"
+          end
+
+          synchronize(opts[:server]) do |conn| 
+            conn.execute(sql)
+            begin
+              if block_given?
+                while buf = yield
+                  conn.put_copy_data(buf)
+                end
+              else
+                data.each{|buf| conn.put_copy_data(buf)}
+              end
+            rescue Exception => e
+              conn.put_copy_end("ruby exception occurred while copying data into PostgreSQL")
+              raise
+            ensure
+              conn.put_copy_end unless e
+              conn.get_result
+            end
+          end 
+        end
+
+        # Listens on the given channel (or multiple channels if channel is an array), waiting for notifications.
+        # After a notification is received, or the timeout has passed, stops listening to the channel. Options:
+        #
+        # :after_listen :: An object that responds to +call+ that is called with the underlying connection after the LISTEN
+        #                  statement is sent, but before the connection starts waiting for notifications.
+        # :loop :: Whether to continually wait for notifications, instead of just waiting for a single
+        #          notification. If this option is given, a block must be provided.  If this object responds to call, it is
+        #          called with the underlying connection after each notification is received (after the block is called).
+        #          If a :timeout option is used, and a callable object is given, the object will also be called if the
+        #          timeout expires.  If :loop is used and you want to stop listening, you can either break from inside the
+        #          block given to #listen, or you can throw :stop from inside the :loop object's call method or the block.
+        # :server :: The server on which to listen, if the sharding support is being used.
+        # :timeout :: How long to wait for a notification, in seconds (can provide a float value for
+        #             fractional seconds).  If not given or nil, waits indefinitely.
+        #
+        # This method is only supported if pg is used as the underlying ruby driver.  It returns the
+        # channel the notification was sent to (as a string), unless :loop was used, in which case it returns nil.
+        # If a block is given, it is yielded 3 arguments:
+        # * the channel the notification was sent to (as a string)
+        # * the backend pid of the notifier (as an integer),
+        # * and the payload of the notification (as a string or nil).
+        def listen(channels, opts={}, &block)
+          check_database_errors do
+            synchronize(opts[:server]) do |conn|
+              begin
+                channels = Array(channels)
+                channels.each{|channel| conn.execute("LISTEN #{channel}")}
+                opts[:after_listen].call(conn) if opts[:after_listen]
+                timeout = opts[:timeout] ? [opts[:timeout]] : []
+                if l = opts[:loop]
+                  raise Error, 'calling #listen with :loop requires a block' unless block
+                  loop_call = l.respond_to?(:call)
+                  catch(:stop) do
+                    loop do
+                      conn.wait_for_notify(*timeout, &block)
+                      l.call(conn) if loop_call
+                    end
+                  end
+                  nil
+                else
+                  conn.wait_for_notify(*timeout, &block)
+                end
+              ensure
+                conn.execute("UNLISTEN *")
+              end
+            end
+          end
         end
       end
-      
-      # Insert the values into the table and return the primary key (if
-      # automatically generated).
-      def execute_insert(sql, opts={})
-        return execute(sql, opts) if Symbol === sql
-        check_database_errors do
-          synchronize(opts[:server]) do |conn|
-            conn.execute(sql, opts[:arguments])
-            insert_result(conn, opts[:table], opts[:values])
+
+      # If convert_infinite_timestamps is true and the value is infinite, return an appropriate
+      # value based on the convert_infinite_timestamps setting.
+      def to_application_timestamp(value)
+        if c = convert_infinite_timestamps
+          case value
+          when *INFINITE_TIMESTAMP_STRINGS
+            infinite_timestamp_value(value)
+          else
+            super
           end
+        else
+          super
         end
       end
-      
+        
       private
-      
+
+      # Execute the given SQL string or prepared statement on the connection object.
+      def _execute(conn, sql, opts, &block)
+        if sql.is_a?(Symbol)
+          execute_prepared_statement(conn, sql, opts, &block)
+        else
+          conn.execute(sql, opts[:arguments], &block)
+        end
+      end
+
+      # Execute the prepared statement name with the given arguments on the connection.
+      def _execute_prepared_statement(conn, ps_name, args, opts)
+        conn.exec_prepared(ps_name, args)
+      end
+
       # Convert exceptions raised from the block into DatabaseErrors.
       def check_database_errors
         begin
@@ -264,6 +446,13 @@ module Sequel
         end
       end
 
+      # Set the DateStyle to ISO if configured, for faster date parsing.
+      def connection_configuration_sqls
+        sqls = super
+        sqls << "SET DateStyle = 'ISO'" if Postgres.use_iso_date_format
+        sqls
+      end
+
       # Disconnect given connection
       def disconnect_connection(conn)
         begin
@@ -278,31 +467,67 @@ module Sequel
       # has prepared a statement with the same name and different SQL,
       # deallocate that statement first and then prepare this statement.
       # If a block is given, yield the result, otherwise, return the number
-      # of rows changed.  If the :insert option is passed, return the value
-      # of the primary key for the last inserted row.
-      def execute_prepared_statement(name, opts={})
-        ps = prepared_statements[name]
+      # of rows changed.
+      def execute_prepared_statement(conn, name, opts={}, &block)
+        ps = prepared_statement(name)
         sql = ps.prepared_sql
         ps_name = name.to_s
-        args = opts[:arguments]
-        synchronize(opts[:server]) do |conn|
-          unless conn.prepared_statements[ps_name] == sql
-            if conn.prepared_statements.include?(ps_name)
-              conn.execute("DEALLOCATE #{ps_name}") unless conn.prepared_statements[ps_name] == sql
-            end
-            conn.prepared_statements[ps_name] = sql
-            conn.check_disconnect_errors{log_yield("PREPARE #{ps_name} AS #{sql}"){conn.prepare(ps_name, sql)}}
-          end
-          q = conn.check_disconnect_errors{log_yield("EXECUTE #{ps_name}", args){conn.exec_prepared(ps_name, args)}}
-          if opts[:table] && opts[:values]
-            insert_result(conn, opts[:table], opts[:values])
+
+        if args = opts[:arguments]
+          args = args.map{|arg| bound_variable_arg(arg, conn)}
+        end
+
+        unless conn.prepared_statements[ps_name] == sql
+          conn.execute("DEALLOCATE #{ps_name}") if conn.prepared_statements.include?(ps_name)
+          conn.prepared_statements[ps_name] = sql
+          conn.check_disconnect_errors{log_yield("PREPARE #{ps_name} AS #{sql}"){conn.prepare(ps_name, sql)}}
+        end
+
+        log_sql = "EXECUTE #{ps_name}"
+        if ps.log_sql
+          log_sql << " ("
+          log_sql << sql
+          log_sql << ")"
+        end
+
+        q = conn.check_disconnect_errors{log_yield(log_sql, args){_execute_prepared_statement(conn, ps_name, args, opts)}}
+        begin
+          block_given? ? yield(q) : q.cmd_tuples
+        ensure
+          q.clear if q && q.respond_to?(:clear)
+        end
+      end
+
+      # Return an appropriate value for the given infinite timestamp string.
+      def infinite_timestamp_value(value)
+        case convert_infinite_timestamps
+        when :nil
+          nil
+        when :string
+          value
+        else
+          value == 'infinity' ? PLUS_INFINITY : MINUS_INFINITY
+        end
+      end
+      
+      # Don't log, since logging is done by the underlying connection.
+      def log_connection_execute(conn, sql)
+        conn.execute(sql)
+      end
+
+      # If the value is an infinite value (either an infinite float or a string returned by
+      # by PostgreSQL for an infinite timestamp), return it without converting it if
+      # convert_infinite_timestamps is set.
+      def typecast_value_datetime(value)
+        if convert_infinite_timestamps
+          case value
+          when *INFINITE_DATETIME_VALUES
+            value
           else
-            begin
-              block_given? ? yield(q) : q.cmd_tuples
-            ensure
-              q.clear
-            end
+            super
           end
+        else
+          super
         end
       end
     end
@@ -311,12 +536,15 @@ module Sequel
     # postgres-pr driver.
     class Dataset < Sequel::Dataset
       include Sequel::Postgres::DatasetMethods
+
+      Database::DatasetClass = self
+      APOS = Sequel::Dataset::APOS
       
       # Yield all rows returned by executing the given SQL and converting
       # the types.
-      def fetch_rows(sql, &block)
-        return cursor_fetch_rows(sql, &block) if @opts[:cursor]
-        execute(sql){|res| yield_hash_rows(res, fetch_rows_set_cols(res), &block)}
+      def fetch_rows(sql)
+        return cursor_fetch_rows(sql){|h| yield h} if @opts[:cursor]
+        execute(sql){|res| yield_hash_rows(res, fetch_rows_set_cols(res)){|h| yield h}}
       end
       
       # Uses a cursor for fetching records, instead of fetching the entire result
@@ -372,11 +600,17 @@ module Sequel
             end
             LiteralString.new("#{prepared_arg_placeholder}#{i}#{"::#{type}" if type}")
           end
+
+          # Always assume a prepared argument.
+          def prepared_arg?(k)
+           true
+          end
         end
 
         # Allow use of bind arguments for PostgreSQL using the pg driver.
         module BindArgumentMethods
           include ArgumentMapper
+          include ::Sequel::Postgres::DatasetMethods::PreparedStatementMethods
           
           private
           
@@ -389,18 +623,18 @@ module Sequel
           def execute_dui(sql, opts={}, &block)
             super(sql, {:arguments=>bind_arguments}.merge(opts), &block)
           end
-          
-          # Same as execute, explicit due to intricacies of alias and super.
-          def execute_insert(sql, opts={}, &block)
-            super(sql, {:arguments=>bind_arguments}.merge(opts), &block)
-          end
         end
         
         # Allow use of server side prepared statements for PostgreSQL using the
         # pg driver.
         module PreparedStatementMethods
           include BindArgumentMethods
-          include ::Sequel::Postgres::DatasetMethods::PreparedStatementMethods
+
+          # 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
           
@@ -414,11 +648,6 @@ module Sequel
           def execute_dui(sql, opts={}, &block)
             super(prepared_statement_name, opts, &block)
           end
-          
-          # Same as execute, explicit due to intricacies of alias and super.
-          def execute_insert(sql, opts={}, &block)
-            super(prepared_statement_name, opts, &block)
-          end
         end
         
         # Execute the given type of statement with the hash of values.
@@ -427,7 +656,7 @@ module Sequel
           ps.extend(BindArgumentMethods)
           ps.call(bind_vars, &block)
         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)
@@ -435,7 +664,7 @@ module Sequel
           ps.extend(PreparedStatementMethods)
           if name
             ps.prepared_statement_name = name
-            db.prepared_statements[name] = ps
+            db.set_prepared_statement(name, ps)
           end
           ps
         end
@@ -452,7 +681,7 @@ module Sequel
       private
       
       # Use a cursor to fetch groups of records at a time, yielding them to the block.
-      def cursor_fetch_rows(sql, &block)
+      def cursor_fetch_rows(sql)
         server_opts = {:server=>@opts[:server] || :read_only}
         db.transaction(server_opts) do 
           begin
@@ -464,12 +693,12 @@ module Sequel
             # Load columns only in the first fetch, so subsequent fetches are faster
             execute(fetch_sql) do |res|
               cols = fetch_rows_set_cols(res)
-              yield_hash_rows(res, cols, &block)
+              yield_hash_rows(res, cols){|h| yield h}
               return if res.ntuples < rows_per_fetch
             end
             loop do
               execute(fetch_sql) do |res|
-                yield_hash_rows(res, cols, &block)
+                yield_hash_rows(res, cols){|h| yield h}
                 return if res.ntuples < rows_per_fetch
               end
             end
@@ -483,21 +712,22 @@ module Sequel
       # field numers, type conversion procs, and name symbol arrays.
       def fetch_rows_set_cols(res)
         cols = []
+        procs = db.conversion_procs
         res.nfields.times do |fieldnum|
-          cols << [fieldnum, PG_TYPES[res.ftype(fieldnum)], output_identifier(res.fname(fieldnum))]
+          cols << [fieldnum, procs[res.ftype(fieldnum)], output_identifier(res.fname(fieldnum))]
         end
         @columns = cols.map{|c| c.at(2)}
         cols
       end
       
       # Use the driver's escape_bytea
-      def literal_blob(v)
-        db.synchronize{|c| "'#{c.escape_bytea(v)}'"}
+      def literal_blob_append(sql, v)
+        sql << APOS << db.synchronize{|c| c.escape_bytea(v)} << APOS
       end
       
       # Use the driver's escape_string
-      def literal_string(v)
-        db.synchronize{|c| "'#{c.escape_string(v)}'"}
+      def literal_string_append(sql, v)
+        sql << APOS << db.synchronize{|c| c.escape_string(v)} << APOS
       end
       
       # For each row in the result set, yield a hash with column name symbol