sequel 3.2.0 → 3.3.0

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

@@ -91,12 +91,13 @@ module Sequel
         when :rename_column, :set_column_type, :set_column_null, :set_column_default
           o = op[:op]
           opts = schema(table).find{|x| x.first == op[:name]}
-          old_opts = opts ? opts.last : {}
-          name = o == :rename_column ? op[:new_name] : op[:name]
-          type = o == :set_column_type ? op[:type] : old_opts[:db_type]
-          null = o == :set_column_null ? op[:null] : old_opts[:allow_null]
-          default = o == :set_column_default ? op[:default] : old_opts[:ruby_default]
-          "ALTER TABLE #{quote_schema_table(table)} CHANGE COLUMN #{quote_identifier(op[:name])} #{column_definition_sql(op.merge(:name=>name, :type=>type, :null=>null, :default=>default))}"
+          opts = opts ? opts.last.dup : {}
+          opts[:name] = o == :rename_column ? op[:new_name] : op[:name]
+          opts[:type] = o == :set_column_type ? op[:type] : opts[:db_type]
+          opts[:null] = o == :set_column_null ? op[:null] : opts[:allow_null]
+          opts[:default] = o == :set_column_default ? op[:default] : opts[:ruby_default]
+          opts.delete(:default) if opts[:default] == nil
+          "ALTER TABLE #{quote_schema_table(table)} CHANGE COLUMN #{quote_identifier(op[:name])} #{column_definition_sql(opts)}"
         when :drop_index
           "#{drop_index_sql(table, op)} ON #{quote_schema_table(table)}"
         else
@@ -187,10 +188,9 @@ module Sequel
         column[:only_time] ? :time : :datetime
       end
 
-      # MySQL doesn't have a true boolean class, so it uses tinyint
-      # MySQL doesn't have a true boolean class, so it uses tinyint
+      # MySQL doesn't have a true boolean class, so it uses tinyint(1)
       def type_literal_generic_trueclass(column)
-        :tinyint
+        :'tinyint(1)'
       end
     end
   

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

@@ -107,48 +107,26 @@ module Sequel
       # the column inside of a transaction.
       def alter_table_sql(table, op)
         case op[:op]
-        when :add_column, :add_index, :drop_index
+        when :add_index, :drop_index
           super
+        when :add_column
+          if op[:unique] || op[:primary_key]
+            duplicate_table(table){|columns| columns.push(op)}
+          else
+            super
+          end
         when :drop_column
-          qt = quote_schema_table(table)
-          bt = quote_identifier(backup_table_name(qt.gsub('`', '')))
-          columns_str = dataset.send(:identifier_list, columns_for(table, :except => op[:name]))
-          defined_columns_str = column_list_sql(defined_columns_for(table, :except => op[:name]))
-          ["CREATE TEMPORARY TABLE #{bt}(#{defined_columns_str})",
-           "INSERT INTO #{bt} SELECT #{columns_str} FROM #{qt}",
-           "DROP TABLE #{qt}",
-           "CREATE TABLE #{qt}(#{defined_columns_str})",
-           "INSERT INTO #{qt} SELECT #{columns_str} FROM #{bt}",
-           "DROP TABLE #{bt}"]
+          ocp = lambda{|oc| oc.delete_if{|c| c.to_s == op[:name].to_s}}
+          duplicate_table(table, :old_columns_proc=>ocp){|columns| columns.delete_if{|s| s[:name].to_s == op[:name].to_s}}
         when :rename_column
