sequel 4.26.0 → 4.29.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cf4997b7f0149580e9838f7a7c1d0802ce9fdd6b
-  data.tar.gz: 21d723dcf70b74e58a194e71c0d1fb31a6775917
+  metadata.gz: f1baf17a3ed5aedeadf0002e4e68ac8e2e27bdc2
+  data.tar.gz: 9ceec8f5898df4025b6cf5239f461dee5595ebeb
 SHA512:
-  metadata.gz: 851a0cbbd200cffc7280a35168450fcfdb690af48b21c5adf6864289df9fa8eb2b7e7999b396598d0bf3db371e1e721db896bdb869288aa79b8d5db36467b2ed
-  data.tar.gz: 806d66ebf5e196040b42bc023dc2ac13a374037df98e419cc1db69bc2a52c10cd4bae8e6e22c79681ed27256fbba81e109d3a0a593ae62831d3f0cd827c6e2f8
+  metadata.gz: a2c9116e35e8ff8a536530cff484f2d82fac1916db18d8d4b4666359c6ce1f6a67aeb855feb173128f874a179bc75ef10a22bd326ecf48ad6c3cfbe6f3f3b8d3
+  data.tar.gz: 07d8ee3fb38aeae9caa9344756826a7e43fa19bd5786948525b427e9d64c3714ee06d452299b310bb7d30666e16ee0af64f663de7bb9a3dbd3b2fd0f2c5255dd

data/CHANGELOG

