sequel 5.6.0 → 5.7.0

data/lib/sequel/connection_pool/threaded.rb

@@ -134,25 +134,25 @@ class Sequel::ThreadedConnectionPool < Sequel::ConnectionPool
       return conn
     end
 
-    time = Time.now
+    timeout = @timeout
+    timer = Sequel.start_timer
 
     sync do
-      @waiter.wait(@mutex, @timeout)
+      @waiter.wait(@mutex, timeout)
       if conn = next_available
         return(@allocated[thread] = conn)
       end
     end
 
     until conn = assign_connection(thread)
-      deadline ||= time + @timeout
-      current_time = Time.now
-      raise_pool_timeout(current_time - time) if current_time > deadline
+      elapsed = Sequel.elapsed_seconds_since(timer)
+      raise_pool_timeout(elapsed) if elapsed > timeout
 
       # :nocov:
       # It's difficult to get to this point, it can only happen if there is a race condition
       # where a connection cannot be acquired even after the thread is signalled by the condition
       sync do
-        @waiter.wait(@mutex, deadline - current_time)
+        @waiter.wait(@mutex, timeout - elapsed)
         if conn = next_available
           return(@allocated[thread] = conn)
         end

data/lib/sequel/core.rb

@@ -303,6 +303,26 @@ module Sequel
     @single_threaded ? yield : @data_mutex.synchronize(&block)
   end
 
+  if RUBY_VERSION >= '2.1'
+    # A timer object that can be passed to Sequel.elapsed_seconds_since
+    # to return the number of seconds elapsed.
+    def self.start_timer
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+  else
+    # :nocov:
+    def self.start_timer # :nodoc:
+      Time.now
+    end
+    # :nocov:
+  end
+
+  # The elapsed seconds since the given timer object was created.  The
+  # timer object should have been created via Sequel.start_timer.
+  def self.elapsed_seconds_since(timer)
+    start_timer - timer
+  end
+
   # Uses a transaction on all given databases with the given options. This:
   #
   #   Sequel.transaction([DB1, DB2, DB3]){}

data/lib/sequel/database/logging.rb

@@ -37,14 +37,15 @@ module Sequel
     def log_connection_yield(sql, conn, args=nil)
       return yield if @loggers.empty?
       sql = "#{connection_info(conn) if conn && log_connection_info}#{sql}#{"; #{args.inspect}" if args}"
-      start = Time.now
+      timer = Sequel.start_timer
+
       begin
         yield
       rescue => e
         log_exception(e, sql)
         raise
       ensure
-        log_duration(Time.now - start, sql) unless e
+        log_duration(Sequel.elapsed_seconds_since(timer), sql) unless e
       end
     end
 

data/lib/sequel/database/schema_generator.rb

@@ -263,8 +263,7 @@ module Sequel
       # 
       # Examples:
       #   primary_key(:id)
-      #   primary_key(:id, Bigint)
-      #   primary_key(:id, Bigint, keep_order: true)
+      #   primary_key(:id, type: :Bignum, keep_order: true)
       #   primary_key([:street_number, :house_number], name: :some constraint_name)
       def primary_key(name, *args)
         return composite_primary_key(name, *args) if name.is_a?(Array)

data/lib/sequel/dataset/actions.rb

@@ -929,14 +929,11 @@ module Sequel
     alias with_sql_update with_sql_delete
 
     # Run the given SQL and yield each returned row to the block.
-    #
-    # This method should not be called on a shared dataset if the columns selected
-    # in the given SQL do not match the columns in the receiver.
     def with_sql_each(sql)
       if rp = row_proc
-        fetch_rows(sql){|r| yield rp.call(r)}
+        _with_sql_dataset.fetch_rows(sql){|r| yield rp.call(r)}
       else
-        fetch_rows(sql){|r| yield r}
+        _with_sql_dataset.fetch_rows(sql){|r| yield r}
       end
       self
     end
@@ -1219,5 +1216,18 @@ module Sequel
         c
       end
     end
+
+    # Cached dataset to use for with_sql_#{all,each,first,single_value}.
+    # This is used so that the columns returned by the given SQL do not
+    # affect the receiver of the with_sql_* method.
+    def _with_sql_dataset
+      if @opts[:_with_sql_ds]
+        self
+      else
+        cached_dataset(:_with_sql_ds) do
+          clone(:_with_sql_ds=>true)
+        end
+      end
+    end
   end
 end

data/lib/sequel/extensions/connection_expiration.rb

