sequel 2.12.0 → 3.0.0

data/spec/adapters/sqlite_spec.rb

@@ -67,70 +67,6 @@ context "An SQLite database" do
     proc {@db.temp_store = :invalid}.should raise_error(Sequel::Error)
   end
   
-  specify "should be able to execute transactions" do
-    @db.transaction do
-      @db.create_table!(:t) {text :name}
-    end
-    
-    @db.tables.should include(:t)
-
-    proc {@db.transaction do
-      @db.create_table!(:u) {text :name}
-      raise ArgumentError
-    end}.should raise_error(ArgumentError)
-    # no commit
-    @db.tables.should_not include(:u)
-
-    proc {@db.transaction do
-      @db.create_table!(:v) {text :name}
-      raise Sequel::Rollback
-    end}.should_not raise_error
-    # no commit
-    @db.tables.should_not include(:r)
-  end
-
-  specify "should support nested transactions" do
-    @db.transaction do
-      @db.transaction do
-        @db.create_table!(:t) {text :name}
-      end
-    end
-    
-    @db.tables.should include(:t)
-
-    proc {@db.transaction do
-      @db.create_table!(:v) {text :name}
-      @db.transaction do
-        raise Sequel::Rollback # should roll back the top-level transaction
-      end
-    end}.should_not raise_error
-    # no commit
-    @db.tables.should_not include(:v)
-  end
-  
-  specify "should handle returning inside of transaction by committing" do
-    @db.create_table!(:items2){text :name}
-    def @db.ret_commit
-      transaction do
-        self[:items2] << {:name => 'abc'}
-        return
-        self[:items2] << {:name => 'd'}
-      end
-    end
-    @db[:items2].count.should == 0
-    @db.ret_commit
-    @db[:items2].count.should == 1
-    @db.ret_commit
-    @db[:items2].count.should == 2
-    proc do
-      @db.transaction do
-        raise Interrupt, 'asdf'
-      end
-    end.should raise_error(Interrupt)
-
-    @db[:items2].count.should == 2
-  end
-
   specify "should support timestamps and datetimes and respect datetime_class" do
     @db.create_table!(:time){timestamp :t; datetime :d}
     t1 = Time.at(1)
@@ -156,15 +92,6 @@ context "An SQLite database" do
     ]
   end
   
-  specify "should catch invalid SQL errors and raise them as Error" do
-    proc {@db.execute 'blah blah'}.should raise_error(Sequel::Error)
-    proc {@db.execute_insert 'blah blah'}.should raise_error(Sequel::Error)
-  end
-  
-  specify "should not swallow non-SQLite based exceptions" do
-    proc {@db.pool.hold{raise Interrupt, "test"}}.should raise_error(Interrupt)
-  end
-
   specify "should correctly parse the schema" do
     @db.create_table!(:time2) {timestamp :t}
     @db.schema(:time2, :reload=>true).should == [[:t, {:type=>:datetime, :allow_null=>true, :default=>nil, :db_type=>"timestamp", :primary_key=>false}]]
@@ -173,61 +100,9 @@ end
 
 context "An SQLite dataset" do
   before do
-    SQLITE_DB.create_table! :items do
-      integer :id, :primary_key => true, :auto_increment => true
-      text :name
-      float :value
-    end
     @d = SQLITE_DB[:items]
-    @d.delete # remove all records
-  end
-  
-  specify "should return the correct records" do
-    @d.to_a.should == []
-    @d << {:name => 'abc', :value => 1.23}
-    @d << {:name => 'abc', :value => 4.56}
-    @d << {:name => 'def', :value => 7.89}
-    @d.select(:name, :value).to_a.sort_by {|h| h[:value]}.should == [
-      {:name => 'abc', :value => 1.23},
-      {:name => 'abc', :value => 4.56},
-      {:name => 'def', :value => 7.89}
-    ]
-  end
-  
-  specify "should return the correct record count" do
-    @d.count.should == 0
-    @d << {:name => 'abc', :value => 1.23}
-    @d << {:name => 'abc', :value => 4.56}
-    @d << {:name => 'def', :value => 7.89}
-    @d.count.should == 3
-  end
-
-  specify "should return the last inserted id when inserting records" do
-    id = @d << {:name => 'abc', :value => 1.23}
-    id.should == @d.first[:id]
   end
   
