sequel 2.4.0 → 2.5.0

data/CHANGELOG

@@ -1,3 +1,37 @@
+=== 2.5.0 (2008-09-03)
+
+* Add Dataset #set_defaults and #set_overrides, used for scoping the values used in insert/update statements (jeremyevans)
+
+* Allow Models to use the RETURNING clause when inserting records on PostgreSQL (jeremyevans)
+
+* Raise Sequel::DatabaseError instead of generic Sequel::Error for database errors, don't swallow tracebacks (jeremyevans)
+
+* Use INSERT ... RETURNING ... with PostgreSQL 8.2 and higher (jeremyevans)
+
+* Make insert_sql, delete_sql, and update_sql respect the :sql option (jeremyevans)
+
+* Default to converting 2 digit years, use Sequel.convert_two_digit_years = false to get back the old behavior (jeremyevans)
+
+* Make the PostgreSQL adapter with the pg driver use async_exec, so it doesn't block the entire interpreter (jeremyevans)
+
+* Make the schema generators support composite primary and foreign keys and unique constraints (jarredholman)
+
+* Work with the 2008.08.17 version of the pg gem (erikh)
+
+* Disallow abuse of SQL function syntax for types (use :type=>:varchar, :size=>255 instead of :type=>:varchar[255]) (jeremyevans)
+
+* Quote index names when creating or dropping indexes (jeremyevans, SanityInAnarchy)
+
+* Don't have column accessor methods override plugin instance methods (jeremyevans)
+
+* Allow validation of multiple attributes at once, with built in support for uniqueness checking of multiple columns (jeremyevans)
+
+* In PostgreSQL adapter, fix inserting a row with a primary key value inside a transaction (jeremyevans)
+
+* Allow before_save and before_update to affect the columns saved by save_changes (jeremyevans)
+
+* Make Dataset#single_value work when graphing, which fixes count and paginate on graphed datasets (jeremyevans)
+
 === 2.4.0 (2008-08-06)
 
 * Handle Java::JavaSql::Date type in the JDBC adapter (jeremyevans)

data/Rakefile

@@ -8,7 +8,7 @@ require "spec/rake/spectask"
 include FileUtils
 
 NAME = 'sequel'
-VERS = '2.4.0'
+VERS = '2.5.0'
 CLEAN.include ["**/.*.sw?", "pkg", ".config", "rdoc", "coverage", "www/public/*.html"]
 RDOC_OPTS = ["--quiet", "--line-numbers", "--inline-source", '--title', \
   'Sequel: The Database Toolkit for Ruby', '--main', 'README']

data/lib/sequel_core.rb

@@ -22,21 +22,30 @@ end
 #
 #   Sequel.sqlite('blog.db'){|db| puts db.users.count}  
 #
-# Sequel can use either Time or DateTime for times returned from the
-# database.  It defaults to Time.  To change it to DateTime, use:
-#
-#   Sequel.datetime_class = DateTime
-#
 # Sequel converts the column type tinyint to a boolean by default,
 # you can override the conversion to use tinyint as an integer:
 #
 #   Sequel.convert_tinyint_to_bool = false
+#
+# Sequel converts two digit years in Dates and DateTimes by default,
+# so 01/02/03 is interpreted at January 2nd, 2003, and 12/13/99 is interpreted
+# as December 13, 1999.. You can override this # to treat those dates as
+# January 2nd, 0003 and December 13, 0099, respectively, by setting: 
+#
+#   Sequel.convert_two_digit_years = false
+#
+# Sequel can use either Time or DateTime for times returned from the
+# database.  It defaults to Time.  To change it to DateTime, use:
+#
+#   Sequel.datetime_class = DateTime
 module Sequel
-  @datetime_class = Time
   @convert_tinyint_to_bool = true
+  @convert_two_digit_years = true
+  @datetime_class = Time
   
-  metaattr_accessor :datetime_class
   metaattr_accessor :convert_tinyint_to_bool
+  metaattr_accessor :convert_two_digit_years
+  metaattr_accessor :datetime_class
 
   # Creates a new database object based on the supplied connection string
   # and optional arguments.  The specified scheme determines the database

data/lib/sequel_core/adapters/ado.rb