@@ -59,7 +59,7 @@ module Sequel
     # Record the time the connection was created.
     def make_new(*)
       conn = super
-      @connection_expiration_timestamps[conn] = Time.now
+      @connection_expiration_timestamps[conn] = Sequel.start_timer
       conn
     end
 
@@ -69,8 +69,8 @@ module Sequel
     def acquire(*a)
       begin
         if (conn = super) &&
-           (t = sync{@connection_expiration_timestamps[conn]}) &&
-           Time.now - t > @connection_expiration_timeout
+           (timer = sync{@connection_expiration_timestamps[conn]}) &&
+           Sequel.elapsed_seconds_since(timer) > @connection_expiration_timeout
 
           if pool_type == :sharded_threaded
             sync{allocated(a.last).delete(Thread.current)}

data/lib/sequel/extensions/connection_validator.rb

@@ -79,7 +79,7 @@ module Sequel
     # Record the time the connection was checked back into the pool.
     def checkin_connection(*)
       conn = super
-      @connection_timestamps[conn] = Time.now
+      @connection_timestamps[conn] = Sequel.start_timer
       conn
     end
 
@@ -96,8 +96,8 @@ module Sequel
     def acquire(*a)
       begin
         if (conn = super) &&
-           (t = sync{@connection_timestamps.delete(conn)}) &&
-           Time.now - t > @connection_validation_timeout &&
+           (timer = sync{@connection_timestamps.delete(conn)}) &&
+           Sequel.elapsed_seconds_since(timer) > @connection_validation_timeout &&
            !db.valid_connection?(conn)
 
           if pool_type == :sharded_threaded

data/lib/sequel/extensions/integer64.rb

@@ -0,0 +1,30 @@
+# frozen-string-literal: true
+#
+# The integer64 extension changes the default type used for Integer
+# to be the same type as used for :Bignum.  In general, this means that
+# instead of Integer resulting in a 32-bit database integer type, it will
+# result in a 64-bit database integer type.  This affects the default
+# type used for primary_key and foreign_key when using the schema
+# modification methods.
+#
+# Note that it doesn't make sense to use this extension on SQLite, since
+# the integer type will automatically handle 64-bit integers, and it treats
+# the integer type specially when the column is also the primary key.
+# 
+# To load the extension into the database:
+#
+#   DB.extension :integer64
+#
+# Related module: Sequel::Integer64
+
+#
+module Sequel
+  module Integer64
+    # Use timestamptz by default for generic timestamp value.
+    def type_literal_generic_integer(column)
+      type_literal_generic_bignum_symbol(column)
+    end
+  end
+
+  Database.register_extension(:integer64, Integer64)
+end

data/lib/sequel/extensions/migration.rb

@@ -548,13 +548,13 @@ module Sequel
     # Apply all migrations on the database
     def run
       migrations.zip(version_numbers).each do |m, v|
-        t = Time.now
+        timer = Sequel.start_timer
         db.log_info("Begin applying migration version #{v}, direction: #{direction}")
         checked_transaction(m) do
           m.apply(db, direction)
           set_migration_version(up? ? v : v-1)
         end
-        db.log_info("Finished applying migration version #{v}, direction: #{direction}, took #{sprintf('%0.6f', Time.now - t)} seconds")
+        db.log_info("Finished applying migration version #{v}, direction: #{direction}, took #{sprintf('%0.6f', Sequel.elapsed_seconds_since(timer))} seconds")
       end
       
       target
@@ -736,7 +736,6 @@ module Sequel
     def get_migration_tuples
       up_mts = []
       down_mts = []
-      ms = Migration.descendants
       files.each do |path|
         f = File.basename(path)
         fi = f.downcase

data/lib/sequel/plugins/pg_array_associations.rb

@@ -80,7 +80,7 @@ module Sequel
         def array_type
           cached_fetch(:array_type) do
             if (sch = associated_class.db_schema) && (s = sch[self[:key]]) && (t = s[:db_type])
-              t
+              t.sub(/\[\]\z/, '').freeze
             else
               :integer
             end
@@ -189,7 +189,7 @@ module Sequel
         def array_type
           cached_fetch(:array_type) do
             if (sch = self[:model].db_schema) && (s = sch[self[:key]]) && (t = s[:db_type])
-              t
+              t.sub(/\[\]\z/, '').freeze
             else
               :integer
             end
@@ -400,7 +400,9 @@ module Sequel
           end
 
           opts[:clearer] ||= proc do
