sequel 4.38.0 → 4.39.0

data/lib/sequel/plugins/list.rb

@@ -94,7 +94,7 @@ module Sequel
         def after_destroy
           super
 
-          f = Sequel.expr(position_field)
+          f = Sequel[position_field]
           list_dataset.where(f > position_value).update(f => f - 1)
         end
 

data/lib/sequel/plugins/pg_array_associations.rb

@@ -491,14 +491,14 @@ module Sequel
           expr = case obj
           when Sequel::Model
             if (assoc_pks = obj.get_column_value(key)) && !assoc_pks.empty?
-              Sequel.expr(pk=>assoc_pks.to_a)
+              Sequel[pk=>assoc_pks.to_a]
             end
           when Array
             if (assoc_pks = obj.map{|o| o.get_column_value(key)}.flatten.compact.uniq) && !assoc_pks.empty?
-              Sequel.expr(pk=>assoc_pks)
+              Sequel[pk=>assoc_pks]
             end
           when Sequel::Dataset
-            Sequel.expr(pk=>obj.select{Sequel.pg_array_op(ref.qualify(obj.model.table_name, ref[:key_column])).unnest})
+            Sequel[pk=>obj.select{Sequel.pg_array_op(ref.qualify(obj.model.table_name, ref[:key_column])).unnest}]
           end
           expr = Sequel::SQL::Constants::FALSE unless expr
           expr = add_association_filter_conditions(ref, obj, expr)

data/lib/sequel/plugins/timestamps.rb

@@ -24,12 +24,14 @@ module Sequel
       # Configure the plugin by setting the available options.  Note that
       # if this method is run more than once, previous settings are ignored,
       # and it will just use the settings given or the default settings.  Options:
+      # :allow_manual_update :: Whether to skip setting the update timestamp if it has been modified manually (default: false)
       # :create :: The field to hold the create timestamp (default: :created_at)
       # :force :: Whether to overwrite an existing create timestamp (default: false)
       # :update :: The field to hold the update timestamp (default: :updated_at)
       # :update_on_create :: Whether to set the update timestamp to the create timestamp when creating (default: false)
       def self.configure(model, opts=OPTS)
         model.instance_eval do
+          @allow_manual_timestamp_update = opts[:allow_manual_update]||false
           @create_timestamp_field = opts[:create]||:created_at
           @update_timestamp_field = opts[:update]||:updated_at
           @create_timestamp_overwrite = opts[:force]||false
@@ -49,9 +51,19 @@ module Sequel
           @create_timestamp_overwrite
         end
         
-        Plugins.inherited_instance_variables(self, :@create_timestamp_field=>nil, :@update_timestamp_field=>nil,
-          :@create_timestamp_overwrite=>nil, :@set_update_timestamp_on_create=>nil)
+        Plugins.inherited_instance_variables(self,
+          :@allow_manual_timestamp_update=>nil,
+          :@create_timestamp_field=>nil,
+          :@create_timestamp_overwrite=>nil,
+          :@set_update_timestamp_on_create=>nil,
+          :@update_timestamp_field=>nil)
         
+        
+        # Whether to allow manual setting of the update timestamp when creating
+        def allow_manual_timestamp_update?
+          @allow_manual_timestamp_update
+        end
+
         # Whether to set the update timestamp to the create timestamp when creating
         def set_update_timestamp_on_create?
           @set_update_timestamp_on_create
@@ -88,6 +100,7 @@ module Sequel
         # Set the update timestamp to the time given or the current time if the
         # object has a setter method for the update timestamp field.
         def set_update_timestamp(time=nil)
+          return if model.allow_manual_timestamp_update? && modified?(model.update_timestamp_field)
           meth = :"#{model.update_timestamp_field}="
           set_column_value(meth, time||model.dataset.current_datetime) if respond_to?(meth)
         end

data/lib/sequel/plugins/touch.rb

@@ -78,6 +78,12 @@ module Sequel
       end
 
       module InstanceMethods
