sequel 4.10.0 → 4.11.0

data/spec/core/expression_filters_spec.rb

@@ -390,6 +390,22 @@ describe "Blockless Ruby Filters" do
   it "should handled emulated trim function" do
     @d.lit(Sequel.trim(:a)).should == 'trim(a)'
   end
+
+  it "should handled emulated function where only name is emulated" do
+    dsc = Class.new(Sequel::Dataset)
+    dsc::EMULATED_FUNCTION_MAP[:trim] = :foo
+    dsc.new(@d.db).literal(Sequel.trim(:a)).should == 'foo(a)'
+  end
+
+  it "should handled emulated function needing full emulation" do
+    dsc = Class.new(Sequel::Dataset) do
+      def emulate_function?(n) n == :trim end
+      def emulate_function_sql_append(sql, f)
+        sql << "#{f.name}FOO(lower(#{f.args.first}))"
+      end
+    end
+    dsc.new(@d.db).literal(Sequel.trim(:a)).should == 'trimFOO(lower(a))'
+  end
 end
 
 describe Sequel::SQL::VirtualRow do
@@ -419,15 +435,17 @@ describe Sequel::SQL::VirtualRow do
     @d.l{version{}}.should == 'version()'
   end
 
-  it "should treat methods with a block and a leading argument :* as a function call starting with the SQL wildcard" do
+  it "should treat methods with a block and a leading argument :* as a function call with the SQL wildcard" do
     @d.l{count(:*){}}.should == 'count(*)'
-    @d.l{count(:*, 1){}}.should == 'count(*, 1)'
   end
 
-  it "should support * method on functions to add * as the first argument" do
+  it "should support * method on functions to raise error if function already has an argument" do
+    proc{@d.l{count(1).*}}.should raise_error(Sequel::Error)
+  end
+
+  it "should support * method on functions to use * as the argument" do
     @d.l{count{}.*}.should == 'count(*)'
-    @d.l{count(1).*}.should == 'count(*, 1)'
-    @d.literal(Sequel.expr{count(1) * 2}).should == '(count(1) * 2)'
+    @d.literal(Sequel.expr{sum(1) * 2}).should == '(sum(1) * 2)'
   end
 
   it "should treat methods with a block and a leading argument :distinct as a function call with DISTINCT and the additional method arguments" do
@@ -496,6 +514,14 @@ describe Sequel::SQL::VirtualRow do
     @d.l{sum(c).over(:partition=>a, :order=>b, :window=>:win, :frame=>:rows)}.should == 'sum("c") OVER ("win" PARTITION BY "a" ORDER BY "b" ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)'
   end
 
+  it "should support over method with a Window argument" do
+    @d.l{sum(c).over(Sequel::SQL::Window.new(:partition=>a, :order=>b, :window=>:win, :frame=>:rows))}.should == 'sum("c") OVER ("win" PARTITION BY "a" ORDER BY "b" ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)'
+  end
+
+  it "should raise error if over is called on a function that already has a window " do
+    proc{@d.l{rank{}.over.over}}.should raise_error(Sequel::Error)
+  end
+
   it "should raise an error if window functions are not supported" do
     class << @d; remove_method :supports_window_functions? end
     meta_def(@d, :supports_window_functions?){false}
@@ -503,6 +529,30 @@ describe Sequel::SQL::VirtualRow do
     proc{Sequel.mock.dataset.filter{count(:over, :* =>true, :partition=>a, :order=>b, :window=>:win, :frame=>:rows){}}.sql}.should raise_error(Sequel::Error)
   end
   
