sequel 3.44.0 → 3.45.0

data/lib/sequel/plugins/unlimited_update.rb

@@ -0,0 +1,31 @@
+module Sequel
+  module Plugins
+    # The unlimited_update plugin is designed to work around a
+    # MySQL warning in replicated environments, which occurs if
+    # you issue an UPDATE with a LIMIT clause.  No other
+    # database Sequel supports will create an UPDATE clause with
+    # a LIMIT, and in non-replicated MySQL environments, MySQL
+    # doesn't issue a warning.  Note that even in replicated
+    # environments the MySQL warning is harmless, as Sequel
+    # restricts an update to rows with a matching primary key,
+    # which should be unique.
+    #
+    # Usage:
+    #
+    #   # Make all model subclass not use a limit for update
+    #   Sequel::Model.plugin :unlimited_update
+    #
+    #   # Make the Album class not use a limit for update
+    #   Album.plugin :unlimited_update
+    module UnlimitedUpdate
+      module InstanceMethods
+        private
+
+        # Use an unlimited dataset for updates.
+        def _update_dataset
+          super.unlimited
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/validation_class_methods.rb

@@ -432,10 +432,12 @@ module Sequel
         # Handle the :if option for validations
         def validation_if_proc(o, i)
           case i
-          when Symbol then o.send(i)
-          when Proc then o.instance_eval(&i)
-          when nil then true
-          else raise(::Sequel::Error, "invalid value for :if validation option")
+          when Symbol
+            o.send(i)
+          when Proc
+            o.instance_eval(&i)
+          else
+            raise(::Sequel::Error, "invalid value for :if validation option")
           end
         end
       end

data/lib/sequel/plugins/xml_serializer.rb

@@ -57,32 +57,54 @@ module Sequel
     #     </artist>
     #   </album>
     #
+    # +to_xml+ also exists as a class and dataset method, both
+    # of which return all objects in the dataset:
+    #
+    #   Album.to_xml
+    #   Album.filter(:artist_id=>1).to_xml(:include=>:tags)
+    #
+    # If you have an existing array of model instances you want to convert to
+    # XML, you can call the class to_xml method with the :array option:
+    #
+    #   Album.to_xml(:array=>[Album[1], Album[2]])
+    #
     # In addition to creating XML, this plugin also enables Sequel::Model
-    # objects to be created by parsing XML:
+    # classes to create instances directly from XML using the from_xml class
+    # method:
     #
     #   xml = album.to_xml
     #   album = Album.from_xml(xml)
     #
-    # In addition, you can update existing model objects directly from XML
-    # using +from_xml+:
+    # The array_from_xml class method exists to parse arrays of model instances
+    # from xml:
     #
-    #   album.from_xml(xml)
+    #   xml = Album.filter(:artist_id=>1).to_xml
+    #   albums = Album.array_from_xml(xml)
     #
-    # Additionally, +to_xml+ also exists as a class and dataset method, both
-    # of which return all objects in the dataset:
+    # These does not necessarily round trip, since doing so would let users
+    # create model objects with arbitrary values.  By default, from_xml will
+    # call set using values from the tags in the xml.  If you want to specify the allowed
+    # fields, you can use the :fields option, which will call set_fields with
+    # the given fields:
     #
-    #   Album.to_xml
-    #   Album.filter(:artist_id=>1).to_xml(:include=>:tags)
+    #   Album.from_xml(album.to_xml, :fields=>%w'id name')
     #
-    # Such XML can be loaded back into an array of Sequel::Model objects using
-    # +array_from_xml+:
+    # If you want to update an existing instance, you can use the from_xml
+    # instance method:
     #
-    #   Album.array_from_xml(Album.to_xml) # same as Album.all
+    #   album.from_xml(xml)
     #
-    # If you have an existing array of model instances you want to convert to
-    # XML, you can call the class to_xml method with the :array option:
+    # Both of these allow creation of cached associated objects, if you provide
+    # the :associations option:
     #
-    #   Album.to_xml(:array=>[Album[1], Album[2]])
+    #   album.from_xml(xml, :associations=>:artist)
+    #
+    # You can even provide options when setting up the associated objects:
+    #
+    #   album.from_xml(xml, :associations=>{:artist=>{:fields=>%w'id name', :associations=>:tags}})
+    #
+    # If the xml is trusted and should be allowed to set all column and association
+    # values, you can use the :all_columns and :all_associations options.
     #
     # Usage:
     #