@@ -1,3 +1,65 @@
+=== 4.29.0 (2015-12-01)
+
+* Add Model#json_serializer_opts method to json_serializer plugin, allowing for setting to_json defaults on per-instance basis (jeremyevans)
+
+* Add uuid plugin for automatically setting UUID column when creating a model object (pdrakeweb, jeremyevans) (#1106)
+
+* Allow the sqlanywhere adapter to work with sharding (jeremyevans)
+
+* Support blobs as bound variables in the oracle adapter (jeremyevans) (#1104)
+
+* Order by best results first when using the Database#full_text_search :rank option on PostgreSQL (chanks) (#1101)
+
+* Run Database#table_exists? inside a savepoint if currently in a transaction and the database supports savepoints (jeremyevans) (#1100)
+
+* Allow Database#transaction :retry_on option to work when using savepoints (jeremyevans)
+
+* Allow for external adapters to implement Dataset#date_add_sql_append to integrate with the date_arithmetic extension (jeremyevans)
+
+* Add Dataset#insert_empty_columns_values private method for easy overriding for databases that don't support INSERT with DEFAULT VALUES (jeremyevans)
+
+=== 4.28.0 (2015-11-02)
+
+* Add boolean_subsets plugin, which adds a subset for each boolean column (jeremyevans)
+
+* Add subset_conditions plugin, which adds a method for each subset returning the filter conditions for the subset (jeremyevans)
+
+* Make the list plugin work better with the auto_validations plugin when there is a validation on the position column (jeremyevans)
+
+* Make to_csv for model datasets call instance methods, just like Model#to_csv, in the csv_serializer plugin (skrobul) (#1088)
+
+* Raise Sequel::NoExistingObject instead of generic error if Model#refresh can't find the related row (jeremyevans)
+
+=== 4.27.0 (2015-10-01)
+
+* Don't stub Sequel.synchronize on MRI (YorickPeterse) (#1083)
+
+* Make bin/sequel warn if given arguments that it doesn't use (jeremyevans)
+
+* Fix the order of referenced composite keys returned by Database#foreign_key_list on PostgreSQL (jeremyevans) (#1081)
+
+* Recognize another disconnect error in the jdbc/postgresql adapter (jeremyevans)
+
+* In the active model plugin, make Model#persisted? return false if the transaction used for creation is rolled back (jeremyevans) (#1076)
+
+* Use primary_key :keep_order option in the schema dumper if the auto incrementing column is not the first column in the table (jeremyevans)
+
+* Set :auto_increment option correctly in the schema parser when the auto incrementing column is not the first column in the table (jeremyevans)
+
+* Support :keep_order option to primary_key in schema generator, to not automatically make the primary key the first column (jeremyevans)
+
+* Add new jsonb/json functions and operators supported in PostgreSQL 9.5+ (jeremyevans)
+
+* Add before_after_save plugin, for refreshing created objects and resetting modified flag before calling after_create/update/save hooks (jeremyevans)
+
+* Add Dataset#single_record! and #single_value! which don't require cloning the receiver (jeremyevans)
+
+* Dataset#with_sql_single_value now works correctly for model datasets (jeremyevans)
+
+* Optimize Dataset#single_value and #with_sql_single_value to not create an unnecessary array (jeremyevans)
+
+* Make postgres adapter work with postgres-pr 0.7.0 (jeremyevans) (#1074)
+
 === 4.26.0 (2015-09-01)
 
 * Make Dataset#== not consider frozen status in determining equality (jeremyevans)

data/README.rdoc

@@ -44,7 +44,7 @@ If you have any comments or suggestions please post to the Google group.
 
   require 'sequel'
   
-  DB = Sequel.sqlite # memory database
+  DB = Sequel.sqlite # memory database, requires sqlite3
   
   DB.create_table :items do
     primary_key :id
@@ -109,11 +109,11 @@ Or getting results as a hash via +to_hash+, with one column as key and another a
 To connect to a database you simply provide <tt>Sequel.connect</tt> with a URL:
 
   require 'sequel'
-  DB = Sequel.connect('sqlite://blog.db')
+  DB = Sequel.connect('sqlite://blog.db') # requires sqlite3
   
 The connection URL can also include such stuff as the user name, password, and port:
 
-  DB = Sequel.connect('postgres://user:password@host:port/database_name')
+  DB = Sequel.connect('postgres://user:password@host:port/database_name') # requires pg
 
 You can also specify optional parameters, such as the connection pool size, or loggers for logging SQL queries:
 
@@ -267,7 +267,7 @@ issues that you should be aware of when using Sequel.
 
 Counting records is easy using +count+:
 
-  posts.where(:category.like('%ruby%')).count
+  posts.where(Sequel.like(:category, '%ruby%')).count
   # SELECT COUNT(*) FROM posts WHERE category LIKE '%ruby%'
 
 And you can also query maximum/minimum values via +max+ and +min+:

data/bin/sequel

@@ -116,6 +116,9 @@ error_proc = lambda do |msg|
   $stderr.puts(msg)
   exit 1
 end
+extra_proc = lambda do
+  $stderr.puts("Warning: last #{ARGV.length} arguments ignored") unless ARGV.empty?
+end
 
 error_proc["Error: Must specify -m if using -M"] if migrate_ver && !migrate_dir
 error_proc["Error: Cannot specify #{exclusive_options.map{|v| "-#{v}"}.join(' and ')} together"] if exclusive_options.length > 1
@@ -151,16 +154,19 @@ begin
   DB = connect_proc[db]
   load_dirs.each{|d| d.is_a?(Array) ? require(d.first) : Dir["#{d}/**/*.rb"].each{|f| load(f)}}
   if migrate_dir
+    extra_proc.call
     Sequel.extension :migration, :core_extensions
     Sequel::Migrator.apply(DB, migrate_dir, migrate_ver)
     exit
   end
   if dump_migration
+    extra_proc.call
     DB.extension :schema_dumper
     puts DB.dump_schema_migration(:same_db=>dump_migration==:same_db)
     exit
   end
   if dump_schema
+    extra_proc.call
     DB.extension :schema_caching
     DB.tables.each{|t| DB.schema(Sequel::SQL::Identifier.new(t))}
     DB.dump_schema_cache(dump_schema)
@@ -172,6 +178,7 @@ begin
 
     db2 = ARGV.shift
     error_proc["Error: Must specify database connection string or path to yaml file as second argument for database you want to copy to"] if db2.nil? || db2.empty?
+    extra_proc.call
     start_time = Time.now
     TO_DB = connect_proc[db2]
     same_db = DB.database_type==TO_DB.database_type
@@ -225,6 +232,7 @@ begin
     exit
   end
   if code
+    extra_proc.call
     eval(code)
     exit
   end

data/doc/opening_databases.rdoc

@@ -269,12 +269,8 @@ The following additional options are supported:
 === mysql2
 
 This is a newer MySQL adapter that does typecasting in C, so it is often faster than the
-mysql adapter.  Supports the same additional options as the mysql adapter, except for :compress, and uses
-:timeout instead of :read_timeout and :connect_timeout.
-
-The following additional options are supported:
-
-:flags :: Override the flags to use for the connection (e.g. ::Mysql2::Client::MULTI_STATEMENTS)
+mysql adapter.  The options given are passed to Mysql2::Client.new, see the mysql2 documentation
+for details on what options are supported.
 
 === odbc 
 
@@ -309,7 +305,9 @@ The Sequel postgres adapter works with the pg, postgres, and postgres-pr ruby li
 The pg library is the best supported, as it supports real bound variables and prepared statements.
 If the pg library is being used, Sequel will also attempt to load the sequel_pg library, which is
 a C extension that optimizes performance when Sequel is used with pg.  All users of Sequel who
-use pg are encouraged to install sequel_pg.
+use pg are encouraged to install sequel_pg.  For users who want to use postgres-pr to avoid issues
+with C extensions, it is recommended to use jeremyevans-postgres-pr, which fixes many issues in
+the upstream postgres-pr gem, and is regularly tested with Sequel.
 
 The following additional options are supported:
 

data/doc/postgresql.rdoc

@@ -185,6 +185,19 @@ When returning is used, instead of returning the number of rows affected (for up
 or the serial primary key value (for insert), it will return an array of hashes with the
 returned results.
 
+=== VALUES Support
+
+Sequel offers support for the +VALUES+ statement using <tt>Database#values</tt>:
+
+  DB.values([[1,2],[2,3],[3,4]])
+  # VALUES (1, 2), (2, 3), (3, 4)
+
+  DB.values([[1,2],[2,3],[3,4]]).order(2, 1)
+  # VALUES (1, 2), (2, 3), (3, 4) ORDER BY 2, 1
+
+  DB.values([[1,2],[2,3],[3,4]]).order(2, 1).limit(1,2)
+  # VALUES (1, 2), (2, 3), (3, 4) ORDER BY 2, 1 LIMIT 1 OFFSET 2
+
 === INSERT ON CONFLICT Support
 
 Starting with PostgreSQL 9.5, you can do an upsert or ignore unique or exclusion constraint

data/doc/release_notes/4.27.0.txt

@@ -0,0 +1,78 @@
+= New Features
+
+* A before_after_save plugin has been added, which for newly
+  created objects refreshes the object before calling after_create,
+  and resets the modified flag before calling after_update.
+  Previously, these actions were not taken until after after_save
+  was called.  This will be the default behavior in Sequel 5.
+
+* In create_table blocks, primary_key now supports a :keep_order
+  option, which will not change the order in which the primary key
+  is added.  Without this option, Sequel's historical behavior of
+  making the primary key column the first column is used.
+
+    DB.create_table(:foo) do
+      Integer :a
+      primary_key :b, :keep_order=>true
+    end
+    # CREATE TABLE foo 
+    # (a integer, b integer PRIMARY KEY AUTOINCREMENT)
+
+  The schema dumper now uses this option if necessary, allowing it
+  to correctly dump tables where the primary key column is not the
+  first column.
+
+* Dataset#single_record! and #single_value! have been added.  These
+  are faster versions of #single_record and #single_value that
+  don't require cloning the dataset.  If you are sure the dataset
+  will only return a single row or a single value, you can use
+  these methods for better performance.
+
+* The new jsonb and json functions added in PostgreSQL 9.5 are now
+  supported by the pg_json_ops extension.
+
+    Sequel.pg_jsonb_op(:metadata).set(%w'a b', [1,2,3])
+    # jsonb_set("metadata", ARRAY['a','b'], '[1,2,3]'::jsonb, true)
+
+= Other Improvements
+
+* Sequel.synchronize is no longer a stub on MRI.  Testing has shown
+  that relying on the global interpreter lock to protect
+  multi-threaded access to hashes is not safe in all environments,
+  so Sequel now uses a mutex on MRI just as it does on other ruby
+  interpreters.
+
+* Database#schema now sets the :auto_increment option correctly for
+  auto incrementing primary keys if they are not the first column
+  in the table.
+
+* Dataset#single_value and #with_sql_single_value are now slightly
+  faster by avoiding an array allocation.
+
+* Model datasets can now use #with_sql_single_value and return a
+  single value, instead of an array in [:column_name, value] format.
+
+* Model#persisted? in the active_model plugin will now return false
+  if the transaction that inserts the row for the object is rolled
+  back.
+  
+* bin/sequel now warns if additional arguments are passed that it
+  ignores.  In Sequel 5, bin/sequel will raise an error in these
+  cases.
+
+* Database#foreign_key_list on PostgreSQL now returns referenced
+  composite keys in the correct order.
+
+* The postgres adapter now works with postgres-pr 0.7.0. Note that
+  postgres adapter users that want a pure-ruby driver are encouraged
+  to use jeremyevans-postgres-pr as that has many additional bugfixes
+  and is the version tested with Sequel on a regular basis.
+
+* The jdbc/postgresql adapter now recognizes an additional disconnect
+  error.
+
+= Backwards Compatibility
+
+* Users who were relying on #with_sql_single_value returning an array
+  instead of a single value for model datasets need to update their
+  code.

data/doc/release_notes/4.28.0.txt

@@ -0,0 +1,57 @@
+= New Features
+
+* A subset_conditions plugin has been added, which adds a method
+  for each subset that returns the filter conditions for the
+  subset.  This makes it easier to reuse the subset conditions:
+
+    class Foo < Sequel::Model
+      plugin :subset_conditions
+      subset :active, :active=>true
+    end
+
+    Foo.exclude(Foo.active_conditions)
+    Foo.where(:a=>1).or(Foo.active_conditions)
+
+* A boolean_subsets plugin has been added, which adds a subset for each
+  boolean column:
+
+    # Assume boolean column :active
+    Foo.plugin :boolean_subsets
+
+    Foo.active
+    # SELECT * FROM foos WHERE (active IS TRUE)
+
+  You can provide a block to the plugin to change the arguments passed
+  to subset:
+    
+    Foo.plugin :boolean_subsets do |column|
+      [:"where_#{column}", column]
+    end
+
+    Foo.where_active
+    # SELECT * FROM foos WHERE active
+
+  As with similar plugins, you can add the boolean_subsets plugin to
+  Sequel::Model itself, and all subclasses created afterward will have
+  the boolean subset methods automatically created.
+
+= Other Improvements
+
+* If Model#refresh can't find the related row, Sequel now raises a
+  Sequel::NoExistingObject exception instead of a generic
+  Sequel::Error exception.
+
+* In the csv_serializer plugin, when calling #to_csv on a model class
+  or dataset, instead of using #[] to access data, #send is used to
+  call methods.  This is more similar to other plugins as well as
+  Model#to_csv.
+
+* The list plugin now works better with the auto_validations plugin,
+  or any other time there is a validation on the position column.
+
+= Backwards Compatibility
+
+* The change to the csv_serializer plugin can change results if you
+  are overriding any of the column accessor methods.  It can also
+  break existing code if one of the columns being used isn't defined
+  as a method or the method requires more than one argument.

data/doc/release_notes/4.29.0.txt

@@ -0,0 +1,41 @@
+= New Features
+
+* A uuid plugin has now been added.  This plugin will automatically
+  create a uuid for newly created model objects.
+
+    Model.plugin :uuid
+    Model.create.uuid => # some UUID
+
+* Model#json_serializer_opts has been added to the json_serializer
+  plugin, allowing you to override the JSON serialization options
+  on a per instance basis without passing the options directly
+  to Model#to_json.  This is useful if you are including the model
+  instance inside another datastructure that will be serialized
+  to JSON.
+
+    obj.json_serializer_opts(:root => true)
+    [obj].to_json
+    # => '[{"obj":{"id":1,"name":"Foo"}}]'
+
+= Other Improvements
+
+* The Database#transaction :retry_on option now works when using
+  savepoints.
+
+* Calling Database#table_exists? inside a transaction will now use
+  a savepoint if the database supports it, so that if the table
+  doesn't exist, it will not affect the state of the transaction.
+
+* Blobs can now be used as bound variables in the oracle adapter.
+
+* The sqlanywhere adapter now works with database sharding.
+
+* The Dataset#full_text_search :rank option has been fixed to order
+  by rank descending instead of ascending.
+
+* External adapters that do not support INSERT with DEFAULT VALUES
+  can now override Dataset#insert_empty_columns_values to set
+  the columns and values to use for an empty INSERT.
+
+* External adapters can now implement Dataset#date_add_sql_append
+  to integrate with the date_arithmetic extension.

data/doc/thread_safety.rdoc

@@ -4,7 +4,7 @@ Most Sequel usage (and all common Sequel usage) is thread safe by default.  Spec
 
 == Connection Pool
 
-In order to allow multiple threads to operate on the same database at the same time, Sequel uses a connection pool.  The connection pool is designed so that a thread uses a connection for the minimum amount of time, returning the connection to the pool as soon as it is done using the connection.  If a thread requests a connection and the pool does not have an available connection, a new connection will be created.  If the maximum number of connections in the pool has already been reached, the thread will block (actually busy-wait) until a connection is available or the connection pool timeout has elapsed (in which case a PoolTimeout error will be raised).
+In order to allow multiple threads to operate on the same database at the same time, Sequel uses a connection pool.  The connection pool is designed so that a thread uses a connection for the minimum amount of time, returning the connection to the pool as soon as it is done using the connection.  If a thread requests a connection and the pool does not have an available connection, a new connection will be created.  If the maximum number of connections in the pool has already been reached, the thread will block until a connection is available or the connection pool timeout has elapsed (in which case a PoolTimeout error will be raised).
 
 == Exceptions
 

data/doc/transactions.rdoc

@@ -6,7 +6,10 @@ Sequel uses autocommit mode by default for all of its database adapters, so in g
 * Model#save
 * Model#destroy
 * Migrations if the database supports transactional schema
-* A few model plugins
+* Database#use_cursor in the postgres adapter
+* Dataset#lock on PostgreSQL if given a block
+* setter methods created by the association_pks plugin
+* move* methods in the list plugin
 
 Everywhere else, it is up to you to use a database transaction if you want to.
 

data/doc/validations.rdoc

@@ -1,6 +1,6 @@
 = Model Validations
 
-This guide is based on http://guides.rubyonrails.org/activerecord_validations_callbacks.html
+This guide is based on http://guides.rubyonrails.org/active_record_validations.html
 
 == Overview
 

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

@@ -135,7 +135,7 @@ module Sequel
         end
 
         def disconnect_error?(exception, opts)
-          super || exception.message =~ /\AThis connection has been closed\.\z|\AFATAL: terminating connection due to administrator command\z/
+          super || exception.message =~ /\A(This connection has been closed\.|FATAL: terminating connection due to administrator command|An I\/O error occurred while sending to the backend\.)\z/
         end
 
         # Use setNull for nil arguments as the default behavior of setString

data/lib/sequel/adapters/oracle.rb

@@ -122,7 +122,7 @@ module Sequel
           when BigDecimal
             arg = arg.to_f
           when ::Sequel::SQL::Blob
-            raise Error, "Sequel's oracle adapter does not currently support using a blob in a bound variable"
+            arg = ::OCI8::BLOB.new(conn, arg)
           end
           if t = PS_TYPES[type]
             cursor.bind_param(i, arg, t)

data/lib/sequel/adapters/postgres.rb

@@ -2,6 +2,10 @@ Sequel.require 'adapters/shared/postgres'
 
 begin 
   require 'pg' 
+
+  # Work around postgres-pr 0.7.0+ which ships with a pg.rb file
+  raise LoadError unless defined?(PGconn::CONNECTION_OK)
+
   SEQUEL_POSTGRES_USES_PG = true
 rescue LoadError => e 
   SEQUEL_POSTGRES_USES_PG = false
@@ -670,9 +674,11 @@ module Sequel
       end
 
       # Uses a cursor for fetching records, instead of fetching the entire result
-      # set at once.  Can be used to process large datasets without holding
-      # all rows in memory (which is what the underlying drivers may do
-      # by default). Options:
+      # set at once.  Note this uses a transaction around the cursor usage by
+      # default and can be changed using `hold: true` as described below.
+      # Cursors can be used to process large datasets without holding all rows
+      # in memory (which is what the underlying drivers may do by default).
+      # Options:
       #
       # :cursor_name :: The name assigned to the cursor (default 'sequel_cursor').
       #                 Nested cursors require different names.

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

@@ -308,7 +308,7 @@ module Sequel
         ref_ds = base_ds.
           join(:pg_class___cl2, :oid=>:co__confrelid).
           join(:pg_attribute___att2, :attrelid=>:oid, :attnum=>SQL::Function.new(:ANY, :co__confkey)).
-          order(:co__conname, SQL::CaseExpression.new(range.map{|x| [SQL::Subscript.new(:co__conkey, [x]), x]}, 32, :att2__attnum)).
+          order(:co__conname, SQL::CaseExpression.new(range.map{|x| [SQL::Subscript.new(:co__confkey, [x]), x]}, 32, :att2__attnum)).
           select(:co__conname___name, :cl2__relname___table, :att2__attname___refcolumn)
 
         # If a schema is given, we only search in that schema, and the returned :table
@@ -1331,7 +1331,7 @@ module Sequel
         end
 
         if opts[:rank]
-          ds = ds.order{ts_rank_cd(cols, terms)}
+          ds = ds.reverse{ts_rank_cd(cols, terms)}
         end
 
         ds

data/lib/sequel/adapters/sqlanywhere.rb

@@ -79,19 +79,19 @@ module Sequel
 
       # Returns number of rows affected
       def execute_dui(sql, opts=OPTS)
-        synchronize do |conn|
+        synchronize(opts[:server]) do |conn|
           _execute(conn, :rows, sql, opts)
         end
       end
 
       def execute(sql, opts=OPTS, &block)
-        synchronize do |conn|
+        synchronize(opts[:server]) do |conn|
           _execute(conn, :select, sql, opts, &block)
         end
       end
 
       def execute_insert(sql, opts=OPTS)
-        synchronize do |conn|
+        synchronize(opts[:server]) do |conn|
           _execute(conn, :insert, sql, opts)
         end
       end

data/lib/sequel/core.rb

@@ -293,24 +293,14 @@ module Sequel
     end
   end
 
-  if defined?(RUBY_ENGINE) && RUBY_ENGINE != 'ruby'
-  # :nocov:
-    # Mutex used to protect mutable data structures
-    @data_mutex = Mutex.new
-
-    # Unless in single threaded mode, protects access to any mutable
-    # global data structure in Sequel.
-    # Uses a non-reentrant mutex, so calling code should be careful.
-    def self.synchronize(&block)
-      @single_threaded ? yield : @data_mutex.synchronize(&block)
-    end
-  # :nocov:
-  else
-    # Yield directly to the block.  You don't need to synchronize
-    # access on MRI because the GVL makes certain methods atomic.
-    def self.synchronize
-      yield
-    end
+  # Mutex used to protect mutable data structures
+  @data_mutex = Mutex.new
+
+  # Unless in single threaded mode, protects access to any mutable
+  # global data structure in Sequel.
+  # Uses a non-reentrant mutex, so calling code should be careful.
+  def self.synchronize(&block)
+    @single_threaded ? yield : @data_mutex.synchronize(&block)
   end
 
   # Uses a transaction on all given databases with the given options. This:

data/lib/sequel/database/query.rb

@@ -161,7 +161,7 @@ module Sequel
 
       primary_keys = 0
       auto_increment_set = false
-      cols.all? do |_,c|
+      cols.each do |_,c|
         auto_increment_set = true if c.has_key?(:auto_increment)
         primary_keys += 1 if c[:primary_key]
       end
@@ -191,7 +191,12 @@ module Sequel
     def table_exists?(name)
       sch, table_name = schema_and_table(name)
       name = SQL::QualifiedIdentifier.new(sch, table_name) if sch
-      _table_exists?(from(name))
+      ds = from(name)
+      if in_transaction? && supports_savepoints?
+        transaction(:savepoint=>true){_table_exists?(ds)}
+      else
+        _table_exists?(ds)
+      end
       true
     rescue DatabaseError
       false

data/lib/sequel/database/schema_generator.rb

@@ -236,22 +236,35 @@ module Sequel
       #
       # If an array of column symbols is used, you can specify the :name option
       # to name the constraint.
+      #
+      # Options:
+      # :keep_order :: For non-composite primary keys, respects the existing order of
+      #                columns, overriding the default behavior of making the primary
+      #                key the first column.
       # 
       # Examples:
       #   primary_key(:id)
+      #   primary_key(:id, Bigint)
+      #   primary_key(:id, Bigint, :keep_order=>true)
       #   primary_key([:street_number, :house_number], :name=>:some constraint_name)
       def primary_key(name, *args)
         return composite_primary_key(name, *args) if name.is_a?(Array)
-        @primary_key = @db.serial_primary_key_options.merge({:name => name})
+        column = @db.serial_primary_key_options.merge({:name => name})
         
         if opts = args.pop
           opts = {:type => opts} unless opts.is_a?(Hash)
           if type = args.pop
-            opts.merge!(:type => type)
+            opts = opts.merge(:type => type)
           end
-          @primary_key.merge!(opts)
+          column.merge!(opts)
+        end
+
+        @primary_key = column
+        if column[:keep_order]
+          columns << column
+        else
+          columns.unshift(column)
         end
-        @primary_key
       end
 
       # The name of the primary key for this generator, if it has a primary key.

data/lib/sequel/database/transactions.rb

@@ -96,12 +96,12 @@ module Sequel
       else
         synchronize(opts[:server]) do |conn|
           if already_in_transaction?(conn, opts)
-            if opts[:retrying]
-              raise Sequel::Error, "cannot set :retry_on options if you are already inside a transaction"
-            end
             if opts[:savepoint] != false && (stack = _trans(conn)[:savepoints]) && stack.last
               _transaction(conn, Hash[opts].merge!(:savepoint=>true), &block)
             else
+              if opts[:retrying]
+                raise Sequel::Error, "cannot set :retry_on options if you are already inside a transaction"
+              end
               return yield(conn)
             end
           else