sequel 5.3.0 → 5.4.0

data/lib/sequel/extensions/datetime_parse_to_time.rb

@@ -0,0 +1,37 @@
+# frozen-string-literal: true
+#
+# This switches the default parsing of strings into Time values
+# from using Time.parse to using DateTime.parse.to_time.  This
+# fixes issues when the times being parsed have no timezone
+# information, the implicit timezone for the Database instance
+# is set to +:utc+, and the timestamps being used include values
+# not valid in the local timezone, such as during a daylight
+# savings time switch.  
+#
+# To load the extension:
+#
+#   Sequel.extension :datetime_parse_to_time
+
+#
+module Sequel::DateTimeParseToTime
+  private
+
+  # Use DateTime.parse.to_time to do the conversion if the input a string and is assumed to
+  # be in UTC and there is no offset information in the string.
+  def convert_input_timestamp(v, input_timezone)
+    if v.is_a?(String) && datetime_class == Time && input_timezone == :utc && !Date._parse(v).has_key?(:offset)
+      t = DateTime.parse(v).to_time
+      case application_timezone
+      when nil, :local
+        t = t.localtime
+      end
+      t
+    else
+      super
+    end
+  rescue => e
+    raise convert_exception_class(e, Sequel::InvalidValue)
+  end
+end
+
+Sequel.extend(Sequel::DateTimeParseToTime)

data/lib/sequel/extensions/index_caching.rb

@@ -0,0 +1,107 @@
+# frozen-string-literal: true
+#
+# The index_caching extension adds a few methods to Sequel::Database
+# that make it easy to dump information about database indexes to a file,
+# and load it from that file.  Loading index information from a
+# dumped file is faster than parsing it from the database, so this
+# can save bootup time for applications with large numbers of index.
+#
+# Basic usage in application code:
+#
+#   DB = Sequel.connect('...')
+#   DB.extension :index_caching
+#   DB.load_index_cache('/path/to/index_cache.dump')
+#
+#   # load model files
+#
+# Then, whenever database indicies are modified, write a new cached
+# file.  You can do that with <tt>bin/sequel</tt>'s -X option:
+#
+#   bin/sequel -X /path/to/index_cache.dump postgres://...
+#
+# Alternatively, if you don't want to dump the index information for
+# all tables, and you don't worry about race conditions, you can
+# choose to use the following in your application code:
+#
+#   DB = Sequel.connect('...')
+#   DB.extension :index_caching
+#   DB.load_index_cache?('/path/to/index_cache.dump')
+#
+#   # load model files
+#
+#   DB.dump_index_cache?('/path/to/index_cache.dump')
+#
+# With this method, you just have to delete the index dump file if
+# the schema is modified, and the application will recreate it for you
+# using just the tables that your models use.
+#
+# Note that it is up to the application to ensure that the dumped
+# index cache reflects the current state of the database.  Sequel
+# does no checking to ensure this, as checking would take time and the
+# purpose of this code is to take a shortcut.
+#
+# The index cache is dumped in Marshal format, since it is the fastest
+# and it handles all ruby objects used in the indexes hash.  Because of this,
+# you should not attempt to load from an untrusted file.
+#
+# Related module: Sequel::IndexCaching
+
+#
+module Sequel
+  module IndexCaching
+    # Set index cache to the empty hash.
+    def self.extended(db)
+      db.instance_variable_set(:@indexes, {})
+    end
+    
+    # Remove the index cache for the given schema name
+    def remove_cached_schema(table)
+      k = quote_schema_table(table)
+      Sequel.synchronize{@indexes.delete(k)}
+      super
+    end
+    
+    # Dump the index cache to the filename given in Marshal format.
+    def dump_index_cache(file)
+      File.open(file, 'wb'){|f| f.write(Marshal.dump(@indexes))}
+      nil
+    end
+
+    # Dump the index cache to the filename given unless the file
+    # already exists.
+    def dump_index_cache?(file)
+      dump_index_cache(file) unless File.exist?(file)
+    end
+
+    # Replace the index cache with the data from the given file, which
+    # should be in Marshal format.
+    def load_index_cache(file)
+      @indexes = Marshal.load(File.read(file))
+      nil
+    end
+
+    # Replace the index cache with the data from the given file if the
+    # file exists.
+    def load_index_cache?(file)
+      load_index_cache(file) if File.exist?(file)
+    end
+
+    # If no options are provided and there is cached index information for
+    # the table, return the cached information instead of querying the
+    # database.
+    def indexes(table, opts=OPTS)
+      return super unless opts.empty?
+
+      quoted_name = literal(table)
+      if v = Sequel.synchronize{@indexes[quoted_name]}
+        return v
+      end
+
+      result = super
+      Sequel.synchronize{@indexes[quoted_name] = result}
+      result
+    end
+  end
+
+  Database.register_extension(:index_caching, IndexCaching)
+end