@@ -109,7 +131,11 @@ module Sequel
         # Return an array of instances of this class based on
         # the provided XML.
         def array_from_xml(xml, opts={})
-          Nokogiri::XML(xml).children.first.children.reject{|c| c.is_a?(Nokogiri::XML::Text)}.map{|c| from_xml_node(c, opts)}
+          node = Nokogiri::XML(xml).children.first
+          unless node 
+            raise Error, "Malformed XML used"
+          end
+          node.children.reject{|c| c.is_a?(Nokogiri::XML::Text)}.map{|c| from_xml_node(c, opts)}
         end
 
         # Return an instance of this class based on the provided
@@ -193,30 +219,107 @@ module Sequel
 
         # Update the contents of this instance based on the given 
         # XML node, which should be a Nokogiri::XML::Node instance.
+        # By default, just calls set with a hash created from the content of the node.
+        # 
+        # Options:
+        # :all_associations :: Indicates that all associations supported by the model should be tried.
+        #                      This option also cascades to associations if used. It is better to use the
+        #                      :associations option instead of this option. This option only exists for
+        #                      backwards compatibility.
+        # :all_columns :: Overrides the setting logic allowing all setter methods be used,
+        #                 even if access to the setter method is restricted.
+        #                 This option cascades to associations if used, and can be reset in those associations
+        #                 using the :all_columns=>false or :fields options.  This option is considered a
+        #                 security risk, and only exists for backwards compatibility.  It is better to use
+        #                 the :fields option appropriately instead of this option, or no option at all.
+        # :associations :: Indicates that the associations cache should be updated by creating
+        #                  a new associated object using data from the hash.  Should be a Symbol
+        #                  for a single association, an array of symbols for multiple associations,
+        #                  or a hash with symbol keys and dependent association option hash values.
+        # :fields :: Changes the behavior to call set_fields using the provided fields, instead of calling set.
         def from_xml_node(parent, opts={})
-          cols = model.columns.map{|x| x.to_s}
-          assocs = {}
-          model.associations.map{|x| assocs[x.to_s] = model.association_reflection(x)}
-          meths = send(:setter_methods, nil, nil)
+          unless parent
+            raise Error, "Malformed XML used"
+          end
+          if !parent.children.empty? && parent.children.all?{|node| node.is_a?(Nokogiri::XML::Text)}
+            raise Error, "XML consisting of just text nodes used"
+          end
+
+          unless assocs = opts[:associations]
+            if opts[:all_associations]
+              assocs = {}
+              model.associations.each{|v| assocs[v] = {:all_associations=>true}}
+            end
+          end
+
+          if assocs
+            assocs = case assocs
+            when Symbol
+              {assocs=>{}}
+            when Array
+              assocs_tmp = {}
+              assocs.each{|v| assocs_tmp[v] = {}}
+              assocs_tmp
+            when Hash
+              assocs
+            else
+              raise Error, ":associations should be Symbol, Array, or Hash if present"
+            end
+
+            if opts[:all_columns]
+              assocs.each_value do |assoc_opts|
+                assoc_opts[:all_columns] = true unless assoc_opts.has_key?(:fields) || assoc_opts.has_key?(:all_columns)
+              end
+            end
+
+            assocs_hash = {}
+            assocs.each{|k,v| assocs_hash[k.to_s] = v}
+            assocs_present = []
+          end
+
+          hash = {}
           name_proc = model.xml_deserialize_name_proc(opts)
           parent.children.each do |node|
             next if node.is_a?(Nokogiri::XML::Text)
             k = name_proc[node.name]
