sequel_core 1.5.1 → 2.0.0

data/spec/core_sql_spec.rb

@@ -1,5 +1,28 @@
 require File.join(File.dirname(__FILE__), 'spec_helper')
 
+context "Array#all_two_pairs?" do
+  specify "should return false if empty" do
+    [].all_two_pairs?.should == false
+  end
+
+  specify "should return false if any of the elements is not an array" do
+    [1].all_two_pairs?.should == false
+    [[1,2],1].all_two_pairs?.should == false
+  end
+
+  specify "should return false if any of the elements has a length other than two" do
+    [[1,2],[]].all_two_pairs?.should == false
+    [[1,2],[1]].all_two_pairs?.should == false
+    [[1,2],[1,2,3]].all_two_pairs?.should == false
+  end
+
+  specify "should return true if all of the elements are arrays with a length of two" do
+    [[1,2]].all_two_pairs?.should == true
+    [[1,2],[1,2]].all_two_pairs?.should == true
+    [[1,2],[1,2],[1,2]].all_two_pairs?.should == true
+  end
+end
+  
 context "Array#to_sql" do
   specify "should concatenate multiple lines into a single string" do
     "SELECT * \r\nFROM items\r\n WHERE a = 1".split.to_sql. \
@@ -51,25 +74,14 @@ context "String#lit" do
   end
   
   specify "should inhibit string literalization" do
-    db = Sequel::Database.new
-    ds = db[:t]
-    
-    ds.update_sql(:stamp => "NOW()".lit).should == \
+    Sequel::Database.new[:t].update_sql(:stamp => "NOW()".expr).should == \
       "UPDATE t SET stamp = NOW()"
   end
-end
 
-context "String#expr" do
-  specify "should return an LiteralString object" do
+  specify "should be aliased as expr" do
     'xyz'.expr.should be_a_kind_of(Sequel::LiteralString)
     'xyz'.expr.to_s.should == 'xyz'
-  end
-
-  specify "should inhibit string literalization" do
-    db = Sequel::Database.new
-    ds = db[:t]
-    
-    ds.update_sql(:stamp => "NOW()".expr).should == \
+    Sequel::Database.new[:t].update_sql(:stamp => "NOW()".expr).should == \
       "UPDATE t SET stamp = NOW()"
   end
 end
@@ -149,20 +161,21 @@ end
 context "Column references" do
   setup do
     @c = Class.new(Sequel::Dataset) do
-      def quote_column_ref(c); "`#{c}`"; end
+      def quoted_identifier(c); "`#{c}`"; end
     end
     @ds = @c.new(nil)
+    @ds.quote_identifiers = true
   end
   
   specify "should be quoted properly" do
     @ds.literal(:xyz).should == "`xyz`"
-    @ds.literal(:xyz__abc).should == "xyz.`abc`"
+    @ds.literal(:xyz__abc).should == "`xyz`.`abc`"
 
     @ds.literal(:xyz.as(:x)).should == "`xyz` AS `x`"
-    @ds.literal(:xyz__abc.as(:x)).should == "xyz.`abc` AS `x`"
+    @ds.literal(:xyz__abc.as(:x)).should == "`xyz`.`abc` AS `x`"
 
     @ds.literal(:xyz___x).should == "`xyz` AS `x`"
-    @ds.literal(:xyz__abc___x).should == "xyz.`abc` AS `x`"
+    @ds.literal(:xyz__abc___x).should == "`xyz`.`abc` AS `x`"
   end
   
   specify "should be quoted properly in SQL functions" do
@@ -178,7 +191,7 @@ context "Column references" do
   
   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__y.cast_as(:varchar[20])).should == "cast(`x`.`y` AS varchar(20))"
   end
 end
 
@@ -187,10 +200,15 @@ context "Symbol#*" do
     @ds = Sequel::Dataset.new(nil)
   end
   
-  specify "should format a qualified wildcard" do
+  specify "should format a qualified wildcard if no argument" do
     :xyz.*.to_s(@ds).should == 'xyz.*'
     :abc.*.to_s(@ds).should == 'abc.*'
   end
+
+  specify "should format a filter expression if an argument" do
+    :xyz.*(3).to_s(@ds).should == '(xyz * 3)'
+    :abc.*(5).to_s(@ds).should == '(abc * 5)'
+  end
 end
 
 context "Symbol#to_column_ref" do
