sequel 2.11.0 → 2.12.0

data/lib/{sequel_core → sequel}/adapters/shared/mssql.rb

@@ -1,4 +1,4 @@
-require 'sequel_core/adapters/utils/unsupported'
+Sequel.require 'adapters/utils/unsupported'
 
 module Sequel
   module MSSQL
@@ -8,10 +8,6 @@ module Sequel
       SQL_COMMIT = "COMMIT TRANSACTION".freeze
       SQL_ROLLBACK = "ROLLBACK TRANSACTION".freeze
       
-      def auto_increment_sql
-        AUTO_INCREMENT
-      end
-
       def dataset(opts = nil)
         ds = super
         ds.extend(DatasetMethods)
@@ -20,6 +16,10 @@ module Sequel
 
       private
 
+      def auto_increment_sql
+        AUTO_INCREMENT
+      end
+
       # SQL to BEGIN a transaction.
       def begin_transaction_sql
         SQL_BEGIN

data/lib/{sequel_core → sequel}/adapters/shared/mysql.rb

@@ -1,27 +1,55 @@
-require 'sequel_core/adapters/utils/unsupported'
+Sequel.require 'adapters/utils/unsupported'
 
 module Sequel
-  module Schema
-    module SQL
-      # Keep default column_references_sql for add_foreign_key support
-      alias default_column_references_sql column_references_sql
-    end
+  class Database
+    # Keep default column_references_sql for add_foreign_key support
+    alias default_column_references_sql column_references_sql
   end
   module MySQL
-    # Set the default options used for CREATE TABLE
-    metaattr_accessor :default_charset, :default_collate, :default_engine
+    class << self
+      # Set the default options used for CREATE TABLE
+      attr_accessor :default_charset, :default_collate, :default_engine
+    end
 
     # Methods shared by Database instances that connect to MySQL,
     # currently supported by the native and JDBC adapters.
     module DatabaseMethods
       AUTO_INCREMENT = 'AUTO_INCREMENT'.freeze