-            if ar = assocs[k]
-              klass = ar.associated_class
-              associations[k.to_sym] = if ar.returns_array?
-                node.children.reject{|c| c.is_a?(Nokogiri::XML::Text)}.map{|c| klass.from_xml_node(c)}
+            if assocs_hash && (assoc = assocs_hash[k])
+              assocs_present << [k.to_sym, node]
+            else
+              hash[k] = node.key?('nil') ? nil : node.children.first.to_s
+            end
+          end
+
+          if assocs_present
+            assocs_present.each do |assoc, node|
+              assoc_opts = assocs[assoc]
+
+              unless r = model.association_reflection(assoc)
+                raise Error, "Association #{assoc} is not defined for #{model}"
+              end
+
+              associations[assoc] = if r.returns_array?
+                node.children.reject{|c| c.is_a?(Nokogiri::XML::Text)}.map{|c| r.associated_class.from_xml_node(c, assoc_opts)}
               else
-                klass.from_xml_node(node)
+                r.associated_class.from_xml_node(node, assoc_opts)
+              end
+            end
+          end
+
+          if fields = opts[:fields]
+            set_fields(hash, fields, opts)
+          elsif opts[:all_columns]
+            meths = methods.collect{|x| x.to_s}.grep(Model::SETTER_METHOD_REGEXP) - Model::RESTRICTED_SETTER_METHODS
+            hash.each do |k, v|
+              if meths.include?(setter_meth = "#{k}=")
+                send(setter_meth, v)
+              else
+                raise Error, "Entry in XML does not have a matching setter method: #{k}"
               end
-            elsif cols.include?(k)
-              self[k.to_sym] = node.key?('nil') ? nil : node.children.first.to_s
-            elsif meths.include?("#{k}=")
-              send("#{k}=", node.key?('nil') ? nil : node.children.first.to_s)
-            else
-              raise Error, "Entry in XML not an association or column and no setter method exists: #{k}"
             end
+          else
+            set(hash)
           end
+
           self
         end
 

data/lib/sequel/sql.rb

@@ -1,5 +1,6 @@
 module Sequel
   if RUBY_VERSION < '1.9.0'
+  # :nocov:
     # If on Ruby 1.8, create a <tt>Sequel::BasicObject</tt> class that is similar to the
     # the Ruby 1.9 +BasicObject+ class.  This is used in a few places where proxy
     # objects are needed that respond to any method call.
@@ -16,6 +17,7 @@ module Sequel
       end
       remove_methods!
     end
+  # :nocov:
   else
     # If on 1.9, create a <tt>Sequel::BasicObject</tt> class that is just like the
     # default +BasicObject+ class, except that missing constants are resolved in

data/lib/sequel/timezones.rb

@@ -168,9 +168,11 @@ module Sequel
           if v.respond_to?(:to_datetime)
             v.to_datetime
           else
+          # :nocov:
             # Ruby 1.8 code, %N not available and %z broken on Windows
             offset_hours, offset_minutes = (v.utc_offset/60).divmod(60)
             string_to_datetime(v.strftime("%Y-%m-%dT%H:%M:%S") << sprintf(".%06i%+03i%02i", v.usec, offset_hours, offset_minutes))
+          # :nocov:
           end
         else
           v
@@ -181,7 +183,9 @@ module Sequel
         elsif v.respond_to?(:to_time)
           v.to_time
         else
+        # :nocov:
           string_to_datetime(v.strftime("%FT%T.%N%z"))
+        # :nocov:
         end
       else
         raise InvalidValue, "Invalid convert_input_timestamp type: #{v.inspect}"

data/lib/sequel/version.rb

@@ -3,7 +3,7 @@ module Sequel
   MAJOR = 3
   # The minor version of Sequel.  Bumped for every non-patch level
   # release, generally around once a month.
-  MINOR = 44
+  MINOR = 45
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.
   TINY  = 0

data/spec/adapters/mysql_spec.rb

@@ -1105,17 +1105,6 @@ describe "MySQL::Dataset#complex_expression_sql" do
     @d = MYSQL_DB.dataset
   end
 