+  it "should handle lateral function calls" do
+    @d.l{rank{}.lateral}.should == 'LATERAL rank()' 
+  end
+
+  it "should handle ordered-set and hypothetical-set function calls" do
+    @d.l{mode{}.within_group(:a)}.should == 'mode() WITHIN GROUP (ORDER BY "a")' 
+    @d.l{mode{}.within_group(:a, :b)}.should == 'mode() WITHIN GROUP (ORDER BY "a", "b")' 
+  end
+
+  it "should handle filtered aggregate function calls" do
+    @d.l{count{}.*.filter(:a, :b)}.should == 'count(*) FILTER (WHERE ("a" AND "b"))' 
+    @d.l{count{}.*.filter(:a=>1)}.should == 'count(*) FILTER (WHERE ("a" = 1))'
+    @d.l{count{}.*.filter{b > 1}}.should == 'count(*) FILTER (WHERE ("b" > 1))'
+    @d.l{count{}.*.filter(:a=>1){b > 1}}.should == 'count(*) FILTER (WHERE (("a" = 1) AND ("b" > 1)))'
+  end
+
+  it "should handle fitlered ordered-set and hypothetical-set function calls" do
+    @d.l{mode{}.within_group(:a).filter(:a=>1)}.should == 'mode() WITHIN GROUP (ORDER BY "a") FILTER (WHERE ("a" = 1))' 
+  end
+
+  it "should handle function calls with ordinality" do
+    @d.l{foo{}.with_ordinality}.should == 'foo() WITH ORDINALITY' 
+  end
+
   it "should support function method on identifiers to create functions" do
     @d.l{rank.function}.should == 'rank()' 
     @d.l{sum.function(c)}.should == 'sum("c")'
@@ -522,6 +572,18 @@ describe Sequel::SQL::VirtualRow do
     @d.l{sch__rank.function}.should == '"sch"."rank"()' 
   end
 
+  it "should quote function names if a quoted function is used and database supports quoted function names" do
+    def @d.supports_quoted_function_names?; true; end
+    @d.l{rank{}.quoted}.should == '"rank"()' 
+    @d.l{sch__rank{}.quoted}.should == '"sch__rank"()' 
+  end
+
+  it "should not quote function names if an unquoted function is used" do
+    def @d.supports_quoted_function_names?; true; end
+    @d.l{rank.function.unquoted}.should == 'rank()' 
+    @d.l{sch__rank.function.unquoted}.should == 'sch.rank()' 
+  end
+
   it "should deal with classes without requiring :: prefix" do
     @d.l{date < Date.today}.should == "(\"date\" < '#{Date.today}')"
     @d.l{date < Sequel::CURRENT_DATE}.should == "(\"date\" < CURRENT_DATE)"

data/spec/core/mock_adapter_spec.rb

@@ -424,13 +424,15 @@ describe "Sequel Mock Adapter" do
       class Sequel::Database; @identifier_input_method=nil; end
       class Sequel::Database; @identifier_output_method=nil; end
       Sequel.mock(:host=>'access').select(Date.new(2011, 12, 13)).sql.should == 'SELECT #2011-12-13#'
+      Sequel.mock(:host=>'cubrid').from(:a).offset(1).sql.should == 'SELECT * FROM "a" LIMIT 1,4294967295'
       Sequel.mock(:host=>'db2').select(1).sql.should == 'SELECT 1 FROM "SYSIBM"."SYSDUMMY1"'
       Sequel.mock(:host=>'firebird')[:a].distinct.limit(1, 2).sql.should == 'SELECT DISTINCT FIRST 1 SKIP 2 * FROM "A"'
       Sequel.mock(:host=>'informix')[:a].distinct.limit(1, 2).sql.should == 'SELECT SKIP 2 FIRST 1 DISTINCT * FROM A'
       Sequel.mock(:host=>'mssql')[:a].full_text_search(:b, 'c').sql.should == "SELECT * FROM [A] WHERE (CONTAINS ([B], 'c'))"
       Sequel.mock(:host=>'mysql')[:a].full_text_search(:b, 'c').sql.should == "SELECT * FROM `a` WHERE (MATCH (`b`) AGAINST ('c'))"
       Sequel.mock(:host=>'oracle')[:a].limit(1).sql.should == 'SELECT * FROM (SELECT * FROM "A") "T1" WHERE (ROWNUM <= 1)'
-      Sequel.mock(:host=>'postgres')[:a].full_text_search(:b, 'c').sql.should == "SELECT * FROM \"a\" WHERE (to_tsvector('simple'::regconfig, (COALESCE(\"b\", ''))) @@ to_tsquery('simple'::regconfig, 'c'))"
+      Sequel.mock(:host=>'postgres')[:a].full_text_search(:b, 'c').sql.should == "SELECT * FROM \"a\" WHERE (to_tsvector(CAST('simple' AS regconfig), (COALESCE(\"b\", ''))) @@ to_tsquery(CAST('simple' AS regconfig), 'c'))"
+      Sequel.mock(:host=>'sqlanywhere').from(:a).offset(1).sql.should == 'SELECT TOP 2147483647 START AT (1 + 1) * FROM "A"'
       Sequel.mock(:host=>'sqlite')[:a___b].sql.should == "SELECT * FROM `a` AS 'b'"
     ensure
       Sequel.quote_identifiers = qi