-      NOT_NULL = Sequel::Schema::SQL::NOT_NULL
-      NULL = Sequel::Schema::SQL::NULL
-      PRIMARY_KEY = Sequel::Schema::SQL::PRIMARY_KEY
-      TYPES = Sequel::Schema::SQL::TYPES.merge(DateTime=>'datetime', \
+      NOT_NULL = Sequel::Database::NOT_NULL
+      NULL = Sequel::Database::NULL
+      PRIMARY_KEY = Sequel::Database::PRIMARY_KEY
+      TYPES = Sequel::Database::TYPES.merge(DateTime=>'datetime', \
         TrueClass=>'tinyint', FalseClass=>'tinyint')
-      UNIQUE = Sequel::Schema::SQL::UNIQUE
-      UNSIGNED = Sequel::Schema::SQL::UNSIGNED
+      UNIQUE = Sequel::Database::UNIQUE
+      UNSIGNED = Sequel::Database::UNSIGNED
+      
+      # Get version of MySQL server, used for determined capabilities.
+      def server_version
+        m = /(\d+)\.(\d+)\.(\d+)/.match(get(SQL::Function.new(:version)))
+        @server_version ||= (m[1].to_i * 10000) + (m[2].to_i * 100) + m[3].to_i
+      end
+      
+      # Return an array of symbols specifying table names in the current database.
+      #
+      # Options:
+      # * :server - Set the server to use
+      def tables(opts={})
+        ds = self['SHOW TABLES'].server(opts[:server])
+        ds.identifier_output_method = nil
+        ds2 = dataset
+        ds.map{|r| ds2.send(:output_identifier, r.values.first)}
+      end
+      
+      # Changes the database in use by issuing a USE statement.  I would be
+      # very careful if I used this.
+      def use(db_name)
+        disconnect
+        @opts[:database] = db_name if self << "USE #{db_name}"
+        @schemas = nil
+        self
+      end
+      
+      private
       
       # Use MySQL specific syntax for rename column, set column type, and
       # drop index cases.
@@ -66,6 +94,16 @@ module Sequel
         sql
       end
 
+      # MySQL folds unquoted identifiers to lowercase, so it shouldn't need to upcase identifiers on input.
+      def identifier_input_method_default
+        nil
+      end
+      
+      # MySQL folds unquoted identifiers to lowercase, so it shouldn't need to upcase identifiers on output.
+      def identifier_output_method_default
+        nil
+      end
+
       # Handle MySQL specific index SQL syntax
       def index_definition_sql(table_name, index)
         index_name = quote_identifier(index[:name] || default_index_name(table_name, index[:columns]))
@@ -81,44 +119,6 @@ module Sequel
         "CREATE #{index_type}INDEX #{index_name} ON #{quote_schema_table(table_name)} #{literal(index[:columns])}#{using}"
       end
       
-      # Get version of MySQL server, used for determined capabilities.
-      def server_version
-        m = /(\d+)\.(\d+)\.(\d+)/.match(get(SQL::Function.new(:version)))
-        @server_version ||= (m[1].to_i * 10000) + (m[2].to_i * 100) + m[3].to_i
-      end
-      
-      # Return an array of symbols specifying table names in the current database.
-      #
-      # Options:
-      # * :server - Set the server to use
-      def tables(opts={})
-        ds = self['SHOW TABLES'].server(opts[:server])
-        ds.identifier_output_method = nil
-        ds2 = dataset
-        ds.map{|r| ds2.send(:output_identifier, r.values.first)}
-      end
-      
-      # Changes the database in use by issuing a USE statement.  I would be
-      # very careful if I used this.
-      def use(db_name)
-        disconnect
-        @opts[:database] = db_name if self << "USE #{db_name}"
-        @schemas = nil
-        self
-      end
-      
-      private
-      
-      # MySQL folds unquoted identifiers to lowercase, so it shouldn't need to upcase identifiers on input.
-      def identifier_input_method_default
-        nil
-      end
-      
-      # MySQL folds unquoted identifiers to lowercase, so it shouldn't need to upcase identifiers on output.
-      def identifier_output_method_default
-        nil
-      end
-
       # Use the MySQL specific DESCRIBE syntax to get a table description.
       def schema_parse_table(table_name, opts)
         ds = self["DESCRIBE ?", SQL::Identifier.new(table_name)]
@@ -129,7 +129,7 @@ module Sequel
           row[:allow_null] = row.delete(:Null) == 'YES'
           row[:default] = row.delete(:Default)
           row[:primary_key] = row.delete(:Key) == 'PRI'
-          row[:default] = nil if row[:default].blank?
+          row[:default] = nil if blank_object?(row[:default])
           row[:db_type] = row.delete(:Type)
           row[:type] = schema_column_type(row[:db_type])
           [ds2.send(:output_identifier, row.delete(:Field)), row]
@@ -175,9 +175,14 @@ module Sequel
       end
       
       # MySQL supports ORDER and LIMIT clauses in DELETE statements.
-      def delete_sql(opts = nil)
-        sql = super
-        opts = opts ? @opts.merge(opts) : @opts
+      def delete_sql(opts = (defarg=true;nil))
+        if defarg
+          sql = super()
+          opts = @opts
+        else
+          sql = super
+          opts = opts ? @opts.merge(opts) : @opts
+        end
 
         if order = opts[:order]
           sql << " ORDER BY #{expression_list(order)}"
@@ -189,11 +194,17 @@ module Sequel
         sql
       end
 
+      # MySQL doesn't support DISTINCT ON
+      def distinct(*columns)
+        raise(Error, "DISTINCT ON not supported by MySQL") unless columns.empty?
+        super
+      end
+
       # MySQL specific full text search syntax.
       def full_text_search(cols, terms, opts = {})
         mode = opts[:boolean] ? " IN BOOLEAN MODE" : ""
         s = if Array === terms
-          if mode.blank?
+          if mode.empty?
             "MATCH #{literal(Array(cols))} AGAINST #{literal(terms)}"
           else
             "MATCH #{literal(Array(cols))} AGAINST (#{literal(terms)[1...-1]}#{mode})"
@@ -206,8 +217,7 @@ module Sequel
 
       # MySQL allows HAVING clause on ungrouped datasets.
       def having(*cond, &block)
-        @opts[:having] = {}
-        x = filter(*cond, &block)
+        _filter(:having, *cond, &block)
       end
       
       # MySQL doesn't use the SQL standard DEFAULT VALUES.
@@ -233,10 +243,58 @@ module Sequel
         end
       end
       
+      # Sets up multi_insert or import to use INSERT IGNORE.
+      # Useful if you have a unique key and want to just skip
+      # inserting rows that violate the unique key restriction.
+      #
+      # Example:
+      #
+      # dataset.insert_ignore.multi_insert(
+      #  [{:name => 'a', :value => 1}, {:name => 'b', :value => 2}]
+      # )
+      #
+      # INSERT IGNORE INTO tablename (name, value) VALUES (a, 1), (b, 2)
+      #
+      def insert_ignore
+        clone(:insert_ignore=>true)
+      end
+      
+      # Sets up multi_insert or import to use ON DUPLICATE KEY UPDATE
+      # If you pass no arguments, ALL fields will be
+      # updated with the new values.  If you pass the fields you
+      # want then ONLY those field will be updated.
+      #
+      # Useful if you have a unique key and want to update
+      # inserting rows that violate the unique key restriction.
+      #
+      # Examples:
+      #
+      # dataset.on_duplicate_key_update.multi_insert(
+      #  [{:name => 'a', :value => 1}, {:name => 'b', :value => 2}]
+      # )
+      #
+      # INSERT INTO tablename (name, value) VALUES (a, 1), (b, 2)
+      # ON DUPLICATE KEY UPDATE name=VALUES(name), value=VALUES(value)
+      #
+      # dataset.on_duplicate_key_update(:value).multi_insert(
+      #  [{:name => 'a', :value => 1}, {:name => 'b', :value => 2}]
+      # )
+      #
+      # INSERT INTO tablename (name, value) VALUES (a, 1), (b, 2)
+      # ON DUPLICATE KEY UPDATE value=VALUES(value)
+      #
+      def on_duplicate_key_update(*args)
+        clone(:on_duplicate_key_update => args)
+      end
+      
       # MySQL specific syntax for inserting multiple values at once.
       def multi_insert_sql(columns, values)
+        if update_cols = opts[:on_duplicate_key_update]
+          update_cols = columns if update_cols.empty?
+          update_string = update_cols.map{|c| "#{quote_identifier(c)}=VALUES(#{quote_identifier(c)})"}.join(COMMA_SEPARATOR)
+        end
         values = values.map {|r| literal(Array(r))}.join(COMMA_SEPARATOR)
-        ["INSERT INTO #{source_list(@opts[:from])} (#{identifier_list(columns)}) VALUES #{values}"]
+        ["INSERT#{' IGNORE' if opts[:insert_ignore]} INTO #{source_list(@opts[:from])} (#{identifier_list(columns)}) VALUES #{values}#{" ON DUPLICATE KEY UPDATE #{update_string}" if update_string}"]
       end
       
       # MySQL uses the nonstandard ` (backtick) for quoting identifiers.
@@ -286,9 +344,14 @@ module Sequel
       end
       
       # MySQL supports ORDER and LIMIT clauses in UPDATE statements.
-      def update_sql(values, opts = nil)
-        sql = super
-        opts = opts ? @opts.merge(opts) : @opts
+      def update_sql(values, opts = (defarg=true;nil))
+        if defarg
+          sql = super(values)
+          opts = @opts
+        else
+          sql = super
+          opts = opts ? @opts.merge(opts) : @opts
+        end
 
         if order = opts[:order]
           sql << " ORDER BY #{expression_list(order)}"
@@ -321,14 +384,6 @@ module Sequel
       def literal_true
         BOOL_TRUE
       end
-      
-      # MySQL doesn't support DISTINCT ON
-      def select_distinct_sql(sql, opts)
-        if opts[:distinct]
-          raise(Error, "DISTINCT ON not supported by MySQL") unless opts[:distinct].empty?
-          sql << " DISTINCT"
-        end
-      end
     end
   end
 end

data/lib/{sequel_core → sequel}/adapters/shared/oracle.rb

@@ -1,5 +1,4 @@
-require 'sequel_core/adapters/utils/date_format'
-require 'sequel_core/adapters/utils/unsupported'
+Sequel.require %w'date_format unsupported', 'adapters/utils'
 
 module Sequel
   module Oracle
@@ -20,6 +19,12 @@ module Sequel
 
       SELECT_CLAUSE_ORDER = %w'distinct columns from join where group having compounds order limit'.freeze
 
+      # Oracle doesn't support DISTINCT ON
+      def distinct(*columns)
+        raise(Error, "DISTINCT ON not supported by Oracle") unless columns.empty?
+        super
+      end
+
       # Oracle uses MINUS instead of EXCEPT, and doesn't support EXCEPT ALL
       def except(dataset, all = false)
         raise(Sequel::Error, "EXCEPT ALL not supported") if all
@@ -42,14 +47,6 @@ module Sequel
         SELECT_CLAUSE_ORDER
       end
 
-      # Oracle doesn't support DISTINCT ON
-      def select_distinct_sql(sql, opts)
-        if opts[:distinct]
-          raise(Error, "DISTINCT ON not supported by Oracle") unless opts[:distinct].empty?
-          sql << " DISTINCT"
-        end
-      end
-
       # Oracle requires a subselect to do limit and offset
       def select_limit_sql(sql, opts)
         if limit = opts[:limit]

data/lib/{sequel_core → sequel}/adapters/shared/postgres.rb

@@ -35,18 +35,20 @@ module Sequel
     @client_min_messages = :warning
     @force_standard_strings = true
     
-    # 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
-    # of mostly useless messages when running migrations, such as a couple of lines
-    # for every serial primary key field.
-    metaattr_accessor :client_min_messages
+    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
+      # of mostly useless messages when running migrations, such as a couple of lines
+      # for every serial primary key field.
+      attr_accessor :client_min_messages
 
-    # By default, Sequel forces the use of standard strings, so that
-    # '\\' is interpreted as \\ and not \.  While PostgreSQL defaults
-    # to interpreting plain strings as extended strings, this will change
-    # in a future version of PostgreSQL.  Sequel assumes that SQL standard
-    # strings will be used.
-    metaattr_accessor :force_standard_strings
+      # By default, Sequel forces the use of standard strings, so that
+      # '\\' is interpreted as \\ and not \.  While PostgreSQL defaults
+      # to interpreting plain strings as extended strings, this will change
+      # in a future version of PostgreSQL.  Sequel assumes that SQL standard
+      # strings will be used.
+      attr_accessor :force_standard_strings
+    end
 
     # Methods shared by adapter/connection instances.
     module AdapterMethods
@@ -170,14 +172,9 @@ module Sequel
       SQL_ROLLBACK = 'ROLLBACK'.freeze
       SQL_RELEASE_SAVEPOINT = 'RELEASE SAVEPOINT autopoint_%d'.freeze
       SYSTEM_TABLE_REGEXP = /^pg|sql/.freeze
-      TYPES = Sequel::Schema::SQL::TYPES.merge(File=>'bytea', String=>'text')
+      TYPES = Sequel::Database::TYPES.merge(File=>'bytea', String=>'text')
 
-      # Creates the function in the database.  See create_function_sql for arguments.
-      def create_function(*args)
-        self << create_function_sql(*args)
-      end
-      
-      # SQL statement to create database function. Arguments:
+      # Creates the function in the database.  Arguments:
       # * name : name of the function to create
       # * definition : string definition of the function, or object file for a dynamically loaded C function.
       # * opts : options hash:
@@ -197,47 +194,21 @@ module Sequel
       #   * :set : Configuration variables to set while the function is being run, can be a hash or an array of two pairs.  search_path is
       #     often used here if :security_definer is used.
       #   * :strict : Makes the function return NULL when any argument is NULL.
-      def create_function_sql(name, definition, opts={})
-        args = opts[:args]
-        if !opts[:args].is_a?(Array) || !opts[:args].any?{|a| Array(a).length == 3 and %w'OUT INOUT'.include?(a[2].to_s)}
-          returns = opts[:returns] || 'void'
-        end
-        language = opts[:language] || 'SQL'
-        <<-END
-        CREATE#{' OR REPLACE' if opts[:replace]} FUNCTION #{name}#{sql_function_args(args)}
-        #{"RETURNS #{returns}" if returns}
-        LANGUAGE #{language}
-        #{opts[:behavior].to_s.upcase if opts[:behavior]}
-        #{'STRICT' if opts[:strict]}
-        #{'SECURITY DEFINER' if opts[:security_definer]}
-        #{"COST #{opts[:cost]}" if opts[:cost]}
-        #{"ROWS #{opts[:rows]}" if opts[:rows]}
-        #{opts[:set].map{|k,v| " SET #{k} = #{v}"}.join("\n") if opts[:set]}
-        AS #{literal(definition.to_s)}#{", #{literal(opts[:link_symbol].to_s)}" if opts[:link_symbol]}
-        END
-      end
-      
-      # Create the procedural language in the database.  See create_language_sql for arguments.
-      def create_language(*args)
-        self << create_language_sql(*args)
+      def create_function(name, definition, opts={})
+        self << create_function_sql(name, definition, opts)
       end
       
-      # SQL for creating a procedural language. Arguments:
+      # Create the procedural language in the database. Arguments:
       # * name : Name of the procedural language (e.g. plpgsql)
       # * opts : options hash:
       #   * :handler : The name of a previously registered function used as a call handler for this language.
       #   * :trusted : Marks the language being created as trusted, allowing unprivileged users to create functions using this language.
       #   * :validator : The name of previously registered function used as a validator of functions defined in this language.
-      def create_language_sql(name, opts={})
-        "CREATE#{' TRUSTED' if opts[:trusted]} LANGUAGE #{name}#{" HANDLER #{opts[:handler]}" if opts[:handler]}#{" VALIDATOR #{opts[:validator]}" if opts[:validator]}"
+      def create_language(name, opts={})
+        self << create_language_sql(name, opts)
       end
       
-      # Create a trigger in the database.  See create_trigger_sql for arguments.
-      def create_trigger(*args)
-        self << create_trigger_sql(*args)
-      end
-      
-      # SQL for creating a database trigger. Arguments:
+      # Create a trigger in the database.  Arguments:
       # * table : the table on which this trigger operates
       # * name : the name of this trigger
       # * function : the function to call for this trigger, which should return type trigger.
@@ -247,41 +218,29 @@ module Sequel
       #   * :each_row : Calls the trigger for each row instead of for each statement.
       #   * :events : Can be :insert, :update, :delete, or an array of any of those. Calls the trigger whenever that type of statement is used.  By default,
       #     the trigger is called for insert, update, or delete.
-      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
-      
-      # Drops the function from the database.  See drop_function_sql for arguments.
-      def drop_function(*args)
-        self << drop_function_sql(*args)
+      def create_trigger(table, name, function, opts={})
+        self << create_trigger_sql(table, name, function, opts)
       end
       
-      # SQL for dropping a function from the database.  Arguments:
+      # Drops the function from the database. Arguments:
       # * name : name of the function to drop
       # * opts : options hash:
       #   * :args : The arguments for the function.  See create_function_sql.
       #   * :cascade : Drop other objects depending on this function.
       #   * :if_exists : Don't raise an error if the function doesn't exist.
-      def drop_function_sql(name, opts={})
-        "DROP FUNCTION#{' IF EXISTS' if opts[:if_exists]} #{name}#{sql_function_args(opts[:args])}#{' CASCADE' if opts[:cascade]}"
+      def drop_function(name, opts={})
+        self << drop_function_sql(name, opts)
       end
       
-      # Drops a procedural language from the database.  See drop_language_sql for arguments.
-      def drop_language(*args)
-        self << drop_language_sql(*args)
-      end
-      
-      # SQL for dropping a procedural language from the database.  Arguments:
+      # Drops a procedural language from the database.  Arguments:
       # * name : name of the procedural language to drop
       # * opts : options hash:
       #   * :cascade : Drop other objects depending on this function.
       #   * :if_exists : Don't raise an error if the function doesn't exist.
-      def drop_language_sql(name, opts={})
-        "DROP LANGUAGE#{' IF EXISTS' if opts[:if_exists]} #{name}#{' CASCADE' if opts[:cascade]}"
+      def drop_language(name, opts={})
+        self << drop_language_sql(name, opts)
       end
-
+      
       # Remove the cached entries for primary keys and sequences when dropping a table.
       def drop_table(*names)
         names.each do |name|
@@ -292,43 +251,14 @@ module Sequel
         super
       end
 
-      # Always CASCADE the table drop
-      def drop_table_sql(name)
-        "DROP TABLE #{quote_schema_table(name)} CASCADE"
-      end
-      
-      # Drops a trigger from the database.  See drop_trigger_sql for arguments.
-      def drop_trigger(*args)
-        self << drop_trigger_sql(*args)
-      end
-      
-      # SQL for dropping a trigger from the database.  Arguments:
+      # Drops a trigger from the database.  Arguments:
       # * table : table from which to drop the trigger
       # * name : name of the trigger to drop
       # * opts : options hash:
       #   * :cascade : Drop other objects depending on this function.
       #   * :if_exists : Don't raise an error if the function doesn't exist.
-      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]}"
-      end
-
-      # PostgreSQL specific index SQL.
-      def index_definition_sql(table_name, index)
-        index_name = index[:name] || default_index_name(table_name, index[:columns])
-        expr = literal(Array(index[:columns]))
-        unique = "UNIQUE " if index[:unique]
-        index_type = index[:type]
-        filter = index[:where] || index[:filter]
-        filter = " WHERE #{filter_expr(filter)}" if filter
-        case index_type
-        when :full_text
-          cols = Array(index[:columns]).map{|x| SQL::Function.new(:COALESCE, x, '')}.sql_string_join(' ')
-          expr = "(to_tsvector(#{literal(index[:language] || 'simple')}, #{literal(cols)}))"
-          index_type = :gin
-        when :spatial
-          index_type = :gist
-        end
-        "CREATE #{unique}INDEX #{quote_identifier(index_name)} ON #{quote_schema_table(table_name)} #{"USING #{index_type} " if index_type}#{expr}#{filter}"
+      def drop_trigger(table, name, opts={})
+        self << drop_trigger_sql(table, name, opts)
       end
       
       # Dataset containing all current database locks 