+        # Touch all of the model's touched_associations when creating the object.
+        def after_create
+          super
+          touch_associations
+        end
+
         # Touch all of the model's touched_associations when destroying the object.
         def after_destroy
           super

data/lib/sequel/sql.rb

@@ -465,6 +465,10 @@ module Sequel
       # to construct via other methods.  For example:
       #
       #   Sequel.expr(1) - :a # SQL: (1 - a)
+      #
+      # On the Sequel module, this is aliased as #[], for easier use:
+      #
+      #   Sequel[1] - :a # SQL: (1 - a)
       def expr(arg=(no_arg=true), &block)
         if block_given?
           if no_arg
@@ -793,7 +797,7 @@ module Sequel
       # If the argument given is Numeric, treat it as a NumericExpression,
       # allowing code such as:
       #
-      #   1 + Sequel.expr(:x) # SQL: (1 + x)
+      #   1 + Sequel[:x] # SQL: (1 + x)
       #   Sequel.expr{1 - x(y)} # SQL: (1 - x(y))
       def coerce(other)
         if other.is_a?(Numeric)
@@ -822,17 +826,17 @@ module Sequel
     # return when using a hash with a single entry, where the receiver was the key
     # and the argument was the value. Example:
     #
-    #   Sequel.expr(:a) =~ 1 # (a = 1)
-    #   Sequel.expr(:a) =~ [1, 2] # (a IN [1, 2])
-    #   Sequel.expr(:a) =~ nil # (a IS NULL)
+    #   Sequel[:a] =~ 1 # (a = 1)
+    #   Sequel[:a] =~ [1, 2] # (a IN [1, 2])
+    #   Sequel[:a] =~ nil # (a IS NULL)
     #
     # On Ruby 1.9+, this also adds the !~ method, for easily setting up not equals,
     # exclusion, and inverse pattern matching.  This is the same as as inverting the
     # result of the =~ method
     #
-    #   Sequel.expr(:a) !~ 1 # (a != 1)
-    #   Sequel.expr(:a) !~ [1, 2] # (a NOT IN [1, 2])
-    #   Sequel.expr(:a) !~ nil # (a IS NOT NULL)
+    #   Sequel[:a] !~ 1 # (a != 1)
+    #   Sequel[:a] !~ [1, 2] # (a NOT IN [1, 2])
+    #   Sequel[:a] !~ nil # (a IS NOT NULL)
     module PatternMatchMethods
       # Set up an equality, inclusion, or pattern match operation, based on the type
       # of the argument.
@@ -929,7 +933,7 @@ module Sequel
     module QualifyingMethods
       # If no arguments are given, return an SQL::ColumnAll:
       #
-      #   Sequel.expr(:a__b).*  # a.b.*
+      #   Sequel[:a__b].*  # a.b.*
       def *(ce=(arg=false;nil))
         if arg == false
           Sequel::SQL::ColumnAll.new(self)
@@ -940,8 +944,8 @@ module Sequel
 
       # Qualify the receiver with the given +qualifier+ (table for column/schema for table).
       #
-      #   Sequel.expr(:column).qualify(:table) # "table"."column"
-      #   Sequel.expr(:table).qualify(:schema) # "schema"."table"
+      #   Sequel[:column].qualify(:table) # "table"."column"
+      #   Sequel[:table].qualify(:schema) # "schema"."table"
       #   Sequel.qualify(:table, :column).qualify(:schema) # "schema"."table"."column"
       def qualify(qualifier)
         QualifiedIdentifier.new(qualifier, self)
@@ -1392,7 +1396,7 @@ module Sequel
       # Return a new function where the function name will not be quoted even
       # if the database supports quoted functions:
       #
-      #   Sequel.expr(:foo).function.unquoted # foo()
+      #   Sequel[:foo].function.unquoted # foo()
       def unquoted
         with_opts(:quoted=>false)
       end

data/lib/sequel/version.rb

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

data/spec/adapters/mysql_spec.rb

@@ -515,6 +515,24 @@ describe "A MySQL database" do
     end
   end
 
