sequel 5.31.0 → 5.32.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f7419480f1c01043fb35c490c25cfbbcfaa9b5694ad41462f7af1c5e5e57bdf5
-  data.tar.gz: 7fe799521a27993775f197f15cc38b780c04a3d8d4a9a8ef931da1bea2308779
+  metadata.gz: 5d15527276e1c30bbe39a7260589f3a1e027908dfa51b01e0c365e4162850605
+  data.tar.gz: 7ff61ff4f1af3ef3700c8a8bc15cda941f68eb42f19f28fc376126ebb1f9f9ed
 SHA512:
-  metadata.gz: c3c37683caeb5390eaf614d481be330af8685a07250f4464487d45f0cc0758b94afc28c7008f6ba62f2945f92caf7dc83f2e43907d534e502d16c62e8b0d1c4d
-  data.tar.gz: 49eb980c909fb2490b7e0ec808c0594e84f80593baed607917cd40ed99abab69fc42daf8e7fc5d4691785a0681fa1689c9e1c5130813c0d89cb5e5d638e60cd8
+  metadata.gz: 154fd4039919acb1185ad57c2671eb3cd7162dcc6652f803f2f64ce3acc6204ea99b95a485fab1f003590199f4a1e0213fee1c779bec7852c08db6e17f5995c4
+  data.tar.gz: 398dcdb11a158c49ba270ffecfe6a330085784b28448c367eb4678c1fb394c968377193a06d01db6d6d938788afaad45e2ac56fcfe6688e2c6a8211b42a958cd

data/CHANGELOG

