sequel 3.24.0 → 3.25.0

data/spec/core/schema_spec.rb

@@ -594,6 +594,16 @@ describe "DB#drop_table" do
     @db.drop_table :cats
     @db.sqls.should == ['DROP TABLE cats']
   end
+
+  specify "should drop multiple tables at once" do
+    @db.drop_table :cats, :dogs
+    @db.sqls.should == ['DROP TABLE cats', 'DROP TABLE dogs']
+  end
+
+  specify "should take an options hash and support the :cascade option" do
+    @db.drop_table :cats, :dogs, :cascade=>true
+    @db.sqls.should == ['DROP TABLE cats CASCADE', 'DROP TABLE dogs CASCADE']
+  end
 end
 
 describe "DB#alter_table" do
@@ -722,6 +732,13 @@ describe "DB#alter_table" do
     @db.sqls.should == ["ALTER TABLE cats DROP COLUMN score"]
   end
 
+  specify "should support drop_column with :cascade=>true option" do
+    @db.alter_table(:cats) do
+      drop_column :score, :cascade=>true
+    end
+    @db.sqls.should == ["ALTER TABLE cats DROP COLUMN score CASCADE"]
+  end
+
   specify "should support drop_constraint" do
     @db.alter_table(:cats) do
       drop_constraint :valid_score
@@ -729,6 +746,13 @@ describe "DB#alter_table" do
     @db.sqls.should == ["ALTER TABLE cats DROP CONSTRAINT valid_score"]
   end
 
+  specify "should support drop_constraint with :cascade=>true option" do
+    @db.alter_table(:cats) do
+      drop_constraint :valid_score, :cascade=>true
+    end
+    @db.sqls.should == ["ALTER TABLE cats DROP CONSTRAINT valid_score CASCADE"]
+  end
+
   specify "should support drop_index" do
     @db.alter_table(:cats) do
       drop_index :name
@@ -776,6 +800,286 @@ describe "DB#alter_table" do
   end
 end
 
