sequel 3.35.0 → 3.36.0

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

@@ -21,13 +21,10 @@ module Sequel
           db_type == 'tinyint(1)' ? :boolean : super
         end
       
-        # By default, MySQL 'where id is null' selects the last inserted id.
-        # Turn that off unless explicitly enabled.
+        # Apply the connectiong setting SQLs for every new connection.
         def setup_connection(conn)
+          mysql_connection_setting_sqls.each{|sql| log_yield(sql){conn.execute(sql)}}
           super
-          sql = "SET SQL_AUTO_IS_NULL=0"
-          log_yield(sql){conn.execute(sql)} unless opts[:auto_is_null]
-          conn
         end
       end
       

data/lib/sequel/adapters/tinytds.rb

@@ -7,8 +7,7 @@ module Sequel
       include Sequel::MSSQL::DatabaseMethods
       set_adapter_scheme :tinytds
       
-      # Transfer the :host and :user options to the
-      # :dataserver and :username options.
+      # Transfer the :user option to the :username option.
       def connect(server)
         opts = server_opts(server)
         opts[:username] = opts[:user]

data/lib/sequel/connection_pool/sharded_threaded.rb

@@ -221,7 +221,11 @@ class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
     if @connections_to_remove.include?(conn)
       remove(thread, conn, server)
     else
-      available_connections(server) << allocated(server).delete(thread)
+      if @queue
+        available_connections(server).unshift(allocated(server).delete(thread))
+      else
+        available_connections(server) << allocated(server).delete(thread)
+      end
     end
   end
 

data/lib/sequel/connection_pool/threaded.rb

@@ -13,6 +13,9 @@ class Sequel::ThreadedConnectionPool < Sequel::ConnectionPool
   attr_reader :allocated
 
   # The following additional options are respected:
+  # * :connection_handling - Set how to handle available connections.  By default,
+  #   uses a a stack for performance.  Can be set to :queue to use a queue, which reduces
+  #   the chances of connections becoming stale.
   # * :max_connections - The maximum number of connections the connection pool
   #   will open (default 4)
   # * :pool_sleep_time - The amount of time to sleep before attempting to acquire
@@ -24,6 +27,7 @@ class Sequel::ThreadedConnectionPool < Sequel::ConnectionPool
     @max_size = Integer(opts[:max_connections] || 4)
     raise(Sequel::Error, ':max_connections must be positive') if @max_size < 1
     @mutex = Mutex.new  
+    @queue = opts[:connection_handling] == :queue
     @available_connections = []
     @allocated = {}
     @timeout = Integer(opts[:pool_timeout] || 5)
@@ -153,7 +157,11 @@ class Sequel::ThreadedConnectionPool < Sequel::ConnectionPool
   # Releases the connection assigned to the supplied thread back to the pool.
   # The calling code should already have the mutex before calling this.
   def release(thread)
-    @available_connections << @allocated.delete(thread)
+    if @queue
+      @available_connections.unshift(@allocated.delete(thread))
+    else
+      @available_connections << @allocated.delete(thread)
+    end
   end
 
   # Yield to the block while inside the mutex. The calling code should NOT

data/lib/sequel/database/dataset_defaults.rb

@@ -50,7 +50,9 @@ module Sequel
     # an optional options hash.
     attr_reader :dataset_class
 
-    # The default schema to use, generally should be nil.
+    # The default schema to use, generally should be nil.  This sets
+    # the default schema used for some schema modification and
+    # introspection queries, but does not effect most dataset code.
     attr_accessor :default_schema
 
     # If the database has any dataset modules associated with it,

data/lib/sequel/database/misc.rb

@@ -26,7 +26,7 @@ module Sequel
     # options hash.
     #
     # Accepts the following options:
-    # :default_schema :: The default schema to use, should generally be nil
+    # :default_schema :: The default schema to use, see #default_schema.
     # :disconnection_proc :: A proc used to disconnect the connection
     # :identifier_input_method :: A string method symbol to call on identifiers going into the database
     # :identifier_output_method :: A string method symbol to call on identifiers coming from the database
@@ -114,6 +114,12 @@ module Sequel
       Sequel.convert_output_timestamp(v, timezone)
     end
 
+    # Whether the database uses a global namespace for the index.  If
+    # false, the indexes are going to be namespaced per table.
+    def global_index_namespace?
+      true
+    end
+
     # Return true if already in a transaction given the options,
     # false otherwise.  Respects the :server option for selecting
     # a shard.

data/lib/sequel/database/query.rb

