sequel 3.32.0 → 3.33.0

data/doc/testing.rdoc

@@ -106,7 +106,7 @@ These specs are broken down into two parts.  For each database, there are specif
 
 == Environment variables
 
-Sequel often uses environment variables when testing to specify either the database to be tested or specify how testing should be done.  You can also specify the databases to test by copying spec/spec_config.rb.example to spec/spec_config.rb and modifying it.  See that file for details.  It may be necessary to use spec_config.rb as opposed to an environment variable if you database connection cannot be specified by a connection string.
+Sequel often uses environment variables when testing to specify either the database to be tested or specify how testing should be done.  You can also specify the databases to test by copying spec/spec_config.rb.example to spec/spec_config.rb and modifying it.  See that file for details.  It may be necessary to use spec_config.rb as opposed to an environment variable if your database connection cannot be specified by a connection string.
 
 === Connection Strings
 

data/lib/sequel/adapters/do.rb

@@ -30,6 +30,7 @@ module Sequel
         Sequel.ts_require 'adapters/do/sqlite'
         db.extend(Sequel::DataObjects::SQLite::DatabaseMethods)
         db.dataset_class = Sequel::DataObjects::SQLite::Dataset
+        db.set_integer_booleans
       end
     }
       

data/lib/sequel/adapters/do/mysql.rb

@@ -30,6 +30,12 @@ module Sequel
         APOS_RE = Dataset::APOS_RE
         DOUBLE_APOS = Dataset::DOUBLE_APOS
         
+        # The DataObjects MySQL driver uses the number of rows actually modified in the update,
+        # instead of the number of matched by the filter.
+        def provides_accurate_rows_matched?
+          false
+        end
+      
         # Use execute_insert to execute the replace_sql.
         def replace(*args)
           execute_insert(replace_sql(*args))

data/lib/sequel/adapters/jdbc.rb

@@ -47,6 +47,7 @@ module Sequel
         Sequel.ts_require 'adapters/jdbc/sqlite'
         db.extend(Sequel::JDBC::SQLite::DatabaseMethods)
         db.dataset_class = Sequel::JDBC::SQLite::Dataset
+        db.set_integer_booleans
         JDBC.load_gem('sqlite3')
         org.sqlite.JDBC
       end,

data/lib/sequel/adapters/jdbc/mysql.rb

@@ -71,11 +71,6 @@ module Sequel
         def replace(*args)
           execute_insert(replace_sql(*args))
         end
-        
-        # MySQL on JDBC does provides an accurate number of rows matched.
-        def provides_accurate_rows_matched?
-          true
-        end
       end
     end
   end

data/lib/sequel/adapters/mock.rb

@@ -110,6 +110,7 @@ module Sequel
         super
         opts = @opts
         if mod_name = SHARED_ADAPTERS[opts[:host]]
+          @shared_adapter = true
           require "sequel/adapters/shared/#{opts[:host]}"
           extend Sequel.const_get(mod_name)::DatabaseMethods
           extend_datasets Sequel.const_get(mod_name)::DatasetMethods
@@ -155,7 +156,7 @@ module Sequel
 
       # Enable use of savepoints.
       def supports_savepoints?
-        true
+        shared_adapter? ? super : true
       end
 
       private
@@ -177,7 +178,7 @@ module Sequel
       def _execute(c, sql, opts={}, &block)
         sql += " -- args: #{opts[:arguments].inspect}" if opts[:arguments]
         sql += " -- #{@opts[:append]}" if @opts[:append]
-        sql += " -- #{c.server}" if c.server != :default
+        sql += " -- #{c.server.is_a?(Symbol) ? c.server : c.server.inspect}" if c.server != :default
         log_info(sql)
         @sqls << sql 
 
@@ -281,15 +282,19 @@ module Sequel
       end
 
       def quote_identifiers_default
-        false
+        shared_adapter? ? super : false
       end
 
       def identifier_input_method_default
-        nil
+        shared_adapter? ? super : nil
       end
 
       def identifier_output_method_default
-        nil
+        shared_adapter? ? super : nil
+      end
+
+      def shared_adapter?
+        @shared_adapter
       end
     end
 