@@ -219,38 +237,21 @@ context "Symbol#to_column_ref" do
     :ABC.to_column_ref(@ds).should == 'ABC'
     :Zvashtoy__aBcD.to_column_ref(@ds).should == 'Zvashtoy.aBcD'
   end
+
+  specify "should support spaces inside column names" do
+    @ds.quote_identifiers = true
+    :"AB C".to_column_ref(@ds).should == '"AB C"'
+    :"Zvas htoy__aB cD".to_column_ref(@ds).should == '"Zvas htoy"."aB cD"'
+    :"aB cD___XX XX".to_column_ref(@ds).should == '"aB cD" AS "XX XX"'
+    :"Zva shtoy__aB cD___XX XX".to_column_ref(@ds).should == '"Zva shtoy"."aB cD" AS "XX XX"'
+  end
 end
 
-### DEPRECATED
 context "Symbol" do
   setup do
     @ds = Sequel::Dataset.new(nil)
   end
   
-  specify "should support MIN for specifying min function" do
-    :abc__def.MIN.to_s(@ds).should == 'min(abc.def)'
-  end
-
-  specify "should support MAX for specifying max function" do
-    :abc__def.MAX.to_s(@ds).should == 'max(abc.def)'
-  end
-
-  specify "should support SUM for specifying sum function" do
-    :abc__def.SUM.to_s(@ds).should == 'sum(abc.def)'
-  end
-
-  specify "should support AVG for specifying avg function" do
-    :abc__def.AVG.to_s(@ds).should == 'avg(abc.def)'
-  end
-  
-  specify "should support COUNT for specifying count function" do
-    :abc__def.COUNT.to_s(@ds).should == 'count(abc.def)'
-  end
-  
-  specify "should support any other function using upper case letters" do
-    :abc__def.DADA.to_s(@ds).should == 'dada(abc.def)'
-  end
-  
   specify "should support upper case outer functions" do
     :COUNT['1'].to_s(@ds).should == "COUNT('1')"
   end
@@ -265,10 +266,6 @@ context "Symbol" do
     :abc.cast_as(:integer).to_s(@ds).should == "cast(abc AS integer)"
   end
   
-  specify "should raise NoMethodError for non-uppercase invalid methods" do
-    proc {:abc.dfaxs}.should raise_error(NoMethodError)
-  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]'
@@ -298,6 +295,16 @@ context "String#to_date" do
   end
 end
 
