sequel 2.12.0 → 3.0.0

data/spec/core/expression_filters_spec.rb

@@ -202,6 +202,12 @@ context "Blockless Ruby Filters" do
     @d.l(:x => nil, :y => [1,2,3])[1...-1].split(' AND ').sort.should == ['(x IS NULL)', '(y IN (1, 2, 3))']
   end
   
+  it "should support sql_expr on hashes" do
+    @d.l({:x => 100, :y => 'a'}.sql_expr)[1...-1].split(' AND ').sort.should == ['(x = 100)', '(y = \'a\')']
+    @d.l({:x => true, :y => false}.sql_expr)[1...-1].split(' AND ').sort.should == ['(x IS TRUE)', '(y IS FALSE)']
+    @d.l({:x => nil, :y => [1,2,3]}.sql_expr)[1...-1].split(' AND ').sort.should == ['(x IS NULL)', '(y IN (1, 2, 3))']
+  end
+  
   it "should support sql_negate on hashes" do
     @d.l({:x => 100, :y => 'a'}.sql_negate)[1...-1].split(' AND ').sort.should == ['(x != 100)', '(y != \'a\')']
     @d.l({:x => true, :y => false}.sql_negate)[1...-1].split(' AND ').sort.should == ['(x IS NOT TRUE)', '(y IS NOT FALSE)']
@@ -226,6 +232,12 @@ context "Blockless Ruby Filters" do
     @d.l([[:x, nil], [:y, [1,2,3]]]).should == '((x IS NULL) AND (y IN (1, 2, 3)))'
   end
   
+  it "should support sql_expr on arrays with all two pairs" do
+    @d.l([[:x, 100],[:y, 'a']].sql_expr).should == '((x = 100) AND (y = \'a\'))'
+    @d.l([[:x, true], [:y, false]].sql_expr).should == '((x IS TRUE) AND (y IS FALSE))'
+    @d.l([[:x, nil], [:y, [1,2,3]]].sql_expr).should == '((x IS NULL) AND (y IN (1, 2, 3)))'
+  end
+  
   it "should support sql_negate on arrays with all two pairs" do
     @d.l([[:x, 100],[:y, 'a']].sql_negate).should == '((x != 100) AND (y != \'a\'))'
     @d.l([[:x, true], [:y, false]].sql_negate).should == '((x IS NOT TRUE) AND (y IS NOT FALSE))'

data/spec/core/schema_generator_spec.rb

@@ -10,30 +10,27 @@ describe Sequel::Schema::Generator do
       check 'price > 100'
       constraint(:xxx) {:yyy == :zzz}
       index :title
-      index [:title, :body]
+      index [:title, :body], :unique => true
       foreign_key :node_id, :nodes
       primary_key [:title, :parent_id], :name => :cpk
       foreign_key [:node_id, :prop_id], :nodes_props, :name => :cfk
     end
-    @columns, @indexes = @generator.create_info
+    @columns, @indexes, @constraints = @generator.columns, @generator.indexes, @generator.constraints
   end
   
-  {:name => :id, :primary_key => true}.each do |column, expected|
-    it "uses default primary key #{column}" do
-      @columns.first[column].should == expected
-    end
+  it "should primary key column first" do
+    @columns.first[:name].should == :id
+    @columns.first[:primary_key].should == true
+    @columns[3][:name].should == :parent_id
+    @columns[3][:primary_key].should == nil
   end
   
-  it "counts primary key, column and constraint definitions as columns" do
-    @columns.size.should == 9
+  it "counts definitions correctly" do
+    @columns.size.should == 5
+    @indexes.size.should == 2
+    @constraints.size.should == 4
   end
   
-  it "places primary key first" do
-    @columns[0][:primary_key].should     be_true
-    @columns[1][:primary_key].should_not be_true
-    @columns[2][:primary_key].should_not be_true
-  end
-
   it "retrieves primary key name" do
     @generator.primary_key_name.should == :id
   end
@@ -48,14 +45,14 @@ describe Sequel::Schema::Generator do
   it "creates foreign key column" do
     @columns[3][:name].should == :parent_id
     @columns[3][:type].should == Integer