+describe "Database#create_table" do
+  before do
+    @db = DummyDatabase.new
+  end
+  
+  specify "should construct proper SQL" do
+    @db.create_table :test do
+      primary_key :id, :integer, :null => false
+      column :name, :text
+      index :name, :unique => true
+    end
+    @db.sqls.should == [
+      'CREATE TABLE test (id integer NOT NULL PRIMARY KEY AUTOINCREMENT, name text)',
+      'CREATE UNIQUE INDEX test_name_index ON test (name)'
+    ]
+  end
+  
+  specify "should create a temporary table" do
+    @db.create_table :test_tmp, :temp => true do
+      primary_key :id, :integer, :null => false
+      column :name, :text
+      index :name, :unique => true
+    end
+    
+    @db.sqls.should == [
+      'CREATE TEMPORARY TABLE test_tmp (id integer NOT NULL PRIMARY KEY AUTOINCREMENT, name text)',
+      'CREATE UNIQUE INDEX test_tmp_name_index ON test_tmp (name)'
+    ]
+  end
+
+  specify "should not use default schema when creating a temporary table" do
+    @db.default_schema = :foo
+    @db.create_table :test_tmp, :temp => true do
+      column :name, :text
+    end
+    @db.sqls.should == ['CREATE TEMPORARY TABLE test_tmp (name text)']
+  end
+end
+
+describe "Database#alter_table" do
+  before do
+    @db = DummyDatabase.new
+  end
+  
+  specify "should construct proper SQL" do
+    @db.alter_table :xyz do
+      add_column :aaa, :text, :null => false, :unique => true
+      drop_column :bbb
+      rename_column :ccc, :ddd
+      set_column_type :eee, :integer
+      set_column_default :hhh, 'abcd'
+      
+      add_index :fff, :unique => true
+      drop_index :ggg
+    end
+    
+    @db.sqls.should == [
+      'ALTER TABLE xyz ADD COLUMN aaa text NOT NULL UNIQUE',
+      'ALTER TABLE xyz DROP COLUMN bbb',
+      'ALTER TABLE xyz RENAME COLUMN ccc TO ddd',
+      'ALTER TABLE xyz ALTER COLUMN eee TYPE integer',
+      "ALTER TABLE xyz ALTER COLUMN hhh SET DEFAULT 'abcd'",
+      
+      'CREATE UNIQUE INDEX xyz_fff_index ON xyz (fff)',
+      'DROP INDEX xyz_ggg_index'
+    ]
+  end
+end
+
+describe "Database#add_column" do
+  before do
+    @db = DummyDatabase.new
+  end
+  
+  specify "should construct proper SQL" do
+    @db.add_column :test, :name, :text, :unique => true
+    @db.sqls.should == [
+      'ALTER TABLE test ADD COLUMN name text UNIQUE'
+    ]
+  end
+end
+
+describe "Database#drop_column" do
+  before do
+    @db = DummyDatabase.new
+  end
+  
+  specify "should construct proper SQL" do
+    @db.drop_column :test, :name
+    @db.sqls.should == ['ALTER TABLE test DROP COLUMN name']
+  end
+  
+  specify "should use CASCADE for :cascade=>true option" do
+    @db.drop_column :test, :name, :cascade=>true
+    @db.sqls.should == ['ALTER TABLE test DROP COLUMN name CASCADE']
+  end
+end
+
+describe "Database#rename_column" do
+  before do
+    @db = DummyDatabase.new
+  end
+  
+  specify "should construct proper SQL" do
+    @db.rename_column :test, :abc, :def
+    @db.sqls.should == [
+      'ALTER TABLE test RENAME COLUMN abc TO def'
+    ]
+  end
+end
+
+describe "Database#set_column_type" do
+  before do
+    @db = DummyDatabase.new
+  end
+  
+  specify "should construct proper SQL" do
+    @db.set_column_type :test, :name, :integer
+    @db.sqls.should == [
+      'ALTER TABLE test ALTER COLUMN name TYPE integer'
+    ]
+  end
+end
+
+describe "Database#set_column_default" do
+  before do
+    @db = DummyDatabase.new
+  end
+  
+  specify "should construct proper SQL" do
+    @db.set_column_default :test, :name, 'zyx'
+    @db.sqls.should == [
+      "ALTER TABLE test ALTER COLUMN name SET DEFAULT 'zyx'"
+    ]
+  end
+end
+
+describe "Database#add_index" do
+  before do
+    @db = DummyDatabase.new
+  end
+  
+  specify "should construct proper SQL" do
+    @db.add_index :test, :name, :unique => true
+    @db.sqls.should == [
+      'CREATE UNIQUE INDEX test_name_index ON test (name)'
+    ]
+  end
+  
+  specify "should accept multiple columns" do
+    @db.add_index :test, [:one, :two]
+    @db.sqls.should == [
+      'CREATE INDEX test_one_two_index ON test (one, two)'
+    ]
+  end
+end
+
+describe "Database#drop_index" do
+  before do
+    @db = DummyDatabase.new
+  end
+  
+  specify "should construct proper SQL" do
+    @db.drop_index :test, :name
+    @db.sqls.should == [
+      'DROP INDEX test_name_index'
+    ]
+  end
+  
+end
+
+describe "Database#drop_table" do
+  before do
+    @db = DummyDatabase.new
+  end
+  
+  specify "should construct proper SQL" do
+    @db.drop_table :test
+    @db.sqls.should == ['DROP TABLE test']
+  end
+  
+  specify "should accept multiple table names" do
+    @db.drop_table :a, :bb, :ccc
+    @db.sqls.should == [
+      'DROP TABLE a',
+      'DROP TABLE bb',
+      'DROP TABLE ccc'
+    ]
+  end
+end
+
+describe "Database#rename_table" do
+  before do
+    @db = DummyDatabase.new
+  end
+  
+  specify "should construct proper SQL" do
+    @db.rename_table :abc, :xyz
+    @db.sqls.should == ['ALTER TABLE abc RENAME TO xyz']
+  end
+end
+
+describe "Database#create_view" do
+  before do
+    @db = DummyDatabase.new
+  end
+  
+  specify "should construct proper SQL with raw SQL" do
+    @db.create_view :test, "SELECT * FROM xyz"
+    @db.sqls.should == ['CREATE VIEW test AS SELECT * FROM xyz']
+    @db.sqls.clear
+    @db.create_view :test.identifier, "SELECT * FROM xyz"
+    @db.sqls.should == ['CREATE VIEW test AS SELECT * FROM xyz']
+  end
+  
+  specify "should construct proper SQL with dataset" do
+    @db.create_view :test, @db[:items].select(:a, :b).order(:c)
+    @db.sqls.should == ['CREATE VIEW test AS SELECT a, b FROM items ORDER BY c']
+    @db.sqls.clear
+    @db.create_view :test.qualify(:sch), @db[:items].select(:a, :b).order(:c)
+    @db.sqls.should == ['CREATE VIEW sch.test AS SELECT a, b FROM items ORDER BY c']
+  end
+end
+
+describe "Database#create_or_replace_view" do
+  before do
+    @db = DummyDatabase.new
+  end
+  
+  specify "should construct proper SQL with raw SQL" do
+    @db.create_or_replace_view :test, "SELECT * FROM xyz"
+    @db.sqls.should == ['CREATE OR REPLACE VIEW test AS SELECT * FROM xyz']
+    @db.sqls.clear
+    @db.create_or_replace_view :sch__test, "SELECT * FROM xyz"
+    @db.sqls.should == ['CREATE OR REPLACE VIEW sch.test AS SELECT * FROM xyz']
+  end
+
+  specify "should construct proper SQL with dataset" do
+    @db.create_or_replace_view :test, @db[:items].select(:a, :b).order(:c)
+    @db.sqls.should == ['CREATE OR REPLACE VIEW test AS SELECT a, b FROM items ORDER BY c']
+    @db.sqls.clear
+    @db.create_or_replace_view :test.identifier, @db[:items].select(:a, :b).order(:c)
+    @db.sqls.should == ['CREATE OR REPLACE VIEW test AS SELECT a, b FROM items ORDER BY c']
+  end
+end
+
+describe "Database#drop_view" do
+  before do
+    @db = DummyDatabase.new
+  end
+  
+  specify "should construct proper SQL" do
+    @db.drop_view :test
+    @db.drop_view :test.identifier
+    @db.drop_view :sch__test
+    @db.drop_view :test.qualify(:sch)
+    @db.sqls.should == ['DROP VIEW test', 'DROP VIEW test', 'DROP VIEW sch.test', 'DROP VIEW sch.test']
+  end
+
+  specify "should drop multiple views at once" do
+    @db.drop_view :cats, :dogs
+    @db.sqls.should == ['DROP VIEW cats', 'DROP VIEW dogs']
+  end
+
+  specify "should take an options hash and support the :cascade option" do
+    @db.drop_view :cats, :dogs, :cascade=>true
+    @db.sqls.should == ['DROP VIEW cats CASCADE', 'DROP VIEW dogs CASCADE']
+  end
+end
+
+describe "Database#alter_table_sql" do
+  before do
+    @db = DummyDatabase.new
+  end
+  
+  specify "should raise error for an invalid op" do
+    proc {@db.send(:alter_table_sql, :mau, :op => :blah)}.should raise_error(Sequel::Error)
+  end
+end
+
 describe "Schema Parser" do
   before do
     @sqls = []

