sequel 4.26.0 → 4.29.0

data/lib/sequel/plugins/uuid.rb

@@ -0,0 +1,72 @@
+require 'securerandom'
+
+module Sequel
+  module Plugins
+    # The uuid plugin creates hooks that automatically create a uuid for every
+    # instance.  Note that this uses SecureRandom.uuid to create UUIDs, and
+    # that method is not defined on ruby 1.8.7.  If you would like to use this
+    # on ruby 1.8.7, you need to override the Model#create_uuid private method
+    # to return a valid uuid.
+    # 
+    # Usage:
+    #
+    #   # Uuid all model instances using +uuid+
+    #   # (called before loading subclasses)
+    #   Sequel::Model.plugin :uuid
+    #
+    #   # Uuid Album instances, with custom column name
+    #   Album.plugin :uuid, :field=>my_uuid
+    module Uuid
+      # 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:
+      # :field :: The field to hold the uuid (default: :uuid)
+      # :force :: Whether to overwrite an existing uuid (default: false)
+      def self.configure(model, opts=OPTS)
+        model.instance_eval do
+          @uuid_field = opts[:field]||:uuid
+          @uuid_overwrite = opts[:force]||false
+        end
+      end
+
+      module ClassMethods
+        # The field to store the uuid
+        attr_reader :uuid_field
+        
+        # Whether to overwrite the create uuid if it already exists
+        def uuid_overwrite?
+          @uuid_overwrite
+        end
+        
+        Plugins.inherited_instance_variables(self, :@uuid_field=>nil, :@uuid_overwrite=>nil)
+      end
+
+      module InstanceMethods
+        private
+        
+        # Set the uuid when creating
+        def _before_validation
+          set_uuid if new?
+          super
+        end
+
+        # Create a new UUID.  This method can be overridden to use a separate
+        # method for creating UUIDs.  Note that this method does not work on
+        # ruby 1.8.7, you will have to override it if you are using ruby 1.8.7.
+        def create_uuid
+          SecureRandom.uuid
+        end
+        
+        # If the object has accessor methods for the uuid field, and the uuid
+        # value is nil or overwriting it is allowed, set the uuid.
+        def set_uuid(uuid=create_uuid)
+          field = model.uuid_field
+          meth = :"#{field}="
+          if respond_to?(field) && respond_to?(meth) && (model.uuid_overwrite? || get_column_value(field).nil?)
+            set_column_value(meth, uuid)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sequel/version.rb

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

@@ -20,6 +20,7 @@ end
 describe "PostgreSQL", '#create_table' do
   before do
     @db = DB
+    @db.test_connection
     DB.sqls.clear
   end
   after do
@@ -986,7 +987,7 @@ describe "A PostgreSQL database" do
     t2 = "ruby sequel " * 1000
     @db[:posts].insert(:title=>t1)
     @db[:posts].insert(:title=>t2)
-    @db[:posts].full_text_search(:title, 'ruby & sequel', :rank=>true).select_map(:title).must_equal [t1, t2]
+    @db[:posts].full_text_search(:title, 'ruby & sequel', :rank=>true).select_map(:title).must_equal [t2, t1]
   end
 
   it "should support spatial indexes" do
@@ -2868,6 +2869,15 @@ describe 'PostgreSQL json type' do
         end
       end
 
+      if DB.server_version >= 90500  && json_type == :jsonb
+        @db.get(pg_json.call([nil, 2]).op.strip_nulls[1]).must_equal 2
+        @db.get(pg_json.call([nil, 2]).op.pretty).must_equal "[\n    null,\n    2\n]"
+        @db.from((jo - 'b').keys.as(:k)).select_order_map(:k).must_equal %w'a'
+        @db.from(jo.delete_path(['b','c'])['b'].keys.as(:k)).select_order_map(:k).must_equal %w'd'
+        @db.from(jo.concat('c'=>'d').keys.as(:k)).select_order_map(:k).must_equal %w'a b c'
+        @db.get(jo.set(%w'a', 'f'=>'g')['a']['f']).must_equal 'g'
+      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/bin_spec.rb

@@ -203,6 +203,10 @@ END
     bin(:args=>'-S foo -C', :stderr=>true).must_equal "Error: Cannot specify -S and -C together\n"
   end
 
