sequel 5.3.0 → 5.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: ac284f3deba98d7ef4b7213b3f6d17c9df344333
-  data.tar.gz: 3396c7263e758fa01b6820cd1eed79e9f1676be0
+SHA256:
+  metadata.gz: 31c759888ccdeebe39b3d3bd9e953c74d8584bade28bdc1bc2d6e38545c8896d
+  data.tar.gz: dbf22a0e145192f4a50ea421a4e93a8b182472c5430d06061d710f218bd61d24
 SHA512:
-  metadata.gz: c0c7a62b97b76a7a10a8ebe6df53c17de99efb70a2403a18362a32bb11a66b736885430911e982a834d60013ba84c154ebb7609c0b1d7d8c103fe8d4000cb549
-  data.tar.gz: 9cffa3dd8f2c87aec5598a5ac14676d061c6214f24f1851f721952c3b9c90a263dd2c4d220dfc828f87181faafe9a4d61fe7daf3d82861db0f752871450611f6
+  metadata.gz: 764c3d3d8856d8be93d5ee7492e331b1a56caeef4a2ad2d8a53a6c781e34650007f44a1ea0d3cb97b03ebf633842da3c67846edcfe0a0a9c7f788e15123403a9
+  data.tar.gz: f0f32cc6e140e46a7cf91f78ace601a0c5bf7c77b87f2fcbfd236fca04090e2bc97e89f579206bb10b9bce84a340215aafe029c9923aec816f33f60aa54da80d

data/CHANGELOG

