sequel 3.21.0 → 3.32.0

data/lib/sequel/adapters/postgres.rb

@@ -93,13 +93,14 @@ module Sequel
       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
+      def date(s) ::Date.new(*s.split("-").map{|x| x.to_i}) end
     end.new
 
+    # Hash with type name symbols and callable values for converting PostgreSQL types.
+    # Non-builtin types that don't have fixed numbers should use this to register
+    # conversion procs.
+    PG_NAMED_TYPES = {}
+
     # Hash with integer keys and callable values for converting PostgreSQL types.
     PG_TYPES = {}
     {
@@ -107,9 +108,8 @@ module Sequel
       [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)
+      [790, 1700] => ::BigDecimal.method(:new),
+      [1083, 1266] => ::Sequel.method(:string_to_time),
     }.each do |k,v|
       k.each{|n| PG_TYPES[n] = v}
     end
@@ -123,7 +123,7 @@ module Sequel
 
     # 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)
+      PG_TYPES[1082] = v ? TYPE_TRANSLATOR.method(:date) : Sequel.method(:string_to_date)
       @use_iso_date_format = v
     end
     self.use_iso_date_format = true
@@ -131,7 +131,10 @@ module Sequel
     # PGconn subclass for connection specific methods used with the
     # pg, postgres, or postgres-pr driver.
     class Adapter < ::PGconn
+      DISCONNECT_ERROR_RE = /\Acould not receive data from server: Software caused connection abort/
+      
       include Sequel::Postgres::AdapterMethods
+
       self.translate_results = false if respond_to?(:translate_results=)
       
       # Hash of prepared statements for this connection.  Keys are
@@ -150,20 +153,23 @@ module Sequel
         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
@@ -176,7 +182,7 @@ module Sequel
         begin
           block_given? ? yield(q) : q.cmd_tuples
         ensure
-          q.clear
+          q.clear if q
         end
       end
 
@@ -194,6 +200,10 @@ module Sequel
       include Sequel::Postgres::DatabaseMethods
       
       set_adapter_scheme :postgres
+
+      # A hash of conversion procs, keyed by type integer (oid) and
+      # having callable values for the conversion proc for that type.
+      attr_reader :conversion_procs
       
       # Add the primary_keys and primary_key_sequences instance variables,
       # so we can get the correct return values for inserted rows.
@@ -208,14 +218,27 @@ module Sequel
       # client encoding for the connection.
       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,
+            :tty => '',
+            :dbname => opts[:database],
+            :user => opts[:user],
+            :password => opts[:password],
+            :connect_timeout => opts[:connect_timeout] || 20
+          }.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)
@@ -225,14 +248,10 @@ module Sequel
         end
         conn.db = self
         conn.apply_connection_settings
+        @conversion_procs ||= get_conversion_procs(conn)
         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
@@ -253,6 +272,119 @@ module Sequel
         end
       end
       
+      if SEQUEL_POSTGRES_USES_PG
+        # +copy_table+ uses PostgreSQL's +COPY+ 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 FROM+ or +COPY TO+
+        # with a filename, you should just use +run+ instead of this method.  This
+        # method does not currently support +COPY FROM STDIN+, but that may be supported
+        # in the future.
+        #
+        # 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
+
+        # 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
+        
       private
       
       # Convert exceptions raised from the block into DatabaseErrors.
@@ -305,12 +437,29 @@ module Sequel
           end
         end
       end
+
+      # Return the conversion procs hash to use for this database
+      def get_conversion_procs(conn)
+        procs = PG_TYPES.dup
+        procs[1114] = method(:to_application_timestamp)
+        procs[1184] = method(:to_application_timestamp)
+        conn.execute("SELECT oid, typname FROM pg_type where typtype = 'b'") do |res|
+          res.ntuples.times do |recnum|
+            if pr = PG_NAMED_TYPES[res.getvalue(recnum, 1).untaint.to_sym]
+              procs[res.getvalue(recnum, 0).to_i] ||= pr
+            end
+          end
+        end
+        procs
+      end
     end
     
     # Dataset class for PostgreSQL datasets that use the pg, postgres, or
     # postgres-pr driver.
     class Dataset < Sequel::Dataset
       include Sequel::Postgres::DatasetMethods
+
+      Database::DatasetClass = self
       
       # Yield all rows returned by executing the given SQL and converting
       # the types.
@@ -372,11 +521,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
           
@@ -400,7 +555,12 @@ module Sequel
         # 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
           
@@ -427,7 +587,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)
@@ -483,21 +643,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 << "'" << db.synchronize{|c| c.escape_bytea(v)} << "'"
       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 << "'" << db.synchronize{|c| c.escape_string(v)} << "'"
       end
       
       # For each row in the result set, yield a hash with column name symbol

data/lib/sequel/adapters/shared/access.rb

@@ -1,21 +1,17 @@
 module Sequel
   module Access
     module DatabaseMethods
+      # Access uses type :access as the database_type
       def database_type
         :access
       end
 
-      def dataset(opts = nil)
-        ds = super
-        ds.extend(DatasetMethods)
-        ds
-      end
-
       # Doesn't work, due to security restrictions on MSysObjects
       def tables
         from(:MSysObjects).filter(:Type=>1, :Flags=>0).select_map(:Name).map{|x| x.to_sym}
       end
 
+      # Access uses type Counter for an autoincrementing keys
       def serial_primary_key_options
         {:primary_key => true, :type=>:Counter}
       end
@@ -32,18 +28,45 @@ module Sequel
     end
   
     module DatasetMethods
-      SELECT_CLAUSE_METHODS = Dataset.clause_methods(:select, %w'limit distinct columns from join where group order having compounds')
+      SELECT_CLAUSE_METHODS = Dataset.clause_methods(:select, %w'select limit distinct columns from join where group order having compounds')
+      DATE_FORMAT = '#%Y-%m-%d#'.freeze
+      TIMESTAMP_FORMAT = '#%Y-%m-%d %H:%M:%S#'.freeze
+      TOP = " TOP ".freeze
+      BRACKET_CLOSE = Dataset::BRACKET_CLOSE
+      BRACKET_OPEN = Dataset::BRACKET_OPEN
 
+      # Access doesn't support INTERSECT or EXCEPT
       def supports_intersect_except?
         false
       end
 
       private
 
-      def quoted_identifier(v)
-        "[#{v}]"
+      # Access uses # to quote dates
+      def literal_date(d)
+        d.strftime(DATE_FORMAT)
+      end
+
+      # Access uses # to quote datetimes
+      def literal_datetime(t)
+        t.strftime(TIMESTAMP_FORMAT)
+      end
+      alias literal_time literal_datetime
+
+      # Access uses TOP for limits
+      def select_limit_sql(sql)
+        if l = @opts[:limit]
+          sql << TOP
+          literal_append(sql, l)
+        end
+      end
+
+      # Access uses [] for quoting identifiers
+      def quoted_identifier_append(sql, v)
+        sql << BRACKET_OPEN << v.to_s << BRACKET_CLOSE
       end
 
+      # Access requires the limit clause come before other clauses
       def select_clause_methods
         SELECT_CLAUSE_METHODS
       end