sequel 5.10.0 → 5.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 629d77185f762e5399741ae9b1caf03c8cd2bbe5f72fd9487900dc0c4bfc2e7a
-  data.tar.gz: ee46b9c3180a67eb356b1f2ae7b274cc293687b333bf216b76a3e55def081c57
+  metadata.gz: 935bcf2280ce67a62dfd6e705308c85324f9d82303f5144ccbede8883d0956e5
+  data.tar.gz: 91dc87ca6afcaa82372233829919bab98227e2f7a7555bc0229811cfc829b482
 SHA512:
-  metadata.gz: 2b5a5c9ed14dcd9bc6c98286bb4c22637052bb2f152f352d5002b096e2d361e2ac6ec15dcd44881e3e96e37b6acd8896161ad94cac4b674d55a6f54a9d43a948
-  data.tar.gz: 847891aeebf175eca649d58461c38d3127311594bb3906bb73429726230b57dd1555ffbd760e3d5f7b30bb9907d5c6d461af1ac0d3b8e166b8dcbf61787fea97
+  metadata.gz: f0540143323390f812a543e8a28fa2ec3184faad7ad5508e9d64cf49bf6642f09dd636f0356d8bd2a4ad632a21e5a4358eda096d86b08ddaae0f62cdf8bfc9fa
+  data.tar.gz: f85a4c4880b34f737b00affaab544473e02d70052e70ddc438597455974b411a65093f2aa511af84558a15121f3032192df191677bc7ea4b1c0b779cda1714ae

data/CHANGELOG