@@ -1,3 +1,33 @@
+=== 5.4.0 (2018-01-04)
+
+* Enable fractional seconds in timestamps on DB2 (jeremyevans) (#1463)
+
+* Don't attempt to insert a second time if insert_select runs a query that doesn't return results, which can happen when triggers are used (jeremyevans)
+
+* Make Dataset#insert_select on PostgreSQL and MSSQL return false instead of nil if the INSERT query is sent to the database but returns no rows (jeremyevans)
+
+* Add index_caching extension for caching calls to Database#indexes (kenaniah, jeremyevans) (#1461)
+
+* Allow Database#indexes on SQLite, MSSQL, SQLAnywhere, and DB2 to handle SQL::Identifier values (jeremyevans)
+
+* Add pg_timestamptz extension for using timestamptz (timestamp with time zone) as the default timestamp type (jeremyevans)
+
+* Support Sequel.date_{add,sub} :cast option for setting cast type in date_arithmetic extension (jeremyevans)
+
+* Optimize Database#synchronize implementation on ruby 2.5+ (jeremyevans)
+
+* Add class_table_inheritance plugin :ignore_subclass_columns option (brianphillips) (#1459)
+
+* Make Dataset#to_xml in xml_serializer work with eager_graphed datasets (jeremyevans)
+
+* Make Dataset#to_json in json_serializer work with eager_graphed datasets (jeremyevans)
+
+* Cache Dataset#nullify dataset in the null_dataset extension (chanks) (#1456)
+
+* Add datetime_parse_to_time extension, for parsing timestamp strings without offsets using DateTime.parse.to_time (jeremyevans) (#1455)
+
+* Add WHERE NULL filter for Dataset#where calls with no existing filter, no argument, and where the virtual row block returns nil (jeremyevans)
+
 === 5.3.0 (2017-12-01)
 
 * Add logger to Database instance before making first connection in bin/sequel (jeremyevans)

data/bin/sequel

@@ -7,6 +7,7 @@ code = nil
 copy_databases = nil
 dump_migration = nil
 dump_schema = nil
+dump_indexes = nil
 env = nil
 migrate_dir = nil
 migrate_ver = nil
@@ -106,6 +107,11 @@ options = OptionParser.new do |opts|
   opts.on_tail("-v", "--version", "Show version") do
     show_version = true
   end
+
+  opts.on("-X", "--dump-indexes filename", "dump the index cache for all tables to the file") do |v|
+    dump_indexes = v
+    exclusive_options << :X
+  end
 end
 opts = options
 opts.parse!
@@ -170,6 +176,13 @@ begin
     DB.dump_schema_cache(dump_schema)
     exit
   end
+  if dump_indexes
+    extra_proc.call
+    DB.extension :index_caching
+    DB.tables.each{|t| DB.indexes(Sequel::SQL::Identifier.new(t))}
+    DB.dump_index_cache(dump_indexes)
+    exit
+  end
   if copy_databases
     Sequel.extension :migration
     DB.extension :schema_dumper

data/doc/cheat_sheet.rdoc

@@ -49,6 +49,7 @@ Without a filename argument, the sqlite adapter will setup a new sqlite database
   dataset.each{|r| p r}
   dataset.all # => [{...}, {...}, ...]
   dataset.first # => {...}
+  dataset.last # => {...}
 
 == Update/Delete rows
 

data/doc/dataset_filtering.rdoc

@@ -84,7 +84,7 @@ You can also use the =~ operator:
 This works with other hash values, such as arrays and ranges:
 
   items.where{Sequel.|({category: ['ruby', 'other']}, (price - 100 > 200))}.sql
-  # "SELECT * FROM items WHERE ((category IN ('ruby', 'other')) OR ((price - 100) <= 200))"
+  # "SELECT * FROM items WHERE ((category IN ('ruby', 'other')) OR ((price - 100) > 200))"
 
   items.where{(price =~ (100..200)) & :active}.sql
   # "SELECT * FROM items WHERE ((price >= 100 AND price <= 200) AND active)"

data/doc/querying.rdoc

@@ -49,7 +49,7 @@ to raise an exception if no record is found, you can use <tt>Sequel::Model.with_
 
 ==== Using +first+
 
-If you just want the first record in the dataset,
+If you want the first record in the dataset,
 <tt>Sequel::Dataset#first</tt> is probably the most obvious method to use:
 
   artist = Artist.first
@@ -82,22 +82,19 @@ Dataset#[] does not (unless it is a model dataset).
 ==== Using +last+
 
 If you want the last record in the dataset,
-<tt>Sequel::Dataset#last</tt> is an obvious method to use.  Note
-that last requires that the dataset be ordered, unless the
-dataset is a model dataset.  For a model dataset, +last+ will do a
-reverse order by the primary key field:
+<tt>Sequel::Dataset#last</tt> is an obvious method to use.  +last+ requires the
+dataset be ordered, unless the dataset is a model dataset in which case +last+
+will do a reverse order by the primary key field:
 
   artist = Artist.last
   # SELECT * FROM artists ORDER BY id DESC LIMIT 1
   # => #<Artist @values={:name=>"YJM", :id=>1}>
 
-Note that what +last+ does is reverse the order of the dataset and then
-call +first+.  This is why +last+ raises a Sequel::Error if there is no
-order on a plain dataset, because otherwise it would provide the same record
-as +first+, and most users would find that confusing.
+Note:
 
-Note that +last+ is not necessarily going to give you the last record
-in the dataset unless you give the dataset an unambiguous order.
+1. +last+ is equivalent to running a +reverse.first+ query, in other words it reverses the order of the dataset and then calls +first+.  This is why +last+ raises a Sequel::Error when there is no order on a plain dataset - because it will provide the same record as +first+, and most users will find that confusing.
+2. +last+ is not necessarily going to give you the last record in the dataset unless you give the dataset an unambiguous order.
+3. +last+ will ignore +limit+ if chained together in a query because it sets a limit of 1 if no arguments are given.
 
 ==== Retrieving a Single Column Value
 

data/doc/release_notes/5.4.0.txt

@@ -0,0 +1,80 @@
+= New Features
+
+* An index_caching extension has been added, which makes
+  Database#indexes use a cache similar to Database#schema, and also
+  offers methods for saving and loading the cache from a file, similar
+  to the schema_caching extension.
+  
+  This can speed up model loaded in certain cases when the
+  auto_validations plugin is used.
+
+* A datetime_parse_to_time extension has been added, which parses
+  strings without timezone offsets using DateTime.parse intead of
+  Time.parse.  This can fix problems when the string being parsed
+  represents a time not valid in the local timezone due to daylight
+  savings time shifts.  Time.parse silently shifts such times by 1
+  hour instead of raising an exception, resulting in incorrect
+  behavior in that case.
+
+  It only makes sense to use this extension when the times in the
+  database are stored in UTC but not returned with timezone
+  information, the timezone for the Database instance
+  (or Sequel.database_timezone) is set to :utc (not the default),
+  and Time is used as the datetime_class (the default).
+
+* A pg_timestamptz extension has been added for switching the default
+  generic timestamp type from timestamp to timestamptz.
+
+* Sequel.date_{add,sub} in the date_arithmetic extension now supports
+  a :cast option for setting the cast type.  This value defaults to
+  Time for backwards compatibility, which uses the default generic
+  timestamp type for the database.
+
+* The class_table_inheritance plugin now supports an
+  :ignore_subclass_columns option which takes an array of column
+  symbols to ignore in subclasses.  This allows you to use
+  the plugin when your table inheritance hierarchy includes
+  non-primary key columns with the same name in different tables.
+
+= Improvements
+
+* Dataset#insert_select now returns false instead of nil if it runs
+  an INSERT statement but does not return a value on Microsoft SQL
+  Server or PostgreSQL.  This can happen on both databases if triggers
+  are used.
+
+  Model#save now checks for a false value returned by
+  Dataset#insert_select, and does not issue another INSERT statement
+  in that case.
+
+* Database#indexes now correctly handles SQL::Identifier arguments on
+  SQLite, Microsoft SQL Server, SQLAnywhere, and DB2.
+
+* Dataset#to_json in the json_serializer plugin and Dataset#to_xml
+  in the xml_serializer plugin now both handle datasets that use
+  eager_graph.
+
+* Dataset#nullify now caches the dataset it returns, for better
+  performance if it is called more than once on the same dataset.
+
+* Database#synchronize is now optimized on ruby 2.5+ and is about
+  10% faster by relying on the new lazy proc allocation feature.
+
+= Backwards Compatibility
+
+* Fractional second timestamps are now enabled on DB2.  If you are
+  connecting to a DB2 database that does not support fractional
+  seconds, you should add the following code (where DB is your
+  Sequel::Database instance):
+
+    DB.extend_datasets do
+      def supports_timestamp_usecs?
+        false
+      end
+    end
+
+* Calling a filtering method with no argument and a virtual row
+  block that returns nil on a dataset with no existing filter now
+  adds a WHERE NULL filter, to match the behavior if given a nil
+  argument.  Previously, a deprecation warning was issued and a
+  dataset with no filter was returned.

data/doc/testing.rdoc

@@ -156,6 +156,7 @@ SEQUEL_COLUMNS_INTROSPECTION :: Use the columns_introspection extension when run
 SEQUEL_CONNECTION_VALIDATOR :: Use the connection validator extension when running the specs
 SEQUEL_DUPLICATE_COLUMNS_HANDLER :: Use the duplicate columns handler extension with value given when running the specs
 SEQUEL_ERROR_SQL :: Use the error_sql extension when running the specs
+SEQUEL_INDEX_CACHING :: Use the index_caching extension when running the specs
 SEQUEL_FREEZE_DATABASE :: Freeze the database before running the integration specs
 SEQUEL_IDENTIFIER_MANGLING :: Use the identifier_mangling extension when running the specs
 SEQUEL_MODEL_PREPARED_STATEMENTS :: Use the prepared_statements plugin when running the specs
@@ -163,5 +164,6 @@ SEQUEL_NO_CACHE_ASSOCIATIONS :: Don't cache association metadata when running th
 SEQUEL_NO_CHECK_SQLS :: Don't check for specific SQL syntax when running the specs
 SEQUEL_CHECK_PENDING :: Try running all specs (note, can cause lockups for some adapters), and raise errors for skipped specs that don't fail
 SEQUEL_NO_PENDING :: Don't skip any specs, try running all specs (note, can cause lockups for some adapters)
+SEQUEL_PG_TIMESTAMPTZ :: Use the pg_timestamptz extension when running the postgres specs
 SEQUEL_SPLIT_SYMBOLS :: Turn on symbol splitting when running the adapter and integration specs
 SEQUEL_SYNCHRONIZE_SQL :: Use the synchronize_sql extension when running the specs

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

@@ -69,6 +69,7 @@ module Sequel
       # Use SYSCAT.INDEXES to get the indexes for the table
       def indexes(table, opts = OPTS)
         m = output_identifier_meth
+        table = table.value if table.is_a?(Sequel::SQL::Identifier)
         indexes = {}
         metadata_dataset.
          from(Sequel[:syscat][:indexes]).
@@ -345,11 +346,6 @@ module Sequel
         false
       end
 
-      # DB2 does not support fractional seconds in timestamps.
-      def supports_timestamp_usecs?
-        false
-      end
-
       # DB2 supports window functions
       def supports_window_functions?
         true
@@ -384,6 +380,11 @@ module Sequel
         '0'
       end
 
+      # DB2 doesn't support fractional seconds in times, only fractional seconds in timestamps.
+      def literal_sqltime(v)
+        v.strftime("'%H:%M:%S'")
+      end
+
       # Use 1 for true on DB2
       def literal_true
         '1'

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

@@ -165,6 +165,7 @@ module Sequel
         m = output_identifier_meth
         im = input_identifier_meth
         indexes = {}
+        table = table.value if table.is_a?(Sequel::SQL::Identifier)
         i = Sequel[:i]
         ds = metadata_dataset.from(Sequel.lit('[sys].[tables]').as(:t)).
          join(Sequel.lit('[sys].[indexes]').as(:i), :object_id=>:object_id).
@@ -473,12 +474,6 @@ module Sequel
         :datetime
       end
 
-      # MSSQL has both datetime and timestamp classes, most people are going
-      # to want datetime
-      def type_literal_generic_time(column)
-        column[:only_time] ? :time : :datetime
-      end
-      
       # MSSQL doesn't have a true boolean class, so it uses bit
       def type_literal_generic_trueclass(column)
         :bit
@@ -580,10 +575,12 @@ module Sequel
         where(Sequel.lit("CONTAINS (?, ?)", cols, terms))
       end
 
-      # Use the OUTPUT clause to get the value of all columns for the newly inserted record.
+      # Insert a record, returning the record inserted, using OUTPUT.  Always returns nil without
+      # running an INSERT statement if disable_insert_output is used.  If the query runs
+      # but returns no values, returns false.
       def insert_select(*values)
         return unless supports_insert_select?
-        with_sql_first(insert_select_sql(*values))
+        with_sql_first(insert_select_sql(*values)) || false
       end
 
       # Add OUTPUT clause unless there is already an existing output clause, then return

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

@@ -537,15 +537,11 @@ module Sequel
 
       # MySQL has both datetime and timestamp classes, most people are going
       # to want datetime.
-      def type_literal_generic_time(column)
-        if column[:only_time]
-          if supports_timestamp_usecs?
-            :'time(6)'
-          else
-            :time
-          end
+      def type_literal_generic_only_time(column)
+        if supports_timestamp_usecs?
+          :'time(6)'
         else
-          type_literal_generic_datetime(column)
+          :time
         end
       end
 

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

@@ -285,7 +285,7 @@ module Sequel
 
       # Oracle doesn't have a time type, so use timestamp for all
       # time columns.
-      def type_literal_generic_time(column)
+      def type_literal_generic_only_time(column)
         :timestamp
       end
 

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

@@ -1393,11 +1393,13 @@ module Sequel
         insert_conflict
       end
 
-      # Insert a record returning the record inserted.  Always returns nil without
-      # inserting a query if disable_insert_returning is used.
+      # Insert a record, returning the record inserted, using RETURNING.  Always returns nil without
+      # running an INSERT statement if disable_insert_returning is used.  If the query runs
+      # but returns no values, returns false.
       def insert_select(*values)
         return unless supports_insert_select?
-        server?(:default).with_sql_first(insert_select_sql(*values))
+        # Handle case where query does not return a row
+        server?(:default).with_sql_first(insert_select_sql(*values)) || false
       end
 
       # The SQL to use for an insert_select, adds a RETURNING clause to the insert

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

@@ -58,6 +58,7 @@ module Sequel
       def indexes(table, opts = OPTS)
         m = output_identifier_meth
         im = input_identifier_meth
+        table = table.value if table.is_a?(Sequel::SQL::Identifier)
         indexes = {}
         metadata_dataset.
          from(Sequel[:dbo][:sysobjects].as(:z)).
@@ -158,12 +159,6 @@ module Sequel
         :datetime
       end
 
-      # Sybase has both datetime and timestamp classes, most people are going
-      # to want datetime
-      def type_literal_generic_time(column)
-        column[:only_time] ? :time : :datetime
-      end
-      
       # Sybase doesn't have a true boolean class, so it uses integer
       def type_literal_generic_trueclass(column)
         :smallint

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

@@ -82,6 +82,7 @@ module Sequel
         m = output_identifier_meth
         im = input_identifier_meth
         indexes = {}
+        table = table.value if table.is_a?(Sequel::SQL::Identifier)
         metadata_dataset.with_sql("PRAGMA index_list(?)", im.call(table)).each do |r|
           if opts[:only_autocreated]
             # If specifically asked for only autocreated indexes, then return those an only those
@@ -188,6 +189,7 @@ module Sequel
             ops.each{|op| alter_table_sql_list(table, [op]).flatten.each{|sql| execute_ddl(sql)}}
           end
         end
+        remove_cached_schema(table)
       ensure
         run "PRAGMA foreign_keys = 1" if fks
       end

data/lib/sequel/database/connecting.rb

@@ -247,7 +247,7 @@ module Sequel
       @single_threaded
     end
     
-    if !defined?(RUBY_ENGINE) || RUBY_ENGINE == 'ruby'
+    if RUBY_ENGINE == 'ruby' && RUBY_VERSION < '2.5'
       # Acquires a database connection, yielding it to the passed block. This is
       # useful if you want to make sure the same connection is used for all
       # database queries in the block.  It is also useful if you want to gain

data/lib/sequel/database/schema_methods.rb

@@ -1010,7 +1010,16 @@ module Sequel
     # Sequel uses the timestamp type by default for Time values.
     # If the :only_time option is used, the time type is used.
     def type_literal_generic_time(column)
-      column[:only_time] ? :time : :timestamp
+      if column[:only_time]
+        type_literal_generic_only_time(column)
+      else
+        type_literal_generic_datetime(column)
+      end
+    end
+
+    # Use time by default for Time values if :only_time option is used.
+    def type_literal_generic_only_time(column)
+      :time
     end
 
     # Sequel uses the boolean type by default for TrueClass and FalseClass.

data/lib/sequel/dataset/query.rb

@@ -1211,8 +1211,7 @@ module Sequel
         cond = SQL::BooleanExpression.new(combine, @opts[clause], cond) if @opts[clause]
 
         if cond.nil?
-          Sequel::Deprecation.deprecate('Filtering method called on dataset with no existing filter with virtual row block and no argument and virtual row block returned nil.  Currently, this results in the filter being ignored instead of using a NULL filter.  In Sequel 5.4+, this behavior will change to using a NULL filter, similar to the behavior in all other cases.')
-          #cond = Sequel::NULL
+          cond = Sequel::NULL
         end
 
         clone(clause => cond)

data/lib/sequel/extensions/date_arithmetic.rb

@@ -21,6 +21,11 @@
 #   add = Sequel.date_add(:date_column, 1.years + 2.months + 3.days)
 #   sub = Sequel.date_sub(:date_column, 1.hours + 2.minutes + 3.seconds)
 #
+# By default, values are casted to the generic timestamp type for the
+# database.  You can override the cast type using the :cast option:
+#
+#   add = Sequel.date_add(:date_column, {years: 1, months: 2, days: 3}, :cast=>:timestamptz)
+#
 # These expressions can be used in your datasets, or anywhere else that
 # Sequel expressions are allowed:
 #
@@ -33,13 +38,17 @@ module Sequel
   module SQL
     module Builders
       # Return a DateAdd expression, adding an interval to the date/timestamp expr.
-      def date_add(expr, interval)
-        DateAdd.new(expr, interval)
+      # Options:
+      # :cast :: Cast to the specified type instead of the default if casting
+      def date_add(expr, interval, opts=OPTS)
+        DateAdd.new(expr, interval, opts)
       end
 
       # Return a DateAdd expression, adding the negative of the interval to
       # the date/timestamp expr.
-      def date_sub(expr, interval)
+      # Options:
+      # :cast :: Cast to the specified type instead of the default if casting
+      def date_sub(expr, interval, opts=OPTS)
         interval = if interval.is_a?(Hash)
           h = {}
           interval.each{|k,v| h[k] = -v unless v.nil?}
@@ -47,7 +56,7 @@ module Sequel
         else
           -interval
         end
-        DateAdd.new(expr, interval)
+        DateAdd.new(expr, interval, opts)
       end
     end
 
@@ -72,8 +81,11 @@ module Sequel
           if defined?(super)
             return super
           end
+
           h = da.interval
           expr = da.expr
+          cast_type = da.cast_type || Time
+
           cast = case db_type = db.database_type
           when :postgres
             interval = String.new
@@ -81,9 +93,9 @@ module Sequel
               interval << "#{value} #{sql_unit} "
             end
             if interval.empty?
-              return literal_append(sql, Sequel.cast(expr, Time))
+              return literal_append(sql, Sequel.cast(expr, cast_type))
             else
-              return complex_expression_sql_append(sql, :+, [Sequel.cast(expr, Time), Sequel.cast(interval, :interval)])
+              return complex_expression_sql_append(sql, :+, [Sequel.cast(expr, cast_type), Sequel.cast(interval, :interval)])
             end
           when :sqlite
             args = [expr]
@@ -94,7 +106,7 @@ module Sequel
           when :mysql, :hsqldb
             if db_type == :hsqldb
               # HSQLDB requires 2.2.9+ for the DATE_ADD function
-              expr = Sequel.cast(expr, Time)
+              expr = Sequel.cast(expr, cast_type)
             end
             each_valid_interval_unit(h, MYSQL_DURATION_UNITS) do |value, sql_unit|
               expr = Sequel.function(:DATE_ADD, expr, Sequel.lit(["INTERVAL ", " "], value, sql_unit))
@@ -124,7 +136,7 @@ module Sequel
               expr = Sequel.+(expr, Sequel.lit(["INTERVAL ", " "], value.to_s, sql_unit))
             end
           when :db2
-            expr = Sequel.cast(expr, Time)
+            expr = Sequel.cast(expr, cast_type)
             each_valid_interval_unit(h, DB2_DURATION_UNITS) do |value, sql_unit|
               expr = Sequel.+(expr, Sequel.lit(["", " "], value, sql_unit))
             end
@@ -134,7 +146,7 @@ module Sequel
           end
 
           if cast
-            expr = Sequel.cast(expr, Time)
+            expr = Sequel.cast(expr, cast_type)
           end
 
           literal_append(sql, expr)
@@ -165,10 +177,14 @@ module Sequel
       # symbol keys.
       attr_reader :interval
 
+      # The type to cast the expression to.  nil if not overridden, in which cast
+      # the generic timestamp type for the database will be used.
+      attr_reader :cast_type
+
       # Supports two types of intervals:
       # Hash :: Used directly, but values cannot be plain strings.
       # ActiveSupport::Duration :: Converted to a hash using the interval's parts.
-      def initialize(expr, interval)
+      def initialize(expr, interval, opts=OPTS)
         @expr = expr
         @interval = if interval.is_a?(Hash)
           interval.each_value do |v|
@@ -186,6 +202,7 @@ module Sequel
         end
 
         @interval.freeze
+        @cast_type = opts[:cast] if opts[:cast]
         freeze
       end