-  specify "should update records correctly" do
-    @d << {:name => 'abc', :value => 1.23}
-    @d << {:name => 'abc', :value => 4.56}
-    @d << {:name => 'def', :value => 7.89}
-    @d.filter(:name => 'abc').update(:value => 5.3)
-    
-    # the third record should stay the same
-    @d[:name => 'def'][:value].should == 7.89
-    @d.filter(:value => 5.3).count.should == 2
-  end
-  
-  specify "should delete records correctly" do
-    @d << {:name => 'abc', :value => 1.23}
-    @d << {:name => 'abc', :value => 4.56}
-    @d << {:name => 'def', :value => 7.89}
-    @d.filter(:name => 'abc').delete
-    
-    @d.count.should == 1
-    @d.first[:name].should == 'def'
-  end
-
   specify "should handle string pattern matches correctly" do
     @d.literal(:x.like('a')).should == "(x LIKE 'a')"
     @d.literal(~:x.like('a')).should == "NOT (x LIKE 'a')"
@@ -283,43 +158,12 @@ context "An SQLite dataset AS clause" do
   end
 end
 
-context "An SQLite dataset" do
-  before do
-    SQLITE_DB.create_table! :items do
-      integer :id, :primary_key => true, :auto_increment => true
-      text :name
-      float :value
-    end
-    @d = SQLITE_DB[:items]
-    @d.delete # remove all records
-    @d << {:name => 'abc', :value => 1.23}
-    @d << {:name => 'def', :value => 4.56}
-    @d << {:name => 'ghi', :value => 7.89}
-  end
-  
-  specify "should correctly return avg" do
-    @d.avg(:value).to_s.should == ((1.23 + 4.56 + 7.89) / 3).to_s
-  end
-  
-  specify "should correctly return sum" do
-    @d.sum(:value).to_s.should == (1.23 + 4.56 + 7.89).to_s
-  end
-  
-  specify "should correctly return max" do
-    @d.max(:value).to_s.should == 7.89.to_s
-  end
-  
-  specify "should correctly return min" do
-    @d.min(:value).to_s.should == 1.23.to_s
-  end
-end
-
 context "SQLite::Dataset#delete" do
   before do
     SQLITE_DB.create_table! :items do
-      integer :id, :primary_key => true, :auto_increment => true
-      text :name
-      float :value
+      primary_key :id
+      String :name
+      Float :value
     end
     @d = SQLITE_DB[:items]
     @d.delete # remove all records
@@ -349,9 +193,9 @@ end
 context "SQLite::Dataset#update" do
   before do
     SQLITE_DB.create_table! :items do
-      integer :id, :primary_key => true, :auto_increment => true
-      text :name
-      float :value
+      primary_key :id
+      String :name
+      Float :value
     end
     @d = SQLITE_DB[:items]
     @d.delete # remove all records
@@ -372,24 +216,22 @@ end
 context "SQLite dataset" do
   before do
     SQLITE_DB.create_table! :test do
-      integer :id, :primary_key => true, :auto_increment => true
-      text :name
-      float :value
+      primary_key :id
+      String :name
+      Float :value
     end
     SQLITE_DB.create_table! :items do
-      integer :id, :primary_key => true, :auto_increment => true
-      text :name
-      float :value
+      primary_key :id
+      String :name
+      Float :value
     end
     @d = SQLITE_DB[:items]
-    @d.delete # remove all records
     @d << {:name => 'abc', :value => 1.23}
     @d << {:name => 'def', :value => 4.56}
     @d << {:name => 'ghi', :value => 7.89}
   end
-  
   after do
-    SQLITE_DB.drop_table :test
+    SQLITE_DB.drop_table(:test, :items)
   end
   
   specify "should be able to insert from a subquery" do

data/spec/core/connection_pool_spec.rb

@@ -55,11 +55,22 @@ context "A connection pool handling connections" do
     @cpool.hold {:block_return}.should == :block_return
   end
 
+  if RUBY_VERSION < '1.9.0' and (!defined?(RUBY_ENGINE) or RUBY_ENGINE != 'jruby')
+    specify "#hold should remove dead threads from the pool if it reaches its max_size" do
+      Thread.new{@cpool.hold{Thread.current.exit!}}.join
+      @cpool.allocated.keys.map{|t| t.alive?}.should == [false]
+
+      Thread.new{@cpool.hold{Thread.current.exit!}}.join
+      @cpool.allocated.keys.map{|t| t.alive?}.should == [false, false]
+
+      Thread.new{@cpool.hold{}}.join
+      @cpool.allocated.should == {}
+    end
+  end
+
   specify "#make_new should not make more than max_size connections" do
-    @cpool.send(:make_new, :default).should == :got_connection
-    @cpool.send(:make_new, :default).should == :got_connection
-    @cpool.send(:make_new, :default).should == nil
-    @cpool.created_count.should == 2
+    50.times{Thread.new{@cpool.hold{sleep 0.01}}}
+    @cpool.created_count.should == @max_size
   end
 
   specify ":disconnection_proc option should set the disconnection proc to use" do

data/spec/core/core_sql_spec.rb

@@ -63,50 +63,6 @@ context "Array#sql_array" do
   end
 end
 