@@ -1,3 +1,19 @@
+=== 5.32.0 (2020-05-01)
+
+* Allow Database#create_table? work with :partition_of option on PostgreSQL (jeremyevans) (#1690)
+
+* Add fiber_concurrency extension, for using Fiber.current instead of Thread.current for checking out connections (jeremyevans)
+
+* Move most Sequel singleton methods into a module that extends Sequel for easier overriding (jeremyevans)
+
+* Fix method visibility issues in model, plugin, extension, and adapter code (jeremyevans)
+
+* Avoid defining conversion procs for PostgreSQL inet/cidr types in pg_inet extension when using sequel_pg 1.13.0+ (jeremyevans)
+
+* Add run_transaction_hooks Database extension, allowing for running the transaction hooks before commit/rollback, for use with transactional testing (jeremyevans)
+
+* Recognize timestamp(N) with time zone type (isc) (#1684)
+
 === 5.31.0 (2020-04-01)
 
 * Fix alter_table drop_constraint :primary_key option on SQLite for non-integer primary keys (jeremyevans)

data/doc/advanced_associations.rdoc

@@ -731,7 +731,7 @@ associations:
     one_to_one :tracks, key: [:disc_number, :number, :album_id], primary_key: [:disc_number, :number, :album_id]
   end
 
-=== Tree - All Ancestors and Descendents
+=== Tree - All Ancestors and Descendants
 
 Let's say you want to store a tree relationship in your database, it's pretty
 simple:
@@ -749,7 +749,7 @@ node.children.  You can even eager load the relationship up to a certain depth:
   # Load parents and grandparents for a group of nodes
   Node.where{id < 10}.eager(parent: :parent).all
 
-What if you want to get all ancestors up to the root node, or all descendents,
+What if you want to get all ancestors up to the root node, or all descendants,
 without knowing the depth of the tree?
 
   class Node < Sequel::Model
@@ -770,7 +770,7 @@ without knowing the depth of the tree?
         id_map = {}
         # Create an map of parent_ids to nodes that have that parent id
         non_root_nodes.each{|n| (id_map[n.parent_id] ||= []) << n}
-        # Doesn't cause an infinte loop, because when only the root node
+        # Doesn't cause an infinite loop, because when only the root node
         # is left, this is not called.
         Node.where(id: id_map.keys).eager(:ancestors).all do |node|
           # Populate the parent association for each node
@@ -879,4 +879,4 @@ associated tickets.
   end
 
 Note that it is often better to use a sum cache instead of this approach.  You can implement
-a sum cache using +after_create+, +after_update+, and +after_delete+ hooks, or preferrably using a database trigger.
+a sum cache using +after_create+, +after_update+, and +after_delete+ hooks, or preferably using a database trigger.

data/doc/association_basics.rdoc

@@ -113,7 +113,7 @@ many rows in the current table, by using a join table to associate the two table
 The one_through_one association can be thought of as a subset of the many_to_many
 association, but where there can only be 0 or 1 records in the associated table.
 This is useful if there is a unique constraint on the foreign key in the join table
-that refrences the current table.  It's also useful if you want to impose an order
+that references the current table.  It's also useful if you want to impose an order
 on the association and just want the first record returned.  The one_through_one
 association is so named because it sets up a one-to-one association through a
 single join table.
@@ -781,7 +781,7 @@ Sequel is designed to be very flexible.  If the default behavior of the
 association modification methods isn't what you desire, you can override
 the methods in your classes.  However, you should be aware that for each
 of the association modification methods described, there is a private
-method that is preceeded by an underscore that does the actual
+method that is preceded by an underscore that does the actual
 modification.  The public method without the underscore handles caching
 and callbacks, and shouldn't be overridden by the user.
 
@@ -1069,7 +1069,7 @@ option of the first association, it doesn't attempt to merge them.
 In addition to the options hash, the :clone option will copy a block argument
 from the existing situation.  If you want a cloned association to not have the
 same block as the association you are cloning from, specify the block: nil option
-in additon to the :clone option.
+in addition to the :clone option.
 
 ==== :dataset
 

data/doc/code_order.rdoc

@@ -7,7 +7,7 @@ this guide will be specific about which are strictly necessary.
 
 == Require Sequel
 
-This is sort of a no brainer, but you need to require the library
+This is sort of a no-brainer, but you need to require the library
 first.  This is a strict requirement, none of the other code can
 be executed unless the library has been required first. Example:
 
@@ -70,7 +70,7 @@ copied into the subclass when model subclasses are created.  Example:
 == Load Model Classes
 
 After you have established a database connection, and configured your
-global model configration and global plugins, you can load your model
+global model configuration and global plugins, you can load your model
 classes.  It's recommended to have a separate file for each model class,
 unless the model classes are very simple.  Example:
 
@@ -91,6 +91,16 @@ unsafe runtime modification of the configuration:
   model_classes.each(&:freeze)
   DB.freeze
 
+The `subclasses` plugin can be used to keep track of all model classes
+that have been setup in your application. Finalizing their associations
+and freezing them can easily be achieved through the plugin:
+
+  # Register the plugin before setting up the models
+  Sequel::Model.plugin :subclasses
+  # ... setup models
+  # Now finalize associations & freeze models by calling the plugin:
+  Sequel::Model.freeze_descendents
+
 == Disconnect If Using Forking Webserver with Code Preloading
 
 If you are using a forking webserver such as unicorn or passenger, with

data/doc/model_dataset_method_design.rdoc

@@ -4,7 +4,7 @@ How you design your model dataset methods can significantly affect the flexibili
 
 == Flexibility: Use Single Method Per Task
 
-In general, it is recommended that you have a single method per task for maximum flexibilty.  For example, let's say you need to retrieve all albums released in a given year, ordered by number of units sold descending, and only care about the id, name and number of units sold.  One way to do this is in your application code (outside the model), you can
+In general, it is recommended that you have a single method per task for maximum flexibility.  For example, let's say you need to retrieve all albums released in a given year, ordered by number of units sold descending, and only care about the id, name and number of units sold.  One way to do this is in your application code (outside the model), you can
 call the dataset methods directly:
 
   Album.

data/doc/release_notes/5.32.0.txt

@@ -0,0 +1,46 @@
+= New Features
+
+* A fiber_concurrency extension has been added, for using
+  Fiber.current instead of Thread.current when checking out a
+  connection.  This allows separate fibers of the same thread
+  to use separate connections.  In addition to allowing direct use
+  of fibers, this also allows concurrent use of multiple enumerators
+  that use database connections in the same thread.
+
+  When using this extension, you must be careful and ensure that you
+  are not using more concurrent fibers than your connection pool size.
+  Otherwise, all fibers will block while one fiber waits until a
+  connection is available.  It is possible this issue will be
+  addressed when Ruby implements a fiber scheduler (currently
+  being discussed for inclusion in Ruby 3).
+
+* A run_transaction_hooks Database extension has been added,
+  allowing for running the transaction hooks before commit/rollback,
+  which can be helpful for testing the hooks when using transactional
+  testing.
+
+= Other Improvements
+
+* Database#create_table? now works correctly with the :partition_of
+  option on PostgreSQL.
+
+* The timestamp(N) with time zone type is now recognized by the
+  schema parser.
+
+* Singleton methods of the Sequel module have now been moved into a
+  Sequel::SequelMethods module.  This allows you to extend Sequel
+  with a module that overrides the methods and call super to get
+  the default behavior.
+
+* The pg_inet extension no longer defines inet/cidr conversion procs
+  if sequel_pg 1.13.0+ is in use.  This is because sequel_pg 1.13.0+
+  will respect the conversion procs and defining them makes things
+  slower.  sequel_pg 1.13.0+ handles the same conversion by default
+  without needing a conversion proc.
+
+* Method visibility issues in the model, plugin, extension, and adapter
+  code have been fixed.  Most cases fixed were private methods being
+  accidentally made public when they were overridden.
+
+  During this change, Model#_insert_values was changed from public to
+  private, since it was originally intended to be private.

data/doc/testing.rdoc

@@ -162,6 +162,7 @@ SEQUEL_CONNECTION_VALIDATOR :: Use the connection validator extension when runni
 SEQUEL_DUPLICATE_COLUMNS_HANDLER :: Use the duplicate columns handler extension with value given when running the specs
 SEQUEL_ERROR_SQL :: Use the error_sql extension when running the specs
 SEQUEL_INDEX_CACHING :: Use the index_caching extension when running the specs
+SEQUEL_FIBER_CONCURRENCY :: Use the fiber_concurrency extension when running the adapter and integration specs
 SEQUEL_FREEZE_DATABASE :: Freeze the database before running the integration specs
 SEQUEL_IDENTIFIER_MANGLING :: Use the identifier_mangling extension when running the specs
 SEQUEL_INTEGER64 :: Use the integer64 extension when running the adapter or integration specs

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

@@ -171,6 +171,12 @@ module Sequel
         clone(:into => table)
       end
 
+      # Access uses [] for quoting identifiers, and can't handle
+      # ] inside identifiers.
+      def quoted_identifier_append(sql, v)
+        sql << '[' << v.to_s << ']'
+      end
+
       # Access does not support derived column lists.
       def supports_derived_column_lists?
         false
@@ -279,12 +285,6 @@ module Sequel
           literal_append(sql, l)
         end
       end
-
-      # Access uses [] for quoting identifiers, and can't handle
-      # ] inside identifiers.
-      def quoted_identifier_append(sql, v)
-        sql << '[' << v.to_s << ']'
-      end
     end
   end
 end

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

@@ -775,11 +775,6 @@ module Sequel
         end
       end
 
-      # MSSQL does not allow ordering in sub-clauses unless TOP (limit) is specified
-      def aggregate_dataset
-        (options_overlap(Sequel::Dataset::COUNT_FROM_SELF_OPTS) && !options_overlap([:limit])) ? unordered.from_self : super
-      end
-
       # If the dataset using a order without a limit or offset or custom SQL, 
       # remove the order.  Compounds on Microsoft SQL Server have undefined
       # order unless the result is specifically ordered.  Applying the current
@@ -799,6 +794,11 @@ module Sequel
 
       private
 
+      # MSSQL does not allow ordering in sub-clauses unless TOP (limit) is specified
+      def aggregate_dataset
+        (options_overlap(Sequel::Dataset::COUNT_FROM_SELF_OPTS) && !options_overlap([:limit])) ? unordered.from_self : super
+      end
+
       # Allow update and delete for unordered, limited datasets only.
       def check_not_limited!(type)
         return if @opts[:skip_limit_check] && type != :truncate

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

@@ -717,15 +717,6 @@ module Sequel
         SQL::PlaceholderLiteralString.new((opts[:boolean] ? MATCH_AGAINST_BOOLEAN : MATCH_AGAINST), [Array(cols), terms])
       end
 
-      # Transforms :straight to STRAIGHT_JOIN.
-      def join_type_sql(join_type)
-        if join_type == :straight
-          'STRAIGHT_JOIN'
-        else
-          super
-        end
-      end
-      
       # Sets up the insert methods to use INSERT IGNORE.
       # Useful if you have a unique key and want to just skip
       # inserting rows that violate the unique key restriction.
@@ -956,6 +947,15 @@ module Sequel
         end
       end
 
+      # Transforms :straight to STRAIGHT_JOIN.
+      def join_type_sql(join_type)
+        if join_type == :straight
+          'STRAIGHT_JOIN'
+        else
+          super
+        end
+      end
+      
       # MySQL allows a LIMIT in DELETE and UPDATE statements.
       def limit_sql(sql)
         if l = @opts[:limit]

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

@@ -422,22 +422,6 @@ module Sequel
         end
       end
 
-      def select_limit_sql(sql)
-        return unless supports_fetch_next_rows?
-
-        if offset = @opts[:offset]
-          sql << " OFFSET "
-          literal_append(sql, offset)
-          sql << " ROWS"
-        end
-
-        if limit = @opts[:limit]
-          sql << " FETCH NEXT "
-          literal_append(sql, limit)
-          sql << " ROWS ONLY"
-        end
-      end
-
       # Oracle requires recursive CTEs to have column aliases.
       def recursive_cte_requires_column_aliases?
         true
@@ -624,6 +608,22 @@ module Sequel
         :union
       end
 
+      def select_limit_sql(sql)
+        return unless supports_fetch_next_rows?
+
+        if offset = @opts[:offset]
+          sql << " OFFSET "
+          literal_append(sql, offset)
+          sql << " ROWS"
+        end
+
+        if limit = @opts[:limit]
+          sql << " FETCH NEXT "
+          literal_append(sql, limit)
+          sql << " ROWS ONLY"
+        end
+      end
+
       # Use SKIP LOCKED if skipping locked rows.
       def select_lock_sql(sql)
         super

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

@@ -459,6 +459,16 @@ module Sequel
         super
       end
 
+      # Support partitions of tables using the :partition_of option.
+      def create_table?(name, options=OPTS, &block)
+        if options[:partition_of]
+          create_table(name, options.merge!(:if_not_exists=>true), &block)
+          return
+        end
+
+        super
+      end
+
       # Create a trigger in the database.  Arguments:
       # table :: the table on which this trigger operates
       # name :: the name of this trigger
@@ -1896,6 +1906,14 @@ module Sequel
         end
       end
 
+      def to_prepared_statement(type, *a)
+        if type == :insert && !@opts.has_key?(:returning)
+          returning(insert_pk).send(:to_prepared_statement, :insert_pk, *a)
+        else
+          super
+        end
+      end
+
       private
 
       # Format TRUNCATE statement with PostgreSQL specific options.
@@ -2110,14 +2128,6 @@ module Sequel
         true
       end
 
-      def to_prepared_statement(type, *a)
-        if type == :insert && !@opts.has_key?(:returning)
-          returning(insert_pk).send(:to_prepared_statement, :insert_pk, *a)
-        else
-          super
-        end
-      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, '')}

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

