sequel 0.3.1 → 0.3.2

data/spec/dataset_spec.rb

@@ -109,13 +109,13 @@ context "A simple dataset" do
       @dataset.insert_sql({}).should == "INSERT INTO test DEFAULT VALUES;"
   end
 
-  specify "should format an insert statement with array fields" do
+  specify "should format an insert statement with array with keys" do
     v = [1, 2, 3]
-    v.fields = [:a, :b, :c]
+    v.keys = [:a, :b, :c]
     @dataset.insert_sql(v).should == "INSERT INTO test (a, b, c) VALUES (1, 2, 3);"
     
     v = []
-    v.fields = [:a, :b]
+    v.keys = [:a, :b]
     @dataset.insert_sql(v).should == "INSERT INTO test DEFAULT VALUES;"
   end
   
@@ -155,9 +155,9 @@ context "A simple dataset" do
       "UPDATE test SET name = 'abc'"
   end
   
-  specify "should format an update statement with array fields" do
+  specify "should format an update statement with array with keys" do
     v = ['abc']
-    v.fields = [:name]
+    v.keys = [:name]
     
     @dataset.update_sql(v).should == "UPDATE test SET name = 'abc'"
   end
@@ -458,7 +458,7 @@ context "Dataset#having" do
     @grouped = @dataset.group(:region).select(:region, :population.SUM, :gdp.AVG)
     @d1 = @grouped.having('sum(population) > 10')
     @d2 = @grouped.having(:region => 'Asia')
-    @fields = "region, sum(population), avg(gdp)"
+    @columns = "region, sum(population), avg(gdp)"
   end
 
   specify "should raise if the dataset is not grouped" do
@@ -467,12 +467,12 @@ context "Dataset#having" do
 
   specify "should affect select statements" do
     @d1.select_sql.should ==
-      "SELECT #{@fields} FROM test GROUP BY region HAVING sum(population) > 10"
+      "SELECT #{@columns} FROM test GROUP BY region HAVING sum(population) > 10"
   end
 
   specify "should support proc expressions" do
     @grouped.having {:sum[:population] > 10}.sql.should == 
-      "SELECT #{@fields} FROM test GROUP BY region HAVING (sum(population) > 10)"
+      "SELECT #{@columns} FROM test GROUP BY region HAVING (sum(population) > 10)"
   end
 end
 
@@ -789,19 +789,19 @@ context "Dataset#naked" do
   end
 end
 
-context "Dataset#qualified_field_name" do
+context "Dataset#qualified_column_name" do
   setup do
     @dataset = Sequel::Dataset.new(nil).from(:test)
   end
   
   specify "should return the same if already qualified" do
-    @dataset.qualified_field_name('test.a', :items).should == 'test.a'
-    @dataset.qualified_field_name(:ccc__b, :items).should == 'ccc.b'
+    @dataset.qualified_column_name('test.a', :items).should == 'test.a'
+    @dataset.qualified_column_name(:ccc__b, :items).should == 'ccc.b'
   end
   
-  specify "should qualify the field with the supplied table name" do
-    @dataset.qualified_field_name('a', :items).should == 'items.a'
-    @dataset.qualified_field_name(:b1, :items).should == 'items.b1'
+  specify "should qualify the column with the supplied table name" do
+    @dataset.qualified_column_name('a', :items).should == 'items.a'
+    @dataset.qualified_column_name(:b1, :items).should == 'items.b1'
   end
 end
 
@@ -825,7 +825,7 @@ context "Dataset#map" do
     @d.map {|n| n[:a] + n[:b]}.should == [3, 7, 11]
   end
   
-  specify "should map using #[fieldname] if fieldname is given" do
+  specify "should map using #[column name] if column name is given" do
     @d.map(:a).should == [1, 3, 5]
   end
   
@@ -839,7 +839,7 @@ context "Dataset#to_hash" do
     @d = DummyDataset.new(nil).from(:items)
   end
   
-  specify "should provide a hash with the first field as key and the second as value" do
+  specify "should provide a hash with the first column as key and the second as value" do
     @d.to_hash(:a, :b).should == {1 => 2, 3 => 4, 5 => 6}
     @d.to_hash(:b, :a).should == {2 => 1, 4 => 3, 6 => 5}
   end
@@ -889,6 +889,26 @@ context "Dataset#count" do
   end
 end
 