@@ -55,8 +55,8 @@ module Sequel
     #
     #   DB[:items].filter(:id=>1).prepare(:first, :sa)
     #   DB.call(:sa) # SELECT * FROM items WHERE id = 1
-    def call(ps_name, hash={})
-      prepared_statement(ps_name).call(hash)
+    def call(ps_name, hash={}, &block)
+      prepared_statement(ps_name).call(hash, &block)
     end
     
     # Executes the given SQL on the database. This method should be overridden in descendants.
@@ -232,7 +232,7 @@ module Sequel
     # either all statements are successful or none of the statements are
     # successful.  Note that MySQL MyISAM tabels do not support transactions.
     #
-    # The following options are respected:
+    # The following general options are respected:
     #
     # :isolation :: The transaction isolation level to use for this transaction,
     #               should be :uncommitted, :committed, :repeatable, or :serializable,
@@ -249,6 +249,14 @@ module Sequel
     #               only respected if the database/adapter supports savepoints.  By
     #               default Sequel will reuse an existing transaction, so if you want to
     #               use a savepoint you must use this option.
+    #
+    # PostgreSQL specific options:
+    #
+    # :deferrable :: (9.1+) If present, set to DEFERRABLE if true or NOT DEFERRABLE if false.
+    # :read_only :: If present, set to READ ONLY if true or READ WRITE if false.
+    # :synchronous :: if non-nil, set synchronous_commit
+    #                 appropriately.  Valid values true, :on, false, :off, :local (9.1+),
+    #                 and :remote_write (9.2+).
     def transaction(opts={}, &block)
       synchronize(opts[:server]) do |conn|
         return yield(conn) if already_in_transaction?(conn, opts)

data/lib/sequel/database/schema_generator.rb

@@ -98,14 +98,8 @@ module Sequel
       #               (:restrict, :cascade, :set_null, :set_default, :no_action).
       # :primary_key :: Make the column as a single primary key column.  This should only
       #                 be used if you have a single, nonautoincrementing primary key column.
-      # :size :: The size of the column, generally used with string
-      #          columns to specify the maximum number of characters the column will hold.
-      #          An array of two integers can be provided to set the size and the
-      #          precision, respectively, of decimal columns.
       # :unique :: Mark the column as unique, generally has the same effect as
       #            creating a unique index on the column.
-      # :unsigned :: Make the column type unsigned, only useful for integer
-      #              columns.
       def column(name, type, opts = {})
         columns << {:name => name, :type => type}.merge(opts)
         if index_opts = opts[:index]
@@ -151,6 +145,12 @@ module Sequel
       end
 
       # Add a full text index on the given columns to the DDL.
+      #
+      # PostgreSQL specific options:
+      # :language :: Set a language to use for the index (default: simple).
+      #
+      # Microsoft SQL Server specific options:
+      # :key_index :: The KEY INDEX to use for the full text index.
       def full_text_index(columns, opts = {})
         index(columns, opts.merge(:type => :full_text))
       end
@@ -161,12 +161,26 @@ module Sequel
       end
       
       # Add an index on the given column(s) with the given options to the DDL.
-      # The available options are:
+      # General options:
       #
+      # :name :: The name to use for the index. If not given, a default name
+      #          based on the table and columns is used.
       # :type :: The type of index to use (only supported by some databases)
       # :unique :: Make the index unique, so duplicate values are not allowed.
       # :where :: Create a partial index (only supported by some databases)
       #
+      # PostgreSQL specific options:
+      #
+      # :concurrently :: Create the index concurrently, so it doesn't block
+      #                  operations on the table while the index is being
+      #                  built.
+      # :op_class :: Use a specific operator class in the index.
+      #
+      # Microsoft SQL Server specific options:
+      #
+      # :include :: Include additional column values in the index, without
+      #             actually indexing on those values.
+      #
       #   index :name
       #   # CREATE INDEX table_name_index ON table (name)
       #
@@ -345,7 +359,10 @@ module Sequel
         @operations << {:op => :drop_column, :name => name}.merge(opts)
       end
       
-      # Remove a constraint from the DDL for the table.
+      # Remove a constraint from the DDL for the table. MySQL/SQLite specific options:
+      #
+      # :type :: Set the type of constraint to drop, either :primary_key, :foreign_key,
+      #          or :unique.
       #
       #   drop_constraint(:unique_name) # DROP CONSTRAINT unique_name
       #   drop_constraint(:unique_name, :cascade=>true) # DROP CONSTRAINT unique_name CASCADE
@@ -353,7 +370,17 @@ module Sequel
         @operations << {:op => :drop_constraint, :name => name}.merge(opts)
       end
       
