sequel 4.32.0 → 4.33.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d56404078cfe75cf79b2fe4b804e205d8a2e48d3
-  data.tar.gz: 587618022698a1b6f7076571e01361b080f3ea77
+  metadata.gz: 3187d95f59e9b0abc9502193d8843e11fc1c46f6
+  data.tar.gz: 7437eeaaa3c1a9f2016ef5d0fbe70a13b6f92a54
 SHA512:
-  metadata.gz: 97590c69f6bef7d22b856c9e331256357cdb4bc5804a65747242c14e3e9c40149f134503f303ce410941181e7574253205e73482f5fe5501ce2d6bebaa94c6cc
-  data.tar.gz: cb19067f82ec892008af6e1064bfb107edce01df096e377606adade354dbfa59dad90aa55dd2a33dc1d7ede4b9c42f16e5f5850c864979e85dfbb63adbfceca6
+  metadata.gz: 7a6239f275f8d99e78fddfbdce4ee36f28cd00b1d79a895b5b1c1f2a6529de35b437905d20bd9a60fb9e8aff6d2dd00b4a89d5bbbeb9f5ea52b897b0cbe72830
+  data.tar.gz: d123e46cfeb494f9ea8ecb4ee62793bb4873b6df240cec31ea7c290fe8e6c0f24f64f0f419729ee1bf7aedf724d69ad86497c248458c6818af70ccf44d65d525

data/CHANGELOG

