sequel 4.48.0 → 4.49.0

data/lib/sequel/plugins/pg_row.rb

@@ -53,7 +53,9 @@ module Sequel
     #     Address.load(:street=>'123 Foo St', :city=>'Bar Town', :zip=>'12345'))
     module PgRow
       ROW = 'ROW'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :ROW)
       CAST = '::'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :CAST)
 
       # When loading the extension, make sure the database has the pg_row extension
       # loaded, load the custom database extensions, and automatically register the
@@ -75,9 +77,9 @@ module Sequel
       module InstanceMethods
         # Literalize the model instance and append it to the sql.
         def sql_literal_append(ds, sql)
-          sql << ROW
+          sql << 'ROW'
           ds.literal_append(sql, values.values_at(*columns))
-          sql << CAST
+          sql << '::'
           ds.quote_schema_table_append(sql, model.dataset.first_source_table)
         end
       end

data/lib/sequel/plugins/serialization.rb

@@ -149,6 +149,7 @@ module Sequel
         # The columns that will be serialized.  This is only for
         # backwards compatibility, use serialization_map in new code.
         def serialized_columns
+          Sequel::Deprecation.deprecate("#{self}.serialized_columns in the serialization plugin", "Use #{self}.serialization_map.keys instead")
           serialization_map.keys
         end
 

data/lib/sequel/plugins/single_table_inheritance.rb

@@ -182,7 +182,12 @@ module Sequel
         # Return an instance of the class specified by sti_key,
         # used by the row_proc.
         def sti_load(r)
-          sti_class(sti_model_map[r[sti_key]]).call(r)
+          sti_class_from_sti_key(r[sti_key]).call(r)
+        end
+
+        # Return the sti class based on one of the keys from sti_model_map.
+        def sti_class_from_sti_key(key)
+          sti_class(sti_model_map[key])
         end
 
         # Make sure that all subclasses of the parent class correctly include 

data/lib/sequel/plugins/touch.rb

@@ -31,6 +31,7 @@ module Sequel
     module Touch
       # The default column to update when touching
       TOUCH_COLUMN_DEFAULT = :updated_at
+      Sequel::Deprecation.deprecate_constant(self, :TOUCH_COLUMN_DEFAULT)
 
       def self.apply(model, opts=OPTS)
         model.instance_variable_set(:@touched_associations, {})
@@ -46,7 +47,7 @@ module Sequel
       #                  If a hash is used, the value is used as the column to update.
       # :column :: The column to modify when touching a model instance.
       def self.configure(model, opts=OPTS)
-        model.touch_column = opts[:column] || TOUCH_COLUMN_DEFAULT if opts[:column] || !model.touch_column
+        model.touch_column = opts[:column] || :updated_at if opts[:column] || !model.touch_column
         model.touch_associations(opts[:associations]) if opts[:associations]
       end
 

data/lib/sequel/plugins/validation_helpers.rb

@@ -90,6 +90,8 @@ module Sequel
         :presence=>{:message=>lambda{"is not present"}},
         :unique=>{:message=>lambda{'is already taken'}}
       }
+      DEFAULT__OPTIONS = DEFAULT_OPTIONS
+      Sequel::Deprecation.deprecate_constant(self, :DEFAULT_OPTIONS)
 
       module InstanceMethods 
         # Check that the attribute values are the given exact length.
@@ -129,7 +131,13 @@ module Sequel
         # Accepts a :nil_message option that is the error message to use when the
         # value is nil instead of being too long.
         def validates_max_length(max, atts, opts=OPTS)
-          validatable_attributes_for_type(:max_length, atts, opts){|a,v,m| v ? validation_error_message(m, max) : validation_error_message(opts[:nil_message] || DEFAULT_OPTIONS[:max_length][:nil_message]) if v.nil? || v.length > max}
+          validatable_attributes_for_type(:max_length, atts, opts) do |a,v,m|
+            if v.nil?
+              validation_error_message(opts[:nil_message] || default_validation_helpers_options(:max_length)[:nil_message])
+            elsif v.length > max
+              validation_error_message(m, max)
+            end
+          end
         end
 
         # Check that the attribute values are not shorter than the given min length.