@@ -14,14 +14,18 @@ module Sequel
     class Database < Sequel::Database
       set_adapter_scheme :ado
 
-      def connect(server)
-        opts = server_opts(server)
+      def initialize(opts)
+        super(opts)
         opts[:driver] ||= 'SQL Server'
         case opts[:driver]
         when 'SQL Server'
           require 'sequel_core/adapters/shared/mssql'
           extend Sequel::MSSQL::DatabaseMethods
         end
+      end
+
+      def connect(server)
+        opts = server_opts(server)
         s = "driver=#{opts[:driver]};server=#{opts[:host]};database=#{opts[:database]}#{";uid=#{opts[:user]};pwd=#{opts[:password]}" if opts[:user]}"
         handle = WIN32OLE.new('ADODB.Connection')
         handle.Open(s)

data/lib/sequel_core/adapters/db2.rb

@@ -69,7 +69,7 @@ module Sequel
         when SQL_SUCCESS, SQL_SUCCESS_WITH_INFO
           nil
         else
-          raise Error, msg
+          raise DatabaseError, msg
         end
       end
     end

data/lib/sequel_core/adapters/jdbc.rb

@@ -126,7 +126,7 @@ module Sequel
               end
             end
           rescue NativeException, JavaSQL::SQLException => e
-            raise Error, e.message
+            raise_error(e)
           ensure
             stmt.close
           end
@@ -232,7 +232,7 @@ module Sequel
               end
             end
           rescue NativeException, JavaSQL::SQLException => e
-            raise Error, e.message
+            raise_error(e)
           ensure
             cps.close unless name
           end

data/lib/sequel_core/adapters/jdbc/postgresql.rb

@@ -21,7 +21,7 @@ module Sequel
             rows = stmt.send(method, sql)
             yield(rows) if block_given?
           rescue NativeException => e
-            raise Error, e.message
+            raise_error(e)
           ensure
             stmt.close
           end
@@ -30,15 +30,10 @@ module Sequel
         private
         
         # JDBC specific method of getting specific values from a result set.
-        def result_set_values(r, *vals)
-          return if r.nil?
-          r.next
-          return if r.getRow == 0
-          case vals.length
-          when 1
-            r.getString(vals.first+1)
-          else
-            vals.collect{|col| r.getString(col+1)}
+        def single_value(r)
+          unless r.nil?
+            r.next
+            r.getString(1) unless r.getRow == 0
           end
         end
       end
@@ -48,6 +43,15 @@ module Sequel
       module DatabaseMethods
         include Sequel::Postgres::DatabaseMethods
         
+        # Add the primary_keys and primary_key_sequences instance variables,
+        # so we can get the correct return values for inserted rows.
+        def self.extended(db)
+          db.instance_eval do
+            @primary_keys = {}
+            @primary_key_sequences = {}
+          end
+        end
+        
         # Return instance of Sequel::JDBC::Postgres::Dataset with the given opts.
         def dataset(opts=nil)
           Sequel::JDBC::Postgres::Dataset.new(self, opts)
@@ -65,6 +69,7 @@ module Sequel
         def setup_connection(conn)
           conn = super(conn)
           conn.extend(Sequel::JDBC::Postgres::AdapterMethods)
+          conn.db = self
           conn
         end
         
@@ -77,6 +82,13 @@ module Sequel
       # Dataset subclass used for datasets that connect to PostgreSQL via JDBC.
       class Dataset < JDBC::Dataset
         include Sequel::Postgres::DatasetMethods
+
+        # Add the shared PostgreSQL prepared statement methods
+        def prepare(*args)
+          ps = super
+          ps.extend(::Sequel::Postgres::DatasetMethods::PreparedStatementMethods)
+          ps
+        end
         
         # Convert Java::JavaSql::Timestamps correctly, and handle SQL::Blobs
         # correctly.

data/lib/sequel_core/adapters/mysql.rb

@@ -137,7 +137,7 @@ module Sequel
         begin
           synchronize(opts[:server]){|conn| _execute(conn, sql, opts, &block)}
         rescue Mysql::Error => e
-          raise Error.new(e.message)
+          raise_error(e)
         end
       end
       
@@ -163,7 +163,7 @@ module Sequel
           rescue ::Exception => e
             log_info(SQL_ROLLBACK)
             conn.query(SQL_ROLLBACK)