+  it "should warn if providing too many arguments" do
+    bin(:args=>'-c "" "" 1 2 3 4', :stderr=>true).must_equal "Warning: last 5 arguments ignored\n"
+  end
+
   it "should use a mock database if no database is given" do
     bin(:args=>'-c "print DB.adapter_scheme"', :no_conn=>true).must_equal "mock"
   end

data/spec/core/database_spec.rb

@@ -614,6 +614,17 @@ describe "Database#table_exists?" do
     db.table_exists?(:b).must_equal true
     db.table_exists?(:c).must_equal true
   end
+
+  it "should use a savepoint if inside a transaction" do
+    db = Sequel.mock(:fetch=>[Sequel::Error, [], [{:a=>1}]])
+    def db.supports_savepoints?; true end
+    db.transaction do
+      db.table_exists?(:a).must_equal false
+    end
+    db.sqls.must_equal ["BEGIN", "SAVEPOINT autopoint_1", "SELECT NULL AS nil FROM a LIMIT 1", "ROLLBACK TO SAVEPOINT autopoint_1", "COMMIT"]
+    db.table_exists?(:b).must_equal true
+    db.table_exists?(:c).must_equal true
+  end
 end
 
 DatabaseTransactionSpecs = shared_description do
@@ -964,6 +975,30 @@ describe "Database#transaction with savepoint support" do
 
   include DatabaseTransactionSpecs
 
+  it "should support :retry_on option for automatically retrying transactions when using :savepoint option" do
+    a = []
+    @db.transaction do
+      @db.transaction(:retry_on=>Sequel::SerializationFailure, :savepoint=>true) do
+        a << 1
+        raise Sequel::SerializationFailure if a.length == 1
+      end
+    end
+    @db.sqls.must_equal ["BEGIN", "SAVEPOINT autopoint_1", "ROLLBACK TO SAVEPOINT autopoint_1", "SAVEPOINT autopoint_1", "RELEASE SAVEPOINT autopoint_1", "COMMIT"]
+    a.must_equal [1, 1]
+  end
+  
+  it "should support :retry_on option for automatically retrying transactions inside an :auto_savepoint transaction" do
+    a = []
+    @db.transaction(:auto_savepoint=>true) do
+      @db.transaction(:retry_on=>Sequel::SerializationFailure) do
+        a << 1
+        raise Sequel::SerializationFailure if a.length == 1
+      end
+    end
+    @db.sqls.must_equal ["BEGIN", "SAVEPOINT autopoint_1", "ROLLBACK TO SAVEPOINT autopoint_1", "SAVEPOINT autopoint_1", "RELEASE SAVEPOINT autopoint_1", "COMMIT"]
+    a.must_equal [1, 1]
+  end
+  
   it "should support after_commit inside savepoints" do
     @db.transaction do
       @db.after_commit{@db.execute('foo')}

data/spec/core/dataset_spec.rb

@@ -2728,6 +2728,23 @@ describe "Dataset#single_record" do
   end
 end
 
+describe "Dataset#single_record!" do
+  before do
+    @db = Sequel.mock
+  end
+  
+  it "should call each and return the first record" do
+    @db.fetch = [{:a=>1}, {:a=>2}]
+    @db[:test].single_record!.must_equal(:a=>1)
+    @db.sqls.must_equal ['SELECT * FROM test']
+  end
+  
+  it "should return nil if no record is present" do
+    @db[:test].single_record!.must_equal nil
+    @db.sqls.must_equal ['SELECT * FROM test']
+  end
+end
+
 describe "Dataset#single_value" do
   before do
     @db = Sequel.mock
@@ -2752,6 +2769,23 @@ describe "Dataset#single_value" do
   end
 end
 
+describe "Dataset#single_value!" do
+  before do
+    @db = Sequel.mock
+  end
+  
+  it "should call each and return the first value of the first record" do
+    @db.fetch = [{:a=>1, :b=>2}, {:a=>3, :b=>4}]
+    @db[:test].single_value!.to_s.must_match /\A(1|2)\z/
+    @db.sqls.must_equal ['SELECT * FROM test']
+  end
+  
+  it "should return nil if no records" do
+    @db[:test].single_value!.must_equal nil
+    @db.sqls.must_equal ['SELECT * FROM test']
+  end
+end
+
 describe "Dataset#get" do
   before do
     @d = Sequel.mock(:fetch=>proc{|s| {:name=>s}})[:test]