+  it "should correctly handle add_column :after option" do
+    @db.create_table(:items){Integer :id; Integer :value}
+    @db.alter_table(:items){add_column :name, String, :after=>:id}
+    @db[:items].columns.must_equal [:id, :name, :value]
+  end
+
+  it "should correctly handle add_column :first option" do
+    @db.create_table(:items){Integer :id; Integer :value}
+    @db.alter_table(:items){add_column :name, String, :first => true}
+    @db[:items].columns.must_equal [:name, :id, :value]
+  end
+
+  it "should correctly handle add_foreign_key :first option" do
+    @db.create_table(:items){primary_key :id; Integer :value}
+    @db.alter_table(:items){add_foreign_key :parent_id, :items, :first => true}
+    @db[:items].columns.must_equal [:parent_id, :id, :value]
+  end
+
   it "should have rename_column support keep existing options" do
     @db.create_table(:items){String :id, :null=>false, :default=>'blah'}
     @db.alter_table(:items){rename_column :id, :nid}

data/spec/adapters/postgres_spec.rb

@@ -204,6 +204,17 @@ describe "PostgreSQL", 'INSERT ON CONFLICT' do
     @ds.all.must_equal [{:a=>1, :b=>2, :c=>3}]
   end
 
+  it "Dataset#insert_ignore and insert_conflict should work with multi_insert/import" do
+    @ds.insert(1, 2, 3)
+    @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}]
+    @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}]
+    @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}]
+    end
+
   it "Dataset#insert_conflict should handle upserts" do
     @ds.insert(1, 2, 3)
     @ds.insert_conflict(:target=>:a, :update=>{:b=>3}).insert(1, 3, 4).must_equal nil
@@ -991,6 +1002,11 @@ describe "A PostgreSQL database" do
     @db[:posts].full_text_search(:title, 'rubinius ruby', :plain=>true).select_order_map(:title).must_equal ['jruby rubinius ruby maglev mri iron', 'ruby jruby maglev mri rubinius iron']
     @db[:posts].full_text_search(:title, 'jruby maglev', :plain=>true).select_order_map(:title).must_equal ['jruby rubinius ruby maglev mri iron', 'ruby jruby maglev mri rubinius iron']
 
+    if DB.server_version >= 90600
+      @db[:posts].full_text_search(:title, 'rubinius ruby', :to_tsquery=>:phrase).select_order_map(:title).must_equal ['jruby rubinius ruby maglev mri iron']
+      @db[:posts].full_text_search(:title, 'jruby maglev', :to_tsquery=>:phrase).select_order_map(:title).must_equal ['ruby jruby maglev mri rubinius iron']
+    end
+
     @db[:posts].full_text_search(Sequel.function(:to_tsvector, 'simple', :title), 'rails', :tsvector=>true).all.must_equal [{:title=>'ruby rails', :body=>'yowsa'}]
     @db[:posts].full_text_search(:title, Sequel.function(:to_tsquery, 'simple', 'rails'), :tsquery=>true).all.must_equal [{:title=>'ruby rails', :body=>'yowsa'}]
     proc{@db[:posts].full_text_search(Sequel.function(:to_tsvector, 'simple', :title), 'rubinius ruby', :tsvector=>true, :phrase=>true)}.must_raise(Sequel::Error)
@@ -1058,6 +1074,13 @@ describe "A PostgreSQL database" do
     @db.create_table!(:posts1){primary_key :a}
     @db.rename_table(:posts1, :posts)
   end
+
+  it "should adding a primary key only if it does not already exists" do
+    @db.create_table(:posts){Integer :a}
+    @db.alter_table(:posts){add_column :b, Integer}
+    @db.alter_table(:posts){add_column :b, Integer, :if_not_exists=>true}
+    proc{@db.alter_table(:posts){add_column :b, Integer}}.must_raise Sequel::DatabaseError
+  end if DB.server_version >= 90600
 end
 
 describe "Postgres::Dataset#import" do