data/lib/sequel/extensions/null_dataset.rb

@@ -41,7 +41,9 @@ module Sequel
     module Nullifiable
       # Return a cloned nullified dataset.
       def nullify
-        with_extend(NullDataset)
+        cached_dataset(:_nullify_ds) do
+          with_extend(NullDataset)
+        end
       end
     end
 

data/lib/sequel/extensions/pg_timestamptz.rb

@@ -0,0 +1,26 @@
+# frozen-string-literal: true
+#
+# The pg_timestamptz extension changes the default timestamp
+# type for the database to be +timestamptz+ (+timestamp with time zone+)
+# instead of +timestamp+ (+timestamp without time zone+).  This is
+# recommended if you are dealing with multiple timezones in your application.
+# 
+# To load the extension into the database:
+#
+#   DB.extension :pg_timestamptz
+#
+# Related module: Sequel::Postgres::Timestamptz
+
+#
+module Sequel
+  module Postgres
+    module Timestamptz
+      # Use timestamptz by default for generic timestamp value.
+      def type_literal_generic_datetime(column)
+        :timestamptz
+      end
+    end
+  end
+
+  Database.register_extension(:pg_timestamptz, Postgres::Timestamptz)
+end

data/lib/sequel/model/base.rb

@@ -1635,8 +1635,8 @@ module Sequel
       # the record should be refreshed from the database.
       def _insert
         ds = _insert_dataset
-        if _use_insert_select?(ds) && (h = _insert_select_raw(ds))
-          _save_set_values(h)
+        if _use_insert_select?(ds) && !(h = _insert_select_raw(ds)).nil?
+          _save_set_values(h) if h
           nil
         else
           iid = _insert_raw(ds)

data/lib/sequel/plugins/class_table_inheritance.rb

@@ -196,6 +196,8 @@ module Sequel
       # :key_chooser :: proc returning key for the provided model instance
       # :table_map :: Hash with class name symbols keys mapping to table name symbol values.
       #               Overrides implicit table names.
+      # :ignore_subclass_columns :: Array with column names as symbols that are ignored
+      #                             on all sub-classes.
       def self.configure(model, opts = OPTS)
         SingleTableInheritance.configure model, opts[:key], opts
 
@@ -206,6 +208,7 @@ module Sequel
           @cti_table_columns = columns
           @cti_table_map = opts[:table_map] || {}
           @cti_alias = opts[:alias] || @dataset.first_source
+          @cti_ignore_subclass_columns = opts[:ignore_subclass_columns] || []
         end
       end
 
@@ -232,17 +235,22 @@ module Sequel
         # the implicit naming is incorrect.
         attr_reader :cti_table_map
 
+        # An array of columns that may be duplicated in sub-classes. The
+        # primary key column is always allowed to be duplicated
+        attr_reader :cti_ignore_subclass_columns
+
         # Freeze CTI information when freezing model class.
         def freeze
           @cti_models.freeze
           @cti_tables.freeze
           @cti_table_columns.freeze
           @cti_table_map.freeze