-          qt = quote_schema_table(table)
-          bt = quote_identifier(backup_table_name(qt.gsub('`', '')))
-          old_columns = dataset.send(:identifier_list, columns_for(table))
-          new_columns_arr = columns_for(table)
-
-          # Replace the old column in place. This is extremely important.
-          new_columns_arr[new_columns_arr.index(op[:name])] = op[:new_name]
-          
-          new_columns = dataset.send(:identifier_list, new_columns_arr)
-          
-          def_old_columns = column_list_sql(defined_columns_for(table))
-
-          def_new_columns_arr = defined_columns_for(table).map do |c|
-            c[:name] = op[:new_name].to_s if c[:name] == op[:name].to_s
-            c
-          end
-          
-          def_new_columns = column_list_sql(def_new_columns_arr)
-
-          [
-           "CREATE TEMPORARY TABLE #{bt}(#{def_old_columns})",
-           "INSERT INTO #{bt}(#{old_columns}) SELECT #{old_columns} FROM #{qt}",
-           "DROP TABLE #{qt}",
-           "CREATE TABLE #{qt}(#{def_new_columns})",
-           "INSERT INTO #{qt}(#{new_columns}) SELECT #{old_columns} FROM #{bt}",
-           "DROP TABLE #{bt}"
-          ]
-
+          ncp = lambda{|nc| nc.map!{|c| c.to_s == op[:name].to_s ? op[:new_name] : c}}
+          duplicate_table(table, :new_columns_proc=>ncp){|columns| columns.each{|s| s[:name] = op[:new_name] if s[:name].to_s == op[:name].to_s}}
+        when :set_column_default
+          duplicate_table(table){|columns| columns.each{|s| s[:default] = op[:default] if s[:name].to_s == op[:name].to_s}}
+        when :set_column_null
+          duplicate_table(table){|columns| columns.each{|s| s[:null] = op[:null] if s[:name].to_s == op[:name].to_s}}
+        when :set_column_type
+          duplicate_table(table){|columns| columns.each{|s| s[:type] = op[:type] if s[:name].to_s == op[:name].to_s}}
         else
           raise Error, "Unsupported ALTER TABLE operation"
         end
@@ -156,19 +134,13 @@ module Sequel
       
       # The array of column symbols in the table, except for ones given in opts[:except]
       def backup_table_name(table, opts={})
+        table = table.gsub('`', '')
         (opts[:times]||1000).times do |i|
           table_name = "#{table}_backup#{i}"
           return table_name unless table_exists?(table_name)
         end
       end
 
-      # The array of column symbols in the table, except for ones given in opts[:except]
-      def columns_for(table, opts={})
-        cols = schema_parse_table(table, {}).map{|c| c[0]}
-        cols = cols - Array(opts[:except])
-        cols
-      end
-
       # Allow use without a generator, needed for the alter table hackery that Sequel allows.
       def column_list_sql(generator)
         generator.is_a?(Schema::Generator) ? super : generator.map{|c| column_definition_sql(c)}.join(', ')
@@ -177,7 +149,10 @@ module Sequel
       # The array of column schema hashes, except for the ones given in opts[:except]
       def defined_columns_for(table, opts={})
         cols = parse_pragma(table, {})
-        cols.each{|c| c[:default] = LiteralString.new(c[:default]) if c[:default]}
+        cols.each do |c|
+          c[:default] = LiteralString.new(c[:default]) if c[:default]
+          c[:type] = c[:db_type]
+        end
         if opts[:except]
           nono= Array(opts[:except]).compact.map{|n| n.to_s}
           cols.reject!{|c| nono.include? c[:name] }
@@ -185,6 +160,29 @@ module Sequel
         cols
       end
       
