sequel 2.10.0 → 2.11.0

data/lib/sequel_model/validations.rb

@@ -69,8 +69,7 @@ module Sequel
     # Defines validations by converting a longhand block into a series of 
     # shorthand definitions. For example:
     #
-    #   class MyClass
-    #     include Validation
+    #   class MyClass < Sequel::Model
     #     validates do
     #       length_of :name, :minimum => 6
     #       length_of :password, :minimum => 8
@@ -78,8 +77,7 @@ module Sequel
     #   end
     #
     # is equivalent to:
-    #   class MyClass
-    #     include Validation
+    #   class MyClass < Sequel::Model
     #     validates_length_of :name, :minimum => 6
     #     validates_length_of :password, :minimum => 8
     #   end
@@ -223,7 +221,7 @@ module Sequel
     # * :minimum - The minimum size allowed for the value (no default)
     # * :too_long - The message to use use if it the value is too long (default: 'is too long')
     # * :too_short - The message to use use if it the value is too short (default: 'is too short')
-    # * :with - The array/range that must include the size of the value for it to be valid (no default)
+    # * :within - The array/range that must include the size of the value for it to be valid (no default)
     # * :wrong_length - The message to use use if it the value is not valid (default: 'is the wrong length')
     def self.validates_length_of(*atts)
       opts = {
@@ -317,6 +315,23 @@ module Sequel
         o.errors[a] << opts[:message] if v.blank? && v != false
       end
     end
+    
+    # Validates that an attribute is within a specified range or set of values.
+    #
+    # Possible Options:
+    # * :in - An array or range of values to check for validity (required)
+    # * :message - The message to use (default: 'is not in range or set: <specified range>')
+    def self.validates_inclusion_of(*atts)
+      opts = atts.extract_options!
+      unless opts[:in] && opts[:in].respond_to?(:include?) 
+        raise ArgumentError, "The :in parameter is required, and respond to include?"
+      end
+      opts[:message] ||= "is not in range or set: #{opts[:in].inspect}"
+      atts << opts
+      validates_each(*atts) do |o, a, v|
+        o.errors[a] << opts[:message] unless opts[:in].include?(v)
+      end
+    end
 
     # Validates only if the fields in the model (specified by atts) are
     # unique in the database.  Pass an array of fields instead of multiple

data/spec/adapters/firebird_spec.rb

@@ -334,6 +334,11 @@ context "A Firebird database" do
 
     @db[:test2].first[:xyz].should == "56.40"
   end
+
+  specify "should allow us to retrieve the primary key for a table" do
+    @db.create_table!(:test2){primary_key :id}
+    @db.primary_key(:test2).should == ["id"]
+  end
 end
 
 context "Postgres::Dataset#insert" do
@@ -343,7 +348,7 @@ context "Postgres::Dataset#insert" do
   end
 
   specify "should using call insert_returning_sql" do
-    @ds.should_receive(:single_value).once.with(:sql=>'INSERT INTO TEST5 (VAL) VALUES (10) RETURNING XID')
+    @ds.should_receive(:single_value).once.with(:sql=>'INSERT INTO TEST5 (VAL) VALUES (10) RETURNING XID', :server=> :default)
     @ds.insert(:val=>10)
   end
 

data/spec/adapters/mysql_spec.rb

@@ -858,6 +858,7 @@ unless MYSQL_DB.class.adapter_scheme == :do
     
     specify "should be callable on the dataset object" do
       MYSQL_DB.execute('CREATE PROCEDURE test_sproc(a INTEGER) BEGIN SELECT *, a AS b FROM items; END')
+      MYSQL_DB[:items].delete
       @d = MYSQL_DB[:items]
       @d.call_sproc(:select, :test_sproc, 3).should == []
       @d.insert(:value=>1)
@@ -865,5 +866,16 @@ unless MYSQL_DB.class.adapter_scheme == :do
       @d.row_proc = proc{|r| r.keys.each{|k| r[k] *= 2 if r[k].is_a?(Integer)}; r}
       @d.call_sproc(:select, :test_sproc, 3).should == [{:id=>nil, :value=>2, :b=>6}]
     end
+    
+    specify "should be callable on the dataset object with multiple arguments" do
+      MYSQL_DB.execute('CREATE PROCEDURE test_sproc(a INTEGER, c INTEGER) BEGIN SELECT *, a AS b, c AS d FROM items; END')
+      MYSQL_DB[:items].delete
+      @d = MYSQL_DB[:items]
+      @d.call_sproc(:select, :test_sproc, 3, 4).should == []
+      @d.insert(:value=>1)
+      @d.call_sproc(:select, :test_sproc, 4, 5).should == [{:id=>nil, :value=>1, :b=>4, :d=>5}]
+      @d.row_proc = proc{|r| r.keys.each{|k| r[k] *= 2 if r[k].is_a?(Integer)}; r}
+      @d.call_sproc(:select, :test_sproc, 3, 4).should == [{:id=>nil, :value=>2, :b=>6, :d => 8}]
+    end
   end
 end

data/spec/adapters/postgres_spec.rb

@@ -472,9 +472,9 @@ context "Postgres::Dataset#insert" do
     @ds.insert(:value=>10)
   end
 
-  specify "should using call insert_returning_sql if server_version >= 80200" do
+  specify "should use INSERT RETURNING if server_version >= 80200" do
     @ds.meta_def(:server_version){80201}
-    @ds.should_receive(:single_value).once.with(:sql=>'INSERT INTO test5 (value) VALUES (10) RETURNING xid')
+    @ds.should_receive(:single_value).once.with(:server=>:default, :sql=>'INSERT INTO test5 (value) VALUES (10) RETURNING xid')
     @ds.insert(:value=>10)
   end
 

data/spec/adapters/sqlite_spec.rb

@@ -456,8 +456,87 @@ context "A SQLite database" do
     @db[:test3].select(:id).all.should == [{:id => 1}, {:id => 3}]
   end
 
-  specify "should not support rename_column operations" do
-    proc {@db.rename_column :test2, :value, :zyx}.should raise_error(Sequel::Error)
+  specify "should support rename_column operations" do
+    @db[:test2].delete
+    @db.add_column :test2, :xyz, :text
+    @db[:test2] << {:name => 'mmm', :value => 111, :xyz => 'qqqq'}
+
+    @db[:test2].columns.should == [:name, :value, :xyz]
+    @db.rename_column :test2, :xyz, :zyx, :type => :text
+    @db[:test2].columns.should == [:name, :value, :zyx]
+    @db[:test2].first[:zyx].should == 'qqqq'
+    @db[:test2].count.should eql(1)
+  end
+  
+  specify "should preserve defaults when dropping or renaming columns" do
+    @db.create_table! :test3 do
+      String :s, :default=>'a'
+      Integer :i
+    end
+
+    @db[:test3].insert
+    @db[:test3].first[:s].should == 'a'
+    @db[:test3].delete
+    @db.drop_column :test3, :i
+    @db[:test3].insert
+    @db[:test3].first[:s].should == 'a'
+    @db[:test3].delete
+    @db.rename_column :test3, :s, :t
+    @db[:test3].insert
+    @db[:test3].first[:t].should == 'a'
+    @db[:test3].delete
+  end
+  
+  specify "should handle quoted tables when dropping or renaming columns" do
+    @db.quote_identifiers = true
+    table_name = "T T"
+    @db.drop_table(table_name) rescue nil
+    @db.create_table! table_name do
+      Integer :"s s"
+      Integer :"i i"
+    end
+
+    @db.from(table_name).insert(:"s s"=>1, :"i i"=>2)
+    @db.from(table_name).all.should == [{:"s s"=>1, :"i i"=>2}]
+    @db.drop_column table_name, :"i i"
+    @db.from(table_name).all.should == [{:"s s"=>1}]
+    @db.rename_column table_name, :"s s", :"t t"
+    @db.from(table_name).all.should == [{:"t t"=>1}]
+  end
+  
+  specify "should choose a temporary table name that isn't already used when dropping or renaming columns" do
+    @db.create_table! :test3 do
+      Integer :h
+      Integer :i
+    end
+    @db.create_table! :test3_backup0 do
+      Integer :j
+    end
+    @db.create_table! :test3_backup1 do
+      Integer :k
+    end
+
+    @db[:test3].columns.should == [:h, :i]
+    @db[:test3_backup0].columns.should == [:j]
+    @db[:test3_backup1].columns.should == [:k]
+    sqls = @db.drop_column(:test3, :i)
+    sqls.any?{|x| x =~ /test3_backup2/}.should == true
+    sqls.any?{|x| x =~ /test3_backup[01]/}.should == false
+    @db[:test3].columns.should == [:h]
+    @db[:test3_backup0].columns.should == [:j]
+    @db[:test3_backup1].columns.should == [:k]
+
+    @db.create_table! :test3_backup2 do
+      Integer :l
+    end
+
+    sqls = @db.rename_column(:test3, :h, :i)
+    sqls.any?{|x| x =~ /test3_backup3/}.should == true
+    sqls.any?{|x| x =~ /test3_backup[012]/}.should == false
+    @db[:test3].columns.should == [:i]
+    @db[:test3_backup0].columns.should == [:j]
+    @db[:test3_backup1].columns.should == [:k]
+    @db[:test3_backup2].columns.should == [:l]
   end
   
   specify "should not support set_column_type operations" do

data/spec/integration/dataset_test.rb

@@ -101,7 +101,7 @@ describe "Dataset UNION, EXCEPT, and INTERSECT" do
   
   specify "should give the correct results for simple UNION, EXCEPT, and INTERSECT" do
     @ds1.union(@ds2).order(:number).map{|x| x[:number].to_s}.should == %w'10 20 30'
-    unless @ds1.class.ancestors.include?(Sequel::Dataset::UnsupportedIntersectExcept)
+    unless defined?(Sequel::Dataset::UnsupportedIntersectExcept) and @ds1.class.ancestors.include?(Sequel::Dataset::UnsupportedIntersectExcept)
       @ds1.except(@ds2).order(:number).map{|x| x[:number].to_s}.should == %w'20'
       @ds1.intersect(@ds2).order(:number).map{|x| x[:number].to_s}.should == %w'10'
     end
@@ -110,7 +110,7 @@ describe "Dataset UNION, EXCEPT, and INTERSECT" do
   specify "should give the correct results for compound UNION, EXCEPT, and INTERSECT" do
     @ds1.union(@ds2).union(@ds3).order(:number).map{|x| x[:number].to_s}.should == %w'10 20 30 40'
     @ds1.union(@ds2.union(@ds3)).order(:number).map{|x| x[:number].to_s}.should == %w'10 20 30 40'
-    unless @ds1.class.ancestors.include?(Sequel::Dataset::UnsupportedIntersectExcept)
+    unless defined?(Sequel::Dataset::UnsupportedIntersectExcept) and @ds1.class.ancestors.include?(Sequel::Dataset::UnsupportedIntersectExcept)
       @ds1.union(@ds2).except(@ds3).order(:number).map{|x| x[:number].to_s}.should == %w'20 30'
       @ds1.union(@ds2.except(@ds3)).order(:number).map{|x| x[:number].to_s}.should == %w'10 20 30'
       @ds1.union(@ds2).intersect(@ds3).order(:number).map{|x| x[:number].to_s}.should == %w'10 '

data/spec/integration/type_test.rb

@@ -6,6 +6,15 @@ describe "Supported types" do
     INTEGRATION_DB[:items]
   end
 
+  specify "should support casting correctly" do
+    ds = create_items_table_with_column(:number, Integer)
+    ds.insert(:number => 1)
+    ds.select(:number.cast_string.as(:n)).map(:n).should == %w'1'
+    ds = create_items_table_with_column(:name, String)
+    ds.insert(:name=> '1')
+    ds.select(:name.cast_numeric.as(:n)).map(:n).should == [1]
+  end
+
   specify "should support NULL correctly" do
     ds = create_items_table_with_column(:number, Integer)
     ds.insert(:number => nil)
@@ -71,8 +80,9 @@ describe "Supported types" do
   
   specify "should support generic file type" do
     ds = create_items_table_with_column(:name, File)
-    ds.insert(:name => ("a\0"*300).to_blob)
-    ds.all.should == [{:name=>("a\0"*300).to_blob}]
+    ds.insert(:name => ("a\0"*300).to_sequel_blob)
+    ds.all.should == [{:name=>("a\0"*300).to_sequel_blob}]
+    ds.first[:name].should be_a_kind_of(::Sequel::SQL::Blob)
   end
   
   specify "should support generic boolean type" do

data/spec/sequel_core/core_sql_spec.rb

@@ -124,12 +124,23 @@ context "String#lit" do
     Sequel::Database.new[:t].update_sql(:stamp => "NOW()".expr).should == \
       "UPDATE t SET stamp = NOW()"
   end
+
+  specify "should return a PlaceholderLiteralString object if args are given" do
+    a = 'DISTINCT ?'.lit(:a)
+    a.should be_a_kind_of(Sequel::SQL::PlaceholderLiteralString)
+    ds = MockDatabase.new.dataset
+    ds.literal(a).should == 'DISTINCT a'
+    ds.quote_identifiers = true
+    ds.literal(a).should == 'DISTINCT "a"'
+  end
 end
 
-context "String#to_blob" do
+context "String#to_blob and #to_sequel_blob" do
   specify "should return a Blob object" do
     'xyz'.to_blob.should be_a_kind_of(::Sequel::SQL::Blob)
     'xyz'.to_blob.should == 'xyz'
+    'xyz'.to_sequel_blob.should be_a_kind_of(::Sequel::SQL::Blob)
+    'xyz'.to_sequel_blob.should == 'xyz'
   end
 
   specify "should retain binary data" do
@@ -206,7 +217,7 @@ context "Column references" do
     @c = Class.new(Sequel::Dataset) do
       def quoted_identifier(c); "`#{c}`"; end
     end
-    @ds = @c.new(nil)
+    @ds = @c.new(MockDatabase.new)
     @ds.quote_identifiers = true
   end
   
@@ -233,15 +244,17 @@ context "Column references" do
   end
   
   specify "should be quoted properly in a cast function" do
-    @ds.literal(:x.cast_as(:integer)).should == "cast(`x` AS integer)"
-    @ds.literal(:x__y.cast_as('varchar(20)')).should == "cast(`x`.`y` AS varchar(20))"
+    @ds.literal(:x.cast_as(:integer)).should == "CAST(`x` AS integer)"
+    @ds.literal(:x__y.cast_as('varchar(20)')).should == "CAST(`x`.`y` AS varchar(20))"
   end
 end
 
 context "Blob" do
-  specify "#to_blob should return self" do
+  specify "#to_blob and #to_sequel_blob should return self" do
     blob = "x".to_blob
     blob.to_blob.object_id.should == blob.object_id
+    blob = "x".to_sequel_blob
+    blob.to_sequel_blob.object_id.should == blob.object_id
   end
 end
 
@@ -339,7 +352,7 @@ end
 
 context "Symbol" do
   setup do
-    @ds = Sequel::Dataset.new(nil)
+    @ds = Sequel::Dataset.new(MockDatabase.new)
   end
   
   specify "should support upper case outer functions" do
@@ -353,28 +366,49 @@ context "Symbol" do
   end
   
   specify "should support cast method and its cast_as alias" do
-    :abc.cast_as(:integer).to_s(@ds).should == "cast(abc AS integer)"
-    :abc.cast(:integer).to_s(@ds).should == "cast(abc AS integer)"
+    :abc.cast_as(:integer).to_s(@ds).should == "CAST(abc AS integer)"
+    :abc.cast(:integer).to_s(@ds).should == "CAST(abc AS integer)"
   end
   
   specify "should support cast_numeric and cast_string" do
     x = :abc.cast_numeric
     x.should be_a_kind_of(Sequel::SQL::NumericExpression)
-    x.to_s(@ds).should == "cast(abc AS integer)"
+    x.to_s(@ds).should == "CAST(abc AS integer)"
 
     x = :abc.cast_numeric(:real)
     x.should be_a_kind_of(Sequel::SQL::NumericExpression)
-    x.to_s(@ds).should == "cast(abc AS real)"
+    x.to_s(@ds).should == "CAST(abc AS real)"
 
     x = :abc.cast_string
     x.should be_a_kind_of(Sequel::SQL::StringExpression)
-    x.to_s(@ds).should == "cast(abc AS text)"
+    x.to_s(@ds).should == "CAST(abc AS varchar(255))"
 
     x = :abc.cast_string(:varchar)
     x.should be_a_kind_of(Sequel::SQL::StringExpression)
-    x.to_s(@ds).should == "cast(abc AS varchar)"
+    x.to_s(@ds).should == "CAST(abc AS varchar)"
   end
   
+  specify "should allow database independent types when casting" do
+    m = MockDatabase.new
+    m.instance_eval do
+       def type_literal_base(column)
+         return :foo if column[:type] == Integer
+         return :bar if column[:type] == String
+         column
+       end
+    end
+    @ds2 = Sequel::Dataset.new(m)
+    :abc.cast_as(Integer).to_s(@ds).should == "CAST(abc AS integer)"
+    :abc.cast_as(Integer).to_s(@ds2).should == "CAST(abc AS foo)"
+    :abc.cast(String).to_s(@ds).should == "CAST(abc AS varchar(255))"
+    :abc.cast(String).to_s(@ds2).should == "CAST(abc AS bar)"
+    :abc.cast(String).to_s(@ds2).should == "CAST(abc AS bar)"
+    :abc.cast_string.to_s(@ds2).should == "CAST(abc AS bar)"
+    :abc.cast_string(Integer).to_s(@ds2).should == "CAST(abc AS foo)"
+    :abc.cast_numeric.to_s(@ds2).should == "CAST(abc AS foo)"
+    :abc.cast_numeric(String).to_s(@ds2).should == "CAST(abc AS bar)"
+  end
+
   specify "should support subscript access using | operator" do
     (:abc|1).to_s(@ds).should == 'abc[1]'
     (:abc|[1]).to_s(@ds).should == 'abc[1]'

data/spec/sequel_core/database_spec.rb

@@ -55,6 +55,12 @@ context "A new Database" do
     db.quote_identifiers?.should == true
   end
 
+  specify "should upcase on input and downcase on output by default" do
+    db = Sequel::Database.new
+    db.send(:identifier_input_method_default).should == :upcase
+    db.send(:identifier_output_method_default).should == :downcase
+  end
+
   specify "should respect the :upcase_identifiers option" do
     Sequel.upcase_identifiers = false
     db = Sequel::Database.new(:upcase_identifiers=>false)
@@ -78,6 +84,7 @@ context "A new Database" do
   
   specify "should respect the :identifier_input_method option" do
     Sequel.identifier_input_method = nil
+    Sequel::Database.identifier_input_method.should == ""
     db = Sequel::Database.new(:identifier_input_method=>nil)
     db.identifier_input_method.should == nil
     db.identifier_input_method = :downcase
@@ -87,6 +94,7 @@ context "A new Database" do
     db.identifier_input_method = nil
     db.identifier_input_method.should == nil
     Sequel.identifier_input_method = :downcase
+    Sequel::Database.identifier_input_method.should == :downcase
     db = Sequel::Database.new(:identifier_input_method=>nil)
     db.identifier_input_method.should == nil
     db.identifier_input_method = :upcase
@@ -99,6 +107,7 @@ context "A new Database" do
   
   specify "should respect the :identifier_output_method option" do
     Sequel.identifier_output_method = nil
+    Sequel::Database.identifier_output_method.should == ""
     db = Sequel::Database.new(:identifier_output_method=>nil)
     db.identifier_output_method.should == nil
     db.identifier_output_method = :downcase
@@ -108,6 +117,7 @@ context "A new Database" do
     db.identifier_output_method = nil
     db.identifier_output_method.should == nil
     Sequel.identifier_output_method = :downcase
+    Sequel::Database.identifier_output_method.should == :downcase
     db = Sequel::Database.new(:identifier_output_method=>nil)
     db.identifier_output_method.should == nil
     db.identifier_output_method = :upcase
@@ -197,6 +207,13 @@ context "A new Database" do
     db.should be_a_kind_of(Sequel::Database)
     db.opts[:uri].should == 'jdbc:test://host/db_name'
   end
+
+  specify "should just use a :uri option for do with the full connection string" do
+    Sequel::Database.should_receive(:adapter_class).once.with(:do).and_return(Sequel::Database)
+    db = Sequel.connect('do:test://host/db_name')
+    db.should be_a_kind_of(Sequel::Database)
+    db.opts[:uri].should == 'do:test://host/db_name'
+  end
 end
 
 context "Database#disconnect" do
@@ -228,6 +245,10 @@ context "Database#uri" do
   specify "should return the connection URI for the database" do
     @db.uri.should == 'mau://user:pass@localhost:9876/maumau'
   end
+  
+  specify "should be aliased as #url" do
+    @db.url.should == 'mau://user:pass@localhost:9876/maumau'
+  end
 end
 
 context "Database.adapter_scheme" do
@@ -1153,24 +1174,15 @@ end
 
 context "Database#typecast_value" do
   setup do
-    @db = Sequel::Database.new(1 => 2, :logger => 3)
+    @db = Sequel::Database.new
   end
-  specify "should raise InvalidValue when setting invalid integer" do
+  specify "should raise an Error::InvalidValue when given an invalid value" do
     proc{@db.typecast_value(:integer, "13a")}.should raise_error(Sequel::Error::InvalidValue)
-  end
-  specify "should raise InvalidValue when setting invalid float" do
     proc{@db.typecast_value(:float, "4.e2")}.should raise_error(Sequel::Error::InvalidValue)
-  end
-  specify "should raise InvalidValue when setting invalid decimal" do
     proc{@db.typecast_value(:decimal, :invalid_value)}.should raise_error(Sequel::Error::InvalidValue)
-  end
-  specify "should raise InvalidValue when setting invalid date" do
     proc{@db.typecast_value(:date, Object.new)}.should raise_error(Sequel::Error::InvalidValue)
-  end
-  specify "should raise InvalidValue when setting invalid time" do
+    proc{@db.typecast_value(:date, 'a')}.should raise_error(Sequel::Error::InvalidValue)
     proc{@db.typecast_value(:time, Date.new)}.should raise_error(Sequel::Error::InvalidValue)
-  end
-  specify "should raise InvalidValue when setting invalid datetime" do
     proc{@db.typecast_value(:datetime, 4)}.should raise_error(Sequel::Error::InvalidValue)
   end
 end