data/spec/core/spec_helper.rb

@@ -60,3 +60,32 @@ class SchemaDummyDatabase < Sequel::Database
     @sqls << sql
   end
 end
+
+class DummyDataset < Sequel::Dataset
+  def first
+    raise if @opts[:from] == [:a]
+    true
+  end
+end
+
+class DummyDatabase < Sequel::Database
+  attr_reader :sqls
+  
+  def execute(sql, opts={})
+    @sqls ||= []
+    @sqls << sql
+  end
+  
+  def transaction; yield; end
+
+  def dataset
+    DummyDataset.new(self)
+  end
+end
+
+class Dummy2Database < Sequel::Database
+  attr_reader :sql
+  def execute(sql); @sql = sql; end
+  def transaction; yield; end
+end
+

data/spec/extensions/association_pks_spec.rb

@@ -89,4 +89,35 @@ describe "Sequel::Plugins::AssociationPks" do
     @db.sqls[3].should == "COMMIT"
   end
 
+  specify "should automatically convert keys to numbers if the primary key is an integer for one_to_many associations" do
+    @Album.db_schema[:id][:type] = :integer
+    @Artist.load(:id=>1).album_pks = %w'1 2'
+    @db.sqls.should == ["UPDATE albums SET artist_id = 1 WHERE (id IN (1, 2))",
+      "UPDATE albums SET artist_id = NULL WHERE ((albums.artist_id = 1) AND (id NOT IN (1, 2)))"]
+  end
+
+  specify "should not automatically convert keys if the primary key is not an integer for many_to_many associations" do
+    @Album.db_schema[:id][:type] = :string
+    @Artist.load(:id=>1).album_pks = %w'1 2'
+    @db.sqls.should == ["UPDATE albums SET artist_id = 1 WHERE (id IN ('1', '2'))",
+      "UPDATE albums SET artist_id = NULL WHERE ((albums.artist_id = 1) AND (id NOT IN ('1', '2')))"]
+  end
+
+  specify "should automatically convert keys to numbers if the primary key is an integer for one_to_many associations" do
+    @Tag.db_schema[:id][:type] = :integer
+    @Album.load(:id=>2).tag_pks = %w'1 3'
+    @db.sqls[0].should == "DELETE FROM albums_tags WHERE ((album_id = 2) AND (tag_id NOT IN (1, 3)))"
+    @db.sqls[1].should =~ /INSERT INTO albums_tags \((album_id, tag_id|tag_id, album_id)\) VALUES \((2, 1|1, 2)\)/
+    @db.sqls.length.should == 2
+  end
+
+  specify "should not automatically convert keys to numbers if the primary key is an integer for many_to_many associations" do
+    @Tag.db_schema[:id][:type] = :string
+    @Album.load(:id=>2).tag_pks = %w'1 3'
+    @db.sqls[0].should == "DELETE FROM albums_tags WHERE ((album_id = 2) AND (tag_id NOT IN ('1', '3')))"
+    @db.sqls[1].should =~ /INSERT INTO albums_tags \((album_id, tag_id|tag_id, album_id)\) VALUES \((2, '1'|'1', 2)\)/
+    @db.sqls[2].should =~ /INSERT INTO albums_tags \((album_id, tag_id|tag_id, album_id)\) VALUES \((2, '3'|'3', 2)\)/
+    @db.sqls.length.should == 3
+  end
+
 end