+      # Duplicate an existing table by creating a new table, copying all records
+      # from the existing table into the new table, deleting the existing table
+      # and renaming the new table to the existing table's name.
+      def duplicate_table(table, opts={})
+        def_columns = defined_columns_for(table)
+        old_columns = def_columns.map{|c| c[:name]}
+        opts[:old_columns_proc].call(old_columns) if opts[:old_columns_proc]
+
+        yield def_columns if block_given?
+        def_columns_str = column_list_sql(def_columns)
+        new_columns = old_columns.dup
+        opts[:new_columns_proc].call(new_columns) if opts[:new_columns_proc]
+
+        qt = quote_schema_table(table)
+        bt = quote_identifier(backup_table_name(qt))
+        [
+           "CREATE TABLE #{bt}(#{def_columns_str})",
+           "INSERT INTO #{bt}(#{dataset.send(:identifier_list, new_columns)}) SELECT #{dataset.send(:identifier_list, old_columns)} FROM #{qt}",
+           "DROP TABLE #{qt}",
+           "ALTER TABLE #{bt} RENAME TO #{qt}"
+        ]
+      end
+
       # SQLite folds unquoted identifiers to lowercase, so it shouldn't need to upcase identifiers on input.
       def identifier_input_method_default
         nil

data/lib/sequel/connection_pool.rb

@@ -95,16 +95,19 @@ class Sequel::ConnectionPool
   def hold(server=:default)
     begin
       t = Thread.current
-      time = Time.new
-      timeout = time + @timeout
-      sleep_time = @sleep_time
       if conn = owned_connection(t, server)
         return yield(conn)
       end
       begin
-        until conn = acquire(t, server)
-          raise(::Sequel::PoolTimeout) if Time.new > timeout
+        unless conn = acquire(t, server)
+          time = Time.new
+          timeout = time + @timeout
+          sleep_time = @sleep_time
           sleep sleep_time
+          until conn = acquire(t, server)
+            raise(::Sequel::PoolTimeout) if Time.new > timeout
+            sleep sleep_time
+          end
         end
         yield conn
       rescue Sequel::DatabaseDisconnectError => dde

data/lib/sequel/core.rb

@@ -15,12 +15,7 @@
 # object, which is closed (disconnected) when the block exits, just
 # like a block passed to connect.  For example:
 #
-#   Sequel.sqlite('blog.db'){|db| puts db[:users].count}  
-#
-# 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.sqlite('blog.db'){|db| puts db[:users].count} 
 #
 # 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
@@ -37,13 +32,12 @@
 # You can set the SEQUEL_NO_CORE_EXTENSIONS constant or environment variable to have
 # Sequel not extend the core classes.
 module Sequel
-  @convert_tinyint_to_bool = true
   @convert_two_digit_years = true
   @datetime_class = Time
   @virtual_row_instance_eval = true
   
   class << self
-    attr_accessor :convert_tinyint_to_bool, :convert_two_digit_years, :datetime_class, :virtual_row_instance_eval
+    attr_accessor :convert_two_digit_years, :datetime_class, :virtual_row_instance_eval
   end
 
   # Returns true if the passed object could be a specifier of conditions, false otherwise.

data/lib/sequel/database.rb

@@ -137,9 +137,10 @@ module Sequel
           scheme = uri.scheme
           scheme = :dbi if scheme =~ /\Adbi-/
           c = adapter_class(scheme)
-          uri_options = {}
+          uri_options = c.send(:uri_to_options, uri)
           uri.query.split('&').collect{|s| s.split('=')}.each{|k,v| uri_options[k.to_sym] = v} unless uri.query.to_s.strip.empty?
-          opts = c.send(:uri_to_options, uri).merge(uri_options).merge(opts)
+          uri_options.entries.each{|k,v| uri_options[k] = URI.unescape(v) if v.is_a?(String)}
+          opts = uri_options.merge(opts)
         end
       when Hash
         opts = conn_string.merge(opts)
@@ -846,27 +847,25 @@ module Sequel
     # integer, string, date, datetime, boolean, and float.
     def schema_column_type(db_type)
       case db_type
-      when /\Atinyint/io
-        Sequel.convert_tinyint_to_bool ? :boolean : :integer
       when /\Ainterval\z/io
         :interval
-      when /\A(character( varying)?|(var)?char|text)/io
+      when /\A(character( varying)?|n?(var)?char|n?text)/io
         :string
-      when /\A(int(eger)?|bigint|smallint)/io
+      when /\A(int(eger)?|(big|small|tiny)int)/io
         :integer
       when /\Adate\z/io
         :date