+context "String#to_datetime" do
+  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
+  
+  specify "should raise Error::InvalidValue for an invalid date" do
+    proc {'0000-00-00'.to_datetime}.should raise_error(Sequel::Error::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[:t]

data/spec/database_spec.rb

@@ -9,8 +9,17 @@ context "A new Database" do
     @db.opts.should == {1 => 2, :logger => 3}  
   end
   
-  specify "should set the logger from opts[:logger]" do
+  specify "should set the logger from opts[:logger] and opts[:loggers]" do
     @db.logger.should == 3
+    @db.loggers.should == [3]
+    Sequel::Database.new(1 => 2, :loggers => 3).logger.should == 3
+    Sequel::Database.new(1 => 2, :loggers => 3).loggers.should == [3]
+    Sequel::Database.new(1 => 2, :loggers => [3]).logger.should == 3
+    Sequel::Database.new(1 => 2, :loggers => [3]).loggers.should == [3]
+    Sequel::Database.new(1 => 2, :logger => 4, :loggers => 3).logger.should == 4
+    Sequel::Database.new(1 => 2, :logger => 4, :loggers => 3).loggers.should == [4,3]
+    Sequel::Database.new(1 => 2, :logger => [4], :loggers => [3]).logger.should == 4
+    Sequel::Database.new(1 => 2, :logger => [4], :loggers => [3]).loggers.should == [4,3]
   end
   
   specify "should create a connection pool" do
@@ -88,7 +97,7 @@ context "Database#dataset" do
     e.sql.should == 'SELECT * FROM miu'
   end
   
-  specify "should provide a filtered #from dataset if a block is given" do
+  pt_specify "should provide a filtered #from dataset if a block is given" do
     d = @db.from(:mau) {:x > 100}
     d.should be_a_kind_of(Sequel::Dataset)
     d.sql.should == 'SELECT * FROM mau WHERE (x > 100)'
@@ -435,6 +444,18 @@ context "Database#transaction" do
     @db.sql.should == ['BEGIN', 'DROP TABLE test;', 'COMMIT']
   end
   
+  specify "should handle returning inside of the block by committing" do
+    def @db.ret_commit
+      transaction do
+        execute 'DROP TABLE test;'
+        return
+        execute 'DROP TABLE test2;';
+      end
+    end
+    @db.ret_commit
+    @db.sql.should == ['BEGIN', 'DROP TABLE test;', 'COMMIT']
+  end
+  
   specify "should issue ROLLBACK if an exception is raised, and re-raise" do
     @db.transaction {@db.execute 'DROP TABLE test'; raise RuntimeError} rescue nil
     @db.sql.should == ['BEGIN', 'DROP TABLE test', 'ROLLBACK']
@@ -477,7 +498,15 @@ end
 context "A Database adapter with a scheme" do
   setup do
     class CCC < Sequel::Database
+      if defined?(DISCONNECTS)
+        DISCONNECTS.clear
+      else
+        DISCONNECTS = []
+      end
       set_adapter_scheme :ccc
+      def disconnect
+        DISCONNECTS << self
+      end
     end
   end
 
@@ -499,25 +528,40 @@ context "A Database adapter with a scheme" do
     c.opts[:database].should == 'db'
   end
 
-  specify "should be accessible through Sequel.open" do
-    c = Sequel.open 'ccc://localhost/db'
-    c.should be_a_kind_of(CCC)
-    c.opts[:host].should == 'localhost'
-    c.opts[:database].should == 'db'
+  specify "should be accessible through Sequel.connect via a block" do
+    x = nil
+    y = nil
+    z = nil
+
+    p = proc do |c|
+      c.should be_a_kind_of(CCC)
+      c.opts[:host].should == 'localhost'
+      c.opts[:database].should == 'db'
+      z = y
+      y = x
+      x = c
+    end
+    Sequel::Database.connect('ccc://localhost/db', &p).should == nil
+    CCC::DISCONNECTS.should == [x]
+
+    Sequel.connect('ccc://localhost/db', &p).should == nil
+    CCC::DISCONNECTS.should == [y, x]
+
+    Sequel.send(:def_adapter_method, :ccc)
+    Sequel.ccc('db', :host=>'localhost', &p).should == nil
+    CCC::DISCONNECTS.should == [z, y, x]
   end
 
-  ### DEPRECATED
-  specify "should be accessible through Sequel()" do
-    c = Sequel('ccc://localhost/db')
+  specify "should be accessible through Sequel.open" do
+    c = Sequel.open 'ccc://localhost/db'
     c.should be_a_kind_of(CCC)
     c.opts[:host].should == 'localhost'
     c.opts[:database].should == 'db'
   end
 
   specify "should be accessible through Sequel.<adapter>" do
-    class << Sequel
-      def_adapter_method(:ccc)
-    end
+    Sequel.send(:def_adapter_method, :ccc)
+
     # invalid parameters
     proc {Sequel.ccc('abc', 'def')}.should raise_error(Sequel::Error)
     
@@ -681,9 +725,26 @@ context "A database" do
     db = Sequel::Database.new
     s = "I'm a logger"
     db.logger = s
-    db.logger.should be(s)
+    db.logger.should == s
+    db.loggers.should == [s]
     db.logger = nil
-    db.logger.should be_nil
+    db.logger.should == nil
+    db.loggers.should == []
+
+    db.loggers = [s]
+    db.logger.should == s
+    db.loggers.should == [s]
+    db.loggers = []
+    db.logger.should == nil
+    db.loggers.should == []
+
+    t = "I'm also a logger"
+    db.loggers = [s, t]
+    db.logger.should == s
+    db.loggers.should == [s,t]
+    db.loggers = []
+    db.logger.should == nil
+    db.loggers.should == []
   end
 end
 
@@ -720,7 +781,7 @@ context "Database#fetch" do
     sql.should == "select * from xyz where x = 15 and y = 'abc'"
     
     # and Aman Gupta's example
-    @db.fetch('select name from table where name = ? or id in (?)',
+    @db.fetch('select name from table where name = ? or id in ?',
     'aman', [3,4,7]) {|r| sql = r[:sql]}
     sql.should == "select name from table where name = 'aman' or id in (3, 4, 7)"
   end
@@ -739,7 +800,7 @@ context "Database#fetch" do
     ds.select_sql.should == 'select * from xyz'
     ds.sql.should == 'select * from xyz'
     
-    ds.filter! {:price < 100}
+    ds.filter!(:price < 100)
     ds.select_sql.should == 'select * from xyz'
     ds.sql.should == 'select * from xyz'
   end