data/lib/sequel/adapters/mysql.rb

@@ -268,6 +268,10 @@ module Sequel
       include Sequel::MySQL::PreparedStatements::DatasetMethods
 
       Database::DatasetClass = self
+
+      # Regular expression used for getting accurate number of rows
+      # matched by an update statement.
+      AFFECTED_ROWS_RE = /Rows matched:\s+(\d+)\s+Changed:\s+\d+\s+Warnings:\s+\d+/.freeze
       
       # Delete rows matching this dataset
       def delete
@@ -311,6 +315,12 @@ module Sequel
         execute_dui(insert_sql(*values)){|c| return c.insert_id}
       end
       
+      # You can parse out the correct number of rows matched using the query info,
+      # even though affected_rows doesn't provide an accurate number.
+      def provides_accurate_rows_matched?
+        true
+      end
+
       # Replace (update or insert) the matching row.
       def replace(*args)
         execute_dui(replace_sql(*args)){|c| return c.insert_id}
@@ -334,11 +344,23 @@ module Sequel
       
       # Update the matching rows.
       def update(values={})
-        execute_dui(update_sql(values)){|c| return c.affected_rows}
+        execute_dui(update_sql(values)){|c| return affected_rows(c)}
       end
       
       private
       
+      # Try to get an accurate number of rows matched using the query
+      # info.  Fall back to affected_rows if there was no match, but
+      # that may be inaccurate.
+      def affected_rows(conn)
+        s = conn.info
+        if s && s =~ AFFECTED_ROWS_RE
+          $1.to_i
+        else
+          conn.affected_rows
+        end
+      end
+
       # Set the :type option to :select if it hasn't been set.
       def execute(sql, opts={}, &block)
         super(sql, {:type=>:select}.merge(opts), &block)

data/lib/sequel/adapters/mysql2.rb

@@ -45,6 +45,7 @@ module Sequel
         opts = server_opts(server)
         opts[:host] ||= 'localhost'
         opts[:username] ||= opts[:user]
+        opts[:flags] = ::Mysql2::Client::FOUND_ROWS if ::Mysql2::Client.const_defined?(:FOUND_ROWS)
         conn = ::Mysql2::Client.new(opts)
 
         sqls = []
@@ -138,8 +139,21 @@ module Sequel
       # Yield all rows matching this dataset.
       def fetch_rows(sql, &block)
         execute(sql) do |r|
-          @columns = r.fields
-          r.each(:cast_booleans => db.convert_tinyint_to_bool, &block)
+          if identifier_output_method
+            cols = r.fields
+            @columns = cols2 = cols.map{|c| output_identifier(c.to_s)}
+            cs = cols.zip(cols2)
+            r.each(:cast_booleans => db.convert_tinyint_to_bool) do |row|
+              h = {}
+              cs.each do |a, b|
+                h[b] = row[a]
+              end
+              yield h
+            end
+          else
+            @columns = r.fields
+            r.each(:cast_booleans => db.convert_tinyint_to_bool, &block)
+          end
         end
         self
       end

data/lib/sequel/adapters/postgres.rb

@@ -88,11 +88,26 @@ module Sequel
   module Postgres
     CONVERTED_EXCEPTIONS << PGError
     
+    NAN             = 0.0/0.0
+    PLUS_INFINITY   = 1.0/0.0
+    MINUS_INFINITY  = -1.0/0.0
+    
     TYPE_TRANSLATOR = tt = Class.new do
       def boolean(s) s == 't' end
       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 float(s) 
+        case s
+        when 'NaN'
+          NAN
+        when 'Infinity'
+          PLUS_INFINITY
+        when '-Infinity'
+          MINUS_INFINITY
+        else
+          s.to_f 
+        end
+      end
       def date(s) ::Date.new(*s.split("-").map{|x| x.to_i}) end
     end.new
 
@@ -215,18 +230,21 @@ module Sequel
 
       # 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 = 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
+            :connect_timeout => opts[:connect_timeout] || 20,
+            :sslmode => opts[:sslmode]
           }.delete_if { |key, value| blank_object?(value) }
           Adapter.connect(connection_params)
         else

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