-      when /\A(datetime|timestamp( with(out)? time zone)?)\z/io
+      when /\A((small)?datetime|timestamp( with(out)? time zone)?)\z/io
         :datetime
       when /\Atime( with(out)? time zone)?\z/io
         :time
-      when /\Aboolean\z/io
+      when /\A(boolean|bit)\z/io
         :boolean
       when /\A(real|float|double( precision)?)\z/io
         :float
-      when /\A(((numeric|decimal)(\(\d+,\d+\))?)|money)\z/io
+      when /\A(((numeric|decimal)(\(\d+,\d+\))?)|(small)?money)\z/io
         :decimal
-      when /bytea|blob/io
+      when /bytea|blob|image|(var)?binary/io
         :blob
       end
     end

data/lib/sequel/database/schema_sql.rb

@@ -69,8 +69,9 @@ module Sequel
     def column_definition_sql(column)
       sql = "#{quote_identifier(column[:name])} #{type_literal(column)}"
       sql << UNIQUE if column[:unique]
-      sql << NOT_NULL if column[:null] == false
-      sql << NULL if column[:null] == true
+      null = column.include?(:null) ? column[:null] : column[:allow_null]
+      sql << NOT_NULL if null == false
+      sql << NULL if 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]

data/lib/sequel/dataset.rb

@@ -342,6 +342,7 @@ module Sequel
     # Modify the identifier returned from the database based on the
     # identifier_output_method.
     def output_identifier(v)
+      v = 'untitled' if v == ''
       (i = identifier_output_method) ? v.to_s.send(i).to_sym : v.to_sym
     end
 

data/lib/sequel/dataset/sql.rb

@@ -272,14 +272,16 @@ module Sequel
     end
 
     # Returns a dataset selecting from the current dataset.
+    # Supplying the :alias option controls the name of the result.
     #
-    #   ds = DB[:items].order(:name)
-    #   ds.sql #=> "SELECT * FROM items ORDER BY name"
-    #   ds.from_self.sql #=> "SELECT * FROM (SELECT * FROM items ORDER BY name)"
-    def from_self
+    #   ds = DB[:items].order(:name).select(:id, :name)
+    #   ds.sql                         #=> "SELECT id,name FROM items ORDER BY name"
+    #   ds.from_self.sql               #=> "SELECT * FROM (SELECT id, name FROM items ORDER BY name) AS 't1'"
+    #   ds.from_self(:alias=>:foo).sql #=> "SELECT * FROM (SELECT id, name FROM items ORDER BY name) AS 'foo'"
+    def from_self(opts={})
       fs = {}
       @opts.keys.each{|k| fs[k] = nil} 
-      clone(fs).from(self)
+      clone(fs).from(opts[:alias] ? as(opts[:alias]) : self)
     end
 
     # SQL fragment specifying an SQL function call
@@ -453,7 +455,7 @@ module Sequel
     # * options - a hash of options, with any of the following keys:
     #   * :table_alias - the name of the table's alias when joining, necessary for joining
     #     to the same table more than once.  No alias is used by default.
-    #   * :implicit_qualifer - The name to use for qualifying implicit conditions.  By default,
+    #   * :implicit_qualifier - The name to use for qualifying implicit conditions.  By default,
     #     the last joined or primary table is used.
     # * block - The block argument should only be given if a JOIN with an ON clause is used,
     #   in which case it yields the table alias/name for the table currently being joined,
@@ -797,6 +799,13 @@ module Sequel
       opts = {:all=>opts} unless opts.is_a?(Hash)
       compound_clone(:union, dataset, opts)
     end
+    
+    # Returns a copy of the dataset with no limit or offset.
+    # 
+    #   dataset.limit(10, 20).unlimited # SELECT * FROM items
+    def unlimited
+      clone(:limit=>nil, :offset=>nil)
+    end
 
     # Returns a copy of the dataset with no order.
     # 