-            opts.associated_dataset.where(Sequel.pg_array_op(key).contains([get_column_value(pk)])).update(key=>Sequel.function(:array_remove, key, get_column_value(pk)))
+            pk_value = get_column_value(pk)
+            db_type = opts.array_type
+            opts.associated_dataset.where(Sequel.pg_array_op(key).contains(Sequel.pg_array([pk_value], db_type))).update(key=>Sequel.function(:array_remove, key, Sequel.cast(pk_value, db_type)))
           end
         end
 

data/lib/sequel/plugins/validate_associated.rb

@@ -16,6 +16,24 @@ module Sequel
     #
     #   # Make the Album class support validating associated objects
     #   Album.plugin :validate_associated
+    #
+    #   class Album
+    #     many_to_one :artist
+    #     many_to_many :tags
+    #
+    #     # Always validate associated artist when saving the album
+    #     def validate
+    #       super
+    #       if artist
+    #         validate_associated_object(model.association_reflection(:artist), artist)
+    #       end
+    #     end
+    #
+    #     # When saving after calling this method, validate the given tag as well.
+    #     def check_tag!(tag)
+    #       delay_validate_associated_object(model.association_reflection(:tags), tag)
+    #     end
+    #   end
     module ValidateAssociated
       # Depend on the instance_hooks plugin.
       def self.apply(mod)

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 = 6
+  MINOR = 7
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.
   TINY  = 0

data/spec/adapters/mssql_spec.rb

@@ -636,18 +636,18 @@ describe "Database#foreign_key_list" do
   before(:all) do
     DB.create_table! :items do
       primary_key :id
-      integer     :sku
+      Integer     :sku
     end
     DB.create_table! :prices do
-      integer     :item_id
+      Integer     :item_id
       datetime    :valid_from
       float       :price
       primary_key [:item_id, :valid_from]
       foreign_key [:item_id], :items, :key => :id, :name => :fk_prices_items
     end
     DB.create_table! :sales do
-      integer  :id
-      integer  :price_item_id
+      Integer  :id
+      Integer  :price_item_id
       datetime :price_valid_from
       foreign_key [:price_item_id, :price_valid_from], :prices, :key => [:item_id, :valid_from], :name => :fk_sales_prices, :on_delete => :cascade
     end
@@ -682,8 +682,8 @@ describe "Database#foreign_key_list" do
         varchar     :name
       end
       DB.create_table! Sequel[:vendor][:mapping] do
-        integer :vendor_id
-        integer :item_id
+        Integer :vendor_id
+        Integer :item_id
         foreign_key [:vendor_id], Sequel[:vendor][:vendors], :name => :fk_mapping_vendor
         foreign_key [:item_id], :items, :name => :fk_mapping_item
       end

data/spec/adapters/mysql_spec.rb

@@ -274,7 +274,7 @@ describe "A MySQL database" do
     @db = DB
     @db.create_table! :test2 do
       text :name
-      integer :value
+      Integer :value
     end
   end
   after(:all) do

data/spec/adapters/oracle_spec.rb

@@ -113,7 +113,7 @@ describe "An Oracle database" do
   it "should create a temporary table" do
     DB.create_table! :test_tmp, :temp => true do
       varchar2 :name, :size => 50
-      primary_key :id, :integer, :null => false
+      primary_key :id, :null => false
       index :name, :unique => true
     end
     DB.drop_table?(:test_tmp)
@@ -311,3 +311,17 @@ describe "An Oracle database" do
     DB[:books].select(:title).group_by(:title).count.must_equal 2
   end
 end
+
+describe "An Oracle database with xml types" do
+  before(:all) do
+    DB.create_table!(:xml_test){xmltype :xml_col}
+  end
+  after(:all) do
+    DB.drop_table(:xml_test)
+  end
+
+  it "should work correctly with temporary clobs" do
+    DB[:xml_test].insert("<a href='b'>c</a>")
+    DB.from(Sequel.lit('xml_test x')).select(Sequel.lit("x.xml_col.getCLOBVal() v")).all.must_equal [{:v=>"<a href=\"b\">c</a>\n"}]
+  end
+end

data/spec/adapters/postgres_spec.rb

@@ -107,6 +107,83 @@ describe "PostgreSQL", '#create_table' do
     end
   end if DB.server_version >= 90000
 