+
+context "Dataset#group_and_count" do
+  setup do
+    @c = Class.new(Sequel::Dataset) do
+      def self.sql
+        @@sql
+      end
+      
+      def fetch_rows(sql)
+        @@sql = sql
+        yield({1 => 1})
+      end
+    end
+    @ds = @c.new(nil).from(:test)
+  end
+  
+  specify "should format SQL properly" do
+    @ds.group_and_count(:name).sql.should == "SELECT name, count(name) AS count FROM test GROUP BY name ORDER BY count"
+  end
+end
 context "Dataset#empty?" do
   specify "should return true if #count == 0" do
     @c = Class.new(Sequel::Dataset) do
@@ -1025,6 +1045,28 @@ context "Dataset#[]=" do
   end
 end
 
+context "Dataset#set" do
+  setup do
+    c = Class.new(Sequel::Dataset) do
+      def last_sql
+        @@last_sql
+      end
+      
+      def update(*args)
+        @@last_sql = update_sql(*args)
+      end
+    end
+    
+    @d = c.new(nil).from(:items)
+  end
+  
+  specify "should act as alis to #update" do
+    @d.set({:x => 3})
+    @d.last_sql.should == 'UPDATE items SET x = 3'
+  end
+end
+
+
 context "Dataset#insert_multiple" do
   setup do
     c = Class.new(Sequel::Dataset) do
@@ -1076,11 +1118,69 @@ context "Dataset aggregate methods" do
     @d.avg(:d).should == 'SELECT avg(d) AS v FROM test'
   end
   
-  specify "should accept qualified fields" do
+  specify "should accept qualified columns" do
     @d.avg(:test__bc).should == 'SELECT avg(test.bc) AS v FROM test'
   end
 end
 
+context "Dataset#range" do
+  setup do
+    c = Class.new(Sequel::Dataset) do
+      @@sql = nil
+      
+      def last_sql; @@sql; end
+      
+      def fetch_rows(sql)
+        @@sql = sql
+        yield(:v1 => 1, :v2 => 10)
+      end
+    end
+    @d = c.new(nil).from(:test)
+  end
+  
+  specify "should generate a correct SQL statement" do
+    @d.range(:stamp)
+    @d.last_sql.should == "SELECT min(stamp) AS v1, max(stamp) AS v2 FROM test LIMIT 1"
+
+    @d.filter {:price > 100}.range(:stamp)
+    @d.last_sql.should == "SELECT min(stamp) AS v1, max(stamp) AS v2 FROM test WHERE (price > 100) LIMIT 1"
+  end
+  
+  specify "should return a range object" do
+    @d.range(:tryme).should == (1..10)
+    @d.last_sql.should == "SELECT min(tryme) AS v1, max(tryme) AS v2 FROM test LIMIT 1"
+  end
+end
+
+context "Dataset#range" do
+  setup do
+    c = Class.new(Sequel::Dataset) do
+      @@sql = nil
+      
+      def last_sql; @@sql; end
+      
+      def fetch_rows(sql)
+        @@sql = sql
+        yield(:v => 1234)
+      end
+    end
+    @d = c.new(nil).from(:test)
+  end
+  
+  specify "should generate a correct SQL statement" do
+    @d.interval(:stamp)
+    @d.last_sql.should == "SELECT (max(stamp) - min(stamp)) AS v FROM test LIMIT 1"
+
+    @d.filter {:price > 100}.interval(:stamp)
+    @d.last_sql.should == "SELECT (max(stamp) - min(stamp)) AS v FROM test WHERE (price > 100) LIMIT 1"
+  end
+  
+  specify "should return a range object" do
+    @d.interval(:tryme).should == 1234
+    @d.last_sql.should == "SELECT (max(tryme) - min(tryme)) AS v FROM test LIMIT 1"
+  end
+end
+
 context "Dataset#first" do
   setup do
     @c = Class.new(Sequel::Dataset) do
@@ -2023,6 +2123,10 @@ context "Dataset#transform" do
     @ds.each(:naked => true) {|r| f = r}
     f.should == {:x => "wow", :y => 'hello'}
   end
+  
+  specify "should return self" do
+    @ds.transform(:x => :marshal).should be(@ds)
+  end
 end
 
 context "Dataset#to_csv" do
@@ -2033,7 +2137,7 @@ context "Dataset#to_csv" do
       
       def fetch_rows(sql, &block)
         @columns = @cols
-        @data.each {|r| r.fields = @columns; block[r]}
+        @data.each {|r| r.keys = @columns; block[r]}
       end
       
       # naked should return self here because to_csv wants a naked result set.