-  specify "should handle pattern matches correctly" do
-    @d.literal(Sequel.expr(:x).like('a')).should == "(`x` LIKE BINARY 'a')"
-    @d.literal(~Sequel.expr(:x).like('a')).should == "(`x` NOT LIKE BINARY 'a')"
-    @d.literal(Sequel.expr(:x).ilike('a')).should == "(`x` LIKE 'a')"
-    @d.literal(~Sequel.expr(:x).ilike('a')).should == "(`x` NOT LIKE 'a')"
-    @d.literal(Sequel.expr(:x).like(/a/)).should == "(`x` REGEXP BINARY 'a')"
-    @d.literal(~Sequel.expr(:x).like(/a/)).should == "(`x` NOT REGEXP BINARY 'a')"
-    @d.literal(Sequel.expr(:x).like(/a/i)).should == "(`x` REGEXP 'a')"
-    @d.literal(~Sequel.expr(:x).like(/a/i)).should == "(`x` NOT REGEXP 'a')"
-  end
-
   specify "should handle string concatenation with CONCAT if more than one record" do
     @d.literal(Sequel.join([:x, :y])).should == "CONCAT(`x`, `y`)"
     @d.literal(Sequel.join([:x, :y], ' ')).should == "CONCAT(`x`, ' ', `y`)"

data/spec/adapters/postgres_spec.rb

@@ -83,6 +83,16 @@ describe "A PostgreSQL database" do
     @db.server_version.should > 70000
   end
 
+  specify "should support a :qualify option to tables and views" do
+    @db.tables(:qualify=>true).should include(Sequel.qualify(:public, :testfk))
+    begin
+      @db.create_view(:testfkv, @db[:testfk])
+      @db.views(:qualify=>true).should include(Sequel.qualify(:public, :testfkv))
+    ensure
+      @db.drop_view(:testfkv)
+    end
+  end
+
   specify "should not typecast the int2vector type incorrectly" do
     @db.get(Sequel.cast('10 20', :int2vector)).should_not == 10
   end
@@ -790,109 +800,131 @@ end
 
 describe "Postgres::Database schema qualified tables" do
   before do
-    POSTGRES_DB << "CREATE SCHEMA schema_test"
-    POSTGRES_DB.instance_variable_set(:@primary_keys, {})
-    POSTGRES_DB.instance_variable_set(:@primary_key_sequences, {})
+    @db = POSTGRES_DB
+    @db << "CREATE SCHEMA schema_test"
+    @db.instance_variable_set(:@primary_keys, {})
+    @db.instance_variable_set(:@primary_key_sequences, {})
   end
   after do
-    POSTGRES_DB << "DROP SCHEMA schema_test CASCADE"
-    POSTGRES_DB.default_schema = nil
+    @db << "DROP SCHEMA schema_test CASCADE"
+    @db.default_schema = nil
   end
 
   specify "should be able to create, drop, select and insert into tables in a given schema" do
-    POSTGRES_DB.create_table(:schema_test__schema_test){primary_key :i}
-    POSTGRES_DB[:schema_test__schema_test].first.should == nil
-    POSTGRES_DB[:schema_test__schema_test].insert(:i=>1).should == 1
-    POSTGRES_DB[:schema_test__schema_test].first.should == {:i=>1}
-    POSTGRES_DB.from(Sequel.lit('schema_test.schema_test')).first.should == {:i=>1}
-    POSTGRES_DB.drop_table(:schema_test__schema_test)
-    POSTGRES_DB.create_table(Sequel.qualify(:schema_test, :schema_test)){integer :i}
-    POSTGRES_DB[:schema_test__schema_test].first.should == nil
-    POSTGRES_DB.from(Sequel.lit('schema_test.schema_test')).first.should == nil
-    POSTGRES_DB.drop_table(Sequel.qualify(:schema_test, :schema_test))
+    @db.create_table(:schema_test__schema_test){primary_key :i}
+    @db[:schema_test__schema_test].first.should == nil
+    @db[:schema_test__schema_test].insert(:i=>1).should == 1
+    @db[:schema_test__schema_test].first.should == {:i=>1}
+    @db.from(Sequel.lit('schema_test.schema_test')).first.should == {:i=>1}
+    @db.drop_table(:schema_test__schema_test)
+    @db.create_table(Sequel.qualify(:schema_test, :schema_test)){integer :i}
+    @db[:schema_test__schema_test].first.should == nil
+    @db.from(Sequel.lit('schema_test.schema_test')).first.should == nil
+    @db.drop_table(Sequel.qualify(:schema_test, :schema_test))
   end
 
   specify "#tables should not include tables in a default non-public schema" do