data/spec/core/schema_generator_spec.rb

@@ -30,6 +30,19 @@ describe Sequel::Schema::Generator do
     @columns[3][:primary_key].must_equal nil
   end
   
+  it "should respect existing column order if primary_key :keep_order is used" do
+    generator = Sequel::Schema::Generator.new(Sequel.mock) do
+      string :title
+      primary_key :id, :keep_order=>true
+    end
+
+    columns = generator.columns
+    columns.last[:name].must_equal :id
+    columns.last[:primary_key].must_equal true
+    columns.first[:name].must_equal :title
+    columns.first[:primary_key].must_equal nil
+  end
+  
   it "counts definitions correctly" do
     @columns.size.must_equal 6
     @indexes.size.must_equal 2

data/spec/core/schema_spec.rb

@@ -111,6 +111,18 @@ describe "DB#create_table" do
       primary_key :id, :type => :serial, :auto_increment => false
     end
     @db.sqls.must_equal ['CREATE TABLE cats (id serial PRIMARY KEY)']
+
+    @db.create_table(:cats) do
+      Integer :a
+      primary_key :id
+    end
+    @db.sqls.must_equal ['CREATE TABLE cats (id integer PRIMARY KEY AUTOINCREMENT, a integer)']
+
+    @db.create_table(:cats) do
+      Integer :a
+      primary_key :id, :keep_order=>true
+    end
+    @db.sqls.must_equal ['CREATE TABLE cats (a integer, id integer PRIMARY KEY AUTOINCREMENT)']
   end
 
   it "should allow naming primary key constraint with :primary_key_constraint_name option" do
@@ -1571,6 +1583,11 @@ describe "Schema Parser" do
     @db.schema(:x).last.last[:auto_increment].must_equal false
   end
 
+  it "should set :auto_increment to true by default if set and not the first column" do
+    meta_def(@db, :schema_parse_table){|*| [[:b, {}], [:a, {:primary_key=>true, :db_type=>'integer'}]]}
+    @db.schema(:x).last.last[:auto_increment].must_equal true
+  end
+
   it "should convert various types of table name arguments" do
     meta_def(@db, :schema_parse_table) do |t, opts|
       [[t, opts]]

data/spec/extensions/active_model_spec.rb

@@ -2,122 +2,84 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
 begin
   require 'active_model'
-  begin
-    require 'minitest'
-    if defined?(MiniTest::Unit)
-      class << MiniTest::Unit
-        def autorun; end
-      end
-    end
-    if defined?(MiniTest::Test)
-      test_class = MiniTest::Test
-    end
-  rescue
-    require 'test/unit'
-    test_class = Test::Unit::TestCase
-    if Test::Unit.respond_to?(:run=)
-      Test::Unit.run = false
-      require 'test/unit/testresult'
-    end
-  end
 rescue LoadError => e
   skip_warn "active_model plugin: can't load active_model (#{e.class}: #{e})"
 else
 describe "ActiveModel plugin" do
-  it "should be compliant to the ActiveModel spec" do
-    tc = Class.new(test_class)
-    tc.class_eval do
-      define_method(:setup) do
-        class ::AMLintTest < Sequel::Model
-          set_primary_key :id
-          columns :id, :id2
-          def delete; end
-        end
-        module ::Blog
-          class Post < Sequel::Model
-             plugin :active_model
-          end
-        end
-        @c = AMLintTest
-        @c.plugin :active_model
-        @m = @model = @c.new
-        @o = @c.load({})
-        super()
-      end
-      def teardown
-        super
-        Object.send(:remove_const, :AMLintTest)
-        Object.send(:remove_const, :Blog)
+  before do
+    class ::AMLintTest < Sequel::Model
+      set_primary_key :id
+      columns :id, :id2
+      def delete; end
+    end
+    module ::Blog
+      class Post < Sequel::Model
+         plugin :active_model
       end
-      include ActiveModel::Lint::Tests
+    end
+    @c = AMLintTest
+    @c.plugin :active_model
+    @m = @model = @c.new
+    @o = @c.load({})
+  end
+  after do
+    Object.send(:remove_const, :AMLintTest)
+    Object.send(:remove_const, :Blog)
+  end
+  include ActiveModel::Lint::Tests
 
