sequel 2.4.0 → 2.5.0

data/lib/sequel_model.rb

@@ -13,17 +13,14 @@ module Sequel
   # Lets you create a Model subclass with its dataset already set.
   # source can be an existing dataset or a symbol (in which case
   # it will create a dataset using the default database with 
-  # source as the table name.
+  # source as the table name).
   #
   # Example:
   #   class Comment < Sequel::Model(:something)
   #     table_name # => :something
   #   end
   def self.Model(source)
-    return @models[source] if @models[source]
-    klass = Class.new(Model)
-    klass.set_dataset(source.is_a?(Dataset) ? source : Model.db[source])
-    @models[source] = klass
+    @models[source] ||= Class.new(Model).set_dataset(source)
   end
 
   # Model has some methods that are added via metaprogramming:

data/lib/sequel_model/associations.rb

@@ -297,13 +297,13 @@ module Sequel::Model::Associations
     return if opts[:read_only]
 
     class_def(opts._add_method) do |o|
-      database[join_table].insert(left=>pk, right=>o.pk)
+      database.dataset.from(join_table).insert(left=>pk, right=>o.pk)
     end
     class_def(opts._remove_method) do |o|
-      database[join_table].filter([[left, pk], [right, o.pk]]).delete
+      database.dataset.from(join_table).filter([[left, pk], [right, o.pk]]).delete
     end
     class_def(opts._remove_all_method) do
-      database[join_table].filter(left=>pk).delete
+      database.dataset.from(join_table).filter(left=>pk).delete
     end
     private opts._add_method, opts._remove_method, opts._remove_all_method
 

data/lib/sequel_model/base.rb

@@ -206,7 +206,7 @@ module Sequel
           if sup_class == Model
             subclass.set_dataset(Model.db[subclass.implicit_table_name]) unless subclass.name.blank?
           elsif ds = sup_class.instance_variable_get(:@dataset)
-            subclass.set_dataset(sup_class.sti_key ? sup_class.sti_dataset.filter(sup_class.sti_key=>subclass.name.to_s) : ds.clone)
+            subclass.set_dataset(sup_class.sti_key ? sup_class.sti_dataset.filter(sup_class.sti_key=>subclass.name.to_s) : ds.clone, :inherited=>true)
           end
         rescue
           nil
@@ -308,7 +308,8 @@ module Sequel
     # if there is one associated with the model. Finally, it attempts to 
     # determine the database schema based on the given/created dataset unless
     # lazy_load_schema is set.
-    def self.set_dataset(ds)
+    def self.set_dataset(ds, opts={})
+      inherited = opts[:inherited]
       @dataset = case ds
       when Symbol
         db[ds]
@@ -319,13 +320,15 @@ module Sequel
         raise(Error, "Model.set_dataset takes a Symbol or a Sequel::Dataset")
       end
       @dataset.set_model(self)
-      @dataset.extend(DatasetMethods)
-      @dataset.extend(Associations::EagerLoading)
       @dataset.transform(@transform) if @transform
-      @dataset_methods.each{|meth, block| @dataset.meta_def(meth, &block)} if @dataset_methods
-      unless @@lazy_load_schema
-        (@db_schema = get_db_schema) rescue nil
+      if inherited
+        ((@columns = @dataset.columns) rescue nil) unless @@lazy_load_schema
+      else
+        @dataset.extend(DatasetMethods)
+        @dataset.extend(Associations::EagerLoading)
+        @dataset_methods.each{|meth, block| @dataset.meta_def(meth, &block)} if @dataset_methods
       end
+      ((@db_schema = inherited ? superclass.db_schema : get_db_schema) rescue nil) unless @@lazy_load_schema
       self
     end
     metaalias :dataset=, :set_dataset
@@ -425,15 +428,18 @@ module Sequel
     
     # Create the column accessors
     def self.def_column_accessor(*columns) # :nodoc:
+      include(@column_accessors_module = Module.new) unless @column_accessors_module
       columns.each do |column|
         im = instance_methods.collect{|x| x.to_s}
         meth = "#{column}="
-         define_method(column){self[column]} unless im.include?(column.to_s)
-        unless im.include?(meth)
-          define_method(meth) do |*v|
-            len = v.length
-            raise(ArgumentError, "wrong number of arguments (#{len} for 1)") unless len == 1
-            self[column] = v.first 
+        @column_accessors_module.module_eval do
+          define_method(column){self[column]} unless im.include?(column.to_s)
+          unless im.include?(meth)
+            define_method(meth) do |*v|
+              len = v.length
+              raise(ArgumentError, "wrong number of arguments (#{len} for 1)") unless len == 1
+              self[column] = v.first 
+            end
           end
         end
       end

data/lib/sequel_model/record.rb

@@ -214,25 +214,33 @@ module Sequel
     # (if !new?) return false, returns nil unless raise_on_save_failure
     # is true.  Otherwise, returns self.
     def save!(*columns)
+      opts = columns.extract_options!
       return save_failure(:save) if before_save == false
       if @new
         return save_failure(:create) if before_create == false
-        iid = model.dataset.insert(@values)
-        # if we have a regular primary key and it's not set in @values,
-        # we assume it's the last inserted id
-        if (pk = primary_key) && !(Array === pk) && !@values[pk]
-          @values[pk] = iid
-        end
-        if pk
-          @this = nil # remove memoized this dataset
-          refresh
+        ds = model.dataset
+        if ds.respond_to?(:insert_select) and h = ds.insert_select(@values)
+          @values = h
+          @this = nil
+        else
+          iid = ds.insert(@values)
+          # if we have a regular primary key and it's not set in @values,
+          # we assume it's the last inserted id
+          if (pk = primary_key) && !(Array === pk) && !@values[pk]
+            @values[pk] = iid
+          end
+          if pk
+            @this = nil # remove memoized this dataset
+            refresh
+          end
         end
         @new = false
         after_create
       else
         return save_failure(:update) if before_update == false
         if columns.empty?
-          this.update(@values)
+          vals = opts[:changed] ? @values.reject{|k,v| !@changed_columns.include?(k)} : @values
+          this.update(vals)
           @changed_columns = []
         else # update only the specified columns
           this.update(@values.reject {|k, v| !columns.include?(k)})
@@ -248,7 +256,7 @@ module Sequel
     # chanaged.  If no columns have been changed, returns nil.  If unable to
     # save, returns false unless raise_on_save_failure is true.
     def save_changes
-      save(*@changed_columns) || false unless @changed_columns.empty?
+      save(:changed=>true) || false unless @changed_columns.empty?
     end
 
     # Updates the instance with the supplied values with support for virtual

data/lib/sequel_model/schema.rb

@@ -1,13 +1,14 @@
 module Sequel
   class Model
-    # Creates table.
+    # Creates table, using the column information from set_schema.
     def self.create_table
       db.create_table(table_name, @schema)
       @db_schema = get_db_schema(true) unless @@lazy_load_schema
       columns
     end
     
-    # Drops the table if it exists and then runs create_table.
+    # Drops the table if it exists and then runs create_table.  Should probably
+    # not be used except in testing.
     def self.create_table!
       drop_table rescue nil
       create_table
@@ -27,8 +28,13 @@ module Sequel
 
     # Defines a table schema (see Schema::Generator for more information).
     #
-    # This is only needed if you want to use the create_table or drop_table
-    # methods.
+    # This is only needed if you want to use the create_table/create_table! methods.
+    # Will also set the dataset if you provide a name, as well as setting
+    # the primary key if you defined one in the passed block.
+    #
+    # In general, it is a better idea to use migrations for production code, as
+    # migrations allow changes to existing schema.  set_schema is mostly useful for
+    # test code or simple examples.
     def self.set_schema(name = nil, &block)
       set_dataset(db[name]) if name
       @schema = Schema::Generator.new(db, &block)