@@ -1071,7 +1094,6 @@ describe "Postgres::Dataset#import" do
     @db.drop_table?(:test)
   end
 
-
   it "#import should a single insert statement" do
     @ds.import([:x, :y], [[1, 2], [3, 4]])
     check_sqls do
@@ -2916,6 +2938,13 @@ describe 'PostgreSQL json type' do
         @db.get(jo.set(%w'a', 'f'=>'g')['a']['f']).must_equal 'g'
       end
 
+      if DB.server_version >= 90600  && json_type == :jsonb
+        @db.get(pg_json.call([3]).op.insert(['0'], {'a'=>2})[0]['a']).must_equal 2
+        @db.get(pg_json.call([3]).op.insert(['0'], {'a'=>2}, false)[0]['a']).must_equal 2
+        @db.get(pg_json.call([3]).op.insert(['0'], {'a'=>2}, true)[0]).must_equal 3
+        @db.get(pg_json.call([3]).op.insert(['0'], {'a'=>2}, true)[1]['a']).must_equal 2
+      end
+
       @db.from(jo.keys.as(:k)).select_order_map(:k).must_equal %w'a b'
       @db.from(jo.each).select_order_map(:key).must_equal %w'a b'
       @db.from(jo.each).order(:key).select_map(:value).must_equal [1, {'c'=>2, 'd'=>{'e'=>3}}]

data/spec/core/database_spec.rb

@@ -834,6 +834,35 @@ DatabaseTransactionSpecs = shared_description do
     @db.in_transaction?.must_equal false
   end
   
+  it "should have rollback_checker return a proc which returns whether the transaction was rolled back" do
+    proc{@db.rollback_checker}.must_raise Sequel::Error
+    proc{@db.transaction(:server=>:test){@db.rollback_checker}}.must_raise Sequel::Error
+
+    rbc = nil
+    @db.transaction do 
+      rbc = @db.rollback_checker
+      rbc.call.must_equal nil
+    end
+    rbc.call.must_equal false
+
+    @db.transaction(:rollback=>:always) do 
+      rbc = @db.rollback_checker
+      rbc.call.must_equal nil
+    end
+    rbc.call.must_equal true
+
+    proc do
+      @db.transaction do 
+        rbc = @db.rollback_checker
+        raise
+      end
+    end.must_raise RuntimeError
+    rbc.call.must_equal true
+
+    @db.transaction(:server=>:test){rbc = @db.rollback_checker(:server=>:test)}
+    rbc.call.must_equal false
+  end
+  
   it "should return nil if Sequel::Rollback is called in the transaction" do
     @db.transaction{raise Sequel::Rollback}.must_equal nil
   end

data/spec/core/mock_adapter_spec.rb

@@ -7,6 +7,37 @@ describe "Sequel Mock Adapter" do
     db.adapter_scheme.must_equal :mock
   end
 
+  it "should support registering mock adapter type" do
+    begin
+      mod = Module.new do
+        Sequel::Database.set_shared_adapter_scheme(:foo, self)
+        
+        def self.mock_adapter_setup(db)
+          db.instance_variable_set(:@foo, :foo)
+        end
+
+        module self::DatabaseMethods
+          def foo
+            @foo
+          end
+        end
+
+        module self::DatasetMethods
+          def foo
+            db.foo
+          end
+        end
+      end
+
+      Sequel.connect('mock://foo') do |db|
+        db.foo.must_equal :foo
+        db.dataset.foo.must_equal :foo
+      end
+    ensure
+      Sequel.synchronize{Sequel::SHARED_ADAPTER_MAP.delete(:foo)}
+    end
+  end
+
   it "should have constructor accept no arguments" do
     Sequel::Mock::Database.new.must_be_kind_of(Sequel::Mock::Database)
   end
@@ -443,7 +474,7 @@ describe "Sequel Mock Adapter" do
     end
   end
 