+          @cti_ignore_subclass_columns.freeze
 
           super
         end
 
-        Plugins.inherited_instance_variables(self, :@cti_models=>nil, :@cti_tables=>nil, :@cti_table_columns=>nil, :@cti_instance_dataset=>nil, :@cti_table_map=>nil, :@cti_alias=>nil)
+        Plugins.inherited_instance_variables(self, :@cti_models=>nil, :@cti_tables=>nil, :@cti_table_columns=>nil, :@cti_instance_dataset=>nil, :@cti_table_map=>nil, :@cti_alias=>nil, :@cti_ignore_subclass_columns=>nil)
 
         def inherited(subclass)
           ds = sti_dataset
@@ -273,10 +281,10 @@ module Sequel
             if cti_tables.length == 1
               ds = ds.select(*self.columns.map{|cc| Sequel.qualify(cti_table_name, Sequel.identifier(cc))})
             end
-            cols = columns - [pk]
+            cols = (columns - [pk]) - cti_ignore_subclass_columns
             dup_cols = cols & ds.columns
             unless dup_cols.empty?
-              raise Error, "class_table_inheritance with duplicate column names (other than the primary key column) is not supported, make sure tables have unique column names"
+              raise Error, "class_table_inheritance with duplicate column names (other than the primary key column) is not supported, make sure tables have unique column names (duplicate columns: #{dup_cols}). If this is desired, specify these columns in the :ignore_subclass_columns option when initializing the plugin"
             end
             sel_app = cols.map{|cc| Sequel.qualify(table, Sequel.identifier(cc))}
             @sti_dataset = ds = ds.join(table, pk=>pk).select_append(*sel_app)

data/lib/sequel/plugins/json_serializer.rb

@@ -406,7 +406,7 @@ module Sequel
             end
           end
 
-          res = if row_proc 
+          res = if row_proc || @opts[:eager_graph] 
             array = if opts[:array]
               opts = opts.dup
               opts.delete(:array)
@@ -414,7 +414,7 @@ module Sequel
               all
             end
             array.map{|obj| Literal.new(Sequel.object_to_json(obj, opts, &opts[:instance_block]))}
-           else
+          else
             all
           end
 

data/lib/sequel/plugins/xml_serializer.rb

@@ -389,7 +389,7 @@ module Sequel
         # as well as the :array_root_name option for specifying the name of
         # the root node that contains the nodes for all of the instances.
         def to_xml(opts=OPTS)
-          raise(Sequel::Error, "Dataset#to_xml") unless row_proc
+          raise(Sequel::Error, "Dataset#to_xml") unless row_proc || @opts[:eager_graph]
           x = model.xml_builder(opts)
           name_proc = model.xml_serialize_name_proc(opts)
           array = if opts[:array]

data/lib/sequel/version.rb

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

@@ -511,7 +511,7 @@ describe "A PostgreSQL dataset" do
 
   it "should support :using when altering a column's type" do
     @db.create_table!(:atest){Integer :t}
-    @db[:atest].insert(1262304000)
+    @db[:atest].insert(1262404000)
     @db.alter_table(:atest){set_column_type :t, Time, :using=>Sequel.cast('epoch', Time) + Sequel.cast('1 second', :interval) * :t}
     @db[:atest].get(Sequel.extract(:year, :t)).must_equal 2010
   end

data/spec/adapters/spec_helper.rb

@@ -32,6 +32,9 @@ end
 IDENTIFIER_MANGLING = !!ENV['SEQUEL_IDENTIFIER_MANGLING'] unless defined?(IDENTIFIER_MANGLING)
 DB.extension(:identifier_mangling) if IDENTIFIER_MANGLING
 