@@ -358,12 +288,6 @@ module Sequel
         end
       end
 
-      # SQL DDL statement for renaming a table. PostgreSQL doesn't allow you to change a table's schema in
-      # 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 
-
       # PostgreSQL uses SERIAL psuedo-type instead of AUTOINCREMENT for
       # managing incrementing primary keys.
       def serial_primary_key_options
@@ -402,7 +326,7 @@ module Sequel
       # * :schema - The schema to search (default_schema by default)
       # * :server - The server to use
       def tables(opts={})
-        ds = self[:pg_class].filter(:relkind=>'r').select(:relname).exclude(:relname.like(SYSTEM_TABLE_REGEXP)).server(opts[:server])
+        ds = self[:pg_class].filter(:relkind=>'r').select(:relname).exclude(SQL::StringExpression.like(:relname, SYSTEM_TABLE_REGEXP)).server(opts[:server])
         ds.join!(:pg_namespace, :oid=>:relnamespace, :nspname=>(opts[:schema]||default_schema).to_s) if opts[:schema] || default_schema
         ds.identifier_input_method = nil
         ds.identifier_output_method = nil
@@ -411,9 +335,16 @@ module Sequel
       end
       
       # PostgreSQL supports multi-level transactions using save points.
-      def transaction(server=nil)
-        synchronize(server) do |conn|
-          conn.transaction_depth = 0 if conn.transaction_depth.nil?
+      # To use a savepoint instead of reusing the current transaction,
+      # use the :savepoint=>true option.
+      def transaction(opts={})
+        unless opts.is_a?(Hash)
+          Deprecation.deprecate('Passing an argument other than a Hash to Database#transaction', "Use DB.transaction(:server=>#{opts.inspect})") 
+          opts = {:server=>opts}
+        end
+        synchronize(opts[:server]) do |conn|
+          return yield(conn) if @transactions.include?(Thread.current) and !opts[:savepoint]
+          conn.transaction_depth ||= 0
           if conn.transaction_depth > 0
             log_info(SQL_SAVEPOINT % conn.transaction_depth)
             conn.execute(SQL_SAVEPOINT % conn.transaction_depth)