@@ -268,7 +276,7 @@ module Sequel
         # The hash return must include a :message option that is either a
         # proc or string.
         def default_validation_helpers_options(type)
-          DEFAULT_OPTIONS[type]
+          DEFAULT__OPTIONS[type]
         end
 
         # Skip validating any attribute that matches one of the allow_* options.

data/lib/sequel/sql.rb

@@ -1030,10 +1030,13 @@ module Sequel
       # The expression to alias
       attr_reader :expression
 
-      # The alias to use for the expression, not +alias+ since that is
-      # a keyword in ruby.
-      attr_reader :aliaz
-      alias_method :alias, :aliaz
+      # The alias to use for the expression
+      attr_reader :alias
+
+      def aliaz
+        Sequel::Deprecation.deprecate("Sequel::SQL::AliasedExpression#aliaz", "Use #alias instead")
+        self.alias
+      end
 
       # The columns aliases to use, for when the aliased expression is
       # a record or set of records (such as a dataset). 
@@ -1042,7 +1045,7 @@ module Sequel
       # Create an object with the given expression and alias.
       def initialize(expression, aliaz, columns=nil)
         @expression = expression
-        @aliaz = aliaz
+        @alias = aliaz
         @columns = columns
         freeze
       end
@@ -1359,7 +1362,11 @@ module Sequel
 
       # The SQL function to call
       attr_reader :name
-      alias f name
+
+      def f
+        Sequel::Deprecation.deprecate("Sequel::SQL::Function#f", "Use #name instead")
+        name
+      end
       
       # The array of arguments to pass to the function (may be blank)
       attr_reader :args
@@ -1917,7 +1924,9 @@ module Sequel
     # For a more detailed explanation, see the {Virtual Rows guide}[rdoc-ref:doc/virtual_rows.rdoc].
     class VirtualRow < BasicObject
       QUESTION_MARK = LiteralString.new('?').freeze
+      Sequel::Deprecation.deprecate_constant(self, :QUESTION_MARK)
       DOUBLE_UNDERSCORE = '__'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :DOUBLE_UNDERSCORE)
 
       include OperatorBuilders
 
@@ -1972,7 +1981,7 @@ module Sequel
             end
           elsif args.empty?
             if split = Sequel.split_symbols?
-              table, column = m.to_s.split(DOUBLE_UNDERSCORE, 2)
+              table, column = m.to_s.split('__', 2)
               if column && split == :deprecated
                 Sequel::Deprecation.deprecate("Splitting virtual row method names", "Either set Sequel.split_symbols = true, or change #{m.inspect} to #{table}[:#{column}]")
               end

data/lib/sequel/version.rb

@@ -5,7 +5,7 @@ module Sequel
   MAJOR = 4
   # The minor version of Sequel.  Bumped for every non-patch level
   # release, generally around once a month.
-  MINOR = 48
+  MINOR = 49
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.
   TINY  = 0

data/spec/adapters/mssql_spec.rb

@@ -17,13 +17,13 @@ describe "A MSSQL database" do
   end
 
   it "should be able to read fractional part of timestamp" do
-    rs = @db["select getutcdate() as full_date, cast(datepart(millisecond, getutcdate()) as int) as milliseconds"].first
-    rs[:milliseconds].must_equal rs[:full_date].usec/1000
+    rs = @db["select getutcdate() as full_date, cast(round(datepart(millisecond, getutcdate()), 0) as int) as milliseconds"].first
+    rs[:milliseconds].must_be_close_to(rs[:full_date].usec/1000, 2)
   end
 
   it "should be able to write fractional part of timestamp" do