-context "Array#to_sql" do
-  deprec_specify "should concatenate multiple lines into a single string" do
-    "SELECT * \r\nFROM items\r\n WHERE a = 1".split.to_sql. \
-      should == 'SELECT * FROM items WHERE a = 1'
-  end
-  
-  deprec_specify "should remove superfluous white space and line breaks" do
-    "\tSELECT * \n FROM items    ".split.to_sql. \
-      should == 'SELECT * FROM items'
-  end
-  
-  deprec_specify "should remove ANSI SQL comments" do
-    "SELECT *   --comment\r\n  FROM items\r\n  --comment".split.to_sql. \
-      should == 'SELECT * FROM items'
-  end
-  
-  deprec_specify "should remove C-style comments" do
-    "SELECT * \r\n /* comment comment\r\n comment\r\n FROM items */\r\n FROM items\r\n--comment".split.to_sql. \
-      should == 'SELECT * FROM items'
-  end
-end
-
-context "String#to_sql" do
-  deprec_specify "should concatenate multiple lines into a single string" do
-    "SELECT * \r\nFROM items\r\nWHERE a = 1".to_sql. \
-      should == 'SELECT * FROM items WHERE a = 1'
-  end
-  
-  deprec_specify "should remove superfluous white space and line breaks" do
-    "\tSELECT * \r\n FROM items    ".to_sql. \
-      should == 'SELECT * FROM items'
-  end
-  
-  deprec_specify "should remove ANSI SQL comments" do
-    "SELECT *   --comment \r\n FROM items\r\n  --comment".to_sql. \
-      should == 'SELECT * FROM items'
-  end
-  
-  deprec_specify "should remove C-style comments" do
-    "SELECT * \r\n/* comment comment\r\ncomment\r\nFROM items */\r\nFROM items\r\n--comment".to_sql. \
-      should == 'SELECT * FROM items'
-  end
-end
-
 context "String#lit" do
   specify "should return an LiteralString object" do
     'xyz'.lit.should be_a_kind_of(Sequel::LiteralString)
@@ -118,13 +74,6 @@ context "String#lit" do
       "UPDATE t SET stamp = NOW()"
   end
 
-  deprec_specify "should be aliased as expr" do
-    'xyz'.expr.should be_a_kind_of(Sequel::LiteralString)
-    'xyz'.expr.to_s.should == 'xyz'
-    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)
@@ -146,18 +95,6 @@ context "String#to_sequel_blob" do
   end
 end
 
-context "String#split_sql" do
-  deprec_specify "should split a string containing multiple statements" do
-    "DROP TABLE a; DROP TABLE c".split_sql.should == \
-      ['DROP TABLE a', 'DROP TABLE c']
-  end
-  
-  deprec_specify "should remove comments from the string" do
-    "DROP TABLE a;/* DROP TABLE b; DROP TABLE c;*/DROP TABLE d".split_sql.should == \
-      ['DROP TABLE a', 'DROP TABLE d']
-  end
-end
-
 context "#desc" do
   before do
     @ds = Sequel::Dataset.new(nil)
@@ -300,6 +237,10 @@ context "Symbol" do
     @ds.literal(:xyz.qualify(:abc)).should == '"ABC"."XYZ"'
   end
 
+  specify "#qualify should work on QualifiedIdentifiers" do
+    @ds.literal(:xyz.qualify(:abc).qualify(:def)).should == '"DEF"."ABC"."XYZ"'
+  end
+
   specify "should be able to qualify an identifier" do
     @ds.literal(:xyz.identifier.qualify(:xyz__abc)).should == '"XYZ"."ABC"."XYZ"'
   end
@@ -365,10 +306,12 @@ context "Symbol" do
     :abc.cast(:integer).to_s(@ds).should == "CAST(abc AS integer)"
   end
 
-  deprec_specify "should support cast_as method" do
-    :abc.cast_as(:integer).to_s(@ds).should == "CAST(abc AS integer)"
+  specify "should support sql array accesses via sql_subscript" do
+    @ds.literal(:abc.sql_subscript(1)).should == "abc[1]"
+    @ds.literal(:abc__def.sql_subscript(1)).should == "abc.def[1]"
+    @ds.literal(:abc.sql_subscript(1)|2).should == "abc[1, 2]"
   end
-  
+
   specify "should support cast_numeric and cast_string" do
     x = :abc.cast_numeric
     x.should be_a_kind_of(Sequel::SQL::NumericExpression)
@@ -384,16 +327,16 @@ context "Symbol" do
 
     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(255))"
   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
+       def cast_type_literal(type)
+         return :foo if type == Integer
+         return :bar if type == String
+         type
        end
     end
     @ds2 = Sequel::Dataset.new(m)