-            raise (Mysql::Error === e ? Error.new(e.message) : e) unless Error::Rollback === e
+            transaction_error(e, Mysql::Error)
           ensure
             unless e
               log_info(SQL_COMMIT)

data/lib/sequel_core/adapters/odbc.rb

@@ -8,13 +8,17 @@ module Sequel
       GUARDED_DRV_NAME = /^\{.+\}$/.freeze
       DRV_NAME_GUARDS = '{%s}'.freeze
 
-      def connect(server)
-        opts = server_opts(server)
+      def initialize(opts)
+        super(opts)
         case opts[:db_type]
         when 'mssql'
           require 'sequel_core/adapters/shared/mssql'
           extend Sequel::MSSQL::DatabaseMethods
         end
+      end
+
+      def connect(server)
+        opts = server_opts(server)
         if opts.include? :driver
           drv = ::ODBC::Driver.new
           drv.name = 'Sequel ODBC Driver130'

data/lib/sequel_core/adapters/postgres.rb

@@ -56,7 +56,12 @@ rescue LoadError => e
           end
         end
       end
-      alias_method :finish, :close unless method_defined?(:finish) 
+      alias_method :finish, :close unless method_defined?(:finish)
+      alias_method :async_exec, :exec unless method_defined?(:async_exec)
+      unless method_defined?(:block)
+        def block(timeout=nil)
+        end
+      end
     end
     class PGresult 
       alias_method :nfields, :num_fields unless method_defined?(:nfields) 
@@ -119,11 +124,13 @@ module Sequel
       def execute(sql, args=nil)
         q = nil
         begin
-          q = args ? exec(sql, args) : exec(sql)
+          q = args ? async_exec(sql, args) : async_exec(sql)
         rescue PGError => e
           raise if status == Adapter::CONNECTION_OK
           reset
-          q = args ? exec(sql, args) : exec(sql)
+          q = args ? async_exec(sql, args) : async_exec(sql)
+        ensure
+          block
         end
         begin
           block_given? ? yield(q) : q.cmd_tuples
@@ -144,14 +151,8 @@ module Sequel
       private
       
       # Return the requested values for the given row.
-      def result_set_values(r, *vals)
-        return if r.nil? || (r.ntuples == 0)
-        case vals.length
-        when 1
-          r.getvalue(0, vals.first)
-        else
-          vals.collect{|col| r.getvalue(0, col)}
-        end
+      def single_value(r)
+        r.getvalue(0, 0) unless r.nil? || (r.ntuples == 0)
       end
     end
     
@@ -162,6 +163,14 @@ module Sequel
       
       set_adapter_scheme :postgres
       