@@ -31,7 +31,7 @@ module Sequel
     module DatabaseMethods
       AUTO_INCREMENT = 'AUTO_INCREMENT'.freeze
       CAST_TYPES = {String=>:CHAR, Integer=>:SIGNED, Time=>:DATETIME, DateTime=>:DATETIME, Numeric=>:DECIMAL, BigDecimal=>:DECIMAL, File=>:BINARY}
-      COLUMN_DEFINITION_ORDER = [:null, :default, :unique, :primary_key, :auto_increment, :references]
+      COLUMN_DEFINITION_ORDER = [:collate, :null, :default, :unique, :primary_key, :auto_increment, :references]
       PRIMARY = 'PRIMARY'.freeze
       
       # MySQL's cast rules are restrictive in that you can't just cast to any possible
@@ -91,12 +91,18 @@ module Sequel
       
       # MySQL supports prepared transactions (two-phase commit) using XA
       def supports_prepared_transactions?
-        true
+        server_version >= 50000
       end
 
       # MySQL supports savepoints
       def supports_savepoints?
-        true
+        server_version >= 50000
+      end
+
+      # MySQL doesn't appear to support savepoints inside prepared transactions in >=5.5.12,
+      # see http://bugs.mysql.com/bug.php?id=64374
+      def supports_savepoints_in_prepared_transactions?
+        super && server_version <= 50512
       end
 
       # MySQL supports transaction isolation levels
@@ -139,6 +145,7 @@ module Sequel
           if related = op.delete(:table)
             sql = super(table, op)
             op[:table] = related
+            op[:key] ||= primary_key_from_schema(related)
             [sql, "ALTER TABLE #{quote_schema_table(table)} ADD FOREIGN KEY (#{quote_identifier(op[:name])})#{column_references_sql(op)}"]
           else
             super(table, op)
@@ -167,6 +174,11 @@ module Sequel
             raise(Error, "must specify constraint type via :type=>(:foreign_key|:primary_key|:unique) when dropping constraints on MySQL")
           end
           "ALTER TABLE #{quote_schema_table(table)} DROP #{type} #{quote_identifier(op[:name])}"
+        when :add_constraint
+          if op[:type] == :foreign_key
+            op[:key] ||= primary_key_from_schema(op[:table])
+          end
+          super(table, op)
         else
           super(table, op)
         end
@@ -222,11 +234,41 @@ module Sequel
         engine = options.fetch(:engine, Sequel::MySQL.default_engine)
         charset = options.fetch(:charset, Sequel::MySQL.default_charset)
         collate = options.fetch(:collate, Sequel::MySQL.default_collate)
+        generator.constraints.sort_by{|c| (c[:type] == :primary_key) ? -1 : 1}
+
+        key_proc = lambda do |t|
+          if t == name 
+            if pk = generator.primary_key_name
+              [pk]
+            elsif !(pkc = generator.constraints.select{|con| con[:type] == :primary_key}).empty?
+              pkc.first[:columns]
+            end
+          else
+            primary_key_from_schema(t)
+          end
+        end
+
+        generator.constraints.each do |c|
+          if c[:type] == :foreign_key
+            c[:key] ||= key_proc.call(c[:table])
+          end
+        end
+
         generator.columns.each do |c|
           if t = c.delete(:table)
-            generator.foreign_key([c[:name]], t, c.merge(:name=>nil, :type=>:foreign_key))
+            same_table = t == name
+            k = c[:key]
+
+            key ||= key_proc.call(t)
+
+            if same_table && !k.nil?
+              generator.constraints.unshift(:type=>:unique, :columns=>Array(k))
+            end
+
+            generator.foreign_key([c[:name]], t, c.merge(:name=>nil, :type=>:foreign_key, :key=>key))
           end
         end
+
         "#{super}#{" ENGINE=#{engine}" if engine}#{" DEFAULT CHARSET=#{charset}" if charset}#{" DEFAULT COLLATE=#{collate}" if collate}"
       end
 