data/spec/extensions/schema_spec.rb

@@ -23,22 +23,19 @@ describe Sequel::Model, "dataset & schema" do
 end
 
 describe Sequel::Model, "table_exists?" do
-
-  before(:each) do
+  before do
     MODEL_DB.reset
     @model = Class.new(Sequel::Model(:items))
   end
 
   it "should get the table name and question the model's db if table_exists?" do
-    @model.should_receive(:table_name).and_return(:items)
-    @model.db.should_receive(:table_exists?)
-    @model.table_exists?
+    @model.db.should_receive(:table_exists?).and_return(false)
+    @model.table_exists?.should == false
   end
 end
 
 describe Sequel::Model, "create_table and schema" do
-
-  before(:each) do
+  before do
     MODEL_DB.reset
     @model = Class.new(Sequel::Model) do
       set_schema(:items) do
@@ -84,19 +81,15 @@ describe Sequel::Model, "create_table and schema" do
 end
 
 describe Sequel::Model, "drop_table" do
-
-  before(:each) do
-    MODEL_DB.reset
+  before do
     @model = Class.new(Sequel::Model(:items))
+    MODEL_DB.reset
   end
 
   it "should get the drop table SQL for the associated table and then execute the SQL." do
-    @model.should_receive(:table_name).and_return(:items)
-    @model.db.should_receive(:drop_table_sql).with(:items)
-    @model.db.should_receive(:execute).and_return(:true)
     @model.drop_table
+    MODEL_DB.sqls.should == ['DROP TABLE items']
   end
-
 end
 
 describe Sequel::Model, "create_table!" do
@@ -106,9 +99,8 @@ describe Sequel::Model, "create_table!" do
   end
   
   it "should drop table if it exists and then create the table" do
-    @model.should_receive(:drop_table).and_return(true)
-    @model.should_receive(:create_table).and_return(true)
     @model.create_table!
+    MODEL_DB.sqls.should == ['DROP TABLE items', 'CREATE TABLE items ()']
   end
 end
 