@@ -1,3 +1,23 @@
+=== 5.11.0 (2018-08-01)
+
+* Fix using the jdbc/sqlserver adapter on JRuby 9.2+ (jeremyevans)
+
+* Fix dumping schema for numeric/decimal columns with default values, broken starting in 5.9.0 (jeremyevans)
+
+* Recognize additional check constraint violations on certain versions of SQLite (jeremyevans)
+
+* Use cached model instances for Model.first calls without an argument or with a single integer argument in the static_cache plugin (AlexWayfer) (#1529)
+
+* Support ON CONFLICT clause for INSERT on SQLite 3.24+ (jeremyevans)
+
+* Support Dataset#window for WINDOW clause on MySQL 8 and SQLAnywhere (jeremyevans)
+
+* Enable window function support on SQLAnywhere (jeremyevans)
+
+* Support using a hash as a window function :frame option value, with support for ROWS/RANGE/GROUPS, numeric offsets, and EXCLUDE (jeremyevans)
+
+* Allow using set_column_default with a nil value to remove the default value for a column on MySQL when the column is NOT NULL (jeremyevans)
+
 === 5.10.0 (2018-07-01)
 
 * Use input type casts when using the postgres adapter with pg 0.18+ to reduce string allocations for some primitive types used as prepared statement arguments (jeremyevans)

data/doc/release_notes/5.11.0.txt

@@ -0,0 +1,83 @@
+= New Features
+
+* Sequel now supports more window frame specification types when
+  using window functions.  You can now provide the window frame
+  specification as a hash, and Sequel will format the correct
+  SQL.  Specifically, this adds support for RANGE and GROUPS,
+  numeric offsets, and EXCLUDE on a database that supports it
+  (e.g. PostgreSQL 11+).  Examples:
+
+    DB[:albums].select{function(c1).over(:partition=>c2, :order=>:c3,
+      :frame=>{:type=>:range, :start=>1, :end=>1})}
+    # SELECT function(c1) OVER (PARTITION BY c2 ORDER BY c3
+    # RANGE BETWEEN 1 PRECEDING AND 1 FOLLOWING) FROM albums
+
+    DB[:albums].select{function(c1).over(:partition=>c2, :order=>:c3,
+      :frame=>{:type=>:groups, :start=>[2, :preceding], :end=>[1, :preceding]})}
+    # SELECT function(c1) OVER (PARTITION BY c2 ORDER BY c3
+    # GROUPS BETWEEN 2 PRECEDING AND 1 PRECEDING) FROM albums
+
+    DB[:albums].select{function(c1).over(:partition=>c2, :order=>:c3,
+      :frame=>{:type=>:range, :start=>:preceding, :exclude=>:current})}
+    # SELECT function(c1) OVER (PARTITION BY c2 ORDER BY c3
+    # RANGE UNBOUNDED PRECEDING EXCLUDE CURRENT ROW) FROM albums
+
+* The SQLite 3.24+ ON CONFLICT clause to INSERT is now supported.
+  This support is very similar to the PostgreSQL support for the
+  same feature, also known as  UPSERT (UPDATE if the row already
+  exists, INSERT if it does not).  This support is different than
+  the previous support for INSERT ON CONFLICT REPLACE (also known as
+  INSERT OR REPLACE), but it uses the same method name in order to
+  be compatible with the PostgreSQL support.  The new syntax requires
+  passing a hash to Dataset#insert_conflict.  Examples:
+
+    DB[:table].insert_conflict({}).insert(a: 1, b: 2)
+    # INSERT INTO TABLE (a, b) VALUES (1, 2)
+    # ON CONFLICT DO NOTHING
+ 
+    DB[:table].insert_conflict(target: :a).insert(a: 1, b: 2)
+    # INSERT INTO TABLE (a, b) VALUES (1, 2)
+    # ON CONFLICT (a) DO NOTHING
+ 
+    DB[:table].insert_conflict(target: :a,
+      conflict_where: {c: true}).insert(a: 1, b: 2)
+    # INSERT INTO TABLE (a, b) VALUES (1, 2)
+    # ON CONFLICT (a) WHERE (c IS TRUE) DO NOTHING
+ 
+    DB[:table].insert_conflict(target: :a,
+      update: {b: Sequel[:excluded][:b]}).insert(a: 1, b: 2)
+    # INSERT INTO TABLE (a, b) VALUES (1, 2)
+    # ON CONFLICT (a) DO UPDATE SET b = excluded.b
+ 
+    DB[:table].insert_conflict(target: :a,
+      update: {b: Sequel[:excluded][:b]},
+      update_where: {Sequel[:table][:status_id] => 1}).insert(a: 1, b: 2)
+    # INSERT INTO TABLE (a, b) VALUES (1, 2) ON CONFLICT (a)
+    # DO UPDATE SET b = excluded.b WHERE (table.status_id = 1)
+
+* Dataset#window for the WINDOW clause has been moved from the
+  PostgreSQL-specific support to core, and has been enabled on
+  MySQL 8+ and SQLAnywhere.  This allows you to specify a shared
+  window specification in a query, which can be used by multiple
+  window functions.
+
+= Other Improvements
+
+* When using the static_cache plugin, Model.first when called without
+  a block and without arguments or with a single Integer argument now
+  uses the cached values instead of issuing a query.
+
+* Using set_column_default with a nil value now correctly removes an
+  existing default value on MySQL when the column is NOT NULL.
+
+* Window function support has been enabled on SQLAnywhere, since it
+  works correctly.
+
+* Dumping schema for numeric/decimal columns with default values
+  now works correctly.  This was broken starting in Sequel 5.9.0
+  due to changes to use BigDecimal() instead of BigDecimal.new().
+
+* The jdbc/sqlserver adapter now works correctly on JRuby 9.2+.
+
+* An additional check constraint violation failure message is now
+  recognized on SQLite.

data/doc/security.rdoc

@@ -173,6 +173,16 @@ user input for function names.
 
   DB[:table].select(Sequel.function(params[:id])) # SQL injection!
 
+==== SQL Window Frames
+
+For backwards compatibility, Sequel supports regular strings in the
+window function :frame option, which will be treated as a literal string:
+
+  DB[:table].select{fun(arg).over(:frame=>'SQL Here')}
+
+You should make sure the frame argument is not derived from user input,
+or switch to using a hash as the :frame option value.
+
 ==== auto_literal_strings extension
 
 If the auto_literal_strings extension is used for backwards compatibility,

data/doc/sql.rdoc

@@ -229,6 +229,18 @@ If the database supports window functions, Sequel can handle them by calling the
   DB[:albums].select{function(c1, c2).over(:partition=>[c3, c4], :order=>[c5, c6.desc])}
   # SELECT function(c1, c2) OVER (PARTITION BY c3, c4 ORDER BY c5, c6 DESC) FROM albums
 
+  DB[:albums].select{function(c1).over(:partition=>c2, :order=>:c3, :frame=>:rows)}
+  # SELECT function(c1) OVER (PARTITION BY c2 ORDER BY c3 ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM albums
+
+  DB[:albums].select{function(c1).over(:partition=>c2, :order=>:c3, :frame=>{:type=>:range, :start=>1, :end=>1})}
+  # SELECT function(c1) OVER (PARTITION BY c2 ORDER BY c3 RANGE BETWEEN 1 PRECEDING AND 1 FOLLOWING) FROM albums
+
+  DB[:albums].select{function(c1).over(:partition=>c2, :order=>:c3, :frame=>{:type=>:groups, :start=>[2, :preceding], :end=>[1, :preceding]})}
+  # SELECT function(c1) OVER (PARTITION BY c2 ORDER BY c3 GROUPS BETWEEN 2 PRECEDING AND 1 PRECEDING) FROM albums
+
+  DB[:albums].select{function(c1).over(:partition=>c2, :order=>:c3, :frame=>{:type=>:range, :start=>:preceding, :exclude=>:current})}
+  # SELECT function(c1) OVER (PARTITION BY c2 ORDER BY c3 RANGE UNBOUNDED PRECEDING EXCLUDE CURRENT ROW) FROM albums
+
 === Schema Qualified Functions
 
 If the database supports schema qualified functions, Sequel can handle them by calling the +function+ method on a qualified identifier:

data/lib/sequel/adapters/jdbc/sqlserver.rb

@@ -75,7 +75,7 @@ module Sequel
         private
 
         def _metadata_dataset
-          super.extend(MetadataDatasetMethods)
+          super.with_extend(MetadataDatasetMethods)
         end
 
         def disconnect_error?(exception, opts)

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

@@ -232,7 +232,18 @@ module Sequel
       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_set_column_default_sql(table, op)
+        return super unless op[:default].nil?
+
+        opts = schema(table).find{|x| x[0] == op[:name]}
+
+        if opts && opts[1][:allow_null] == false
+          "ALTER COLUMN #{quote_identifier(op[:name])} DROP DEFAULT"
+        else
+          super
+        end
+      end
 
       def alter_table_add_constraint_sql(table, op)
         if op[:type] == :foreign_key
@@ -591,7 +602,7 @@ module Sequel
 
       Dataset.def_sql_method(self, :delete, %w'with delete from where order limit')
       Dataset.def_sql_method(self, :insert, %w'insert ignore into columns values on_duplicate_key_update')
-      Dataset.def_sql_method(self, :select, %w'with select distinct calc_found_rows columns from join where group having compounds order limit lock')
+      Dataset.def_sql_method(self, :select, %w'with select distinct calc_found_rows columns from join where group having window compounds order limit lock')
       Dataset.def_sql_method(self, :update, %w'with update ignore table set where order limit')
 
       include Sequel::Dataset::Replace
@@ -835,6 +846,11 @@ module Sequel
         db.supports_timestamp_usecs?
       end
 
+      # MySQL 8+ supports WINDOW clause.
+      def supports_window_clause?
+        !db.mariadb? && db.server_version >= 80000
+      end
+
       # MariaDB 10.2+ and MySQL 8+ support window functions
       def supports_window_functions?
         db.server_version >= (db.mariadb? ? 100200 : 80000)

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

@@ -1673,11 +1673,29 @@ module Sequel
         true
       end
 
+      # PostgreSQL 8.4+ supports WINDOW clause.
+      def supports_window_clause?
+        server_version >= 80400
+      end
+
       # PostgreSQL 8.4+ supports window functions
       def supports_window_functions?
         server_version >= 80400
       end
 
+      # Base support added in 8.4, offset supported added in 9.0,
+      # GROUPS and EXCLUDE support added in 11.0.
+      def supports_window_function_frame_option?(option)
+        case option
+        when :rows, :range
+          true
+        when :offset
+          server_version >= 90000
+        when :groups, :exclude
+          server_version >= 110000
+        end
+      end
+    
       # Truncates the dataset.  Returns nil.
       #
       # Options:
@@ -1702,13 +1720,6 @@ module Sequel
         end
       end
 
-      # Return a clone of the dataset with an addition named window that can be
-      # referenced in window functions. See Sequel::SQL::Window for a list of
-      # options that can be passed in.
-      def window(name, opts)
-        clone(:window=>(@opts[:window]||[]) + [[name, SQL::Window.new(opts)]])
-      end
-
       protected
 
       # If returned primary keys are requested, use RETURNING unless already set on the
@@ -1900,23 +1911,6 @@ module Sequel
         expression_list_append(sql, opts[:values])
       end
 
-      # SQL fragment for named window specifications
-      def select_window_sql(sql)
-        if ws = @opts[:window]
-          sql << " WINDOW "
-          c = false
-          co = ', '
-          as = ' AS '
-          ws.map do |name, window|
-            sql << co if c
-            literal_append(sql, name)
-            sql << as
-            literal_append(sql, window)
-            c ||= true
-          end
-        end
-      end
-
       # Use WITH RECURSIVE instead of WITH if any of the CTEs is recursive
       def select_with_sql_base
         opts[:with].any?{|w| w[:recursive]} ? "WITH RECURSIVE " : super

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

@@ -233,7 +233,7 @@ module Sequel
 
     module DatasetMethods
       Dataset.def_sql_method(self, :insert, %w'insert into columns values')
-      Dataset.def_sql_method(self, :select, %w'with select distinct limit columns into from join where group having compounds order lock')
+      Dataset.def_sql_method(self, :select, %w'with select distinct limit columns into from join where group having window compounds order lock')
 
       # Whether to convert smallint to boolean arguments for this dataset.
       # Defaults to the IBMDB module setting.
@@ -275,6 +275,14 @@ module Sequel
         false
       end
 
+      def supports_window_clause?
+        true
+      end
+
+      def supports_window_functions?
+        true
+      end
+
       # Uses CROSS APPLY to join the given table into the current dataset.
       def cross_apply(table)
         join_table(:cross_apply, table)

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

@@ -299,7 +299,7 @@ module Sequel
       DATABASE_ERROR_REGEXPS = {
         /(is|are) not unique\z|PRIMARY KEY must be unique\z|UNIQUE constraint failed: .+\z/ => UniqueConstraintViolation,
         /foreign key constraint failed\z/i => ForeignKeyConstraintViolation,
-        /\ACHECK constraint failed/ => CheckConstraintViolation,
+        /\A(SQLITE ERROR 275 \(CONSTRAINT_CHECK\) : )?CHECK constraint failed/ => CheckConstraintViolation,
         /\A(SQLITE ERROR 19 \(CONSTRAINT\) : )?constraint failed\z/ => ConstraintViolation,
         /may not be NULL\z|NOT NULL constraint failed: .+\z/ => NotNullConstraintViolation,
         /\ASQLITE ERROR \d+ \(\) : CHECK constraint failed: / => CheckConstraintViolation
@@ -500,7 +500,7 @@ module Sequel
       EXTRACT_MAP.each_value(&:freeze)
 
       Dataset.def_sql_method(self, :delete, [['if db.sqlite_version >= 30803', %w'with delete from where'], ["else", %w'delete from where']])
-      Dataset.def_sql_method(self, :insert, [['if db.sqlite_version >= 30803', %w'with insert conflict into columns values'], ["else", %w'insert conflict into columns values']])
+      Dataset.def_sql_method(self, :insert, [['if db.sqlite_version >= 30803', %w'with insert conflict into columns values on_conflict'], ["else", %w'insert conflict into columns values']])
       Dataset.def_sql_method(self, :select, [['if opts[:values]', %w'with values compounds'], ['else', %w'with select distinct columns from join where group having compounds order limit lock']])
       Dataset.def_sql_method(self, :update, [['if db.sqlite_version >= 30803', %w'with update table set where'], ["else", %w'update table set where']])
 
@@ -620,6 +620,14 @@ module Sequel
       # supports the following conflict resolution algoriths: ROLLBACK, ABORT,
       # FAIL, IGNORE and REPLACE.
       #
+      # On SQLite 3.24.0+, you can pass a hash to use an ON CONFLICT clause.
+      # With out :update option, uses ON CONFLICT DO NOTHING.  Options:
+      #
+      # :conflict_where :: The index filter, when using a partial index to determine uniqueness.
+      # :target :: The column name or expression to handle uniqueness violations on.
+      # :update :: A hash of columns and values to set.  Uses ON CONFLICT DO UPDATE.
+      # :update_where :: A WHERE condition to use for the update.
+      #
       # Examples:
       #
       #   DB[:table].insert_conflict.insert(a: 1, b: 2)
@@ -627,11 +635,39 @@ module Sequel
       #
       #   DB[:table].insert_conflict(:replace).insert(a: 1, b: 2)
       #   # INSERT OR REPLACE INTO TABLE (a, b) VALUES (1, 2)
-      def insert_conflict(resolution = :ignore)
-        unless INSERT_CONFLICT_RESOLUTIONS.include?(resolution.to_s.upcase)
-          raise Error, "Invalid value passed to Dataset#insert_conflict: #{resolution.inspect}.  The allowed values are: :rollback, :abort, :fail, :ignore, or :replace"
+      #
+      #   DB[:table].insert_conflict({}).insert(a: 1, b: 2)
+      #   # INSERT INTO TABLE (a, b) VALUES (1, 2)
+      #   # ON CONFLICT DO NOTHING
+      #   
+      #   DB[:table].insert_conflict(target: :a).insert(a: 1, b: 2)
+      #   # INSERT INTO TABLE (a, b) VALUES (1, 2)
+      #   # ON CONFLICT (a) DO NOTHING
+      #
+      #   DB[:table].insert_conflict(target: :a, conflict_where: {c: true}).insert(a: 1, b: 2)
+      #   # INSERT INTO TABLE (a, b) VALUES (1, 2)
+      #   # ON CONFLICT (a) WHERE (c IS TRUE) DO NOTHING
+      #   
+      #   DB[:table].insert_conflict(target: :a, update: {b: Sequel[:excluded][:b]}).insert(a: 1, b: 2)
+      #   # INSERT INTO TABLE (a, b) VALUES (1, 2)
+      #   # ON CONFLICT (a) DO UPDATE SET b = excluded.b
+      #   
+      #   DB[:table].insert_conflict(target: :a,
+      #     update: {b: Sequel[:excluded][:b]}, update_where: {Sequel[:table][:status_id] => 1}).insert(a: 1, b: 2)
+      #   # INSERT INTO TABLE (a, b) VALUES (1, 2)
+      #   # ON CONFLICT (a) DO UPDATE SET b = excluded.b WHERE (table.status_id = 1)
+      def insert_conflict(opts = :ignore)
+        case opts
+        when Symbol, String
+          unless INSERT_CONFLICT_RESOLUTIONS.include?(opts.to_s.upcase)
+            raise Error, "Invalid symbol or string passed to Dataset#insert_conflict: #{opts.inspect}.  The allowed values are: :rollback, :abort, :fail, :ignore, or :replace"
+          end
+          clone(:insert_conflict => opts)
+        when Hash
+          clone(:insert_on_conflict => opts)
+        else
+          raise Error, "Invalid value passed to Dataset#insert_conflict: #{opts.inspect}, should use a symbol or a hash"
         end
-        clone(:insert_conflict => resolution)
       end
 
       # Ignore uniqueness/exclusion violations when inserting, using INSERT OR IGNORE.
@@ -729,6 +765,36 @@ module Sequel
         end
       end
 
+      # Add ON CONFLICT clause if it should be used
+      def insert_on_conflict_sql(sql)
+        if opts = @opts[:insert_on_conflict]
+          sql << " ON CONFLICT"
+
+          if target = opts[:constraint] 
+            sql << " ON CONSTRAINT "
+            identifier_append(sql, target)
+          elsif target = opts[:target]
+            sql << ' '
+            identifier_append(sql, Array(target))
+            if conflict_where = opts[:conflict_where]
+              sql << " WHERE "
+              literal_append(sql, conflict_where)
+            end
+          end
+
+          if values = opts[:update]
+            sql << " DO UPDATE SET "
+            update_sql_values_hash(sql, values)
+            if update_where = opts[:update_where]
+              sql << " WHERE "
+              literal_append(sql, update_where)
+            end
+          else
+            sql << " DO NOTHING"
+          end
+        end
+      end
+
       # SQLite uses a preceding X for hex escaping strings
       def literal_blob_append(sql, v)
         sql <<  "X'" << v.unpack("H*").first << "'"

data/lib/sequel/dataset/features.rb

@@ -178,11 +178,29 @@ module Sequel
       true
     end
     
+    # Whether the dataset supports the WINDOW clause to define windows used by multiple
+    # window functions, false by default.
+    def supports_window_clause?
+      false
+    end
+
     # Whether the dataset supports window functions, false by default.
     def supports_window_functions?
       false
     end
     
+    # Whether the dataset supports the given window function option.  True by default.
+    # This should only be called if supports_window_functions? is true. Possible options
+    # are :rows, :range, :groups, :offset, :exclude.
+    def supports_window_function_frame_option?(option)
+      case option
+      when :rows, :range, :offset
+        true
+      else
+        false
+      end
+    end
+    
     # Whether the dataset supports WHERE TRUE (or WHERE 1 for databases that
     # that use 1 for true), true by default.
     def supports_where_true?

data/lib/sequel/dataset/query.rb

@@ -82,6 +82,8 @@ module Sequel
       # columns are deleted.  This method should generally not be called
       # directly by user code.
       def clone(opts = (return self; nil))
+        # return self used above because clone is called by almost all
+        # other query methods, and it is the fastest approach
         c = super(:freeze=>false)
         c.opts.merge!(opts)
         unless opts.each_key{|o| break if COLUMN_CHANGE_OPTS.include?(o)}
@@ -1044,6 +1046,16 @@ module Sequel
       add_filter(:where, cond, &block)
     end
     
+    # Return a clone of the dataset with an addition named window that can be
+    # referenced in window functions. See Sequel::SQL::Window for a list of
+    # options that can be passed in. Example:
+    #
+    #   DB[:items].window(:w, :partition=>:c1, :order=>:c2)
+    #   # SELECT * FROM items WINDOW w AS (PARTITION BY c1 ORDER BY c2)
+    def window(name, opts)
+      clone(:window=>((@opts[:window]||EMPTY_ARRAY) + [[name, SQL::Window.new(opts)].freeze]).freeze)
+    end
+
     # Add a common table expression (CTE) with the given name and a dataset that defines the CTE.
     # A common table expression acts as an inline view for the query.
     # Options:

data/lib/sequel/dataset/sql.rb

@@ -718,41 +718,86 @@ module Sequel
     # Append literalization of windows (for window functions) to SQL string.
     def window_sql_append(sql, opts)
       raise(Error, 'This dataset does not support window functions') unless supports_window_functions?
-      sql << '('
-      window, part, order, frame = opts.values_at(:window, :partition, :order, :frame)
       space = false
       space_s = ' '
-      if window
+
+      sql << '('
+
+      if window = opts[:window]
         literal_append(sql, window)
         space = true
       end
-      if part
+
+      if part = opts[:partition]
         sql << space_s if space
         sql << "PARTITION BY "
         expression_list_append(sql, Array(part))
         space = true
       end
-      if order
+
+      if order = opts[:order]
         sql << space_s if space
         sql << "ORDER BY "
         expression_list_append(sql, Array(order))
         space = true
       end
-      case frame
-        when nil
-          # nothing
-        when :all
-          sql << space_s if space
-          sql << "ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING"
-        when :rows
-          sql << space_s if space
-          sql << "ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW"
-        when String
-          sql << space_s if space
+
+      if frame = opts[:frame]
+        sql << space_s if space
+
+        if frame.is_a?(String)
           sql << frame
         else
-          raise Error, "invalid window frame clause, should be :all, :rows, a string, or nil"
+          case frame
+          when :all
+            frame_type = :rows
+            frame_start = :preceding
+            frame_end = :following
+          when :rows, :range, :groups
+            frame_type = frame
+            frame_start = :preceding
+            frame_end = :current
+          when Hash
+            frame_type = frame[:type]
+            unless frame_type == :rows || frame_type == :range || frame_type == :groups
+              raise Error, "invalid window :frame :type option: #{frame_type.inspect}"
+            end
+            unless frame_start = frame[:start]
+              raise Error, "invalid window :frame :start option: #{frame_start.inspect}"
+            end
+            frame_end = frame[:end]
+            frame_exclude = frame[:exclude]
+          else
+            raise Error, "invalid window :frame option: #{frame.inspect}"
+          end
+
+          sql << frame_type.to_s.upcase << " "
+          sql << 'BETWEEN ' if frame_end
+          window_frame_boundary_sql_append(sql, frame_start, :preceding)
+          if frame_end
+            sql << " AND "
+            window_frame_boundary_sql_append(sql, frame_end, :following)
+          end
+
+          if frame_exclude
+            sql << " EXCLUDE "
+
+            case frame_exclude
+            when :current
+              sql << "CURRENT ROW"
+            when :group
+              sql << "GROUP"
+            when :ties
+              sql << "TIES"
+            when :no_others
+              sql << "NO OTHERS"
+            else
+              raise Error, "invalid window :frame :exclude option: #{frame_exclude.inspect}"
+            end
+          end
+        end
       end
+
       sql << ')'
     end
 
@@ -1412,6 +1457,22 @@ module Sequel
     alias delete_where_sql select_where_sql
     alias update_where_sql select_where_sql
     
+    def select_window_sql(sql)
+      if ws = @opts[:window]
+        sql << " WINDOW "
+        c = false
+        co = ', '
+        as = ' AS '
+        ws.map do |name, window|
+          sql << co if c
+          literal_append(sql, name)
+          sql << as
+          literal_append(sql, window)
+          c ||= true
+        end
+      end
+    end
+
     def select_with_sql(sql)
       return unless supports_cte?
       ws = opts[:with]
@@ -1535,5 +1596,35 @@ module Sequel
     def update_update_sql(sql)
       sql << 'UPDATE'
     end
+
+    def window_frame_boundary_sql_append(sql, boundary, direction)
+      case boundary
+      when :current
+       sql << "CURRENT ROW"
+      when :preceding
+        sql << "UNBOUNDED PRECEDING"
+      when :following
+        sql << "UNBOUNDED FOLLOWING"
+      else
+        if boundary.is_a?(Array)
+          offset, direction = boundary
+          unless boundary.length == 2 && (direction == :preceding || direction == :following)
+            raise Error, "invalid window :frame boundary (:start or :end) option: #{boundary.inspect}"
+          end
+        else
+          offset = boundary
+        end
+
+        case offset
+        when Numeric, String, SQL::Cast
+          # nothing
+        else
+          raise Error, "invalid window :frame boundary (:start or :end) option: #{boundary.inspect}"
+        end
+
+        literal_append(sql, offset)
+        sql << (direction == :preceding ? " PRECEDING" : " FOLLOWING")
+      end
+    end
   end
 end

data/lib/sequel/extensions/eval_inspect.rb

@@ -27,7 +27,7 @@ module Sequel
     def eval_inspect(obj)
       case obj
       when BigDecimal
-        "BigDecimal(#{obj.to_s.inspect})"
+        "Kernel::BigDecimal(#{obj.to_s.inspect})"
       when Sequel::SQL::Blob, Sequel::LiteralString
         "#{obj.class}.new(#{obj.to_s.inspect})"
       when Sequel::SQL::ValueList

data/lib/sequel/plugins/list.rb

@@ -124,8 +124,10 @@ module Sequel
           move_to(position_value + n)
         end
 
-        # Move this instance to the given place in the list.  Raises an
-        # exception if target is less than 1 or greater than the last position in the list.
+        # Move this instance to the given place in the list.  If lp is not
+        # given or greater than the last list position, uses the last list
+        # position.  If lp is less than the top list position, uses the
+        # top list position.
         def move_to(target, lp = nil)
           current = position_value
           if target != current

data/lib/sequel/plugins/static_cache.rb

@@ -24,6 +24,7 @@ module Sequel
     # * Primary key lookups (e.g. Model[1])
     # * Model.all
     # * Model.each
+    # * Model.first (without block, only supporting no arguments or single integer argument)
     # * Model.count (without an argument or block)
     # * Model.map
     # * Model.as_hash
@@ -80,6 +81,20 @@ module Sequel
           end
         end
 
+        # If a block is given, multiple arguments are given, or a single
+        # non-Integer argument is given, performs the default behavior of
+        # issuing a database query.  Otherwise, uses the cached values
+        # to return either the first cached instance (no arguments) or an
+        # array containing the number of instances specified (single integer
+        # argument).
+        def first(*args)
+          if block_given? || args.length > 1 || (args.length == 1 && !args[0].is_a?(Integer))
+            super
+          else
+            @all.first(*args)
+          end
+        end
+
         # Get the number of records in the cache, without issuing a database query.
         def count(*a, &block)
           if a.empty? && !block

data/lib/sequel/sql.rb

@@ -1903,16 +1903,40 @@ module Sequel
     #   # (PARTITION BY col7 ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING)
     #   Sequel::SQL::Window.new(partition: :col7, frame: :rows)
     #   # (PARTITION BY col7 ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
-    #   Sequel::SQL::Window.new(partition: :col7, frame: "RANGE CURRENT ROW")
+    #   Sequel::SQL::Window.new(partition: :col7, frame: {type: :range, start: current})
     #   # (PARTITION BY col7 RANGE CURRENT ROW)
+    #   Sequel::SQL::Window.new(partition: :col7, frame: {type: :range, start: 1, end: 1})
+    #   # (PARTITION BY col7 RANGE BETWEEN 1 PRECEDING AND 1 FOLLOWING)
+    #   Sequel::SQL::Window.new(partition: :col7, frame: {type: :range, start: 2, end: [1, :preceding]})
+    #   # (PARTITION BY col7 RANGE BETWEEN 2 PRECEDING AND 1 PRECEDING)
+    #   Sequel::SQL::Window.new(partition: :col7, frame: {type: :range, start: 1, end: [2, :following]})
+    #   # (PARTITION BY col7 RANGE BETWEEN 1 FOLLOWING AND 2 FOLLOWING)
+    #   Sequel::SQL::Window.new(partition: :col7, frame: {type: :range, start: :preceding, exclude: :current})
+    #   # (PARTITION BY col7 RANGE UNBOUNDED PRECEDING EXCLUDE CURRENT ROW)
     #
     #   Sequel::SQL::Window.new(window: :named_window) # you can create a named window with Dataset#window
     #   # (named_window)
     class Window < Expression
       # The options for this window.  Options currently supported:
-      # :frame :: if specified, should be :all, :rows, or a String that is used literally. :all always operates over all rows in the
-      #           partition, while :rows excludes the current row's later peers.  The default is to include
-      #           all previous rows in the partition up to the current row's last peer.
+      # :frame :: if specified, should be :all, :rows, :range, :groups, a String, or a Hash.
+      #           :all :: Always operates over all rows in the partition
+      #           :rows :: Includes rows in the partition up to and including the current row
+      #           :range, :groups :: Includes rows in the partition up to and including the current group
+      #           String :: Used as literal SQL code, try to avoid
+      #           Hash :: Hash of options for the frame:
+      #                   :type :: The type of frame, must be :rows, :range, or :groups (required)
+      #                   :start :: The start of the frame (required).  Possible values:
+      #                             :preceding :: UNBOUNDED PRECEDING
+      #                             :following :: UNBOUNDED FOLLOWING
+      #                             :current :: CURRENT ROW
+      #                             String, Numeric, or Cast :: Used as the offset of rows/values preceding
+      #                             Array :: Must have two elements, with first element being String, Numeric, or
+      #                                      Cast and second element being :preceding or :following
+      #                   :end :: The end of the frame.  Can be left out.  If present, takes the same values as
+      #                           :start, except that when a String, Numeric, or Hash, it is used as the offset
+      #                           for rows following
+      #                   :exclude :: Which rows to exclude.  Possible values are :current, :ties, :group
+      #                               :no_others.
       # :order :: order on the column(s) given
       # :partition :: partition/group on the column(s) given
       # :window :: base results on a previously specified named window

data/lib/sequel/version.rb

@@ -3,9 +3,11 @@
 module Sequel
   # The major version of Sequel.  Only bumped for major changes.
   MAJOR = 5
+
   # The minor version of Sequel.  Bumped for every non-patch level
   # release, generally around once a month.
-  MINOR = 10
+  MINOR = 11
+
   # 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

@@ -462,6 +462,12 @@ describe "A PostgreSQL database " do
     DB.drop_table?(:b, :a)
   end
 
+  it "should handle non-ASCII column aliases" do
+    s = String.new("\u00E4").force_encoding(DB.get('a').encoding)
+    k, v = DB.select(Sequel.as(s, s)).first.shift
+    k.to_s.must_equal v
+  end
+
   it "should parse foreign keys referencing current table using :reverse option" do
     DB.create_table!(:a) do
       primary_key :id
@@ -1665,36 +1671,6 @@ if DB.server_version >= 80300
   end
 end
 
-if DB.dataset.supports_window_functions?
-  describe "Postgres::Dataset named windows" do
-    before do
-      @db = DB
-      @db.create_table!(:i1){Integer :id; Integer :group_id; Integer :amount}
-      @ds = @db[:i1].order(:id)
-      @ds.insert(:id=>1, :group_id=>1, :amount=>1)
-      @ds.insert(:id=>2, :group_id=>1, :amount=>10)
-      @ds.insert(:id=>3, :group_id=>1, :amount=>100)
-      @ds.insert(:id=>4, :group_id=>2, :amount=>1000)
-      @ds.insert(:id=>5, :group_id=>2, :amount=>10000)
-      @ds.insert(:id=>6, :group_id=>2, :amount=>100000)
-    end
-    after do
-      @db.drop_table?(:i1)
-    end
-
-    it "should give correct results for window functions" do
-      @ds.window(:win, :partition=>:group_id, :order=>:id).select(:id){sum(:amount).over(:window=>win)}.all.
-        must_equal [{:sum=>1, :id=>1}, {:sum=>11, :id=>2}, {:sum=>111, :id=>3}, {:sum=>1000, :id=>4}, {:sum=>11000, :id=>5}, {:sum=>111000, :id=>6}]
-      @ds.window(:win, :partition=>:group_id).select(:id){sum(:amount).over(:window=>win, :order=>id)}.all.
-        must_equal [{:sum=>1, :id=>1}, {:sum=>11, :id=>2}, {:sum=>111, :id=>3}, {:sum=>1000, :id=>4}, {:sum=>11000, :id=>5}, {:sum=>111000, :id=>6}]
-      @ds.window(:win, {}).select(:id){sum(:amount).over(:window=>:win, :order=>id)}.all.
-        must_equal [{:sum=>1, :id=>1}, {:sum=>11, :id=>2}, {:sum=>111, :id=>3}, {:sum=>1111, :id=>4}, {:sum=>11111, :id=>5}, {:sum=>111111, :id=>6}]
-      @ds.window(:win, :partition=>:group_id).select(:id){sum(:amount).over(:window=>:win, :order=>id, :frame=>:all)}.all.
-        must_equal [{:sum=>111, :id=>1}, {:sum=>111, :id=>2}, {:sum=>111, :id=>3}, {:sum=>111000, :id=>4}, {:sum=>111000, :id=>5}, {:sum=>111000, :id=>6}]
-    end
-  end
-end
-
 describe "Postgres::Database functions, languages, schemas, and triggers" do
   before do
     @d = DB
@@ -3575,16 +3551,18 @@ describe 'PostgreSQL row-valued/composite types' do
     Sequel.extension :pg_array_ops, :pg_row_ops
     @ds = @db[:person]
 
-    @db.create_table!(:address) do
+    @db.drop_table?(:company, :person, :address)
+
+    @db.create_table(:address) do
       String :street
       String :city
       String :zip
     end
-    @db.create_table!(:person) do
+    @db.create_table(:person) do
       Integer :id
       address :address
     end
-    @db.create_table!(:company) do
+    @db.create_table(:company) do
       Integer :id
       column :employees, 'person[]'
     end

data/spec/adapters/sqlite_spec.rb

@@ -598,3 +598,55 @@ describe "A SQLite database" do
     @db.indexes(:test2).values.first[:columns].must_equal [:name]
   end if DB.sqlite_version >= 30808
 end
+
+describe "SQLite", 'INSERT ON CONFLICT' do
+  before(:all) do
+    @db = DB
+    @db.create_table!(:ic_test){Integer :a; Integer :b; Integer :c; TrueClass :c_is_unique, :default=>false; unique :a, :name=>:ic_test_a_uidx; unique [:b, :c], :name=>:ic_test_b_c_uidx; index [:c], :where=>:c_is_unique, :unique=>true}
+    @ds = @db[:ic_test]
+  end
+  before do
+    @ds.delete
+  end
+  after(:all) do
+    @db.drop_table?(:ic_test)
+  end
+
+  it "Dataset#insert_ignore and insert_conflict should ignore uniqueness violations" do
+    @ds.insert(1, 2, 3, false)
+    @ds.insert(10, 11, 3, true)
+    proc{@ds.insert(1, 3, 4, false)}.must_raise Sequel::UniqueConstraintViolation
+    proc{@ds.insert(11, 12, 3, true)}.must_raise Sequel::UniqueConstraintViolation
+    @ds.insert_ignore.insert(1, 3, 4, false)
+    @ds.insert_conflict.insert(1, 3, 4, false)
+    @ds.insert_conflict.insert(11, 12, 3, true)
+    @ds.insert_conflict(:target=>:a).insert(1, 3, 4, false)
+    @ds.insert_conflict(:target=>:c, :conflict_where=>:c_is_unique).insert(11, 12, 3, true)
+    @ds.all.must_equal [{:a=>1, :b=>2, :c=>3, :c_is_unique=>false}, {:a=>10, :b=>11, :c=>3, :c_is_unique=>true}]
+  end
+
+  it "Dataset#insert_ignore and insert_conflict should work with multi_insert/import" do
+    @ds.insert(1, 2, 3, false)
+    @ds.insert_ignore.multi_insert([{:a=>1, :b=>3, :c=>4}])
+    @ds.insert_ignore.import([:a, :b, :c], [[1, 3, 4]])
+    @ds.all.must_equal [{:a=>1, :b=>2, :c=>3, :c_is_unique=>false}]
+    @ds.insert_conflict(:target=>:a, :update=>{:b=>3}).import([:a, :b, :c], [[1, 3, 4]])
+    @ds.all.must_equal [{:a=>1, :b=>3, :c=>3, :c_is_unique=>false}]
+    @ds.insert_conflict(:target=>:a, :update=>{:b=>4}).multi_insert([{:a=>1, :b=>5, :c=>6}])
+    @ds.all.must_equal [{:a=>1, :b=>4, :c=>3, :c_is_unique=>false}]
+    end
+
+  it "Dataset#insert_conflict should handle upserts" do
+    @ds.insert(1, 2, 3, false)
+    @ds.insert_conflict(:target=>:a, :update=>{:b=>3}).insert(1, 3, 4, false)
+    @ds.all.must_equal [{:a=>1, :b=>3, :c=>3, :c_is_unique=>false}]
+    @ds.insert_conflict(:target=>[:b, :c], :update=>{:c=>5}).insert(5, 3, 3, false)
+    @ds.all.must_equal [{:a=>1, :b=>3, :c=>5, :c_is_unique=>false}]
+    @ds.insert_conflict(:target=>:a, :update=>{:b=>4}).insert(1, 3, nil, false)
+    @ds.all.must_equal [{:a=>1, :b=>4, :c=>5, :c_is_unique=>false}]
+    @ds.insert_conflict(:target=>:a, :update=>{:b=>5}, :update_where=>{Sequel[:ic_test][:b]=>4}).insert(1, 3, 4, false)
+    @ds.all.must_equal [{:a=>1, :b=>5, :c=>5, :c_is_unique=>false}]
+    @ds.insert_conflict(:target=>:a, :update=>{:b=>6}, :update_where=>{Sequel[:ic_test][:b]=>4}).insert(1, 3, 4, false)
+    @ds.all.must_equal [{:a=>1, :b=>5, :c=>5, :c_is_unique=>false}]
+  end
+end if DB.sqlite_version >= 32400

data/spec/core/dataset_spec.rb

@@ -4189,7 +4189,7 @@ describe "Sequel::Dataset#qualify" do
   end
 end
 
-describe "Sequel::Dataset #with and #with_recursive" do
+describe "Dataset#with and #with_recursive" do
   before do
     @db = Sequel.mock
     @ds = @db[:t].with_extend{def supports_cte?(*) true end}
@@ -4251,6 +4251,27 @@ describe "Sequel::Dataset #with and #with_recursive" do
   end
 end
 
+describe "Dataset#window" do
+  before do
+    @db = Sequel.mock
+    @ds = @db[:t].with_extend do
+      Sequel::Dataset.def_sql_method(self, :select, %w'select columns from window')
+      def supports_window_clause?; true end
+      def supports_window_functions?; true end
+    end
+  end
+  
+  it "should not support window clause by default" do
+    @db.dataset.supports_window_clause?.must_equal false
+  end
+
+  it "should take a name and hash of window options" do
+    ds = @ds.window(:w, :partition=>:a, :order=>:b)
+    ds.sql.must_equal 'SELECT * FROM t WINDOW w AS (PARTITION BY a ORDER BY b)'
+    ds.window(:w2, :partition=>:c, :order=>:d).sql.must_equal 'SELECT * FROM t WINDOW w AS (PARTITION BY a ORDER BY b), w2 AS (PARTITION BY c ORDER BY d)'
+  end
+end
+
 describe Sequel::SQL::Constants do
   before do
     @db = Sequel::Database.new

data/spec/core/expression_filters_spec.rb

@@ -583,18 +583,75 @@ describe Sequel::SQL::VirtualRow do
     @d.l{count.function.*.over}.must_equal 'count(*) OVER ()'
   end
 
-  it "should handle method.function.over(:frame=>:all) as a window function call" do
+  it "should handle method.function.over(:frame=>:all) as a window function call with frame for all rows" do
     @d.l{rank.function.over(:frame=>:all)}.must_equal 'rank() OVER (ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING)'
   end
 
-  it "should handle method.function.over(:frame=>:rows) as a window function call" do
+  it "should handle method.function.over(:frame=>:rows) as a window function call with frame for all rows before current row" do
     @d.l{rank.function.over(:frame=>:rows)}.must_equal 'rank() OVER (ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)'
   end
 
-  it "should handle method.function.over(:frame=>'some string') as a window function call" do
+  it "should handle method.function.over(:frame=>:groups) as a window function call with frame for all groups before current row" do
+    @d.l{rank.function.over(:frame=>:groups)}.must_equal 'rank() OVER (GROUPS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)'
+  end
+
+  it "should handle method.function.over(:frame=>:range) as a window function call with frame for all groups before current row" do
+    @d.l{rank.function.over(:frame=>:range)}.must_equal 'rank() OVER (RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)'
+  end
+
+  it "should handle window function with :frame hash argument with :type option" do
+    @d.l{rank.function.over(:frame=>{:type=>:rows, :start=>:preceding})}.must_equal 'rank() OVER (ROWS UNBOUNDED PRECEDING)'
+    @d.l{rank.function.over(:frame=>{:type=>:range, :start=>:preceding})}.must_equal 'rank() OVER (RANGE UNBOUNDED PRECEDING)'
+    @d.l{rank.function.over(:frame=>{:type=>:groups, :start=>:preceding})}.must_equal 'rank() OVER (GROUPS UNBOUNDED PRECEDING)'
+  end
+
+  it "should handle window function with :frame hash argument with :start option" do
+    @d.l{rank.function.over(:frame=>{:type=>:rows, :start=>:preceding})}.must_equal 'rank() OVER (ROWS UNBOUNDED PRECEDING)'
+    @d.l{rank.function.over(:frame=>{:type=>:rows, :start=>:following})}.must_equal 'rank() OVER (ROWS UNBOUNDED FOLLOWING)'
+    @d.l{rank.function.over(:frame=>{:type=>:rows, :start=>:current})}.must_equal 'rank() OVER (ROWS CURRENT ROW)'
+    @d.l{rank.function.over(:frame=>{:type=>:rows, :start=>1})}.must_equal 'rank() OVER (ROWS 1 PRECEDING)'
+    @d.l{rank.function.over(:frame=>{:type=>:rows, :start=>[1, :following]})}.must_equal 'rank() OVER (ROWS 1 FOLLOWING)'
+  end
+
+  it "should handle window function with :frame hash argument with :end option" do
+    @d.l{rank.function.over(:frame=>{:type=>:rows, :start=>:preceding, :end=>:preceding})}.must_equal 'rank() OVER (ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED PRECEDING)'
+    @d.l{rank.function.over(:frame=>{:type=>:rows, :start=>:preceding, :end=>:following})}.must_equal 'rank() OVER (ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING)'
+    @d.l{rank.function.over(:frame=>{:type=>:rows, :start=>:preceding, :end=>:current})}.must_equal 'rank() OVER (ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)'
+    @d.l{rank.function.over(:frame=>{:type=>:rows, :start=>:preceding, :end=>1})}.must_equal 'rank() OVER (ROWS BETWEEN UNBOUNDED PRECEDING AND 1 FOLLOWING)'
+    @d.l{rank.function.over(:frame=>{:type=>:rows, :start=>:preceding, :end=>[1, :preceding]})}.must_equal 'rank() OVER (ROWS BETWEEN UNBOUNDED PRECEDING AND 1 PRECEDING)'
+  end
+
+  it "should handle window function with :frame hash argument with :exclude option" do
+    @d.l{rank.function.over(:frame=>{:type=>:rows, :start=>:preceding,:exclude=>:current})}.must_equal 'rank() OVER (ROWS UNBOUNDED PRECEDING EXCLUDE CURRENT ROW)'
+    @d.l{rank.function.over(:frame=>{:type=>:rows, :start=>:preceding, :exclude=>:group})}.must_equal 'rank() OVER (ROWS UNBOUNDED PRECEDING EXCLUDE GROUP)'
+    @d.l{rank.function.over(:frame=>{:type=>:rows, :start=>:preceding, :exclude=>:ties})}.must_equal 'rank() OVER (ROWS UNBOUNDED PRECEDING EXCLUDE TIES)'
+    @d.l{rank.function.over(:frame=>{:type=>:rows, :start=>:preceding, :exclude=>:no_others})}.must_equal 'rank() OVER (ROWS UNBOUNDED PRECEDING EXCLUDE NO OTHERS)'
+  end
+
+  it "should handle window function with :frame hash argument with invalid options" do
+    proc{@d.l{rank.function.over(:frame=>{:type=>:blah, :start=>:preceding})}}.must_raise Sequel::Error
+    proc{@d.l{rank.function.over(:frame=>{:type=>:rows})}}.must_raise Sequel::Error
+    proc{@d.l{rank.function.over(:frame=>{:type=>:rows, :start=>:blah})}}.must_raise Sequel::Error
+    proc{@d.l{rank.function.over(:frame=>{:type=>:rows, :start=>[1, :blah]})}}.must_raise Sequel::Error
+    proc{@d.l{rank.function.over(:frame=>{:type=>:rows, :start=>[1, :preceding, 3]})}}.must_raise Sequel::Error
+    proc{@d.l{rank.function.over(:frame=>{:type=>:rows, :start=>:preceding, :end=>:blah})}}.must_raise Sequel::Error
+    proc{@d.l{rank.function.over(:frame=>{:type=>:rows, :start=>:preceding, :end=>[1, :blah]})}}.must_raise Sequel::Error
+    proc{@d.l{rank.function.over(:frame=>{:type=>:rows, :start=>:preceding, :end=>[1, :following, 3]})}}.must_raise Sequel::Error
+    proc{@d.l{rank.function.over(:frame=>{:type=>:rows, :start=>:preceding, :exclude=>:blah})}}.must_raise Sequel::Error
+  end
+
+  it "should handle method.function.over(:frame=>'some string') as a window function call with explicit frame" do
     @d.l{rank.function.over(:frame=>'RANGE BETWEEN 3 PRECEDING AND CURRENT ROW')}.must_equal 'rank() OVER (RANGE BETWEEN 3 PRECEDING AND CURRENT ROW)'
   end
 
+  it "should support window functions options" do
+    @d.supports_window_function_frame_option?(:rows).must_equal true
+    @d.supports_window_function_frame_option?(:range).must_equal true
+    @d.supports_window_function_frame_option?(:groups).must_equal false
+    @d.supports_window_function_frame_option?(:offset).must_equal true
+    @d.supports_window_function_frame_option?(:exclude).must_equal false
+  end
+
   it "should raise an error if an invalid :frame option is used" do
     proc{@d.l{rank.function.over(:frame=>:blah)}}.must_raise(Sequel::Error)
   end

data/spec/extensions/eval_inspect_spec.rb

@@ -69,6 +69,13 @@ describe "eval_inspect extension" do
       v = eval(o.inspect)
       v.must_equal o
       @ds.literal(v).must_equal @ds.literal(o)
+
+      ds = @ds
+      @ds.db.create_table(:test) do
+        v = eval(o.inspect)
+        v.must_equal o
+        ds.literal(v).must_equal ds.literal(o)
+      end
     end
   end
 end

data/spec/extensions/schema_dumper_spec.rb

@@ -673,8 +673,8 @@ END_MIG
       s
     end
     e = RUBY_VERSION >= '2.4' ? 'e' : 'E'
-    @d.dump_table_schema(:t4).gsub(/[+-]\d\d\d\d"\)/, '")').gsub(/\.0+/, '.0').must_equal "create_table(:t4) do\n  TrueClass :c1, :default=>false\n  String :c2, :default=>\"blah\"\n  Integer :c3, :default=>-1\n  Float :c4, :default=>1.0\n  BigDecimal :c5, :default=>BigDecimal(\"0.1005#{e}3\")\n  File :c6, :default=>Sequel::SQL::Blob.new(\"blah\")\n  Date :c7, :default=>Date.new(2008, 10, 29)\n  DateTime :c8, :default=>DateTime.parse(\"2008-10-29T10:20:30.0\")\n  Time :c9, :default=>Sequel::SQLTime.parse(\"10:20:30.0\"), :only_time=>true\n  String :c10\n  Date :c11, :default=>Sequel::CURRENT_DATE\n  DateTime :c12, :default=>Sequel::CURRENT_TIMESTAMP\nend"
-    @d.dump_table_schema(:t4, :same_db=>true).gsub(/[+-]\d\d\d\d"\)/, '")').gsub(/\.0+/, '.0').must_equal "create_table(:t4) do\n  column :c1, \"boolean\", :default=>false\n  column :c2, \"varchar\", :default=>\"blah\"\n  column :c3, \"integer\", :default=>-1\n  column :c4, \"float\", :default=>1.0\n  column :c5, \"decimal\", :default=>BigDecimal(\"0.1005#{e}3\")\n  column :c6, \"blob\", :default=>Sequel::SQL::Blob.new(\"blah\")\n  column :c7, \"date\", :default=>Date.new(2008, 10, 29)\n  column :c8, \"datetime\", :default=>DateTime.parse(\"2008-10-29T10:20:30.0\")\n  column :c9, \"time\", :default=>Sequel::SQLTime.parse(\"10:20:30.0\")\n  column :c10, \"foo\", :default=>Sequel::LiteralString.new(\"'6 weeks'\")\n  column :c11, \"date\", :default=>Sequel::CURRENT_DATE\n  column :c12, \"timestamp\", :default=>Sequel::CURRENT_TIMESTAMP\nend"
+    @d.dump_table_schema(:t4).gsub(/[+-]\d\d\d\d"\)/, '")').gsub(/\.0+/, '.0').must_equal "create_table(:t4) do\n  TrueClass :c1, :default=>false\n  String :c2, :default=>\"blah\"\n  Integer :c3, :default=>-1\n  Float :c4, :default=>1.0\n  BigDecimal :c5, :default=>Kernel::BigDecimal(\"0.1005#{e}3\")\n  File :c6, :default=>Sequel::SQL::Blob.new(\"blah\")\n  Date :c7, :default=>Date.new(2008, 10, 29)\n  DateTime :c8, :default=>DateTime.parse(\"2008-10-29T10:20:30.0\")\n  Time :c9, :default=>Sequel::SQLTime.parse(\"10:20:30.0\"), :only_time=>true\n  String :c10\n  Date :c11, :default=>Sequel::CURRENT_DATE\n  DateTime :c12, :default=>Sequel::CURRENT_TIMESTAMP\nend"
+    @d.dump_table_schema(:t4, :same_db=>true).gsub(/[+-]\d\d\d\d"\)/, '")').gsub(/\.0+/, '.0').must_equal "create_table(:t4) do\n  column :c1, \"boolean\", :default=>false\n  column :c2, \"varchar\", :default=>\"blah\"\n  column :c3, \"integer\", :default=>-1\n  column :c4, \"float\", :default=>1.0\n  column :c5, \"decimal\", :default=>Kernel::BigDecimal(\"0.1005#{e}3\")\n  column :c6, \"blob\", :default=>Sequel::SQL::Blob.new(\"blah\")\n  column :c7, \"date\", :default=>Date.new(2008, 10, 29)\n  column :c8, \"datetime\", :default=>DateTime.parse(\"2008-10-29T10:20:30.0\")\n  column :c9, \"time\", :default=>Sequel::SQLTime.parse(\"10:20:30.0\")\n  column :c10, \"foo\", :default=>Sequel::LiteralString.new(\"'6 weeks'\")\n  column :c11, \"date\", :default=>Sequel::CURRENT_DATE\n  column :c12, \"timestamp\", :default=>Sequel::CURRENT_TIMESTAMP\nend"
   end
   
   it "should not use a literal string as a fallback if using MySQL with the :same_db option" do

data/spec/extensions/static_cache_spec.rb

@@ -45,6 +45,41 @@ describe "Sequel::Plugins::StaticCache" do
       @db.sqls.must_equal []
     end
 
+    it "should have first just returns instances without sending a query" do
+      @c.first.must_equal @c1
+      @c.first(2).must_equal [@c1, @c2]
+      @c.first(0).must_equal []
+      @db.sqls.must_equal []
+    end
+
+    it "should have first just returns instances with sending a query" do
+      @db.fetch = lambda do |s|
+        case s
+        when /id = '?(\d+)'?/
+          id = $1.to_i
+          id <= 2 ? { id: id } : nil
+        when /id >= '?(\d+)'?/
+          id = $1.to_i
+          id <= 2 ? (id..2).map { |i| { id: i } } : []
+        end
+      end
+
+      @c.first(id: 2).must_equal @c2
+      @c.first(id: '2').must_equal @c2
+      @c.first(id: 3).must_be_nil
+      @c.first { id >= 2 }.must_equal @c2
+      @c.first(2) { id >= 1 }.must_equal [@c1, @c2]
+      @c.first(Sequel.lit('id = ?', 2)).must_equal @c2
+      @db.sqls.must_equal [
+        "SELECT * FROM t WHERE (id = 2) LIMIT 1",
+        "SELECT * FROM t WHERE (id = '2') LIMIT 1",
+        "SELECT * FROM t WHERE (id = 3) LIMIT 1",
+        "SELECT * FROM t WHERE (id >= 2) LIMIT 1",
+        "SELECT * FROM t WHERE (id >= 1) LIMIT 2",
+        "SELECT * FROM t WHERE (id = 2) LIMIT 1"
+      ]
+    end
+
     it "should have each just iterate over the hash's values without sending a query" do
       a = []
       @c.each{|o| a << o}

data/spec/extensions/tree_spec.rb

@@ -108,6 +108,13 @@ describe Sequel::Model, "tree plugin" do
       "SELECT * FROM nodes WHERE (nodes.parent_id = 1)"]
   end
 
+  it "should have self_and_siblings return the roots if the current object is a root" do
+    h = {:id=>2, :parent_id=>nil, :name=>'AA'}
+    @c.dataset = @c.dataset.with_fetch(h)
+    @c.load(h).self_and_siblings.must_equal [@c.load(h)]
+    @db.sqls.must_equal ["SELECT * FROM nodes WHERE (parent_id IS NULL)"]
+  end
+
   it "should have siblings return the children of the current node's parent, except for the current node" do
     @c.dataset = @c.dataset.with_fetch([[{:id=>1, :parent_id=>3, :name=>'r'}], [{:id=>7, :parent_id=>1, :name=>'r2'}, @o.values.dup]])
     @o.siblings.must_equal [@c.load(:id=>7, :parent_id=>1, :name=>'r2')] 

data/spec/integration/dataset_test.rb

@@ -902,6 +902,8 @@ if DB.dataset.supports_window_functions?
         must_equal [{:sum=>1, :id=>1}, {:sum=>11, :id=>2}, {:sum=>111, :id=>3}, {:sum=>1000, :id=>4}, {:sum=>11000, :id=>5}, {:sum=>111000, :id=>6}]
       @ds.select(:id){sum(:amount).over(:order=>:id).as(:sum)}.all.
         must_equal [{:sum=>1, :id=>1}, {:sum=>11, :id=>2}, {:sum=>111, :id=>3}, {:sum=>1111, :id=>4}, {:sum=>11111, :id=>5}, {:sum=>111111, :id=>6}]
+      @ds.select(:id){sum(:amount).over(:partition=>:group_id, :order=>id.desc, :frame=>:rows).as(:sum)}.all.
+        must_equal [{:sum=>111, :id=>1}, {:sum=>110, :id=>2}, {:sum=>100, :id=>3}, {:sum=>111000, :id=>4}, {:sum=>110000, :id=>5}, {:sum=>100000, :id=>6}]
     end
     
     it "should give correct results for aggregate window functions with frames" do
@@ -915,6 +917,71 @@ if DB.dataset.supports_window_functions?
       @ds.select(:id){sum(:amount).over(:order=>:id, :frame=>:rows).as(:sum)}.all.
         must_equal [{:sum=>1, :id=>1}, {:sum=>11, :id=>2}, {:sum=>111, :id=>3}, {:sum=>1111, :id=>4}, {:sum=>11111, :id=>5}, {:sum=>111111, :id=>6}]
     end
+
+    it "should give correct results for aggregate window functions with ranges" do
+      @ds.select(:id){sum(:amount).over(:partition=>:group_id, :order=>:id, :frame=>:range).as(:sum)}.all.
+        must_equal [{:sum=>1, :id=>1}, {:sum=>11, :id=>2}, {:sum=>111, :id=>3}, {:sum=>1000, :id=>4}, {:sum=>11000, :id=>5}, {:sum=>111000, :id=>6}]
+      @ds.select(:id){sum(:amount).over(:partition=>:group_id, :order=>:group_id, :frame=>:range).as(:sum)}.all.
+        must_equal [{:sum=>111, :id=>1}, {:sum=>111, :id=>2}, {:sum=>111, :id=>3}, {:sum=>111000, :id=>4}, {:sum=>111000, :id=>5}, {:sum=>111000, :id=>6}]
+    end if DB.dataset.supports_window_function_frame_option?(:range)
+
+    it "should give correct results for aggregate window functions with groups" do
+      @ds.select(:id){sum(:amount).over(:partition=>:group_id, :order=>:id, :frame=>:groups).as(:sum)}.all.
+        must_equal [{:sum=>1, :id=>1}, {:sum=>11, :id=>2}, {:sum=>111, :id=>3}, {:sum=>1000, :id=>4}, {:sum=>11000, :id=>5}, {:sum=>111000, :id=>6}]
+      @ds.select(:id){sum(:amount).over(:partition=>:group_id, :frame=>:groups).as(:sum)}.all.
+        must_equal [{:sum=>111, :id=>1}, {:sum=>111, :id=>2}, {:sum=>111, :id=>3}, {:sum=>111000, :id=>4}, {:sum=>111000, :id=>5}, {:sum=>111000, :id=>6}]
+    end if DB.dataset.supports_window_function_frame_option?(:groups)
+
+   if DB.dataset.supports_window_function_frame_option?(:offset)
+      it "should give correct results for aggregate window functions with offsets for ROWS" do
+        @ds.select(:id){sum(:amount).over(:order=>:id, :frame=>{:type=>:rows, :start=>1}).as(:sum)}.all.
+          must_equal [{:sum=>1, :id=>1}, {:sum=>11, :id=>2}, {:sum=>110, :id=>3}, {:sum=>1100, :id=>4}, {:sum=>11000, :id=>5}, {:sum=>110000, :id=>6}]
+        @ds.select(:id){sum(:amount).over(:order=>:id, :frame=>{:type=>:rows, :start=>1, :end=>1}).as(:sum)}.all.
+          must_equal [{:sum=>11, :id=>1}, {:sum=>111, :id=>2}, {:sum=>1110, :id=>3}, {:sum=>11100, :id=>4}, {:sum=>111000, :id=>5}, {:sum=>110000, :id=>6}]
+        @ds.select(:id){sum(:amount).over(:order=>:id, :frame=>{:type=>:rows, :start=>2, :end=>[1, :preceding]}).as(:sum)}.all.
+          must_equal [{:sum=>nil, :id=>1}, {:sum=>1, :id=>2}, {:sum=>11, :id=>3}, {:sum=>110, :id=>4}, {:sum=>1100, :id=>5}, {:sum=>11000, :id=>6}]
+        @ds.select(:id){sum(:amount).over(:order=>:id, :frame=>{:type=>:rows, :start=>[1, :following], :end=>2}).as(:sum)}.order(:id).all.
+          must_equal [{:sum=>110, :id=>1}, {:sum=>1100, :id=>2}, {:sum=>11000, :id=>3}, {:sum=>110000, :id=>4}, {:sum=>100000, :id=>5}, {:sum=>nil, :id=>6}]
+      end
+
+      cspecify "should give correct results for aggregate window functions with offsets for RANGES", :mssql, [proc{DB.server_version < 110000}, :postgres] do
+        @ds.select(:id){sum(:amount).over(:order=>:group_id, :frame=>{:type=>:range, :start=>1}).as(:sum)}.all.
+          must_equal [{:sum=>111, :id=>1}, {:sum=>111, :id=>2}, {:sum=>111, :id=>3}, {:sum=>111111, :id=>4}, {:sum=>111111, :id=>5}, {:sum=>111111, :id=>6}]
+        @ds.select(:id){sum(:amount).over(:order=>:group_id, :frame=>{:type=>:range, :start=>0, :end=>1}).as(:sum)}.all.
+          must_equal [{:sum=>111111, :id=>1}, {:sum=>111111, :id=>2}, {:sum=>111111, :id=>3}, {:sum=>111000, :id=>4}, {:sum=>111000, :id=>5}, {:sum=>111000, :id=>6}]
+        @ds.select(:id){sum(:amount).over(:order=>:amount, :frame=>{:type=>:range, :start=>100, :end=>1000}).as(:sum)}.all.
+          must_equal [{:sum=>1111, :id=>1}, {:sum=>1111, :id=>2}, {:sum=>1111, :id=>3}, {:sum=>1000, :id=>4}, {:sum=>10000, :id=>5}, {:sum=>100000, :id=>6}]
+      end if DB.dataset.supports_window_function_frame_option?(:range)
+
+      it "should give correct results for aggregate window functions with offsets for GROUPS" do
+        @ds.select(:id){sum(:amount).over(:order=>:group_id, :frame=>{:type=>:groups, :start=>1}).as(:sum)}.all.
+          must_equal [{:sum=>111, :id=>1}, {:sum=>111, :id=>2}, {:sum=>111, :id=>3}, {:sum=>111111, :id=>4}, {:sum=>111111, :id=>5}, {:sum=>111111, :id=>6}]
+        @ds.select(:id){sum(:amount).over(:order=>:group_id, :frame=>{:type=>:groups, :start=>0, :end=>1}).as(:sum)}.all.
+          must_equal [{:sum=>111111, :id=>1}, {:sum=>111111, :id=>2}, {:sum=>111111, :id=>3}, {:sum=>111000, :id=>4}, {:sum=>111000, :id=>5}, {:sum=>111000, :id=>6}]
+      end if DB.dataset.supports_window_function_frame_option?(:groups)
+    end
+
+    it "should give correct results for aggregate window functions with exclusions" do
+      @ds.select(:id){sum(:amount).over(:order=>:id, :frame=>{:type=>:rows, :start=>:preceding, :exclude=>:current}).as(:sum)}.all.
+        must_equal [{:sum=>nil, :id=>1}, {:sum=>1, :id=>2}, {:sum=>11, :id=>3}, {:sum=>111, :id=>4}, {:sum=>1111, :id=>5}, {:sum=>11111, :id=>6}]
+      @ds.select(:id){sum(:amount).over(:order=>:group_id, :frame=>{:type=>:rows, :start=>:preceding, :exclude=>:group}).as(:sum)}.all.
+        must_equal [{:sum=>nil, :id=>1}, {:sum=>nil, :id=>2}, {:sum=>nil, :id=>3}, {:sum=>111, :id=>4}, {:sum=>111, :id=>5}, {:sum=>111, :id=>6}]
+      @ds.select(:id){sum(:amount).over(:order=>:group_id, :frame=>{:type=>:rows, :start=>:preceding, :exclude=>:ties}).as(:sum)}.all.
+        must_equal [{:sum=>1, :id=>1}, {:sum=>10, :id=>2}, {:sum=>100, :id=>3}, {:sum=>1111, :id=>4}, {:sum=>10111, :id=>5}, {:sum=>100111, :id=>6}]
+      @ds.select(:id){sum(:amount).over(:order=>:id, :frame=>{:type=>:rows, :start=>:preceding, :exclude=>:no_others}).as(:sum)}.all.
+        must_equal [{:sum=>1, :id=>1}, {:sum=>11, :id=>2}, {:sum=>111, :id=>3}, {:sum=>1111, :id=>4}, {:sum=>11111, :id=>5}, {:sum=>111111, :id=>6}]
+    end if DB.dataset.supports_window_function_frame_option?(:exclude)
+
+    it "should give correct results for window functions" do
+      @ds.window(:win, :partition=>:group_id, :order=>:id).select(:id){sum(:amount).over(:window=>win, :frame=>:rows).as(:sum)}.all.
+        must_equal [{:sum=>1, :id=>1}, {:sum=>11, :id=>2}, {:sum=>111, :id=>3}, {:sum=>1000, :id=>4}, {:sum=>11000, :id=>5}, {:sum=>111000, :id=>6}]
+      @ds.window(:win, :partition=>:group_id).select(:id){sum(:amount).over(:window=>win, :order=>id, :frame=>:rows).as(:sum)}.all.
+        must_equal [{:sum=>1, :id=>1}, {:sum=>11, :id=>2}, {:sum=>111, :id=>3}, {:sum=>1000, :id=>4}, {:sum=>11000, :id=>5}, {:sum=>111000, :id=>6}]
+      @ds.window(:win, {}).select(:id){sum(:amount).over(:window=>:win, :order=>id, :frame=>:rows).as(:sum)}.all.
+        must_equal [{:sum=>1, :id=>1}, {:sum=>11, :id=>2}, {:sum=>111, :id=>3}, {:sum=>1111, :id=>4}, {:sum=>11111, :id=>5}, {:sum=>111111, :id=>6}]
+      @ds.window(:win, :partition=>:group_id).select(:id){sum(:amount).over(:window=>:win, :order=>id, :frame=>:all).as(:sum)}.all.
+        must_equal [{:sum=>111, :id=>1}, {:sum=>111, :id=>2}, {:sum=>111, :id=>3}, {:sum=>111000, :id=>4}, {:sum=>111000, :id=>5}, {:sum=>111000, :id=>6}]
+    end if DB.dataset.supports_window_clause?
   end
 end
 

data/spec/integration/plugin_test.rb

@@ -1989,6 +1989,13 @@ describe "Caching plugins" do
     end
 
     include CachingPluginSpecs
+
+    it "should have first retrieve correct values" do 
+      @Artist.first.must_equal @Artist.load(:id=>1)
+      @Artist.first(1).must_equal [@Artist.load(:id=>1)]
+      @Artist.first(:id=>1).must_equal @Artist.load(:id=>1)
+      @Artist.first{id =~ 1}.must_equal @Artist.load(:id=>1)
+    end
   end
 end
 

data/spec/integration/schema_test.rb

@@ -634,6 +634,26 @@ describe "Database schema modifiers" do
     @ds.all.must_equal [{:id=>10}, {:id=>20}]
   end
 
+  it "should set column defaults to nil correctly" do
+    @db.create_table!(:items){Integer :id}
+    @ds.insert(:id=>10)
+    @db.alter_table(:items){set_column_default :id, nil}
+    @db.schema(:items, :reload=>true).map{|x| x.first}.must_equal [:id]
+    @ds.columns!.must_equal [:id]
+    @ds.insert
+    @ds.all.must_equal [{:id=>10}, {:id=>nil}]
+  end
+
+  it "should set column defaults to nil for NOT NULL columns correctly" do
+    @db.create_table!(:items){Integer :id, :null=>false}
+    @ds.insert(:id=>10)
+    @db.alter_table(:items){set_column_default :id, nil}
+    @db.schema(:items, :reload=>true).map{|x| x.first}.must_equal [:id]
+    @ds.columns!.must_equal [:id]
+    @ds.insert(20)
+    @ds.all.must_equal [{:id=>10}, {:id=>20}]
+  end
+
   cspecify "should set column types correctly", [:jdbc, :db2], :oracle do
     @db.create_table!(:items){Integer :id}
     @ds.insert(:id=>10)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sequel
 version: !ruby/object:Gem::Version
-  version: 5.10.0
+  version: 5.11.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-07-01 00:00:00.000000000 Z
+date: 2018-08-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -194,6 +194,7 @@ extra_rdoc_files:
 - doc/release_notes/5.7.0.txt
 - doc/release_notes/5.9.0.txt
 - doc/release_notes/5.10.0.txt
+- doc/release_notes/5.11.0.txt
 files:
 - CHANGELOG
 - MIT-LICENSE
@@ -274,6 +275,7 @@ files:
 - doc/release_notes/5.0.0.txt
 - doc/release_notes/5.1.0.txt
 - doc/release_notes/5.10.0.txt
+- doc/release_notes/5.11.0.txt
 - doc/release_notes/5.2.0.txt
 - doc/release_notes/5.3.0.txt
 - doc/release_notes/5.4.0.txt