+  it "should support creating identity columns on non-primary key tables" do
+    @db.create_table(:tmp_dolls){Integer :a, :identity=>true}
+    2.times do
+      @db[:tmp_dolls].insert
+    end
+    @db[:tmp_dolls].select_order_map(:a).must_equal [1, 2]
+    @db[:tmp_dolls].insert(:a=>2)
+    @db[:tmp_dolls].select_order_map(:a).must_equal [1, 2, 2]
+    @db[:tmp_dolls].insert(:a=>4)
+    @db[:tmp_dolls].select_order_map(:a).must_equal [1, 2, 2, 4]
+    @db[:tmp_dolls].overriding_user_value.insert(:a=>5)
+    @db[:tmp_dolls].select_order_map(:a).must_equal [1, 2, 2, 3, 4]
+  end if DB.server_version >= 100002
+
+  it "should support creating identity columns generated always" do
+    @db.create_table(:tmp_dolls){primary_key :id, :identity=>:always}
+    2.times do
+      @db[:tmp_dolls].insert
+    end
+    @db[:tmp_dolls].select_order_map(:id).must_equal [1, 2]
+    proc{@db[:tmp_dolls].insert(:id=>2)}.must_raise Sequel::DatabaseError
+    @db[:tmp_dolls].overriding_system_value.insert(:id=>4)
+    @db[:tmp_dolls].select_order_map(:id).must_equal [1, 2, 4]
+    @db[:tmp_dolls].insert
+    @db[:tmp_dolls].select_order_map(:id).must_equal [1, 2, 3, 4]
+  end if DB.server_version >= 100002
+
+  it "should support converting serial columns to identity columns" do
+    @db.create_table(:tmp_dolls){primary_key :id, :identity=>false, :serial=>true}
+    sch = @db.schema(:tmp_dolls)[0][1]
+    sch[:default].must_match(/nextval/)
+    sch[:auto_increment].must_equal true
+
+    2.times do
+      @db[:tmp_dolls].insert
+    end
+
+    @db.convert_serial_to_identity(:tmp_dolls)
+    sch = @db.schema(:tmp_dolls)[0][1]
+    sch[:default].must_be_nil
+    sch[:auto_increment].must_equal true
+
+    @db[:tmp_dolls].insert
+    @db[:tmp_dolls].insert(5)
+    @db[:tmp_dolls].select_order_map(:id).must_equal [1, 2, 3, 5]
+
+    # Make sure it doesn't break if already converted
+    @db.convert_serial_to_identity(:tmp_dolls)
+  end if DB.server_version >= 100002 && DB.get{current_setting('is_superuser')} == 'on'
+
+  it "should support converting serial columns to identity columns when using the :column option" do
+    @db.create_table(:tmp_dolls){Integer :i, :primary_key=>true; serial :id}
+    sch = @db.schema(:tmp_dolls)[1][1]
+    sch[:default].must_match(/nextval/)
+
+    2.times do |i|
+      @db[:tmp_dolls].insert(:i=>-i)
+    end
+
+    # Automatic conversion should not work
+    proc{@db.convert_serial_to_identity(:tmp_dolls)}.must_raise Sequel::Error
+
+    # Conversion of type without related sequence should not work
+    proc{@db.convert_serial_to_identity(:tmp_dolls, :column=>:i)}.must_raise Sequel::Error
+
+    @db.convert_serial_to_identity(:tmp_dolls, :column=>:id)
+    sch = @db.schema(:tmp_dolls)[1][1]
+    sch[:default].must_be_nil
+
+    @db[:tmp_dolls].insert(:i=>200)
+    @db[:tmp_dolls].insert(:i=>300, :id=>5)
+    @db[:tmp_dolls].select_order_map(:id).must_equal [1, 2, 3, 5]
+
+    # Make sure it doesn't break if already converted
+    @db.convert_serial_to_identity(:tmp_dolls, :column=>:id)
+  end if DB.server_version >= 100002 && DB.get{current_setting('is_superuser')} == 'on'
+
   it "should support pg_loose_count extension" do
     @db.extension :pg_loose_count
     @db.create_table(:tmp_dolls){text :name}
@@ -324,7 +401,7 @@ describe "A PostgreSQL database" do
   end
 
   it "should correctly parse the schema" do
-    @db.schema(Sequel[:public][:testfk], :reload=>true).map{|c,s| [c, s[:oid]]}.must_equal [[:id, 23], [:i, 23]]
+    [[[:id, 23], [:i, 23]], [[:id, 20], [:i, 20]]].must_include @db.schema(Sequel[:public][:testfk], :reload=>true).map{|c,s| [c, s[:oid]]}
   end
 
   it "should parse foreign keys for tables in a schema" do