@@ -439,9 +441,11 @@ describe "Sequel Mock Adapter" do
     end
   end
 
-  specify "should automatically set version for postgres and mssql" do
-    Sequel.mock(:host=>'postgres').server_version.should == 90103
-    Sequel.mock(:host=>'mssql').server_version.should == 10000000
+  specify "should automatically set version for adapters nedding versions" do
+    Sequel.mock(:host=>'postgres').server_version.should == 90400
+    Sequel.mock(:host=>'mssql').server_version.should == 11000000
+    Sequel.mock(:host=>'mysql').server_version.should == 50617
+    Sequel.mock(:host=>'sqlite').sqlite_version.should == 30804
   end
 
   specify "should stub out the primary_key method for postgres" do

data/spec/core/schema_spec.rb

@@ -1399,6 +1399,13 @@ describe "Database#create_view" do
     @db.sqls.should == ['CREATE VIEW test (d, e) AS SELECT a, b FROM items ORDER BY c']
   end
 
+  specify "should handle :check option" do
+    @db.create_view :test, @db[:items].select(:a, :b).order(:c), :check=>true
+    @db.sqls.should == ['CREATE VIEW test AS SELECT a, b FROM items ORDER BY c WITH CHECK OPTION']
+    @db.create_view :test, @db[:items].select(:a, :b).order(:c), :check=>:local
+    @db.sqls.should == ['CREATE VIEW test AS SELECT a, b FROM items ORDER BY c WITH LOCAL CHECK OPTION']
+  end
+
   specify "should handle create_or_replace_view" do
     @db.create_or_replace_view :sch__test, "SELECT * FROM xyz"
     @db.sqls.should == ['DROP VIEW sch.test', 'CREATE VIEW sch.test AS SELECT * FROM xyz']

data/spec/core_extensions_spec.rb

@@ -647,6 +647,12 @@ describe "Postgres extensions integration" do
 
   it "Symbol#pg_json should return an JSONOp" do
     @db.literal(:a.pg_json[%w'a b']).should == "(a #> ARRAY['a','b'])"
+    @db.literal(:a.pg_json.extract('a')).should == "json_extract_path(a, 'a')"
+  end
+
+  it "Symbol#pg_jsonb should return an JSONBOp" do
+    @db.literal(:a.pg_jsonb[%w'a b']).should == "(a #> ARRAY['a','b'])"
+    @db.literal(:a.pg_jsonb.extract('a')).should == "jsonb_extract_path(a, 'a')"
   end
 
   it "Symbol#pg_range should return a RangeOp" do
@@ -662,6 +668,10 @@ describe "Postgres extensions integration" do
     @db.literal([1].pg_json).should == "'[1]'::json"
   end
 
+  it "Array#pg_jsonb should return a JSONBArray" do
+    @db.literal([1].pg_jsonb).should == "'[1]'::jsonb"
+  end
+
   it "Array#pg_row should return a ArrayRow" do
     @db.literal([1].pg_row).should == "ROW(1)"
   end
@@ -674,6 +684,10 @@ describe "Postgres extensions integration" do
     @db.literal({'a'=>'b'}.pg_json).should == "'{\"a\":\"b\"}'::json"
   end
 
+  it "Hash#pg_jsonb should return an JSONBHash" do
+    @db.literal({'a'=>'b'}.pg_jsonb).should == "'{\"a\":\"b\"}'::jsonb"
+  end
+
   it "Range#pg_range should return an PGRange" do
     @db.literal((1..2).pg_range).should == "'[1,2]'"
     @db.literal((1..2).pg_range(:int4range)).should == "'[1,2]'::int4range"

data/spec/extensions/class_table_inheritance_spec.rb

@@ -94,6 +94,18 @@ describe "class_table_inheritance plugin" do
     Manager.all.collect{|x| x.class}.should == [Manager, Manager]
   end
   