@@ -23,15 +23,6 @@ module Sequel
         to_application_timestamp(v.to_s) if v
       end
 
-      # Convert smallint type to boolean if convert_smallint_to_bool is true
-      def schema_column_type(db_type)
-        if convert_smallint_to_bool && db_type =~ /smallint/i
-          :boolean
-        else
-          super
-        end
-      end
-
       def schema_parse_table(table, opts)
         m = output_identifier_meth(opts[:dataset])
         im = input_identifier_meth(opts[:dataset])
@@ -216,6 +207,15 @@ module Sequel
         "ALTER TABLE #{quote_schema_table(name)} RENAME #{quote_schema_table(new_name)}"
       end
 
+      # Convert smallint type to boolean if convert_smallint_to_bool is true
+      def schema_column_type(db_type)
+        if convert_smallint_to_bool && db_type =~ /smallint/i
+          :boolean
+        else
+          super
+        end
+      end
+
       def tables_and_views(type, opts=OPTS)
         m = output_identifier_meth
         metadata_dataset.

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

@@ -14,6 +14,7 @@ module Sequel
         def schema_parse_table(*)
           []
         end
+        singleton_class.send(:private, :schema_parse_table)
       end
     end
     

data/lib/sequel/connection_pool/sharded_threaded.rb

@@ -57,7 +57,7 @@ class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
   # it is yielding all of the connections, which means that until
   # the method's block returns, the pool is locked.
   def all_connections