@@ -120,13 +112,13 @@ describe Sequel::Model, "create_table?" do
   
   it "should not create the table if it already exists" do
     @model.should_receive(:table_exists?).and_return(true)
-    @model.should_not_receive(:create_table)
-    @model.create_table?.should == nil
+    @model.create_table?
+    MODEL_DB.sqls.should == []
   end
 
   it "should create the table if it doesn't exist" do
     @model.should_receive(:table_exists?).and_return(false)
-    @model.should_receive(:create_table).and_return(3)
-    @model.create_table?.should == 3
+    @model.create_table?
+    MODEL_DB.sqls.should == ['CREATE TABLE items ()']
   end
 end

data/spec/integration/dataset_test.rb

@@ -632,6 +632,23 @@ describe "Sequel::Dataset main SQL methods" do
     @ds.filter(:a=>20).or(:b=>15).all.should == [{:a=>20, :b=>30}]
     @ds.filter(:a=>10).or(:b=>15).all.should == []
   end
+
+  it "#select_group should work correctly" do
+    @ds.unordered!
+    @ds.select_group(:a).all.should == []
+    @ds.insert(20, 30)
+    @ds.select_group(:a).all.should == [{:a=>20}]
+    @ds.select_group(:b).all.should == [{:b=>30}]
+    @ds.insert(20, 40)
+    @ds.select_group(:a).all.should == [{:a=>20}]
+    @ds.order(:b).select_group(:b).all.should == [{:b=>30}, {:b=>40}]
+  end
+
+  it "#select_group should work correctly when aliasing" do
+    @ds.unordered!
+    @ds.insert(20, 30)
+    @ds.select_group(:b___c).all.should == [{:c=>30}]
+  end
   
   it "#having should work correctly" do
     @ds.unordered!

data/spec/integration/prepared_statement_test.rb

@@ -95,6 +95,13 @@ describe "Prepared Statements and Bound Arguments" do
     @ds.order(:id).map(:number).should == [10, 20]
   end
 
+  specify "should support bound variables with NULL values" do
+    @ds.delete
+    @ds.call(:insert, {:n=>nil}, :number=>@ds.ba(:$n))
+    @ds.count.should == 1
+    @ds.map(:number).should == [nil]
+  end
+
   specify "should have insert return primary key value when using bound arguments" do
     @ds.call(:insert, {:n=>20}, :number=>@ds.ba(:$n)).should == 2
     @ds.filter(:id=>2).first[:number].should == 20
@@ -172,6 +179,14 @@ describe "Prepared Statements and Bound Arguments" do
     @ds.order(:id).map(:number).should == [10, 20]
   end
 
+  specify "should support prepared statements with NULL values" do
+    @ds.delete
+    @ds.prepare(:insert, :insert_n, :number=>@ds.ba(:$n))
+    INTEGRATION_DB.call(:insert_n, :n=>nil)
+    @ds.count.should == 1
+    @ds.map(:number).should == [nil]
+  end
+
   specify "should have insert return primary key value when using prepared statements" do
     @ds.prepare(:insert, :insert_n, :number=>@ds.ba(:$n))
     INTEGRATION_DB.call(:insert_n, :n=>20).should == 2

data/spec/integration/schema_test.rb

@@ -183,6 +183,15 @@ describe "Database schema modifiers" do
     @db[:items].columns.should == [:b]
   end
 
+  specify "should have create_table? work correctly with indexes" do
+    @db.create_table!(:items){String :a, :index=>true}
+    @db.create_table?(:items){String :b, :index=>true}
+    @db[:items].columns.should == [:a]
+    @db.drop_table(:items) rescue nil
+    @db.create_table?(:items){String :b, :index=>true}
+    @db[:items].columns.should == [:b]
+  end
+
   specify "should rename tables correctly" do
     @db.drop_table(:items) rescue nil
     @db.create_table!(:items2){Integer :number}

data/spec/model/model_spec.rb

@@ -19,6 +19,27 @@ describe "Sequel::Model()" do
     c.table_name.should == :blah
   end
 