@@ -406,110 +349,11 @@ context "Symbol" do
     :abc.cast_numeric(String).to_s(@ds2).should == "CAST(abc AS bar)"
   end
 
-  deprec_specify "should support subscript access using | operator" do
-    (:abc|1).to_s(@ds).should == 'abc[1]'
-    (:abc|[1]).to_s(@ds).should == 'abc[1]'
-    (:abc|[1, 2]).to_s(@ds).should == 'abc[1, 2]'
-    (:abc|1|2).to_s(@ds).should == 'abc[1, 2]'
-  end
-
   specify "should support SQL EXTRACT function via #extract " do
     :abc.extract(:year).to_s(@ds).should == "extract(year FROM abc)"
   end
 end
 
-context "String#to_time" do
-  deprec_specify "should convert the string into a Time object" do
-    "2007-07-11".to_time.should == Time.parse("2007-07-11")
-    "06:30".to_time.should == Time.parse("06:30")
-  end
-  
-  deprec_specify "should raise InvalidValue for an invalid time" do
-    proc {'0000-00-00'.to_time}.should raise_error(Sequel::InvalidValue)
-  end
-end
-
-context "String#to_date" do
-  after do
-    Sequel.convert_two_digit_years = true
-  end
-
-  deprec_specify "should convert the string into a Date object" do
-    "2007-07-11".to_date.should == Date.parse("2007-07-11")
-  end
-  
-  deprec_specify "should convert 2 digit years by default" do
-    "July 11, 07".to_date.should == Date.parse("2007-07-11")
-  end
-
-  deprec_specify "should not convert 2 digit years if set not to" do
-    Sequel.convert_two_digit_years = false
-    "July 11, 07".to_date.should == Date.parse("0007-07-11")
-  end
-
-  deprec_specify "should raise InvalidValue for an invalid date" do
-    proc {'0000-00-00'.to_date}.should raise_error(Sequel::InvalidValue)
-  end
-end
-
-context "String#to_datetime" do
-  after do
-    Sequel.convert_two_digit_years = true
-  end
-
-  deprec_specify "should convert the string into a DateTime object" do
-    "2007-07-11 10:11:12a".to_datetime.should == DateTime.parse("2007-07-11 10:11:12a")
-  end
-  
-  deprec_specify "should convert 2 digit years by default" do
-    "July 11, 07 10:11:12a".to_datetime.should == DateTime.parse("2007-07-11 10:11:12a")
-  end
-
-  deprec_specify "should not convert 2 digit years if set not to" do
-    Sequel.convert_two_digit_years = false
-    "July 11, 07 10:11:12a".to_datetime.should == DateTime.parse("0007-07-11 10:11:12a")
-  end
-
-  deprec_specify "should raise InvalidValue for an invalid date" do
-    proc {'0000-00-00'.to_datetime}.should raise_error(Sequel::InvalidValue)
-  end
-end
-
-context "String#to_sequel_time" do
-  after do
-    Sequel.datetime_class = Time
-    Sequel.convert_two_digit_years = true
-  end
-
-  deprec_specify "should convert the string into a Time object by default" do
-    "2007-07-11 10:11:12a".to_sequel_time.class.should == Time
-    "2007-07-11 10:11:12a".to_sequel_time.should == Time.parse("2007-07-11 10:11:12a")
-  end
-  
-  deprec_specify "should convert the string into a DateTime object if that is set" do
-    Sequel.datetime_class = DateTime
-    "2007-07-11 10:11:12a".to_sequel_time.class.should == DateTime
-    "2007-07-11 10:11:12a".to_sequel_time.should == DateTime.parse("2007-07-11 10:11:12a")
-  end
-  
-  deprec_specify "should convert 2 digit years by default if using DateTime class" do
-    Sequel.datetime_class = DateTime
-    "July 11, 07 10:11:12a".to_sequel_time.should == DateTime.parse("2007-07-11 10:11:12a")
-  end
-
-  deprec_specify "should not convert 2 digit years if set not to when using DateTime class" do
-    Sequel.datetime_class = DateTime
-    Sequel.convert_two_digit_years = false
-    "July 11, 07 10:11:12a".to_sequel_time.should == DateTime.parse("0007-07-11 10:11:12a")
-  end
-
-  deprec_specify "should raise InvalidValue for an invalid time" do
-    proc {'0000-00-00'.to_sequel_time}.should raise_error(Sequel::InvalidValue)
-    Sequel.datetime_class = DateTime
-    proc {'0000-00-00'.to_sequel_time}.should raise_error(Sequel::InvalidValue)
-  end
-end
-
 context "Sequel::SQL::Function#==" do
   specify "should be true for functions with the same name and arguments, false otherwise" do
     a = :date.sql_function(:t)