-    @columns[6][:name].should == :node_id
-    @columns[6][:type].should == Integer
+    @columns[4][:name].should == :node_id
+    @columns[4][:type].should == Integer
   end
   
   it "uses table for foreign key columns, if specified" do
-    @columns[6][:table].should == :nodes
     @columns[3][:table].should == nil
-    @columns[8][:table].should == :nodes_props
+    @columns[4][:table].should == :nodes
+    @constraints[3][:table].should == :nodes_props
   end
   
   it "finds columns" do
@@ -66,24 +63,22 @@ describe Sequel::Schema::Generator do
   end
   
   it "creates constraints" do
-    @columns[4][:name].should == nil
-    @columns[4][:type].should == :check
-    @columns[4][:check].should == ['price > 100']
+    @constraints[0][:name].should == nil
+    @constraints[0][:type].should == :check
+    @constraints[0][:check].should == ['price > 100']
 
-    @columns[5][:name].should == :xxx
-    @columns[5][:type].should == :check
-    @columns[5][:check].should be_a_kind_of(Proc)
+    @constraints[1][:name].should == :xxx
+    @constraints[1][:type].should == :check
+    @constraints[1][:check].should be_a_kind_of(Proc)
 
-    @columns[7][:name].should == :cpk
-    @columns[7][:type].should == :check
-    @columns[7][:constraint_type].should == :primary_key
-    @columns[7][:columns].should == [ :title, :parent_id ]
+    @constraints[2][:name].should == :cpk
+    @constraints[2][:type].should == :primary_key
+    @constraints[2][:columns].should == [ :title, :parent_id ]
 
-    @columns[8][:name].should == :cfk
-    @columns[8][:type].should == :check
-    @columns[8][:constraint_type].should == :foreign_key
-    @columns[8][:columns].should == [ :node_id, :prop_id ]
-    @columns[8][:table].should == :nodes_props
+    @constraints[3][:name].should == :cfk
+    @constraints[3][:type].should == :foreign_key
+    @constraints[3][:columns].should == [ :node_id, :prop_id ]
+    @constraints[3][:table].should == :nodes_props
   end
   
   it "creates indexes" do
@@ -103,6 +98,7 @@ describe Sequel::Schema::AlterTableGenerator do
       set_column_default :eee, 1
       add_index [:fff, :ggg]
       drop_index :hhh
+      drop_index :hhh, :name=>:blah_blah
       add_full_text_index :blah
       add_spatial_index :geom
       add_index :blah, :type => :hash
@@ -126,24 +122,25 @@ describe Sequel::Schema::AlterTableGenerator do
       {:op => :set_column_default, :name => :eee, :default => 1},
       {:op => :add_index, :columns => [:fff, :ggg]},
       {:op => :drop_index, :columns => [:hhh]},
+      {:op => :drop_index, :columns => [:hhh], :name=>:blah_blah},
       {:op => :add_index, :columns => [:blah], :type => :full_text},
       {:op => :add_index, :columns => [:geom], :type => :spatial},
       {:op => :add_index, :columns => [:blah], :type => :hash},
       {:op => :add_index, :columns => [:blah], :where => {:something => true}},
-      {:op => :add_constraint, :type => :check, :constraint_type => :check, :name => :con1, :check => ['fred > 100']},
+      {:op => :add_constraint, :type => :check, :name => :con1, :check => ['fred > 100']},
       {:op => :drop_constraint, :name => :con2},
-      {:op => :add_constraint, :type => :check, :constraint_type => :unique, :name => :con3, :columns => [:aaa, :bbb, :ccc]},
+      {:op => :add_constraint, :type => :unique, :name => :con3, :columns => [:aaa, :bbb, :ccc]},
       {:op => :add_column, :name => :id, :type => Integer, :primary_key=>true, :auto_increment=>true},
       {:op => :add_column, :name => :node_id, :type => Integer, :table=>:nodes},
-      {:op => :add_constraint, :type => :check, :constraint_type => :primary_key, :columns => [:aaa, :bbb]},
-      {:op => :add_constraint, :type => :check, :constraint_type => :foreign_key, :columns => [:node_id, :prop_id], :table => :nodes_props}
+      {:op => :add_constraint, :type => :primary_key, :columns => [:aaa, :bbb]},
+      {:op => :add_constraint, :type => :foreign_key, :columns => [:node_id, :prop_id], :table => :nodes_props}
     ]
   end
 end
 
 describe "Sequel::Schema::Generator generic type methods" do