@@ -423,6 +354,7 @@ module Sequel
           end
           begin
             conn.transaction_depth += 1
+            @transactions << Thread.current
             yield conn
           rescue ::Exception => e
             if conn.transaction_depth > 1
@@ -431,17 +363,19 @@ module Sequel
             else
               log_info(SQL_ROLLBACK)
               conn.execute(SQL_ROLLBACK) rescue nil
+              @transactions.delete(Thread.current)
             end
             transaction_error(e, *CONVERTED_EXCEPTIONS)
           ensure
             unless e
               begin
-                if conn.transaction_depth < 2
-                  log_info(SQL_COMMIT)
-                  conn.execute(SQL_COMMIT)
-                else
+                if conn.transaction_depth > 1
                   log_info(SQL_RELEASE_SAVEPOINT % [conn.transaction_depth - 1])
                   conn.execute(SQL_RELEASE_SAVEPOINT % [conn.transaction_depth - 1])
+                else
+                  log_info(SQL_COMMIT)
+                  conn.execute(SQL_COMMIT)
+                  @transactions.delete(Thread.current)
                 end
               rescue => e
                 log_info(e.message)
@@ -455,6 +389,59 @@ module Sequel
 
       private
 
+      # SQL statement to create database function.
+      def create_function_sql(name, definition, opts={})
+        args = opts[:args]
+        if !opts[:args].is_a?(Array) || !opts[:args].any?{|a| Array(a).length == 3 and %w'OUT INOUT'.include?(a[2].to_s)}
+          returns = opts[:returns] || 'void'
+        end
+        language = opts[:language] || 'SQL'
+        <<-END
+        CREATE#{' OR REPLACE' if opts[:replace]} FUNCTION #{name}#{sql_function_args(args)}
+        #{"RETURNS #{returns}" if returns}
+        LANGUAGE #{language}
+        #{opts[:behavior].to_s.upcase if opts[:behavior]}
+        #{'STRICT' if opts[:strict]}
+        #{'SECURITY DEFINER' if opts[:security_definer]}
+        #{"COST #{opts[:cost]}" if opts[:cost]}
+        #{"ROWS #{opts[:rows]}" if opts[:rows]}
+        #{opts[:set].map{|k,v| " SET #{k} = #{v}"}.join("\n") if opts[:set]}
+        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#{' 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. 
+      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
+      
+      # 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
+
+      # Always CASCADE the table drop
+      def drop_table_sql(name)
+        "DROP TABLE #{quote_schema_table(name)} 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]}"
+      end
+
       # PostgreSQL folds unquoted identifiers to lowercase, so it shouldn't need to upcase identifiers on input.
       def identifier_input_method_default
         nil