-    t = Time.utc(2001, 12, 31, 23, 59, 59, 997000)
-    (t.usec/1000).must_equal @db["select cast(datepart(millisecond, ?) as int) as milliseconds", t].get
+    t = Time.utc(2001, 12, 31, 23, 59, 59, 996000)
+    (t.usec/1000).must_equal @db["select cast(round(datepart(millisecond, ?), 0) as int) as milliseconds", t].get
   end
   
   it "should not raise an error when getting the server version" do

data/spec/adapters/mysql_spec.rb

@@ -318,7 +318,7 @@ describe "MySQL join expressions" do
   it "should support cross joins" do
     @ds.join_table(:cross, :nodes).sql.must_equal 'SELECT * FROM `nodes` CROSS JOIN `nodes`'
   end
-  it "should support cross joins as inner joins if conditions are used" do
+  deprecated "should support cross joins as inner joins if conditions are used" do
     @ds.join_table(:cross, :nodes, :id=>:id).sql.must_equal 'SELECT * FROM `nodes` INNER JOIN `nodes` ON (`nodes`.`id` = `nodes`.`id`)'
   end
   it "should support straight joins (force left table to be read before right)" do
@@ -1367,6 +1367,10 @@ if DB.adapter_scheme == :mysql2
     it "should correctly handle early returning when streaming results" do
       3.times{@ds.each{|r| break r[:a]}.must_equal 0}
     end
+
+    it "#paged_each should bypass streaming when :stream => false passed in" do
+      DB[:a].order(:a).paged_each(:stream => false){|x| DB[:a].first; break}
+    end
   end
 end
 

data/spec/adapters/oracle_spec.rb

@@ -2,6 +2,10 @@ SEQUEL_ADAPTER_TEST = :oracle
 
 require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper.rb')
 
+unless DB.opts[:autosequence]
+  warn "Running oracle adapter specs without :autosequence Database option results in many errors, use the :autosequence Database option when testing"
+end
+
 describe "An Oracle database" do
   before(:all) do
     DB.create_table!(:items) do

data/spec/bin_spec.rb

@@ -40,7 +40,13 @@ describe "bin/sequel" do
     DB2.disconnect
     File.delete(BIN_SPEC_DB) if File.file?(BIN_SPEC_DB)
     File.delete(BIN_SPEC_DB2) if File.file?(BIN_SPEC_DB2)
-    File.delete(TMP_FILE) if File.file?(TMP_FILE)
+    if File.file?(TMP_FILE)
+      begin
+        File.delete(TMP_FILE)
+      rescue Errno::ENOENT
+        nil
+      end
+    end
     File.delete(OUTPUT) if File.file?(OUTPUT)
   end
   

data/spec/core/connection_pool_spec.rb

@@ -18,6 +18,16 @@ describe "An empty ConnectionPool" do
     @cpool = Sequel::ConnectionPool.get_pool(mock_db.call, CONNECTION_POOL_DEFAULTS)
   end
 
+  deprecated "should support :pool_class option with string" do
+    begin
+      c = Class.new(Sequel::ConnectionPool)
+      Sequel::ConnectionPool::CONNECTION_POOL__MAP[:foo] = c
+      Sequel::ConnectionPool.get_pool(mock_db.call, :pool_class=>:foo).must_be_instance_of c
+    ensure
+      Sequel::ConnectionPool::CONNECTION_POOL__MAP.delete(c)
+    end
+  end
+
   it "should have no available connections" do
     @cpool.available_connections.must_equal []
   end
@@ -26,9 +36,13 @@ describe "An empty ConnectionPool" do
     @cpool.allocated.must_equal({})
   end
 
-  it "should have a created_count of zero" do
+  deprecated "should have a created_count of zero" do
     @cpool.created_count.must_equal 0
   end
+
+  it "should have a size of zero" do
+    @cpool.size.must_equal 0
+  end
 end
 
 describe "ConnectionPool options" do