@@ -2066,7 +2170,7 @@ context "Dataset#each_hash" 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]}
+        a.each {|r| r.keys = [:a, :b, :c]; block[r]}
       end
     end
     
@@ -2078,4 +2182,85 @@ context "Dataset#each_hash" do
     @ds.each_hash {|h| hashes << h}
     hashes.should == [{:a => 1, :b => 2, :c => 3}, {:a => 4, :b => 5, :c => 6}]
   end
+end
+
+context "Dataset magic methods" do
+  setup do
+    @c = Class.new(Sequel::Dataset) do
+      @@sqls = []
+      
+      def self.sqls; @@sqls; end
+      
+      def fetch_rows(sql)
+        @@sqls << sql
+        yield({:a => 1, :b => 2})
+      end
+    end
+    
+    @ds = @c.new(nil).from(:items)
+  end
+  
+  specify "should support order_by_xxx" do
+    @ds.should_not respond_to(:order_by_name)
+    proc {@ds.order_by_name}.should_not raise_error
+    @ds.should respond_to(:order_by_name)
+    @ds.order_by_name.should be_a_kind_of(@c)
+    @ds.order_by_name.sql.should == "SELECT * FROM items ORDER BY name"
+  end
+
+  specify "should support group_by_xxx" do
+    @ds.should_not respond_to(:group_by_name)
+    proc {@ds.group_by_name}.should_not raise_error
+    @ds.should respond_to(:group_by_name)
+    @ds.group_by_name.should be_a_kind_of(@c)
+    @ds.group_by_name.sql.should == "SELECT * FROM items GROUP BY name"
+  end
+
+  specify "should support count_by_xxx" do
+    @ds.should_not respond_to(:count_by_name)
+    proc {@ds.count_by_name}.should_not raise_error
+    @ds.should respond_to(:count_by_name)
+    @ds.count_by_name.should be_a_kind_of(@c)
+    @ds.count_by_name.sql.should == "SELECT name, count(name) AS count FROM items GROUP BY name ORDER BY count"
+  end
+
+  specify "should support filter_by_xxx" do
+    @ds.should_not respond_to(:filter_by_name)
+    proc {@ds.filter_by_name('sharon')}.should_not raise_error
+    @ds.should respond_to(:filter_by_name)
+    @ds.filter_by_name('sharon').should be_a_kind_of(@c)
+    @ds.filter_by_name('sharon').sql.should == "SELECT * FROM items WHERE (name = 'sharon')"
+  end
+  
+  specify "should support all_by_xxx" do
+    @ds.should_not respond_to(:all_by_name)
+    proc {@ds.all_by_name('sharon')}.should_not raise_error
+    @ds.should respond_to(:all_by_name)
+    @ds.all_by_name('sharon').should == [{:a => 1, :b => 2}]
+    @c.sqls.should == ["SELECT * FROM items WHERE (name = 'sharon')"] * 2
+  end
+  
+  specify "should support find_by_xxx" do
+    @ds.should_not respond_to(:find_by_name)
+    proc {@ds.find_by_name('sharon')}.should_not raise_error
+    @ds.should respond_to(:find_by_name)
+    @ds.find_by_name('sharon').should == {:a => 1, :b => 2}
+    @c.sqls.should == ["SELECT * FROM items WHERE (name = 'sharon') LIMIT 1"] * 2
+  end
+
+  specify "should support first_by_xxx" do
+    @ds.should_not respond_to(:first_by_name)
+    proc {@ds.first_by_name('sharon')}.should_not raise_error
+    @ds.should respond_to(:first_by_name)
+    @ds.first_by_name('sharon').should == {:a => 1, :b => 2}
+    @c.sqls.should == ["SELECT * FROM items ORDER BY name LIMIT 1"] * 2
+  end
+
+  specify "should support last_by_xxx" do
+    @ds.should_not respond_to(:last_by_name)
+    proc {@ds.last_by_name('sharon')}.should_not raise_error
+    @ds.should respond_to(:last_by_name)
+    @ds.last_by_name('sharon').should == {:a => 1, :b => 2}
+    @c.sqls.should == ["SELECT * FROM items ORDER BY name DESC LIMIT 1"] * 2
+  end
 end

data/spec/model_spec.rb

@@ -968,5 +968,75 @@ context "A Model constructor" do
     m.should be_new
   end
   