+DB.extension(:pg_timestamptz) if ENV['SEQUEL_PG_TIMESTAMPTZ']
+DB.extension :index_caching if ENV['SEQUEL_INDEX_CACHING']
+
 if dch = ENV['SEQUEL_DUPLICATE_COLUMNS_HANDLER']
   DB.extension :duplicate_columns_handler
   DB.opts[:on_duplicate_columns] = dch.to_sym unless dch.empty?

data/spec/adapters/sqlite_spec.rb

@@ -554,7 +554,7 @@ describe "A SQLite database" do
     @db.add_index :test3, :b
     @db.add_index :test3, [:b, :a]
     @db.drop_column :test3, :b
-    @db.indexes(:test3).must_equal(:test3_a_index=>{:unique=>false, :columns=>[:a]})
+    @db.indexes(:test3)[:test3_a_index].must_equal(:unique=>false, :columns=>[:a])
   end
 
   it "should have support for various #transaction modes" do

data/spec/bin_spec.rb

@@ -183,6 +183,15 @@ END
     Marshal.load(File.read(TMP_FILE)).must_equal("`a`"=>[[:a, {:type=>:integer, :db_type=>"integer", :ruby_default=>nil, :allow_null=>true, :default=>nil, :primary_key=>false}]])
   end
 
+  it "-X should dump the index cache" do
+    bin(:args=>"-X #{TMP_FILE}").must_equal ''
+    Marshal.load(File.read(TMP_FILE)).must_equal({})
+    DB.create_table(:a){Integer :id}
+    DB.create_table(:b){Integer :b, index: {name: "idx_test", unique: true}}
+    bin(:args=>"-X #{TMP_FILE}").must_equal ''
+    Marshal.load(File.read(TMP_FILE)).must_equal("`a`"=>{}, "`b`"=>{:idx_test=>{:unique=>true, :columns=>[:b]}})
+  end
+
   it "-t should output full backtraces on error" do
     bin(:args=>'-c "lambda{lambda{lambda{raise \'foo\'}.call}.call}.call"', :stderr=>true).count("\n").must_be :<,  3
     bin(:args=>'-t -c "lambda{lambda{lambda{raise \'foo\'}.call}.call}.call"', :stderr=>true).count("\n").must_be :>,  3

data/spec/core/connection_pool_spec.rb

@@ -510,7 +510,7 @@ ThreadedConnectionPoolSpecs = shared_description do
     @pool.hold{|cc| cc.must_equal c}
     @pool.hold do |cc|
       cc.must_equal c
-      Thread.new{@pool.hold{|cc2| cc2.must_equal c2}}
+      Thread.new{@pool.hold{|cc2| _(cc2).must_equal c2}}.join
     end
   end
 
@@ -523,7 +523,7 @@ ThreadedConnectionPoolSpecs = shared_description do
     @pool.hold{|cc| cc.must_equal c}
     @pool.hold do |cc|
       cc.must_equal c2
-      Thread.new{@pool.hold{|cc2| cc2.must_equal c}}
+      Thread.new{@pool.hold{|cc2| _(cc2).must_equal c}}.join
     end
   end
 

data/spec/core/dataset_spec.rb

@@ -378,14 +378,9 @@ describe "Dataset#where" do
     @dataset.where(nil).sql.must_equal "SELECT * FROM test WHERE NULL"
   end
   
-  deprecated "should handle nil block result has no existing filter" do
-    @dataset.where{nil}.sql.must_equal "SELECT * FROM test"
-  end
-
-  # SEQUEL54
   it "should handle nil block result has no existing filter" do
     @dataset.where{nil}.sql.must_equal "SELECT * FROM test WHERE NULL"
-  end if false
+  end
   
   it "should just clone if given an empty array or hash argument" do
     @dataset.where({}).sql.must_equal @dataset.sql

data/spec/extensions/class_table_inheritance_spec.rb

