sequel 4.25.0 → 4.26.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5bb525327915d4e6d6e8306e9edd0dc6cd32afa3
-  data.tar.gz: b64f5447c918b9d36b47622629ec697286adc0b8
+  metadata.gz: cf4997b7f0149580e9838f7a7c1d0802ce9fdd6b
+  data.tar.gz: 21d723dcf70b74e58a194e71c0d1fb31a6775917
 SHA512:
-  metadata.gz: caa13716ae448d4a3b3c6f4886c2e529f495e843eeb5386b85a264d259bb54d0ffefca3d7cba9c82013d1c96c87bff8691e460e1e0a06806bb64cef18950e284
-  data.tar.gz: 302d93a18b52e0810e74fce6f3d4a87f497f4199fb47045834aecbe193f6796fd910453b0c1669b8d82b3d698ac5bb13346fce825311da03c7a77ab7d89d728c
+  metadata.gz: 851a0cbbd200cffc7280a35168450fcfdb690af48b21c5adf6864289df9fa8eb2b7e7999b396598d0bf3db371e1e721db896bdb869288aa79b8d5db36467b2ed
+  data.tar.gz: 806d66ebf5e196040b42bc023dc2ac13a374037df98e419cc1db69bc2a52c10cd4bae8e6e22c79681ed27256fbba81e109d3a0a593ae62831d3f0cd827c6e2f8

data/CHANGELOG