-    t = Thread.current
+    t = Sequel.current
     sync do
       @allocated.values.each do |threads|
         threads.each do |thread, conn|
@@ -121,7 +121,7 @@ class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
   # connection can be acquired, a Sequel::PoolTimeout is raised.
   def hold(server=:default)
     server = pick_server(server)
-    t = Thread.current
+    t = Sequel.current
     if conn = owned_connection(t, server)
       return yield(conn)
     end

data/lib/sequel/connection_pool/threaded.rb

@@ -83,7 +83,7 @@ class Sequel::ThreadedConnectionPool < Sequel::ConnectionPool
   # is available or the timeout expires.  If the timeout expires before a
   # connection can be acquired, a Sequel::PoolTimeout is raised.
   def hold(server=nil)
-    t = Thread.current
+    t = Sequel.current
     if conn = owned_connection(t)
       return yield(conn)
     end

data/lib/sequel/core.rb

@@ -30,7 +30,15 @@ module Sequel
   @split_symbols = false
   @single_threaded = false
 
-  class << self
+  # Mutex used to protect mutable data structures
+  @data_mutex = Mutex.new
+
+  # Frozen hash used as the default options hash for most options.
+  OPTS = {}.freeze
+
+  SPLIT_SYMBOL_CACHE = {}
+
+  module SequelMethods
     # Sequel converts two digit years in <tt>Date</tt>s and <tt>DateTime</tt>s 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
@@ -63,361 +71,357 @@ module Sequel
     # require for backwards compatibility.
     alias orig_require require
     private :orig_require
-  end
 
-  # Returns true if the passed object could be a specifier of conditions, false otherwise.
-  # Currently, Sequel considers hashes and arrays of two element arrays as
-  # condition specifiers.
-  #
-  #   Sequel.condition_specifier?({}) # => true
-  #   Sequel.condition_specifier?([[1, 2]]) # => true
-  #   Sequel.condition_specifier?([]) # => false
-  #   Sequel.condition_specifier?([1]) # => false
-  #   Sequel.condition_specifier?(1) # => false
-  def self.condition_specifier?(obj)
-    case obj
-    when Hash
-      true
-    when Array
-      !obj.empty? && !obj.is_a?(SQL::ValueList) && obj.all?{|i| i.is_a?(Array) && (i.length == 2)}
-    else
-      false
+    # Returns true if the passed object could be a specifier of conditions, false otherwise.
+    # Currently, Sequel considers hashes and arrays of two element arrays as
+    # condition specifiers.
+    #
+    #   Sequel.condition_specifier?({}) # => true
+    #   Sequel.condition_specifier?([[1, 2]]) # => true
+    #   Sequel.condition_specifier?([]) # => false
+    #   Sequel.condition_specifier?([1]) # => false
+    #   Sequel.condition_specifier?(1) # => false
+    def condition_specifier?(obj)
+      case obj
+      when Hash
+        true
+      when Array
+        !obj.empty? && !obj.is_a?(SQL::ValueList) && obj.all?{|i| i.is_a?(Array) && (i.length == 2)}
+      else
+        false
+      end
     end
-  end
 
-  # Frozen hash used as the default options hash for most options.
-  OPTS = {}.freeze
+    # Creates a new database object based on the supplied connection string
+    # and optional arguments.  The specified scheme determines the database
+    # class used, and the rest of the string specifies the connection options.
+    # For example:
+    #
+    #   DB = Sequel.connect('sqlite:/') # Memory database
+    #   DB = Sequel.connect('sqlite://blog.db') # ./blog.db
+    #   DB = Sequel.connect('sqlite:///blog.db') # /blog.db
+    #   DB = Sequel.connect('postgres://user:password@host:port/database_name')
+    #   DB = Sequel.connect('sqlite:///blog.db', max_connections: 10)
+    #
+    # You can also pass a single options hash:
+    #
+    #   DB = Sequel.connect(adapter: 'sqlite', database: './blog.db')
+    #
+    # If a block is given, it is passed the opened +Database+ object, which is
+    # closed when the block exits.  For example:
+    #
+    #   Sequel.connect('sqlite://blog.db'){|db| puts db[:users].count}  
+    #
+    # If a block is not given, a reference to this database will be held in
+    # <tt>Sequel::DATABASES</tt> until it is removed manually.  This is by
+    # design, and used by <tt>Sequel::Model</tt> to pick the default
+    # database.  It is recommended to pass a block if you do not want the
+    # resulting Database object to remain in memory until the process
+    # terminates, or use the <tt>keep_reference: false</tt> Database option.
+    #
+    # For details, see the {"Connecting to a Database" guide}[rdoc-ref:doc/opening_databases.rdoc].
+    # To set up a primary/replica or sharded database connection, see the {"Primary/Replica Database Configurations and Sharding" guide}[rdoc-ref:doc/sharding.rdoc].
+    def connect(*args, &block)
+      Database.connect(*args, &block)
+    end
 