-  before do
-    @generator = Sequel::Schema::Generator.new(SchemaDummyDatabase.new) do
+  it "should store the type class in :type for each column" do
+    Sequel::Schema::Generator.new(SchemaDummyDatabase.new) do
       String :a
       Integer :b
       Fixnum :c
@@ -157,11 +154,6 @@ describe "Sequel::Schema::Generator generic type methods" do
       File :k
       TrueClass :l
       FalseClass :m
-    end
-    @columns, @indexes = @generator.create_info
-  end
-  
-  it "should store the type class in :type for each column" do
-    @columns.map{|c| c[:type]}.should == [String, Integer, Fixnum, Bignum, Float, BigDecimal, Date, DateTime, Time, Numeric, File, TrueClass, FalseClass]
+    end.columns.map{|c| c[:type]}.should == [String, Integer, Fixnum, Bignum, Float, BigDecimal, Date, DateTime, Time, Numeric, File, TrueClass, FalseClass]
   end
 end

data/spec/core/schema_spec.rb

@@ -61,6 +61,21 @@ context "DB#create_table" do
     @db.sqls.should == ['CREATE TABLE cats (o varchar(255) PRIMARY KEY AUTOINCREMENT, a varchar(255), b integer, c integer, d bigint, e double precision, f numeric, g date, h timestamp, i timestamp, j numeric, k blob, l boolean, m boolean, n integer, p date REFERENCES f)']
   end
 
+  specify "should allow the use of modifiers with ruby class types" do
+    @db.create_table(:cats) do
+      String :a, :size=>50
+      String :b, :text=>true
+      String :c, :fixed=>true, :size=>40
+      Time :d, :only_time=>true
+      BigDecimal :e, :size=>[11,2]
+    end
+    @db.sqls.should == ['CREATE TABLE cats (a varchar(50), b text, c char(40), d time, e numeric(11, 2))']
+  end
+
+  specify "should raise an error if you use a ruby class that isn't handled" do
+    proc{@db.create_table(:cats){column :a, Class}}.should raise_error(Sequel::Error)
+  end
+
   specify "should accept primary key definition" do
     @db.create_table(:cats) do
       primary_key :id
@@ -404,6 +419,10 @@ context "DB#create_table" do
     @db.sqls.should == ["CREATE TABLE cats (CONSTRAINT blah_blah CHECK ((x > 0) AND (y < 1)))"]
   end
 
+  specify "should raise an error if an invalid constraint type is used" do
+    proc{@db.create_table(:cats){unique [:a, :b], :type=>:bb}}.should raise_error(Sequel::Error)
+  end
+
   specify "should accept composite primary keys" do
     @db.create_table(:cats) do
       integer :a
@@ -646,6 +665,13 @@ context "DB#alter_table" do
     @db.sqls.should == ["DROP INDEX cats_name_index"]
   end
 
+  specify "should support drop_index with a given name" do
+    @db.alter_table(:cats) do
+      drop_index :name, :name=>:blah_blah
+    end
+    @db.sqls.should == ["DROP INDEX blah_blah"]
+  end
+
   specify "should support rename_column" do
     @db.alter_table(:cats) do
       rename_column :name, :old_name
@@ -710,22 +736,6 @@ context "Schema Parser" do
     @sqls.should == ['x', 'x']
   end
 
-  deprec_specify "should parse the schema correctly for all tables" do
-    sqls = @sqls
-    proc{@db.schema}.should raise_error(Sequel::Error)
-    @db.meta_def(:tables){[:x]}
-    @db.meta_def(:schema_parse_table) do |t, opts|
-      sqls << t
-      [[:x, {:db_type=>t.to_s}]]
-    end
-    @db.schema.should == {'x'=>[[:x, {:db_type=>"x"}]]}
-    @sqls.should == ['x']
-    @db.schema.should == {'x'=>[[:x, {:db_type=>"x"}]]}
-    @sqls.should == ['x']
-    @db.schema(nil, :reload=>true).should == {'x'=>[[:x, {:db_type=>"x"}]]}
-    @sqls.should == ['x', 'x']
-  end
-
   specify "should convert various types of table name arguments" do
     @db.meta_def(:schema_parse_table) do |t, opts|
       [[t, {:db_type=>t}]]