+  it "should handle a model map with integer values" do
+    Employee.plugin(:class_table_inheritance, :key=>:kind, :model_map=>{0=>:Employee, 1=>:Manager, 2=>:Executive})
+    Object.send(:remove_const, :Executive)
+    Object.send(:remove_const, :Manager)
+    class ::Manager < Employee; end 
+    class ::Executive < Manager; end 
+    Employee.dataset._fetch = [{:kind=>nil},{:kind=>0},{:kind=>1}, {:kind=>2}]
+    Employee.all.collect{|x| x.class}.should == [Employee, Employee, Manager, Executive]
+    Manager.dataset._fetch = [{:kind=>nil},{:kind=>0},{:kind=>1}, {:kind=>2}]
+    Manager.all.collect{|x| x.class}.should == [Manager, Employee, Manager, Executive]
+  end
+  
   it "should fallback to the main class if the given class does not exist" do
     @ds._fetch = [{:kind=>'Employee'}, {:kind=>'Manager'}, {:kind=>'Blah'}, {:kind=>'Staff'}]
     Employee.all.collect{|x| x.class}.should == [Employee, Manager, Employee, Staff]
@@ -104,19 +116,19 @@ describe "class_table_inheritance plugin" do
     Manager.all.collect{|x| x.class}.should == [Manager, Executive, Manager]
   end
 
-  it "should add a before_create hook that sets the model class name for the key" do
+  it "should sets the model class name for the key when creating new parent class records" do
     Employee.create
     @db.sqls.should == ["INSERT INTO employees (kind) VALUES ('Employee')"]
   end
   
-  it "should add a before_create hook that sets the model class name for the key in subclasses" do
+  it "should sets the model class name for the key when creating new subclass records" do
     Executive.create
     @db.sqls.should == ["INSERT INTO employees (kind) VALUES ('Executive')",
       "INSERT INTO managers (id) VALUES (1)",
       "INSERT INTO executives (id) VALUES (1)"]
   end
 
-  it "should ignore existing cti_key value" do
+  it "should ignore existing cti_key value when creating new records" do
     Employee.create(:kind=>'Manager')
     @db.sqls.should == ["INSERT INTO employees (kind) VALUES ('Employee')"]
   end
@@ -127,6 +139,14 @@ describe "class_table_inheritance plugin" do
       "INSERT INTO managers (id) VALUES (1)"]
   end
 
+  it "should handle validations on the type column field" do
+    o = Employee.new
+    def o.validate
+      errors.add(:kind, 'not present') unless kind
+    end
+    o.valid?.should == true
+  end
+
   it "should raise an error if attempting to create an anonymous subclass" do
     proc{Class.new(Manager)}.should raise_error(Sequel::Error)
   end

data/spec/extensions/core_refinements_spec.rb

@@ -468,6 +468,12 @@ describe "Postgres extensions integration" do
 
   it "Symbol#pg_json should return an JSONOp" do
     @db.literal(:a.pg_json[%w'a b']).should == "(a #> ARRAY['a','b'])"
+    @db.literal(:a.pg_json.extract('a')).should == "json_extract_path(a, 'a')"
+  end
+
+  it "Symbol#pg_jsonb should return an JSONBOp" do
+    @db.literal(:a.pg_jsonb[%w'a b']).should == "(a #> ARRAY['a','b'])"
+    @db.literal(:a.pg_jsonb.extract('a')).should == "jsonb_extract_path(a, 'a')"
   end
 
   it "Symbol#pg_range should return a RangeOp" do
@@ -483,6 +489,10 @@ describe "Postgres extensions integration" do
     @db.literal([1].pg_json).should == "'[1]'::json"
   end
 
+  it "Array#pg_jsonb should return a JSONBArray" do
+    @db.literal([1].pg_jsonb).should == "'[1]'::jsonb"
+  end
+
   it "Array#pg_row should return a ArrayRow" do
     @db.literal([1].pg_row).should == "ROW(1)"
   end
@@ -495,6 +505,10 @@ describe "Postgres extensions integration" do
     @db.literal({'a'=>'b'}.pg_json).should == "'{\"a\":\"b\"}'::json"
   end
 
+  it "Hash#pg_jsonb should return an JSONBHash" do
+    @db.literal({'a'=>'b'}.pg_jsonb).should == "'{\"a\":\"b\"}'::jsonb"
+  end
+
   it "Range#pg_range should return an PGRange" do
     @db.literal((1..2).pg_range).should == "'[1,2]'"
     @db.literal((1..2).pg_range(:int4range)).should == "'[1,2]'::int4range"