@@ -261,6 +303,11 @@ module Sequel
         "CREATE #{index_type}INDEX #{index_name}#{using} ON #{quote_schema_table(table_name)} #{literal(index[:columns])}"
       end
       
+      # Parse the schema for the given table to get an array of primary key columns
+      def primary_key_from_schema(table)
+        schema(table).select{|a| a[1][:primary_key]}.map{|a| a[0]}
+      end
+
       # Rollback the currently open XA transaction
       def rollback_transaction(conn, opts={})
         if (s = opts[:prepare]) && @transactions[conn][:savepoint_level] <= 1
@@ -503,12 +550,6 @@ module Sequel
         [insert_sql(columns, sql)]
       end
       
-      # MySQL uses the number of rows actually modified in the update,
-      # instead of the number of matched by the filter.
-      def provides_accurate_rows_matched?
-        false
-      end
-      
       # MySQL uses the nonstandard ` (backtick) for quoting identifiers.
       def quoted_identifier_append(sql, c)
         sql << BACKTICK << c.to_s << BACKTICK

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

@@ -33,10 +33,10 @@ module Sequel
     # Array of exceptions that need to be converted.  JDBC
     # uses NativeExceptions, the native adapter uses PGError.
     CONVERTED_EXCEPTIONS = []
-    
+
     @client_min_messages = :warning
     @force_standard_strings = true
-    
+
     class << self
       # By default, Sequel sets the minimum level of log messages sent to the client
       # to WARNING, where PostgreSQL uses a default of NOTICE.  This is to avoid a lot
@@ -55,14 +55,14 @@ module Sequel
     # Methods shared by adapter/connection instances.
     module AdapterMethods
       attr_writer :db
-      
+
       SELECT_CURRVAL = "SELECT currval('%s')".freeze
       SELECT_CUSTOM_SEQUENCE = proc do |schema, table| <<-end_sql