-      # Remove an index from the DDL for the table.
+      # Remove an index from the DDL for the table. General options:
+      #
+      # :name :: The name of the index to drop.  If not given, uses the same name
+      #          that would be used by add_index with the same columns.
+      #
+      # PostgreSQL specific options:
+      #
+      # :cascade :: Cascade the index drop to dependent objects.
+      # :concurrently :: Drop the index using CONCURRENTLY, which doesn't block
+      #                  operations on the table.  Supported in PostgreSQL 9.2+.
+      # :if_exists :: Only drop the index if it already exists.
       #
       #   drop_index(:artist_id) # DROP INDEX table_artist_id_index
       #   drop_index([:a, :b]) # DROP INDEX table_a_b_index
@@ -379,6 +406,10 @@ module Sequel
       # Modify a column's type in the DDL for the table.
       #
       #   set_column_type(:artist_name, 'char(10)') # ALTER COLUMN artist_name TYPE char(10)
+      #
+      # PostgreSQL specific options:
+      #
+      # :using :: Add a USING clause that specifies how to convert existing values to new values.
       def set_column_type(name, type, opts={})
         @operations << {:op => :set_column_type, :name => name, :type => type}.merge(opts)
       end

data/lib/sequel/database/schema_methods.rb

@@ -131,13 +131,18 @@ module Sequel
     #     index :title
     #   end
     #
-    # Options:
+    # General options:
     # :as :: Create the table using the value, which should be either a
     #        dataset or a literal SQL string.  If this option is used,
     #        a block should not be given to the method.
     # :ignore_index_errors :: Ignore any errors when creating indexes.
     # :temp :: Create the table as a temporary table.
     #
+    # MySQL specific options:
+    # :charset :: The character set to use for the table.
+    # :collate :: The collation to use for the table.
+    # :engine :: The table engine to use for the table.
+    #
     # See <tt>Schema::Generator</tt> and the {"Schema Modification" guide}[link:files/doc/schema_modification_rdoc.html].
     def create_table(name, options={}, &block)
       remove_cached_schema(name)

data/lib/sequel/dataset/actions.rb

@@ -204,12 +204,12 @@ module Sequel
     #
     #   ds.get{sum(id)} # SELECT sum(id) FROM table LIMIT 1
     #   # => 6
-    def get(column=nil, &block)
-      if column
-        raise(Error, ARG_BLOCK_ERROR_MSG) if block
-        select(column).single_value
-      else
+    def get(column=(no_arg=true; nil), &block)
+      if block
+        raise(Error, ARG_BLOCK_ERROR_MSG) unless no_arg
         select(&block).single_value
+      else
+        select(column).single_value
       end
     end
     

data/lib/sequel/dataset/prepared_statements.rb

@@ -80,7 +80,7 @@ module Sequel
       # the type of the statement and the prepared_modify_values.
       def prepared_sql
         case @prepared_type
-        when :select, :all
+        when :select, :all, :each
           # Most common scenario, so listed first.
           select_sql
         when :first
@@ -131,6 +131,8 @@ module Sequel
         when :select, :all
           # Most common scenario, so listed first
           all(&block)
+        when :each
+          each(&block)
         when :insert_select
           with_sql(prepared_sql).first
         when :first

data/lib/sequel/dataset/query.rb

@@ -164,7 +164,7 @@ module Sequel
     #   DB[:items].filter('price < ?', 100)
     #   # SELECT * FROM items WHERE price < 100
     #
-    #   DB[:items].filter([[:id, (1,2,3)], [:id, 0..10]])
+    #   DB[:items].filter([[:id, [1,2,3]], [:id, 0..10]])
     #   # SELECT * FROM items WHERE ((id IN (1, 2, 3)) AND ((id >= 0) AND (id <= 10)))
     #
     #   DB[:items].filter('price < 100')

data/lib/sequel/extensions/migration.rb

@@ -340,11 +340,28 @@ module Sequel
     class Error < Sequel::Error
     end
 
+    # Exception class raised when Migrator.check_current signals that it is
+    # not current.
+    class NotCurrentError < Error
+    end
+
     # Wrapper for +run+, maintaining backwards API compatibility
     def self.apply(db, directory, target = nil, current = nil)
       run(db, directory, :target => target, :current => current)
     end
 