+  it "should return a model subclass with a dataset with the default database and given table name if given an SQL::Identifier" do
+    c = Sequel::Model(:blah.identifier)
+    c.superclass.should == Sequel::Model
+    c.db.should == @db
+    c.table_name.should == :blah.identifier
+  end
+
+  it "should return a model subclass with a dataset with the default database and given table name if given an SQL::QualifiedIdentifier" do
+    c = Sequel::Model(:blah.qualify(:boo))
+    c.superclass.should == Sequel::Model
+    c.db.should == @db
+    c.table_name.should == :blah.qualify(:boo)
+  end
+
+  it "should return a model subclass with a dataset with the default database and given table name if given an SQL::AliasedExpression" do
+    c = Sequel::Model(:blah.as(:boo))
+    c.superclass.should == Sequel::Model
+    c.db.should == @db
+    c.table_name.should == :boo
+  end
+
   it "should return a model subclass associated to the given database if given a database" do
     db = Sequel::Database.new
     c = Sequel::Model(db)
@@ -43,6 +64,27 @@ describe "Sequel::Model()" do
       end.should_not raise_error
     end
 
+    it "should work without raising an exception with an SQL::Identifier " do
+      proc do
+        class ::Album < Sequel::Model(:table.identifier); end
+        class ::Album < Sequel::Model(:table.identifier); end
+      end.should_not raise_error
+    end
+
+    it "should work without raising an exception with an SQL::QualifiedIdentifier " do
+      proc do
+        class ::Album < Sequel::Model(:table.qualify(:schema)); end
+        class ::Album < Sequel::Model(:table.qualify(:schema)); end
+      end.should_not raise_error
+    end
+
+    it "should work without raising an exception with an SQL::AliasedExpression" do
+      proc do
+        class ::Album < Sequel::Model(:table.as(:alias)); end
+        class ::Album < Sequel::Model(:table.as(:alias)); end
+      end.should_not raise_error
+    end
+
     it "should work without raising an exception with a database" do
       proc do
         class ::Album < Sequel::Model(@db); end
@@ -112,6 +154,24 @@ describe Sequel::Model, "dataset & schema" do
     @model.table_name.should == :foo
   end
 
+  it "set_dataset should take an SQL::Identifier" do
+    @model.db = MODEL_DB
+    @model.set_dataset(:foo.identifier)
+    @model.table_name.should == :foo.identifier
+  end
+
+  it "set_dataset should take an SQL::QualifiedIdentifier" do
+    @model.db = MODEL_DB
+    @model.set_dataset(:foo.qualify(:bar))
+    @model.table_name.should == :foo.qualify(:bar)
+  end
+
+  it "set_dataset should take an SQL::AliasedExpression" do
+    @model.db = MODEL_DB
+    @model.set_dataset(:foo.as(:bar))
+    @model.table_name.should == :bar
+  end
+
   it "table_name should respect table aliases" do
     @model.set_dataset(:foo___x)
     @model.table_name.should == :x

data/spec/model/plugins_spec.rb

@@ -233,4 +233,21 @@ describe Sequel::Model, ".plugin" do
     end
     lambda{@c.plugin m}.should_not raise_error
   end
+
+  it "should not raise an error if plugin submodule names exist higher up in the namespace hierarchy" do
+    class ::ClassMethods; end
+    @c.plugin(m = Module.new)
+    Object.send(:remove_const, :ClassMethods)
+    @c.plugins.should include(m)
+
+    class ::InstanceMethods; end
+    @c.plugin(m = Module.new)
+    Object.send(:remove_const, :InstanceMethods)
+    @c.plugins.should include(m)
+
+    class ::DatasetMethods; end
+    @c.plugin(m = Module.new)
+    Object.send(:remove_const, :DatasetMethods)
+    @c.plugins.should include(m)
+  end
 end

data/spec/model/validations_spec.rb

@@ -61,6 +61,17 @@ describe Sequel::Model::Errors do
     msgs.should include('blow blieuh', 'blow blich', 'blay bliu')
   end
 
+  specify "should not add column names for LiteralStrings" do
+    @errors.full_messages.should == []
+    
+    @errors[:blow] << 'blieuh'
+    @errors[:blow] << 'blich'.lit
+    @errors[:blay] << 'bliu'
+    msgs = @errors.full_messages
+    msgs.size.should == 3
+    msgs.should include('blow blieuh', 'blich', 'blay bliu')
+  end
+
   specify "should return the number of error messages using #count" do
     @errors.count.should == 0
     @errors.add(:a, 'b')