data/lib/sequel/extensions/schema_dumper.rb

@@ -109,30 +109,30 @@ END_MIG
       case t = schema[:db_type].downcase
       when /\A(?:medium|small)?int(?:eger)?(?:\((?:\d+)\))?\z/o
         {:type=>Integer}
-      when /\Atinyint(?:\((?:\d+)\))?\z/o
-        {:type=>(Sequel.convert_tinyint_to_bool ? TrueClass : Integer)}
+      when /\Atinyint(?:\((\d+)\))?\z/o
+        {:type=>(self.class.adapter_scheme == :mysql && $1 == '1' && Sequel::MySQL.convert_tinyint_to_bool ? TrueClass : Integer)}
       when /\Abigint(?:\((?:\d+)\))?\z/o
         {:type=>Bignum}
       when /\A(?:real|float|double(?: precision)?)\z/o
         {:type=>Float}
       when 'boolean'
         {:type=>TrueClass}
-      when /\A(?:(?:tiny|medium|long)?text|clob)\z/o
+      when /\A(?:(?:tiny|medium|long|n)?text|clob)\z/o
         {:type=>String, :text=>true}
       when 'date'
         {:type=>Date}
-      when 'datetime'
+      when /\A(?:small)?datetime\z/o
         {:type=>DateTime}
       when /\Atimestamp(?: with(?:out)? time zone)?\z/o
         {:type=>DateTime}
       when /\Atime(?: with(?:out)? time zone)?\z/o
         {:type=>Time, :only_time=>true}
-      when /\Achar(?:acter)?(?:\((\d+)\))?\z/o
+      when /\An?char(?:acter)?(?:\((\d+)\))?\z/o
         {:type=>String, :size=>($1.to_i if $1), :fixed=>true}
-      when /\A(?:varchar|character varying|bpchar|string)(?:\((\d+)\))?\z/o
+      when /\A(?:n?varchar|character varying|bpchar|string)(?:\((\d+)\))?\z/o
         s = ($1.to_i if $1)
         {:type=>String, :size=>(s == 255 ? nil : s)}
-      when 'money'
+      when /\A(?:small)?money\z/o
         {:type=>BigDecimal, :size=>[19,2]}
       when /\A(?:decimal|numeric|number)(?:\((\d+)(?:,\s*(\d+))?\))?\z/o
         s = [($1.to_i if $1), ($2.to_i if $2)].compact

data/lib/sequel/model/associations.rb

@@ -548,6 +548,7 @@ module Sequel
             when Class
               opts[:class_name] ||= opts[:class].name
           end
+          opts[:class_name] ||= ((self.name || '').split("::")[0..-2] + [camelize(opts.returns_array? ? singularize(name) : name)]).join('::')
       
           send(:"def_#{type}", opts)
       
@@ -625,17 +626,21 @@ module Sequel
       
         # Add the add_ instance method 
         def def_add_method(opts)
-          association_module_def(opts.add_method){|o| add_associated_object(opts, o)}
+          association_module_def(opts.add_method){|o,*args| add_associated_object(opts, o, *args)}
         end
       
-        # Adds methods to the module included in the class related to getting the
-        # dataset and associated object(s).
+        # Adds methods related to the association's dataset to the module included in the class.
         def def_association_dataset_methods(opts)
           # If a block is given, define a helper method for it, because it takes
           # an argument.  This is unnecessary in Ruby 1.9, as that has instance_exec.
           association_module_private_def(opts.dataset_helper_method, &opts[:block]) if opts[:block]
           association_module_private_def(opts._dataset_method, &opts[:dataset])
           association_module_def(opts.dataset_method){_dataset(opts)}
+          def_association_method(opts)
+        end
+
+        # Adds method for retrieving the associated objects to the module included in the class.
+        def def_association_method(opts)
           association_module_def(opts.association_method){|*reload| load_associated_objects(opts, reload[0])}
         end
       