@@ -54,11 +68,11 @@ describe "A connection pool handling connections" do
     @cpool = Sequel::ConnectionPool.get_pool(mock_db.call(proc{|c| msp.call}){:got_connection}, CONNECTION_POOL_DEFAULTS.merge(:max_connections=>@max_size))
   end
 
-  it "#hold should increment #created_count" do
+  it "#hold should increment #size" do
     @cpool.hold do
-      @cpool.created_count.must_equal 1
-      @cpool.hold {@cpool.hold {@cpool.created_count.must_equal 1}}
-      Thread.new{@cpool.hold {_(@cpool.created_count).must_equal 2}}.join
+      @cpool.size.must_equal 1
+      @cpool.hold {@cpool.hold {@cpool.size.must_equal 1}}
+      Thread.new{@cpool.hold {_(@cpool.size).must_equal 2}}.join
     end
   end
 
@@ -100,7 +114,7 @@ describe "A connection pool handling connections" do
     q = Queue.new
     50.times{Thread.new{@cpool.hold{q.pop}}}
     50.times{q.push nil}
-    @cpool.created_count.must_be :<=,  @max_size
+    @cpool.size.must_be :<=,  @max_size
   end
 
   it "database's disconnect connection method should be called when a disconnect is detected" do
@@ -110,16 +124,16 @@ describe "A connection pool handling connections" do
   end
 
   it "#hold should remove the connection if a DatabaseDisconnectError is raised" do
-    @cpool.created_count.must_equal 0
+    @cpool.size.must_equal 0
     q, q1 = Queue.new, Queue.new
     @cpool.hold{Thread.new{@cpool.hold{q1.pop; q.push nil}; q1.pop; q.push nil}; q1.push nil; q.pop; q1.push nil; q.pop}
-    @cpool.created_count.must_equal 2
+    @cpool.size.must_equal 2
     proc{@cpool.hold{raise Sequel::DatabaseDisconnectError}}.must_raise(Sequel::DatabaseDisconnectError)
-    @cpool.created_count.must_equal 1
+    @cpool.size.must_equal 1
     proc{@cpool.hold{raise Sequel::DatabaseDisconnectError}}.must_raise(Sequel::DatabaseDisconnectError)
-    @cpool.created_count.must_equal 0
+    @cpool.size.must_equal 0
     proc{@cpool.hold{raise Sequel::DatabaseDisconnectError}}.must_raise(Sequel::DatabaseDisconnectError)
-    @cpool.created_count.must_equal 0
+    @cpool.size.must_equal 0
   end
 end
 
@@ -127,13 +141,13 @@ describe "A connection pool handling connection errors" do
   it "#hold should raise a Sequel::DatabaseConnectionError if an exception is raised by the connection_proc" do
     cpool = Sequel::ConnectionPool.get_pool(mock_db.call{raise Interrupt}, CONNECTION_POOL_DEFAULTS)
     proc{cpool.hold{:block_return}}.must_raise(Sequel::DatabaseConnectionError)
-    cpool.created_count.must_equal 0
+    cpool.size.must_equal 0
   end
 
   it "#hold should raise a Sequel::DatabaseConnectionError if nil is returned by the connection_proc" do
     cpool = Sequel::ConnectionPool.get_pool(mock_db.call{nil}, CONNECTION_POOL_DEFAULTS)
     proc{cpool.hold{:block_return}}.must_raise(Sequel::DatabaseConnectionError)
-    cpool.created_count.must_equal 0
+    cpool.size.must_equal 0
   end
 end
 
@@ -1100,7 +1114,7 @@ AllConnectionPoolClassesSpecs = shared_description do
   end
 end
 
-Sequel::ConnectionPool::CONNECTION_POOL_MAP.keys.each do |k, v|
+Sequel::ConnectionPool::CONNECTION_POOL__MAP.keys.each do |k, v|
   opts = {:single_threaded=>k, :servers=>(v ? {} : nil)}
   describe "Connection pool with #{opts.inspect}" do
     before(:all) do