@@ -6,7 +6,7 @@ describe "class_table_inheritance plugin" do
     def @db.supports_schema_parsing?() true end
     def @db.schema(table, opts={})
       {:employees=>[[:id, {:primary_key=>true, :type=>:integer}], [:name, {:type=>:string}], [:kind, {:type=>:string}]],
-       :managers=>[[:id, {:type=>:integer}], [:num_staff, {:type=>:integer}]],
+       :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]
@@ -486,7 +486,7 @@ describe "class_table_inheritance plugin without sti_key with :alias option" do
 end
 
 describe "class_table_inheritance plugin with duplicate columns" do
-  it "should raise error" do
+  it "should raise error if no columns are explicitly ignored" do
     @db = Sequel.mock(:autoid=>proc{|sql| 1})
     def @db.supports_schema_parsing?() true end
     def @db.schema(table, opts={})
@@ -510,6 +510,56 @@ describe "class_table_inheritance plugin with duplicate columns" do
     end 
     proc{class ::Manager < Employee; end}.must_raise Sequel::Error
   end
+
+  describe "with certain sub-class columns ignored" 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}], [:kind, {:type=>:string}], [:updated_at, {:type=>:datetime}]],
+         :managers=>[[:id, {:type=>:integer}], [:num_staff, {:type=>:integer}], [:updated_at, {:type=>:datetime}], [:another_duplicate_column, {:type=>:integer}]],
+         :executives=>[[:id, {:type=>:integer}], [:num_managers, {:type=>:integer}], [:updated_at, {:type=>:datetime}], [:another_duplicate_column, {:type=>:integer}]],
+         }[table.is_a?(Sequel::Dataset) ? table.first_source_table : table]
+      end
+      @db.extend_datasets do
+        def columns
+          {[:employees]=>[:id, :name, :kind, :updated_at],
+           [:managers]=>[:id, :num_staff, :updated_at, :another_duplicate_column],
+           [:executives]=>[:id, :num_managers, :updated_at, :another_duplicate_column],
+           [:employees, :managers]=>[:id, :name, :kind, :updated_at, :num_staff],
+          }[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 || dataset.opts[:from].first.expression.columns
+        end
+        plugin :class_table_inheritance, :ignore_subclass_columns=>[:updated_at]
+      end 
+      class ::Manager < Employee
+        Manager.cti_ignore_subclass_columns.push(:another_duplicate_column)
+      end
+      class ::Executive < Manager; end
+    end
+
+    it "should not use the ignored column in a sub-class subquery" do
+      Employee.dataset.sql.must_equal 'SELECT * FROM employees'
+      Manager.dataset.sql.must_equal 'SELECT * FROM (SELECT employees.id, employees.name, employees.kind, employees.updated_at, managers.num_staff, managers.another_duplicate_column FROM employees INNER JOIN managers ON (managers.id = employees.id)) AS employees'
+      Executive.dataset.sql.must_equal 'SELECT * FROM (SELECT employees.id, employees.name, employees.kind, employees.updated_at, managers.num_staff, managers.another_duplicate_column, executives.num_managers FROM employees INNER JOIN managers ON (managers.id = employees.id) INNER JOIN executives ON (executives.id = managers.id)) AS employees'
+    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}, :kind=>{:type=>:string}, :updated_at=>{:type=>:datetime})
+      Manager.db_schema.must_equal(:id=>{:primary_key=>true, :type=>:integer}, :name=>{:type=>:string}, :kind=>{:type=>:string}, :updated_at=>{:type=>:datetime}, :num_staff=>{:type=>:integer}, :another_duplicate_column=>{:type=>:integer})
+      Executive.db_schema.must_equal(:id=>{:primary_key=>true, :type=>:integer}, :name=>{:type=>:string}, :kind=>{:type=>:string}, :updated_at=>{:type=>:datetime}, :num_staff=>{:type=>:integer}, :another_duplicate_column=>{:type=>:integer}, :num_managers=>{:type=>:integer})
+    end
+
+    after do
+      Object.send(:remove_const, :Executive)
+    end
+  end
+
   after do
     Object.send(:remove_const, :Manager)
     Object.send(:remove_const, :Employee)