@@ -1,3 +1,25 @@
+=== 4.26.0 (2015-09-01)
+
+* Make Dataset#== not consider frozen status in determining equality (jeremyevans)
+
+* Support :if_exists option to drop_column on PostgreSQL (jeremyevans)
+
+* Add Dataset#grouping_sets to support GROUP BY GROUPING SETS on PostgreSQL 9.5+, MSSQL 2008+, Oracle, DB2, and SQLAnywhere (jeremyevans)
+
+* Fix handling of Class.new(ModelClass){set_dataset :table} on ruby 1.8 (jeremyevans)
+
+* Use range function constructors instead of casts for known range types in pg_range (jeremyevans) (#1066)
+
+* Make class_table_inheritance plugin work without sti_key (jeremyevans)
+
+* Detect additional disconnect errors when using the tinytds adapter (jeremyevans)
+
+* Make offset emulation without order but with explicit selection handle ambiguous column names (jeremyevans)
+
+* Allow preparing already prepared statements when emulating limits and/or offsets (jeremyevans)
+
+* Have Sequel::NoMatchingRow exceptions record the dataset related to the exception (pedro, jeremyevans) (#1060)
+
 === 4.25.0 (2015-08-01)
 
 * Add Dataset#insert_conflict on PostgreSQL 9.5+, for upsert/insert ignore support using INSERT ON CONFLICT (jeremyevans)

data/README.rdoc

@@ -17,15 +17,15 @@ toolkit for Ruby.
 
 == Resources
 
-* {Website}[http://sequel.jeremyevans.net]
-* {Source code}[http://github.com/jeremyevans/sequel]
-* {Google group}[http://groups.google.com/group/sequel-talk]
-* {IRC}[irc://irc.freenode.net/sequel]
-* {Bug tracking}[http://github.com/jeremyevans/sequel/issues]
-* {RDoc}[http://sequel.jeremyevans.net/rdoc]
+Website :: http://sequel.jeremyevans.net
+RDoc Documentation :: http://sequel.jeremyevans.net/rdoc
+Source Code :: https://github.com/jeremyevans/sequel
+Bug tracking (GitHub Issues) :: http://github.com/jeremyevans/sequel/issues
+Discussion Forum (sequel-talk Google Group) :: http://groups.google.com/group/sequel-talk
+IRC Channel (#sequel) :: irc://irc.freenode.net/sequel
 
 If you have questions about how to use Sequel, please ask on the
-Google Group or IRC.  Only use the the bug tracker to report
+sequel-talk Google Group or IRC.  Only use the the bug tracker to report
 bugs in Sequel, not to ask for help on using Sequel.
 
 To check out the source code:

data/doc/release_notes/4.26.0.txt

@@ -0,0 +1,44 @@
+= New Features
+
+* Add Dataset#grouping_sets to support GROUP BY GROUPING SETS on
+  PostgreSQL 9.5+, MSSQL 2008+, Oracle, DB2, and SQLAnywhere:
+
+    DB[:test].group([:type_id, :b], :type_id, []).grouping_sets
+    # SELECT * FROM test
+    # GROUP BY GROUPING SETS((type_id, b), (type_id), ())
+
+* Sequel::NoMatchingRow exceptions raised by Sequel now give access
+  to the dataset that raised the exception via the dataset method.
+  This makes it easier to write generic error handling code.
+
+* Support :if_exists option to drop_column on PostgreSQL:
+
+    DB.drop_column :t, :col, :if_exists=>true 
+    ALTER TABLE t DROP COLUMN IF EXISTS col
+
+= Other Improvements
+
+* Make the class_table_inheritance plugin work correctly without an
+  sti_key.  This was broken in a recent refactoring to make class
+  table inheritance support multiple classes for a single table.
+
+* Make Class.new(ModelClass){set_dataset :table} work correctly on
+  ruby 1.8.  This was broken in a refactoring to allow the
+  singular_table_names plugin to work.
+
+* Make offset emulation via ROW_NUMBER better handle ambiguous column
+  names for datasets without an ORDER BY clause, but with an explicit
+  SELECT clause.
+
+* Make pg_range extension use PostgreSQL range function constructors
+  instead of casting string literals to the appropriate range type,
+  if the range type is known.  This allows arbitrary expressions to
+  be used inside ranges, such as CURRENT_TIMESTAMP in timestamp
+  ranges.
+
+* Make Dataset#== not consider frozen status.
+
+* Allow Dataset#prepare on already prepared statements in situations
+  where determining the SQL for a prepared statement requires it.
+
+* Detect additional disconnect errors when using the tinytds adapter.

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

@@ -29,13 +29,8 @@ module Sequel
 
       private
 
-      def alter_table_op_sql(table, op)
-        case op[:op]
-        when :set_column_type
-          "ALTER COLUMN #{quote_identifier(op[:name])} #{type_literal(op)}"
-        else
-          super
-        end
+      def alter_table_set_column_type_sql(table, op)
+        "ALTER COLUMN #{quote_identifier(op[:name])} #{type_literal(op)}"
       end
 
       # Access doesn't support CREATE TABLE AS, it only supports SELECT INTO.

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

@@ -81,24 +81,24 @@ module Sequel
           map{|c| m.call(c)}
       end
 
-      def alter_table_op_sql(table, op)
-        case op[:op]
-        when :rename_column
-          "RENAME COLUMN #{quote_identifier(op[:name])} AS #{quote_identifier(op[:new_name])}"
-        when :set_column_type, :set_column_null, :set_column_default
-          o = op[:op]
-          opts = schema(table).find{|x| x.first == op[:name]}
-          opts = opts ? opts.last.dup : {}
-          opts[:name] = o == :rename_column ? op[:new_name] : op[:name]
-          opts[:type] = o == :set_column_type ? op[:type] : opts[:db_type]
-          opts[:null] = o == :set_column_null ? op[:null] : opts[:allow_null]
-          opts[:default] = o == :set_column_default ? op[:default] : opts[:ruby_default]
-          opts.delete(:default) if opts[:default] == nil
-          "CHANGE COLUMN #{quote_identifier(op[:name])} #{column_definition_sql(op.merge(opts))}"
-        else
-          super
-        end
-      end
+      def alter_table_rename_column_sql(table, op)
+        "RENAME COLUMN #{quote_identifier(op[:name])} AS #{quote_identifier(op[:new_name])}"
+      end
+
+      def alter_table_change_column_sql(table, op)
+        o = op[:op]
+        opts = schema(table).find{|x| x.first == op[:name]}
+        opts = opts ? opts.last.dup : {}
+        opts[:name] = o == :rename_column ? op[:new_name] : op[:name]
+        opts[:type] = o == :set_column_type ? op[:type] : opts[:db_type]
+        opts[:null] = o == :set_column_null ? op[:null] : opts[:allow_null]
+        opts[:default] = o == :set_column_default ? op[:default] : opts[:ruby_default]
+        opts.delete(:default) if opts[:default] == nil
+        "CHANGE COLUMN #{quote_identifier(op[:name])} #{column_definition_sql(op.merge(opts))}"
+      end
+      alias alter_table_set_column_type_sql alter_table_change_column_sql
+      alias alter_table_set_column_null_sql alter_table_change_column_sql
+      alias alter_table_set_column_default_sql alter_table_change_column_sql
 
       def alter_table_sql(table, op)
         case op[:op]

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

@@ -322,6 +322,11 @@ module Sequel
         true
       end
 
+      # DB2 supports GROUPING SETS
+      def supports_grouping_sets?
+        true
+      end
+
       # DB2 does not support IS TRUE.
       def supports_is_true?
         false

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

@@ -729,6 +729,11 @@ module Sequel
         is_2005_or_later?
       end
 
+      # MSSQL 2005+ supports GROUPING SETS
+      def supports_grouping_sets?
+        is_2008_or_later?
+      end
+
       # MSSQL supports insert_select via the OUTPUT clause.
       def supports_insert_select?
         supports_output_clause? && !opts[:disable_insert_output]

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

@@ -185,60 +185,64 @@ module Sequel
       
       private
       
-      # Use MySQL specific syntax for some alter table operations.
-      def alter_table_op_sql(table, op)
-        case op[:op]
-        when :add_column
-          if related = op.delete(:table)
-            sql = super
-            op[:table] = related
-            op[:key] ||= primary_key_from_schema(related)
-            sql << ", ADD "
-            if constraint_name = op.delete(:foreign_key_constraint_name)
-              sql << "CONSTRAINT #{quote_identifier(constraint_name)} "
-            end
-            sql << "FOREIGN KEY (#{quote_identifier(op[:name])})#{column_references_sql(op)}"
-          else
-            super
-          end
-        when :rename_column, :set_column_type, :set_column_null, :set_column_default
-          o = op[:op]
-          opts = schema(table).find{|x| x.first == op[:name]}
-          opts = opts ? opts.last.dup : {}
-          opts[:name] = o == :rename_column ? op[:new_name] : op[:name]
-          opts[:type] = o == :set_column_type ? op[:type] : opts[:db_type]
-          opts[:null] = o == :set_column_null ? op[:null] : opts[:allow_null]
-          opts[:default] = o == :set_column_default ? op[:default] : opts[:ruby_default]
-          opts.delete(:default) if opts[:default] == nil
-          opts.delete(:primary_key)
-          unless op[:type] || opts[:type]
-            raise Error, "cannot determine database type to use for CHANGE COLUMN operation"
-          end
-          opts = op.merge(opts)
-          if op.has_key?(:auto_increment)
-            opts[:auto_increment] = op[:auto_increment]
+      def alter_table_add_column_sql(table, op)
+        if related = op.delete(:table)
+          sql = super
+          op[:table] = related
+          op[:key] ||= primary_key_from_schema(related)
+          sql << ", ADD "
+          if constraint_name = op.delete(:foreign_key_constraint_name)
+            sql << "CONSTRAINT #{quote_identifier(constraint_name)} "
           end
-          "CHANGE COLUMN #{quote_identifier(op[:name])} #{column_definition_sql(opts)}"
-        when :drop_constraint
-          case op[:type]
-          when :primary_key
-            "DROP PRIMARY KEY"
-          when :foreign_key
-            name = op[:name] || foreign_key_name(table, op[:columns])
-            "DROP FOREIGN KEY #{quote_identifier(name)}"
-          when :unique
-            "DROP INDEX #{quote_identifier(op[:name])}"
-          end
-        when :add_constraint
-          if op[:type] == :foreign_key
-            op[:key] ||= primary_key_from_schema(op[:table])
-          end
-          super
+          sql << "FOREIGN KEY (#{quote_identifier(op[:name])})#{column_references_sql(op)}"
         else
           super
         end
       end
 
+      def alter_table_change_column_sql(table, op)
+        o = op[:op]
+        opts = schema(table).find{|x| x.first == op[:name]}
+        opts = opts ? opts.last.dup : {}
+        opts[:name] = o == :rename_column ? op[:new_name] : op[:name]
+        opts[:type] = o == :set_column_type ? op[:type] : opts[:db_type]
+        opts[:null] = o == :set_column_null ? op[:null] : opts[:allow_null]
+        opts[:default] = o == :set_column_default ? op[:default] : opts[:ruby_default]
+        opts.delete(:default) if opts[:default] == nil
+        opts.delete(:primary_key)
+        unless op[:type] || opts[:type]
+          raise Error, "cannot determine database type to use for CHANGE COLUMN operation"
+        end
+        opts = op.merge(opts)
+        if op.has_key?(:auto_increment)
+          opts[:auto_increment] = op[:auto_increment]
+        end
+        "CHANGE COLUMN #{quote_identifier(op[:name])} #{column_definition_sql(opts)}"
+      end
+      alias alter_table_rename_column_sql alter_table_change_column_sql
+      alias alter_table_set_column_type_sql alter_table_change_column_sql
+      alias alter_table_set_column_null_sql alter_table_change_column_sql
+      alias alter_table_set_column_default_sql alter_table_change_column_sql
+
+      def alter_table_add_constraint_sql(table, op)
+        if op[:type] == :foreign_key
+          op[:key] ||= primary_key_from_schema(op[:table])
+        end
+        super
+      end
+
+      def alter_table_drop_constraint_sql(table, op)
+        case op[:type]
+        when :primary_key
+          "DROP PRIMARY KEY"
+        when :foreign_key
+          name = op[:name] || foreign_key_name(table, op[:columns])
+          "DROP FOREIGN KEY #{quote_identifier(name)}"
+        when :unique
+          "DROP INDEX #{quote_identifier(op[:name])}"
+        end
+      end
+
       # MySQL server requires table names when dropping indexes.
       def alter_table_sql(table, op)
         case op[:op]

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

@@ -393,6 +393,11 @@ module Sequel
         true
       end
 
+      # Oracle supports GROUPING SETS
+      def supports_grouping_sets?
+        true
+      end
+
       # Oracle does not support INTERSECT ALL or EXCEPT ALL
       def supports_intersect_except_all?
         false
@@ -435,6 +440,12 @@ module Sequel
 
       private
 
+      # Allow preparing prepared statements, since determining the prepared sql to use for
+      # a prepared statement requires calling prepare on that statement.
+      def allow_preparing_prepared_statements?
+        true
+      end
+
       # Oracle doesn't support the use of AS when aliasing a dataset.  It doesn't require
       # the use of AS anywhere, so this disables it in all cases.
       def as_sql_append(sql, aliaz, column_aliases=nil)

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

@@ -579,22 +579,22 @@ module Sequel
         Postgres::AlterTableGenerator
       end
     
-      # Handle :using option for set_column_type op, and the :validate_constraint op.
-      def alter_table_op_sql(table, op)
-        case op[:op]
-        when :set_column_type
-          s = super
-          if using = op[:using]
-            using = Sequel::LiteralString.new(using) if using.is_a?(String)
-            s << ' USING '
-            s << literal(using)
-          end
-          s
-        when :validate_constraint
-          "VALIDATE CONSTRAINT #{quote_identifier(op[:name])}"
-        else
-          super
+      def alter_table_set_column_type_sql(table, op)
+        s = super
+        if using = op[:using]
+          using = Sequel::LiteralString.new(using) if using.is_a?(String)
+          s << ' USING '
+          s << literal(using)
         end
+        s
+      end
+
+      def alter_table_drop_column_sql(table, op)
+        "DROP COLUMN #{'IF EXISTS ' if op[:if_exists]}#{quote_identifier(op[:name])}#{' CASCADE' if op[:cascade]}"
+      end
+
+      def alter_table_validate_constraint_sql(table, op)
+        "VALIDATE CONSTRAINT #{quote_identifier(op[:name])}"
       end
 
       # If the :synchronous option is given and non-nil, set synchronous_commit
@@ -1462,6 +1462,11 @@ module Sequel
         server_version >= 90500
       end
 
+      # PostgreSQL 9.5+ supports GROUPING SETS
+      def supports_grouping_sets?
+        server_version >= 90500
+      end
+
       # True unless insert returning has been disabled for this dataset.
       def supports_insert_select?
         !@opts[:disable_insert_returning]

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

@@ -283,6 +283,11 @@ module Sequel
         type == :select || type == :insert
       end
 
+      # SQLAnywhere supports GROUPING SETS
+      def supports_grouping_sets?
+        true
+      end
+
       def supports_multiple_column_in?
         false
       end

data/lib/sequel/adapters/tinytds.rb

@@ -129,9 +129,10 @@ module Sequel
         end
       end
 
+      TINYTDS_DISCONNECT_ERRORS = /\A(Attempt to initiate a new Adaptive Server operation with results pending|The request failed to run because the batch is aborted, this can be caused by abort signal sent from client)/
       # Return true if the :conn argument is present and not active.
       def disconnect_error?(e, opts)
-        super || (opts[:conn] && !opts[:conn].active?)
+        super || (opts[:conn] && !opts[:conn].active?) || ((e.is_a?(::TinyTds::Error) && TINYTDS_DISCONNECT_ERRORS.match(e.message)))
       end
 
       # Dispose of any possible results of execution.

data/lib/sequel/adapters/utils/emulate_offset_with_row_number.rb

@@ -51,9 +51,30 @@ module Sequel
 
     private
 
+    # Allow preparing prepared statements, since determining the prepared sql to use for
+    # a prepared statement requires calling prepare on that statement.
+    def allow_preparing_prepared_statements?
+      true
+    end
+
     # The default order to use for datasets with offsets, if no order is defined.
     # By default, orders by all of the columns in the dataset.
     def default_offset_order
+      if (cols = opts[:select])
+        cols.each do |c|
+          case c
+          when Symbol
+            return [split_alias(c).first]
+          when SQL::Identifier, SQL::QualifiedIdentifier
+            return [c]
+          when SQL::AliasedExpression
+            case c.expression
+            when Symbol, SQL::Identifier, SQL::QualifiedIdentifier
+              return [c.expression]
+            end
+          end
+        end
+      end
       clone(:append_sql=>'').columns
     end
 

data/lib/sequel/database/schema_generator.rb

@@ -407,6 +407,15 @@ module Sequel
       #
       #   drop_column(:artist_id) # DROP COLUMN artist_id
       #   drop_column(:artist_id, :cascade=>true) # DROP COLUMN artist_id CASCADE
+      #
+      # Options:
+      #
+      # :cascade :: CASCADE the operation, dropping other objects that depend on
+      #             the dropped column.
+      # 
+      # PostgreSQL specific options:
+      # :if_exists :: Use IF EXISTS, so no error is raised if the column does not
+      #               exist.
       def drop_column(name, opts=OPTS)
         @operations << {:op => :drop_column, :name => name}.merge!(opts)
       end

data/lib/sequel/database/schema_methods.rb

@@ -430,32 +430,50 @@ module Sequel
     
     # SQL fragment for given alter table operation.
     def alter_table_op_sql(table, op)
-      quoted_name = quote_identifier(op[:name]) if op[:name]
-      case op[:op]
-      when :add_column
-        "ADD COLUMN #{column_definition_sql(op)}"
-      when :drop_column
-        "DROP COLUMN #{quoted_name}#{' CASCADE' if op[:cascade]}"
-      when :rename_column
-        "RENAME COLUMN #{quoted_name} TO #{quote_identifier(op[:new_name])}"
-      when :set_column_type
-        "ALTER COLUMN #{quoted_name} TYPE #{type_literal(op)}"
-      when :set_column_default
-        "ALTER COLUMN #{quoted_name} SET DEFAULT #{literal(op[:default])}"
-      when :set_column_null
-        "ALTER COLUMN #{quoted_name} #{op[:null] ? 'DROP' : 'SET'} NOT NULL"
-      when :add_constraint
-        "ADD #{constraint_definition_sql(op)}"
-      when :drop_constraint
-        if op[:type] == :foreign_key
-          quoted_name ||= quote_identifier(foreign_key_name(table, op[:columns]))
-        end
-        "DROP CONSTRAINT #{quoted_name}#{' CASCADE' if op[:cascade]}"
+      meth = "alter_table_#{op[:op]}_sql"
+      if respond_to?(meth, true)
+        send(meth, table, op)
       else
         raise Error, "Unsupported ALTER TABLE operation: #{op[:op]}"
       end
     end
 
+    def alter_table_add_column_sql(table, op)
+      "ADD COLUMN #{column_definition_sql(op)}"
+    end
+
+    def alter_table_drop_column_sql(table, op)
+      "DROP COLUMN #{quote_identifier(op[:name])}#{' CASCADE' if op[:cascade]}"
+    end
+
+    def alter_table_rename_column_sql(table, op)
+      "RENAME COLUMN #{quote_identifier(op[:name])} TO #{quote_identifier(op[:new_name])}"
+    end
+
+    def alter_table_set_column_type_sql(table, op)
+      "ALTER COLUMN #{quote_identifier(op[:name])} TYPE #{type_literal(op)}"
+    end
+
+    def alter_table_set_column_default_sql(table, op)
+      "ALTER COLUMN #{quote_identifier(op[:name])} SET DEFAULT #{literal(op[:default])}"
+    end
+
+    def alter_table_set_column_null_sql(table, op)
+      "ALTER COLUMN #{quote_identifier(op[:name])} #{op[:null] ? 'DROP' : 'SET'} NOT NULL"
+    end
+
+    def alter_table_add_constraint_sql(table, op)
+      "ADD #{constraint_definition_sql(op)}"
+    end
+
+    def alter_table_drop_constraint_sql(table, op)
+      quoted_name = quote_identifier(op[:name]) if op[:name]
+      if op[:type] == :foreign_key
+        quoted_name ||= quote_identifier(foreign_key_name(table, op[:columns]))
+      end
+      "DROP CONSTRAINT #{quoted_name}#{' CASCADE' if op[:cascade]}"
+    end
+
     # The SQL to execute to modify the DDL for the given table name.  op
     # should be one of the operations returned by the AlterTableGenerator.
     def alter_table_sql(table, op)

data/lib/sequel/dataset/actions.rb

@@ -203,7 +203,7 @@ module Sequel
     # Calls first.  If first returns nil (signaling that no
     # row matches), raise a Sequel::NoMatchingRow exception.
     def first!(*args, &block)
-      first(*args, &block) || raise(Sequel::NoMatchingRow)
+      first(*args, &block) || raise(Sequel::NoMatchingRow.new(self))
     end
 
     # Return the column value for the first matching record in the dataset.
@@ -268,7 +268,7 @@ module Sequel
     # :commit_every :: Open a new transaction for every given number of records.
     #                  For example, if you provide a value of 50, will commit
     #                  after every 50 records.
-    # :return :: When the :value is :primary_key, returns an array of
+    # :return :: When this is set to :primary_key, returns an array of
     #            autoincremented primary key values for the rows inserted.
     # :server :: Set the server/shard to use for the transaction and insert
     #            queries.

data/lib/sequel/dataset/features.rb

@@ -76,6 +76,11 @@ module Sequel
       false
     end
 
+    # Whether the dataset supports GROUPING SETS with GROUP BY.
+    def supports_grouping_sets?
+      false
+    end
+
     # Whether this dataset supports the +insert_select+ method for returning all columns values
     # directly from an insert query.
     def supports_insert_select?

data/lib/sequel/dataset/graph.rb

@@ -2,9 +2,9 @@ module Sequel
   class Dataset
     # ---------------------
     # :section: 5 - Methods related to dataset graphing
-    # Dataset graphing changes the dataset to yield hashes where keys are table
-    # name symbols and values are hashes representing the columns related to
-    # that table.  All of these methods return modified copies of the receiver.
+    # Dataset graphing automatically creates unique aliases columns in join
+    # tables that overlap with already selected column aliases. 
+    # All of these methods return modified copies of the receiver.
     # ---------------------
     
     # Adds the given graph aliases to the list of graph aliases to use,

data/lib/sequel/dataset/misc.rb

@@ -50,7 +50,7 @@ module Sequel
     # Similar to #clone, but returns an unfrozen clone if the receiver is frozen.
     def dup
       o = clone
-      o.opts.delete(:frozen)
+      o.instance_variable_set(:@frozen, false) if frozen?
       o
     end
     
@@ -74,13 +74,13 @@ module Sequel
 
     # Sets the frozen flag on the dataset, so you can't modify it. Returns the receiver.
     def freeze
-      @opts[:frozen] = true
+      @frozen = true
       self
     end
 
     # Whether the object is frozen.
     def frozen?
-      @opts[:frozen]
+      @frozen == true
     end
    
     # Alias of +first_source_alias+

data/lib/sequel/dataset/prepared_statements.rb

@@ -100,7 +100,8 @@ module Sequel
       # Raise an error if attempting to call prepare on an already
       # prepared statement.
       def prepare(*)
-        raise Error, "cannot prepare an already prepared statement"
+        raise Error, "cannot prepare an already prepared statement" unless allow_preparing_prepared_statements?
+        super
       end
 
       # Send the columns to the original dataset, as calling it
@@ -309,6 +310,11 @@ module Sequel
 
     private
     
+    # Don't allow preparing prepared statements by default.
+    def allow_preparing_prepared_statements?
+      false
+    end
+
     # The argument placeholder.  Most databases used unnumbered
     # arguments with question marks, so that is the default.
     def prepared_arg_placeholder

data/lib/sequel/dataset/query.rb

@@ -337,6 +337,12 @@ module Sequel
       clone(:group_options=>:rollup)
     end
 
+    # Adds the appropriate GROUPING SETS syntax to GROUP BY.
+    def grouping_sets
+      raise Error, "GROUP BY GROUPING SETS not supported on #{db.database_type}" unless supports_grouping_sets?
+      clone(:group_options=>:"grouping sets")
+    end
+
     # Returns a copy of the dataset with the HAVING conditions changed. See #where for argument types.
     #
     #   DB[:items].group(:sum).having(:sum=>10)

data/lib/sequel/dataset/sql.rb

@@ -271,6 +271,7 @@ module Sequel
     DOUBLE_APOS = "''".freeze
     DOUBLE_QUOTE = '""'.freeze
     EQUAL = ' = '.freeze
+    EMPTY_PARENS = '()'.freeze
     ESCAPE = " ESCAPE ".freeze
     EXTRACT = 'extract('.freeze
     EXISTS = ['EXISTS '.freeze].freeze
@@ -1008,6 +1009,21 @@ module Sequel
       end
     end
 
+    # Append literalization of array of grouping elements to SQL string.
+    def grouping_element_list_append(sql, columns)
+      c = false
+      co = COMMA
+      columns.each do |col|
+        sql << co if c
+        if col.is_a?(Array) && col.empty?
+          sql << EMPTY_PARENS
+        else
+          literal_append(sql, Array(col))
+        end
+        c ||= true
+      end
+    end
+
     # An expression for how to handle an empty array lookup.
     def empty_array_value(op, cols)
       {1 => ((op == :IN) ? 0 : 1)}
@@ -1352,7 +1368,11 @@ module Sequel
       if group = @opts[:group]
         sql << GROUP_BY
         if go = @opts[:group_options]
-          if uses_with_rollup?
+          if go == :"grouping sets"
+            sql << go.to_s.upcase << PAREN_OPEN
+            grouping_element_list_append(sql, group)
+            sql << PAREN_CLOSE
+          elsif uses_with_rollup?
             expression_list_append(sql, group)
             sql << SPACE_WITH << go.to_s.upcase
           else

data/lib/sequel/exceptions.rb

@@ -52,7 +52,20 @@ module Sequel
 
   # Error raised when the user requests a record via the first! or similar
   # method, and the dataset does not yield any rows.
-  NoMatchingRow = Class.new(Error)
+  class NoMatchingRow < Error
+    # The dataset that raised this NoMatchingRow exception.
+    attr_accessor :dataset
+
+    # If the first argument is a Sequel::Dataset, set the dataset related to
+    # the exception to that argument, instead of assuming it is the exception message.
+    def initialize(msg=nil)
+      if msg.is_a?(Sequel::Dataset)
+        @dataset = msg
+        msg = nil
+      end
+      super
+    end
+  end
 
   # Error raised when the connection pool cannot acquire a database connection
   # before the timeout.

data/lib/sequel/extensions/pg_range.rb

@@ -71,6 +71,7 @@ module Sequel
 
       EMPTY = 'empty'.freeze
       EMPTY_STRING = ''.freeze
+      COMMA = ','.freeze
       QUOTED_EMPTY_STRING = '""'.freeze
       OPEN_PAREN = "(".freeze
       CLOSE_PAREN = ")".freeze
@@ -91,8 +92,8 @@ module Sequel
       # :oid :: The PostgreSQL OID for the range type.  This is used by the Sequel postgres adapter
       #         to set up automatic type conversion on retrieval from the database.
       # :subtype_oid :: Should be the PostgreSQL OID for the range's subtype. If given,
-      #                automatically sets the :converter option by looking for scalar conversion
-      #                proc.
+      #                 automatically sets the :converter option by looking for scalar conversion
+      #                 proc.
       #
       # If a block is given, it is treated as the :converter option.
       def self.register(db_type, opts=OPTS, &block)
@@ -414,9 +415,19 @@ module Sequel
 
       # Append a literalize version of the receiver to the sql.
       def sql_literal_append(ds, sql)
-        ds.literal_append(sql, unquoted_literal(ds))
-        if s = @db_type
-          sql << CAST << s.to_s
+        if (s = @db_type) && !empty?
+          sql << s.to_s << OPEN_PAREN
+          ds.literal_append(sql, self.begin)
+          sql << COMMA
+          ds.literal_append(sql, self.end)
+          sql << COMMA
+          ds.literal_append(sql, "#{exclude_begin? ? OPEN_PAREN : OPEN_BRACKET}#{exclude_end? ? CLOSE_PAREN : CLOSE_BRACKET}")
+          sql << CLOSE_PAREN
+        else
+          ds.literal_append(sql, unquoted_literal(ds))
+          if s
+            sql << CAST << s.to_s
+          end
         end
       end
 

data/lib/sequel/model/base.rb

@@ -468,7 +468,7 @@ module Sequel
       # An alias for calling first! on the model's dataset, but with
       # optimized handling of the single argument case.
       def first!(*args, &block)
-        first(*args, &block) || raise(Sequel::NoMatchingRow)
+        first(*args, &block) || raise(Sequel::NoMatchingRow.new(dataset))
       end
 
       # Clear the setter_methods cache when a module is included, as it
@@ -509,11 +509,13 @@ module Sequel
           subclass.instance_variable_set(iv, sup_class_value)
         end
 
-        if @dataset && self != Model
-          subclass.set_dataset(@dataset.clone, :inherited=>true) rescue nil
-        elsif (n = subclass.name) && !n.to_s.empty?
-          db
-          subclass.set_dataset(subclass.implicit_table_name) rescue nil
+        unless ivs.include?("@dataset")
+          if @dataset && self != Model
+            subclass.set_dataset(@dataset.clone, :inherited=>true) rescue nil
+          elsif (n = subclass.name) && !n.to_s.empty?
+            db
+            subclass.set_dataset(subclass.implicit_table_name) rescue nil
+          end
         end
       end
 
@@ -783,7 +785,7 @@ module Sequel
 
       # Return the model instance with the primary key, or raise NoMatchingRow if there is no matching record.
       def with_pk!(pk)
-        with_pk(pk) || raise(NoMatchingRow)
+        with_pk(pk) || raise(NoMatchingRow.new(dataset))
       end
   
       # Add model methods that call dataset methods
@@ -2346,7 +2348,7 @@ module Sequel
       # Same as with_pk, but raises NoMatchingRow instead of returning nil if no
       # row matches.
       def with_pk!(pk)
-        with_pk(pk) || raise(NoMatchingRow)
+        with_pk(pk) || raise(NoMatchingRow.new(self))
       end
     end
 

data/lib/sequel/plugins/association_pks.rb

@@ -20,10 +20,10 @@ module Sequel
     # not call any callbacks.  If you have any association callbacks,
     # you probably should not use the setter methods.
     #
-    # If an association uses the :delay option, you can set the associated
+    # If an association uses the :delay_pks option, you can set the associated
     # pks for new objects, and the setting will not be persisted until after the
     # object has been created in the database.  Additionally, if an association
-    # uses the :delay=>:all option, you can set the associated pks for existing
+    # uses the :delay_pks=>:all option, you can set the associated pks for existing
     # objects, and the setting will not be persisted until after the object has
     # been saved.
     #

data/lib/sequel/plugins/single_table_inheritance.rb

@@ -211,7 +211,7 @@ module Sequel
 
         # Set the sti_key column based on the sti_key_map.
         def _before_validation
-          if new? && !self[model.sti_key]
+          if new? && model.sti_key && !self[model.sti_key]
             set_column_value("#{model.sti_key}=", model.sti_key_chooser.call(self))
           end
           super

data/lib/sequel/version.rb

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

data/spec/adapters/postgres_spec.rb

@@ -107,6 +107,14 @@ describe "PostgreSQL", '#create_table' do
     end.must_raise(Sequel::Error, "can't provide both :temp and :unlogged to create_table")
   end
 
+  it "should support :if_exists option to drop_column" do
+    @db.create_table(:tmp_dolls){Integer :a; Integer :b}
+    2.times do
+      @db.drop_column :tmp_dolls, :b, :if_exists=>true
+      @db[:tmp_dolls].columns.must_equal [:a]
+    end
+  end if DB.server_version >= 90000
+
   it "should support pg_loose_count extension" do
     @db.extension :pg_loose_count
     @db.create_table(:tmp_dolls){text :name}
@@ -3145,6 +3153,15 @@ describe 'PostgreSQL range types' do
     v.each{|k,v1| v1.must_be :==, @ra[k].to_a}
   end
 
+  it 'works with current_datetime_timestamp extension' do
+    ds = @db.dataset.extension(:current_datetime_timestamp)
+    tsr = ds.get(Sequel.pg_range(ds.current_datetime..ds.current_datetime, :tstzrange))
+    if @native
+      tsr.begin.must_be_kind_of Time
+      tsr.end.must_be_kind_of Time
+    end
+  end
+
   it 'operations/functions with pg_range_ops' do
     Sequel.extension :pg_range_ops
 

data/spec/core/dataset_spec.rb

@@ -869,9 +869,16 @@ describe "Dataset#group_by" do
     @dataset.group(:type_id, :b).group_cube.select_sql.must_equal "SELECT * FROM test GROUP BY type_id, b WITH CUBE"
   end
 
-  it "should have #group_cube and #group_rollup methods raise an Error if not supported it" do
+  it "should support a #grouping_sets method if the database supports it" do
+    meta_def(@dataset, :supports_grouping_sets?){true}
+    @dataset.group(:type_id).grouping_sets.select_sql.must_equal "SELECT * FROM test GROUP BY GROUPING SETS((type_id))"
+    @dataset.group([:type_id, :b], :type_id, []).grouping_sets.select_sql.must_equal "SELECT * FROM test GROUP BY GROUPING SETS((type_id, b), (type_id), ())"
+  end
+
+  it "should have #group_* methods raise an Error if not supported it" do
     proc{@dataset.group(:type_id).group_rollup}.must_raise(Sequel::Error)
     proc{@dataset.group(:type_id).group_cube}.must_raise(Sequel::Error)
+    proc{@dataset.group(:type_id).grouping_sets}.must_raise(Sequel::Error)
   end
 end
 
@@ -2580,6 +2587,17 @@ describe "Dataset #first!" do
   it "should raise NoMatchingRow exception if no rows match" do
     proc{Sequel.mock[:t].first!}.must_raise(Sequel::NoMatchingRow)
   end
+
+  it "saves a reference to the dataset with the exception to allow further processing" do
+    dataset = Sequel.mock[:t]
+    begin
+      dataset.first!
+    rescue Sequel::NoMatchingRow => e
+      e.dataset.must_equal(dataset)
+    end
+    proc{raise Sequel::NoMatchingRow, 'test'}.must_raise Sequel::NoMatchingRow
+    proc{raise Sequel::NoMatchingRow.new('test')}.must_raise Sequel::NoMatchingRow
+  end
 end
   
 describe "Dataset compound operations" do
@@ -4877,6 +4895,10 @@ describe "Frozen Datasets" do
     @ds.clone.must_be :frozen?
   end
 
+  it "should be equal to unfrozen ones" do
+    @ds.must_equal @ds.db[:test]
+  end
+
   it "should have dups not be frozen" do
     @ds.dup.wont_be :frozen?
   end

data/spec/core_extensions_spec.rb

@@ -694,6 +694,6 @@ describe "Postgres extensions integration" do
 
   it "Range#pg_range should return an PGRange" do
     @db.literal((1..2).pg_range).must_equal "'[1,2]'"
-    @db.literal((1..2).pg_range(:int4range)).must_equal "'[1,2]'::int4range"
+    @db.literal((1..2).pg_range(:int4range)).must_equal "int4range(1,2,'[]')"
   end
 end

data/spec/extensions/class_table_inheritance_spec.rb

@@ -58,11 +58,11 @@ describe "class_table_inheritance plugin" do
     Staff.simple_table.must_equal nil
   end
   
-    it "should have working row_proc if using set_dataset in subclass to remove columns" do
-      Manager.set_dataset(Manager.dataset.select(*(Manager.columns - [:blah])))
-      Manager.dataset._fetch = {:id=>1, :kind=>'Ceo'}
-      Manager[1].must_equal Ceo.load(:id=>1, :kind=>'Ceo')
-    end
+  it "should have working row_proc if using set_dataset in subclass to remove columns" do
+    Manager.set_dataset(Manager.dataset.select(*(Manager.columns - [:blah])))
+    Manager.dataset._fetch = {:id=>1, :kind=>'Ceo'}
+    Manager[1].must_equal Ceo.load(:id=>1, :kind=>'Ceo')
+  end
 
   it "should use a joined dataset in subclasses" do
     Employee.dataset.sql.must_equal 'SELECT * FROM employees'
@@ -276,3 +276,145 @@ describe "class_table_inheritance plugin" do
     @db.sqls.must_equal ['SELECT employees.id, employees.name, employees.kind, staff.manager_id FROM employees INNER JOIN staff ON (staff.id = employees.id) WHERE (staff.manager_id = 3)']
   end
 end
+
+describe "class_table_inheritance plugin without sti_key" do
+  before do
+    @db = Sequel.mock(:autoid=>proc{|sql| 1})
+    def @db.supports_schema_parsing?() true end
+    def @db.schema(table, opts={})
+      {:employees=>[[:id, {:primary_key=>true, :type=>:integer}], [:name, {:type=>:string}]],
+       :managers=>[[:id, {:type=>:integer}], [:num_staff, {:type=>:integer}]],
+       :executives=>[[:id, {:type=>:integer}], [:num_managers, {:type=>:integer}]],
+       :staff=>[[:id, {:type=>:integer}], [:manager_id, {:type=>:integer}]],
+       }[table.is_a?(Sequel::Dataset) ? table.first_source_table : table]
+    end
+    @db.extend_datasets do
+      def columns
+        {[:employees]=>[:id, :name],
+         [:managers]=>[:id, :num_staff],
+         [:executives]=>[:id, :num_managers],
+         [:staff]=>[:id, :manager_id],
+         [:employees, :managers]=>[:id, :name, :num_staff],
+         [:employees, :managers, :executives]=>[:id, :name, :num_staff, :num_managers],
+         [:employees, :staff]=>[:id, :name, :manager_id],
+        }[opts[:from] + (opts[:join] || []).map{|x| x.table}]
+      end
+    end
+    class ::Employee < Sequel::Model(@db)
+      def _save_refresh; @values[:id] = 1 end
+      def self.columns
+        dataset.columns
+      end
+      plugin :class_table_inheritance, :table_map=>{:Staff=>:staff}
+    end 
+    class ::Manager < Employee
+      one_to_many :staff_members, :class=>:Staff
+    end 
+    class ::Executive < Manager
+    end 
+    class ::Staff < Employee
+      many_to_one :manager
+    end 
+    @ds = Employee.dataset
+    @db.sqls
+  end
+  after do
+    Object.send(:remove_const, :Executive)
+    Object.send(:remove_const, :Manager)
+    Object.send(:remove_const, :Staff)
+    Object.send(:remove_const, :Employee)
+  end
+
+  it "should have simple_table = nil for all subclasses" do
+    Manager.simple_table.must_equal nil
+    Executive.simple_table.must_equal nil
+    Staff.simple_table.must_equal nil
+  end
+  
+  it "should have working row_proc if using set_dataset in subclass to remove columns" do
+    Manager.set_dataset(Manager.dataset.select(*(Manager.columns - [:blah])))
+    Manager.dataset._fetch = {:id=>1}
+    Manager[1].must_equal Manager.load(:id=>1)
+  end
+
+  it "should use a joined dataset in subclasses" do
+    Employee.dataset.sql.must_equal 'SELECT * FROM employees'
+    Manager.dataset.sql.must_equal 'SELECT employees.id, employees.name, managers.num_staff FROM employees INNER JOIN managers ON (managers.id = employees.id)'
+    Executive.dataset.sql.must_equal 'SELECT employees.id, employees.name, managers.num_staff, executives.num_managers FROM employees INNER JOIN managers ON (managers.id = employees.id) INNER JOIN executives ON (executives.id = managers.id)'
+    Staff.dataset.sql.must_equal 'SELECT employees.id, employees.name, staff.manager_id FROM employees INNER JOIN staff ON (staff.id = employees.id)'
+  end
+  
+  it "should return rows with the current class if cti_key is nil" do
+    Employee.plugin(:class_table_inheritance)
+    Employee.dataset._fetch = [{}]
+    Employee.first.class.must_equal Employee
+  end
+  
+  
+  it "should include schema for columns for tables for ancestor classes" do
+    Employee.db_schema.must_equal(:id=>{:primary_key=>true, :type=>:integer}, :name=>{:type=>:string})
+    Manager.db_schema.must_equal(:id=>{:primary_key=>true, :type=>:integer}, :name=>{:type=>:string}, :num_staff=>{:type=>:integer})
+    Executive.db_schema.must_equal(:id=>{:primary_key=>true, :type=>:integer}, :name=>{:type=>:string}, :num_staff=>{:type=>:integer}, :num_managers=>{:type=>:integer})
+    Staff.db_schema.must_equal(:id=>{:primary_key=>true, :type=>:integer}, :name=>{:type=>:string}, :manager_id=>{:type=>:integer})
+  end
+
+  it "should use the correct primary key (which should have the same name in all subclasses)" do
+    [Employee, Manager, Executive, Staff].each{|c| c.primary_key.must_equal :id}
+  end
+
+  it "should have table_name return the table name of the most specific table" do
+    Employee.table_name.must_equal :employees
+    Manager.table_name.must_equal :managers
+    Executive.table_name.must_equal :executives
+    Staff.table_name.must_equal :staff
+  end
+
+  it "should delete the correct rows from all tables when deleting" do
+    Executive.load(:id=>1).delete
+    @db.sqls.must_equal ["DELETE FROM executives WHERE (id = 1)", "DELETE FROM managers WHERE (id = 1)", "DELETE FROM employees WHERE (id = 1)"]
+  end
+
+  it "should not allow deletion of frozen object" do
+    o = Executive.load(:id=>1)
+    o.freeze
+    proc{o.delete}.must_raise(Sequel::Error)
+    @db.sqls.must_equal []
+  end
+
+  it "should insert the correct rows into all tables when inserting" do
+    Executive.create(:num_managers=>3, :num_staff=>2, :name=>'E')
+    sqls = @db.sqls
+    sqls.length.must_equal 3
+    sqls[0].must_match(/INSERT INTO employees \(name\) VALUES \('E'\)/)
+    sqls[1].must_match(/INSERT INTO managers \((num_staff|id), (num_staff|id)\) VALUES \([12], [12]\)/)
+    sqls[2].must_match(/INSERT INTO executives \((num_managers|id), (num_managers|id)\) VALUES \([13], [13]\)/)
+    end
+    
+  it "should insert the correct rows into all tables with a given primary key" do
+    e = Executive.new(:num_managers=>3, :num_staff=>2, :name=>'E')
+    e.id = 2
+    e.save
+    sqls = @db.sqls
+    sqls.length.must_equal 3
+    sqls[0].must_match(/INSERT INTO employees \((name|id), (name|id)\) VALUES \(('E'|2), ('E'|2)\)/)
+    sqls[1].must_match(/INSERT INTO managers \((num_staff|id), (num_staff|id)\) VALUES \(2, 2\)/)
+    sqls[2].must_match(/INSERT INTO executives \((num_managers|id), (num_managers|id)\) VALUES \([23], [23]\)/)
+  end
+
+  it "should update the correct rows in all tables when updating" do
+    Executive.load(:id=>2).update(:num_managers=>3, :num_staff=>2, :name=>'E')
+    @db.sqls.must_equal ["UPDATE employees SET name = 'E' WHERE (id = 2)", "UPDATE managers SET num_staff = 2 WHERE (id = 2)", "UPDATE executives SET num_managers = 3 WHERE (id = 2)"]
+  end
+
+  it "should handle many_to_one relationships correctly" do
+    Manager.dataset._fetch = {:id=>3, :name=>'E',  :num_staff=>3}
+    Staff.load(:manager_id=>3).manager.must_equal Manager.load(:id=>3, :name=>'E', :num_staff=>3)
+    @db.sqls.must_equal ['SELECT employees.id, employees.name, managers.num_staff FROM employees INNER JOIN managers ON (managers.id = employees.id) WHERE (managers.id = 3) LIMIT 1']
+  end
+  
+  it "should handle one_to_many relationships correctly" do
+    Staff.dataset._fetch = {:id=>1, :name=>'S', :manager_id=>3}
+    Executive.load(:id=>3).staff_members.must_equal [Staff.load(:id=>1, :name=>'S', :manager_id=>3)]
+    @db.sqls.must_equal ['SELECT employees.id, employees.name, staff.manager_id FROM employees INNER JOIN staff ON (staff.id = employees.id) WHERE (staff.manager_id = 3)']
+  end
+end

data/spec/extensions/core_refinements_spec.rb

@@ -511,7 +511,7 @@ describe "Postgres extensions integration" do
 
   it "Range#pg_range should return an PGRange" do
     @db.literal((1..2).pg_range).must_equal "'[1,2]'"
-    @db.literal((1..2).pg_range(:int4range)).must_equal "'[1,2]'::int4range"
+    @db.literal((1..2).pg_range(:int4range)).must_equal "int4range(1,2,'[]')"
   end
 end
 else

data/spec/extensions/pg_range_ops_spec.rb

@@ -26,7 +26,7 @@ describe "Sequel::Postgres::RangeOp" do
   end
 
   it "PGRange#op should return a RangeOp" do
-    @ds.literal(Sequel.pg_range(1..2, :numrange).op.lower).must_equal "lower('[1,2]'::numrange)"
+    @ds.literal(Sequel.pg_range(1..2, :numrange).op.lower).must_equal "lower(numrange(1,2,'[]'))"
   end
 
   it "should define methods for all of the PostgreSQL range operators" do

data/spec/extensions/pg_range_spec.rb

@@ -36,7 +36,7 @@ describe "pg_range extension" do
     @db.literal(@R.new(1, 2, :exclude_end=>true)).must_equal "'[1,2)'"
     @db.literal(@R.new(nil, 2)).must_equal "'[,2]'"
     @db.literal(@R.new(1, nil)).must_equal "'[1,]'"
-    @db.literal(@R.new(1, 2, :db_type=>'int8range')).must_equal "'[1,2]'::int8range"
+    @db.literal(@R.new(1, 2, :db_type=>'int8range')).must_equal "int8range(1,2,'[]')"
     @db.literal(@R.new(nil, nil, :empty=>true)).must_equal "'empty'"
     @db.literal(@R.new("", 2)).must_equal "'[\"\",2]'"
   end

data/spec/integration/dataset_test.rb

@@ -239,6 +239,10 @@ describe "Simple Dataset operations" do
   
   it "should fetch correctly with a limit and offset without an order" do
     @ds.limit(2, 1).all.must_equal []
+    @ds.join(:items___i, :id=>:id).select(:items__id___s, :i__id___id2).limit(2, 1).all.must_equal []
+    @ds.join(:items___i, :id=>:id).select(:items__id).limit(2, 1).all.must_equal []
+    @ds.join(:items___i, :id=>:id).select(Sequel.qualify(:items, :id)).limit(2, 1).all.must_equal []
+    @ds.join(:items___i, :id=>:id).select(Sequel.qualify(:items, :id).as(:s)).limit(2, 1).all.must_equal []
   end
 
   it "should be orderable by column number" do
@@ -957,14 +961,19 @@ describe "Sequel::Dataset convenience methods" do
   end
   
   it "#group_rollup should include hierarchy of groupings" do
-    @ds.group_by(:a).group_rollup.select_map([:a, Sequel.function(:sum, :b).cast(Integer).as(:b), Sequel.function(:sum, :c).cast(Integer).as(:c)]).sort_by{|x| x.inspect}.must_equal [[1, 10, 16], [2, 7, 11], [nil, 17, 27]]
-    @ds.group_by(:a, :b).group_rollup.select_map([:a, :b, Sequel.function(:sum, :c).cast(Integer).as(:c)]).sort_by{|x| x.inspect}.must_equal [[1, 3, 11], [1, 4, 5], [1, nil, 16], [2, 3, 5], [2, 4, 6], [2, nil, 11], [nil, nil, 27]]
+    @ds.group_by(:a).group_rollup.select_map([:a, Sequel.function(:sum, :b).cast(Integer).as(:b), Sequel.function(:sum, :c).cast(Integer).as(:c)]).sort_by{|x| x.map(&:to_i)}.must_equal [[nil, 17, 27], [1, 10, 16], [2, 7, 11]]
+    @ds.group_by(:a, :b).group_rollup.select_map([:a, :b, Sequel.function(:sum, :c).cast(Integer).as(:c)]).sort_by{|x| x.map(&:to_i)}.must_equal [[nil, nil, 27], [1, nil, 16], [1, 3, 11], [1, 4, 5], [2, nil, 11], [2, 3, 5], [2, 4, 6]]
   end if DB.dataset.supports_group_rollup?
 
   it "#group_cube should include all combinations of groupings" do
-    @ds.group_by(:a).group_cube.select_map([:a, Sequel.function(:sum, :b).cast(Integer).as(:b), Sequel.function(:sum, :c).cast(Integer).as(:c)]).sort_by{|x| x.inspect}.must_equal [[1, 10, 16], [2, 7, 11], [nil, 17, 27]]
-    @ds.group_by(:a, :b).group_cube.select_map([:a, :b, Sequel.function(:sum, :c).cast(Integer).as(:c)]).sort_by{|x| x.inspect}.must_equal [[1, 3, 11], [1, 4, 5], [1, nil, 16], [2, 3, 5], [2, 4, 6], [2, nil, 11], [nil, 3, 16], [nil, 4, 11], [nil, nil, 27]]
+    @ds.group_by(:a).group_cube.select_map([:a, Sequel.function(:sum, :b).cast(Integer).as(:b), Sequel.function(:sum, :c).cast(Integer).as(:c)]).sort_by{|x| x.map(&:to_i)}.must_equal [[nil, 17, 27], [1, 10, 16], [2, 7, 11]]
+    @ds.group_by(:a, :b).group_cube.select_map([:a, :b, Sequel.function(:sum, :c).cast(Integer).as(:c)]).sort_by{|x| x.map(&:to_i)}.must_equal [[nil, nil, 27], [nil, 3, 16], [nil, 4, 11], [1, nil, 16], [1, 3, 11], [1, 4, 5], [2, nil, 11], [2, 3, 5], [2, 4, 6]]
   end if DB.dataset.supports_group_cube?
+
+  it "#grouping_sets should include sets specified in group" do
+    @ds.group_by(:a, []).grouping_sets.select_map([:a, Sequel.function(:sum, :b).cast(Integer).as(:b), Sequel.function(:sum, :c).cast(Integer).as(:c)]).sort_by{|x| x.map(&:to_i)}.must_equal [[nil, 17, 27], [1, 10, 16], [2, 7, 11]]
+    @ds.group_by([:a, :b], :a, :b, []).grouping_sets.select_map([:a, :b, Sequel.function(:sum, :c).cast(Integer).as(:c)]).sort_by{|x| x.map(&:to_i)}.must_equal [[nil, nil, 27], [nil, 3, 16], [nil, 4, 11], [1, nil, 16], [1, 3, 11], [1, 4, 5], [2, nil, 11], [2, 3, 5], [2, 4, 6]]
+  end if DB.dataset.supports_grouping_sets?
 end
 
 describe "Sequel::Dataset convenience methods" do

data/spec/integration/plugin_test.rb

@@ -1971,6 +1971,7 @@ describe "Sequel::Plugins::ConstraintValidations" do
   before(:all) do
     @db = DB
     @db.extension(:constraint_validations)
+    @db.drop_table?(:sequel_constraint_validations)
     @db.create_constraint_validations_table
     @ds = @db[:cv_test]
     @regexp = regexp = @db.dataset.supports_regexp?

data/spec/model/base_spec.rb

@@ -91,6 +91,13 @@ describe Sequel::Model, "dataset" do
   it "should raise if no dataset is explicitly set and the class is anonymous" do
     proc {@b.dataset}.must_raise(Sequel::Error)
   end
+  
+  it "should not override dataset explicitly set when subclassing" do
+    sc = Class.new(::Elephant) do
+      set_dataset :foo
+    end
+    sc.table_name.must_equal :foo
+  end
 end
   
 describe Sequel::Model, "implicit table names" do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sequel
 version: !ruby/object:Gem::Version
-  version: 4.25.0
+  version: 4.26.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-01 00:00:00.000000000 Z
+date: 2015-09-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -226,6 +226,7 @@ extra_rdoc_files:
 - doc/release_notes/4.23.0.txt
 - doc/release_notes/4.24.0.txt
 - doc/release_notes/4.25.0.txt
+- doc/release_notes/4.26.0.txt
 files:
 - CHANGELOG
 - MIT-LICENSE
@@ -339,6 +340,7 @@ files:
 - doc/release_notes/4.23.0.txt
 - doc/release_notes/4.24.0.txt
 - doc/release_notes/4.25.0.txt
+- doc/release_notes/4.26.0.txt
 - doc/release_notes/4.3.0.txt
 - doc/release_notes/4.4.0.txt
 - doc/release_notes/4.5.0.txt
@@ -847,7 +849,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
 summary: The Database Toolkit for Ruby