@@ -465,6 +452,25 @@ module Sequel
         nil
       end
 
+      # PostgreSQL specific index SQL.
+      def index_definition_sql(table_name, index)
+        cols = index[:columns]
+        index_name = index[:name] || default_index_name(table_name, cols)
+        expr = literal(Array(cols))
+        unique = "UNIQUE " if index[:unique]
+        index_type = index[:type]
+        filter = index[:where] || index[:filter]
+        filter = " WHERE #{filter_expr(filter)}" if filter
+        case index_type
+        when :full_text
+          expr = "(to_tsvector(#{literal(index[:language] || 'simple')}, #{dataset.send(:full_text_string_join, cols)}))"
+          index_type = :gin
+        when :spatial
+          index_type = :gist
+        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
@@ -499,6 +505,12 @@ module Sequel
         PREPARED_ARG_PLACEHOLDER
       end
       
+      # SQL DDL statement for renaming a table. PostgreSQL doesn't allow you to change a table's schema in
+      # 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 
+
       # The dataset used for parsing table schemas, using the pg_* system catalogs.
       def schema_parse_table(table_name, opts)
         ds2 = dataset
@@ -506,7 +518,7 @@ module Sequel
             SQL::Function.new(:format_type, :pg_type__oid, :pg_attribute__atttypmod).as(:db_type),
             SQL::Function.new(:pg_get_expr, :pg_attrdef__adbin, :pg_class__oid).as(:default),
             SQL::BooleanExpression.new(:NOT, :pg_attribute__attnotnull).as(:allow_null),