-        SELECT '"' || name.nspname || '".' || CASE  
-            WHEN split_part(def.adsrc, '''', 2) ~ '.' THEN  
-              substr(split_part(def.adsrc, '''', 2),  
-                     strpos(split_part(def.adsrc, '''', 2), '.')+1) 
-            ELSE split_part(def.adsrc, '''', 2)  
+        SELECT '"' || name.nspname || '".' || CASE
+            WHEN split_part(def.adsrc, '''', 2) ~ '.' THEN
+              substr(split_part(def.adsrc, '''', 2),
+                     strpos(split_part(def.adsrc, '''', 2), '.')+1)
+            ELSE split_part(def.adsrc, '''', 2)
           END
         FROM pg_class t
         JOIN pg_namespace  name ON (t.relnamespace = name.oid)
@@ -103,11 +103,11 @@ module Sequel
           AND seq.relname = '#{table}'
       end_sql
       end
-      
+
       # Depth of the current transaction on this connection, used
       # to implement multi-level transactions with savepoints.
       attr_accessor :transaction_depth
-      
+
       # Apply connection settings for this connection. Currently, turns
       # standard_conforming_strings ON if Postgres.force_standard_strings
       # is true.
@@ -131,7 +131,7 @@ module Sequel
           return val.to_i if val
         end
       end
-      
+
       # Get the primary key for the given table.
       def primary_key(schema, table)
         sql = SELECT_PK[schema, table]
@@ -139,7 +139,7 @@ module Sequel
           return single_value(r)
         end
       end
-      
+
       # Get the primary key and sequence for the given table.
       def sequence(schema, table)
         sql = SELECT_SERIAL_SEQUENCE[schema, table]
@@ -147,14 +147,14 @@ module Sequel
           seq = single_value(r)
           return seq if seq
         end
-        
+
         sql = SELECT_CUSTOM_SEQUENCE[schema, table]
         execute(sql) do |r|
           return single_value(r)
         end
       end
     end
-    
+
     # Methods shared by Database instances that connect to PostgreSQL.
     module DatabaseMethods
       EXCLUDE_SCHEMAS = /pg_*|information_schema/i
@@ -191,7 +191,7 @@ module Sequel
       def create_function(name, definition, opts={})
         self << create_function_sql(name, definition, opts)
       end
-      
+
       # Create the procedural language in the database. Arguments:
       # * name : Name of the procedural language (e.g. plpgsql)
       # * opts : options hash:
@@ -202,7 +202,13 @@ module Sequel
       def create_language(name, opts={})
         self << create_language_sql(name, opts)
       end
-      
+
+      # Create a schema in the database. Arguments:
+      # * name : Name of the schema (e.g. admin)
+      def create_schema(name)
+        self << create_schema_sql(name)
+      end
+
       # Create a trigger in the database.  Arguments:
       # * table : the table on which this trigger operates
       # * name : the name of this trigger
@@ -216,7 +222,7 @@ module Sequel
       def create_trigger(table, name, function, opts={})
         self << create_trigger_sql(table, name, function, opts)
       end
-      
+
       # PostgreSQL uses the :postgres database type.
       def database_type
         :postgres
@@ -231,7 +237,7 @@ module Sequel
       def drop_function(name, opts={})
         self << drop_function_sql(name, opts)
       end
-      
+
       # Drops a procedural language from the database.  Arguments:
       # * name : name of the procedural language to drop
       # * opts : options hash:
@@ -240,7 +246,16 @@ module Sequel
       def drop_language(name, opts={})
         self << drop_language_sql(name, opts)
       end
-      
+
+      # Drops a schema from the database.  Arguments:
+      # * name : name of the schema to drop
+      # * opts : options hash:
+      #   * :cascade : Drop all objects in this schema.
+      #   * :if_exists : Don't raise an error if the schema doesn't exist.
+      def drop_schema(name, opts={})
+        self << drop_schema_sql(name, opts)
+      end
+
       # Drops a trigger from the database.  Arguments:
       # * table : table from which to drop the trigger
       # * name : name of the trigger to drop
@@ -250,7 +265,7 @@ module Sequel
       def drop_trigger(table, name, opts={})
         self << drop_trigger_sql(table, name, opts)
       end
-      
+
       # Use the pg_* system tables to determine indexes on a table
       def indexes(table, opts={})
         m = output_identifier_meth
@@ -266,11 +281,11 @@ module Sequel
           filter(:indc__relkind=>'i', :ind__indisprimary=>false, :indexprs=>nil, :indpred=>nil).
           order(:indc__relname, range.map{|x| [SQL::Subscript.new(:ind__indkey, [x]), x]}.case(32, :att__attnum)).
           select(:indc__relname___name, :ind__indisunique___unique, :att__attname___column)
-        
+
         ds.join!(:pg_namespace___nsp, :oid=>:tab__relnamespace, :nspname=>schema.to_s) if schema
         ds.filter!(:indisvalid=>true) if server_version >= 80200
         ds.filter!(:indisready=>true, :indcheckxmin=>false) if server_version >= 80300
-        
+
         indexes = {}
         ds.each do |r|
           i = indexes[m.call(r[:name])] ||= {:columns=>[], :unique=>r[:unique]}
@@ -279,11 +294,11 @@ module Sequel
         indexes
       end
 
-      # Dataset containing all current database locks 
+      # Dataset containing all current database locks
       def locks
         dataset.from(:pg_class).join(:pg_locks, :relation=>:relfilenode).select(:pg_class__relname, Sequel::SQL::ColumnAll.new(:pg_locks))
       end
-      
+
       # Notifies the given channel.  See the PostgreSQL NOTIFY documentation. Options:
       #
       # :payload :: The payload string to use for the NOTIFY statement.  Only supported
@@ -304,7 +319,7 @@ module Sequel
           synchronize(opts[:server]){|con| con.primary_key(*schema_and_table(table))}
         end
       end
-      
+
       # Return the sequence providing the default for the primary key for the given table.
       def primary_key_sequence(table, opts={})
         quoted_table = quote_schema_table(table)
@@ -315,7 +330,7 @@ module Sequel
           synchronize(opts[:server]){|con| con.sequence(*schema_and_table(table))}
         end
       end
-      
+
       # Reset the primary key sequence for the given table, baseing it on the
       # maximum current value of the table's primary key.
       def reset_primary_key_sequence(table)
@@ -337,7 +352,7 @@ module Sequel
       def serial_primary_key_options
         {:primary_key => true, :serial => true, :type=>Integer}
       end
-      
+
       # The version of the PostgreSQL server, used for determining capability.
       def server_version(server=nil)
         return @server_version if @server_version
@@ -353,7 +368,7 @@ module Sequel
         end
         @server_version
       end
-      
+
       # PostgreSQL supports prepared transactions (two-phase commit) if
       # max_prepared_transactions is greater than 0.
       def supports_prepared_transactions?
@@ -378,7 +393,7 @@ module Sequel
 
       # Array of symbols specifying table names in the current database.
       # The dataset used is yielded to the block if one is provided,
-      # otherwise, an array of symbols of table names is returned.  
+      # otherwise, an array of symbols of table names is returned.
       #
       # Options:
       # * :schema - The schema to search (default_schema by default)
@@ -428,34 +443,44 @@ module Sequel
         AS #{literal(definition.to_s)}#{", #{literal(opts[:link_symbol].to_s)}" if opts[:link_symbol]}
         END
       end
-      
+
       # SQL for creating a procedural language.
       def create_language_sql(name, opts={})
         "CREATE#{' OR REPLACE' if opts[:replace] && server_version >= 90000}#{' TRUSTED' if opts[:trusted]} LANGUAGE #{name}#{" HANDLER #{opts[:handler]}" if opts[:handler]}#{" VALIDATOR #{opts[:validator]}" if opts[:validator]}"
       end
-      
-      # SQL for creating a database trigger. 
+
+      # SQL for creating a schema.
+      def create_schema_sql(name)
+        "CREATE SCHEMA #{quote_identifier(name)}"
+      end
+
+      # SQL for creating a database trigger.
       def create_trigger_sql(table, name, function, opts={})
         events = opts[:events] ? Array(opts[:events]) : [:insert, :update, :delete]
         whence = opts[:after] ? 'AFTER' : 'BEFORE'
         "CREATE TRIGGER #{name} #{whence} #{events.map{|e| e.to_s.upcase}.join(' OR ')} ON #{quote_schema_table(table)}#{' FOR EACH ROW' if opts[:each_row]} EXECUTE PROCEDURE #{function}(#{Array(opts[:args]).map{|a| literal(a)}.join(', ')})"
       end
-      
+
       # The errors that the main adapters can raise, depends on the adapter being used
       def database_error_classes
         CONVERTED_EXCEPTIONS
       end
-      
-      # SQL for dropping a function from the database. 
+
+      # SQL for dropping a function from the database.
       def drop_function_sql(name, opts={})
         "DROP FUNCTION#{' IF EXISTS' if opts[:if_exists]} #{name}#{sql_function_args(opts[:args])}#{' CASCADE' if opts[:cascade]}"
       end
-      
+
       # SQL for dropping a procedural language from the database.
       def drop_language_sql(name, opts={})
         "DROP LANGUAGE#{' IF EXISTS' if opts[:if_exists]} #{name}#{' CASCADE' if opts[:cascade]}"
       end
 
+      # SQL for dropping a schema from the database.
+      def drop_schema_sql(name, opts={})
+        "DROP SCHEMA#{' IF EXISTS' if opts[:if_exists]} #{quote_identifier(name)}#{' CASCADE' if opts[:cascade]}"
+      end
+
       # SQL for dropping a trigger from the database.
       def drop_trigger_sql(table, name, opts={})
         "DROP TRIGGER#{' IF EXISTS' if opts[:if_exists]} #{name} ON #{quote_schema_table(table)}#{' CASCADE' if opts[:cascade]}"
@@ -470,12 +495,12 @@ module Sequel
           ds.exclude(:pg_namespace__nspname=>EXCLUDE_SCHEMAS)
         end
       end
-      
+
       # PostgreSQL folds unquoted identifiers to lowercase, so it shouldn't need to upcase identifiers on input.
       def identifier_input_method_default
         nil
       end
-      
+
       # PostgreSQL folds unquoted identifiers to lowercase, so it shouldn't need to upcase identifiers on output.
       def identifier_output_method_default
         nil
@@ -485,7 +510,7 @@ module Sequel
       def index_definition_sql(table_name, index)
         cols = index[:columns]
         index_name = index[:name] || default_index_name(table_name, cols)
-        expr = if o = index[:opclass] 
+        expr = if o = index[:opclass]
           "(#{Array(cols).map{|c| "#{literal(c)} #{o}"}.join(', ')})"
         else
           literal(Array(cols))
@@ -503,7 +528,7 @@ module Sequel
         end
         "CREATE #{unique}INDEX #{quote_identifier(index_name)} ON #{quote_schema_table(table_name)} #{"USING #{index_type} " if index_type}#{expr}#{filter}"
       end
-      
+
       # The result of the insert for the given table and values.  If values
       # is an array, assume the first column is the primary key and return
       # that.  If values is a hash, lookup the primary key for the table.  If
@@ -533,13 +558,13 @@ module Sequel
       end
 
       # Don't log, since logging is done by the underlying connection.
-      def log_connection_execute(conn, sql) 
+      def log_connection_execute(conn, sql)
         conn.execute(sql)
       end
-      
+
       # Backbone of the tables and views support.
       def pg_class_relname(type, opts)
-        ds = metadata_dataset.from(:pg_class).filter(:relkind=>type).select(:relname).exclude(SQL::StringExpression.like(:relname, SYSTEM_TABLE_REGEXP)).server(opts[:server]).join(:pg_namespace, :oid=>:relnamespace) 
+        ds = metadata_dataset.from(:pg_class).filter(:relkind=>type).select(:relname).exclude(SQL::StringExpression.like(:relname, SYSTEM_TABLE_REGEXP)).server(opts[:server]).join(:pg_namespace, :oid=>:relnamespace)
         ds = filter_schema(ds, opts)
         m = output_identifier_meth
         block_given? ? yield(ds) : ds.map{|r| m.call(r[:relname])}
@@ -550,7 +575,7 @@ module Sequel
       def prepared_arg_placeholder
         PREPARED_ARG_PLACEHOLDER
       end
-      
+
       # Remove the cached entries for primary keys and sequences when a table is
       # changed.
       def remove_cached_schema(table)
@@ -564,7 +589,7 @@ module Sequel
       # a rename table operation, so speciying a new schema in new_name will not have an effect.
       def rename_table_sql(name, new_name)
         "ALTER TABLE #{quote_schema_table(name)} RENAME TO #{quote_identifier(schema_and_table(new_name).last)}"
-      end 
+      end
 
       # PostgreSQL's autoincrementing primary keys are of type integer or bigint
       # using a nextval function call as a default.
@@ -613,7 +638,7 @@ module Sequel
       def sql_function_args(args)
         "(#{Array(args).map{|a| Array(a).reverse.join(' ')}.join(', ')})"
       end
-      
+
       # Handle bigserial type if :serial option is present
       def type_literal_generic_bignum(column)
         column[:serial] ? :bigserial : super
@@ -643,7 +668,7 @@ module Sequel
         end
       end
     end
-    
+
     # Instance methods for datasets that connect to a PostgreSQL database.
     module DatasetMethods
       ACCESS_SHARE = 'ACCESS SHARE'.freeze
@@ -688,7 +713,7 @@ module Sequel
       BLOB_RE = /[\000-\037\047\134\177-\377]/n.freeze
       WINDOW = " WINDOW ".freeze
       EMPTY_STRING = ''.freeze
-      
+
       # Shared methods for prepared statements when used with PostgreSQL databases.
       module PreparedStatementMethods
         # Override insert action to use RETURNING if the server supports it.
@@ -722,7 +747,7 @@ module Sequel
       def analyze
         explain(:analyze=>true)
       end
-      
+
       # Handle converting the ruby xor operator (^) into the
       # PostgreSQL xor operator (#).
       def complex_expression_sql_append(sql, op, args)
@@ -749,12 +774,12 @@ module Sequel
       def explain(opts={})
         with_sql((opts[:analyze] ? EXPLAIN_ANALYZE : EXPLAIN) + select_sql).map(QUERY_PLAN).join(CRLF)
       end
-      
+
       # Return a cloned dataset which will use FOR SHARE to lock returned rows.
       def for_share
         lock_style(:share)
       end
-      
+
       # PostgreSQL specific full text search syntax, using tsearch2 (included
       # in 8.3 by default, and available for earlier versions as an add-on).
       def full_text_search(cols, terms, opts = {})
@@ -762,7 +787,7 @@ module Sequel
         terms = terms.join(' | ') if terms.is_a?(Array)
         filter("to_tsvector(?, ?) @@ to_tsquery(?, ?)", lang, full_text_string_join(cols), lang, terms)
       end
-      
+
       # Insert given values into the database.
       def insert(*values, &block)
         if @opts[:returning]
@@ -802,17 +827,17 @@ module Sequel
         end
         nil
       end
-      
+
       # For PostgreSQL version > 8.2, allow inserting multiple rows at once.
       def multi_insert_sql(columns, values)
         return super if server_version < 80200
-        
+
         # postgresql 8.2 introduces support for multi-row insert
         sql = LiteralString.new('VALUES ')
         expression_list_append(sql, values.map{|r| Array(r)})
         [insert_sql(columns, sql)]
       end
-      
+
       # PostgreSQL supports using the WITH clause in subqueries if it
       # supports using WITH at all (i.e. on PostgreSQL 8.4+).
       def supports_cte_in_subqueries?
@@ -823,7 +848,7 @@ module Sequel
       def supports_distinct_on?
         true
       end
-      
+
       # PostgreSQL supports modifying joined datasets
       def supports_modifying_joins?
         true
@@ -841,7 +866,7 @@ module Sequel
       def supports_timestamp_timezones?
         true
       end
-      
+
       # PostgreSQL 8.4+ supports window functions
       def supports_window_functions?
         server_version >= 80400
@@ -851,7 +876,7 @@ module Sequel
       def window(name, opts)
         clone(:window=>(@opts[:window]||[]) + [[name, SQL::Window.new(opts)]])
       end
-      
+
       protected
 
       # If returned primary keys are requested, use RETURNING unless already set on the
@@ -876,11 +901,11 @@ module Sequel
       end
 
       private
-      
+
       # PostgreSQL allows deleting from joined datasets
       def delete_clause_methods
         server_version >= 90100 ? DELETE_CLAUSE_METHODS_91 : DELETE_CLAUSE_METHODS
-      end 
+      end
 
       # Only include the primary table in the main delete clause
       def delete_from_sql(sql)
@@ -931,6 +956,19 @@ module Sequel
       def literal_false
         BOOL_FALSE
       end
+      
+      # PostgreSQL quotes NaN and Infinity.
+      def literal_float(value)
+        if value.finite?
+          super
+        elsif value.nan?
+          "'NaN'"
+        elsif value.infinite? == 1
+          "'Infinity'"
+        else
+          "'-Infinity'"
+        end
+      end 
 
       # Assume that SQL standard quoting is on, per Sequel's defaults
       def literal_string_append(sql, v)
@@ -946,7 +984,7 @@ module Sequel
       def select_clause_methods
         server_version >= 80400 ? SELECT_CLAUSE_METHODS_84 : SELECT_CLAUSE_METHODS
       end
-      
+
       # PostgreSQL requires parentheses around compound datasets if they use
       # CTEs, and using them in other places doesn't hurt.
       def compound_dataset_sql_append(sql, ds)
@@ -967,7 +1005,7 @@ module Sequel
           c = false
           co = COMMA
           as = AS
-          ws.map do |name, window| 
+          ws.map do |name, window|
             sql << co if c
             literal_append(sql, name)
             sql << as
@@ -976,7 +1014,7 @@ module Sequel
           end
         end
       end
-      
+
       # Use WITH RECURSIVE instead of WITH if any of the CTEs is recursive
       def select_with_sql_base
         opts[:with].any?{|w| w[:recursive]} ? SQL_WITH_RECURSIVE : super