-      # Should return self, not a proxy object
-      def test__to_model
-        assert_equal @m.to_model.object_id, @m.object_id
-      end
-      
-      def test__to_key
-        assert_equal nil, @m.to_key
-        @o.id = 1
-        assert_equal [1], @o.to_key
-        @o.id = nil
-        assert_equal nil, @o.to_key
+  it ".to_model should return self, not a proxy object" do
+    @m.object_id.must_equal @m.to_model.object_id
+  end
+  
+  it "#to_key should return a key array, or nil" do
+    @o.to_key.must_equal nil
+    @o.id = 1
+    @o.to_key.must_equal [1]
+    @o.id = nil
+    @o.to_key.must_equal nil
 
-        @c.set_primary_key [:id2, :id]
-        assert_equal nil, @o.to_key
-        @o.id = 1
-        @o.id2 = 2
-        assert_equal [2, 1], @o.to_key
-        @o.destroy
-        assert_equal [2, 1], @o.to_key
-        @o.id = nil
-        assert_equal nil, @o.to_key
-      end
-      
-      def test__to_param
-        assert_equal nil, @m.to_param
-        @o.id = 1
-        assert_equal '1', @o.to_param
-        @c.set_primary_key [:id2, :id]
-        @o.id2 = 2
-        assert_equal '2-1', @o.to_param
-        @o.meta_def(:to_param_joiner){'|'}
-        assert_equal '2|1', @o.to_param
-        @o.destroy
-        assert_equal nil, @o.to_param
-      end
+    @c.set_primary_key [:id2, :id]
+    @o.to_key.must_equal nil
+    @o.id = 1
+    @o.id2 = 2
+    @o.to_key.must_equal [2, 1]
+    @o.destroy
+    @o.to_key.must_equal [2, 1]
+    @o.id = nil
+    @o.to_key.must_equal nil
+  end
+  
+  it "#to_param should return a param string or nil" do
+    @o.to_param.must_equal nil
+    @o.id = 1
+    @o.to_param.must_equal '1'
+    @c.set_primary_key [:id2, :id]
+    @o.id2 = 2
+    @o.to_param.must_equal '2-1'
+    @o.meta_def(:to_param_joiner){'|'}
+    @o.to_param.must_equal '2|1'
+    @o.destroy
+    @o.to_param.must_equal nil
+  end
 
-      def test__persisted?
-        assert_equal false, @m.persisted?
-        assert_equal true, @o.persisted?
-        @m.destroy
-        @o.destroy
-        assert_equal false, @m.persisted?
-        assert_equal false, @o.persisted?
-      end
+  it "#persisted? should return true if the object exists and has not been destroyed" do
+    @m.persisted?.must_equal false
+    @o.persisted?.must_equal true
+    @m.destroy
+    @o.destroy
+    @m.persisted?.must_equal false
+    @o.persisted?.must_equal false
+  end
 
-      # Should return self, not a proxy object
-      def test__to_partial_path
-        assert_equal 'am_lint_tests/am_lint_test', @m.to_partial_path
-        assert_equal 'blog/posts/post', Blog::Post.new.to_partial_path
-      end
-      
-    end
-    if defined?(MiniTest::Test) || defined?(MiniTest::Unit)
-      tc.instance_methods.map{|x| x.to_s}.reject{|n| n !~ /\Atest_/}.each do |m|
-        i = tc.new(m)
-        i.setup
-        i.send(m)
-        i.teardown
-      end
-    else
-      res = ::Test::Unit::TestResult.new
-      tc.suite.run(res){}
-      if res.failure_count > 0
-        puts res.instance_variable_get(:@failures)
-      end
-      res.failure_count.must_equal 0
-    end
+  it "#persisted? should return false if the object is created and the transaction is rolled back" do
+    DB.transaction(:rollback=>:always){@m.save}
+    @m.persisted?.must_equal false
+  end
+
+  it "#to_partial_path should return a path string" do
+    @m.to_partial_path.must_equal 'am_lint_tests/am_lint_test'
+    Blog::Post.new.to_partial_path.must_equal 'blog/posts/post'
   end
-end 
 end
+end 

data/spec/extensions/before_after_save_spec.rb