@@ -1,3 +1,33 @@
+=== 4.33.0 (2016-04-01)
+
+* Handle arbitrary objects passed as arguments to the association method (jeremyevans) (#1166)
+
+* Handle array with multiple columns as Dataset#insert_conflict :target value on PostgreSQL (chanks) (#1165)
+
+* Add Database#transaction :savepoint=>:only option, for only creating a savepoint if already inside a transaction (jeremyevans)
+
+* Make Database#sequence_for_table on Oracle handle cases where the schema for a table cannot be determined (jeremyevans)
+
+* The boolean_readers, boolean_subsets, and class_table_inheritance plugins no longer do blind rescues (jeremyevans) (#1162)
+
+* Add Model.require_valid_table setting, if set to true doesn't swallow any errors for invalid tables (jeremyevans)
+
+* Creating model classes inside a transaction when the table doesn't exist no longer rolls back the transaction on PostgreSQL (jeremyevans) (#1160)
+
+* Sequel::Model no longer swallows many errors when subclassing or setting datasets (jeremyevans) (#1160)
+
+* Handle altering column NULL settings for varchar(max) and text columns on MSSQL (Ilja Resch)
+
+* Remove Sequel.firebird and Sequel.informix adapter methods (jeremyevans)
+
+* Make graph_each extension handle result set splitting when using Dataset#first (jeremyevans)
+
+* Allow raising Sequel::ValidationFailed and Sequel::HookFailed without an argument (jeremyevans)
+
+* Allow schema_dumper to handle :qualify=>true option on PostgreSQL (jeremyevans)
+
+* Allow foreign_key schema method to handle SQL::Identifier and SQL::QualifiedIdentifier as 2nd argument (jeremyevans)
+
 === 4.32.0 (2016-03-01)
 
 * Use mutex for synchronizing access to association reflection cache on MRI (jeremyevans)

data/doc/active_record.rdoc

@@ -626,6 +626,22 @@ For anything more complex, you can use +dataset_module+:
     end
   end
 
+=== +none+
+
+If you want to return an empty dataset, but still preserve chaining, you can use the +null_dataset+ extension:
+
+  DB.extension(:null_dataset)
+
+  class User < Sequel::Model
+    def self.nullify
+      dataset.nullify
+    end
+  end
+
+  user = User.create(name: 'John Doe')
+  User.nullify.where(name: 'John Doe').all
+  # => []
+
 ==== +reset_column_information+
 
 If you want to completely reload the schema for the table:

data/doc/release_notes/4.32.0.txt

@@ -1,6 +1,6 @@
 = New Features
 
-* A no_auto_string_literals plugin has been added, which removes the
+* A no_auto_literal_strings extension has been added, which removes the
   automatic usage of strings in filter arguments as literal SQL code.
   By default, if you do:
 
@@ -22,7 +22,7 @@
   input as literal SQL code is probably the most common SQL injection
   vector in applications using Sequel.
 
-  With the no_auto_string_literals extension, passing a plain string
+  With the no_auto_literal_strings extension, passing a plain string
   as the first or only argument to a filter method raises an
   exception.  If you want to use literal SQL code, you have to do so
   explicitly:

data/doc/release_notes/4.33.0.txt

@@ -0,0 +1,88 @@
+= New Features
+
+* A Sequel::Model.require_valid_table accessor has been added. This
+  setting is false for backwards compatibility, but if set to true,
+  will raise an error you try to create a model class where an
+  invalid table name is used or the schema or columns cannot be
+  determined.  This makes it easier to catch bugs, as things will
+  fail fast, but it means that you must change code like:
+
+    class Foo < Sequel::Model
+      set_dataset :my_foos
+    end
+
+  to:
+
+    class Foo < Sequel::Model(:my_foos)
+    end
+
+  as otherwise Foo will attempt to use the foos table by default
+  when creating the class, which will raise an error as it is not
+  the correct table name.
+
+* Sequel::Database#transaction now supports a :savepoint=>:only
+  option, which will create a savepoint if already inside a
+  transaction, but will yield without creating a transaction if
+  not inside a transaction.  The use case for this is when you
+  are running code that may raise an exception, and you don't
+  want to invalidate the current transaction state.
+
+= Other Improvements
+
+* The graph_each extension now splits results into subhashes when
+  using Sequel::Dataset#first, as it did before Sequel 4.27.0.
+
+* On PostgreSQL, Dataset#insert_conflict now accepts an array of
+  columns as the value for the :target option.
+
+* You can now pass a Sequel::SQL::Identifier or a
+  Sequel::SQL::QualifiedIdentifer as the table argument when creating
+  a foreign key.  Previously, only symbols were supported, and using
+  other values required specifying the :table option.  So this will
+  now work to reference a table that includes a double underscore:
+
+    foreign_key :foo_id, Sequel.identifier(:fo__oo)
+
+* Creating model classes inside a transaction on PostgreSQL where
+  the implicit table name isn't correct no longer causes the
+  transaction to fail.
+
+  Similar issues were also fixed in the boolean_readers,
+  boolean_subsets, and class_table_inheritance plugins.
+
+* On PostgreSQL, You can now use the :qualify=>true option in the
+  schema dumper, to dump using schema-qualified table names.
+
+* On Microsoft SQL Server, the set_column_allow_null and
+  set_column_not_null alter table methods now work on varchar(max),
+  text, and similar columns.
+
+* On Oracle, Sequel::Database#sequence_for_table now returns nil if
+  given a table that doesn't exist or that the user does not have
+  access to.
+
+* Passing arbitrary objects to a model association method now
+  indicates that the association should be reloaded, which was
+  used to work but was broken in Sequel 4.32.0.
+
+* It is now possible to raise Sequel::ValidationFailed and
+  Sequel::HookFailed without an argument.
+
+= Backwards Compatibility
+
+* Sequel::Model no longer swallows many errors when subclassing or
+  setting datasets.  While this should hopefully not affect backwards
+  compatibility, it may break things where the methods were raising
+  exceptions.  If this does break backwards compatibility, it is
+  most likely because it is no longer hiding another bug that should
+  be fixed.  Specific changes include:
+
+  * Model.inherited no longer rescues exceptions raised by set_dataset
+  * When subclassing a model that has a dataset, the columns and
+    schema are just copied from the superclass
+  * Only Sequel::Error is rescued in calls to columns and schema,
+    before it would rescue StandardError.
+
+* The Sequel.firebird and Sequel.informix adapter methods have been
+  removed, they are no longer needed as the firebird and informix
+  adapters were removed a few versions back.

data/lib/sequel/adapters/shared/mssql.rb

@@ -283,7 +283,8 @@ module Sequel
         when :set_column_null
           sch = schema(table).find{|k,v| k.to_s == op[:name].to_s}.last
           type = sch[:db_type]
-          if [:string, :decimal].include?(sch[:type]) and size = (sch[:max_chars] || sch[:column_size])
+          if [:string, :decimal].include?(sch[:type]) && !["text", "ntext"].include?(type) && (size = (sch[:max_chars] || sch[:column_size]))
+            size = "MAX" if size == -1
             type += "(#{size}#{", #{sch[:scale]}" if sch[:scale] && sch[:scale].to_i > 0})"
           end
           "ALTER TABLE #{quote_schema_table(table)} ALTER COLUMN #{quote_identifier(op[:name])} #{type_literal(:type=>type)} #{'NOT ' unless op[:null]}NULL"

data/lib/sequel/adapters/shared/oracle.rb

@@ -219,7 +219,13 @@ module Sequel
       def sequence_for_table(table)
         return nil unless autosequence
         @primary_key_sequences.fetch(table) do |key|
-          pk = schema(table).select{|k, v| v[:primary_key]}
+          begin
+            sch = schema(table)
+          rescue Sequel::Error
+            return nil
+          end
+
+          pk = sch.select{|k, v| v[:primary_key]}
           @primary_key_sequences[table] = if pk.length == 1
             seq = "seq_#{table}_#{pk.first.first}"
             seq.to_sym unless from(:user_sequences).filter(:sequence_name=>input_identifier_meth.call(seq)).empty?

data/lib/sequel/adapters/shared/postgres.rb

@@ -1595,9 +1595,8 @@ module Sequel
             sql << " ON CONSTRAINT "
             identifier_append(sql, target)
           elsif target = opts[:target]
-            sql << ' ('
-            identifier_append(sql, target)
-            sql << ')'
+            sql << ' '
+            identifier_append(sql, Array(target))
           end
 
           if values = opts[:update]

data/lib/sequel/database/connecting.rb

@@ -8,7 +8,7 @@ module Sequel
     # ---------------------
 
     # Array of supported database adapters
-    ADAPTERS = %w'ado amalgalite cubrid do firebird ibmdb informix jdbc mock mysql mysql2 odbc oracle postgres sqlanywhere sqlite swift tinytds'.collect(&:to_sym)
+    ADAPTERS = %w'ado amalgalite cubrid do ibmdb jdbc mock mysql mysql2 odbc oracle postgres sqlanywhere sqlite swift tinytds'.collect(&:to_sym)
 
     @single_threaded = false
 

data/lib/sequel/database/query.rb

@@ -194,11 +194,7 @@ module Sequel
       sch, table_name = schema_and_table(name)
       name = SQL::QualifiedIdentifier.new(sch, table_name) if sch
       ds = from(name)
-      if in_transaction? && supports_savepoints?
-        transaction(:savepoint=>true){_table_exists?(ds)}
-      else
-        _table_exists?(ds)
-      end
+      transaction(:savepoint=>:only){_table_exists?(ds)}
       true
     rescue DatabaseError
       false

data/lib/sequel/database/schema_generator.rb

@@ -156,12 +156,10 @@ module Sequel
         opts = case table
         when Hash
           table.merge(opts)
-        when Symbol
-          opts.merge(:table=>table)
         when NilClass
           opts
         else
-          raise(Error, "The second argument to foreign_key should be a Hash, Symbol, or nil")
+          opts.merge(:table=>table)
         end
         return composite_foreign_key(name, opts) if name.is_a?(Array)
         column(name, Integer, opts)

data/lib/sequel/database/transactions.rb

@@ -69,6 +69,8 @@ module Sequel
     #               default Sequel will reuse an existing transaction, so if you want to
     #               use a savepoint you must use this option.  If the surrounding transaction
     #               uses :auto_savepoint, you can set this to false to not use a savepoint.
+    #               If the value given for this option is :only, it will only create a
+    #               savepoint if it is inside a transacation.
     #
     # PostgreSQL specific options:
     #
@@ -97,6 +99,9 @@ module Sequel
         end
       else
         synchronize(opts[:server]) do |conn|
+          if opts[:savepoint] == :only && supports_savepoints? && !_trans(conn)
+            return yield(conn)
+          end
           if already_in_transaction?(conn, opts)
             if opts[:savepoint] != false && (stack = _trans(conn)[:savepoints]) && stack.last
               _transaction(conn, Hash[opts].merge!(:savepoint=>true), &block)

data/lib/sequel/extensions/graph_each.rb

@@ -31,12 +31,21 @@ module Sequel
       end
     end
 
+    # Call graph_each for graphed datasets that are not being eager graphed.
+    def with_sql_each(sql)
+      if @opts[:graph] && !@opts[:eager_graph]
+        graph_each(sql){|r| yield r}
+      else
+        super
+      end
+    end
+
     private
 
     # Fetch the rows, split them into component table parts,
     # tranform and run the row_proc on each part (if applicable),
     # and yield a hash of the parts.
-    def graph_each
+    def graph_each(sql=select_sql)
       # Reject tables with nil datasets, as they are excluded from
       # the result set
       datasets = @opts[:graph][:table_aliases].to_a.reject{|ta,ds| ds.nil?}
@@ -48,7 +57,7 @@ module Sequel
       # Use the manually set graph aliases, if any, otherwise
       # use the ones automatically created by .graph
       column_aliases = @opts[:graph_aliases] || @opts[:graph][:column_aliases]
-      fetch_rows(select_sql) do |r|
+      fetch_rows(sql) do |r|
         graph = {}
         # Create the sub hashes, one per table
         table_aliases.each{|ta| graph[ta]={}}

data/lib/sequel/extensions/schema_dumper.rb

@@ -144,7 +144,6 @@ END_MIG
     # Return a string with a create table block that will recreate the given
     # table's schema.  Takes the same options as dump_schema_migration.
     def dump_table_schema(table, options=OPTS)
-      table = table.value.to_s if table.is_a?(SQL::Identifier)
       gen = dump_table_generator(table, options)
       commands = [gen.dump_columns, gen.dump_constraints, gen.dump_indexes].reject{|x| x == ''}.join("\n\n")
       "create_table(#{table.inspect}#{', :ignore_index_errors=>true' if !options[:same_db] && options[:indexes] != false && !gen.indexes.empty?}) do\n#{commands.gsub(/^/o, '  ')}\nend"
@@ -244,8 +243,6 @@ END_MIG
     # Return a Schema::Generator object that will recreate the
     # table's schema.  Takes the same options as dump_schema_migration.
     def dump_table_generator(table, options=OPTS)
-      table = table.value.to_s if table.is_a?(SQL::Identifier)
-      raise(Error, "must provide table as a Symbol, String, or Sequel::SQL::Identifier") unless [String, Symbol].any?{|c| table.is_a?(c)}
       s = schema(table).dup
       pks = s.find_all{|x| x.last[:primary_key] == true}.map(&:first)
       options = options.merge(:single_pk=>true) if pks.length == 1

data/lib/sequel/model.rb

@@ -125,7 +125,7 @@ module Sequel
       :@raise_on_typecast_failure=>nil, :@plugins=>:dup, :@setter_methods=>nil,
       :@use_after_commit_rollback=>nil, :@fast_pk_lookup_sql=>nil,
       :@fast_instance_delete_sql=>nil, :@finders=>:dup, :@finder_loaders=>:dup,
-      :@db=>nil, :@default_set_fields_options=>:dup}
+      :@db=>nil, :@default_set_fields_options=>:dup, :@require_valid_table=>nil}
 
     # Regular expression that determines if a method name is normal in the sense that
     # it could be used literally in ruby code without using send.  Used to
@@ -153,6 +153,7 @@ module Sequel
     @raise_on_save_failure = true
     @raise_on_typecast_failure = false
     @require_modification = nil
+    @require_valid_table = false
     @restrict_primary_key = true
     @restricted_columns = nil
     @setter_methods = nil

data/lib/sequel/model/associations.rb

@@ -2272,6 +2272,8 @@ module Sequel
           else
             if dynamic_opts.respond_to?(:call)
               {:callback=>dynamic_opts}
+            else
+              {:reload=>true}
             end
           end
 

data/lib/sequel/model/base.rb

@@ -60,6 +60,26 @@ module Sequel
       # Sequel will not check the number of rows modified (default: true).
       attr_accessor :require_modification
   
+      # Requires that all models have valid tables, raising exceptions if creating a model
+      # without a valid table backing it.  Enabling this will break code like:
+      #
+      #   class Foo < Sequel::Model
+      #     set_dataset :my_foo
+      #   end
+      #
+      # As when Sequel::Model is subclassed, before set_dataset is executed, it will try to
+      # get the schema for the foos table, which will raise an exception.  You would need to
+      # switch to using:
+      #
+      #   class Foo < Sequel::Model(:my_foo)
+      #   end
+      #
+      # or:
+      #
+      #   Foo = Sequel::Model()
+      #   Foo.set_dataset :my_foo
+      attr_accessor :require_valid_table
+
       # Should be the literal primary key column name if this Model's table has a simple primary key, or
       # nil if the model has a compound primary key or no primary key.
       attr_reader :simple_pk
@@ -513,10 +533,10 @@ module Sequel
 
         unless ivs.include?("@dataset")
           if @dataset && self != Model
-            subclass.set_dataset(@dataset.clone, :inherited=>true) rescue nil
+            subclass.set_dataset(@dataset.clone, :inherited=>true)
           elsif (n = subclass.name) && !n.to_s.empty?
             db
-            subclass.set_dataset(subclass.implicit_table_name) rescue nil
+            subclass.set_dataset(subclass.implicit_table_name)
           end
         end
       end
@@ -689,12 +709,14 @@ module Sequel
         @require_modification = Sequel::Model.require_modification.nil? ? @dataset.provides_accurate_rows_matched? : Sequel::Model.require_modification
         if inherited
           self.simple_table = superclass.simple_table
-          @columns = @dataset.columns rescue nil
+          @columns = superclass.instance_variable_get(:@columns)
+          @db_schema = superclass.instance_variable_get(:@db_schema)
         else
           @dataset_method_modules.each{|m| @dataset.extend(m)} if @dataset_method_modules
+          @db_schema = get_db_schema
         end
+
         @dataset.model = self if @dataset.respond_to?(:model=)
-        check_non_connection_error{@db_schema = (inherited ? superclass.db_schema : get_db_schema)}
         reset_instance_dataset
         self
       end
@@ -798,11 +820,11 @@ module Sequel
       # Yield to the passed block and swallow all errors other than DatabaseConnectionErrors.
       def check_non_connection_error
         begin
-          yield
+          db.transaction(:savepoint=>:only){yield}
         rescue Sequel::DatabaseConnectionError
           raise
-        rescue
-          nil
+        rescue Sequel::Error
+          raise if require_valid_table
         end
       end
 

data/lib/sequel/model/exceptions.rb

@@ -7,7 +7,7 @@ module Sequel
     # The Sequel::Model instance related to this error.
     attr_reader :model
 
-    def initialize(message, model=nil)
+    def initialize(message=nil, model=nil)
       @model = model
       super(message)
     end
@@ -35,7 +35,7 @@ module Sequel
     # The Sequel::Model::Errors object related to this exception.
     attr_reader :errors
 
-    def initialize(errors)
+    def initialize(errors=nil)
       if errors.is_a?(Sequel::Model)
         @model = errors
         errors = @model.errors

data/lib/sequel/plugins/boolean_readers.rb

@@ -49,8 +49,9 @@ module Sequel
         # Add attribute? methods for all of the boolean attributes for this model.
         def create_boolean_readers
           im = instance_methods.collect(&:to_s)
-          cs = columns rescue return
-          cs.each{|c| create_boolean_reader(c) if boolean_attribute?(c) && !im.include?("#{c}?")}
+          if cs = check_non_connection_error{columns}
+            cs.each{|c| create_boolean_reader(c) if boolean_attribute?(c) && !im.include?("#{c}?")}
+          end
         end
       end
     end

data/lib/sequel/plugins/boolean_subsets.rb

@@ -49,8 +49,9 @@ module Sequel
 
         # Add subset methods for all of the boolean columns in this model.
         def create_boolean_subsets
-          cs = columns rescue return
-          cs.each{|c| subset(*boolean_subset_args(c)) if db_schema[c][:type] == :boolean}
+          if cs = check_non_connection_error{columns}
+            cs.each{|c| subset(*boolean_subset_args(c)) if db_schema[c][:type] == :boolean}
+          end
         end
       end
     end

data/lib/sequel/plugins/class_table_inheritance.rb

@@ -245,7 +245,7 @@ module Sequel
               columns = db.from(table).columns
             else
               table = subclass.implicit_table_name
-              columns = db.from(table).columns rescue nil
+              columns = check_non_connection_error{db.from(table).columns}
               table = nil if !columns || columns.empty?
             end
           end

data/lib/sequel/version.rb

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

data/spec/adapters/mssql_spec.rb

@@ -518,6 +518,33 @@ describe "A MSSQL database adds index with include" do
   end
 end
 
+describe "MSSQL set_column_allow_null" do
+  before do
+    @db = DB
+  end
+  after do
+    @db.drop_table?(:test3)
+  end
+
+  it "should work with nvarchar(MAX) columns" do
+    @db.create_table!(:test3) do
+      column :t, 'nvarchar(MAX)'
+    end
+    @db.alter_table(:test3) do
+      set_column_not_null :t
+    end
+  end
+
+  it "should work with text columns" do
+    @db.create_table!(:test3) do
+      column :t, 'text'
+    end
+    @db.alter_table(:test3) do
+      set_column_not_null :t
+    end
+  end
+end
+
 describe "MSSQL::Database#drop_column with a schema" do
   before do
     DB.run "create schema test" rescue nil

data/spec/adapters/postgres_spec.rb

@@ -184,7 +184,7 @@ end
 describe "PostgreSQL", 'INSERT ON CONFLICT' do
   before(:all) do
     @db = DB
-    @db.create_table!(:ic_test){Integer :a; Integer :b; unique :a, :name=>:ic_test_a_uidx}
+    @db.create_table!(:ic_test){Integer :a; Integer :b; Integer :c; unique :a, :name=>:ic_test_a_uidx; unique [:b, :c], :name=>:ic_test_b_c_uidx}
     @ds = @db[:ic_test]
   end
   before do
@@ -194,26 +194,35 @@ describe "PostgreSQL", 'INSERT ON CONFLICT' do
     @db.drop_table?(:ic_test)
   end
 
-  it "Dataset#insert_ignore and insert_constraint should ignore uniqueness violations" do
-    @ds.insert(1, 2)
-    proc{@ds.insert(1, 3)}.must_raise Sequel::UniqueConstraintViolation
-    @ds.insert_ignore.insert(1, 3).must_equal nil
-    @ds.insert_conflict.insert(1, 3).must_equal nil
-    @ds.insert_conflict(:target=>:a).insert(1, 3).must_equal nil
-    @ds.insert_conflict(:constraint=>:ic_test_a_uidx).insert(1, 3).must_equal nil
-    @ds.all.must_equal [{:a=>1, :b=>2}]
+  it "Dataset#insert_ignore and insert_conflict should ignore uniqueness violations" do
+    @ds.insert(1, 2, 3)
+    proc{@ds.insert(1, 3, 4)}.must_raise Sequel::UniqueConstraintViolation
+    @ds.insert_ignore.insert(1, 3, 4).must_equal nil
+    @ds.insert_conflict.insert(1, 3, 4).must_equal nil
+    @ds.insert_conflict(:target=>:a).insert(1, 3, 4).must_equal nil
+    @ds.insert_conflict(:constraint=>:ic_test_a_uidx).insert(1, 3, 4).must_equal nil
+    @ds.all.must_equal [{:a=>1, :b=>2, :c=>3}]
   end
 
-  it "Dataset#insert_constraint should handle upserts" do
-    @ds.insert(1, 2)
-    @ds.insert_conflict(:target=>:a, :update=>{:b=>3}).insert(1, 3).must_equal nil
-    @ds.all.must_equal [{:a=>1, :b=>3}]
+  it "Dataset#insert_conflict should handle upserts" do
+    @ds.insert(1, 2, 3)
+    @ds.insert_conflict(:target=>:a, :update=>{:b=>3}).insert(1, 3, 4).must_equal nil
+    @ds.all.must_equal [{:a=>1, :b=>3, :c=>3}]
+    @ds.insert_conflict(:target=>[:b, :c], :update=>{:c=>5}).insert(5, 3, 3).must_equal nil
+    @ds.all.must_equal [{:a=>1, :b=>3, :c=>5}]
     @ds.insert_conflict(:constraint=>:ic_test_a_uidx, :update=>{:b=>4}).insert(1, 3).must_equal nil
-    @ds.all.must_equal [{:a=>1, :b=>4}]
-    @ds.insert_conflict(:constraint=>:ic_test_a_uidx, :update=>{:b=>5}, :update_where=>{:ic_test__b=>4}).insert(1, 3).must_equal nil
-    @ds.all.must_equal [{:a=>1, :b=>5}]
-    @ds.insert_conflict(:constraint=>:ic_test_a_uidx, :update=>{:b=>6}, :update_where=>{:ic_test__b=>4}).insert(1, 3).must_equal nil
-    @ds.all.must_equal [{:a=>1, :b=>5}]
+    @ds.all.must_equal [{:a=>1, :b=>4, :c=>5}]
+    @ds.insert_conflict(:constraint=>:ic_test_a_uidx, :update=>{:b=>5}, :update_where=>{:ic_test__b=>4}).insert(1, 3, 4).must_equal nil
+    @ds.all.must_equal [{:a=>1, :b=>5, :c=>5}]
+    @ds.insert_conflict(:constraint=>:ic_test_a_uidx, :update=>{:b=>6}, :update_where=>{:ic_test__b=>4}).insert(1, 3, 4).must_equal nil
+    @ds.all.must_equal [{:a=>1, :b=>5, :c=>5}]
+  end
+
+  it "Dataset#insert_conflict should respect expressions in the target argument" do
+    @ds.insert_conflict(:target=>:a).insert_sql(1, 2, 3).must_equal "INSERT INTO \"ic_test\" VALUES (1, 2, 3) ON CONFLICT (\"a\") DO NOTHING"
+    @ds.insert_conflict(:target=>[:b, :c]).insert_sql(1, 2, 3).must_equal "INSERT INTO \"ic_test\" VALUES (1, 2, 3) ON CONFLICT (\"b\", \"c\") DO NOTHING"
+    @ds.insert_conflict(:target=>[:b, Sequel.function(:round, :c)]).insert_sql(1, 2, 3).must_equal "INSERT INTO \"ic_test\" VALUES (1, 2, 3) ON CONFLICT (\"b\", round(\"c\")) DO NOTHING"
+    @ds.insert_conflict(:target=>[:b, Sequel.virtual_row{|o| o.round(:c)}]).insert_sql(1, 2, 3).must_equal "INSERT INTO \"ic_test\" VALUES (1, 2, 3) ON CONFLICT (\"b\", round(\"c\")) DO NOTHING"
   end
 end if DB.server_version >= 90500
 

data/spec/core/database_spec.rb

@@ -1033,6 +1033,16 @@ describe "Database#transaction with savepoint support" do
     proc{@db.transaction(:prepare=>'XYZ'){@db.transaction(:savepoint=>true){@db.after_rollback{@db.execute('foo')}}}}.must_raise(Sequel::Error)
     @db.sqls.must_equal ['BEGIN', 'SAVEPOINT autopoint_1','ROLLBACK TO SAVEPOINT autopoint_1', 'ROLLBACK']
   end
+
+  it "should create savepoint if inside a transaction when :savepoint=>:only is used" do
+    @db.transaction{@db.transaction(:savepoint=>:only){}}
+    @db.sqls.must_equal ['BEGIN', 'SAVEPOINT autopoint_1','RELEASE SAVEPOINT autopoint_1', 'COMMIT']
+  end
+
+  it "should not create transaction if not inside a transaction when :savepoint=>:only is used" do
+    @db.transaction(:savepoint=>:only){}
+    @db.sqls.must_equal []
+  end
 end
   
 describe "Database#transaction without savepoint support" do
@@ -1041,6 +1051,11 @@ describe "Database#transaction without savepoint support" do
     meta_def(@db, :supports_savepoints?){false}
   end
 
+  it "should not create savepoint if inside a transaction when :savepoint=>:only is used" do
+    @db.transaction{@db.transaction(:savepoint=>:only){}}
+    @db.sqls.must_equal ['BEGIN', 'COMMIT']
+  end
+
   include DatabaseTransactionSpecs
 end
   

data/spec/core/schema_generator_spec.rb

@@ -43,6 +43,17 @@ describe Sequel::Schema::Generator do
     columns.first[:primary_key].must_equal nil
   end
   
+  it "should handle SQL::Identifier and SQL::QualifiedIdentifier as foreign_key arguments" do
+    generator = Sequel::Schema::Generator.new(Sequel.mock) do
+      foreign_key :a_id, Sequel.identifier(:as)
+      foreign_key :b_id, Sequel.qualify(:c, :b)
+    end
+
+    columns = generator.columns
+    columns.first.values_at(:name, :table).must_equal [:a_id, Sequel.identifier(:as)]
+    columns.last.values_at(:name, :table).must_equal [:b_id, Sequel.qualify(:c, :b)]
+  end
+  
   it "counts definitions correctly" do
     @columns.size.must_equal 6
     @indexes.size.must_equal 2

data/spec/extensions/boolean_readers_spec.rb

@@ -2,7 +2,7 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
 describe Sequel::Model, "BooleanReaders plugin" do
   before do
-    @db = Sequel::Database.new
+    @db = Sequel.mock
     def @db.supports_schema_parsing?() true end
     def @db.schema(*args)
       [[:id, {}], [:z, {:type=>:integer, :db_type=>'tinyint(1)'}], [:b, {:type=>:boolean, :db_type=>'boolean'}]]

data/spec/extensions/boolean_subsets_spec.rb

@@ -2,7 +2,7 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
 describe "boolean_subsets plugin" do
   before do
-    @db = Sequel::Database.new
+    @db = Sequel.mock
     def @db.supports_schema_parsing?() true end
     def @db.schema(*args)
       [[:asdaf9898as, {}], [:active, {:type=>:boolean}]]

data/spec/extensions/defaults_setter_spec.rb

@@ -4,11 +4,12 @@ describe "Sequel::Plugins::DefaultsSetter" do
   before do
     @db = db = Sequel.mock
     def db.supports_schema_parsing?() true end
+    def db.schema(*) [] end
     @c = c = Class.new(Sequel::Model(db[:foo]))
     @c.instance_variable_set(:@db_schema, {:a=>{}})
     @c.plugin :defaults_setter
     @c.columns :a
-    @pr = proc{|x| db.meta_def(:schema){|*| [[:a, {:ruby_default => x}]]}; c.dataset = c.dataset; c}
+    @pr = proc{|x| db.meta_def(:schema){|*| [[:id, {:primary_key=>true}], [:a, {:ruby_default => x, :primary_key=>false}]]}; c.dataset = c.dataset; c}
   end
   after do
     Sequel.datetime_class = Time

data/spec/extensions/graph_each_spec.rb

@@ -51,6 +51,16 @@ describe Sequel::Dataset, " graphing" do
     @ds1.graph(@ds2, :x=>:id).graph(@ds2, {:y=>:points__id}, :table_alias=>:graph).all.must_equal [{:points=>{:id=>1, :x=>2, :y=>3}, :lines=>{:id=>4, :x=>5, :y=>6, :graph_id=>7}, :graph=>{:id=>8, :x=>9, :y=>10, :graph_id=>11}}]
   end
 
+  it "#graph_each should split the result set into component tables when using first" do
+    @db.fetch = [[{:id=>1,:x=>2,:y=>3,:lines_id=>4,:lines_x=>5,:lines_y=>6,:graph_id=>7}],
+      [{:id=>1,:x=>2,:y=>3,:lines_id=>4,:lines_x=>5,:lines_y=>6,:graph_id=>7, :graphs_id=>8, :name=>9, :graphs_x=>10, :graphs_y=>11, :graphs_lines_x=>12}],
+      [{:id=>1,:x=>2,:y=>3,:lines_id=>4,:lines_x=>5,:lines_y=>6,:graph_id=>7, :graph_id_0=>8, :graph_x=>9, :graph_y=>10, :graph_graph_id=>11}]]
+
+    @ds1.graph(@ds2, :x=>:id).first.must_equal(:points=>{:id=>1, :x=>2, :y=>3}, :lines=>{:id=>4, :x=>5, :y=>6, :graph_id=>7})
+    @ds1.graph(@ds2, :x=>:id).graph(@ds3, :id=>:graph_id).first.must_equal(:points=>{:id=>1, :x=>2, :y=>3}, :lines=>{:id=>4, :x=>5, :y=>6, :graph_id=>7}, :graphs=>{:id=>8, :name=>9, :x=>10, :y=>11, :lines_x=>12})
+    @ds1.graph(@ds2, :x=>:id).graph(@ds2, {:y=>:points__id}, :table_alias=>:graph).first.must_equal(:points=>{:id=>1, :x=>2, :y=>3}, :lines=>{:id=>4, :x=>5, :y=>6, :graph_id=>7}, :graph=>{:id=>8, :x=>9, :y=>10, :graph_id=>11})
+  end
+
   it "#graph_each should give a nil value instead of a hash when all values for a table are nil" do
     @db.fetch = [[{:id=>1,:x=>2,:y=>3,:lines_id=>nil,:lines_x=>nil,:lines_y=>nil,:graph_id=>nil}],
       [{:id=>1,:x=>2,:y=>3,:lines_id=>4,:lines_x=>5,:lines_y=>6,:graph_id=>7, :graphs_id=>nil, :name=>nil, :graphs_x=>nil, :graphs_y=>nil, :graphs_lines_x=>nil},

data/spec/extensions/looser_typecasting_spec.rb

@@ -2,7 +2,7 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
 describe "LooserTypecasting Extension" do
   before do
-    @db = Sequel::Database.new
+    @db = Sequel.mock
     def @db.supports_schema_parsing?() true end
     def @db.schema(*args)
       [[:id, {}], [:z, {:type=>:float}], [:b, {:type=>:integer}], [:d, {:type=>:decimal}], [:s, {:type=>:string}]]

data/spec/extensions/schema_dumper_spec.rb

@@ -102,7 +102,7 @@ describe "Sequel::Database dump methods" do
   end
 
   it "should support dumping table schemas when given an identifier" do
-    @d.dump_table_schema(Sequel.identifier(:t__t1)).must_equal "create_table(\"t__t1\") do\n  primary_key :c1\n  String :c2, :size=>20\nend"
+    @d.dump_table_schema(Sequel.identifier(:t__t1)).must_equal "create_table(Sequel::SQL::Identifier.new(:t__t1)) do\n  primary_key :c1\n  String :c2, :size=>20\nend"
   end
 
   it "should dump non-Integer primary key columns with explicit :type" do
@@ -804,4 +804,10 @@ END_MIG
     ["create_table(:t4) do\n  primary_key :c1, :table=>:t3, :key=>[:c1]\nend",
      "create_table(:t4) do\n  primary_key :c1, :key=>[:c1], :table=>:t3\nend"].must_include(@d.dump_table_schema(:t4))
   end
+
+  it "should handle dumping on PostgreSQL using qualified tables" do
+    @d = Sequel.connect('mock://postgres').extension(:schema_dumper)
+    @d.meta_def(:schema){|*s| [[:c1, {:db_type=>'timestamp', :primary_key=>true, :allow_null=>true}]]}
+    @d.dump_table_schema(Sequel.qualify(:foo, :bar), :same_db=>true).must_equal "create_table(Sequel::SQL::QualifiedIdentifier.new(:foo, :bar)) do\n  column :c1, \"timestamp\"\n  \n  primary_key [:c1]\nend"
+  end
 end

data/spec/integration/model_test.rb

@@ -222,5 +222,9 @@ describe "Sequel::Model with no existing table" do
     db.drop_table?(:items)
     class ::Item < Sequel::Model(db); end; Object.send(:remove_const, :Item)
     c = Class.new(Sequel::Model); c.set_dataset(db[:items])
+    db.transaction do
+      c = Class.new(Sequel::Model(db[:items]))
+      db.get(Sequel.cast(1, Integer)).must_equal 1
+    end
   end
 end

data/spec/model/associations_spec.rb

@@ -450,6 +450,8 @@ describe Sequel::Model, "many_to_one" do
     DB.sqls.must_equal ["SELECT * FROM nodes WHERE id = 234"]
     d.parent(:reload=>true).wont_equal 42 
     DB.sqls.must_equal ["SELECT * FROM nodes WHERE id = 234"]
+    d.parent(Object.new).wont_equal 42 
+    DB.sqls.must_equal ["SELECT * FROM nodes WHERE id = 234"]
   end
   
   it "should use a callback if given one as the argument" do

data/spec/model/model_spec.rb

@@ -151,6 +151,7 @@ end
 describe Sequel::Model do
   before do
     @model = Class.new(Sequel::Model(:items))
+    DB.reset
   end
 
   it "has table_name return name of table" do
@@ -242,8 +243,9 @@ describe Sequel::Model do
   end
 
   it "doesn't raise an error on set_dataset if there is an error raised getting the schema" do
-    def @model.get_db_schema(*) raise Sequel::Error end
-    @model.set_dataset(DB[:foo])
+    db = Sequel.mock
+    def db.schema(*) raise Sequel::Error; end
+    @model.set_dataset(db[:foo])
   end
 
   it "reload_db_schema? should be false by default" do
@@ -253,10 +255,21 @@ describe Sequel::Model do
   end
 
   it "doesn't raise an error on inherited if there is an error setting the dataset" do
-    def @model.set_dataset(*) raise Sequel::Error end
+    db = Sequel.mock
+    def db.schema(*) raise Sequel::Error; end
+    @model.db = db
     Class.new(@model)
   end
 
+  it "uses a savepoint if inside a transaction when getting the columns" do
+    db = Sequel.mock
+    def db.supports_savepoints?; true end
+    Sequel::Model(db[:table])
+    db.sqls.must_equal ["SELECT * FROM table LIMIT 1"]
+    c = db.transaction{Sequel::Model(db[:table])}
+    db.sqls.must_equal ["BEGIN", "SAVEPOINT autopoint_1", "SELECT * FROM table LIMIT 1", "RELEASE SAVEPOINT autopoint_1", "COMMIT"]
+  end
+
   it "should raise if bad inherited instance variable value is used" do
     def @model.inherited_instance_variables() super.merge(:@a=>:foo) end
     @model.instance_eval{@a=1}
@@ -277,6 +290,59 @@ describe Sequel::Model do
   end
 end
 
+describe Sequel::Model, ".require_valid_table = true" do
+  before do
+    @db = Sequel.mock
+    @db.columns = proc do |sql|
+      raise Sequel::Error if sql =~ /foos/
+      [:id]
+    end
+    def @db.supports_schema_parsing?; true end
+    def @db.schema(t, *) t.first_source == :foos ? (raise Sequel::Error) : [[:id, {}]] end
+    Sequel::Model.db = @db
+    Sequel::Model.require_valid_table = true
+  end
+  after do
+    Sequel::Model.require_valid_table = false
+    Sequel::Model.db = DB
+    if Object.const_defined?(:Bar)
+      Object.send(:remove_const, :Bar)
+    end
+    if Object.const_defined?(:Foo)
+      Object.send(:remove_const, :Foo)
+    end
+  end
+
+  it "should raise an exception when creating a model with an invalid implicit table" do
+    proc{class ::Foo < Sequel::Model; end}.must_raise Sequel::Error
+  end
+
+  it "should not raise an exception when creating a model with a valid implicit table" do
+    class ::Bar < Sequel::Model; end
+    Bar.columns.must_equal [:id]
+  end
+
+  it "should raise an exception when creating a model with an invalid explicit table" do
+    proc{Sequel::Model(@db[:foos])}.must_raise Sequel::Error
+  end
+
+  it "should not raise an exception when creating a model with a valid explicit table" do
+    c = Sequel::Model(@db[:bars])
+    c.columns.must_equal [:id]
+  end
+
+  it "should raise an exception when calling set_dataset with an invalid table" do
+    c = Class.new(Sequel::Model)
+    proc{c.set_dataset @db[:foos]}.must_raise Sequel::Error
+  end
+
+  it "should not raise an exception when calling set_dataset with an valid table" do
+    c = Class.new(Sequel::Model)
+    c.set_dataset @db[:bars]
+    c.columns.must_equal [:id]
+  end
+end
+
 describe Sequel::Model, "constructors" do
   before do
     @m = Class.new(Sequel::Model)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sequel
 version: !ruby/object:Gem::Version
-  version: 4.32.0
+  version: 4.33.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-03-01 00:00:00.000000000 Z
+date: 2016-04-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -233,6 +233,7 @@ extra_rdoc_files:
 - doc/release_notes/4.30.0.txt
 - doc/release_notes/4.31.0.txt
 - doc/release_notes/4.32.0.txt
+- doc/release_notes/4.33.0.txt
 files:
 - CHANGELOG
 - MIT-LICENSE
@@ -354,6 +355,7 @@ files:
 - doc/release_notes/4.30.0.txt
 - doc/release_notes/4.31.0.txt
 - doc/release_notes/4.32.0.txt
+- doc/release_notes/4.33.0.txt
 - doc/release_notes/4.4.0.txt
 - doc/release_notes/4.5.0.txt
 - doc/release_notes/4.6.0.txt