sequel 3.37.0 → 3.38.0

data/spec/adapters/oracle_spec.rb

@@ -115,7 +115,7 @@ describe "An Oracle dataset" do
       {:name => 'def'}
     ]
            
-    @d.order(:value.desc).limit(1).to_a.should == [
+    @d.order(Sequel.desc(:value)).limit(1).to_a.should == [
       {:date_created=>nil, :name => 'def', :value => 789}                                        
     ]
 
@@ -124,7 +124,7 @@ describe "An Oracle dataset" do
       {:date_created=>nil, :name => 'abc', :value => 456} 
     ]
     
-    @d.order(:value.desc).filter(:name => 'abc').to_a.should == [
+    @d.order(Sequel.desc(:value)).filter(:name => 'abc').to_a.should == [
       {:date_created=>nil, :name => 'abc', :value => 456},
       {:date_created=>nil, :name => 'abc', :value => 123} 
     ]
@@ -133,7 +133,7 @@ describe "An Oracle dataset" do
       {:date_created=>nil, :name => 'abc', :value => 123}                                        
     ]
         
-    @d.filter(:name => 'abc').order(:value.desc).limit(1).to_a.should == [
+    @d.filter(:name => 'abc').order(Sequel.desc(:value)).limit(1).to_a.should == [
       {:date_created=>nil, :name => 'abc', :value => 456}                                        
     ]
     
@@ -157,25 +157,25 @@ describe "An Oracle dataset" do
     
     @d.max(:value).to_i.should == 789
     
-    @d.select(:name, :AVG.sql_function(:value).as(:avg)).filter(:name => 'abc').group(:name).to_a.should == [
+    @d.select(:name, Sequel.function(:AVG, :value).as(:avg)).filter(:name => 'abc').group(:name).to_a.should == [
       {:name => 'abc', :avg => (456+123)/2.0}
     ]
 
-    @d.select(:AVG.sql_function(:value).as(:avg)).group(:name).order(:name).limit(1).to_a.should == [
+    @d.select(Sequel.function(:AVG, :value).as(:avg)).group(:name).order(:name).limit(1).to_a.should == [
       {:avg => (456+123)/2.0}
     ]
         
-    @d.select(:name, :AVG.sql_function(:value).as(:avg)).group(:name).order(:name).to_a.should == [
+    @d.select(:name, Sequel.function(:AVG, :value).as(:avg)).group(:name).order(:name).to_a.should == [
       {:name => 'abc', :avg => (456+123)/2.0},
       {:name => 'def', :avg => 789*1.0}
     ]
     
-    @d.select(:name, :AVG.sql_function(:value).as(:avg)).group(:name).order(:name).to_a.should == [
+    @d.select(:name, Sequel.function(:AVG, :value).as(:avg)).group(:name).order(:name).to_a.should == [
       {:name => 'abc', :avg => (456+123)/2.0},
       {:name => 'def', :avg => 789*1.0}
     ]
 
-    @d.select(:name, :AVG.sql_function(:value).as(:avg)).group(:name).having(:name => ['abc', 'def']).order(:name).to_a.should == [
+    @d.select(:name, Sequel.function(:AVG, :value).as(:avg)).group(:name).having(:name => ['abc', 'def']).order(:name).to_a.should == [
       {:name => 'abc', :avg => (456+123)/2.0},
       {:name => 'def', :avg => 789*1.0}
     ]
@@ -203,7 +203,7 @@ describe "An Oracle dataset" do
   specify "should translate values correctly" do
     @d << {:name => 'abc', :value => 456}
     @d << {:name => 'def', :value => 789}
-    @d.filter('value > 500').update(:date_created => "to_timestamp('2009-09-09', 'YYYY-MM-DD')".lit)
+    @d.filter('value > 500').update(:date_created => Sequel.lit("to_timestamp('2009-09-09', 'YYYY-MM-DD')"))
     
     @d[:name => 'def'][:date_created].strftime('%F').should == '2009-09-09'
   end
@@ -266,7 +266,7 @@ describe "Joined Oracle dataset" do
       {:id => 4, :title => 'ddd', :cat_name => nil} 
     ]
     
-    @d1.left_outer_join(:categories, :id => :category_id).select(:books__id, :title, :cat_name).order(:books__id.desc).limit(2, 0).to_a.should == [      
+    @d1.left_outer_join(:categories, :id => :category_id).select(:books__id, :title, :cat_name).reverse_order(:books__id).limit(2, 0).to_a.should == [      
       {:id => 4, :title => 'ddd', :cat_name => nil}, 
       {:id => 3, :title => 'ccc', :cat_name => 'rails'}
     ]      
@@ -283,7 +283,7 @@ describe "Oracle aliasing" do
   end
 
   specify "should allow columns to be renamed" do
-    @d1.select(:title.as(:name)).order_by(:id).to_a.should == [
+    @d1.select(Sequel.as(:title, :name)).order_by(:id).to_a.should == [
       { :name => 'aaa' },
       { :name => 'bbb' },
       { :name => 'bbb' },

data/spec/adapters/postgres_spec.rb

@@ -52,12 +52,12 @@ describe "A PostgreSQL database" do
 
   specify "should correctly parse the schema" do
     @db.schema(:test3, :reload=>true).should == [
-      [:value, {:type=>:integer, :allow_null=>true, :default=>nil, :ruby_default=>nil, :db_type=>"integer", :primary_key=>false}],
-      [:time, {:type=>:datetime, :allow_null=>true, :default=>nil, :ruby_default=>nil, :db_type=>"timestamp without time zone", :primary_key=>false}]
+      [:value, {:oid=>23, :type=>:integer, :allow_null=>true, :default=>nil, :ruby_default=>nil, :db_type=>"integer", :primary_key=>false}],
+      [:time, {:oid=>1114, :type=>:datetime, :allow_null=>true, :default=>nil, :ruby_default=>nil, :db_type=>"timestamp without time zone", :primary_key=>false}]
     ]
     @db.schema(:test4, :reload=>true).should == [
-      [:name, {:type=>:string, :allow_null=>true, :default=>nil, :ruby_default=>nil, :db_type=>"character varying(20)", :primary_key=>false}],
-      [:value, {:type=>:blob, :allow_null=>true, :default=>nil, :ruby_default=>nil, :db_type=>"bytea", :primary_key=>false}]
+      [:name, {:oid=>1043, :type=>:string, :allow_null=>true, :default=>nil, :ruby_default=>nil, :db_type=>"character varying(20)", :primary_key=>false}],
+      [:value, {:oid=>17, :type=>:blob, :allow_null=>true, :default=>nil, :ruby_default=>nil, :db_type=>"bytea", :primary_key=>false}]
     ]
   end
 
@@ -69,73 +69,44 @@ describe "A PostgreSQL database" do
       @db.drop_table(:public__testfk)
     end
   end
+
+  specify "should return uuid fields as strings" do
+    @db.get(Sequel.cast('550e8400-e29b-41d4-a716-446655440000', :uuid)).should == '550e8400-e29b-41d4-a716-446655440000'
+  end
 end
 
 describe "A PostgreSQL dataset" do
   before do
     @d = POSTGRES_DB[:test]
-    @d.delete # remove all records
+    @d.delete
     POSTGRES_DB.sqls.clear
   end
 
   specify "should quote columns and tables using double quotes if quoting identifiers" do
-    @d.select(:name).sql.should == \
-      'SELECT "name" FROM "test"'
-
-    @d.select('COUNT(*)'.lit).sql.should == \
-      'SELECT COUNT(*) FROM "test"'
-
-    @d.select(:max.sql_function(:value)).sql.should == \
-      'SELECT max("value") FROM "test"'
-
-    @d.select(:NOW.sql_function).sql.should == \
-    'SELECT NOW() FROM "test"'
-
-    @d.select(:max.sql_function(:items__value)).sql.should == \
-      'SELECT max("items"."value") FROM "test"'
-
-    @d.order(:name.desc).sql.should == \
-      'SELECT * FROM "test" ORDER BY "name" DESC'
-
-    @d.select('test.name AS item_name'.lit).sql.should == \
-      'SELECT test.name AS item_name FROM "test"'
-
-    @d.select('"name"'.lit).sql.should == \
-      'SELECT "name" FROM "test"'
-
-    @d.select('max(test."name") AS "max_name"'.lit).sql.should == \
-      'SELECT max(test."name") AS "max_name" FROM "test"'
-
-    @d.insert_sql(:x => :y).should =~ \
-      /\AINSERT INTO "test" \("x"\) VALUES \("y"\)( RETURNING NULL)?\z/
+    @d.select(:name).sql.should == 'SELECT "name" FROM "test"'
+    @d.select(Sequel.lit('COUNT(*)')).sql.should == 'SELECT COUNT(*) FROM "test"'
+    @d.select(Sequel.function(:max, :value)).sql.should == 'SELECT max("value") FROM "test"'
+    @d.select(Sequel.function(:NOW)).sql.should == 'SELECT NOW() FROM "test"'
+    @d.select(Sequel.function(:max, :items__value)).sql.should == 'SELECT max("items"."value") FROM "test"'
+    @d.order(Sequel.desc(:name)).sql.should == 'SELECT * FROM "test" ORDER BY "name" DESC'
+    @d.select(Sequel.lit('test.name AS item_name')).sql.should == 'SELECT test.name AS item_name FROM "test"'
+    @d.select(Sequel.lit('"name"')).sql.should == 'SELECT "name" FROM "test"'
+    @d.select(Sequel.lit('max(test."name") AS "max_name"')).sql.should == 'SELECT max(test."name") AS "max_name" FROM "test"'
+    @d.insert_sql(:x => :y).should =~ /\AINSERT INTO "test" \("x"\) VALUES \("y"\)( RETURNING NULL)?\z/
 
     if check_sqls
-      @d.select(:test.sql_function(:abc, 'hello')).sql.should == \
-        "SELECT test(\"abc\", 'hello') FROM \"test\""
-
-      @d.select(:test.sql_function(:abc__def, 'hello')).sql.should == \
-        "SELECT test(\"abc\".\"def\", 'hello') FROM \"test\""
-
-      @d.select(:test.sql_function(:abc__def, 'hello').as(:x2)).sql.should == \
-        "SELECT test(\"abc\".\"def\", 'hello') AS \"x2\" FROM \"test\""
-
-      @d.insert_sql(:value => 333).should =~ \
-        /\AINSERT INTO "test" \("value"\) VALUES \(333\)( RETURNING NULL)?\z/
+      @d.select(Sequel.function(:test, :abc, 'hello')).sql.should == "SELECT test(\"abc\", 'hello') FROM \"test\""
+      @d.select(Sequel.function(:test, :abc__def, 'hello')).sql.should == "SELECT test(\"abc\".\"def\", 'hello') FROM \"test\""
+      @d.select(Sequel.function(:test, :abc__def, 'hello').as(:x2)).sql.should == "SELECT test(\"abc\".\"def\", 'hello') AS \"x2\" FROM \"test\""
+      @d.insert_sql(:value => 333).should =~ /\AINSERT INTO "test" \("value"\) VALUES \(333\)( RETURNING NULL)?\z/
     end
   end
 
   specify "should quote fields correctly when reversing the order if quoting identifiers" do
-    @d.reverse_order(:name).sql.should == \
-      'SELECT * FROM "test" ORDER BY "name" DESC'
-
-    @d.reverse_order(:name.desc).sql.should == \
-      'SELECT * FROM "test" ORDER BY "name" ASC'
-
-    @d.reverse_order(:name, :test.desc).sql.should == \
-      'SELECT * FROM "test" ORDER BY "name" DESC, "test" ASC'
-
-    @d.reverse_order(:name.desc, :test).sql.should == \
-      'SELECT * FROM "test" ORDER BY "name" ASC, "test" DESC'
+    @d.reverse_order(:name).sql.should == 'SELECT * FROM "test" ORDER BY "name" DESC'
+    @d.reverse_order(Sequel.desc(:name)).sql.should == 'SELECT * FROM "test" ORDER BY "name" ASC'
+    @d.reverse_order(:name, Sequel.desc(:test)).sql.should == 'SELECT * FROM "test" ORDER BY "name" DESC, "test" ASC'
+    @d.reverse_order(Sequel.desc(:name), :test).sql.should == 'SELECT * FROM "test" ORDER BY "name" ASC, "test" DESC'
   end
 
   specify "should support regexps" do
@@ -149,9 +120,9 @@ describe "A PostgreSQL dataset" do
     @d << {:name => 'abc'}
     @d << {:name => 'bcd'}
     @d << {:name => 'bcd', :value => 2}
-    @d.order(:value.asc(:nulls=>:first), :name).select_map(:name).should == %w[abc bcd bcd]
-    @d.order(:value.asc(:nulls=>:last), :name).select_map(:name).should == %w[bcd abc bcd]
-    @d.order(:value.asc(:nulls=>:first), :name).reverse.select_map(:name).should == %w[bcd bcd abc]
+    @d.order(Sequel.asc(:value, :nulls=>:first), :name).select_map(:name).should == %w[abc bcd bcd]
+    @d.order(Sequel.asc(:value, :nulls=>:last), :name).select_map(:name).should == %w[bcd abc bcd]
+    @d.order(Sequel.asc(:value, :nulls=>:first), :name).reverse.select_map(:name).should == %w[bcd bcd abc]
   end
 
   specify "#lock should lock tables and yield if a block is given" do
@@ -161,7 +132,7 @@ describe "A PostgreSQL dataset" do
   specify "should support exclusion constraints when creating or altering tables" do
     begin
       @db = POSTGRES_DB
-      @db.create_table!(:atest){Integer :t; exclude [[:t.desc(:nulls=>:last), '=']], :using=>:btree, :where=>proc{t > 0}}
+      @db.create_table!(:atest){Integer :t; exclude [[Sequel.desc(:t, :nulls=>:last), '=']], :using=>:btree, :where=>proc{t > 0}}
       @db[:atest].insert(1)
       @db[:atest].insert(2)
       proc{@db[:atest].insert(2)}.should raise_error(Sequel::DatabaseError)
@@ -200,8 +171,8 @@ describe "A PostgreSQL dataset" do
       @db = POSTGRES_DB
       @db.create_table!(:atest){Integer :t}
       @db[:atest].insert(1262304000)
-      @db.alter_table(:atest){set_column_type :t, Time, :using=>'epoch'.cast(Time) + '1 second'.cast(:interval) * :t}
-      @db[:atest].get(:t.extract(:year)).should == 2010
+      @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)).should == 2010
     ensure
       @db.drop_table?(:atest)
     end
@@ -213,7 +184,7 @@ describe "A PostgreSQL dataset" do
       @db.create_table!(:atest){Integer :t}
       @db[:atest].insert(1262304000)
       @db.alter_table(:atest){set_column_type :t, Time, :using=>"'epoch'::timestamp + '1 second'::interval * t"}
-      @db[:atest].get(:t.extract(:year)).should == 2010
+      @db[:atest].get(Sequel.extract(:year, :t)).should == 2010
     ensure
       @db.drop_table?(:atest)
     end
@@ -341,9 +312,9 @@ describe "Dataset#distinct" do
     @ds.insert(20, 10)
     @ds.insert(30, 10)
     @ds.order(:b, :a).distinct.map(:a).should == [20, 30]
-    @ds.order(:b, :a.desc).distinct.map(:a).should == [30, 20]
+    @ds.order(:b, Sequel.desc(:a)).distinct.map(:a).should == [30, 20]
     @ds.order(:b, :a).distinct(:b).map(:a).should == [20]
-    @ds.order(:b, :a.desc).distinct(:b).map(:a).should == [30]
+    @ds.order(:b, Sequel.desc(:a)).distinct(:b).map(:a).should == [30]
   end
 end
 
@@ -435,7 +406,7 @@ describe "A PostgreSQL dataset with a timestamp field" do
 
   if POSTGRES_DB.adapter_scheme == :postgres
     specify "should handle infinite timestamps if convert_infinite_timestamps is set" do
-      @d << {:time=>'infinity'.cast(:timestamp)}
+      @d << {:time=>Sequel.cast('infinity', :timestamp)}
       @db.convert_infinite_timestamps = :nil
       @db[:test3].get(:time).should == nil
       @db.convert_infinite_timestamps = :string
@@ -443,7 +414,7 @@ describe "A PostgreSQL dataset with a timestamp field" do
       @db.convert_infinite_timestamps = :float
       @db[:test3].get(:time).should == 1.0/0.0
 
-      @d.update(:time=>'-infinity'.cast(:timestamp))
+      @d.update(:time=>Sequel.cast('-infinity', :timestamp))
       @db.convert_infinite_timestamps = :nil
       @db[:test3].get(:time).should == nil
       @db.convert_infinite_timestamps = :string
@@ -730,12 +701,12 @@ describe "Postgres::Database schema qualified tables" do
     POSTGRES_DB[:schema_test__schema_test].first.should == nil
     POSTGRES_DB[:schema_test__schema_test].insert(:i=>1).should == 1
     POSTGRES_DB[:schema_test__schema_test].first.should == {:i=>1}
-    POSTGRES_DB.from('schema_test.schema_test'.lit).first.should == {:i=>1}
+    POSTGRES_DB.from(Sequel.lit('schema_test.schema_test')).first.should == {:i=>1}
     POSTGRES_DB.drop_table(:schema_test__schema_test)
-    POSTGRES_DB.create_table(:schema_test.qualify(:schema_test)){integer :i}
+    POSTGRES_DB.create_table(Sequel.qualify(:schema_test, :schema_test)){integer :i}
     POSTGRES_DB[:schema_test__schema_test].first.should == nil
-    POSTGRES_DB.from('schema_test.schema_test'.lit).first.should == nil
-    POSTGRES_DB.drop_table(:schema_test.qualify(:schema_test))
+    POSTGRES_DB.from(Sequel.lit('schema_test.schema_test')).first.should == nil
+    POSTGRES_DB.drop_table(Sequel.qualify(:schema_test, :schema_test))
   end
 
   specify "#tables should not include tables in a default non-public schema" do
@@ -802,13 +773,13 @@ describe "Postgres::Database schema qualified tables" do
 
   specify "should be able to get custom sequences for tables in a given schema" do
     POSTGRES_DB << "CREATE SEQUENCE schema_test.kseq"
-    POSTGRES_DB.create_table(:schema_test__schema_test){integer :j; primary_key :k, :type=>:integer, :default=>"nextval('schema_test.kseq'::regclass)".lit}
+    POSTGRES_DB.create_table(:schema_test__schema_test){integer :j; primary_key :k, :type=>:integer, :default=>Sequel.lit("nextval('schema_test.kseq'::regclass)")}
     POSTGRES_DB.primary_key_sequence(:schema_test__schema_test).should == '"schema_test".kseq'
   end
 
   specify "should be able to get custom sequences for tables that have spaces in the name in a given schema" do
     POSTGRES_DB << "CREATE SEQUENCE schema_test.\"ks eq\""
-    POSTGRES_DB.create_table(:"schema_test__schema test"){integer :j; primary_key :k, :type=>:integer, :default=>"nextval('schema_test.\"ks eq\"'::regclass)".lit}
+    POSTGRES_DB.create_table(:"schema_test__schema test"){integer :j; primary_key :k, :type=>:integer, :default=>Sequel.lit("nextval('schema_test.\"ks eq\"'::regclass)")}
     POSTGRES_DB.primary_key_sequence(:"schema_test__schema test").should == '"schema_test"."ks eq"'
   end
 
@@ -889,14 +860,14 @@ describe "Postgres::Database schema qualified tables and eager graphing" do
   end
 
   specify "should have eager graphs work with previous joins" do
-    bands = @Band.order(:bands__name).select(:s__bands.*).join(:s__members, :band_id=>:id).from_self(:alias=>:bands0).eager_graph(:albums=>:tracks).all
+    bands = @Band.order(:bands__name).select_all(:s__bands).join(:s__members, :band_id=>:id).from_self(:alias=>:bands0).eager_graph(:albums=>:tracks).all
     bands.should == [@b1, @b2]
     bands.map{|x| x.albums}.should == [[@a1, @a2], [@a3, @a4]]
     bands.map{|x| x.albums.map{|y| y.tracks}}.should == [[[@t1, @t2], [@t3, @t4]], [[], []]]
   end
 
   specify "should have eager graphs work with joins with the same tables" do
-    bands = @Band.order(:bands__name).select(:s__bands.*).join(:s__members, :band_id=>:id).eager_graph({:albums=>:tracks}, :members).all
+    bands = @Band.order(:bands__name).select_all(:s__bands).join(:s__members, :band_id=>:id).eager_graph({:albums=>:tracks}, :members).all
     bands.should == [@b1, @b2]
     bands.map{|x| x.albums}.should == [[@a1, @a2], [@a3, @a4]]
     bands.map{|x| x.albums.map{|y| y.tracks}}.should == [[[@t1, @t2], [@t3, @t4]], [[], []]]
@@ -934,62 +905,62 @@ describe "Postgres::Database schema qualified tables and eager graphing" do
     bands.should == [@b1, @b2]
     bands.map{|x| x.tracks}.should == [[@t1, @t2, @t3, @t4], []]
 
-    bands = @Band.order(:tracks__name).from(:s__bands.as(:tracks)).eager_graph(:tracks).all
+    bands = @Band.order(:tracks__name).from(Sequel.expr(:s__bands).as(:tracks)).eager_graph(:tracks).all
     bands.should == [@b1, @b2]
     bands.map{|x| x.tracks}.should == [[@t1, @t2, @t3, @t4], []]
 
-    bands = @Band.order(:tracks__name).from(:s__bands.as(:tracks.identifier)).eager_graph(:tracks).all
+    bands = @Band.order(:tracks__name).from(Sequel.expr(:s__bands).as(Sequel.identifier(:tracks))).eager_graph(:tracks).all
     bands.should == [@b1, @b2]
     bands.map{|x| x.tracks}.should == [[@t1, @t2, @t3, @t4], []]
 
-    bands = @Band.order(:tracks__name).from(:s__bands.as('tracks')).eager_graph(:tracks).all
+    bands = @Band.order(:tracks__name).from(Sequel.expr(:s__bands).as('tracks')).eager_graph(:tracks).all
     bands.should == [@b1, @b2]
     bands.map{|x| x.tracks}.should == [[@t1, @t2, @t3, @t4], []]
   end
 
   specify "should have eager graphs work with join tables with aliases" do
-    bands = @Band.order(:bands__name).eager_graph(:members).join(:s__albums___tracks, :band_id=>:id.qualify(:s__bands)).eager_graph(:albums=>:tracks).all
+    bands = @Band.order(:bands__name).eager_graph(:members).join(:s__albums___tracks, :band_id=>Sequel.qualify(:s__bands, :id)).eager_graph(:albums=>:tracks).all
     bands.should == [@b1, @b2]
     bands.map{|x| x.albums}.should == [[@a1, @a2], [@a3, @a4]]
     bands.map{|x| x.members}.should == [[@m1, @m2], [@m4, @m3]]
 
-    bands = @Band.order(:bands__name).eager_graph(:members).join(:s__albums.as(:tracks), :band_id=>:id.qualify(:s__bands)).eager_graph(:albums=>:tracks).all
+    bands = @Band.order(:bands__name).eager_graph(:members).join(Sequel.as(:s__albums, :tracks), :band_id=>Sequel.qualify(:s__bands, :id)).eager_graph(:albums=>:tracks).all
     bands.should == [@b1, @b2]
     bands.map{|x| x.albums}.should == [[@a1, @a2], [@a3, @a4]]
     bands.map{|x| x.members}.should == [[@m1, @m2], [@m4, @m3]]
 
-    bands = @Band.order(:bands__name).eager_graph(:members).join(:s__albums.as('tracks'), :band_id=>:id.qualify(:s__bands)).eager_graph(:albums=>:tracks).all
+    bands = @Band.order(:bands__name).eager_graph(:members).join(Sequel.as(:s__albums, 'tracks'), :band_id=>Sequel.qualify(:s__bands, :id)).eager_graph(:albums=>:tracks).all
     bands.should == [@b1, @b2]
     bands.map{|x| x.albums}.should == [[@a1, @a2], [@a3, @a4]]
     bands.map{|x| x.members}.should == [[@m1, @m2], [@m4, @m3]]
 
-    bands = @Band.order(:bands__name).eager_graph(:members).join(:s__albums.as(:tracks.identifier), :band_id=>:id.qualify(:s__bands)).eager_graph(:albums=>:tracks).all
+    bands = @Band.order(:bands__name).eager_graph(:members).join(Sequel.as(:s__albums, Sequel.identifier(:tracks)), :band_id=>Sequel.qualify(:s__bands, :id)).eager_graph(:albums=>:tracks).all
     bands.should == [@b1, @b2]
     bands.map{|x| x.albums}.should == [[@a1, @a2], [@a3, @a4]]
     bands.map{|x| x.members}.should == [[@m1, @m2], [@m4, @m3]]
 
-    bands = @Band.order(:bands__name).eager_graph(:members).join(:s__albums, {:band_id=>:id.qualify(:s__bands)}, :table_alias=>:tracks).eager_graph(:albums=>:tracks).all
+    bands = @Band.order(:bands__name).eager_graph(:members).join(:s__albums, {:band_id=>Sequel.qualify(:s__bands, :id)}, :table_alias=>:tracks).eager_graph(:albums=>:tracks).all
     bands.should == [@b1, @b2]
     bands.map{|x| x.albums}.should == [[@a1, @a2], [@a3, @a4]]
     bands.map{|x| x.members}.should == [[@m1, @m2], [@m4, @m3]]
 
-    bands = @Band.order(:bands__name).eager_graph(:members).join(:s__albums, {:band_id=>:id.qualify(:s__bands)}, :table_alias=>'tracks').eager_graph(:albums=>:tracks).all
+    bands = @Band.order(:bands__name).eager_graph(:members).join(:s__albums, {:band_id=>Sequel.qualify(:s__bands, :id)}, :table_alias=>'tracks').eager_graph(:albums=>:tracks).all
     bands.should == [@b1, @b2]
     bands.map{|x| x.albums}.should == [[@a1, @a2], [@a3, @a4]]
     bands.map{|x| x.members}.should == [[@m1, @m2], [@m4, @m3]]
 
-    bands = @Band.order(:bands__name).eager_graph(:members).join(:s__albums, {:band_id=>:id.qualify(:s__bands)}, :table_alias=>:tracks.identifier).eager_graph(:albums=>:tracks).all
+    bands = @Band.order(:bands__name).eager_graph(:members).join(:s__albums, {:band_id=>Sequel.qualify(:s__bands, :id)}, :table_alias=>Sequel.identifier(:tracks)).eager_graph(:albums=>:tracks).all
     bands.should == [@b1, @b2]
     bands.map{|x| x.albums}.should == [[@a1, @a2], [@a3, @a4]]
     bands.map{|x| x.members}.should == [[@m1, @m2], [@m4, @m3]]
   end
 
   specify "should have eager graphs work with different types of qualified from tables" do
-    bands = @Band.order(:bands__name).from(:bands.qualify(:s)).eager_graph(:tracks).all
+    bands = @Band.order(:bands__name).from(Sequel.qualify(:s, :bands)).eager_graph(:tracks).all
     bands.should == [@b1, @b2]
     bands.map{|x| x.tracks}.should == [[@t1, @t2, @t3, @t4], []]
 
-    bands = @Band.order(:bands__name).from(:bands.identifier.qualify(:s)).eager_graph(:tracks).all
+    bands = @Band.order(:bands__name).from(Sequel.identifier(:bands).qualify(:s)).eager_graph(:tracks).all
     bands.should == [@b1, @b2]
     bands.map{|x| x.tracks}.should == [[@t1, @t2, @t3, @t4], []]
 
@@ -1195,7 +1166,7 @@ if POSTGRES_DB.adapter_scheme == :postgres
 
     specify "should look up conversion procs by name" do
       @db.create_table!(:foo){interval :bar}
-      @db[:foo].insert('21 days'.cast(:interval))
+      @db[:foo].insert(Sequel.cast('21 days', :interval))
       @db[:foo].get(:bar).should == 'syad 12'
     end
   end
@@ -1406,7 +1377,7 @@ describe 'PostgreSQL array handling' do
       column :dp, 'double precision[]'
     end
     @tp.call.should == [:integer_array, :integer_array, :bigint_array, :float_array, :float_array]
-    @ds.insert([1].pg_array(:int2), [nil, 2].pg_array(:int4), [3, nil].pg_array(:int8), [4, nil, 4.5].pg_array(:real), [5, nil, 5.5].pg_array("double precision"))
+    @ds.insert(Sequel.pg_array([1], :int2), Sequel.pg_array([nil, 2], :int4), Sequel.pg_array([3, nil], :int8), Sequel.pg_array([4, nil, 4.5], :real), Sequel.pg_array([5, nil, 5.5], "double precision"))
     @ds.count.should == 1
     rs = @ds.all
     if @jdbc || @native
@@ -1421,7 +1392,7 @@ describe 'PostgreSQL array handling' do
     end
 
     @ds.delete
-    @ds.insert([[1], [2]].pg_array(:int2), [[nil, 2], [3, 4]].pg_array(:int4), [[3, nil], [nil, nil]].pg_array(:int8), [[4, nil], [nil, 4.5]].pg_array(:real), [[5, nil], [nil, 5.5]].pg_array("double precision"))
+    @ds.insert(Sequel.pg_array([[1], [2]], :int2), Sequel.pg_array([[nil, 2], [3, 4]], :int4), Sequel.pg_array([[3, nil], [nil, nil]], :int8), Sequel.pg_array([[4, nil], [nil, 4.5]], :real), Sequel.pg_array([[5, nil], [nil, 5.5]], "double precision"))
 
     rs = @ds.all
     if @jdbc || @native
@@ -1441,7 +1412,7 @@ describe 'PostgreSQL array handling' do
       column :n, 'numeric[]'
     end
     @tp.call.should == [:decimal_array]
-    @ds.insert([BigDecimal.new('1.000000000000000000001'), nil, BigDecimal.new('1')].pg_array(:numeric))
+    @ds.insert(Sequel.pg_array([BigDecimal.new('1.000000000000000000001'), nil, BigDecimal.new('1')], :numeric))
     @ds.count.should == 1
     rs = @ds.all
     if @jdbc || @native
@@ -1456,7 +1427,7 @@ describe 'PostgreSQL array handling' do
     end
 
     @ds.delete
-    @ds.insert([[BigDecimal.new('1.0000000000000000000000000000001'), nil], [nil, BigDecimal.new('1')]].pg_array(:numeric))
+    @ds.insert(Sequel.pg_array([[BigDecimal.new('1.0000000000000000000000000000001'), nil], [nil, BigDecimal.new('1')]], :numeric))
     rs = @ds.all
     if @jdbc || @native
       rs.should == [{:n=>[[BigDecimal.new('1.0000000000000000000000000000001'), nil], [nil, BigDecimal.new('1')]]}]
@@ -1477,7 +1448,7 @@ describe 'PostgreSQL array handling' do
       column :t, 'text[]'
     end
     @tp.call.should == [:string_array, :string_array, :string_array]
-    @ds.insert(['a', nil, 'NULL', 'b"\'c'].pg_array('char(4)'), ['a', nil, 'NULL', 'b"\'c'].pg_array(:varchar), ['a', nil, 'NULL', 'b"\'c'].pg_array(:text))
+    @ds.insert(Sequel.pg_array(['a', nil, 'NULL', 'b"\'c'], 'char(4)'), Sequel.pg_array(['a', nil, 'NULL', 'b"\'c'], :varchar), Sequel.pg_array(['a', nil, 'NULL', 'b"\'c'], :text))
     @ds.count.should == 1
     rs = @ds.all
     if @jdbc || @native
@@ -1492,7 +1463,7 @@ describe 'PostgreSQL array handling' do
     end
 
     @ds.delete
-    @ds.insert([[['a'], [nil]], [['NULL'], ['b"\'c']]].pg_array('char(4)'), [[['a'], ['']], [['NULL'], ['b"\'c']]].pg_array(:varchar), [[['a'], [nil]], [['NULL'], ['b"\'c']]].pg_array(:text))
+    @ds.insert(Sequel.pg_array([[['a'], [nil]], [['NULL'], ['b"\'c']]], 'char(4)'), Sequel.pg_array([[['a'], ['']], [['NULL'], ['b"\'c']]], :varchar), Sequel.pg_array([[['a'], [nil]], [['NULL'], ['b"\'c']]], :text))
     rs = @ds.all
     if @jdbc || @native
       rs.should == [{:c=>[[['a   '], [nil]], [['NULL'], ['b"\'c']]], :vc=>[[['a'], ['']], [['NULL'], ['b"\'c']]], :t=>[[['a'], [nil]], [['NULL'], ['b"\'c']]]}]
@@ -1520,7 +1491,7 @@ describe 'PostgreSQL array handling' do
     t = Sequel::SQLTime.create(10, 20, 30)
     ts = Time.local(2011, 1, 2, 3, 4, 5)
 
-    @ds.insert([true, false].pg_array(:bool), [d, nil].pg_array(:date), [t, nil].pg_array(:time), [ts, nil].pg_array(:timestamp), [ts, nil].pg_array(:timestamptz))
+    @ds.insert(Sequel.pg_array([true, false], :bool), Sequel.pg_array([d, nil], :date), Sequel.pg_array([t, nil], :time), Sequel.pg_array([ts, nil], :timestamp), Sequel.pg_array([ts, nil], :timestamptz))
     @ds.count.should == 1
     rs = @ds.all
     if @jdbc || @native
@@ -1540,7 +1511,7 @@ describe 'PostgreSQL array handling' do
       column :o, 'oid[]'
     end
     @tp.call.should == [:blob_array, :time_timezone_array, :integer_array]
-    @ds.insert( [Sequel.blob("a\0"), nil].pg_array(:bytea), [t, nil].pg_array(:timetz), [1, 2, 3].pg_array(:oid))
+    @ds.insert(Sequel.pg_array([Sequel.blob("a\0"), nil], :bytea), Sequel.pg_array([t, nil], :timetz), Sequel.pg_array([1, 2, 3], :oid))
     @ds.count.should == 1
     if @native
       rs = @ds.all
@@ -1566,7 +1537,7 @@ describe 'PostgreSQL array handling' do
       column :i, 'text[]'
     end
     a = ["\"\\\\\"{}\n\t\r \v\b123afP", 'NULL', nil, '']
-    @ds.call(:insert, {:i=>:$i}, :i=>a.pg_array)
+    @ds.call(:insert, {:i=>:$i}, :i=>Sequel.pg_array(a))
     @ds.get(:i).should == a
     @ds.filter(:i=>:$i).call(:first, :i=>a).should == {:i=>a}
     @ds.filter(:i=>:$i).call(:first, :i=>['', nil, nil, 'a']).should == nil
@@ -1575,37 +1546,37 @@ describe 'PostgreSQL array handling' do
       column :i, 'date[]'
     end
     a = [Date.today]
-    @ds.call(:insert, {:i=>:$i}, :i=>a.pg_array('date'))
+    @ds.call(:insert, {:i=>:$i}, :i=>Sequel.pg_array(a, 'date'))
     @ds.get(:i).should == a
     @ds.filter(:i=>:$i).call(:first, :i=>a).should == {:i=>a}
-    @ds.filter(:i=>:$i).call(:first, :i=>[Date.today-1].pg_array('date')).should == nil
+    @ds.filter(:i=>:$i).call(:first, :i=>Sequel.pg_array([Date.today-1], 'date')).should == nil
 
     @db.create_table!(:items) do
       column :i, 'timestamp[]'
     end
     a = [Time.local(2011, 1, 2, 3, 4, 5)]
-    @ds.call(:insert, {:i=>:$i}, :i=>a.pg_array('timestamp'))
+    @ds.call(:insert, {:i=>:$i}, :i=>Sequel.pg_array(a, 'timestamp'))
     @ds.get(:i).should == a
     @ds.filter(:i=>:$i).call(:first, :i=>a).should == {:i=>a}
-    @ds.filter(:i=>:$i).call(:first, :i=>[a.first-1].pg_array('timestamp')).should == nil
+    @ds.filter(:i=>:$i).call(:first, :i=>Sequel.pg_array([a.first-1], 'timestamp')).should == nil
 
     @db.create_table!(:items) do
       column :i, 'boolean[]'
     end
     a = [true, false]
-    @ds.call(:insert, {:i=>:$i}, :i=>a.pg_array('boolean'))
+    @ds.call(:insert, {:i=>:$i}, :i=>Sequel.pg_array(a, 'boolean'))
     @ds.get(:i).should == a
     @ds.filter(:i=>:$i).call(:first, :i=>a).should == {:i=>a}
-    @ds.filter(:i=>:$i).call(:first, :i=>[false, true].pg_array('boolean')).should == nil
+    @ds.filter(:i=>:$i).call(:first, :i=>Sequel.pg_array([false, true], 'boolean')).should == nil
 
     @db.create_table!(:items) do
       column :i, 'bytea[]'
     end
     a = [Sequel.blob("a\0'\"")]
-    @ds.call(:insert, {:i=>:$i}, :i=>a.pg_array('bytea'))
+    @ds.call(:insert, {:i=>:$i}, :i=>Sequel.pg_array(a, 'bytea'))
     @ds.get(:i).should == a
     @ds.filter(:i=>:$i).call(:first, :i=>a).should == {:i=>a}
-    @ds.filter(:i=>:$i).call(:first, :i=>[Sequel.blob("b\0")].pg_array('bytea')).should == nil
+    @ds.filter(:i=>:$i).call(:first, :i=>Sequel.pg_array([Sequel.blob("b\0")], 'bytea')).should == nil
   end if POSTGRES_DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG
 
   specify 'with models' do
@@ -1617,7 +1588,7 @@ describe 'PostgreSQL array handling' do
       column :t, 'text[]'
     end
     c = Class.new(Sequel::Model(@db[:items]))
-    c.plugin :typecast_on_load, :i, :f, :d, :t unless @native
+    c.plugin :pg_typecast_on_load, :i, :f, :d, :t unless @native
     o = c.create(:i=>[1,2, nil], :f=>[[1, 2.5], [3, 4.5]], :d=>[1, BigDecimal.new('1.000000000000000000001')], :t=>[%w'a b c', ['NULL', nil, '1']])
     o.i.should == [1, 2, nil]
     o.f.should == [[1, 2.5], [3, 4.5]]
@@ -1628,56 +1599,56 @@ describe 'PostgreSQL array handling' do
   specify 'operations/functions with pg_array_ops' do
     Sequel.extension :pg_array_ops
     @db.create_table!(:items){column :i, 'integer[]'; column :i2, 'integer[]'; column :i3, 'integer[]'; column :i4, 'integer[]'; column :i5, 'integer[]'}
-    @ds.insert([1, 2, 3].pg_array, [2, 1].pg_array, [4, 4].pg_array, [[5, 5], [4, 3]].pg_array, [1, nil, 5].pg_array)
+    @ds.insert(Sequel.pg_array([1, 2, 3]), Sequel.pg_array([2, 1]), Sequel.pg_array([4, 4]), Sequel.pg_array([[5, 5], [4, 3]]), Sequel.pg_array([1, nil, 5]))
 
-    @ds.get(:i.pg_array > :i3).should be_false
-    @ds.get(:i3.pg_array > :i).should be_true
+    @ds.get(Sequel.pg_array(:i) > :i3).should be_false
+    @ds.get(Sequel.pg_array(:i3) > :i).should be_true
 
-    @ds.get(:i.pg_array >= :i3).should be_false
-    @ds.get(:i.pg_array >= :i).should be_true
+    @ds.get(Sequel.pg_array(:i) >= :i3).should be_false
+    @ds.get(Sequel.pg_array(:i) >= :i).should be_true
 
-    @ds.get(:i3.pg_array < :i).should be_false
-    @ds.get(:i.pg_array < :i3).should be_true
+    @ds.get(Sequel.pg_array(:i3) < :i).should be_false
+    @ds.get(Sequel.pg_array(:i) < :i3).should be_true
 
-    @ds.get(:i3.pg_array <= :i).should be_false
-    @ds.get(:i.pg_array <= :i).should be_true
+    @ds.get(Sequel.pg_array(:i3) <= :i).should be_false
+    @ds.get(Sequel.pg_array(:i) <= :i).should be_true
 
-    @ds.get({5=>:i.pg_array.any}.sql_expr).should be_false
-    @ds.get({1=>:i.pg_array.any}.sql_expr).should be_true
+    @ds.get(Sequel.expr(5=>Sequel.pg_array(:i).any)).should be_false
+    @ds.get(Sequel.expr(1=>Sequel.pg_array(:i).any)).should be_true
 
-    @ds.get({1=>:i3.pg_array.all}.sql_expr).should be_false
-    @ds.get({4=>:i3.pg_array.all}.sql_expr).should be_true
+    @ds.get(Sequel.expr(1=>Sequel.pg_array(:i3).all)).should be_false
+    @ds.get(Sequel.expr(4=>Sequel.pg_array(:i3).all)).should be_true
 
-    @ds.get(:i2.pg_array[1]).should == 2
-    @ds.get(:i2.pg_array[2]).should == 1
+    @ds.get(Sequel.pg_array(:i2)[1]).should == 2
+    @ds.get(Sequel.pg_array(:i2)[2]).should == 1
 
-    @ds.get(:i4.pg_array[2][1]).should == 4
-    @ds.get(:i4.pg_array[2][2]).should == 3
+    @ds.get(Sequel.pg_array(:i4)[2][1]).should == 4
+    @ds.get(Sequel.pg_array(:i4)[2][2]).should == 3
 
-    @ds.get(:i.pg_array.contains(:i2)).should be_true
-    @ds.get(:i.pg_array.contains(:i3)).should be_false
+    @ds.get(Sequel.pg_array(:i).contains(:i2)).should be_true
+    @ds.get(Sequel.pg_array(:i).contains(:i3)).should be_false
 
-    @ds.get(:i2.pg_array.contained_by(:i)).should be_true
-    @ds.get(:i.pg_array.contained_by(:i2)).should be_false
+    @ds.get(Sequel.pg_array(:i2).contained_by(:i)).should be_true
+    @ds.get(Sequel.pg_array(:i).contained_by(:i2)).should be_false
 
-    @ds.get(:i.pg_array.overlaps(:i2)).should be_true
-    @ds.get(:i2.pg_array.overlaps(:i3)).should be_false
+    @ds.get(Sequel.pg_array(:i).overlaps(:i2)).should be_true
+    @ds.get(Sequel.pg_array(:i2).overlaps(:i3)).should be_false
 
-    @ds.get(:i.pg_array.dims).should == '[1:3]'
-    @ds.get(:i.pg_array.length).should == 3
-    @ds.get(:i.pg_array.lower).should == 1
+    @ds.get(Sequel.pg_array(:i).dims).should == '[1:3]'
+    @ds.get(Sequel.pg_array(:i).length).should == 3
+    @ds.get(Sequel.pg_array(:i).lower).should == 1
 
     if @db.server_version >= 90000
-      @ds.get(:i5.pg_array.join).should == '15'
-      @ds.get(:i5.pg_array.join(':')).should == '1:5'
-      @ds.get(:i5.pg_array.join(':', '*')).should == '1:*:5'
+      @ds.get(Sequel.pg_array(:i5).join).should == '15'
+      @ds.get(Sequel.pg_array(:i5).join(':')).should == '1:5'
+      @ds.get(Sequel.pg_array(:i5).join(':', '*')).should == '1:*:5'
     end
-    @ds.select(:i.pg_array.unnest).from_self.count.should == 3 if @db.server_version >= 80400
+    @ds.select(Sequel.pg_array(:i).unnest).from_self.count.should == 3 if @db.server_version >= 80400
 
     if @native
-      @ds.get(:i.pg_array.push(4)).should == [1, 2, 3, 4]
-      @ds.get(:i.pg_array.unshift(4)).should == [4, 1, 2, 3]
-      @ds.get(:i.pg_array.concat(:i2)).should == [1, 2, 3, 2, 1]
+      @ds.get(Sequel.pg_array(:i).push(4)).should == [1, 2, 3, 4]
+      @ds.get(Sequel.pg_array(:i).unshift(4)).should == [4, 1, 2, 3]
+      @ds.get(Sequel.pg_array(:i).concat(:i2)).should == [1, 2, 3, 2, 1]
     end
   end
 end
@@ -1698,7 +1669,7 @@ describe 'PostgreSQL hstore handling' do
     @db.create_table!(:items) do
       column :h, :hstore
     end
-    @ds.insert(@h.hstore)
+    @ds.insert(Sequel.hstore(@h))
     @ds.count.should == 1
     if @native
       rs = @ds.all
@@ -1716,10 +1687,10 @@ describe 'PostgreSQL hstore handling' do
     @db.create_table!(:items) do
       column :i, :hstore
     end
-    @ds.call(:insert, {:i=>@h.hstore}, {:i=>:$i})
+    @ds.call(:insert, {:i=>Sequel.hstore(@h)}, {:i=>:$i})
     @ds.get(:i).should == @h
-    @ds.filter(:i=>:$i).call(:first, :i=>@h.hstore).should == {:i=>@h}
-    @ds.filter(:i=>:$i).call(:first, :i=>{}.hstore).should == nil
+    @ds.filter(:i=>:$i).call(:first, :i=>Sequel.hstore(@h)).should == {:i=>@h}
+    @ds.filter(:i=>:$i).call(:first, :i=>Sequel.hstore({})).should == nil
 
     @ds.delete
     @ds.call(:insert, {:i=>@h}, {:i=>:$i})
@@ -1747,33 +1718,33 @@ describe 'PostgreSQL hstore handling' do
     end
     Sequel.extension :pg_hstore_ops
     c.plugin :many_through_many
-    c.plugin :typecast_on_load, :h unless @native
+    c.plugin :pg_typecast_on_load, :h unless @native
 
     h = {'item_id'=>"2", 'left_item_id'=>"1"}
     o2 = c.create(:id=>2)
     o = c.create(:id=>1, :h=>h)
     o.h.should == h
 
-    c.many_to_one :item, :class=>c, :key_column=>Sequel.cast(:h.hstore['item_id'], Integer)
-    c.one_to_many :items, :class=>c, :key=>Sequel.cast(:h.hstore['item_id'], Integer), :key_method=>:item_id
-    c.many_to_many :related_items, :class=>c, :join_table=>:items___i, :left_key=>Sequel.cast(:h.hstore['left_item_id'], Integer), :right_key=>Sequel.cast(:h.hstore['item_id'], Integer)
+    c.many_to_one :item, :class=>c, :key_column=>Sequel.cast(Sequel.hstore(:h)['item_id'], Integer)
+    c.one_to_many :items, :class=>c, :key=>Sequel.cast(Sequel.hstore(:h)['item_id'], Integer), :key_method=>:item_id
+    c.many_to_many :related_items, :class=>c, :join_table=>:items___i, :left_key=>Sequel.cast(Sequel.hstore(:h)['left_item_id'], Integer), :right_key=>Sequel.cast(Sequel.hstore(:h)['item_id'], Integer)
 
-    c.many_to_one :other_item, :class=>c, :key=>:id, :primary_key_method=>:item_id, :primary_key=>Sequel.cast(:h.hstore['item_id'], Integer)
-    c.one_to_many :other_items, :class=>c, :primary_key=>:item_id, :key=>:id, :primary_key_column=>Sequel.cast(:h.hstore['item_id'], Integer)
+    c.many_to_one :other_item, :class=>c, :key=>:id, :primary_key_method=>:item_id, :primary_key=>Sequel.cast(Sequel.hstore(:h)['item_id'], Integer)
+    c.one_to_many :other_items, :class=>c, :primary_key=>:item_id, :key=>:id, :primary_key_column=>Sequel.cast(Sequel.hstore(:h)['item_id'], Integer)
     c.many_to_many :other_related_items, :class=>c, :join_table=>:items___i, :left_key=>:id, :right_key=>:id,
-      :left_primary_key_column=>Sequel.cast(:h.hstore['left_item_id'], Integer),
+      :left_primary_key_column=>Sequel.cast(Sequel.hstore(:h)['left_item_id'], Integer),
       :left_primary_key=>:left_item_id,
-      :right_primary_key=>Sequel.cast(:h.hstore['left_item_id'], Integer),
+      :right_primary_key=>Sequel.cast(Sequel.hstore(:h)['left_item_id'], Integer),
       :right_primary_key_method=>:left_item_id
 
     c.many_through_many :mtm_items, [
-        [:items, Sequel.cast(:h.hstore['item_id'], Integer), Sequel.cast(:h.hstore['left_item_id'], Integer)],
-        [:items, Sequel.cast(:h.hstore['left_item_id'], Integer), Sequel.cast(:h.hstore['left_item_id'], Integer)]
+        [:items, Sequel.cast(Sequel.hstore(:h)['item_id'], Integer), Sequel.cast(Sequel.hstore(:h)['left_item_id'], Integer)],
+        [:items, Sequel.cast(Sequel.hstore(:h)['left_item_id'], Integer), Sequel.cast(Sequel.hstore(:h)['left_item_id'], Integer)]
       ],
       :class=>c,
-      :left_primary_key_column=>Sequel.cast(:h.hstore['item_id'], Integer),
+      :left_primary_key_column=>Sequel.cast(Sequel.hstore(:h)['item_id'], Integer),
       :left_primary_key=>:item_id,
-      :right_primary_key=>Sequel.cast(:h.hstore['left_item_id'], Integer),
+      :right_primary_key=>Sequel.cast(Sequel.hstore(:h)['left_item_id'], Integer),
       :right_primary_key_method=>:left_item_id
 
     # Lazily Loading
@@ -1827,10 +1798,10 @@ describe 'PostgreSQL hstore handling' do
   specify 'operations/functions with pg_hstore_ops' do
     Sequel.extension :pg_hstore_ops, :pg_array, :pg_array_ops
     @db.create_table!(:items){hstore :h1; hstore :h2; hstore :h3; String :t}
-    @ds.insert({'a'=>'b', 'c'=>nil}.hstore, {'a'=>'b'}.hstore, {'d'=>'e'}.hstore)
-    h1 = :h1.hstore
-    h2 = :h2.hstore
-    h3 = :h3.hstore
+    @ds.insert(Sequel.hstore('a'=>'b', 'c'=>nil), Sequel.hstore('a'=>'b'), Sequel.hstore('d'=>'e'))
+    h1 = Sequel.hstore(:h1)
+    h2 = Sequel.hstore(:h2)
+    h3 = Sequel.hstore(:h3)
     
     @ds.get(h1['a']).should == 'b'
     @ds.get(h1['d']).should == nil
@@ -1840,13 +1811,13 @@ describe 'PostgreSQL hstore handling' do
     @ds.get(h2.merge(h3).keys.pg_array.length).should == 2
     @ds.get(h1.merge(h3).keys.pg_array.length).should == 3
 
-    unless @db.adapter_scheme == :do
+    unless [:do].include?(@db.adapter_scheme)
       # Broken DataObjects thinks operators with ? represent placeholders
-      @ds.get(h1.contain_all(%w'a c'.pg_array)).should == true
-      @ds.get(h1.contain_all(%w'a d'.pg_array)).should == false
+      @ds.get(h1.contain_all(Sequel.pg_array(%w'a c'))).should == true
+      @ds.get(h1.contain_all(Sequel.pg_array(%w'a d'))).should == false
 
-      @ds.get(h1.contain_any(%w'a d'.pg_array)).should == true
-      @ds.get(h1.contain_any(%w'e d'.pg_array)).should == false
+      @ds.get(h1.contain_any(Sequel.pg_array(%w'a d'))).should == true
+      @ds.get(h1.contain_any(Sequel.pg_array(%w'e d'))).should == false
     end
 
     @ds.get(h1.contains(h2)).should == true
@@ -1860,12 +1831,12 @@ describe 'PostgreSQL hstore handling' do
     @ds.get(h1.defined('d')).should == false
 
     @ds.get(h1.delete('a')['c']).should == nil
-    @ds.get(h1.delete(%w'a d'.pg_array)['c']).should == nil
+    @ds.get(h1.delete(Sequel.pg_array(%w'a d'))['c']).should == nil
     @ds.get(h1.delete(h2)['c']).should == nil
 
-    @ds.from({'a'=>'b', 'c'=>nil}.hstore.op.each).order(:key).all.should == [{:key=>'a', :value=>'b'}, {:key=>'c', :value=>nil}]
+    @ds.from(Sequel.hstore('a'=>'b', 'c'=>nil).op.each).order(:key).all.should == [{:key=>'a', :value=>'b'}, {:key=>'c', :value=>nil}]
 
-    unless @db.adapter_scheme == :do
+    unless [:do].include?(@db.adapter_scheme)
       @ds.get(h1.has_key?('c')).should == true
       @ds.get(h1.include?('c')).should == true
       @ds.get(h1.key?('c')).should == true
@@ -1884,16 +1855,16 @@ describe 'PostgreSQL hstore handling' do
     @ds.get(h1.akeys.pg_array.length).should == 2
     @ds.get(h2.akeys.pg_array.length).should == 1
 
-    @ds.from({'t'=>'s'}.hstore.op.populate(Sequel::SQL::Cast.new(nil, :items))).select_map(:t).should == ['s']
-    @ds.from(:items___i).select({'t'=>'s'}.hstore.op.record_set(:i).as(:r)).from_self(:alias=>:s).select('(r).*'.lit).from_self.select_map(:t).should == ['s']
+    @ds.from(Sequel.hstore('t'=>'s').op.populate(Sequel::SQL::Cast.new(nil, :items))).select_map(:t).should == ['s']
+    @ds.from(:items___i).select(Sequel.hstore('t'=>'s').op.record_set(:i).as(:r)).from_self(:alias=>:s).select(Sequel.lit('(r).*')).from_self.select_map(:t).should == ['s']
 
-    @ds.from({'t'=>'s', 'a'=>'b'}.hstore.op.skeys.as(:s)).select_order_map(:s).should == %w'a t'
+    @ds.from(Sequel.hstore('t'=>'s', 'a'=>'b').op.skeys.as(:s)).select_order_map(:s).should == %w'a t'
 
-    @ds.get(h1.slice(%w'a c'.pg_array).keys.pg_array.length).should == 2
-    @ds.get(h1.slice(%w'd c'.pg_array).keys.pg_array.length).should == 1
-    @ds.get(h1.slice(%w'd e'.pg_array).keys.pg_array.length).should == nil
+    @ds.get(h1.slice(Sequel.pg_array(%w'a c')).keys.pg_array.length).should == 2
+    @ds.get(h1.slice(Sequel.pg_array(%w'd c')).keys.pg_array.length).should == 1
+    @ds.get(h1.slice(Sequel.pg_array(%w'd e')).keys.pg_array.length).should == nil
 
-    @ds.from({'t'=>'s', 'a'=>'b'}.hstore.op.svals.as(:s)).select_order_map(:s).should == %w'b s'
+    @ds.from(Sequel.hstore('t'=>'s', 'a'=>'b').op.svals.as(:s)).select_order_map(:s).should == %w'b s'
 
     @ds.get(h1.to_array.pg_array.length).should == 4
     @ds.get(h2.to_array.pg_array.length).should == 2
@@ -1923,7 +1894,7 @@ describe 'PostgreSQL json type' do
 
   specify 'insert and retrieve json values' do
     @db.create_table!(:items){json :j}
-    @ds.insert(@h.pg_json)
+    @ds.insert(Sequel.pg_json(@h))
     @ds.count.should == 1
     if @native
       rs = @ds.all
@@ -1938,7 +1909,7 @@ describe 'PostgreSQL json type' do
     end
 
     @ds.delete
-    @ds.insert(@a.pg_json)
+    @ds.insert(Sequel.pg_json(@a))
     @ds.count.should == 1
     if @native
       rs = @ds.all
@@ -1955,7 +1926,7 @@ describe 'PostgreSQL json type' do
 
   specify 'insert and retrieve json[] values' do
     @db.create_table!(:items){column :j, 'json[]'}
-    j = [{'a'=>1}.pg_json, ['b', 2].pg_json].pg_array
+    j = Sequel.pg_array([Sequel.pg_json('a'=>1), Sequel.pg_json(['b', 2])])
     @ds.insert(j)
     @ds.count.should == 1
     if @native
@@ -1973,23 +1944,23 @@ describe 'PostgreSQL json type' do
 
   specify 'use json in bound variables' do
     @db.create_table!(:items){json :i}
-    @ds.call(:insert, {:i=>@h.pg_json}, {:i=>:$i})
+    @ds.call(:insert, {:i=>Sequel.pg_json(@h)}, {:i=>:$i})
     @ds.get(:i).should == @h
-    @ds.filter(:i.cast(String)=>:$i).call(:first, :i=>@h.pg_json).should == {:i=>@h}
-    @ds.filter(:i.cast(String)=>:$i).call(:first, :i=>{}.pg_json).should == nil
-    @ds.filter(:i.cast(String)=>:$i).call(:delete, :i=>@h.pg_json).should == 1
+    @ds.filter(Sequel.cast(:i, String)=>:$i).call(:first, :i=>Sequel.pg_json(@h)).should == {:i=>@h}
+    @ds.filter(Sequel.cast(:i, String)=>:$i).call(:first, :i=>Sequel.pg_json({})).should == nil
+    @ds.filter(Sequel.cast(:i, String)=>:$i).call(:delete, :i=>Sequel.pg_json(@h)).should == 1
 
-    @ds.call(:insert, {:i=>@a.pg_json}, {:i=>:$i})
+    @ds.call(:insert, {:i=>Sequel.pg_json(@a)}, {:i=>:$i})
     @ds.get(:i).should == @a
-    @ds.filter(:i.cast(String)=>:$i).call(:first, :i=>@a.pg_json).should == {:i=>@a}
-    @ds.filter(:i.cast(String)=>:$i).call(:first, :i=>[].pg_json).should == nil
+    @ds.filter(Sequel.cast(:i, String)=>:$i).call(:first, :i=>Sequel.pg_json(@a)).should == {:i=>@a}
+    @ds.filter(Sequel.cast(:i, String)=>:$i).call(:first, :i=>Sequel.pg_json([])).should == nil
 
     @db.create_table!(:items){column :i, 'json[]'}
-    j = [{'a'=>1}.pg_json, ['b', 2].pg_json].pg_array(:text)
+    j = Sequel.pg_array([Sequel.pg_json('a'=>1), Sequel.pg_json(['b', 2])], :text)
     @ds.call(:insert, {:i=>j}, {:i=>:$i})
     @ds.get(:i).should == j
-    @ds.filter(:i.cast('text[]')=>:$i).call(:first, :i=>j).should == {:i=>j}
-    @ds.filter(:i.cast('text[]')=>:$i).call(:first, :i=>[].pg_array).should == nil
+    @ds.filter(Sequel.cast(:i, 'text[]')=>:$i).call(:first, :i=>j).should == {:i=>j}
+    @ds.filter(Sequel.cast(:i, 'text[]')=>:$i).call(:first, :i=>Sequel.pg_array([])).should == nil
   end if POSTGRES_DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG
 
   specify 'with models' do
@@ -1998,9 +1969,9 @@ describe 'PostgreSQL json type' do
       json :h
     end
     c = Class.new(Sequel::Model(@db[:items]))
-    c.plugin :typecast_on_load, :h unless @native
-    c.create(:h=>@h.pg_json).h.should == @h
-    c.create(:h=>@a.pg_json).h.should == @a
+    c.plugin :pg_typecast_on_load, :h unless @native
+    c.create(:h=>Sequel.pg_json(@h)).h.should == @h
+    c.create(:h=>Sequel.pg_json(@a)).h.should == @a
   end
 end if POSTGRES_DB.server_version >= 90200
 
@@ -2062,7 +2033,7 @@ describe 'PostgreSQL inet/cidr types' do
 
   specify 'insert and retrieve inet/cidr/macaddr array values' do
     @db.create_table!(:items){column :i, 'inet[]'; column :c, 'cidr[]'; column :m, 'macaddr[]'}
-    @ds.insert([@ipv4].pg_array('inet'), [@ipv4nm].pg_array('cidr'), ['12:34:56:78:90:ab'].pg_array('macaddr'))
+    @ds.insert(Sequel.pg_array([@ipv4], 'inet'), Sequel.pg_array([@ipv4nm], 'cidr'), Sequel.pg_array(['12:34:56:78:90:ab'], 'macaddr'))
     @ds.count.should == 1
     if @native
       rs = @ds.all
@@ -2111,7 +2082,7 @@ describe 'PostgreSQL inet/cidr types' do
       cidr :c
     end
     c = Class.new(Sequel::Model(@db[:items]))
-    c.plugin :typecast_on_load, :i, :c unless @native
+    c.plugin :pg_typecast_on_load, :i, :c unless @native
     c.create(:i=>@v4, :c=>@v4nm).values.values_at(:i, :c).should == [@ipv4, @ipv4nm]
     unless ipv6_broken
       c.create(:i=>@ipv6, :c=>@ipv6nm).values.values_at(:i, :c).should == [@ipv6, @ipv6nm]
@@ -2129,9 +2100,9 @@ describe 'PostgreSQL range types' do
     @ra = {}
     @pgr = {}
     @pgra = {}
-    @r.each{|k, v| @ra[k] = [v].pg_array(@map[k])}
-    @r.each{|k, v| @pgr[k] = v.pg_range}
-    @r.each{|k, v| @pgra[k] = [v.pg_range].pg_array(@map[k])}
+    @r.each{|k, v| @ra[k] = Sequel.pg_array([v], @map[k])}
+    @r.each{|k, v| @pgr[k] = Sequel.pg_range(v)}
+    @r.each{|k, v| @pgra[k] = Sequel.pg_array([Sequel.pg_range(v)], @map[k])}
     @native = POSTGRES_DB.adapter_scheme == :postgres
   end
   after do
@@ -2209,7 +2180,7 @@ describe 'PostgreSQL range types' do
   specify 'with models' do
     @db.create_table!(:items){primary_key :id; int4range :i4; int8range :i8; numrange :n; daterange :d; tsrange :t; tstzrange :tz}
     c = Class.new(Sequel::Model(@db[:items]))
-    c.plugin :typecast_on_load, :i4, :i8, :n, :d, :t, :tz unless @native
+    c.plugin :pg_typecast_on_load, :i4, :i8, :n, :d, :t, :tz unless @native
     v = c.create(@r).values
     v.delete(:id)
     v.should == @r
@@ -2217,7 +2188,7 @@ describe 'PostgreSQL range types' do
     unless @db.adapter_scheme == :jdbc
       @db.create_table!(:items){primary_key :id; column :i4, 'int4range[]'; column :i8, 'int8range[]'; column :n, 'numrange[]'; column :d, 'daterange[]'; column :t, 'tsrange[]'; column :tz, 'tstzrange[]'}
       c = Class.new(Sequel::Model(@db[:items]))
-      c.plugin :typecast_on_load, :i4, :i8, :n, :d, :t, :tz unless @native
+      c.plugin :pg_typecast_on_load, :i4, :i8, :n, :d, :t, :tz unless @native
       v = c.create(@ra).values
       v.delete(:id)
       v.each{|k,v| v.should == @ra[k].to_a}
@@ -2227,60 +2198,60 @@ describe 'PostgreSQL range types' do
   specify 'operations/functions with pg_range_ops' do
     Sequel.extension :pg_range_ops
 
-    @db.get((1..5).pg_range(:int4range).op.contains(2..4)).should be_true
-    @db.get((1..5).pg_range(:int4range).op.contains(3..6)).should be_false
-    @db.get((1..5).pg_range(:int4range).op.contains(0..6)).should be_false
+    @db.get(Sequel.pg_range(1..5, :int4range).op.contains(2..4)).should be_true
+    @db.get(Sequel.pg_range(1..5, :int4range).op.contains(3..6)).should be_false
+    @db.get(Sequel.pg_range(1..5, :int4range).op.contains(0..6)).should be_false
 
-    @db.get((1..5).pg_range(:int4range).op.contained_by(0..6)).should be_true
-    @db.get((1..5).pg_range(:int4range).op.contained_by(3..6)).should be_false
-    @db.get((1..5).pg_range(:int4range).op.contained_by(2..4)).should be_false
+    @db.get(Sequel.pg_range(1..5, :int4range).op.contained_by(0..6)).should be_true
+    @db.get(Sequel.pg_range(1..5, :int4range).op.contained_by(3..6)).should be_false
+    @db.get(Sequel.pg_range(1..5, :int4range).op.contained_by(2..4)).should be_false
 
-    @db.get((1..5).pg_range(:int4range).op.overlaps(5..6)).should be_true
-    @db.get((1...5).pg_range(:int4range).op.overlaps(5..6)).should be_false
+    @db.get(Sequel.pg_range(1..5, :int4range).op.overlaps(5..6)).should be_true
+    @db.get(Sequel.pg_range(1...5, :int4range).op.overlaps(5..6)).should be_false
     
-    @db.get((1..5).pg_range(:int4range).op.left_of(6..10)).should be_true
-    @db.get((1..5).pg_range(:int4range).op.left_of(5..10)).should be_false
-    @db.get((1..5).pg_range(:int4range).op.left_of(-1..0)).should be_false
-    @db.get((1..5).pg_range(:int4range).op.left_of(-1..3)).should be_false
+    @db.get(Sequel.pg_range(1..5, :int4range).op.left_of(6..10)).should be_true
+    @db.get(Sequel.pg_range(1..5, :int4range).op.left_of(5..10)).should be_false
+    @db.get(Sequel.pg_range(1..5, :int4range).op.left_of(-1..0)).should be_false
+    @db.get(Sequel.pg_range(1..5, :int4range).op.left_of(-1..3)).should be_false
 
-    @db.get((1..5).pg_range(:int4range).op.right_of(6..10)).should be_false
-    @db.get((1..5).pg_range(:int4range).op.right_of(5..10)).should be_false
-    @db.get((1..5).pg_range(:int4range).op.right_of(-1..0)).should be_true
-    @db.get((1..5).pg_range(:int4range).op.right_of(-1..3)).should be_false
+    @db.get(Sequel.pg_range(1..5, :int4range).op.right_of(6..10)).should be_false
+    @db.get(Sequel.pg_range(1..5, :int4range).op.right_of(5..10)).should be_false
+    @db.get(Sequel.pg_range(1..5, :int4range).op.right_of(-1..0)).should be_true
+    @db.get(Sequel.pg_range(1..5, :int4range).op.right_of(-1..3)).should be_false
 
-    @db.get((1..5).pg_range(:int4range).op.starts_before(6..10)).should be_true
-    @db.get((1..5).pg_range(:int4range).op.starts_before(5..10)).should be_true
-    @db.get((1..5).pg_range(:int4range).op.starts_before(-1..0)).should be_false
-    @db.get((1..5).pg_range(:int4range).op.starts_before(-1..3)).should be_false
+    @db.get(Sequel.pg_range(1..5, :int4range).op.starts_before(6..10)).should be_true
+    @db.get(Sequel.pg_range(1..5, :int4range).op.starts_before(5..10)).should be_true
+    @db.get(Sequel.pg_range(1..5, :int4range).op.starts_before(-1..0)).should be_false
+    @db.get(Sequel.pg_range(1..5, :int4range).op.starts_before(-1..3)).should be_false
 
-    @db.get((1..5).pg_range(:int4range).op.ends_after(6..10)).should be_false
-    @db.get((1..5).pg_range(:int4range).op.ends_after(5..10)).should be_false
-    @db.get((1..5).pg_range(:int4range).op.ends_after(-1..0)).should be_true
-    @db.get((1..5).pg_range(:int4range).op.ends_after(-1..3)).should be_true
+    @db.get(Sequel.pg_range(1..5, :int4range).op.ends_after(6..10)).should be_false
+    @db.get(Sequel.pg_range(1..5, :int4range).op.ends_after(5..10)).should be_false
+    @db.get(Sequel.pg_range(1..5, :int4range).op.ends_after(-1..0)).should be_true
+    @db.get(Sequel.pg_range(1..5, :int4range).op.ends_after(-1..3)).should be_true
 
-    @db.get((1..5).pg_range(:int4range).op.adjacent_to(6..10)).should be_true
-    @db.get((1...5).pg_range(:int4range).op.adjacent_to(6..10)).should be_false
+    @db.get(Sequel.pg_range(1..5, :int4range).op.adjacent_to(6..10)).should be_true
+    @db.get(Sequel.pg_range(1...5, :int4range).op.adjacent_to(6..10)).should be_false
 
-    @db.get(((1..5).pg_range(:int4range).op + (6..10)).adjacent_to(6..10)).should be_false
-    @db.get(((1..5).pg_range(:int4range).op + (6..10)).adjacent_to(11..20)).should be_true
+    @db.get((Sequel.pg_range(1..5, :int4range).op + (6..10)).adjacent_to(6..10)).should be_false
+    @db.get((Sequel.pg_range(1..5, :int4range).op + (6..10)).adjacent_to(11..20)).should be_true
 
-    @db.get(((1..5).pg_range(:int4range).op * (2..6)).adjacent_to(6..10)).should be_true
-    @db.get(((1..4).pg_range(:int4range).op * (2..6)).adjacent_to(6..10)).should be_false
+    @db.get((Sequel.pg_range(1..5, :int4range).op * (2..6)).adjacent_to(6..10)).should be_true
+    @db.get((Sequel.pg_range(1..4, :int4range).op * (2..6)).adjacent_to(6..10)).should be_false
 
-    @db.get(((1..5).pg_range(:int4range).op - (2..6)).adjacent_to(2..10)).should be_true
-    @db.get(((0..4).pg_range(:int4range).op - (3..6)).adjacent_to(4..10)).should be_false
+    @db.get((Sequel.pg_range(1..5, :int4range).op - (2..6)).adjacent_to(2..10)).should be_true
+    @db.get((Sequel.pg_range(0..4, :int4range).op - (3..6)).adjacent_to(4..10)).should be_false
 
-    @db.get((0..4).pg_range(:int4range).op.lower).should == 0
-    @db.get((0..4).pg_range(:int4range).op.upper).should == 5
+    @db.get(Sequel.pg_range(0..4, :int4range).op.lower).should == 0
+    @db.get(Sequel.pg_range(0..4, :int4range).op.upper).should == 5
 
-    @db.get((0..4).pg_range(:int4range).op.isempty).should be_false
+    @db.get(Sequel.pg_range(0..4, :int4range).op.isempty).should be_false
     @db.get(Sequel::Postgres::PGRange.empty(:int4range).op.isempty).should be_true
 
-    @db.get((1..5).pg_range(:numrange).op.lower_inc).should be_true
+    @db.get(Sequel.pg_range(1..5, :numrange).op.lower_inc).should be_true
     @db.get(Sequel::Postgres::PGRange.new(1, 5, :exclude_begin=>true, :db_type=>:numrange).op.lower_inc).should be_false
 
-    @db.get((1..5).pg_range(:numrange).op.upper_inc).should be_true
-    @db.get((1...5).pg_range(:numrange).op.upper_inc).should be_false
+    @db.get(Sequel.pg_range(1..5, :numrange).op.upper_inc).should be_true
+    @db.get(Sequel.pg_range(1...5, :numrange).op.upper_inc).should be_false
 
     @db.get(Sequel::Postgres::PGRange.new(1, 5, :db_type=>:int4range).op.lower_inf).should be_false
     @db.get(Sequel::Postgres::PGRange.new(nil, 5, :db_type=>:int4range).op.lower_inf).should be_true
@@ -2342,7 +2313,7 @@ describe 'PostgreSQL interval types' do
 
   specify 'insert and retrieve interval array values' do
     @db.create_table!(:items){column :i, 'interval[]'}
-    @ds.insert(['1 year 2 months 3 weeks 4 days 5 hours 6 minutes 7 seconds'].pg_array('interval'))
+    @ds.insert(Sequel.pg_array(['1 year 2 months 3 weeks 4 days 5 hours 6 minutes 7 seconds'], 'interval'))
     @ds.count.should == 1
     if @native
       rs = @ds.all
@@ -2381,7 +2352,7 @@ describe 'PostgreSQL interval types' do
       interval :i
     end
     c = Class.new(Sequel::Model(@db[:items]))
-    c.plugin :typecast_on_load, :i, :c unless @native
+    c.plugin :pg_typecast_on_load, :i, :c unless @native
     v = c.create(:i=>'1 year 2 mons 25 days 05:06:07').i
     v.is_a?(ActiveSupport::Duration).should be_true
     v.should == ActiveSupport::Duration.new(31557600 + 2*86400*30 + 3*86400*7 + 4*86400 + 5*3600 + 6*60 + 7, [[:years, 1], [:months, 2], [:days, 25], [:seconds, 18367]])
@@ -2389,3 +2360,209 @@ describe 'PostgreSQL interval types' do
   end
 end if ((require 'active_support/duration'; require 'active_support/inflector'; require 'active_support/core_ext/string/inflections'; true) rescue false)
 
+describe 'PostgreSQL row-valued/composite types' do
+  before(:all) do
+    @db = POSTGRES_DB
+    @db.extension :pg_array, :pg_row
+    @ds = @db[:person]
+
+    @db.create_table!(:address) do
+      String :street
+      String :city
+      String :zip
+    end
+    @db.create_table!(:person) do
+      Integer :id
+      address :address
+    end
+    @db.create_table!(:company) do
+      Integer :id
+      column :employees, 'person[]'
+    end
+    @db.register_row_type(:address)
+    @db.register_row_type(:person)
+    @db.register_row_type(:company)
+
+    @native = POSTGRES_DB.adapter_scheme == :postgres
+  end
+  after(:all) do
+    @db.drop_table?(:company, :person, :address)
+    @db.row_types.clear
+    @db.reset_conversion_procs if @native
+  end
+  after do
+    [:company, :person, :address].each{|t| @db[t].delete}
+  end
+
+  specify 'insert and retrieve row types' do
+    @ds.insert(:id=>1, :address=>Sequel.pg_row(['123 Sesame St', 'Somewhere', '12345']))
+    @ds.count.should == 1
+    if @native
+      # Single row valued type
+      rs = @ds.all
+      v = rs.first[:address]
+      v.should_not be_a_kind_of(Hash)
+      v.to_hash.should be_a_kind_of(Hash)
+      v.to_hash.should == {:street=>'123 Sesame St', :city=>'Somewhere', :zip=>'12345'}
+      @ds.delete
+      @ds.insert(rs.first)
+      @ds.all.should == rs
+
+      # Nested row value type
+      p = @ds.get(:person)
+      p[:id].should == 1
+      p[:address].should == v
+    end
+  end
+
+  specify 'insert and retrieve arrays of row types' do
+    @ds = @db[:company]
+    @ds.insert(:id=>1, :employees=>Sequel.pg_array([@db.row_type(:person, [1, Sequel.pg_row(['123 Sesame St', 'Somewhere', '12345'])])]))
+    @ds.count.should == 1
+    if @native
+      v = @ds.get(:company)
+      v.should_not be_a_kind_of(Hash)
+      v.to_hash.should be_a_kind_of(Hash)
+      v[:id].should == 1
+      employees = v[:employees]
+      employees.should_not be_a_kind_of(Array)
+      employees.to_a.should be_a_kind_of(Array)
+      employees.should == [{:id=>1, :address=>{:street=>'123 Sesame St', :city=>'Somewhere', :zip=>'12345'}}]
+      @ds.delete
+      @ds.insert(v[:id], v[:employees])
+      @ds.get(:company).should == v
+    end
+  end
+
+  specify 'use row types in bound variables' do
+    @ds.call(:insert, {:address=>Sequel.pg_row(['123 Sesame St', 'Somewhere', '12345'])}, {:address=>:$address, :id=>1})
+    @ds.get(:address).should == {:street=>'123 Sesame St', :city=>'Somewhere', :zip=>'12345'}
+    @ds.filter(:address=>Sequel.cast(:$address, :address)).call(:first, :address=>Sequel.pg_row(['123 Sesame St', 'Somewhere', '12345']))[:id].should == 1
+    @ds.filter(:address=>Sequel.cast(:$address, :address)).call(:first, :address=>Sequel.pg_row(['123 Sesame St', 'Somewhere', '12356'])).should == nil
+  end if POSTGRES_DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG
+
+  specify 'use arrays of row types in bound variables' do
+    @ds = @db[:company]
+    @ds.call(:insert, {:employees=>Sequel.pg_array([@db.row_type(:person, [1, Sequel.pg_row(['123 Sesame St', 'Somewhere', '12345'])])])}, {:employees=>:$employees, :id=>1})
+    @ds.get(:company).should == {:id=>1, :employees=>[{:id=>1, :address=>{:street=>'123 Sesame St', :city=>'Somewhere', :zip=>'12345'}}]}
+    @ds.filter(:employees=>Sequel.cast(:$employees, 'person[]')).call(:first, :employees=>Sequel.pg_array([@db.row_type(:person, [1, Sequel.pg_row(['123 Sesame St', 'Somewhere', '12345'])])]))[:id].should == 1
+    @ds.filter(:employees=>Sequel.cast(:$employees, 'person[]')).call(:first, :employees=>Sequel.pg_array([@db.row_type(:person, [1, Sequel.pg_row(['123 Sesame St', 'Somewhere', '12356'])])])).should == nil
+  end if POSTGRES_DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG
+
+  specify 'operations/functions with pg_row_ops' do
+    Sequel.extension :pg_row_ops, :pg_array_ops
+    @ds.insert(:id=>1, :address=>Sequel.pg_row(['123 Sesame St', 'Somewhere', '12345']))
+    @ds.get(Sequel.pg_row(:address)[:street]).should == '123 Sesame St'
+    @ds.get(Sequel.pg_row(:address)[:city]).should == 'Somewhere'
+    @ds.get(Sequel.pg_row(:address)[:zip]).should == '12345'
+
+    @ds = @db[:company]
+    @ds.insert(:id=>1, :employees=>Sequel.pg_array([@db.row_type(:person, [1, Sequel.pg_row(['123 Sesame St', 'Somewhere', '12345'])])]))
+    @ds.get(Sequel.pg_row(:company)[:id]).should == 1
+    if @native
+      @ds.get(Sequel.pg_row(:company)[:employees]).should == [{:id=>1, :address=>{:street=>'123 Sesame St', :city=>'Somewhere', :zip=>'12345'}}]
+      @ds.get(Sequel.pg_row(:company)[:employees][1]).should == {:id=>1, :address=>{:street=>'123 Sesame St', :city=>'Somewhere', :zip=>'12345'}}
+      @ds.get(Sequel.pg_row(:company)[:employees][1][:address]).should == {:street=>'123 Sesame St', :city=>'Somewhere', :zip=>'12345'}
+    end
+    @ds.get(Sequel.pg_row(:company)[:employees][1][:id]).should == 1
+    @ds.get(Sequel.pg_row(:company)[:employees][1][:address][:street]).should == '123 Sesame St'
+    @ds.get(Sequel.pg_row(:company)[:employees][1][:address][:city]).should == 'Somewhere'
+    @ds.get(Sequel.pg_row(:company)[:employees][1][:address][:zip]).should == '12345'
+  end
+
+  context "with models" do
+    before(:all) do
+      class Address < Sequel::Model(:address)
+        plugin :pg_row
+      end
+      class Person < Sequel::Model(:person)
+        plugin :pg_row
+      end
+      class Company < Sequel::Model(:company)
+        plugin :pg_row
+      end
+      @a = Address.new(:street=>'123 Sesame St', :city=>'Somewhere', :zip=>'12345')
+      @es = Sequel.pg_array([Person.new(:id=>1, :address=>@a)])
+    end
+    after(:all) do
+      Object.send(:remove_const, :Address) rescue nil
+      Object.send(:remove_const, :Person) rescue nil
+      Object.send(:remove_const, :Company) rescue nil
+    end
+
+    specify 'insert and retrieve row types as model objects' do
+      @ds.insert(:id=>1, :address=>@a)
+      @ds.count.should == 1
+      if @native
+        # Single row valued type
+        rs = @ds.all
+        v = rs.first[:address]
+        v.should be_a_kind_of(Address)
+        v.should == @a
+        @ds.delete
+        @ds.insert(rs.first)
+        @ds.all.should == rs
+
+        # Nested row value type
+        p = @ds.get(:person)
+        p.should be_a_kind_of(Person)
+        p.id.should == 1
+        p.address.should be_a_kind_of(Address)
+        p.address.should == @a
+      end
+    end
+
+    specify 'insert and retrieve arrays of row types as model objects' do
+      @ds = @db[:company]
+      @ds.insert(:id=>1, :employees=>@es)
+      @ds.count.should == 1
+      if @native
+        v = @ds.get(:company)
+        v.should be_a_kind_of(Company)
+        v.id.should == 1
+        employees = v[:employees]
+        employees.should_not be_a_kind_of(Array)
+        employees.to_a.should be_a_kind_of(Array)
+        employees.should == @es
+        @ds.delete
+        @ds.insert(v.id, v.employees)
+        @ds.get(:company).should == v
+      end
+    end
+
+    specify 'use model objects in bound variables' do
+      @ds.call(:insert, {:address=>@a}, {:address=>:$address, :id=>1})
+      @ds.get(:address).should == @a
+      @ds.filter(:address=>Sequel.cast(:$address, :address)).call(:first, :address=>@a)[:id].should == 1
+      @ds.filter(:address=>Sequel.cast(:$address, :address)).call(:first, :address=>Address.new(:street=>'123 Sesame St', :city=>'Somewhere', :zip=>'12356')).should == nil
+    end if POSTGRES_DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG
+
+    specify 'use arrays of model objects in bound variables' do
+      @ds = @db[:company]
+      @ds.call(:insert, {:employees=>@es}, {:employees=>:$employees, :id=>1})
+      @ds.get(:company).should == Company.new(:id=>1, :employees=>@es)
+      @ds.filter(:employees=>Sequel.cast(:$employees, 'person[]')).call(:first, :employees=>@es)[:id].should == 1
+      @ds.filter(:employees=>Sequel.cast(:$employees, 'person[]')).call(:first, :employees=>Sequel.pg_array([@db.row_type(:person, [1, Sequel.pg_row(['123 Sesame St', 'Somewhere', '12356'])])])).should == nil
+    end if POSTGRES_DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG
+
+    specify 'model typecasting' do
+      Person.plugin :pg_typecast_on_load, :address unless @native
+      a = Address.new(:street=>'123 Sesame St', :city=>'Somewhere', :zip=>'12345')
+      o = Person.create(:id=>1, :address=>['123 Sesame St', 'Somewhere', '12345'])
+      o.address.should == a
+      o = Person.create(:id=>1, :address=>{:street=>'123 Sesame St', :city=>'Somewhere', :zip=>'12345'})
+      o.address.should == a
+      o = Person.create(:id=>1, :address=>a)
+      o.address.should == a
+
+      Company.plugin :pg_typecast_on_load, :employees unless @native
+      e = Person.new(:id=>1, :address=>a)
+      unless @db.adapter_scheme == :jdbc
+        o = Company.create(:id=>1, :employees=>[{:id=>1, :address=>{:street=>'123 Sesame St', :city=>'Somewhere', :zip=>'12345'}}])
+        o.employees.should == [e]
+        o = Company.create(:id=>1, :employees=>[e])
+        o.employees.should == [e]
+      end
+    end
+  end
+end