+      # 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 = {}
+      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.
@@ -170,7 +179,7 @@ module Sequel
         conn = Adapter.connect(
           opts[:host] || 'localhost',
           opts[:port] || 5432,
-          '', '',
+          nil, '',
           opts[:database],
           opts[:user],
           opts[:password]
@@ -178,6 +187,7 @@ module Sequel
         if encoding = opts[:encoding] || opts[:charset]
           conn.set_client_encoding(encoding)
         end
+        conn.db = self
         conn
       end
       
@@ -199,7 +209,7 @@ module Sequel
           synchronize(opts[:server]){|conn| conn.execute(sql, opts[:arguments], &block)}
         rescue => e
           log_info(e.message)
-          raise convert_pgerror(e)
+          raise_error(e, :classes=>CONVERTED_EXCEPTIONS)
         end
       end
       
@@ -215,7 +225,7 @@ module Sequel
           end
         rescue => e
           log_info(e.message)
-          raise convert_pgerror(e)
+          raise_error(e, :classes=>CONVERTED_EXCEPTIONS)
         end
       end
       
@@ -361,6 +371,7 @@ module Sequel
         # pg driver.
         module PreparedStatementMethods
           include BindArgumentMethods
+          include ::Sequel::Postgres::DatasetMethods::PreparedStatementMethods
           
           private
           

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

@@ -17,15 +17,15 @@ module Sequel
       # Use MySQL specific syntax for rename column, set column type, and
       # drop index cases.
       def alter_table_sql(table, op)
-        type = type_literal(op[:type])
-        type << '(255)' if type == 'varchar'
+        quoted_table = quote_identifier(table)
+        quoted_name = quote_identifier(op[:name]) if op[:name]
         case op[:op]
         when :rename_column
-          "ALTER TABLE #{table} CHANGE COLUMN #{literal(op[:name])} #{literal(op[:new_name])} #{type}"
+          "ALTER TABLE #{quoted_table} CHANGE COLUMN #{quoted_name} #{quote_identifier(op[:new_name])} #{type_literal(op)}"
         when :set_column_type
-          "ALTER TABLE #{table} CHANGE COLUMN #{literal(op[:name])} #{literal(op[:name])} #{type}"
+          "ALTER TABLE #{quoted_table} CHANGE COLUMN #{quoted_name} #{quoted_name} #{type_literal(op)}"
         when :drop_index
-          "DROP INDEX #{default_index_name(table, op[:columns])} ON #{table}"
+          "#{drop_index_sql(table, op)} ON #{quoted_table}"
         else
           super(table, op)
         end
@@ -36,44 +36,24 @@ module Sequel
         AUTO_INCREMENT
       end
       
-      # Handle MySQL specific column syntax (not sure why).
-      def column_definition_sql(column)
-        if column[:type] == :check
-          return constraint_definition_sql(column)
-        end
-        sql = "#{literal(column[:name].to_sym)} #{TYPES[column[:type]]}"
-        column[:size] ||= 255 if column[:type] == :varchar
-        elements = column[:size] || column[:elements]
-        sql << literal(Array(elements)) if elements
-        sql << UNSIGNED if column[:unsigned]
-        sql << UNIQUE if column[:unique]
-        sql << NOT_NULL if column[:null] == false
-        sql << NULL if column[:null] == true
-        sql << " DEFAULT #{literal(column[:default])}" if column.include?(:default)
-        sql << PRIMARY_KEY if column[:primary_key]
-        sql << " #{auto_increment_sql}" if column[:auto_increment]
-        if column[:table]
-          sql << ", FOREIGN KEY (#{literal(column[:name].to_sym)}) REFERENCES #{column[:table]}"
-          sql << literal(Array(column[:key])) if column[:key]
-          sql << " ON DELETE #{on_delete_clause(column[:on_delete])}" if column[:on_delete]
-        end
-        sql
+      # Handle MySQL specific syntax for column references
+      def column_references_sql(column)
+        ", FOREIGN KEY (#{quote_identifier(column[:name])})#{super(column)}"
       end
       
       # Handle MySQL specific index SQL syntax
       def index_definition_sql(table_name, index)
-        index_name = index[:name] || default_index_name(table_name, index[:columns])
-        unique = "UNIQUE " if index[:unique]
-        case index[:type]
+        index_name = quote_identifier(index[:name] || default_index_name(table_name, index[:columns]))
+        index_type = case index[:type]
         when :full_text
-          "CREATE FULLTEXT INDEX #{index_name} ON #{table_name} #{literal(index[:columns])}"
+          "FULLTEXT "
         when :spatial
-          "CREATE SPATIAL INDEX #{index_name} ON #{table_name} #{literal(index[:columns])}"
-        when nil
-          "CREATE #{unique}INDEX #{index_name} ON #{table_name} #{literal(index[:columns])}"
+          "SPATIAL "
         else
-          "CREATE #{unique}INDEX #{index_name} ON #{table_name} #{literal(index[:columns])} USING #{index[:type]}"
+          using = " USING #{index[:type]}" unless index[:type] == nil
+          "UNIQUE " if index[:unique]
         end
+        "CREATE #{index_type}INDEX #{index_name} ON #{quote_identifier(table_name)} #{literal(index[:columns])}#{using}"
       end
       
       # Get version of MySQL server, used for determined capabilities.

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

@@ -6,19 +6,11 @@ module Sequel
     
     # Methods shared by adapter/connection instances.
     module AdapterMethods
+      attr_writer :db
+      
       SELECT_CURRVAL = "SELECT currval('%s')".freeze
-      SELECT_PK = <<-end_sql
-        SELECT pg_attribute.attname
-        FROM pg_class, pg_attribute, pg_index
-        WHERE pg_class.oid = pg_attribute.attrelid AND
-          pg_class.oid = pg_index.indrelid AND
-          pg_index.indkey[0] = pg_attribute.attnum AND
-          pg_index.indisprimary = 't' AND
-          pg_class.relname = '%s'
-      end_sql
-      SELECT_PK_AND_CUSTOM_SEQUENCE = <<-end_sql
-        SELECT attr.attname,  
-          CASE  
+      SELECT_CUSTOM_SEQUENCE = <<-end_sql
+        SELECT CASE  
             WHEN split_part(def.adsrc, '''', 2) ~ '.' THEN  
               substr(split_part(def.adsrc, '''', 2),  
                      strpos(split_part(def.adsrc, '''', 2), '.')+1) 
@@ -33,8 +25,17 @@ module Sequel
           AND cons.contype = 'p'
           AND def.adsrc ~* 'nextval'
       end_sql
-      SELECT_PK_AND_SERIAL_SEQUENCE = <<-end_sql
-        SELECT attr.attname, name.nspname, seq.relname
+      SELECT_PK = <<-end_sql
+        SELECT pg_attribute.attname
+        FROM pg_class, pg_attribute, pg_index
+        WHERE pg_class.oid = pg_attribute.attrelid AND
+          pg_class.oid = pg_index.indrelid AND
+          pg_index.indkey[0] = pg_attribute.attnum AND
+          pg_index.indisprimary = 't' AND
+          pg_class.relname = '%s'
+      end_sql
+      SELECT_SERIAL_SEQUENCE = <<-end_sql
+        SELECT seq.relname
         FROM pg_class seq, pg_attribute attr, pg_depend dep,
           pg_namespace name, pg_constraint cons
         WHERE seq.oid = dep.objid
@@ -52,39 +53,38 @@ module Sequel
       # to implement multi-level transactions with savepoints.
       attr_accessor :transaction_depth
       
-      # Get the last inserted value for the given table.
-      def last_insert_id(table)
-        @table_sequences ||= {}
-        if !@table_sequences.include?(table)
-          pkey_and_seq = pkey_and_sequence(table)
-          if pkey_and_seq
-            @table_sequences[table] = pkey_and_seq[1]
-          end
-        end
-        if seq = @table_sequences[table]
-          execute(SELECT_CURRVAL % seq) do |r|
-            val = result_set_values(r, 0)
-            val.to_i if val
-          end
+      # Get the last inserted value for the given sequence.
+      def last_insert_id(sequence)
+        sql = SELECT_CURRVAL % sequence
+        @db.log_info(sql)
+        execute(sql) do |r|
+          val = single_value(r)
+          return val.to_i if val
         end
       end
       
       # Get the primary key and sequence for the given table.
-      def pkey_and_sequence(table)
-        execute(SELECT_PK_AND_SERIAL_SEQUENCE % table) do |r|
-          vals = result_set_values(r, 2, 2)
-          return vals if vals
+      def sequence(table)
+        sql = SELECT_SERIAL_SEQUENCE % table
+        @db.log_info(sql)
+        execute(sql) do |r|
+          seq = single_value(r)
+          return seq if seq
         end
-    
-        execute(SELECT_PK_AND_CUSTOM_SEQUENCE % table) do |r|
-          result_set_values(r, 0, 1)
+        
+        sql = SELECT_CUSTOM_SEQUENCE % table
+        @db.log_info(sql)
+        execute(sql) do |r|
+          return single_value(r)
         end
       end
       
       # Get the primary key for the given table.
       def primary_key(table)
-        execute(SELECT_PK % table) do |r|
-          result_set_values(r, 0)
+        sql = SELECT_PK % table
+        @db.log_info(sql)
+        execute(sql) do |r|
+          return single_value(r)
         end
       end
     end
@@ -92,7 +92,7 @@ module Sequel
     # Methods shared by Database instances that connect to PostgreSQL.
     module DatabaseMethods
       PREPARED_ARG_PLACEHOLDER = '$'.lit.freeze
-      RE_CURRVAL_ERROR = /currval of sequence "(.*)" is not yet defined in this session/.freeze
+      RE_CURRVAL_ERROR = /currval of sequence "(.*)" is not yet defined in this session|relation "(.*)" does not exist/.freeze
       RELATION_QUERY = {:from => [:pg_class], :select => [:relname]}.freeze
       RELATION_FILTER = "(relkind = 'r') AND (relname !~ '^pg|sql')".freeze
       SQL_BEGIN = 'BEGIN'.freeze
@@ -103,6 +103,16 @@ module Sequel
       SQL_RELEASE_SAVEPOINT = 'RELEASE SAVEPOINT autopoint_%d'.freeze
       SYSTEM_TABLE_REGEXP = /^pg|sql/.freeze
       
+      # Remove the cached entries for primary keys and sequences when dropping a table.
+      def drop_table(*names)
+        names.each do |name|
+          s = name.to_sym
+          @primary_keys.delete(s)
+          @primary_key_sequences.delete(s)
+        end
+        super
+      end
+
       # Always CASCADE the table drop
       def drop_table_sql(name)
         "DROP TABLE #{name} CASCADE"
@@ -128,29 +138,6 @@ module Sequel
         "CREATE #{unique}INDEX #{index_name} ON #{table_name} #{"USING #{index_type} " if index_type}#{expr}#{filter}"
       end
       
-      # The result of the insert for the given table and values.  Uses
-      # last insert id the primary key for the table if it exists,
-      # otherwise determines the primary key for the table and uses the
-      # value of the hash key.  If values is an array, assume the first
-      # value is the primary key value and return that.
-      def insert_result(conn, table, values)
-        begin
-          result = conn.last_insert_id(table)
-          return result if result
-        rescue Exception => e
-          convert_pgerror(e) unless RE_CURRVAL_ERROR.match(e.message)
-        end
-        
-        case values
-        when Hash
-          values[primary_key_for_table(conn, table)]
-        when Array
-          values.first
-        else
-          nil
-        end
-      end
-      
       # Dataset containing all current database locks 
       def locks
         dataset.from(:pg_class, :pg_locks).
@@ -158,14 +145,11 @@ module Sequel
           filter(:pg_class__relfilenode=>:pg_locks__relation)
       end
       
-      # Returns primary key for the given table.  This information is
-      # cached, and if the primary key for a table is changed, the
-      # @primary_keys instance variable should be reset manually.
-      def primary_key_for_table(conn, table)
-        @primary_keys ||= {}
-        @primary_keys[table] ||= conn.primary_key(table)
+      # Return primary key for the given table.
+      def primary_key(table, server=nil)
+        synchronize(server){|conn| primary_key_for_table(conn, table)}
       end
-      
+
       # PostgreSQL uses SERIAL psuedo-type instead of AUTOINCREMENT for
       # managing incrementing primary keys.
       def serial_primary_key_options
@@ -212,7 +196,7 @@ module Sequel
               log_info(SQL_ROLLBACK)
               conn.execute(SQL_ROLLBACK) rescue nil
             end
-            raise convert_pgerror(e) unless Error::Rollback === e
+            transaction_error(e, *CONVERTED_EXCEPTIONS)
           ensure
             unless e
               begin
@@ -225,7 +209,7 @@ module Sequel
                 end
               rescue => e
                 log_info(e.message)
-                raise convert_pgerror(e)
+                raise_error(e, :classes=>CONVERTED_EXCEPTIONS)
               end
             end
             conn.transaction_depth -= 1
@@ -235,9 +219,32 @@ module Sequel
 
       private
       
-      # Convert the exception to a Sequel::Error if it is in CONVERTED_EXCEPTIONS.
-      def convert_pgerror(e)
-        e.is_one_of?(*CONVERTED_EXCEPTIONS) ? Error.new(e.message) : e
+      # 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
+      # the primary key is present in the hash, return its value.  Otherwise,
+      # look up the sequence for the table's primary key.  If one exists,
+      # return the last value the of the sequence for the connection.
+      def insert_result(conn, table, values)
+        case values
+        when Hash
+          return nil unless pk = primary_key_for_table(conn, table)
+          if pk and pkv = values[pk.to_sym]
+            pkv
+          else
+            begin
+              if seq = primary_key_sequence_for_table(conn, table)
+                conn.last_insert_id(seq)
+              end
+            rescue Exception => e
+              raise_error(e, :classes=>CONVERTED_EXCEPTIONS) unless RE_CURRVAL_ERROR.match(e.message)
+            end
+          end
+        when Array
+          values.first
+        else
+          nil
+        end
       end
       
       # Use a dollar sign instead of question mark for the argument
@@ -246,6 +253,20 @@ module Sequel
         PREPARED_ARG_PLACEHOLDER
       end
       
+      # Returns primary key for the given table.  This information is
+      # cached, and if the primary key for a table is changed, the
+      # @primary_keys instance variable should be reset manually.
+      def primary_key_for_table(conn, table)
+        @primary_keys.include?(table) ? @primary_keys[table] : (@primary_keys[table] = conn.primary_key(table))
+      end
+      
+      # Returns primary key for the given table.  This information is
+      # cached, and if the primary key for a table is changed, the
+      # @primary_keys instance variable should be reset manually.
+      def primary_key_sequence_for_table(conn, table)
+        @primary_key_sequences.include?(table) ? @primary_key_sequences[table] : (@primary_key_sequences[table] = conn.sequence(table))
+      end
+      
       # When the :schema option is used, use the the given schema.
       # When the :schema option is nil, return results for all schemas.
       # If the :schema option is not used, use the public schema.
@@ -278,6 +299,20 @@ module Sequel
       SHARE_ROW_EXCLUSIVE = 'SHARE ROW EXCLUSIVE'.freeze
       SHARE_UPDATE_EXCLUSIVE = 'SHARE UPDATE EXCLUSIVE'.freeze
       
+      # Shared methods for prepared statements when used with PostgreSQL databases.
+      module PreparedStatementMethods
+        # Override insert action to use RETURNING if the server supports it.
+        def prepared_sql
+          return @prepared_sql if @prepared_sql
+          super
+          if @prepared_type == :insert and server_version >= 80200
+            @prepared_sql = insert_returning_pk_sql(@prepared_modify_values)
+            meta_def(:insert_returning_pk_sql){|*args| prepared_sql}
+          end
+          @prepared_sql
+        end
+      end
+
       # Return the results of an ANALYZE query as a string
       def analyze(opts = nil)
         analysis = []
@@ -317,10 +352,24 @@ module Sequel
       
       # Insert given values into the database.
       def insert(*values)
-        execute_insert(insert_sql(*values), :table=>source_list(@opts[:from]),
-          :values=>values.size == 1 ? values.first : values)
+        if !@opts[:sql] and server_version >= 80200
+          single_value(:sql=>insert_returning_pk_sql(*values))
+        else
+          execute_insert(insert_sql(*values), :table=>opts[:from].first,
+            :values=>values.size == 1 ? values.first : values)
+        end
       end
-      
+
+      # Use the RETURNING clause to return the columns listed in returning.
+      def insert_returning_sql(returning, *values)
+        "#{insert_sql(*values)} RETURNING #{column_list(Array(returning))}"
+      end
+
+      # Insert a record returning the record inserted
+      def insert_select(*values)
+        single_record(:naked=>true, :sql=>insert_returning_sql(nil, *values)) if server_version >= 80200
+      end
+
       # Handle microseconds for Time and DateTime values, as well as PostgreSQL
       # specific boolean values and string escaping.
       def literal(v)
@@ -357,7 +406,7 @@ module Sequel
       
       # For PostgreSQL version > 8.2, allow inserting multiple rows at once.
       def multi_insert_sql(columns, values)
-        return super if @db.server_version < 80200
+        return super if server_version < 80200
         
         # postgresql 8.2 introduces support for multi-row insert
         columns = column_list(columns)
@@ -390,6 +439,17 @@ module Sequel
       def execute_insert(sql, opts={})
         @db.execute_insert(sql, {:server=>@opts[:server] || :default}.merge(opts))
       end
+
+      # Use the RETURNING clause to return the primary key of the inserted record, if it exists
+      def insert_returning_pk_sql(*values)
+        pk = db.primary_key(opts[:from].first)
+        insert_returning_sql(pk ? Sequel::SQL::Identifier.new(pk) : 'NULL'.lit, *values)
+      end
+
+      # The version of the database server
+      def server_version
+        db.server_version(@opts[:server])
+      end
     end
   end
 end