@@ -646,7 +651,6 @@ module Sequel
           left = (opts[:left_key] ||= opts.default_left_key)
           right = (opts[:right_key] ||= opts.default_right_key)
           left_pk = (opts[:left_primary_key] ||= self.primary_key)
-          opts[:class_name] ||= camelize(singularize(name))
           opts[:cartesian_product_number] ||= 1
           join_table = (opts[:join_table] ||= opts.default_join_table)
           left_key_alias = opts[:left_key_alias] ||= opts.default_associated_key_alias
@@ -705,7 +709,6 @@ module Sequel
           opts[:key] = opts.default_key unless opts.include?(:key)
           key = opts[:key]
           opts[:cartesian_product_number] ||= 0
-          opts[:class_name] ||= camelize(name)
           opts[:dataset] ||= proc do
             klass = opts.associated_class
             klass.filter(SQL::QualifiedIdentifier.new(klass.table_name, opts.primary_key)=>send(key))
@@ -750,7 +753,6 @@ module Sequel
           model = self
           key = (opts[:key] ||= opts.default_key)
           primary_key = (opts[:primary_key] ||= self.primary_key)
-          opts[:class_name] ||= camelize(singularize(name))
           opts[:dataset] ||= proc do
             klass = opts.associated_class
             klass.filter(SQL::QualifiedIdentifier.new(klass.table_name, key) => send(primary_key))
@@ -828,8 +830,8 @@ module Sequel
         
         # Add the remove_ and remove_all instance methods
         def def_remove_methods(opts)
-          association_module_def(opts.remove_method){|o| remove_associated_object(opts, o)}
-          association_module_def(opts.remove_all_method){remove_all_associated_objects(opts)}
+          association_module_def(opts.remove_method){|o,*args| remove_associated_object(opts, o, *args)}
+          association_module_def(opts.remove_all_method){|*args| remove_all_associated_objects(opts, *args)}
         end
       end
 
@@ -878,11 +880,11 @@ module Sequel
         end
 
         # Add the given associated object to the given association
-        def add_associated_object(opts, o)
+        def add_associated_object(opts, o, *args)
           raise(Sequel::Error, "model object #{model} does not have a primary key") unless pk
           raise(Sequel::Error, "associated object #{o.model} does not have a primary key") if opts.need_associated_primary_key? && !o.pk
           return if run_association_callbacks(opts, :before_add, o) == false
-          send(opts._add_method, o)
+          send(opts._add_method, o, *args)
           associations[opts[:name]].push(o) if associations.include?(opts[:name])
           add_reciprocal_object(opts, o)
           run_association_callbacks(opts, :after_add, o)
@@ -921,20 +923,20 @@ module Sequel
         end
 
         # Remove all associated objects from the given association
-        def remove_all_associated_objects(opts)
+        def remove_all_associated_objects(opts, *args)
           raise(Sequel::Error, "model object #{model} does not have a primary key") unless pk
-          send(opts._remove_all_method)
+          send(opts._remove_all_method, *args)
           ret = associations[opts[:name]].each{|o| remove_reciprocal_object(opts, o)} if associations.include?(opts[:name])
           associations[opts[:name]] = []
           ret
         end
 
         # Remove the given associated object from the given association
-        def remove_associated_object(opts, o)
+        def remove_associated_object(opts, o, *args)
           raise(Sequel::Error, "model object #{model} does not have a primary key") unless pk
           raise(Sequel::Error, "associated object #{o.model} does not have a primary key") if opts.need_associated_primary_key? && !o.pk
           return if run_association_callbacks(opts, :before_remove, o) == false
-          send(opts._remove_method, o)
+          send(opts._remove_method, o, *args)
           associations[opts[:name]].delete_if{|x| o === x} if associations.include?(opts[:name])
           remove_reciprocal_object(opts, o)
           run_association_callbacks(opts, :after_remove, o)