data/spec/core/database_spec.rb

@@ -517,6 +517,130 @@ describe "Database#extend_datasets" do
   end
 end
   
+describe "Database#extend_datasets custom methods" do
+  before do
+    @db = Sequel.mock
+  end
+
+  def ds
+    @db[:items]
+  end
+  
+  it "should have dataset_module support a where method" do
+    @db.extend_datasets{where :released, :released}
+    ds.released.sql.must_equal 'SELECT * FROM items WHERE released'
+    ds.where(:foo).released.sql.must_equal 'SELECT * FROM items WHERE (foo AND released)'
+  end
+
+  it "should have dataset_module support a having method" do
+    @db.extend_datasets{having(:released){released}}
+    ds.released.sql.must_equal 'SELECT * FROM items HAVING released'
+    ds.where(:foo).released.sql.must_equal 'SELECT * FROM items WHERE foo HAVING released'
+  end
+
+  it "should have dataset_module support an exclude method" do
+    @db.extend_datasets{exclude :released, :released}
+    ds.released.sql.must_equal 'SELECT * FROM items WHERE NOT released'
+    ds.where(:foo).released.sql.must_equal 'SELECT * FROM items WHERE (foo AND NOT released)'
+  end
+
+  it "should have dataset_module support an exclude_having method" do
+    @db.extend_datasets{exclude_having :released, :released}
+    ds.released.sql.must_equal 'SELECT * FROM items HAVING NOT released'
+    ds.where(:foo).released.sql.must_equal 'SELECT * FROM items WHERE foo HAVING NOT released'
+  end
+
+  it "should have dataset_module support a distinct method" do
+    @db.extend_datasets{def supports_distinct_on?; true end; distinct :foo, :baz}
+    ds.foo.sql.must_equal 'SELECT DISTINCT ON (baz) * FROM items'
+    ds.where(:bar).foo.sql.must_equal 'SELECT DISTINCT ON (baz) * FROM items WHERE bar'
+  end
+
+  it "should have dataset_module support a grep method" do
+    @db.extend_datasets{grep :foo, :baz, 'quux%'}
+    ds.foo.sql.must_equal 'SELECT * FROM items WHERE ((baz LIKE \'quux%\' ESCAPE \'\\\'))'
+    ds.where(:bar).foo.sql.must_equal 'SELECT * FROM items WHERE (bar AND ((baz LIKE \'quux%\' ESCAPE \'\\\')))'
+  end
+
+  it "should have dataset_module support a group method" do
+    @db.extend_datasets{group :foo, :baz}
+    ds.foo.sql.must_equal 'SELECT * FROM items GROUP BY baz'
+    ds.where(:bar).foo.sql.must_equal 'SELECT * FROM items WHERE bar GROUP BY baz'
+  end
+
+  it "should have dataset_module support a group_and_count method" do
+    @db.extend_datasets{group_and_count :foo, :baz}
+    ds.foo.sql.must_equal 'SELECT baz, count(*) AS count FROM items GROUP BY baz'
+    ds.where(:bar).foo.sql.must_equal 'SELECT baz, count(*) AS count FROM items WHERE bar GROUP BY baz'
+  end
+
+  it "should have dataset_module support a group_append method" do
+    @db.extend_datasets{group_append :foo, :baz}
+    ds.foo.sql.must_equal 'SELECT * FROM items GROUP BY baz'
+    ds.group(:bar).foo.sql.must_equal 'SELECT * FROM items GROUP BY bar, baz'
+  end
+
+  it "should have dataset_module support a limit method" do
+    @db.extend_datasets{limit :foo, 1}
+    ds.foo.sql.must_equal 'SELECT * FROM items LIMIT 1'
+    ds.where(:bar).foo.sql.must_equal 'SELECT * FROM items WHERE bar LIMIT 1'
+  end
+
+  it "should have dataset_module support a offset method" do
+    @db.extend_datasets{offset :foo, 1}
+    ds.foo.sql.must_equal 'SELECT * FROM items OFFSET 1'
+    ds.where(:bar).foo.sql.must_equal 'SELECT * FROM items WHERE bar OFFSET 1'
+  end
+
+  it "should have dataset_module support a order method" do
+    @db.extend_datasets{order(:foo){:baz}}
+    ds.foo.sql.must_equal 'SELECT * FROM items ORDER BY baz'
+    ds.where(:bar).foo.sql.must_equal 'SELECT * FROM items WHERE bar ORDER BY baz'
+  end
+
+  it "should have dataset_module support a order_append method" do
+    @db.extend_datasets{order_append :foo, :baz}
+    ds.foo.sql.must_equal 'SELECT * FROM items ORDER BY baz'
+    ds.order(:bar).foo.sql.must_equal 'SELECT * FROM items ORDER BY bar, baz'
+  end
+
+  it "should have dataset_module support a order_prepend method" do
+    @db.extend_datasets{order_prepend :foo, :baz}
+    ds.foo.sql.must_equal 'SELECT * FROM items ORDER BY baz'
+    ds.order(:bar).foo.sql.must_equal 'SELECT * FROM items ORDER BY baz, bar'
+  end
+
+  it "should have dataset_module support a select method" do
+    @db.extend_datasets{select :foo, :baz}
+    ds.foo.sql.must_equal 'SELECT baz FROM items'
+    ds.where(:bar).foo.sql.must_equal 'SELECT baz FROM items WHERE bar'
+  end
+
+  it "should have dataset_module support a select_all method" do
+    @db.extend_datasets{select_all :foo, :baz}
+    ds.foo.sql.must_equal 'SELECT baz.* FROM items'
+    ds.where(:bar).foo.sql.must_equal 'SELECT baz.* FROM items WHERE bar'
+  end
+
+  it "should have dataset_module support a select_append method" do
+    @db.extend_datasets{select_append :foo, :baz}
+    ds.foo.sql.must_equal 'SELECT *, baz FROM items'
+    ds.where(:bar).foo.sql.must_equal 'SELECT *, baz FROM items WHERE bar'
+  end
+
+  it "should have dataset_module support a select_group method" do
+    @db.extend_datasets{select_group :foo, :baz}
+    ds.foo.sql.must_equal 'SELECT baz FROM items GROUP BY baz'
+    ds.where(:bar).foo.sql.must_equal 'SELECT baz FROM items WHERE bar GROUP BY baz'
+  end
+
+  it "should have dataset_module support a server method" do
+    @db.extend_datasets{server :foo, :baz}
+    ds.foo.opts[:server].must_equal :baz
+    ds.where(:bar).foo.opts[:server].must_equal :baz
+  end
+end
+
 describe "Database#disconnect_connection" do
   it "should call close on the connection" do
     o = Object.new
@@ -2257,6 +2381,31 @@ describe "Database#typecast_value" do
     end
   end
 
+  it "should have an underlying exception class available at cause" do
+    begin
+      @db.typecast_value(:date, 'a')
+      true.must_equal false
+    rescue Sequel::InvalidValue => e
+      e.cause.must_be_kind_of(ArgumentError)
+    end
+  end if RUBY_VERSION >= '2.1'
+
+  it "should have an underlying exception class available at cause when using nested exceptions" do
+    begin
+      begin
+        raise ArgumentError
+      rescue => e1
+        begin
+          raise RuntimeError
+        rescue => e2
+          @db.send(:raise_error, e1)
+        end
+      end
+    rescue Sequel::DatabaseError => e
+      e.cause.must_be_kind_of(ArgumentError)
+    end
+  end if RUBY_VERSION >= '2.1'
+
   it "should include underlying exception class in #inspect" do
     begin
       @db.typecast_value(:date, 'a')