-            SQL::Function.new(:COALESCE, {:pg_attribute__attnum => SQL::Function.new(:ANY, :pg_index__indkey)}.sql_expr, false).as(:primary_key)).
+            SQL::Function.new(:COALESCE, SQL::BooleanExpression.from_value_pairs(:pg_attribute__attnum => SQL::Function.new(:ANY, :pg_index__indkey)), false).as(:primary_key)).
           from(:pg_class).
           join(:pg_attribute, :attrelid=>:oid).
           join(:pg_type, :oid=>:atttypid).
@@ -520,7 +532,7 @@ module Sequel
         ds.identifier_input_method = nil
         ds.identifier_output_method = nil
         ds.map do |row|
-          row[:default] = nil if row[:default].blank?
+          row[:default] = nil if blank_object?(row[:default])
           row[:type] = schema_column_type(row[:db_type])
           [ds2.send(:output_identifier, row.delete(:name)), row]
         end
@@ -566,7 +578,7 @@ module Sequel
         def prepared_sql
           return @prepared_sql if @prepared_sql
           super
-          if @prepared_type == :insert and server_version >= 80200
+          if @prepared_type == :insert and !@opts[:disable_insert_returning] and server_version >= 80200
             @prepared_sql = insert_returning_pk_sql(@prepared_modify_values)
             meta_def(:insert_returning_pk_sql){|*args| prepared_sql}
           end