data/lib/sequel_model/validations.rb

@@ -1,5 +1,8 @@
 module Sequel
   class Model
+    # Validations without an :if option are always run
+    DEFAULT_VALIDATION_IF_PROC = proc{true}
+
     # The Validation module houses a couple of classes used by Sequel's
     # validation code.
     module Validation
@@ -20,7 +23,7 @@ module Sequel
         def full_messages
           inject([]) do |m, kv| 
             att, errors = *kv
-            errors.each {|e| m << "#{att} #{e}"}
+            errors.each {|e| m << "#{Array(att).join(' and ')} #{e}"}
             m
           end
         end
@@ -84,7 +87,12 @@ module Sequel
         superclass.validate(o)
       end
       validations.each do |att, procs|
-        v = o.send(att)
+        v = case att
+        when Array
+          att.collect{|a| o.send(a)}
+        else
+          o.send(att)
+        end
         procs.each {|tag, p| p.call(o, att, v)}
       end
     end
@@ -300,6 +308,7 @@ module Sequel
     # database, as this suffers from a fairly obvious race condition.
     #
     # Possible Options:
+    # * :allow_nil - Whether to skip the validation if the value(s) is/are nil (default: false)
     # * :if - A symbol (indicating an instance_method) or proc (which is instance_evaled)
     #   skipping this validation if it returns nil or false.
     # * :message - The message to use (default: 'is already taken')
@@ -311,8 +320,12 @@ module Sequel
 
       atts << {:if=>opts[:if], :tag=>opts[:tag]||:uniqueness}
       validates_each(*atts) do |o, a, v|
-        next if v.blank? 
-        num_dups = o.class.filter(a => v).count
+        error_field = a
+        a = Array(a)
+        v = Array(v)
+        next unless v.any? or opts[:allow_nil] == false
+        ds = o.class.filter(a.zip(v))
+        num_dups = ds.count
         allow = if num_dups == 0
           # No unique value in the database
           true
@@ -323,13 +336,13 @@ module Sequel
         elsif o.new?
           # New record, but unique value already exists in the database
           false
-        elsif o.class[a => v].pk == o.pk
+        elsif ds.first === o
           # Unique value exists in database, but for the same record, so the update won't cause a duplicate record
           true
         else
           false
         end
-        o.errors[a] << opts[:message] unless allow
+        o.errors[error_field] << opts[:message] unless allow
       end
     end
 
@@ -344,7 +357,7 @@ module Sequel
       case opts[:if]
       when Symbol then proc{send opts[:if]}
       when Proc then opts[:if]
-      when nil then proc{true}
+      when nil then DEFAULT_VALIDATION_IF_PROC
       else raise(::Sequel::Error, "invalid value for :if validation option")
       end
     end

data/spec/adapters/mysql_spec.rb

@@ -423,7 +423,7 @@ context "A MySQL database" do
     @db[:test2] << {:name => 'mmm', :value => 111, :tre => 'qqqq'}
 
     @db[:test2].columns.should == [:name, :value, :zyx, :tre]
-    @db.rename_column :test2, :tre, :ert, :type => :varchar[255]
+    @db.rename_column :test2, :tre, :ert, :type => :varchar, :size=>255
     @db[:test2].columns.should == [:name, :value, :zyx, :ert]
     @db[:test2].first[:ert].should == 'qqqq'
   end

data/spec/adapters/postgres_spec.rb

@@ -21,6 +21,10 @@ POSTGRES_DB.create_table! :test4 do
   varchar :name, :size => 20
   bytea :value
 end
+POSTGRES_DB.create_table! :test5 do
+  primary_key :xid
+  integer :value
+end
 
 context "A PostgreSQL database" do
   setup do