-    POSTGRES_DB.create_table(:schema_test__schema_test){integer :i}
-    POSTGRES_DB.tables.should include(:schema_test)
-    POSTGRES_DB.tables.should_not include(:pg_am)
-    POSTGRES_DB.tables.should_not include(:domain_udt_usage)
+    @db.create_table(:schema_test__schema_test){integer :i}
+    @db.tables.should include(:schema_test)
+    @db.tables.should_not include(:pg_am)
+    @db.tables.should_not include(:domain_udt_usage)
   end
 
   specify "#tables should return tables in the schema provided by the :schema argument" do
-    POSTGRES_DB.create_table(:schema_test__schema_test){integer :i}
-    POSTGRES_DB.tables(:schema=>:schema_test).should == [:schema_test]
+    @db.create_table(:schema_test__schema_test){integer :i}
+    @db.tables(:schema=>:schema_test).should == [:schema_test]
   end
 
   specify "#schema should not include columns from tables in a default non-public schema" do
-    POSTGRES_DB.create_table(:schema_test__domains){integer :i}
-    sch = POSTGRES_DB.schema(:domains)
+    @db.create_table(:schema_test__domains){integer :i}
+    sch = @db.schema(:schema_test__domains)
     cs = sch.map{|x| x.first}
     cs.should include(:i)
     cs.should_not include(:data_type)
   end
 
   specify "#schema should only include columns from the table in the given :schema argument" do
-    POSTGRES_DB.create_table!(:domains){integer :d}
-    POSTGRES_DB.create_table(:schema_test__domains){integer :i}
-    sch = POSTGRES_DB.schema(:domains, :schema=>:schema_test)
+    @db.create_table!(:domains){integer :d}
+    @db.create_table(:schema_test__domains){integer :i}
+    sch = @db.schema(:domains, :schema=>:schema_test)
     cs = sch.map{|x| x.first}
     cs.should include(:i)
     cs.should_not include(:d)
-    POSTGRES_DB.drop_table(:domains)
+    @db.drop_table(:domains)
   end
 
-  specify "#schema should raise an exception if columns from tables in two separate schema are returned" do
-    POSTGRES_DB.create_table!(:public__domains){integer :d}
-    POSTGRES_DB.create_table(:schema_test__domains){integer :i}
+  specify "#schema should not include columns in tables from other domains by default" do
+    @db.create_table!(:public__domains){integer :d}
+    @db.create_table(:schema_test__domains){integer :i}
     begin
-      proc{POSTGRES_DB.schema(:domains)}.should raise_error(Sequel::Error)
-      POSTGRES_DB.schema(:public__domains).map{|x| x.first}.should == [:d]
-      POSTGRES_DB.schema(:schema_test__domains).map{|x| x.first}.should == [:i]
+      @db.schema(:domains).map{|x| x.first}.should == [:d]
+      @db.schema(:schema_test__domains).map{|x| x.first}.should == [:i]
     ensure
-      POSTGRES_DB.drop_table?(:public__domains)
+      @db.drop_table?(:public__domains)
     end
   end
 
   specify "#table_exists? should see if the table is in a given schema" do
-    POSTGRES_DB.create_table(:schema_test__schema_test){integer :i}
-    POSTGRES_DB.table_exists?(:schema_test__schema_test).should == true
+    @db.create_table(:schema_test__schema_test){integer :i}
+    @db.table_exists?(:schema_test__schema_test).should == true
   end
 
   specify "should be able to get primary keys for tables in a given schema" do
-    POSTGRES_DB.create_table(:schema_test__schema_test){primary_key :i}
-    POSTGRES_DB.primary_key(:schema_test__schema_test).should == 'i'
+    @db.create_table(:schema_test__schema_test){primary_key :i}
+    @db.primary_key(:schema_test__schema_test).should == 'i'
   end
 
   specify "should be able to get serial sequences for tables in a given schema" do
-    POSTGRES_DB.create_table(:schema_test__schema_test){primary_key :i}
-    POSTGRES_DB.primary_key_sequence(:schema_test__schema_test).should == '"schema_test"."schema_test_i_seq"'
+    @db.create_table(:schema_test__schema_test){primary_key :i}
+    @db.primary_key_sequence(:schema_test__schema_test).should == '"schema_test"."schema_test_i_seq"'
   end
 
   specify "should be able to get serial sequences for tables that have spaces in the name in a given schema" do