@@ -0,0 +1,40 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "Sequel::Plugins::BeforeAfterSave" do
+  before do
+    @db = Sequel.mock(:numrows=>1, :fetch=>{:id=>1, :name=>'b'})
+    @c = Class.new(Sequel::Model(@db[:test]))
+    @ds = @c.dataset
+    @c.columns :id, :name
+    @c.plugin :before_after_save
+    @c.plugin :instance_hooks
+    @o = @c.new
+    @db.sqls
+  end
+
+  it "should reset modified flag before calling after hooks" do
+    a = []
+    @o.after_create_hook{@o.modified?.must_equal false; a << 1}
+    @o.after_save_hook{@o.modified?.must_equal false; a << 2}
+
+    @o.modified!
+    @o.save
+    a.must_equal [1, 2]
+
+    @o.after_save_hook{@o.modified?.must_equal false; a << 2}
+    @o.after_update_hook{@o.modified?.must_equal false; a << 3}
+    a = []
+    @o.modified!
+    @o.save
+    a.must_equal [3, 2]
+  end
+
+  it "should refresh the instance before calling after hooks" do
+    a = []
+    @o.after_create_hook{@o.values.must_equal(:id=>1, :name=>'b'); a << 1}
+    @o.after_save_hook{@o.values.must_equal(:id=>1, :name=>'b'); a << 2}
+
+    @o.save
+    a.must_equal [1, 2]
+  end
+end

data/spec/extensions/boolean_subsets_spec.rb

@@ -0,0 +1,47 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "boolean_subsets plugin" do
+  before do
+    @db = Sequel::Database.new
+    def @db.supports_schema_parsing?() true end
+    def @db.schema(*args)
+      [[:asdaf9898as, {}], [:active, {:type=>:boolean}]]
+    end
+
+    @c = Class.new(Sequel::Model(@db[:items]))
+    @p = proc do
+      @columns = [:asdaf9898as, :active]
+      def columns; @columns; end
+    end
+    @c.instance_eval(&@p)
+  end 
+
+  it "should create subsets only for boolean attributes" do
+    @c.plugin(:boolean_subsets)
+    @c.active.sql.must_equal "SELECT * FROM items WHERE (active IS TRUE)"
+    @c.respond_to?(:asdaf9898as).must_equal false
+  end
+
+  it "should handle a block passed to the plugin" do
+    @c.plugin(:boolean_subsets){|c| ["where_#{c}", c]}
+    @c.where_active.sql.must_equal "SELECT * FROM items WHERE active"
+    @c.respond_to?(:active).must_equal false
+  end
+
+  it "should create boolean subsets when set_dataset is called" do
+    c = Class.new(Sequel::Model(@db))
+    c.instance_eval(&@p)
+    c.plugin(:boolean_subsets)
+    c.respond_to?(:active).must_equal false
+
+    c.set_dataset(@db[:items])
+    c.active.sql.must_equal "SELECT * FROM items WHERE (active IS TRUE)"
+    c.respond_to?(:asdaf9898as).must_equal false
+  end
+
+  it "should handle cases where getting the columns raises an error" do
+    @c.meta_def(:columns){raise Sequel::Error}
+    @c.plugin(:boolean_subsets)
+    @c.respond_to?(:active).must_equal false
+  end
+end

data/spec/extensions/date_arithmetic_spec.rb

@@ -65,6 +65,23 @@ describe "date_arithmetic extension" do
     end
   end
 
+  it "should use existing method" do
+    db = Sequel.mock
+    db.extend_datasets do
+      def date_add_sql_append(sql, da)
+        interval = ''
+        each_valid_interval_unit(da.interval, Sequel::SQL::DateAdd::DatasetMethods::DEF_DURATION_UNITS) do |value, sql_unit|
+          interval << "#{value} #{sql_unit} "
+        end
+        literal_append(sql, Sequel.function(:da, da.expr, interval))
+      end
+    end
+    db.extension :date_arithmetic
+    db.literal(Sequel.date_add(:a, @h0)).must_equal "da(a, '')"
+    db.literal(Sequel.date_add(:a, @h1)).must_equal "da(a, '1 days ')"
+    db.literal(Sequel.date_add(:a, @h2)).must_equal "da(a, '1 years 1 months 1 days 1 hours 1 minutes 1 seconds ')"
+  end
+
   it "should correctly literalize on Postgres" do
     db = dbf.call(:postgres)
     db.literal(Sequel.date_add(:a, @h0)).must_equal "CAST(a AS timestamp)"

data/spec/extensions/json_serializer_spec.rb