-  # Creates a new database object based on the supplied connection string
-  # and optional arguments.  The specified scheme determines the database
-  # class used, and the rest of the string specifies the connection options.
-  # For example:
-  #
-  #   DB = Sequel.connect('sqlite:/') # Memory database
-  #   DB = Sequel.connect('sqlite://blog.db') # ./blog.db
-  #   DB = Sequel.connect('sqlite:///blog.db') # /blog.db
-  #   DB = Sequel.connect('postgres://user:password@host:port/database_name')
-  #   DB = Sequel.connect('sqlite:///blog.db', max_connections: 10)
-  #
-  # You can also pass a single options hash:
-  #
-  #   DB = Sequel.connect(adapter: 'sqlite', database: './blog.db')
-  #
-  # If a block is given, it is passed the opened +Database+ object, which is
-  # closed when the block exits.  For example:
-  #
-  #   Sequel.connect('sqlite://blog.db'){|db| puts db[:users].count}  
-  #
-  # If a block is not given, a reference to this database will be held in
-  # <tt>Sequel::DATABASES</tt> until it is removed manually.  This is by
-  # design, and used by <tt>Sequel::Model</tt> to pick the default
-  # database.  It is recommended to pass a block if you do not want the
-  # resulting Database object to remain in memory until the process
-  # terminates, or use the <tt>keep_reference: false</tt> Database option.
-  #
-  # For details, see the {"Connecting to a Database" guide}[rdoc-ref:doc/opening_databases.rdoc].
-  # To set up a primary/replica or sharded database connection, see the {"Primary/Replica Database Configurations and Sharding" guide}[rdoc-ref:doc/sharding.rdoc].
-  def self.connect(*args, &block)
-    Database.connect(*args, &block)
-  end
+    # Assume the core extensions are not loaded by default, if the core_extensions
+    # extension is loaded, this will be overridden.
+    def core_extensions?
+      false
+    end
 
-  # Assume the core extensions are not loaded by default, if the core_extensions
-  # extension is loaded, this will be overridden.
-  def self.core_extensions?
-    false
-  end
+    # Convert the +exception+ to the given class.  The given class should be
+    # <tt>Sequel::Error</tt> or a subclass.  Returns an instance of +klass+ with
+    # the message and backtrace of +exception+.
+    def convert_exception_class(exception, klass)
+      return exception if exception.is_a?(klass)
+      e = klass.new("#{exception.class}: #{exception.message}")
+      e.wrapped_exception = exception
+      e.set_backtrace(exception.backtrace)
+      e
+    end
 
-  # Convert the +exception+ to the given class.  The given class should be
-  # <tt>Sequel::Error</tt> or a subclass.  Returns an instance of +klass+ with
-  # the message and backtrace of +exception+.
-  def self.convert_exception_class(exception, klass)
-    return exception if exception.is_a?(klass)
-    e = klass.new("#{exception.class}: #{exception.message}")
-    e.wrapped_exception = exception
-    e.set_backtrace(exception.backtrace)
-    e
-  end
+    # The current concurrency primitive, Thread.current by default.
+    def current
+      Thread.current
+    end
 
-  # Load all Sequel extensions given.  Extensions are just files that exist under
-  # <tt>sequel/extensions</tt> in the load path, and are just required.  
-  # In some cases, requiring an extension modifies classes directly, and in others,
-  # it just loads a module that you can extend other classes with.  Consult the documentation
-  # for each extension you plan on using for usage.
-  #
-  #   Sequel.extension(:blank)
-  #   Sequel.extension(:core_extensions, :named_timezones)
-  def self.extension(*extensions)
-    extensions.each{|e| orig_require("sequel/extensions/#{e}")}
-  end
-  
-  # The exception classed raised if there is an error parsing JSON.
-  # This can be overridden to use an alternative json implementation.
-  def self.json_parser_error_class
-    JSON::ParserError
-  end
+    # Load all Sequel extensions given.  Extensions are just files that exist under
+    # <tt>sequel/extensions</tt> in the load path, and are just required.  
+    # In some cases, requiring an extension modifies classes directly, and in others,
+    # it just loads a module that you can extend other classes with.  Consult the documentation
+    # for each extension you plan on using for usage.
+    #
+    #   Sequel.extension(:blank)
+    #   Sequel.extension(:core_extensions, :named_timezones)
+    def extension(*extensions)
+      extensions.each{|e| orig_require("sequel/extensions/#{e}")}
+    end
+    
+    # The exception classed raised if there is an error parsing JSON.
+    # This can be overridden to use an alternative json implementation.
+    def json_parser_error_class
+      JSON::ParserError
+    end
 
-  # Convert given object to json and return the result.
-  # This can be overridden to use an alternative json implementation.
-  def self.object_to_json(obj, *args, &block)
-    obj.to_json(*args, &block)
-  end
+    # Convert given object to json and return the result.
+    # This can be overridden to use an alternative json implementation.
+    def object_to_json(obj, *args, &block)
+      obj.to_json(*args, &block)
+    end
 
-  # Parse the string as JSON and return the result.
-  # This can be overridden to use an alternative json implementation.
-  def self.parse_json(json)
-    JSON.parse(json, :create_additions=>false)
-  end
+    # Parse the string as JSON and return the result.
+    # This can be overridden to use an alternative json implementation.
+    def parse_json(json)
+      JSON.parse(json, :create_additions=>false)
+    end
 
-  # Convert each item in the array to the correct type, handling multi-dimensional
-  # arrays.  For each element in the array or subarrays, call the converter,
-  # unless the value is nil.
-  def self.recursive_map(array, converter)
-    array.map do |i|
-      if i.is_a?(Array)
-        recursive_map(i, converter)
-      elsif !i.nil?
-        converter.call(i)
+    # Convert each item in the array to the correct type, handling multi-dimensional
+    # arrays.  For each element in the array or subarrays, call the converter,
+    # unless the value is nil.
+    def recursive_map(array, converter)
+      array.map do |i|
+        if i.is_a?(Array)
+          recursive_map(i, converter)
+        elsif !i.nil?
+          converter.call(i)
+        end
       end
     end
