sequel 0.4.4.2 → 0.4.5

data/lib/sequel/schema/schema_generator.rb

@@ -102,6 +102,14 @@ module Sequel
         }
       end
       
+      def set_column_default(name, default)
+        @operations << {
+          :op => :set_column_default,
+          :name => name,
+          :default => default
+        }
+      end
+      
       def add_index(columns, opts = {})
         columns = [columns] unless columns.is_a?(Array)
         @operations << {

data/lib/sequel/schema/schema_sql.rb

@@ -115,6 +115,8 @@ module Sequel
           "ALTER TABLE #{table} RENAME COLUMN #{literal(op[:name])} TO #{literal(op[:new_name])}"
         when :set_column_type
           "ALTER TABLE #{table} ALTER COLUMN #{literal(op[:name])} TYPE #{op[:type]}"
+        when :set_column_default
+          "ALTER TABLE #{table} ALTER COLUMN #{literal(op[:name])} SET DEFAULT #{literal(op[:default])}"
         when :add_index
           index_definition_sql(table, op)
         when :drop_index

data/spec/database_spec.rb

@@ -240,6 +240,7 @@ context "Database#alter_table" do
       drop_column :bbb
       rename_column :ccc, :ddd
       set_column_type :eee, :integer
+      set_column_default :hhh, 'abcd'
       
       add_index :fff, :unique => true
       drop_index :ggg
@@ -250,6 +251,7 @@ context "Database#alter_table" do
       'ALTER TABLE xyz DROP COLUMN bbb',
       'ALTER TABLE xyz RENAME COLUMN ccc TO ddd',
       'ALTER TABLE xyz ALTER COLUMN eee TYPE integer',
+      "ALTER TABLE xyz ALTER COLUMN hhh SET DEFAULT 'abcd'",
       
       'CREATE UNIQUE INDEX xyz_fff_index ON xyz (fff)',
       'DROP INDEX xyz_ggg_index'
@@ -309,6 +311,19 @@ context "Database#set_column_type" do
   end
 end
 
+context "Database#set_column_default" do
+  setup do
+    @db = DummyDatabase.new
+  end
+  
+  specify "should construct proper SQL" do
+    @db.set_column_default :test, :name, 'zyx'
+    @db.sqls.should == [
+      "ALTER TABLE test ALTER COLUMN name SET DEFAULT 'zyx'"
+    ]
+  end
+end
+
 context "Database#add_index" do
   setup do
     @db = DummyDatabase.new

data/spec/dataset_spec.rb

@@ -2375,4 +2375,13 @@ context "Dataset#update_sql" do
   specify "should accept strings" do
     @ds.update_sql("a = b").should == "UPDATE items SET a = b"
   end
+  
+  specify "should accept hash with string keys" do
+    @ds.update_sql('c' => 'd').should == "UPDATE items SET c = 'd'"
+  end
+
+  specify "should accept array subscript references" do
+    @ds.update_sql((:day|1) => 'd').should == "UPDATE items SET day[1] = 'd'"
+  end
+
 end

data/spec/model/base_spec.rb

@@ -0,0 +1,148 @@
+describe "Model attribute setters" do
+
+  before(:each) do
+    MODEL_DB.reset
+
+    @c = Class.new(Sequel::Model(:items)) do
+      def columns
+        [:id, :x, :y]
+      end
+    end
+  end
+
+  it "should mark the column value as changed" do
+    o = @c.new
+    o.changed_columns.should == []
+
+    o.x = 2
+    o.changed_columns.should == [:x]
+
+    o.y = 3
+    o.changed_columns.should == [:x, :y]
+
+    o.changed_columns.clear
+
+    o[:x] = 2
+    o.changed_columns.should == [:x]
+
+    o[:y] = 3
+    o.changed_columns.should == [:x, :y]
+  end
+
+end
+
+describe "Model#serialize" do
+
+  before(:each) do
+    MODEL_DB.reset
+  end
+
+  it "should translate values to YAML when creating records" do
+    @c = Class.new(Sequel::Model(:items)) do
+      no_primary_key
+      serialize :abc
+    end
+
+    @c.create(:abc => 1)
+    @c.create(:abc => "hello")
+
+    MODEL_DB.sqls.should == [ \
+      "INSERT INTO items (abc) VALUES ('--- 1\n')", \
+      "INSERT INTO items (abc) VALUES ('--- hello\n')", \
+    ]
+  end
+
+  it "should support calling after the class is defined" do
+    @c = Class.new(Sequel::Model(:items)) do
+      no_primary_key
+    end
+
+    @c.serialize :def
+
+    @c.create(:def => 1)
+    @c.create(:def => "hello")
+
+    MODEL_DB.sqls.should == [ \
+      "INSERT INTO items (def) VALUES ('--- 1\n')", \
+      "INSERT INTO items (def) VALUES ('--- hello\n')", \
+    ]
+  end
+
+  it "should support using the Marshal format" do
+    @c = Class.new(Sequel::Model(:items)) do
+      no_primary_key
+      serialize :abc, :format => :marshal
+    end
+
+    @c.create(:abc => 1)
+    @c.create(:abc => "hello")
+
+    MODEL_DB.sqls.should == [ \
+      "INSERT INTO items (abc) VALUES ('\004\bi\006')", \
+      "INSERT INTO items (abc) VALUES ('\004\b\"\nhello')", \
+    ]
+  end
+
+  it "should translate values to and from YAML using accessor methods" do
+    @c = Class.new(Sequel::Model(:items)) do
+      serialize :abc, :def
+    end
+
+    ds = @c.dataset
+    ds.extend(Module.new {
+      attr_accessor :raw
+
+      def fetch_rows(sql, &block)
+        block.call(@raw)
+      end
+
+      @@sqls = nil
+
+      def insert(*args)
+        @@sqls = insert_sql(*args)
+      end
+
+      def update(*args)
+        @@sqls = update_sql(*args)
+      end
+
+      def sqls
+        @@sqls
+      end
+
+      def columns
+        [:id, :abc, :def]
+      end
+    }
+    )
+
+    ds.raw = {:id => 1, :abc => "--- 1\n", :def => "--- hello\n"}
+    o = @c.first
+    o.id.should == 1
+    o.abc.should == 1
+    o.def.should == "hello"
+
+    o.set(:abc => 23)
+    ds.sqls.should == "UPDATE items SET abc = '#{23.to_yaml}' WHERE (id = 1)"
+
+    ds.raw = {:id => 1, :abc => "--- 1\n", :def => "--- hello\n"}
+    o = @c.create(:abc => [1, 2, 3])
+    ds.sqls.should == "INSERT INTO items (abc) VALUES ('#{[1, 2, 3].to_yaml}')"
+  end
+
+end
+
+describe Sequel::Model, "super_dataset" do
+  
+  before(:each) do
+    MODEL_DB.reset
+    class SubClass < Sequel::Model(:items) ; end
+  end
+  
+  it "should call the superclass's dataset" do
+    SubClass.should_receive(:superclass).exactly(3).times.and_return(Sequel::Model(:items))
+    Sequel::Model(:items).should_receive(:dataset)
+    SubClass.super_dataset
+  end
+
+end

data/spec/model/caching_spec.rb

@@ -0,0 +1,148 @@
+describe Sequel::Model, "caching" do
+
+  before(:each) do
+    MODEL_DB.reset
+    
+    @cache_class = Class.new(Hash) do
+      attr_accessor :ttl
+      def set(k, v, ttl); self[k] = v; @ttl = ttl; end
+      def get(k); self[k]; end
+    end
+    cache = @cache_class.new
+    @cache = cache
+    
+    @c = Class.new(Sequel::Model(:items)) do
+      set_cache cache
+      
+      def self.columns
+        [:name, :id]
+      end
+    end
+    
+    $cache_dataset_row = {:name => 'sharon', :id => 1}
+    @dataset = @c.dataset
+    $sqls = []
+    @dataset.extend(Module.new {
+      def fetch_rows(sql)
+        $sqls << sql
+        yield $cache_dataset_row
+      end
+      
+      def update(values)
+        $sqls << update_sql(values)
+        $cache_dataset_row.merge!(values)
+      end
+      
+      def delete
+        $sqls << delete_sql
+      end
+    })
+  end
+  
+  it "should set the model's cache store" do
+    @c.cache_store.should be(@cache)
+  end
+  
+  it "should have a default ttl of 3600" do
+    @c.cache_ttl.should == 3600
+  end
+  
+  it "should take a ttl option" do
+    @c.set_cache @cache, :ttl => 1234
+    @c.cache_ttl.should == 1234
+  end
+  
+  it "should offer a set_cache_ttl method for setting the ttl" do
+    @c.cache_ttl.should == 3600
+    @c.set_cache_ttl 1234
+    @c.cache_ttl.should == 1234
+  end
+  
+  it "should generate a cache key appropriate to the class" do
+    m = @c.new
+    m.values[:id] = 1
+    m.cache_key.should == "#{m.class}:1"
+    
+    # custom primary key
+    @c.set_primary_key :ttt
+    m = @c.new
+    m.values[:ttt] = 333
+    m.cache_key.should == "#{m.class}:333"
+    
+    # composite primary key
+    @c.set_primary_key [:a, :b, :c]
+    m = @c.new
+    m.values[:a] = 123
+    m.values[:c] = 456
+    m.values[:b] = 789
+    m.cache_key.should == "#{m.class}:123,789,456"
+  end
+  
+  it "should raise error if attempting to generate cache_key and primary key value is null" do
+    m = @c.new
+    proc {m.cache_key}.should raise_error(Sequel::Error)
+    
+    m.values[:id] = 1
+    proc {m.cache_key}.should_not raise_error(Sequel::Error)
+  end
+  
+  it "should set the cache when reading from the database" do
+    $sqls.should == []
+    @cache.should be_empty
+    
+    m = @c[1]
+    $sqls.should == ['SELECT * FROM items WHERE (id = 1) LIMIT 1']
+    m.values.should == $cache_dataset_row
+    @cache[m.cache_key].should == m
+    
+    # read from cache
+    m2 = @c[1]
+    $sqls.should == ['SELECT * FROM items WHERE (id = 1) LIMIT 1']
+    m2.should == m
+    m2.values.should == $cache_dataset_row
+  end
+  
+  it "should delete the cache when writing to the database" do
+    # fill the cache
+    m = @c[1]
+    @cache[m.cache_key].should == m
+    
+    m.set(:name => 'tutu')
+    @cache.has_key?(m.cache_key).should be_false
+    $sqls.last.should == "UPDATE items SET name = 'tutu' WHERE (id = 1)"
+    
+    m = @c[1]
+    @cache[m.cache_key].should == m
+    m.name = 'hey'
+    m.save
+    @cache.has_key?(m.cache_key).should be_false
+    $sqls.last.should == "UPDATE items SET name = 'hey', id = 1 WHERE (id = 1)"
+  end
+  
+  it "should delete the cache when deleting the record" do
+    # fill the cache
+    m = @c[1]
+    @cache[m.cache_key].should == m
+    
+    m.delete
+    @cache.has_key?(m.cache_key).should be_false
+    $sqls.last.should == "DELETE FROM items WHERE (id = 1)"
+  end
+  
+  it "should support #[] as a shortcut to #find with hash" do
+    m = @c[:id => 3]
+    @cache[m.cache_key].should be_nil
+    $sqls.last.should == "SELECT * FROM items WHERE (id = 3) LIMIT 1"
+    
+    m = @c[1]
+    @cache[m.cache_key].should == m
+    $sqls.should == ["SELECT * FROM items WHERE (id = 3) LIMIT 1", \
+      "SELECT * FROM items WHERE (id = 1) LIMIT 1"]
+    
+    @c[:id => 4]
+    $sqls.should == ["SELECT * FROM items WHERE (id = 3) LIMIT 1", \
+      "SELECT * FROM items WHERE (id = 1) LIMIT 1", \
+      "SELECT * FROM items WHERE (id = 4) LIMIT 1"]
+  end
+  
+end

data/spec/model/hooks_spec.rb

@@ -0,0 +1,105 @@
+describe Sequel::Model, "hooks" do
+
+  before do
+    MODEL_DB.reset
+    Sequel::Model.hooks.clear
+
+    @hooks = %w[
+      before_save before_create before_update before_destroy
+      after_save after_create after_update after_destroy
+    ].select { |hook| !hook.empty? }
+  end
+
+  it "should have hooks for everything" do
+    Sequel::Model.methods.should include('hooks')
+    Sequel::Model.methods.should include(*@hooks)
+    @hooks.each do |hook|
+      Sequel::Model.hooks[hook.to_sym].should be_an_instance_of(Array)
+    end
+  end
+
+  it "should be inherited" do
+    pending 'soon'
+
+    @hooks.each do |hook|
+      Sequel::Model.send(hook.to_sym) { nil }
+    end
+
+    model = Class.new Sequel::Model(:models)
+    model.hooks.should == Sequel::Model.hooks
+  end
+
+  it "should run hooks" do
+    pending 'soon'
+
+    test = mock 'Test'
+    test.should_receive(:run).exactly(@hooks.length)
+
+    @hooks.each do |hook|
+      Sequel::Model.send(hook.to_sym) { test.run }
+    end
+
+    model = Class.new Sequel::Model(:models)
+    model.hooks.should == Sequel::Model.hooks
+
+    model_instance = model.new
+    @hooks.each { |hook| model_instance.run_hooks(hook) }
+  end
+
+  it "should run hooks around save and create" do
+    pending 'test execution'
+  end
+
+  it "should run hooks around save and update" do
+    pending 'test execution'
+  end
+
+  it "should run hooks around delete" do
+    pending 'test execution'
+  end
+
+end
+
+describe "Model.after_create" do
+
+  before(:each) do
+    MODEL_DB.reset
+
+    @c = Class.new(Sequel::Model(:items)) do
+      def columns
+        [:id, :x, :y]
+      end
+    end
+
+    ds = @c.dataset
+    def ds.insert(*args)
+      super(*args)
+      1
+    end
+  end
+
+  it "should be called after creation" do
+    s = []
+
+    @c.after_create do
+      s = MODEL_DB.sqls.dup
+    end
+
+    n = @c.create(:x => 1)
+    MODEL_DB.sqls.should == ["INSERT INTO items (x) VALUES (1)", "SELECT * FROM items WHERE (id = 1) LIMIT 1"]
+    s.should == ["INSERT INTO items (x) VALUES (1)", "SELECT * FROM items WHERE (id = 1) LIMIT 1"]
+  end
+
+  it "should allow calling save in the hook" do
+    @c.after_create do
+      values.delete(:x)
+      self.id = 2
+      save
+    end
+
+    n = @c.create(:id => 1)
+    MODEL_DB.sqls.should == ["INSERT INTO items (id) VALUES (1)", "SELECT * FROM items WHERE (id = 1) LIMIT 1", "UPDATE items SET id = 2 WHERE (id = 1)"]
+  end
+
+end
+