@@ -43,6 +43,13 @@ describe "Sequel::Plugins::JsonSerializer" do
     Artist.from_json(Artist.load(:name=>Date.today).to_json).must_equal Artist.load(:name=>Date.today)
   end
 
+  it "should support setting json_serializer_opts on models" do
+    @artist.json_serializer_opts(:only=>:name)
+    Sequel.parse_json([@artist].to_json).must_equal [{'name'=>@artist.name}]
+    @artist.json_serializer_opts(:include=>{:albums=>{:only=>:name}})
+    Sequel.parse_json([@artist].to_json).must_equal [{'name'=>@artist.name, 'albums'=>[{'name'=>@album.name}]}]
+  end
+
   it "should handle the :only option" do
     Artist.from_json(@artist.to_json(:only=>:name)).must_equal Artist.load(:name=>@artist.name)
     Album.from_json(@album.to_json(:only=>[:id, :name])).must_equal Album.load(:id=>@album.id, :name=>@album.name)

data/spec/extensions/list_spec.rb

@@ -264,4 +264,15 @@ describe "List plugin" do
     @o.prev(-1).must_equal @c.load(:id=>9, :position=>4)
     @db.sqls.must_equal ["SELECT * FROM items WHERE (position = 4) ORDER BY position LIMIT 1"]
   end
+
+  it "should work correctly with validation on position" do
+    @c.class_eval do
+      def validate
+        super
+        errors.add(:position, "not set") unless position
+      end
+    end
+    @c.create
+    @db.sqls.must_equal ["SELECT max(position) AS max FROM items LIMIT 1", "INSERT INTO items (position) VALUES (2)", "SELECT * FROM items WHERE (id = 10) ORDER BY position LIMIT 1"]
+  end
 end

data/spec/extensions/pg_json_ops_spec.rb

@@ -108,6 +108,11 @@ describe "Sequel::Postgres::JSONOp" do
     @l[@jb.array_elements_text].must_equal "jsonb_array_elements_text(j)"
   end
 
+  it "should have #strip_nulls use the json_strip_nulls function" do
+    @l[@j.strip_nulls].must_equal "json_strip_nulls(j)"
+    @l[@jb.strip_nulls].must_equal "jsonb_strip_nulls(j)"
+  end
+
   it "should have #typeof use the json_typeof function" do
     @l[@j.typeof].must_equal "json_typeof(j)"
     @l[@jb.typeof].must_equal "jsonb_typeof(j)"
@@ -173,6 +178,47 @@ describe "Sequel::Postgres::JSONOp" do
     @l[@jb.contained_by([1, 2])].must_equal "(j <@ '[1,2]'::jsonb)"
   end
 
+  it "#concat should use the || operator" do
+    @l[@jb.concat(:h1)].must_equal "(j || h1)"
+  end
+
+  it "#concat should handle hashes" do
+    @l[@jb.concat('a'=>'b')].must_equal "(j || '{\"a\":\"b\"}'::jsonb)"
+  end
+
+  it "#concat should handle arrays" do
+    @l[@jb.concat([1, 2])].must_equal "(j || '[1,2]'::jsonb)"
+  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)"
+  end
+
+  it "#set should handle hashes" do
+    @l[@jb.set(:a, 'a'=>'b')].must_equal "jsonb_set(j, a, '{\"a\":\"b\"}'::jsonb, true)"
+  end
+
+  it "#set should handle arrays" do
+    @l[@jb.set(%w'a b', [1, 2])].must_equal "jsonb_set(j, ARRAY['a','b'], '[1,2]'::jsonb, true)"
+  end
+
+  it "#pretty should use the jsonb_pretty function" do
+    @l[@jb.pretty].must_equal "jsonb_pretty(j)"
+  end
+
+  it "#- should use the - operator" do
+    @l[@jb - 1].must_equal "(j - 1)"
+  end
+
+  it "#delete_path should use the #- operator" do
+    @l[@jb.delete_path(:a)].must_equal "(j #- a)"
+  end
+
+  it "#delete_path should handle arrays" do
+    @l[@jb.delete_path(['a'])].must_equal "(j #- ARRAY['a'])"
+  end
+
   it "#has_key? and aliases should use the ? operator" do
     @l[@jb.has_key?('a')].must_equal "(j ? 'a')"
     @l[@jb.include?('a')].must_equal "(j ? 'a')"