@@ -574,6 +586,16 @@ module Sequel
         end
       end
 
+      # Add the disable_insert_returning! mutation method
+      def self.extended(obj)
+        obj.def_mutation_method(:disable_insert_returning)
+      end
+
+      # Add the disable_insert_returning! mutation method
+      def self.included(mod)
+        mod.def_mutation_method(:disable_insert_returning)
+      end
+
       # Return the results of an ANALYZE query as a string
       def analyze(opts = nil)
         analysis = []
@@ -583,6 +605,11 @@ module Sequel
         analysis.join("\r\n")
       end
       
+      # Disable the use of INSERT RETURNING, even if the server supports it
+      def disable_insert_returning
+        clone(:disable_insert_returning=>true)
+      end
+
       # Return the results of an EXPLAIN query as a string
       def explain(opts = nil)
         analysis = []
@@ -606,14 +633,13 @@ module Sequel
       # in 8.3 by default, and available for earlier versions as an add-on).
       def full_text_search(cols, terms, opts = {})
         lang = opts[:language] || 'simple'
-        cols =  Array(cols).map{|x| SQL::Function.new(:COALESCE, x, '')}.sql_string_join(' ')
-        filter("to_tsvector(#{literal(lang)}, #{literal(cols)}) @@ to_tsquery(#{literal(lang)}, #{literal(Array(terms).join(' | '))})")
+        filter("to_tsvector(#{literal(lang)}, #{full_text_string_join(cols)}) @@ to_tsquery(#{literal(lang)}, #{literal(Array(terms).join(' | '))})")
       end
       
       # Insert given values into the database.
       def insert(*values)