-    POSTGRES_DB.create_table(:"schema_test__schema test"){primary_key :i}
-    POSTGRES_DB.primary_key_sequence(:"schema_test__schema test").should == '"schema_test"."schema test_i_seq"'
+    @db.create_table(:"schema_test__schema test"){primary_key :i}
+    @db.primary_key_sequence(:"schema_test__schema test").should == '"schema_test"."schema test_i_seq"'
   end
 
   specify "should be able to get custom sequences for tables in a given schema" do
-    POSTGRES_DB << "CREATE SEQUENCE schema_test.kseq"
-    POSTGRES_DB.create_table(:schema_test__schema_test){integer :j; primary_key :k, :type=>:integer, :default=>Sequel.lit("nextval('schema_test.kseq'::regclass)")}
-    POSTGRES_DB.primary_key_sequence(:schema_test__schema_test).should == '"schema_test".kseq'
+    @db << "CREATE SEQUENCE schema_test.kseq"
+    @db.create_table(:schema_test__schema_test){integer :j; primary_key :k, :type=>:integer, :default=>Sequel.lit("nextval('schema_test.kseq'::regclass)")}
+    @db.primary_key_sequence(:schema_test__schema_test).should == '"schema_test".kseq'
   end
 
   specify "should be able to get custom sequences for tables that have spaces in the name in a given schema" do
-    POSTGRES_DB << "CREATE SEQUENCE schema_test.\"ks eq\""
-    POSTGRES_DB.create_table(:"schema_test__schema test"){integer :j; primary_key :k, :type=>:integer, :default=>Sequel.lit("nextval('schema_test.\"ks eq\"'::regclass)")}
-    POSTGRES_DB.primary_key_sequence(:"schema_test__schema test").should == '"schema_test"."ks eq"'
+    @db << "CREATE SEQUENCE schema_test.\"ks eq\""
+    @db.create_table(:"schema_test__schema test"){integer :j; primary_key :k, :type=>:integer, :default=>Sequel.lit("nextval('schema_test.\"ks eq\"'::regclass)")}
+    @db.primary_key_sequence(:"schema_test__schema test").should == '"schema_test"."ks eq"'
   end
 
   specify "#default_schema= should change the default schema used from public" do
-    POSTGRES_DB.create_table(:schema_test__schema_test){primary_key :i}
-    POSTGRES_DB.default_schema = :schema_test
-    POSTGRES_DB.table_exists?(:schema_test).should == true
-    POSTGRES_DB.tables.should == [:schema_test]
-    POSTGRES_DB.primary_key(:schema_test__schema_test).should == 'i'
-    POSTGRES_DB.primary_key_sequence(:schema_test__schema_test).should == '"schema_test"."schema_test_i_seq"'
+    @db.create_table(:schema_test__schema_test){primary_key :i}
+    @db.default_schema = :schema_test
+    @db.table_exists?(:schema_test).should == true
+    @db.tables.should == [:schema_test]
+    @db.primary_key(:schema_test__schema_test).should == 'i'
+    @db.primary_key_sequence(:schema_test__schema_test).should == '"schema_test"."schema_test_i_seq"'
+  end
+
+  specify "should handle schema introspection cases with tables with same name in multiple schemas" do
+    begin
+      @db.create_table(:schema_test__schema_test) do
+        primary_key :id
+        foreign_key :i, :schema_test__schema_test, :index=>{:name=>:schema_test_sti}
+      end
+      @db.create_table!(:public__schema_test) do
+        primary_key :id
+        foreign_key :j, :public__schema_test, :index=>{:name=>:public_test_sti}
+      end
+
+      h = @db.schema(:schema_test)
+      h.length.should == 2
+      h.last.first.should == :j
+
+      @db.indexes(:schema_test).should == {:public_test_sti=>{:unique=>false, :columns=>[:j], :deferrable=>nil}}
+      @db.foreign_key_list(:schema_test).should == [{:on_update=>:no_action, :columns=>[:j], :deferrable=>false, :key=>[:id], :table=>:schema_test, :on_delete=>:no_action, :name=>:schema_test_j_fkey}]
+    ensure
+      @db.drop_table?(:public__schema_test)
+    end
   end
 end