-  end
-
-  # For backwards compatibility only.  require_relative should be used instead.
-  def self.require(files, subdir=nil)
-    # Use Kernel.require_relative to work around JRuby 9.0 bug
-    Array(files).each{|f| Kernel.require_relative "#{"#{subdir}/" if subdir}#{f}"}
-  end
 
-  SPLIT_SYMBOL_CACHE = {}
+    # For backwards compatibility only.  require_relative should be used instead.
+    def require(files, subdir=nil)
+      # Use Kernel.require_relative to work around JRuby 9.0 bug
+      Array(files).each{|f| Kernel.require_relative "#{"#{subdir}/" if subdir}#{f}"}
+    end
 
-  # Splits the symbol into three parts, if symbol splitting is enabled (not the default).
-  # Each part will either be a string or nil. If symbol splitting
-  # is disabled, returns an array with the first and third parts
-  # being nil, and the second part beind a string version of the symbol.
-  #
-  # For columns, these parts are the table, column, and alias.
-  # For tables, these parts are the schema, table, and alias.
-  def self.split_symbol(sym)
-    unless v = Sequel.synchronize{SPLIT_SYMBOL_CACHE[sym]}
-      if split_symbols?
-        v = case s = sym.to_s
-        when /\A((?:(?!__).)+)__((?:(?!___).)+)___(.+)\z/
-          [$1.freeze, $2.freeze, $3.freeze].freeze
-        when /\A((?:(?!___).)+)___(.+)\z/
-          [nil, $1.freeze, $2.freeze].freeze
-        when /\A((?:(?!__).)+)__(.+)\z/
-          [$1.freeze, $2.freeze, nil].freeze
+    # Splits the symbol into three parts, if symbol splitting is enabled (not the default).
+    # Each part will either be a string or nil. If symbol splitting
+    # is disabled, returns an array with the first and third parts
+    # being nil, and the second part beind a string version of the symbol.
+    #
+    # For columns, these parts are the table, column, and alias.
+    # For tables, these parts are the schema, table, and alias.
+    def split_symbol(sym)
+      unless v = Sequel.synchronize{SPLIT_SYMBOL_CACHE[sym]}
+        if split_symbols?
+          v = case s = sym.to_s
+          when /\A((?:(?!__).)+)__((?:(?!___).)+)___(.+)\z/
+            [$1.freeze, $2.freeze, $3.freeze].freeze
+          when /\A((?:(?!___).)+)___(.+)\z/
+            [nil, $1.freeze, $2.freeze].freeze
+          when /\A((?:(?!__).)+)__(.+)\z/
+            [$1.freeze, $2.freeze, nil].freeze
+          else
+            [nil, s.freeze, nil].freeze
+          end
         else
-          [nil, s.freeze, nil].freeze
+          v = [nil,sym.to_s.freeze,nil].freeze
         end
-      else
-        v = [nil,sym.to_s.freeze,nil].freeze
+        Sequel.synchronize{SPLIT_SYMBOL_CACHE[sym] = v}
       end
-      Sequel.synchronize{SPLIT_SYMBOL_CACHE[sym] = v}
+      v
     end
-    v
-  end
-
-  # Setting this to true enables Sequel's historical behavior of splitting
-  # symbols on double or triple underscores:
-  #
-  #   :table__column         # table.column
-  #   :column___alias        # column AS alias
-  #   :table__column___alias # table.column AS alias
-  #
-  # It is only recommended to turn this on for backwards compatibility until
-  # such symbols have been converted to use newer Sequel APIs such as:
-  #
-  #   Sequel[:table][:column]            # table.column
-  #   Sequel[:column].as(:alias)         # column AS alias
-  #   Sequel[:table][:column].as(:alias) # table.column AS alias
-  #
-  # Sequel::Database instances do their own caching of literalized
-  # symbols, and changing this setting does not affect those caches.  It is
-  # recommended that if you want to change this setting, you do so directly
-  # after requiring Sequel, before creating any Sequel::Database instances.
-  #
-  # Disabling symbol splitting will also disable the handling
-  # of double underscores in virtual row methods, causing such methods to
-  # yield regular identifers instead of qualified identifiers:
-  #
-  #   # Sequel.split_symbols = true
-  #   Sequel.expr{table__column}  # table.column
-  #   Sequel.expr{table[:column]} # table.column
-  #
-  #   # Sequel.split_symbols = false
-  #   Sequel.expr{table__column}  # table__column
-  #   Sequel.expr{table[:column]} # table.column
-  def self.split_symbols=(v)
-    Sequel.synchronize{SPLIT_SYMBOL_CACHE.clear}
-    @split_symbols = v
-  end
 
-  # Whether Sequel currently splits symbols into qualified/aliased identifiers.
-  def self.split_symbols?
-    @split_symbols
-  end
+    # Setting this to true enables Sequel's historical behavior of splitting
+    # symbols on double or triple underscores:
+    #
+    #   :table__column         # table.column
+    #   :column___alias        # column AS alias
+    #   :table__column___alias # table.column AS alias
+    #
+    # It is only recommended to turn this on for backwards compatibility until
+    # such symbols have been converted to use newer Sequel APIs such as:
+    #
+    #   Sequel[:table][:column]            # table.column
+    #   Sequel[:column].as(:alias)         # column AS alias
+    #   Sequel[:table][:column].as(:alias) # table.column AS alias
+    #
+    # Sequel::Database instances do their own caching of literalized
+    # symbols, and changing this setting does not affect those caches.  It is
+    # recommended that if you want to change this setting, you do so directly
+    # after requiring Sequel, before creating any Sequel::Database instances.
+    #
+    # Disabling symbol splitting will also disable the handling
+    # of double underscores in virtual row methods, causing such methods to
+    # yield regular identifers instead of qualified identifiers:
+    #
+    #   # Sequel.split_symbols = true
+    #   Sequel.expr{table__column}  # table.column
+    #   Sequel.expr{table[:column]} # table.column
+    #
+    #   # Sequel.split_symbols = false
+    #   Sequel.expr{table__column}  # table__column
+    #   Sequel.expr{table[:column]} # table.column
+    def split_symbols=(v)
+      Sequel.synchronize{SPLIT_SYMBOL_CACHE.clear}
+      @split_symbols = v
+    end
 
-  # Converts the given +string+ into a +Date+ object.
-  #
-  #   Sequel.string_to_date('2010-09-10') # Date.civil(2010, 09, 10)
-  def self.string_to_date(string)
-    begin
-      Date.parse(string, Sequel.convert_two_digit_years)
-    rescue => e
-      raise convert_exception_class(e, InvalidValue)
+    # Whether Sequel currently splits symbols into qualified/aliased identifiers.
+    def split_symbols?
+      @split_symbols
     end
-  end
 
-  # Converts the given +string+ into a +Time+ or +DateTime+ object, depending on the
-  # value of <tt>Sequel.datetime_class</tt>.
-  #
-  #   Sequel.string_to_datetime('2010-09-10 10:20:30') # Time.local(2010, 09, 10, 10, 20, 30)
-  def self.string_to_datetime(string)
-    begin
-      if datetime_class == DateTime
-        DateTime.parse(string, convert_two_digit_years)
-      else
-        datetime_class.parse(string)
+    # Converts the given +string+ into a +Date+ object.
+    #
+    #   Sequel.string_to_date('2010-09-10') # Date.civil(2010, 09, 10)
+    def string_to_date(string)
+      begin
+        Date.parse(string, Sequel.convert_two_digit_years)
+      rescue => e
+        raise convert_exception_class(e, InvalidValue)
       end
-    rescue => e
-      raise convert_exception_class(e, InvalidValue)
     end
-  end
 
-  # Converts the given +string+ into a <tt>Sequel::SQLTime</tt> object.
-  #
-  #   v = Sequel.string_to_time('10:20:30') # Sequel::SQLTime.parse('10:20:30')
-  #   DB.literal(v) # => '10:20:30'
-  def self.string_to_time(string)
-    begin
-      SQLTime.parse(string)
-    rescue => e
-      raise convert_exception_class(e, InvalidValue)
+    # Converts the given +string+ into a +Time+ or +DateTime+ object, depending on the
+    # value of <tt>Sequel.datetime_class</tt>.
+    #
+    #   Sequel.string_to_datetime('2010-09-10 10:20:30') # Time.local(2010, 09, 10, 10, 20, 30)
+    def string_to_datetime(string)
+      begin
+        if datetime_class == DateTime
+          DateTime.parse(string, convert_two_digit_years)
+        else
+          datetime_class.parse(string)
+        end
+      rescue => e
+        raise convert_exception_class(e, InvalidValue)
+      end
     end
-  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.
-  # In general, this should only be used around the minimal possible code
-  # such as Hash#[], Hash#[]=, Hash#delete, Array#<<, and Array#delete.
-  def self.synchronize(&block)
-    @single_threaded ? yield : @data_mutex.synchronize(&block)
-  end
 
-  if RUBY_VERSION >= '2.1'
-    # A timer object that can be passed to Sequel.elapsed_seconds_since
-    # to return the number of seconds elapsed.
-    def self.start_timer
-      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    # Converts the given +string+ into a <tt>Sequel::SQLTime</tt> object.
+    #
+    #   v = Sequel.string_to_time('10:20:30') # Sequel::SQLTime.parse('10:20:30')
+    #   DB.literal(v) # => '10:20:30'
+    def string_to_time(string)
+      begin
+        SQLTime.parse(string)
+      rescue => e
+        raise convert_exception_class(e, InvalidValue)
+      end
     end
-  else
-    # :nocov:
-    def self.start_timer # :nodoc:
-      Time.now
+
+    # 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.
+    # In general, this should only be used around the minimal possible code
+    # such as Hash#[], Hash#[]=, Hash#delete, Array#<<, and Array#delete.
+    def synchronize(&block)
+      @single_threaded ? yield : @data_mutex.synchronize(&block)
     end
-    # :nocov:
-  end
 
-  # The elapsed seconds since the given timer object was created.  The
-  # timer object should have been created via Sequel.start_timer.
-  def self.elapsed_seconds_since(timer)
-    start_timer - timer
-  end
+    if RUBY_VERSION >= '2.1'
+      # A timer object that can be passed to Sequel.elapsed_seconds_since
+      # to return the number of seconds elapsed.
+      def start_timer
+        Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+    else
+      # :nocov:
+      def start_timer # :nodoc:
+        Time.now
+      end
+      # :nocov:
+    end
 
-  # Uses a transaction on all given databases with the given options. This:
-  #
-  #   Sequel.transaction([DB1, DB2, DB3]){}
-  #
-  # is equivalent to:
-  #
-  #   DB1.transaction do
-  #     DB2.transaction do
-  #       DB3.transaction do
-  #       end
-  #     end
-  #   end
-  #
-  # except that if Sequel::Rollback is raised by the block, the transaction is
-  # rolled back on all databases instead of just the last one.
-  #
-  # Note that this method cannot guarantee that all databases will commit or
-  # rollback.  For example, if DB3 commits but attempting to commit on DB2
-  # fails (maybe because foreign key checks are deferred), there is no way
-  # to uncommit the changes on DB3.  For that kind of support, you need to
-  # have two-phase commit/prepared transactions (which Sequel supports on
-  # some databases).
-  def self.transaction(dbs, opts=OPTS, &block)
-    unless opts[:rollback]
-      rescue_rollback = true
-      opts = Hash[opts].merge!(:rollback=>:reraise)
+    # The elapsed seconds since the given timer object was created.  The
+    # timer object should have been created via Sequel.start_timer.
+    def elapsed_seconds_since(timer)
+      start_timer - timer
     end
-    pr = dbs.reverse.inject(block){|bl, db| proc{db.transaction(opts, &bl)}}
-    if rescue_rollback
-      begin
+
+    # Uses a transaction on all given databases with the given options. This:
+    #
+    #   Sequel.transaction([DB1, DB2, DB3]){}
+    #
+    # is equivalent to:
+    #
+    #   DB1.transaction do
+    #     DB2.transaction do
+    #       DB3.transaction do
+    #       end
+    #     end
+    #   end
+    #
+    # except that if Sequel::Rollback is raised by the block, the transaction is
+    # rolled back on all databases instead of just the last one.
+    #
+    # Note that this method cannot guarantee that all databases will commit or
+    # rollback.  For example, if DB3 commits but attempting to commit on DB2
+    # fails (maybe because foreign key checks are deferred), there is no way
+    # to uncommit the changes on DB3.  For that kind of support, you need to
+    # have two-phase commit/prepared transactions (which Sequel supports on
+    # some databases).
+    def transaction(dbs, opts=OPTS, &block)
+      unless opts[:rollback]
+        rescue_rollback = true
+        opts = Hash[opts].merge!(:rollback=>:reraise)
+      end
+      pr = dbs.reverse.inject(block){|bl, db| proc{db.transaction(opts, &bl)}}
+      if rescue_rollback
+        begin
+          pr.call
+        rescue Sequel::Rollback
+          nil
+        end
+      else
         pr.call
-      rescue Sequel::Rollback
-        nil
       end
-    else
-      pr.call
     end
-  end
 
-  # If the supplied block takes a single argument,
-  # yield an <tt>SQL::VirtualRow</tt> instance to the block
-  # argument.  Otherwise, evaluate the block in the context of a
-  # <tt>SQL::VirtualRow</tt> instance.
-  #
-  #   Sequel.virtual_row{a} # Sequel::SQL::Identifier.new(:a)
-  #   Sequel.virtual_row{|o| o.a} # Sequel::SQL::Function.new(:a)
-  def self.virtual_row(&block)
-    vr = VIRTUAL_ROW
-    case block.arity
-    when -1, 0
-      vr.instance_exec(&block)
-    else
-      block.call(vr)
-    end  
-  end
+    # If the supplied block takes a single argument,
+    # yield an <tt>SQL::VirtualRow</tt> instance to the block
+    # argument.  Otherwise, evaluate the block in the context of a
+    # <tt>SQL::VirtualRow</tt> instance.
+    #
+    #   Sequel.virtual_row{a} # Sequel::SQL::Identifier.new(:a)
+    #   Sequel.virtual_row{|o| o.a} # Sequel::SQL::Function.new(:a)
+    def virtual_row(&block)
+      vr = VIRTUAL_ROW
+      case block.arity
+      when -1, 0
+        vr.instance_exec(&block)
+      else
+        block.call(vr)
+      end  
+    end
 
-  ### Private Class Methods ###
+    private
 
-  # Helper method that the database adapter class methods that are added to Sequel via
-  # metaprogramming use to parse arguments.
-  def self.adapter_method(adapter, *args, &block)
-    options = args.last.is_a?(Hash) ? args.pop : OPTS
-    opts = {:adapter => adapter.to_sym}
-    opts[:database] = args.shift if args.first.is_a?(String)
-    if args.any?
-      raise ::Sequel::Error, "Wrong format of arguments, either use (), (String), (Hash), or (String, Hash)"
-    end
+    # Helper method that the database adapter class methods that are added to Sequel via
+    # metaprogramming use to parse arguments.
+    def adapter_method(adapter, *args, &block)
+      options = args.last.is_a?(Hash) ? args.pop : OPTS
+      opts = {:adapter => adapter.to_sym}
+      opts[:database] = args.shift if args.first.is_a?(String)
+      if args.any?
+        raise ::Sequel::Error, "Wrong format of arguments, either use (), (String), (Hash), or (String, Hash)"
+      end
 
-    connect(opts.merge(options), &block)
-  end
+      connect(opts.merge(options), &block)
+    end
 
-  # Method that adds a database adapter class method to Sequel that calls
-  # Sequel.adapter_method.
-  def self.def_adapter_method(*adapters) # :nodoc:
-    adapters.each do |adapter|
-      define_singleton_method(adapter){|*args, &block| adapter_method(adapter, *args, &block)}
+    # Method that adds a database adapter class method to Sequel that calls
+    # Sequel.adapter_method.
+    def def_adapter_method(*adapters) # :nodoc:
+      adapters.each do |adapter|
+        define_singleton_method(adapter){|*args, &block| adapter_method(adapter, *args, &block)}
+      end
     end
   end
-
-  private_class_method :adapter_method, :def_adapter_method
-
-  require_relative "deprecated"
-  require_relative "sql"
-  require_relative "connection_pool"
-  require_relative "exceptions"
-  require_relative "dataset"
-  require_relative "database"
-  require_relative "timezones"
-  require_relative "ast_transformer"
-  require_relative "version"
+  extend SequelMethods
+
+    require_relative "deprecated"
+    require_relative "sql"
+    require_relative "connection_pool"
+    require_relative "exceptions"
+    require_relative "dataset"
+    require_relative "database"
+    require_relative "timezones"
+    require_relative "ast_transformer"
+    require_relative "version"
 
   class << self
     # Allow nicer syntax for creating Sequel expressions: