sequel 0.2.1.1 → 0.3.0

data/spec/connection_pool_spec.rb

@@ -267,4 +267,87 @@ context "A connection pool with a max size of 5" do
     @pool.available_connections.size.should == 5
     @pool.allocated.should be_empty
   end
+end
+
+context "ConnectionPool#disconnect" do
+  setup do
+    @count = 0
+    @pool = Sequel::ConnectionPool.new(5) {{:id => @count += 1}}
+  end
+  
+  specify "should invoke the given block for each available connection" do
+    threads = []
+    stop = nil
+    5.times {|i| threads << Thread.new {@pool.hold {|c| while !stop;sleep 0.1;end}}; sleep 0.1}
+    while @pool.size < 5
+      sleep 0.2
+    end
+    stop = true
+    sleep 0.2
+    
+    @pool.size.should == 5
+    @pool.available_connections.size.should == 5
+    @pool.available_connections.each {|c| c[:id].should_not be_nil}
+    conns = []
+    @pool.disconnect {|c| conns << c}
+    conns.size.should == 5
+  end
+  
+  specify "should remove all available connections" do
+    threads = []
+    stop = nil
+    5.times {|i| threads << Thread.new {@pool.hold {|c| while !stop;sleep 0.1;end}}; sleep 0.1}
+    while @pool.size < 5
+      sleep 0.2
+    end
+    stop = true
+    sleep 0.2
+    
+    @pool.size.should == 5
+    @pool.disconnect
+    @pool.size.should == 0
+  end
+
+  specify "should not touch connections in use" do
+    threads = []
+    stop = nil
+    5.times {|i| threads << Thread.new {@pool.hold {|c| while !stop;sleep 0.1;end}}; sleep 0.1}
+    while @pool.size < 5
+      sleep 0.2
+    end
+    stop = true
+    sleep 0.2
+    
+    @pool.size.should == 5
+    
+    @pool.hold do |conn|
+      @pool.available_connections.size.should == 4
+      @pool.available_connections.each {|c| c.should_not be(conn)}
+      conns = []
+      @pool.disconnect {|c| conns << c}
+      conns.size.should == 4
+    end
+    @pool.size.should == 1
+  end
+end
+
+context "SingleThreadedPool" do
+  setup do
+    @pool = Sequel::SingleThreadedPool.new {1234}
+  end
+  
+  specify "should provide a #hold method" do
+    conn = nil
+    @pool.hold {|c| conn = c}
+    conn.should == 1234
+  end
+  
+  specify "should provide a #disconnect method" do
+    @pool.hold {|c|}
+    @pool.conn.should == 1234
+    conn = nil
+    @pool.disconnect {|c| conn = c}
+    conn.should == 1234
+    @pool.conn.should be_nil
+  end
 end

data/spec/database_spec.rb

@@ -34,6 +34,12 @@ context "Database#connect" do
   end
 end
 
+context "Database#disconnect" do
+  specify "should raise NotImplementedError" do
+    proc {Sequel::Database.new.disconnect}.should raise_error(NotImplementedError)
+  end
+end
+
 context "Database#uri" do
   setup do
     @c = Class.new(Sequel::Database) do
@@ -125,16 +131,21 @@ context "Database#<<" do
       "CREATE TABLE items (a integer, b text, c integer); DROP TABLE old_items;"
   end
   
-  specify "should remove comments and whitespace from strings as well" do
+  specify "should remove comments and whitespace from arrays" do
     s = %[
       --
       CREATE TABLE items (a integer, /*b integer*/
         b text, c integer); \r\n
       DROP TABLE old_items;
-    ]
+    ].split($/)
     (@db << s).should == 
       "CREATE TABLE items (a integer, b text, c integer); DROP TABLE old_items;"
   end
+  
+  specify "should not remove comments and whitespace from strings" do
+    s = "INSERT INTO items VALUES ('---abc')"
+    (@db << s).should == s
+  end
 end
 
 context "Database#synchronize" do
@@ -487,6 +498,15 @@ context "A database" do
     db.should be_single_threaded
     db.should_not be_multi_threaded
   end
+  
+  specify "should accept a logger object" do
+    db = Sequel::Database.new
+    s = "I'm a logger"
+    db.logger = s
+    db.logger.should be(s)
+    db.logger = nil
+    db.logger.should be_nil
+  end
 end
 
 context "Database#dataset" do
@@ -499,4 +519,63 @@ context "Database#dataset" do
     @d.should be_a_kind_of(Sequel::Dataset)
     @d.sql.should == "SELECT x FROM y"
   end
+end
+
+context "Database#fetch" do
+  setup do
+    @db = Sequel::Database.new
+    c = Class.new(Sequel::Dataset) do
+      def fetch_rows(sql); yield({:sql => sql}); end
+    end
+    @db.meta_def(:dataset) {c.new(self)}
+  end
+  
+  specify "should create a dataset and invoke its fetch_rows method with the given sql" do
+    sql = nil
+    @db.fetch('select * from xyz') {|r| sql = r[:sql]}
+    sql.should == 'select * from xyz'
+  end
+  
+  specify "should format the given sql with any additional arguments" do
+    sql = nil
+    @db.fetch('select * from xyz where x = ? and y = ?', 15, 'abc') {|r| sql = r[:sql]}
+    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 (?)',
+    'aman', [3,4,7]) {|r| sql = r[:sql]}
+    sql.should == "select name from table where name = 'aman' or id in (3, 4, 7)"
+  end
+  
+  specify "should return an enumerator if no block is given" do
+    @db.fetch('select * from xyz').should respond_to(:each)
+    
+    @db.fetch('select a from b').map {|r| r[:sql]}.should == ['select a from b']
+
+    @db.fetch('select c from d').inject([]) {|m, r| m << r; m}.should == \
+      [{:sql => 'select c from d'}]
+  end
+end
+
+context "Database#[]" do
+  setup do
+    @db = Sequel::Database.new
+  end
+  
+  specify "should return a dataset when symbols are given" do
+    ds = @db[:items]
+    ds.class.should == Sequel::Dataset
+    ds.opts[:from].should == [:items]
+  end
+  
+  specify "should return an enumerator when a string is given" do
+    c = Class.new(Sequel::Dataset) do
+      def fetch_rows(sql); yield({:sql => sql}); end
+    end
+    @db.meta_def(:dataset) {c.new(self)}
+
+    sql = nil
+    @db['select * from xyz where x = ? and y = ?', 15, 'abc'].each {|r| sql = r[:sql]}
+    sql.should == "select * from xyz where x = 15 and y = 'abc'"
+  end
 end

data/spec/dataset_spec.rb

@@ -105,12 +105,28 @@ context "A simple dataset" do
   specify "should format an insert statement with hash" do
     @dataset.insert_sql(:name => 'wxyz', :price => 342).
       should match(/INSERT INTO test \(name, price\) VALUES \('wxyz', 342\)|INSERT INTO test \(price, name\) VALUES \(342, 'wxyz'\)/)
+
+      @dataset.insert_sql({}).should == "INSERT INTO test DEFAULT VALUES;"
+  end
+
+  specify "should format an insert statement with array fields" do
+    v = [1, 2, 3]
+    v.fields = [:a, :b, :c]
+    @dataset.insert_sql(v).should == "INSERT INTO test (a, b, c) VALUES (1, 2, 3);"
+    
+    v = []
+    v.fields = [:a, :b]
+    @dataset.insert_sql(v).should == "INSERT INTO test DEFAULT VALUES;"
+  end
+  
+  specify "should format an insert statement with an arbitrary value" do
+    @dataset.insert_sql(123).should == "INSERT INTO test VALUES (123);"
   end
   
   specify "should format an insert statement with sub-query" do
     @sub = Sequel::Dataset.new(nil).from(:something).filter(:x => 2)
     @dataset.insert_sql(@sub).should == \
-      "INSERT INTO test (SELECT * FROM something WHERE (x = 2))"
+      "INSERT INTO test (SELECT * FROM something WHERE (x = 2));"
   end
   
   specify "should format an insert statement with array" do
@@ -123,6 +139,13 @@ context "A simple dataset" do
       "UPDATE test SET name = 'abc'"
   end
   
+  specify "should format an update statement with array fields" do
+    v = ['abc']
+    v.fields = [:name]
+    
+    @dataset.update_sql(v).should == "UPDATE test SET name = 'abc'"
+  end
+  
   specify "should be able to return rows for arbitrary SQL" do
     @dataset.select_sql(:sql => 'xxx yyy zzz').should ==
       "xxx yyy zzz"
@@ -244,6 +267,16 @@ context "Dataset#where" do
 
     @dataset.filter {:id.in?(4..7)}.sql.should ==
       'SELECT * FROM test WHERE (id >= 4 AND id <= 7)'
+
+    @dataset.filter(:table__id => 4..7).sql.should ==
+      'SELECT * FROM test WHERE (table.id >= 4 AND table.id <= 7)'
+    @dataset.filter(:table__id => 4...7).sql.should ==
+      'SELECT * FROM test WHERE (table.id >= 4 AND table.id < 7)'
+
+    @dataset.filter {:table__id == (4..7)}.sql.should ==
+      'SELECT * FROM test WHERE (table.id >= 4 AND table.id <= 7)'
+    @dataset.filter {:table__id.in?(4..7)}.sql.should ==
+      'SELECT * FROM test WHERE (table.id >= 4 AND table.id <= 7)'
   end
   
   specify "should accept nil" do
@@ -537,7 +570,26 @@ context "Dataset#from" do
 
   specify "should format a Dataset as a subquery if it has had options set" do
     @dataset.from(@dataset.from(:a).where(:a=>1)).select_sql.should ==
-      "SELECT * FROM (SELECT * FROM a WHERE (a = 1))"
+      "SELECT * FROM (SELECT * FROM a WHERE (a = 1)) t1"
+  end
+  
+  specify "should automatically alias sub-queries" do
+    @dataset.from(@dataset.from(:a).group(:b)).select_sql.should ==
+      "SELECT * FROM (SELECT * FROM a GROUP BY b) t1"
+      
+    d1 = @dataset.from(:a).group(:b)
+    d2 = @dataset.from(:c).group(:d)
+    
+    @dataset.from(d1, d2).sql.should == 
+      "SELECT * FROM (SELECT * FROM a GROUP BY b) t1, (SELECT * FROM c GROUP BY d) t2"
+  end
+  
+  specify "should accept a hash for aliasing" do
+    @dataset.from(:a => :b).sql.should ==
+      "SELECT * FROM a b"
+      
+    @dataset.from(@dataset.from(:a).group(:b) => :c).sql.should ==
+      "SELECT * FROM (SELECT * FROM a GROUP BY b) c"
   end
 
   specify "should use the relevant table name if given a simple dataset" do
@@ -560,12 +612,12 @@ context "Dataset#select" do
     @d.select(:a, :b, :test__c).sql.should == 'SELECT a, b, test.c FROM test'
   end
   
-  specify "should accept mixed types (strings and symbols)" do
-    @d.select('aaa').sql.should == 'SELECT aaa FROM test'
-    @d.select(:a, 'b').sql.should == 'SELECT a, b FROM test'
-    @d.select(:test__cc, 'test.d AS e').sql.should == 
+  specify "should accept symbols and literal strings" do
+    @d.select('aaa'.lit).sql.should == 'SELECT aaa FROM test'
+    @d.select(:a, 'b'.lit).sql.should == 'SELECT a, b FROM test'
+    @d.select(:test__cc, 'test.d AS e'.lit).sql.should == 
       'SELECT test.cc, test.d AS e FROM test'
-    @d.select('test.d AS e', :test__cc).sql.should == 
+    @d.select('test.d AS e'.lit, :test__cc).sql.should == 
       'SELECT test.d AS e, test.cc FROM test'
 
     # symbol helpers      
@@ -590,6 +642,14 @@ context "Dataset#select" do
     @d.select(:a, :b, :c).select.sql.should == 'SELECT * FROM test'
     @d.select(:price).select(:name).sql.should == 'SELECT name FROM test'
   end
+  
+  specify "should accept arbitrary objects and literalize them correctly" do
+    @d.select(1, :a, 't').sql.should == "SELECT 1, a, 't' FROM test"
+
+    @d.select(nil, :sum[:t], :x___y).sql.should == "SELECT NULL, sum(t), x AS y FROM test"
+
+    @d.select(nil, 1, :x => :y).sql.should == "SELECT NULL, 1, x AS y FROM test"
+  end
 end
 
 context "Dataset#order" do
@@ -613,7 +673,7 @@ context "Dataset#order" do
   end
   
   specify "should accept a string" do
-    @dataset.order('dada ASC').sql.should ==
+    @dataset.order('dada ASC'.lit).sql.should ==
       'SELECT * FROM test ORDER BY dada ASC'
   end
 end
@@ -639,7 +699,7 @@ context "Dataset#order_by" do
   end
   
   specify "should accept a string" do
-    @dataset.order_by('dada ASC').sql.should ==
+    @dataset.order_by('dada ASC'.lit).sql.should ==
       'SELECT * FROM test ORDER BY dada ASC'
   end
 end
@@ -915,6 +975,17 @@ context "Dataset#join_table" do
     @d.from('stats s').join('players p', :id => :player_id).sql.should ==
       'SELECT * FROM stats s INNER JOIN players p ON (p.id = s.player_id)'
   end
+  
+  specify "should allow for arbitrary conditions in the JOIN clause" do
+    @d.join_table(:left_outer, :categories, :id => :category_id, :status => 0).sql.should ==
+      'SELECT * FROM items LEFT OUTER JOIN categories ON (categories.id = items.category_id) AND (categories.status = 0)'
+    @d.join_table(:left_outer, :categories, :id => :category_id, :categorizable_type => "Post").sql.should ==
+      "SELECT * FROM items LEFT OUTER JOIN categories ON (categories.categorizable_type = 'Post') AND (categories.id = items.category_id)"
+    @d.join_table(:left_outer, :categories, :id => :category_id, :timestamp => "CURRENT_TIMESTAMP".lit).sql.should ==
+      "SELECT * FROM items LEFT OUTER JOIN categories ON (categories.id = items.category_id) AND (categories.timestamp = CURRENT_TIMESTAMP)"
+    @d.join_table(:left_outer, :categories, :id => :category_id, :status => [1, 2, 3]).sql.should ==
+      "SELECT * FROM items LEFT OUTER JOIN categories ON (categories.id = items.category_id) AND (categories.status IN (1, 2, 3))"
+  end
 end
 
 context "Dataset#[]=" do
@@ -1029,6 +1100,11 @@ context "Dataset#first" do
     @c.last_opts[:where].should == ('z = 15')
   end
   
+  specify "should return the first matching record if a block is given" do
+    @d.first {:z > 26}.should == {:a => 1, :b => 2}
+    @c.last_opts[:where].should == ('(z > 26)')
+  end
+  
   specify "should return a single record if no argument is given" do
     @d.first.should == {:a => 1, :b => 2}
   end
@@ -1844,4 +1920,146 @@ context "Dataset#transform" do
     @ds.each(:naked => true) {|r| f = r}
     f.should == {:x => "wow", :y => 'hello'}
   end
+end
+
+context "Dataset#transform" do
+  setup do
+    @c = Class.new(Sequel::Dataset) do
+      attr_accessor :raw
+      attr_accessor :sql
+      
+      def fetch_rows(sql, &block)
+        block[@raw]
+      end
+      
+      def insert(v)
+        @sql = insert_sql(v)
+      end
+      
+      def update(v)
+        @sql = update_sql(v)
+      end
+    end
+
+    @ds = @c.new(nil).from(:items)
+  end
+  
+  specify "should raise SequelError for invalid transformations" do
+    proc {@ds.transform(:x => 'mau')}.should raise_error(SequelError)
+    proc {@ds.transform(:x => :mau)}.should raise_error(SequelError)
+    proc {@ds.transform(:x => [])}.should raise_error(SequelError)
+    proc {@ds.transform(:x => ['mau'])}.should raise_error(SequelError)
+    proc {@ds.transform(:x => [proc {|v|}, proc {|v|}])}.should_not raise_error(SequelError)
+  end
+  
+  specify "should support stock YAML transformation" do
+    @ds.transform(:x => :yaml)
+
+    @ds.raw = {:x => [1, 2, 3].to_yaml, :y => 'hello'}
+    @ds.first.should == {:x => [1, 2, 3], :y => 'hello'}
+
+    @ds.insert(:x => :toast)
+    @ds.sql.should == "INSERT INTO items (x) VALUES ('#{:toast.to_yaml}');"
+    @ds.insert(:y => 'butter')
+    @ds.sql.should == "INSERT INTO items (y) VALUES ('butter');"
+    @ds.update(:x => ['dream'])
+    @ds.sql.should == "UPDATE items SET x = '#{['dream'].to_yaml}'"
+
+    @ds2 = @ds.filter(:a => 1)
+    @ds2.raw = {:x => [1, 2, 3].to_yaml, :y => 'hello'}
+    @ds2.first.should == {:x => [1, 2, 3], :y => 'hello'}
+    @ds2.insert(:x => :toast)
+    @ds2.sql.should == "INSERT INTO items (x) VALUES ('#{:toast.to_yaml}');"
+
+    @ds.set_row_proc {|r| r[:z] = r[:x] * 2; r}
+    @ds.raw = {:x => "wow".to_yaml, :y => 'hello'}
+    @ds.first.should == {:x => "wow", :y => 'hello', :z => "wowwow"}
+    f = nil
+    @ds.raw = {:x => "wow".to_yaml, :y => 'hello'}
+    @ds.each(:naked => true) {|r| f = r}
+    f.should == {:x => "wow", :y => 'hello'}
+  end
+  
+  specify "should support stock Marshal transformation" do
+    @ds.transform(:x => :marshal)
+
+    @ds.raw = {:x => Marshal.dump([1, 2, 3]), :y => 'hello'}
+    @ds.first.should == {:x => [1, 2, 3], :y => 'hello'}
+
+    @ds.insert(:x => :toast)
+    @ds.sql.should == "INSERT INTO items (x) VALUES ('#{Marshal.dump(:toast)}');"
+    @ds.insert(:y => 'butter')
+    @ds.sql.should == "INSERT INTO items (y) VALUES ('butter');"
+    @ds.update(:x => ['dream'])
+    @ds.sql.should == "UPDATE items SET x = '#{Marshal.dump(['dream'])}'"
+
+    @ds2 = @ds.filter(:a => 1)
+    @ds2.raw = {:x => Marshal.dump([1, 2, 3]), :y => 'hello'}
+    @ds2.first.should == {:x => [1, 2, 3], :y => 'hello'}
+    @ds2.insert(:x => :toast)
+    @ds2.sql.should == "INSERT INTO items (x) VALUES ('#{Marshal.dump(:toast)}');"
+
+    @ds.set_row_proc {|r| r[:z] = r[:x] * 2; r}
+    @ds.raw = {:x => Marshal.dump("wow"), :y => 'hello'}
+    @ds.first.should == {:x => "wow", :y => 'hello', :z => "wowwow"}
+    f = nil
+    @ds.raw = {:x => Marshal.dump("wow"), :y => 'hello'}
+    @ds.each(:naked => true) {|r| f = r}
+    f.should == {:x => "wow", :y => 'hello'}
+  end
+end
+
+context "Dataset#to_csv" do
+  setup do
+    @c = Class.new(Sequel::Dataset) do
+      attr_accessor :data
+      attr_accessor :cols
+      
+      def fetch_rows(sql, &block)
+        @columns = @cols
+        @data.each {|r| r.fields = @columns; block[r]}
+      end
+      
+      # naked should return self here because to_csv wants a naked result set.
+      def naked
+        self
+      end
+    end
+    
+    @ds = @c.new(nil).from(:items)
+
+    @ds.cols = [:a, :b, :c]
+    @ds.data = [
+      [1, 2, 3], [4, 5, 6], [7, 8, 9]
+    ]
+  end
+  
+  specify "should format a CSV representation of the records" do
+    @ds.to_csv.should ==
+      "a, b, c\r\n1, 2, 3\r\n4, 5, 6\r\n7, 8, 9\r\n"
+  end
+
+  specify "should exclude column titles if so specified" do
+    @ds.to_csv(false).should ==
+      "1, 2, 3\r\n4, 5, 6\r\n7, 8, 9\r\n"
+  end
+end
+
+context "Dataset#each_hash" do
+  setup do
+    @c = Class.new(Sequel::Dataset) do
+      def each(&block)
+        a = [[1, 2, 3], [4, 5, 6]]
+        a.each {|r| r.fields = [:a, :b, :c]; block[r]}
+      end
+    end
+    
+    @ds = @c.new(nil).from(:items)
+  end
+  
+  specify "should yield records converted to hashes" do
+    hashes = []
+    @ds.each_hash {|h| hashes << h}
+    hashes.should == [{:a => 1, :b => 2, :c => 3}, {:a => 4, :b => 5, :c => 6}]
+  end
 end