-  specify "should "
+  specify "should accept a block and yield itself to the block" do
+    block_called = false
+    m = @m.new {|i| block_called = true; i.should be_a_kind_of(@m); i.values[:a] = 1}
+    
+    block_called.should be_true
+    m.values[:a].should == 1
+  end
+end
+
+context "Model magic methods" do
+  setup do
+    @c = Class.new(Sequel::Dataset) do
+      @@sqls = []
+    
+      def self.sqls; @@sqls; end
+    
+      def fetch_rows(sql)
+        @@sqls << sql
+        yield({:id => 123, :name => 'hey'})
+      end
+    end
+  
+    @m = Class.new(Sequel::Model(@c.new(nil).from(:items)))
+  end
+  
+  specify "should support order_by_xxx" do
+    @m.order_by_name.should be_a_kind_of(@c)
+    @m.order_by_name.sql.should == "SELECT * FROM items ORDER BY name"
+  end
+
+  specify "should support group_by_xxx" do
+    @m.group_by_name.should be_a_kind_of(@c)
+    @m.group_by_name.sql.should == "SELECT * FROM items GROUP BY name"
+  end
+
+  specify "should support count_by_xxx" do
+    @m.count_by_name.should be_a_kind_of(@c)
+    @m.count_by_name.sql.should == "SELECT name, count(name) AS count FROM items GROUP BY name ORDER BY count"
+  end
+
+  specify "should support filter_by_xxx" do
+    @m.filter_by_name('sharon').should be_a_kind_of(@c)
+    @m.filter_by_name('sharon').sql.should == "SELECT * FROM items WHERE (name = 'sharon')"
+  end
+  
+  specify "should support all_by_xxx" do
+    all = @m.all_by_name('sharon')
+    all.class.should == Array
+    all.size.should == 1
+    all.first.should be_a_kind_of(@m)
+    all.first.values.should == {:id => 123, :name => 'hey'}
+    @c.sqls.should == ["SELECT * FROM items WHERE (name = 'sharon')"]
+  end
+  
+  specify "should support find_by_xxx" do
+    @m.find_by_name('sharon').should be_a_kind_of(@m)
+    @m.find_by_name('sharon').values.should == {:id => 123, :name => 'hey'}
+    @c.sqls.should == ["SELECT * FROM items WHERE (name = 'sharon') LIMIT 1"] * 2
+  end
+
+  specify "should support first_by_xxx" do
+    @m.first_by_name('sharon').should be_a_kind_of(@m)
+    @m.first_by_name('sharon').values.should == {:id => 123, :name => 'hey'}
+    @c.sqls.should == ["SELECT * FROM items ORDER BY name LIMIT 1"] * 2
+  end
+
+  specify "should support last_by_xxx" do
+    @m.last_by_name('sharon').should be_a_kind_of(@m)
+    @m.last_by_name('sharon').values.should == {:id => 123, :name => 'hey'}
+    @c.sqls.should == ["SELECT * FROM items ORDER BY name DESC LIMIT 1"] * 2
+  end
 end

data/spec/schema_generator_spec.rb

@@ -13,9 +13,9 @@ describe Sequel::Schema::Generator do
     @table_name, @columns, @indexes = @generator.create_info
   end
   
-  {:name => :id, :primary_key => true}.each do |field, expected|
-    it "uses default primary key #{field}" do
-      @columns.first[field].should == expected
+  {:name => :id, :primary_key => true}.each do |column, expected|
+    it "uses default primary key #{column}" do
+      @columns.first[column].should == expected
     end
   end
   

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.4
 specification_version: 1
 name: sequel
 version: !ruby/object:Gem::Version 
-  version: 0.3.1
-date: 2007-10-30 00:00:00 +02:00
+  version: 0.3.2
+date: 2007-11-01 00:00:00 +02:00
 summary: Lightweight ORM library for Ruby
 require_paths: 
 - lib
@@ -33,6 +33,7 @@ files:
 - README
 - Rakefile
 - bin/sequel
+- doc/rdoc
 - spec/adapters
 - spec/adapters/mysql_spec.rb
 - spec/adapters/postgres_spec.rb
@@ -60,9 +61,9 @@ files:
 - lib/sequel/dataset/sequelizer.rb
 - lib/sequel/dataset/sql.rb
 - lib/sequel/dataset.rb
+- lib/sequel/db2.rb
 - lib/sequel/dbi.rb
 - lib/sequel/error.rb
-- lib/sequel/expressions.rb
 - lib/sequel/migration.rb
 - lib/sequel/model
 - lib/sequel/model/base.rb