data/spec/core/spec_helper.rb

@@ -6,31 +6,6 @@ end
 
 Sequel.virtual_row_instance_eval = true
 
-module Spec::Example::ExampleMethods
-  def deprec
-    output = Sequel::Deprecation.output = nil 
-    begin
-      yield
-    ensure
-      Sequel::Deprecation.output = output
-    end 
-  end 
-end
-
-module Spec::Example::ExampleGroupMethods
-  def deprec_specify(*args, &block)
-    specify(*args) do
-      output = Sequel::Deprecation.output
-      Sequel::Deprecation.output = nil
-      begin
-        instance_eval(&block)
-      ensure
-        Sequel::Deprecation.output = output
-      end
-    end
-  end
-end
-
 class MockDataset < Sequel::Dataset
   def insert(*args)
     @db.execute insert_sql(*args)

data/spec/extensions/inflector_spec.rb

@@ -86,9 +86,6 @@ describe String::Inflections do
     String.inflections.plurals.replace(@plurals)
     String.inflections.singulars.replace(@singulars)
     String.inflections.uncountables.replace(@uncountables)
-    Sequel.inflections.plurals.replace(@plurals)
-    Sequel.inflections.singulars.replace(@singulars)
-    Sequel.inflections.uncountables.replace(@uncountables)
   end
 
   it "should be possible to clear the list of singulars, plurals, and uncountables" do

data/spec/extensions/schema_dumper_spec.rb