data/spec/extensions/eval_inspect_spec.rb

@@ -13,6 +13,7 @@ describe "eval_inspect extension" do
     [
       # Objects with components where eval(inspect) == self
       Sequel::SQL::AliasedExpression.new(:b, :a),
+      Sequel::SQL::AliasedExpression.new(:b, :a, [:c, :d]),
       Sequel::SQL::CaseExpression.new({:b=>:a}, :c),
       Sequel::SQL::CaseExpression.new({:b=>:a}, :c, :d),
       Sequel::SQL::Cast.new(:a, :b),
@@ -28,9 +29,12 @@ describe "eval_inspect extension" do
       Sequel::NOTNULL,
       Sequel::SQL::Function.new(:a, :b, :c),
       Sequel::SQL::Identifier.new(:a),
-      Sequel::SQL::JoinClause.new(:inner, :b, :c),
-      Sequel::SQL::JoinOnClause.new({:d=>:a}, :inner, :b, :c),
-      Sequel::SQL::JoinUsingClause.new([:a], :inner, :b, :c),
+      Sequel::SQL::JoinClause.new(:inner, :b),
+      Sequel::SQL::JoinOnClause.new({:d=>:a}, :inner, :b),
+      Sequel::SQL::JoinUsingClause.new([:a], :inner, :b),
+      Sequel::SQL::JoinClause.new(:inner, Sequel.as(:b, :c, [:d, :e])),
+      Sequel::SQL::JoinOnClause.new({:d=>:a}, :inner, Sequel.as(:b, :c, [:d, :e])),
+      Sequel::SQL::JoinUsingClause.new([:a], :inner, Sequel.as(:b, :c, [:d, :e])),
       Sequel::SQL::PlaceholderLiteralString.new('? = ?', [:a, :b]),
       Sequel::SQL::PlaceholderLiteralString.new(':a = :b', [{:a=>:b, :b=>42}]),
       Sequel::SQL::OrderedExpression.new(:a),
@@ -40,7 +44,7 @@ describe "eval_inspect extension" do
       Sequel::SQL::QualifiedIdentifier.new(:b, :a),
       Sequel::SQL::Subscript.new(:a, [1, 2]),
       Sequel::SQL::Window.new(:order=>:a, :partition=>:b),
-      Sequel::SQL::WindowFunction.new(Sequel::SQL::Function.new(:a, :b, :c), Sequel::SQL::Window.new(:order=>:a, :partition=>:b)),
+      Sequel::SQL::Function.new(:a, :b, :c).over(:order=>:a, :partition=>:b),
       Sequel::SQL::Wrapper.new(:a),
       
       # Objects with components where eval(inspect) != self

data/spec/extensions/pg_array_ops_spec.rb

@@ -63,6 +63,10 @@ describe "Sequel::Postgres::ArrayOp" do
     @db.literal(@a.unshift(:b)).should == "(b || a)"
   end
 
+  it "#cardinality should use the cardinality function" do
+    @db.literal(@a.cardinality).should == "cardinality(a)"
+  end
+
   it "#dims should use the array_dims function" do
     @db.literal(@a.dims).should == "array_dims(a)"
   end
@@ -95,6 +99,8 @@ describe "Sequel::Postgres::ArrayOp" do
 
   it "#unnest should use the unnest function" do
     @db.literal(@a.unnest).should == "unnest(a)"
+    @db.literal(@a.unnest(:b, :c)).should == "unnest(a, b, c)"
+    @db.literal(@a.unnest([1])).should == "unnest(a, ARRAY[1])"
   end
 
   it "#pg_array should return self" do

data/spec/extensions/pg_json_ops_spec.rb

@@ -6,6 +6,7 @@ describe "Sequel::Postgres::JSONOp" do
   before do
     @db = Sequel.connect('mock://postgres', :quote_identifiers=>false)
     @j = Sequel.pg_json_op(:j)
+    @jb = Sequel.pg_jsonb_op(:j)
     @l = proc{|o| @db.literal(o)}
   end
 
@@ -48,77 +49,167 @@ describe "Sequel::Postgres::JSONOp" do
 
   it "should have #array_length use the json_array_length function" do
     @l[@j.array_length].should == "json_array_length(j)"
+    @l[@jb.array_length].should == "jsonb_array_length(j)"
   end
 
   it "should have #array_length return a numeric expression" do
     @l[@j.array_length & 1].should == "(json_array_length(j) & 1)"
+    @l[@jb.array_length & 1].should == "(jsonb_array_length(j) & 1)"
   end
 
   it "should have #each use the json_each function" do
     @l[@j.each].should == "json_each(j)"
+    @l[@jb.each].should == "jsonb_each(j)"
   end
 
   it "should have #each_text use the json_each_text function" do
     @l[@j.each_text].should == "json_each_text(j)"
+    @l[@jb.each_text].should == "jsonb_each_text(j)"
   end
 
   it "should have #extract use the json_extract_path function" do
     @l[@j.extract('a')].should == "json_extract_path(j, 'a')"
     @l[@j.extract('a', 'b')].should == "json_extract_path(j, 'a', 'b')"
+    @l[@jb.extract('a')].should == "jsonb_extract_path(j, 'a')"
+    @l[@jb.extract('a', 'b')].should == "jsonb_extract_path(j, 'a', 'b')"
   end
 
   it "should have #extract return a JSONOp" do
     @l[@j.extract('a')[1]].should == "(json_extract_path(j, 'a') -> 1)"
+    @l[@jb.extract('a')[1]].should == "(jsonb_extract_path(j, 'a') -> 1)"
   end
 
   it "should have #extract_text use the json_extract_path_text function" do
     @l[@j.extract_text('a')].should == "json_extract_path_text(j, 'a')"
     @l[@j.extract_text('a', 'b')].should == "json_extract_path_text(j, 'a', 'b')"
+    @l[@jb.extract_text('a')].should == "jsonb_extract_path_text(j, 'a')"
+    @l[@jb.extract_text('a', 'b')].should == "jsonb_extract_path_text(j, 'a', 'b')"
   end
 
   it "should have #extract_text return an SQL::StringExpression" do
     @l[@j.extract_text('a') + 'a'].should == "(json_extract_path_text(j, 'a') || 'a')"
+    @l[@jb.extract_text('a') + 'a'].should == "(jsonb_extract_path_text(j, 'a') || 'a')"
   end
 
   it "should have #keys use the json_object_keys function" do
     @l[@j.keys].should == "json_object_keys(j)"
+    @l[@jb.keys].should == "jsonb_object_keys(j)"
   end
 
   it "should have #array_elements use the json_array_elements function" do
     @l[@j.array_elements].should == "json_array_elements(j)"
+    @l[@jb.array_elements].should == "jsonb_array_elements(j)"
+  end
+
+  it "should have #array_elements use the json_array_elements_text function" do
+    @l[@j.array_elements_text].should == "json_array_elements_text(j)"
+    @l[@jb.array_elements_text].should == "jsonb_array_elements_text(j)"
+  end
+
+  it "should have #typeof use the json_typeof function" do
+    @l[@j.typeof].should == "json_typeof(j)"
+    @l[@jb.typeof].should == "jsonb_typeof(j)"
+  end
+
+  it "should have #to_record use the json_to_record function" do
+    @l[@j.to_record].should == "json_to_record(j, false)"
+    @l[@jb.to_record].should == "jsonb_to_record(j, false)"
+    @l[@j.to_record(true)].should == "json_to_record(j, true)"
+    @l[@jb.to_record(true)].should == "jsonb_to_record(j, true)"
+  end
+
+  it "should have #to_recordset use the json_to_recordsetfunction" do
+    @l[@j.to_recordset].should == "json_to_recordset(j, false)"
+    @l[@jb.to_recordset].should == "jsonb_to_recordset(j, false)"
+    @l[@j.to_recordset(true)].should == "json_to_recordset(j, true)"
+    @l[@jb.to_recordset(true)].should == "jsonb_to_recordset(j, true)"
   end
 
   it "should have #populate use the json_populate_record function" do
     @l[@j.populate(:a)].should == "json_populate_record(a, j)"
+    @l[@jb.populate(:a)].should == "jsonb_populate_record(a, j)"
   end
 
   it "should have #populate_set use the json_populate_record function" do
     @l[@j.populate_set(:a)].should == "json_populate_recordset(a, j)"
+    @l[@jb.populate_set(:a)].should == "jsonb_populate_recordset(a, j)"
+  end
+
+  it "#contain_all should use the ?& operator" do
+    @l[@jb.contain_all(:h1)].should == "(j ?& h1)"
+  end
+
+  it "#contain_all handle arrays" do
+    @l[@jb.contain_all(%w'h1')].should == "(j ?& ARRAY['h1'])"
+  end
+
+  it "#contain_any should use the ?| operator" do
+    @l[@jb.contain_any(:h1)].should == "(j ?| h1)"
+  end
+
+  it "#contain_any should handle arrays" do
+    @l[@jb.contain_any(%w'h1')].should == "(j ?| ARRAY['h1'])"
+  end
+
+  it "#contains should use the @> operator" do
+    @l[@jb.contains(:h1)].should == "(j @> h1)"
+  end
+
+  it "#contains should handle hashes" do
+    @l[@jb.contains('a'=>'b')].should == "(j @> '{\"a\":\"b\"}'::jsonb)"
+  end
+
+  it "#contains should handle arrays" do
+    @l[@jb.contains([1, 2])].should == "(j @> '[1,2]'::jsonb)"
+  end
+
+  it "#contained_by should use the <@ operator" do
+    @l[@jb.contained_by(:h1)].should == "(j <@ h1)"
+  end
+
+  it "#contained_by should handle hashes" do
+    @l[@jb.contained_by('a'=>'b')].should == "(j <@ '{\"a\":\"b\"}'::jsonb)"
+  end
+
+  it "#contained_by should handle arrays" do
+    @l[@jb.contained_by([1, 2])].should == "(j <@ '[1,2]'::jsonb)"
+  end
+
+  it "#has_key? and aliases should use the ? operator" do
+    @l[@jb.has_key?('a')].should == "(j ? 'a')"
+    @l[@jb.include?('a')].should == "(j ? 'a')"
   end
 
   it "#pg_json should return self" do
     @j.pg_json.should equal(@j)
+    @jb.pg_jsonb.should equal(@jb)
   end
 
   it "Sequel.pg_json_op should return arg for JSONOp" do
     Sequel.pg_json_op(@j).should equal(@j)
+    Sequel.pg_jsonb_op(@jb).should equal(@jb)
   end
 
   it "should be able to turn expressions into json ops using pg_json" do
     @db.literal(Sequel.qualify(:b, :a).pg_json[1]).should == "(b.a -> 1)"
     @db.literal(Sequel.function(:a, :b).pg_json[1]).should == "(a(b) -> 1)"
+    @db.literal(Sequel.qualify(:b, :a).pg_jsonb[1]).should == "(b.a -> 1)"
+    @db.literal(Sequel.function(:a, :b).pg_jsonb[1]).should == "(a(b) -> 1)"
   end
 
   it "should be able to turn literal strings into json ops using pg_json" do
     @db.literal(Sequel.lit('a').pg_json[1]).should == "(a -> 1)"
+    @db.literal(Sequel.lit('a').pg_jsonb[1]).should == "(a -> 1)"
   end
 
   it "should be able to turn symbols into json ops using Sequel.pg_json_op" do
     @db.literal(Sequel.pg_json_op(:a)[1]).should == "(a -> 1)"
+    @db.literal(Sequel.pg_jsonb_op(:a)[1]).should == "(a -> 1)"
   end
 
   it "should be able to turn symbols into json ops using Sequel.pg_json" do
     @db.literal(Sequel.pg_json(:a)[1]).should == "(a -> 1)"
+    @db.literal(Sequel.pg_jsonb(:a)[1]).should == "(a -> 1)"
   end
 
   it "should allow transforming JSONArray instances into ArrayOp instances" do
@@ -128,4 +219,12 @@ describe "Sequel::Postgres::JSONOp" do
   it "should allow transforming JSONHash instances into ArrayOp instances" do
     @db.literal(Sequel.pg_json('a'=>1).op['a']).should == "('{\"a\":1}'::json -> 'a')"
   end
+
+  it "should allow transforming JSONBArray instances into ArrayOp instances" do
+    @db.literal(Sequel.pg_jsonb([1,2]).op[1]).should == "('[1,2]'::jsonb -> 1)"
+  end
+
+  it "should allow transforming JSONBHash instances into ArrayOp instances" do
+    @db.literal(Sequel.pg_jsonb('a'=>1).op['a']).should == "('{\"a\":1}'::jsonb -> 'a')"
+  end
 end