-  it "should automatically set version for adapters nedding versions" do
+  it "should automatically set version for adapters needing versions" do
     Sequel.mock(:host=>'postgres').server_version.must_be :>=, 90400
     Sequel.mock(:host=>'mssql').server_version.must_be :>=, 11000000
     Sequel.mock(:host=>'mysql').server_version.must_be :>=, 50617

data/spec/extensions/migration_spec.rb

@@ -319,6 +319,52 @@ describe "Sequel::IntegerMigrator" do
     @db.dataset.columns.must_equal [:sic]
   end
   
+  it "should support :relative option for running relative migrations" do
+    Sequel::Migrator.run(@db, @dirname, :relative=>2).must_equal 2
+    @db.creates.must_equal [1111, 2222]
+    @db.version.must_equal 2
+    @db.sqls.map{|x| x =~ /\AUPDATE.*(\d+)/ ? $1.to_i : nil}.compact.must_equal [1, 2]
+
+    Sequel::Migrator.run(@db, @dirname, :relative=>-1).must_equal 1
+    @db.drops.must_equal [2222]
+    @db.version.must_equal 1
+    @db.sqls.map{|x| x =~ /\AUPDATE.*(\d+)/ ? $1.to_i : nil}.compact.must_equal [1]
+
+    Sequel::Migrator.run(@db, @dirname, :relative=>2).must_equal 3
+    @db.creates.must_equal [1111, 2222, 2222, 3333]
+    @db.version.must_equal 3
+    @db.sqls.map{|x| x =~ /\AUPDATE.*(\d+)/ ? $1.to_i : nil}.compact.must_equal [2, 3]
+
+    Sequel::Migrator.run(@db, @dirname, :relative=>-3).must_equal 0
+    @db.drops.must_equal [2222, 3333, 2222, 1111]
+    @db.version.must_equal 0
+    @db.sqls.map{|x| x =~ /\AUPDATE.*(\d+)/ ? $1.to_i : nil}.compact.must_equal [2, 1, 0]
+  end
+  
+  it "should handle :relative option beyond the upper and lower limit" do
+    Sequel::Migrator.run(@db, @dirname, :relative=>100).must_equal 3
+    @db.creates.must_equal [1111, 2222, 3333]
+    @db.version.must_equal 3
+    @db.sqls.map{|x| x =~ /\AUPDATE.*(\d+)/ ? $1.to_i : nil}.compact.must_equal [1, 2, 3]
+
+    Sequel::Migrator.run(@db, @dirname, :relative=>-200).must_equal 0
+    @db.drops.must_equal [3333, 2222, 1111]
+    @db.version.must_equal 0
+    @db.sqls.map{|x| x =~ /\AUPDATE.*(\d+)/ ? $1.to_i : nil}.compact.must_equal [2, 1, 0]
+  end
+
+  it "should correctly handle migration target versions beyond the upper and lower limits" do
+    Sequel::Migrator.run(@db, @dirname, :target=>100).must_equal 3
+    @db.creates.must_equal [1111, 2222, 3333]
+    @db.version.must_equal 3
+    @db.sqls.map{|x| x =~ /\AUPDATE.*(\d+)/ ? $1.to_i : nil}.compact.must_equal [1, 2, 3]
+
+    Sequel::Migrator.run(@db, @dirname, :target=>-100).must_equal 0
+    @db.drops.must_equal [3333, 2222, 1111]
+    @db.version.must_equal 0
+    @db.sqls.map{|x| x =~ /\AUPDATE.*(\d+)/ ? $1.to_i : nil}.compact.must_equal [2, 1, 0]
+  end
+  
   it "should apply migrations correctly in the up direction if no target is given" do
     Sequel::Migrator.apply(@db, @dirname)
     @db.creates.must_equal [1111, 2222, 3333]

data/spec/extensions/pg_interval_spec.rb