@@ -150,11 +154,11 @@ context "A PostgreSQL dataset" do
     @d.select(:test[:abc__def, 'hello'].as(:x2)).sql.should == \
       "SELECT test(\"abc\".\"def\", 'hello') AS \"x2\" FROM \"test\""
 
-    @d.insert_sql(:value => 333).should == \
-      'INSERT INTO "test" ("value") VALUES (333)'
+    @d.insert_sql(:value => 333).should =~ \
+      /\AINSERT INTO "test" \("value"\) VALUES \(333\)( RETURNING NULL)?\z/
 
-    @d.insert_sql(:x => :y).should == \
-      'INSERT INTO "test" ("x") VALUES ("y")'
+    @d.insert_sql(:x => :y).should =~ \
+      /\AINSERT INTO "test" \("x"\) VALUES \("y"\)( RETURNING NULL)?\z/
   end
   
   specify "should quote fields correctly when reversing the order if quoting identifiers" do
@@ -275,7 +279,7 @@ context "A PostgreSQL dataset" do
   end
 end
 
-context "A PostgreSQL dataaset with a timestamp field" do
+context "A PostgreSQL dataset with a timestamp field" do
   setup do
     @d = POSTGRES_DB[:test3]
     @d.delete
@@ -417,7 +421,7 @@ context "Postgres::Dataset#multi_insert_sql / #import" do
   end
   
   specify "should return separate insert statements if server_version < 80200" do