+    # Raise a NotCurrentError unless the migrator is current, takes the same
+    # arguments as #run.
+    def self.check_current(*args)
+      raise(NotCurrentError, 'migrator is not current') unless is_current?(*args)
+    end
+
+    # Return whether the migrator is current (i.e. it does not need to make
+    # any changes).  Takes the same arguments as #run.
+    def self.is_current?(db, directory, opts={})
+      migrator_class(directory).new(db, directory, opts).is_current?
+    end
+
     # Migrates the supplied database using the migration files in the the specified directory. Options:
     # * :column :: The column in the :table argument storing the migration version (default: :version).
     # * :current :: The current version of the database.  If not given, it is retrieved from the database
@@ -484,6 +501,11 @@ module Sequel
       @migrations = get_migrations
     end
 
+    # The integer migrator is current if the current version is the same as the target version.
+    def is_current?
+      current_migration_version == target
+    end
+    
     # Apply all migrations on the database
     def run
       migrations.zip(version_numbers).each do |m, v|
@@ -601,6 +623,12 @@ module Sequel
       @migration_tuples = get_migration_tuples
     end
 
+    # The timestamp migrator is current if there are no migrations to apply
+    # in either direction.
+    def is_current?
+      migration_tuples.empty?
+    end
+    
     # Apply all migration tuples on the database
     def run
       migration_tuples.each do |m, f, direction|

data/lib/sequel/extensions/pg_auto_parameterize.rb

@@ -98,15 +98,6 @@ module Sequel
           end
           super
         end
-        
-        # If the sql string has an embedded parameter array,
-        # extract the arguments from that.
-        def execute_insert(sql, opts={})
-          if sql.is_a?(StringWithArray) && (args = sql.args)
-            opts = opts.merge(:arguments=>args)
-          end
-          super
-        end
       end
 
       module DatasetMethods

data/lib/sequel/extensions/pg_inet.rb

@@ -0,0 +1,89 @@
+# The pg_inet extension adds support for Sequel to handle
+# PostgreSQL's inet and cidr types using ruby's IPAddr class.
+#
+# This extension integrates with Sequel's native postgres adapter, so
+# that when inet/cidr fields are retrieved, they are returned as
+# IPAddr instances
+#
+# After loading the extension, you should extend your dataset
+# with a module so that it correctly handles the inet/cidr type:
+#
+#   DB.extend Sequel::Postgres::InetDatabaseMethods
+#
+# If you are not using the native postgres adapter, you probably
+# also want to use the typecast_on_load plugin in the model, and
+# set it to typecast the inet/cidr column(s) on load.
+#
+# This extension does not add special support for the macaddr
+# type.  Ruby doesn't have a stdlib class that represents mac
+# addresses, so these will still be returned as strings.
+
+require 'ipaddr'
+
+module Sequel
+  module Postgres
+    # Methods enabling Database object integration with the inet/cidr types.
+    module InetDatabaseMethods
+
+      # Reset the conversion procs when extending the Database object, so
+      # it will pick up the inet/cidr convertor.  Also, extend the datasets
+      # with support for literalizing the IPAddr types.
+      def self.extended(db)
+        db.reset_conversion_procs if db.respond_to?(:reset_conversion_procs)
+        db.extend_datasets(InetDatasetMethods)
+      end
+
+      # Convert an IPAddr arg to a string.  Probably not necessary, but done
+      # for safety.
+      def bound_variable_arg(arg, conn)
+        case arg
+        when IPAddr
+          "#{arg.to_s}/#{arg.instance_variable_get(:@mask_addr).to_s(2).count('1')}"
+        else
+          super
+        end
+      end
+
+      # Make the column type detection recognize the inet and cidr types.
+      def schema_column_type(db_type)
+        case db_type
+        when 'inet', 'cidr'
+          :ipaddr
+        else
+          super
+        end
+      end
+
+      private
+
+      # Typecast the given value to an IPAddr object.
+      def typecast_value_ipaddr(value)
+        case value
+        when IPAddr
+          value
+        when String
+          IPAddr.new(value)
+        else
+          raise Sequel::InvalidValue, "invalid value for inet/cidr: #{value.inspect}"
+        end
+      end
+    end
+
+    module InetDatasetMethods
+      private
+
+      # Convert IPAddr value to a string and append a literal version
+      # of the string to the sql.
+      def literal_other_append(sql, value)
+        if value.is_a?(IPAddr)
+          literal_string_append(sql, "#{value.to_s}/#{value.instance_variable_get(:@mask_addr).to_s(2).count('1')}")
+        else
+          super
+        end
+      end
+    end
+
+    PG_TYPES = {} unless defined?(PG_TYPES)
+    PG_TYPES[869] = PG_TYPES[650] = IPAddr.method(:new)
+  end
+end