@@ -15,6 +15,7 @@ describe "pg_interval extension" do
     @db.literal(ActiveSupport::Duration.new(0, [])).must_equal "'0'::interval"
     @db.literal(ActiveSupport::Duration.new(0, [[:seconds, 0]])).must_equal "'0'::interval"
     @db.literal(ActiveSupport::Duration.new(0, [[:seconds, 10], [:minutes, 20], [:days, 3], [:months, 4], [:years, 6]])).must_equal "'6 years 4 months 3 days 20 minutes 10 seconds '::interval"
+    @db.literal(ActiveSupport::Duration.new(0, [[:seconds, 10], [:minutes, 20], [:hours, 8], [:days, 3], [:weeks, 2], [:months, 4], [:years, 6]])).must_equal "'6 years 4 months 2 weeks 3 days 8 hours 20 minutes 10 seconds '::interval"
     @db.literal(ActiveSupport::Duration.new(0, [[:seconds, -10.000001], [:minutes, -20], [:days, -3], [:months, -4], [:years, -6]])).must_equal "'-6 years -4 months -3 days -20 minutes -10.000001 seconds '::interval"
   end
 

data/spec/extensions/pg_json_ops_spec.rb

@@ -190,6 +190,19 @@ describe "Sequel::Postgres::JSONOp" do
     @l[@jb.concat([1, 2])].must_equal "(j || '[1,2]'::jsonb)"
   end
 
+  it "#insert should use the jsonb_insert function" do
+    @l[@jb.insert(:a, :h)].must_equal "jsonb_insert(j, a, h, false)"
+    @l[@jb.insert(:a, :h, true)].must_equal "jsonb_insert(j, a, h, true)"
+  end
+
+  it "#insert should handle hashes" do
+    @l[@jb.insert(:a, 'a'=>'b')].must_equal "jsonb_insert(j, a, '{\"a\":\"b\"}'::jsonb, false)"
+  end
+
+  it "#insert should handle arrays" do
+    @l[@jb.insert(%w'a b', [1, 2])].must_equal "jsonb_insert(j, ARRAY['a','b'], '[1,2]'::jsonb, false)"
+  end
+
   it "#set should use the jsonb_set function" do
     @l[@jb.set(:a, :h)].must_equal "jsonb_set(j, a, h, true)"
     @l[@jb.set(:a, :h, false)].must_equal "jsonb_set(j, a, h, false)"

data/spec/extensions/timestamps_spec.rb

@@ -50,6 +50,17 @@ describe "Sequel::Plugins::Timestamps" do
     o.updated_at.must_equal '2009-08-01'
   end
 
+  it "should leave manually set update timestamp, if :allow_manual_update was given" do
+    o = @c.load(:id=>1).update(:updated_at=>Date.new(2016))
+    @c.db.sqls.must_equal ["UPDATE t SET updated_at = '2009-08-01' WHERE (id = 1)"]
+    o.updated_at.must_equal '2009-08-01'
+
+    @c.plugin :timestamps, :allow_manual_update=>true
+    o = @c.load(:id=>1).update(:updated_at=>Date.new(2016))
+    @c.db.sqls.must_equal ["UPDATE t SET updated_at = '2016-01-01' WHERE (id = 1)"]
+    o.updated_at.must_equal Date.new(2016)
+  end
+
   it "should work with current_datetime_timestamp extension" do
     Sequel.datetime_class = Time
     @c.dataset = @c.dataset.extension(:current_datetime_timestamp)

data/spec/extensions/touch_spec.rb

@@ -127,6 +127,14 @@ describe "Touch plugin" do
   end
 
   it "should be able to touch many_to_one associations" do
+    @Album.plugin :touch, :associations=>:artist
+    @Album.plugin :skip_create_refresh
+    @Album.create(:artist_id=>4)
+    DB.sqls.must_equal ["INSERT INTO albums (artist_id) VALUES (4)",
+      "UPDATE artists SET updated_at = CURRENT_TIMESTAMP WHERE (artists.id = 4)"]
+  end
+
+  it "should be able to touch one_to_one associations" do
     @Artist.one_to_one :album, :class=>@Album, :key=>:artist_id
     @Artist.plugin :touch, :associations=>:album
     @a.touch