@@ -0,0 +1,292 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe "Sequel::Schema::Generator dump methods" do
+  before do
+    @d = Sequel::Database.new
+    @g = Sequel::Schema::Generator
+  end
+
+  it "should allow the same table information to be converted to a string for evaling inside of another instance with the same result" do
+    g = @g.new(@d) do
+      Integer :a
+      varchar :b
+      column :dt, DateTime
+      column :vc, :varchar
+      primary_key :c
+      foreign_key :d, :a
+      foreign_key :e
+      foreign_key [:d, :e], :name=>:cfk
+      constraint :blah, "a=1"
+      check :a=>1
+      unique [:e]
+      index :a
+      index [:c, :e]
+      index [:b, :c], :type=>:hash
+      index [:d], :unique=>true
+      spatial_index :a
+      full_text_index [:b, :c]
+    end
+    g2 = @g.new(@d) do
+      instance_eval(g.dump_columns, __FILE__, __LINE__)
+      instance_eval(g.dump_constraints, __FILE__, __LINE__)
+      instance_eval(g.dump_indexes, __FILE__, __LINE__)
+    end
+    g.columns.should == g2.columns
+    g.constraints.should == g2.constraints
+    g.indexes.should == g2.indexes
+  end
+
+  it "should allow dumping indexes as separate add_index and drop_index methods" do
+    g = @g.new(@d) do
+      index :a
+      index [:c, :e], :name=>:blah
+      index [:b, :c], :unique=>true
+    end
+
+    t = <<END_CODE
+add_index :t, [:a]
+add_index :t, [:c, :e], :name=>:blah
+add_index :t, [:b, :c], :unique=>true
+END_CODE
+    g.dump_indexes(:add_index=>:t).should == t.strip
+
+    t = <<END_CODE
+drop_index :t, [:a]
+drop_index :t, [:c, :e], :name=>:blah
+drop_index :t, [:b, :c], :unique=>true
+END_CODE
+    g.dump_indexes(:drop_index=>:t).should == t.strip
+  end
+
+  it "should raise an error if you try to dump a Generator that uses a constraint with a proc" do
+    proc{@g.new(@d){check{a>1}}.dump_constraints}.should raise_error(Sequel::Error)
+  end
+end
+
+describe "Sequel::Database dump methods" do
+  before do
+    @d = Sequel::Database.new
+    @d.meta_def(:tables){[:t1, :t2]}
+    @d.meta_def(:schema) do |t, *o|
+      case t
+      when :t1
+        [[:c1, {:db_type=>'integer', :primary_key=>true, :allow_null=>false}],
+         [:c2, {:db_type=>'varchar(20)', :allow_null=>true}]]
+      when :t2
+        [[:c1, {:db_type=>'integer', :primary_key=>true, :allow_null=>false}],
+         [:c2, {:db_type=>'numeric', :primary_key=>true, :allow_null=>false}]]
+      when :t3
+        [[:c1, {:db_type=>'date', :default=>"'now()'", :allow_null=>true}],
+         [:c2, {:db_type=>'datetime', :allow_null=>false}]]
+      when :t4
+        [[:c1, {:db_type=>'boolean', :default=>"false", :allow_null=>true}],
+         [:c2, {:db_type=>'boolean', :default=>"true", :allow_null=>true}],
+         [:c3, {:db_type=>'varchar', :default=>"'blah'", :allow_null=>true}],
+         [:c4, {:db_type=>'integer', :default=>"35", :allow_null=>true}]]
+      when :t5
+        [[:c1, {:db_type=>'blahblah', :allow_null=>true}]]
+      end
+    end
+  end
+
+  it "should support dumping table schemas as create_table method calls" do
+    @d.dump_table_schema(:t1).should == "create_table(:t1) do\n  primary_key :c1\n  String :c2, :size=>20\nend"
+  end
+
+  it "should use a composite primary_key calls if there is a composite primary key" do
+    @d.dump_table_schema(:t2).should == "create_table(:t2) do\n  Integer :c1, :null=>false\n  BigDecimal :c2, :null=>false\n  \n  primary_key [:c1, :c2]\nend"
+  end
+
+  it "should include index information if available" do
+    @d.meta_def(:indexes) do |t|
+      {:i1=>{:columns=>[:c1], :unique=>false},
+       :t1_c2_c1_index=>{:columns=>[:c2, :c1], :unique=>true}}
+    end
+    @d.dump_table_schema(:t1).should == "create_table(:t1) do\n  primary_key :c1\n  String :c2, :size=>20\n  \n  index [:c1], :name=>:i1\n  index [:c2, :c1], :unique=>true\nend"
+  end
+
+  it "should support dumping the whole database as a migration" do
+    @d.dump_schema_migration.should == <<-END_MIG
+Class.new(Sequel::Migration) do
+  def up
+    create_table(:t1) do
+      primary_key :c1
+      String :c2, :size=>20
+    end
+    
+    create_table(:t2) do
+      Integer :c1, :null=>false
+      BigDecimal :c2, :null=>false
+      
+      primary_key [:c1, :c2]
+    end
+  end
+  
+  def down
+    drop_table(:t1, :t2)
+  end
+end
+END_MIG
+  end
+
+  it "should honor the :same_db option to not convert types" do
+    @d.dump_table_schema(:t1, :same_db=>true).should == "create_table(:t1) do\n  primary_key :c1\n  column :c2, \"varchar(20)\"\nend"
+    @d.dump_schema_migration(:same_db=>true).should == <<-END_MIG
+Class.new(Sequel::Migration) do
+  def up
+    create_table(:t1) do
+      primary_key :c1
+      column :c2, "varchar(20)"
+    end
+    
+    create_table(:t2) do
+      column :c1, "integer", :null=>false
+      column :c2, "numeric", :null=>false
+      
+      primary_key [:c1, :c2]
+    end
+  end
+  
+  def down
+    drop_table(:t1, :t2)
+  end
+end
+END_MIG
+  end
+
+  it "should honor the :indexes => false option to not include indexes" do
+    @d.meta_def(:indexes) do |t|
+      {:i1=>{:columns=>[:c1], :unique=>false},
+       :t1_c2_c1_index=>{:columns=>[:c2, :c1], :unique=>true}}
+    end
+    @d.dump_table_schema(:t1, :indexes=>false).should == "create_table(:t1) do\n  primary_key :c1\n  String :c2, :size=>20\nend"
+    @d.dump_schema_migration(:indexes=>false).should == <<-END_MIG
+Class.new(Sequel::Migration) do
+  def up
+    create_table(:t1) do
+      primary_key :c1
+      String :c2, :size=>20
+    end
+    
+    create_table(:t2) do
+      Integer :c1, :null=>false
+      BigDecimal :c2, :null=>false
+      
+      primary_key [:c1, :c2]
+    end
+  end
+  
+  def down
+    drop_table(:t1, :t2)
+  end
+end
+END_MIG
+  end
+
+  it "should support dumping just indexes as a migration" do
+    @d.meta_def(:tables){[:t1]}
+    @d.meta_def(:indexes) do |t|
+      {:i1=>{:columns=>[:c1], :unique=>false},
+       :t1_c2_c1_index=>{:columns=>[:c2, :c1], :unique=>true}}
+    end
+    @d.dump_indexes_migration.should == <<-END_MIG
+Class.new(Sequel::Migration) do
+  def up
+    add_index :t1, [:c1], :name=>:i1
+    add_index :t1, [:c2, :c1], :unique=>true
+  end
+  
+  def down
+    drop_index :t1, [:c1], :name=>:i1
+    drop_index :t1, [:c2, :c1], :unique=>true
+  end
+end
+END_MIG
+  end
+
+  it "should handle not null values and defaults" do
+    @d.dump_table_schema(:t3).should == "create_table(:t3) do\n  Date :c1, :default=>\"'now()'\".lit\n  DateTime :c2, :null=>false\nend"
+  end
+
+  it "should handle converting common defaults" do
+    @d.dump_table_schema(:t4).should == "create_table(:t4) do\n  TrueClass :c1, :default=>false\n  TrueClass :c2, :default=>true\n  String :c3, :default=>\"'blah'\".lit\n  Integer :c4, :default=>35\nend"
+  end
+
+  it "should convert unknown database types to strings" do
+    @d.dump_table_schema(:t5).should == "create_table(:t5) do\n  String :c1\nend"
+  end
+
+  it "should convert many database types to ruby types" do
+    types = %w"mediumint smallint int integer mediumint(6) smallint(7) int(8) integer(9)
+      tinyint tinyint(1) bigint bigint(20) real float double boolean tinytext mediumtext
+      longtext text clob date datetime timestamp time char character
+      varchar varchar(255) varchar(30) bpchar string money
+      decimal decimal(10,2) numeric numeric(15,3) number bytea tinyblob mediumblob longblob
+      blob varbinary varbinary(10) binary binary(20) year" +
+      ["double precision", "timestamp with time zone", "timestamp without time zone",
+       "time with time zone", "time without time zone", "character varying(20)"]
+    @d.meta_def(:schema) do |t, *o|
+      i = 0
+      types.map{|x| [:"c#{i+=1}", {:db_type=>x, :allow_null=>true}]}
+    end
+    table = <<END_MIG
+create_table(:x) do
+  Integer :c1
+  Integer :c2
+  Integer :c3
+  Integer :c4
+  Integer :c5
+  Integer :c6
+  Integer :c7
+  Integer :c8
+  TrueClass :c9
+  TrueClass :c10
+  Bignum :c11
+  Bignum :c12
+  Float :c13
+  Float :c14
+  Float :c15
+  TrueClass :c16
+  String :c17, :text=>true
+  String :c18, :text=>true
+  String :c19, :text=>true
+  String :c20, :text=>true
+  String :c21, :text=>true
+  Date :c22
+  DateTime :c23
+  DateTime :c24
+  Time :c25, :only_time=>true
+  String :c26, :fixed=>true
+  String :c27, :fixed=>true
+  String :c28
+  String :c29
+  String :c30, :size=>30
+  String :c31
+  String :c32
+  BigDecimal :c33, :size=>[19, 2]
+  BigDecimal :c34
+  BigDecimal :c35, :size=>[10, 2]
+  BigDecimal :c36
+  BigDecimal :c37, :size=>[15, 3]
+  BigDecimal :c38
+  File :c39
+  File :c40
+  File :c41
+  File :c42
+  File :c43
+  File :c44
+  File :c45, :size=>10
+  File :c46
+  File :c47, :size=>20
+  Integer :c48
+  Float :c49
+  DateTime :c50
+  DateTime :c51
+  Time :c52, :only_time=>true
+  Time :c53, :only_time=>true
+  String :c54, :size=>20
+end
+END_MIG
+    @d.dump_table_schema(:x).should == table.chomp
+  end
+end