-        if !@opts[:sql] and server_version >= 80200
-          single_value(default_server_opts(:sql=>insert_returning_pk_sql(*values)))
+        if !@opts[:sql] and !@opts[:disable_insert_returning] and server_version >= 80200
+          clone(default_server_opts(:sql=>insert_returning_pk_sql(*values))).single_value
         else
           execute_insert(insert_sql(*values), :table=>opts[:from].first,
             :values=>values.size == 1 ? values.first : values)
@@ -627,7 +653,7 @@ module Sequel
 
       # Insert a record returning the record inserted
       def insert_select(*values)
-        single_record(default_server_opts(:naked=>true, :sql=>insert_returning_sql(nil, *values))) if server_version >= 80200
+        naked.clone(default_server_opts(:sql=>insert_returning_sql(nil, *values))).single_record if server_version >= 80200
       end
 
       # Locks the table with the specified mode.
@@ -712,6 +738,14 @@ module Sequel
       def server_version
         db.server_version(@opts[:server])
       end
+
+      # Concatenate the expressions with a space in between
+      def full_text_string_join(cols)
+        cols = Array(cols).map{|x| SQL::Function.new(:COALESCE, x, '')}
+        cols = cols.zip([' '] * cols.length).flatten
+        cols.pop
+        literal(SQL::StringExpression.new(:'||', *cols))
+      end
     end
   end
 end