-    @ds.db.meta_def(:server_version) {80199}
+    @ds.meta_def(:server_version){80199}
     
     @ds.multi_insert_sql([:x, :y], [[1, 2], [3, 4]]).should == [
       'INSERT INTO test (x, y) VALUES (1, 2)',
@@ -426,16 +430,67 @@ context "Postgres::Dataset#multi_insert_sql / #import" do
   end
   
   specify "should a single insert statement if server_version >= 80200" do
-    @ds.db.meta_def(:server_version) {80200}
-    
+    @ds.meta_def(:server_version){80200}
+   
     @ds.multi_insert_sql([:x, :y], [[1, 2], [3, 4]]).should == [
       'INSERT INTO test (x, y) VALUES (1, 2), (3, 4)'
     ]
 
-    @ds.db.meta_def(:server_version) {80201}
+    @ds.meta_def(:server_version){80201}
     
     @ds.multi_insert_sql([:x, :y], [[1, 2], [3, 4]]).should == [
       'INSERT INTO test (x, y) VALUES (1, 2), (3, 4)'
     ]
   end
 end
+
+context "Postgres::Dataset#insert" do
+  setup do
+    @ds = POSTGRES_DB[:test5]
+    @ds.delete
+  end
+  
+  specify "should call insert_sql if server_version < 80200" do
+    @ds.meta_def(:server_version){80100}
+    @ds.should_receive(:execute_insert).once.with('INSERT INTO test5 (value) VALUES (10)', :table=>:test5, :values=>{:value=>10})
+    @ds.insert(:value=>10)
+  end
+
+  specify "should using call insert_returning_sql if server_version >= 80200" do
+    @ds.meta_def(:server_version){80201}
+    @ds.should_receive(:single_value).once.with(:sql=>'INSERT INTO test5 (value) VALUES (10) RETURNING xid')
+    @ds.insert(:value=>10)
+  end
+
+  specify "should have insert_returning_sql use the RETURNING keyword" do
+    @ds.insert_returning_sql(:xid, :value=>10).should == "INSERT INTO test5 (value) VALUES (10) RETURNING xid"
+    @ds.insert_returning_sql('*'.lit, :value=>10).should == "INSERT INTO test5 (value) VALUES (10) RETURNING *"
+  end
+
+  specify "should have insert_select return nil if server_version < 80200" do
+    @ds.meta_def(:server_version){80100}
+    @ds.insert_select(:value=>10).should == nil
+  end
+
+  specify "should have insert_select insert the record and return the inserted record if server_version < 80200" do
+    @ds.meta_def(:server_version){80201}
+    h = @ds.insert_select(:value=>10)
+    h[:value].should == 10
+    @ds.first(:xid=>h[:xid])[:value].should == 10
+  end
+
+  specify "should correctly return the inserted record's primary key value" do
+    value1 = 10
+    id1 = @ds.insert(:value=>value1)
+    @ds.first(:xid=>id1)[:value].should == value1
+    value2 = 20
+    id2 = @ds.insert(:value=>value2)
+    @ds.first(:xid=>id2)[:value].should == value2
+  end
+
+  specify "should return nil if the table has no primary key" do
+    ds = POSTGRES_DB[:test4]
+    ds.delete
+    ds.insert(:name=>'a').should == nil
+  end
+end

data/spec/integration/dataset_test.rb

@@ -49,3 +49,35 @@ describe "Simple Dataset operations" do
     sqls_should_be('SELECT * FROM items LIMIT 1')
   end
 end
+
+describe "Simple Dataset operations in transactions" do
+  before do
+    INTEGRATION_DB.create_table!(:items_insert_in_transaction) do
+      primary_key :id
+      integer :number
+    end
+    @ds = INTEGRATION_DB[:items_insert_in_transaction]
+    clear_sqls
+  end
+  after do
+    INTEGRATION_DB.drop_table(:items_insert_in_transaction)
+  end
+
+  specify "should insert correctly with a primary key specified inside a transaction" do
+    INTEGRATION_DB.transaction do
+      @ds.insert(:id=>100, :number=>20)
+      sqls_should_be(/INSERT INTO items_insert_in_transaction \((number, id|id, number)\) VALUES \((100, 20|20, 100)\)/)
+      @ds.count.should == 1
+      @ds.order(:id).all.should == [{:id=>100, :number=>20}]
+    end
+  end
+  
+  specify "should have insert return primary key value inside a transaction" do
+    INTEGRATION_DB.transaction do
+      @ds.insert(:number=>20).should == 1
+      sqls_should_be(/INSERT INTO items_insert_in_transaction \(number\) VALUES \(20\)/)
+      @ds.count.should == 1
+      @ds.order(:id).all.should == [{:id=>1, :number=>20}]
+    end
+  end
+end

data/spec/sequel_core/core_sql_spec.rb

@@ -367,20 +367,46 @@ context "String#to_time" do
 end
 
 context "String#to_date" do
+  after do
+    Sequel.convert_two_digit_years = true
+  end
+
   specify "should convert the string into a Date object" do
     "2007-07-11".to_date.should == Date.parse("2007-07-11")
   end
   
+  specify "should convert 2 digit years by default" do
+    "July 11, 07".to_date.should == Date.parse("2007-07-11")
+  end
+
+  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
+
   specify "should raise Error::InvalidValue for an invalid date" do
     proc {'0000-00-00'.to_date}.should raise_error(Sequel::Error::InvalidValue)
   end
 end
 
 context "String#to_datetime" do
+  after do
+    Sequel.convert_two_digit_years = true
+  end
+
   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 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
+
+  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
+
   specify "should raise Error::InvalidValue for an invalid date" do
     proc {'0000-00-00'.to_datetime}.should raise_error(Sequel::Error::InvalidValue)
   end
@@ -389,6 +415,7 @@ end
 context "String#to_sequel_time" do
   after do
     Sequel.datetime_class = Time
+    Sequel.convert_two_digit_years = true
   end
 
   specify "should convert the string into a Time object by default" do
@@ -402,6 +429,17 @@ context "String#to_sequel_time" do
     "2007-07-11 10:11:12a".to_sequel_time.should == DateTime.parse("2007-07-11 10:11:12a")
   end
   
+  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
+
+  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
+
   specify "should raise Error::InvalidValue for an invalid time" do
     proc {'0000-00-00'.to_sequel_time}.should raise_error(Sequel::Error::InvalidValue)
     Sequel.datetime_class = DateTime