sequel 3.32.0 → 3.33.0

data/lib/sequel/extensions/server_block.rb

@@ -0,0 +1,139 @@
+# The server_block extension adds the Database#with_server method, which takes a shard
+# argument and a block, and makes it so that access inside the block will use the
+# specified shard by default.
+#
+# First, you need to enable it on the database object:
+#
+#   Sequel.extension :server_block
+#   DB.extend Sequel::ServerBlock
+# 
+# Then you can call with_server:
+#
+#   DB.with_server(:shard1) do
+#     DB[:a].all # Uses shard1
+#     DB[:a].server(:shard2).all # Uses shard2
+#   end
+#   DB[:a].all # Uses default
+#
+# You can even nest calls to with_server:
+#
+#   DB.with_server(:shard1) do
+#     DB[:a].all # Uses shard1
+#     DB.with_server(:shard2) do
+#       DB[:a].all # Uses shard2
+#     end
+#     DB[:a].all # Uses shard1
+#   end
+#   DB[:a].all # Uses default
+# 
+# Note this this extension assumes the following shard names should use the
+# server/shard passed to with_server: :default, nil, :read_only.  All other
+# shard names will cause the standard behavior to be used.
+
+module Sequel
+  module ServerBlock
+    # Enable the server block on the connection pool, choosing the correct
+    # extension depending on whether the connection pool is threaded or not.
+    # Also defines the with_server method on the receiver for easy use.
+    def self.extended(db)
+      pool = db.pool
+      if defined?(ShardedThreadedConnectionPool) && pool.is_a?(ShardedThreadedConnectionPool)
+        pool.extend(ThreadedServerBlock)
+        pool.instance_variable_set(:@default_servers, {})
+      else
+        pool.extend(UnthreadedServerBlock)
+        pool.instance_variable_set(:@default_servers, [])
+      end
+    end
+
+    # Delegate to the connection pool
+    def with_server(server, &block)
+      pool.with_server(server, &block)
+    end
+  end
+
+  # Adds with_server support for the sharded single connection pool.
+  module UnthreadedServerBlock
+    # Set a default server/shard to use inside the block.
+    def with_server(server)
+      begin
+        set_default_server(server)
+        yield
+      ensure
+        clear_default_server
+      end
+    end
+
+    private
+
+    # Make the given server the new default server.
+    def set_default_server(server)
+      @default_servers << server
+    end
+
+    # Remove the current default server, restoring the
+    # previous default server.
+    def clear_default_server
+      @default_servers.pop
+    end
+
+    # Use the server given to with_server if appropriate.
+    def pick_server(server)
+      if @default_servers.empty?
+        super
+      else
+        case server
+        when :default, nil, :read_only
+          @default_servers.last
+        else
+          super
+        end
+      end
+    end
+  end
+
+  # Adds with_server support for the sharded threaded connection pool.
+  module ThreadedServerBlock
+    # Set a default server/shard to use inside the block for the current
+    # thread.
+    def with_server(server)
+      begin
+        set_default_server(server)
+        yield
+      ensure
+        clear_default_server
+      end
+    end
+
+    private
+
+    # Make the given server the new default server for the current thread.
+    def set_default_server(server)
+      sync{(@default_servers[Thread.current] ||= [])} << server
+    end
+
+    # Remove the current default server for the current thread, restoring the
+    # previous default server.
+    def clear_default_server
+      t = Thread.current
+      a = sync{@default_servers[t]}
+      a.pop
+      sync{@default_servers.delete(t)} if a.empty?
+    end
+
+    # Use the server given to with_server for the given thread, if appropriate.
+    def pick_server(server)
+      a = sync{@default_servers[Thread.current]}
+      if !a || a.empty?
+        super
+      else
+        case server
+        when :default, nil, :read_only
+          a.last
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/sequel/model/associations.rb

@@ -704,7 +704,7 @@ module Sequel
         #           singularized unless the type is :many_to_one or :one_to_one)
         # :clone :: Merge the current options and block into the options and block used in defining
         #           the given association.  Can be used to DRY up a bunch of similar associations that
-        #            all share the same options such as :class and :key, while changing the order and block used.
+        #           all share the same options such as :class and :key, while changing the order and block used.
         # :conditions :: The conditions to use to filter the association, can be any argument passed to filter.
         # :dataset :: A proc that is instance_evaled to get the base dataset
         #             to use for the _dataset method (before the other options are applied).
@@ -809,9 +809,9 @@ module Sequel
         #                 Defaults to primary key of the current table. Can use an
         #                 array of symbols for a composite key association.
         # :primary_key_column :: Similar to, and usually identical to, :primary_key, but :primary_key refers
-        #                to the model method call, where :primary_key_column refers to the underlying column.
-        #                Should only be used if the the model method differs from the primary key column, in
-        #                conjunction with defining a model alias method for the primary key column.
+        #                        to the model method call, where :primary_key_column refers to the underlying column.
+        #                        Should only be used if the the model method differs from the primary key column, in
+        #                        conjunction with defining a model alias method for the primary key column.
         # === :many_to_many
         # :graph_join_table_block :: The block to pass to +join_table+ for
         #                            the join table when eagerly loading the association via +eager_graph+.
@@ -833,17 +833,17 @@ module Sequel
         # :join_table_block :: proc that can be used to modify the dataset used in the add/remove/remove_all
         #                      methods.  Should accept a dataset argument and return a modified dataset if present.
         # :left_key :: foreign key in join table that points to current model's
-        #              primary key, as a symbol. Defaults to :"#{self.name.underscore}_id".  
+        #              primary key, as a symbol. Defaults to :"#{self.name.underscore}_id".
         #              Can use an array of symbols for a composite key association.
         # :left_primary_key :: column in current table that :left_key points to, as a symbol.
         #                      Defaults to primary key of current table.  Can use an
         #                      array of symbols for a composite key association.
         # :left_primary_key_column :: Similar to, and usually identical to, :left_primary_key, but :left_primary_key refers to
-        #                the model method to call, where :left_primary_key_column refers to the underlying column.  Should only
-        #                be used if the model method differs from the left primary key column, in conjunction
-        #                with defining a model alias method for the left primary key column.
+        #                             the model method to call, where :left_primary_key_column refers to the underlying column.  Should only
+        #                             be used if the model method differs from the left primary key column, in conjunction
+        #                             with defining a model alias method for the left primary key column.
         # :right_key :: foreign key in join table that points to associated
-        #               model's primary key, as a symbol.  Defaults to Defaults to :"#{name.to_s.singularize}_id".
+        #               model's primary key, as a symbol.  Defaults to :"#{name.to_s.singularize}_id".
         #               Can use an array of symbols for a composite key association.
         # :right_primary_key :: column in associated table that :right_key points to, as a symbol.
         #                       Defaults to primary key of the associated table.  Can use an

data/lib/sequel/model/inflections.rb

@@ -121,7 +121,7 @@ module Sequel
     def constantize(s)
       s = s.to_s
       return s.constantize if s.respond_to?(:constantize)
-      raise(NameError, "#{inspect} is not a valid constant name!") unless m = VALID_CONSTANT_NAME_REGEXP.match(s.to_s)
+      raise(NameError, "#{s.inspect} is not a valid constant name!") unless m = VALID_CONSTANT_NAME_REGEXP.match(s)
       Object.module_eval("::#{m[1]}", __FILE__, __LINE__)
     end
   

data/lib/sequel/plugins/instance_hooks.rb

@@ -29,7 +29,7 @@ module Sequel
         BEFORE_HOOKS = Sequel::Model::BEFORE_HOOKS
         AFTER_HOOKS = Sequel::Model::AFTER_HOOKS - [:after_initialize]
         HOOKS = BEFORE_HOOKS + AFTER_HOOKS
-        HOOKS.each{|h| class_eval("def #{h}_hook(&block); add_instance_hook(:#{h}, &block) end", __FILE__, __LINE__)}
+        HOOKS.each{|h| class_eval("def #{h}_hook(&block); add_instance_hook(:#{h}, &block); self end", __FILE__, __LINE__)}
         
         BEFORE_HOOKS.each{|h| class_eval("def #{h}; run_before_instance_hooks(:#{h}) == false ? false : super end", __FILE__, __LINE__)}
         AFTER_HOOKS.each{|h| class_eval(<<-END, __FILE__, __LINE__ + 1)}

data/lib/sequel/plugins/json_serializer.rb

@@ -149,7 +149,7 @@ module Sequel
         #             to include in the JSON output.  Using a nested
         #             hash, you can pass options to associations
         #             to affect the JSON used for associated objects.
-        # :naked :: Not to add the JSON.create_id key to the JSON
+        # :naked :: Not to add the JSON.create_id (json_class) key to the JSON
         #           output hash, so when the JSON is parsed, it
         #           will yield a hash instead of a model object.
         # :only :: Symbol or Array of Symbols of columns to only

data/lib/sequel/plugins/list.rb

@@ -39,9 +39,11 @@ module Sequel
     #   Item.plugin :list, :scope=>:user_id
     # 
     # Note that using this plugin modifies the order of the model's dataset to
-    # sort by the position and scope fields.
+    # sort by the position and scope fields.  Also note that this plugin is subject to
+    # race conditions, and is not safe when concurrent modifications are made
+    # to the same list.
     #
-    # Also note that unlike ruby arrays, the list plugin assumes that the
+    # Additionally, note that unlike ruby arrays, the list plugin assumes that the
     # first entry in the list has position 1, not position 0.
     #
     # Copyright (c) 2007-2010 Sharon Rosner, Wayne E. Seguin, Aman Gupta, Adrian Madrid, Jeremy Evans
@@ -90,6 +92,14 @@ module Sequel
           list_dataset.first(position_field => p)
         end
 
+        # Set the value of the position_field to the maximum value plus 1 unless the
+        # position field already has a value.
+        def before_create
+          unless send(position_field)
+            send("#{position_field}=", list_dataset.max(position_field).to_i+1)
+          end
+        end
+
         # Find the last position in the list containing this instance.
         def last_position
           list_dataset.max(position_field).to_i

data/lib/sequel/version.rb

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

data/spec/adapters/mysql_spec.rb

@@ -434,6 +434,7 @@ describe "A MySQL database" do
 
   specify "should support add_foreign_key" do
     @db.alter_table :test2 do
+      add_index :value, :unique=>true
       add_foreign_key :value2, :test2, :key=>:value
     end
     @db[:test2].columns.should == [:name, :value, :zyx, :ert, :xyz, :value2]
@@ -485,6 +486,7 @@ describe "A MySQL database" do
   end
   after do
     @db.drop_table(:items) rescue nil
+    @db.drop_table(:users) rescue nil
   end
 
   specify "should support defaults for boolean columns" do
@@ -493,14 +495,18 @@ describe "A MySQL database" do
   end
 
   specify "should correctly format CREATE TABLE statements with foreign keys" do
-    @db.create_table(:items){Integer :id; foreign_key :p_id, :items, :key => :id, :null => false, :on_delete => :cascade}
-    @db.sqls.should == ["CREATE TABLE `items` (`id` integer, `p_id` integer NOT NULL, FOREIGN KEY (`p_id`) REFERENCES `items`(`id`) ON DELETE CASCADE)"]
+    @db.create_table(:items){primary_key :id; foreign_key :p_id, :items, :key => :id, :null => false, :on_delete => :cascade}
+    @db.sqls.should == ["CREATE TABLE `items` (`id` integer PRIMARY KEY AUTO_INCREMENT, `p_id` integer NOT NULL, UNIQUE (`id`), FOREIGN KEY (`p_id`) REFERENCES `items`(`id`) ON DELETE CASCADE)"]
   end
 
   specify "should correctly format ALTER TABLE statements with foreign keys" do
     @db.create_table(:items){Integer :id}
+    @db.create_table(:users){primary_key :id}
     @db.alter_table(:items){add_foreign_key :p_id, :users, :key => :id, :null => false, :on_delete => :cascade}
-    @db.sqls.should == ["CREATE TABLE `items` (`id` integer)", "ALTER TABLE `items` ADD COLUMN `p_id` integer NOT NULL", "ALTER TABLE `items` ADD FOREIGN KEY (`p_id`) REFERENCES `users`(`id`) ON DELETE CASCADE"]
+    @db.sqls.should == ["CREATE TABLE `items` (`id` integer)",
+      "CREATE TABLE `users` (`id` integer PRIMARY KEY AUTO_INCREMENT)",
+      "ALTER TABLE `items` ADD COLUMN `p_id` integer NOT NULL",
+      "ALTER TABLE `items` ADD FOREIGN KEY (`p_id`) REFERENCES `users`(`id`) ON DELETE CASCADE"]
   end
 
   specify "should have rename_column support keep existing options" do
@@ -593,9 +599,59 @@ describe "A MySQL database" do
   end
 end
 
+describe "MySQL foreign key support" do
+  after do
+    MYSQL_DB.drop_table(:testfk) rescue nil
+    MYSQL_DB.drop_table(:testpk) rescue nil
+  end
+
+  specify "should create table without :key" do
+    MYSQL_DB.create_table!(:testpk){primary_key :id}
+    MYSQL_DB.create_table!(:testfk){foreign_key :fk, :testpk}
+  end
+
+  specify "should create table with composite keys without :key" do
+    MYSQL_DB.create_table!(:testpk){Integer :id; Integer :id2; primary_key([:id, :id2])}
+    MYSQL_DB.create_table!(:testfk){Integer :fk; Integer :fk2; foreign_key([:fk, :fk2], :testpk)}
+  end
+
+  specify "should create table with self referential without :key" do
+    MYSQL_DB.create_table!(:testfk){primary_key :id; foreign_key :fk, :testfk}
+  end
+
+  specify "should create table with self referential with composite keys without :key" do
+    MYSQL_DB.create_table!(:testfk){Integer :id; Integer :id2; Integer :fk; Integer :fk2; primary_key([:id, :id2]); foreign_key([:fk, :fk2], :testfk)}
+  end
+
+  specify "should alter table without :key" do
+    MYSQL_DB.create_table!(:testpk){primary_key :id}
+    MYSQL_DB.create_table!(:testfk){Integer :id}
+    MYSQL_DB.alter_table(:testfk){add_foreign_key :fk, :testpk}
+  end
+
+  specify "should alter table with composite keys without :key" do
+    MYSQL_DB.create_table!(:testpk){Integer :id; Integer :id2; primary_key([:id, :id2])}
+    MYSQL_DB.create_table!(:testfk){Integer :fk; Integer :fk2}
+    MYSQL_DB.alter_table(:testfk){add_foreign_key([:fk, :fk2], :testpk)}
+  end
+
+  specify "should alter table with self referential without :key" do
+    MYSQL_DB.create_table!(:testfk){primary_key :id}
+    MYSQL_DB.alter_table(:testfk){add_foreign_key :fk, :testfk}
+  end
+
+  specify "should alter table with self referential with composite keys without :key" do
+    MYSQL_DB.create_table!(:testfk){Integer :id; Integer :id2; Integer :fk; Integer :fk2; primary_key([:id, :id2])}
+    MYSQL_DB.alter_table(:testfk){add_foreign_key [:fk, :fk2], :testfk}
+  end
+end
+
 describe "A grouped MySQL dataset" do
   before do
-    MYSQL_DB[:test2].delete
+    MYSQL_DB.create_table! :test2 do
+      text :name
+      integer :value
+    end
     MYSQL_DB[:test2] << {:name => '11', :value => 10}
     MYSQL_DB[:test2] << {:name => '11', :value => 20}
     MYSQL_DB[:test2] << {:name => '11', :value => 30}
@@ -626,9 +682,9 @@ describe "A MySQL database" do
   end
 
   specify "should support fulltext indexes and full_text_search" do
-    @db.create_table(:posts){text :title; text :body; full_text_index :title; full_text_index [:title, :body]}
+    @db.create_table(:posts, :engine=>:MyISAM){text :title; text :body; full_text_index :title; full_text_index [:title, :body]}
     @db.sqls.should == [
-      "CREATE TABLE `posts` (`title` text, `body` text)",
+      "CREATE TABLE `posts` (`title` text, `body` text) ENGINE=MyISAM",
       "CREATE FULLTEXT INDEX `posts_title_index` ON `posts` (`title`)",
       "CREATE FULLTEXT INDEX `posts_title_body_index` ON `posts` (`title`, `body`)"
     ]
@@ -651,9 +707,9 @@ describe "A MySQL database" do
   end
 
   specify "should support spatial indexes" do
-    @db.create_table(:posts){point :geom, :null=>false; spatial_index [:geom]}
+    @db.create_table(:posts, :engine=>:MyISAM){point :geom, :null=>false; spatial_index [:geom]}
     @db.sqls.should == [
-      "CREATE TABLE `posts` (`geom` point NOT NULL)",
+      "CREATE TABLE `posts` (`geom` point NOT NULL) ENGINE=MyISAM",
       "CREATE SPATIAL INDEX `posts_geom_index` ON `posts` (`geom`)"
     ]
   end

data/spec/adapters/postgres_spec.rb

@@ -37,7 +37,7 @@ describe "A PostgreSQL database" do
   before do
     @db = POSTGRES_DB
   end
-  
+
   specify "should provide the server version" do
     @db.server_version.should > 70000
   end
@@ -59,18 +59,18 @@ describe "A PostgreSQL dataset" do
     @d = POSTGRES_DB[:test]
     @d.delete # remove all records
   end
-  
+
   specify "should quote columns and tables using double quotes if quoting identifiers" do
     @d.quote_identifiers = true
     @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"'
 
@@ -82,13 +82,13 @@ describe "A PostgreSQL dataset" do
 
     @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.select(:test.sql_function(:abc, 'hello')).sql.should == \
       "SELECT test(\"abc\", 'hello') FROM \"test\""
 
@@ -107,7 +107,7 @@ describe "A PostgreSQL dataset" do
     @d.disable_insert_returning.insert_sql(:value => 333).should =~ \
       /\AINSERT INTO "test" \("value"\) VALUES \(333\)\z/
   end
-  
+
   specify "should quote fields correctly when reversing the order if quoting identifiers" do
     @d.quote_identifiers = true
     @d.reverse_order(:name).sql.should == \
@@ -129,7 +129,7 @@ describe "A PostgreSQL dataset" do
     @d.filter(:name => /bc/).count.should == 2
     @d.filter(:name => /^bc/).count.should == 1
   end
-  
+
   specify "should support NULLS FIRST and NULLS LAST" do
     @d << {:name => 'abc'}
     @d << {:name => 'bcd'}
@@ -138,20 +138,20 @@ describe "A PostgreSQL dataset" do
     @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]
   end
-  
+
   specify "#lock should lock tables and yield if a block is given" do
     @d.lock('EXCLUSIVE'){@d.insert(:name=>'a')}
   end
-  
+
   specify "#lock should lock table if inside a transaction" do
     POSTGRES_DB.transaction{@d.lock('EXCLUSIVE'); @d.insert(:name=>'a')}
   end
-  
+
   specify "#lock should return nil" do
     @d.lock('EXCLUSIVE'){@d.insert(:name=>'a')}.should == nil
     POSTGRES_DB.transaction{@d.lock('EXCLUSIVE').should == nil; @d.insert(:name=>'a')}
   end
-  
+
   specify "should raise an error if attempting to update a joined dataset with a single FROM table" do
     proc{POSTGRES_DB[:test].join(:test2, [:name]).update(:name=>'a')}.should raise_error(Sequel::Error, 'Need multiple FROM tables if updating/deleting a dataset with JOINs')
   end
@@ -169,7 +169,7 @@ describe "Dataset#distinct" do
   after do
     @db.drop_table(:a)
   end
-  
+
   it "#distinct with arguments should return results distinct on those arguments" do
     @ds.insert(20, 10)
     @ds.insert(30, 10)
@@ -194,7 +194,7 @@ if POSTGRES_DB.pool.respond_to?(:max_size) and POSTGRES_DB.pool.max_size > 1
       POSTGRES_DB.drop_table(:items)
       POSTGRES_DB.disconnect
     end
-    
+
     specify "should handle FOR UPDATE" do
       @ds.insert(:number=>20)
       c, t = nil, nil
@@ -216,7 +216,7 @@ if POSTGRES_DB.pool.respond_to?(:max_size) and POSTGRES_DB.pool.max_size > 1
       t.join
       c.should == {:id=>1, :number=>30, :name=>'Jim'}
     end
-  
+
     specify "should handle FOR SHARE" do
       @ds.insert(:number=>20)
       c, t = nil
@@ -285,12 +285,12 @@ describe "A PostgreSQL database" do
     @db[:test2].columns.should == [:name, :value, :xyz]
     @db[:test2] << {:name => 'mmm', :value => 111}
     @db[:test2].first[:xyz].should == '000'
-  
+
     @db[:test2].columns.should == [:name, :value, :xyz]
     @db.drop_column :test2, :xyz
-    
+
     @db[:test2].columns.should == [:name, :value]
-  
+
     @db[:test2].delete
     @db.add_column :test2, :xyz, :text, :default => '000'
     @db[:test2] << {:name => 'mmm', :value => 111, :xyz => 'qqqq'}
@@ -299,20 +299,20 @@ describe "A PostgreSQL database" do
     @db.rename_column :test2, :xyz, :zyx
     @db[:test2].columns.should == [:name, :value, :zyx]
     @db[:test2].first[:zyx].should == 'qqqq'
-  
+
     @db.add_column :test2, :xyz, :float
     @db[:test2].delete
     @db[:test2] << {:name => 'mmm', :value => 111, :xyz => 56.78}
     @db.set_column_type :test2, :xyz, :integer
-    
+
     @db[:test2].first[:xyz].should == 57
   end
-  
+
   specify "#locks should be a dataset returning database locks " do
     @db.locks.should be_a_kind_of(Sequel::Dataset)
     @db.locks.all.should be_a_kind_of(Array)
   end
-end  
+end
 
 describe "A PostgreSQL database" do
   before do
@@ -323,7 +323,7 @@ describe "A PostgreSQL database" do
   after do
     @db.drop_table(:posts) rescue nil
   end
-  
+
   specify "should support resetting the primary key sequence" do
     @db.create_table(:posts){primary_key :a}
     @db[:posts].insert(:a=>20).should == 20
@@ -334,7 +334,7 @@ describe "A PostgreSQL database" do
     @db[:posts].insert.should == 21
     @db[:posts].order(:a).map(:a).should == [1, 2, 10, 20, 21]
   end
-  
+
   specify "should support specifying Integer/Bignum/Fixnum types in primary keys and have them be auto incrementing" do
     @db.create_table(:posts){primary_key :a, :type=>Integer}
     @db[:posts].insert.should == 1
@@ -351,7 +351,7 @@ describe "A PostgreSQL database" do
     @db.create_table(:posts){Integer :a}
     @db.reset_primary_key_sequence(:posts).should == nil
   end
-  
+
   specify "should support opclass specification" do
     @db.create_table(:posts){text :title; text :body; integer :user_id; index(:user_id, :opclass => :int4_ops, :type => :btree)}
     @db.sqls.should == [
@@ -392,7 +392,7 @@ describe "A PostgreSQL database" do
       'CREATE INDEX "posts_geom_index" ON "posts" USING gist ("geom")'
     ]
   end
-  
+
   specify "should support indexes with index type" do
     @db.create_table(:posts){varchar :title, :size => 5; index :title, :type => 'hash'}
     @db.sqls.should == [
@@ -400,7 +400,7 @@ describe "A PostgreSQL database" do
       'CREATE INDEX "posts_title_index" ON "posts" USING hash ("title")'
     ]
   end
-  
+
   specify "should support unique indexes with index type" do
     @db.create_table(:posts){varchar :title, :size => 5; index :title, :type => 'btree', :unique => true}
     @db.sqls.should == [
@@ -408,7 +408,7 @@ describe "A PostgreSQL database" do
       'CREATE UNIQUE INDEX "posts_title_index" ON "posts" USING btree ("title")'
     ]
   end
-  
+
   specify "should support partial indexes" do
     @db.create_table(:posts){varchar :title, :size => 5; index :title, :where => {:title => '5'}}
     @db.sqls.should == [
@@ -416,7 +416,7 @@ describe "A PostgreSQL database" do
       'CREATE INDEX "posts_title_index" ON "posts" ("title") WHERE ("title" = \'5\')'
     ]
   end
-  
+
   specify "should support identifiers for table names in indicies" do
     @db.create_table(Sequel::SQL::Identifier.new(:posts)){varchar :title, :size => 5; index :title, :where => {:title => '5'}}
     @db.sqls.should == [
@@ -424,7 +424,7 @@ describe "A PostgreSQL database" do
       'CREATE INDEX "posts_title_index" ON "posts" ("title") WHERE ("title" = \'5\')'
     ]
   end
-  
+
   specify "should support renaming tables" do
     @db.create_table!(:posts1){primary_key :a}
     @db.rename_table(:posts1, :posts)
@@ -441,45 +441,45 @@ describe "Postgres::Dataset#import" do
   after do
     @db.drop_table(:test) rescue nil
   end
-  
+
   specify "#import should return separate insert statements if server_version < 80200" do
     @ds.meta_def(:server_version){80199}
     @ds.import([:x, :y], [[1, 2], [3, 4]])
     @db.sqls.should == ['BEGIN', 'INSERT INTO "test" ("x", "y") VALUES (1, 2)', 'INSERT INTO "test" ("x", "y") VALUES (3, 4)', 'COMMIT']
     @ds.all.should == [{:x=>1, :y=>2}, {:x=>3, :y=>4}]
   end
-  
+
   specify "#import should a single insert statement if server_version >= 80200" do
     @ds.meta_def(:server_version){80200}
     @ds.import([:x, :y], [[1, 2], [3, 4]])
     @db.sqls.should == ['BEGIN', 'INSERT INTO "test" ("x", "y") VALUES (1, 2), (3, 4)', 'COMMIT']
     @ds.all.should == [{:x=>1, :y=>2}, {:x=>3, :y=>4}]
   end
-  
+
   specify "#import should work correctly when returning primary keys for server_version < 80200" do
     @ds.meta_def(:server_version){80199}
     @ds.import([:x, :y], [[1, 2], [3, 4]], :return=>:primary_key).should == [1, 3]
     @ds.all.should == [{:x=>1, :y=>2}, {:x=>3, :y=>4}]
   end
-  
+
   specify "#import should work correctly when returning primary keys for server_version >= 80200" do
     @ds.meta_def(:server_version){80200}
     @ds.import([:x, :y], [[1, 2], [3, 4]], :return=>:primary_key).should == [1, 3]
     @ds.all.should == [{:x=>1, :y=>2}, {:x=>3, :y=>4}]
   end
-  
+
   specify "#import should work correctly when returning primary keys with :slice option for server_version < 80200" do
     @ds.meta_def(:server_version){80199}
     @ds.import([:x, :y], [[1, 2], [3, 4]], :return=>:primary_key, :slice=>1).should == [1, 3]
     @ds.all.should == [{:x=>1, :y=>2}, {:x=>3, :y=>4}]
   end
-  
+
   specify "#import should work correctly when returning primary keys with :slice option for server_version >= 80200" do
     @ds.meta_def(:server_version){80200}
     @ds.import([:x, :y], [[1, 2], [3, 4]], :return=>:primary_key, :slice=>1).should == [1, 3]
     @ds.all.should == [{:x=>1, :y=>2}, {:x=>3, :y=>4}]
   end
-  
+
   specify "#import should work correctly with an arbitrary returning value" do
     @ds.meta_def(:server_version){80200}
     @ds.returning(:y, :x).import([:x, :y], [[1, 2], [3, 4]]).should == [{:y=>2, :x=>1}, {:y=>4, :x=>3}]
@@ -509,7 +509,7 @@ describe "Postgres::Dataset#insert" do
     @ds.disable_insert_returning.insert(:value=>20).should == 2
     @ds.meta_def(:server_version){80100}
     @ds.insert(:value=>13).should == 3
-    
+
     @db.sqls.reject{|x| x =~ /pg_class/}.should == [
       'INSERT INTO "test5" ("value") VALUES (10) RETURNING "xid"',
       'INSERT INTO "test5" ("value") VALUES (20)',
@@ -519,7 +519,7 @@ describe "Postgres::Dataset#insert" do
     ]
     @ds.all.should == [{:xid=>1, :value=>10}, {:xid=>2, :value=>20}, {:xid=>3, :value=>13}]
   end
-  
+
   specify "should insert correctly if server_version < 80200" do
     @ds.meta_def(:server_version){80100}
     @ds.insert(:value=>10).should == 1
@@ -586,7 +586,7 @@ describe "Postgres::Database schema qualified tables" do
     POSTGRES_DB << "DROP SCHEMA schema_test CASCADE"
     POSTGRES_DB.default_schema = nil
   end
-  
+
   specify "should be able to create, drop, select and insert into tables in a given schema" do
     POSTGRES_DB.create_table(:schema_test__schema_test){primary_key :i}
     POSTGRES_DB[:schema_test__schema_test].first.should == nil
@@ -599,19 +599,19 @@ describe "Postgres::Database schema qualified tables" do
     POSTGRES_DB.from('schema_test.schema_test'.lit).first.should == nil
     POSTGRES_DB.drop_table(:schema_test.qualify(:schema_test))
   end
-  
+
   specify "#tables should not include tables in a default non-public schema" do
     POSTGRES_DB.create_table(:schema_test__schema_test){integer :i}
     POSTGRES_DB.tables.should include(:schema_test)
     POSTGRES_DB.tables.should_not include(:pg_am)
     POSTGRES_DB.tables.should_not include(:domain_udt_usage)
   end
-  
+
   specify "#tables should return tables in the schema provided by the :schema argument" do
     POSTGRES_DB.create_table(:schema_test__schema_test){integer :i}
     POSTGRES_DB.tables(:schema=>:schema_test).should == [:schema_test]
   end
-  
+
   specify "#schema should not include columns from tables in a default non-public schema" do
     POSTGRES_DB.create_table(:schema_test__domains){integer :i}
     sch = POSTGRES_DB.schema(:domains)
@@ -619,7 +619,7 @@ describe "Postgres::Database schema qualified tables" do
     cs.should include(:i)
     cs.should_not include(:data_type)
   end
-  
+
   specify "#schema should only include columns from the table in the given :schema argument" do
     POSTGRES_DB.create_table!(:domains){integer :d}
     POSTGRES_DB.create_table(:schema_test__domains){integer :i}
@@ -629,7 +629,7 @@ describe "Postgres::Database schema qualified tables" do
     cs.should_not include(:d)
     POSTGRES_DB.drop_table(:domains)
   end
-  
+
   specify "#schema should raise an exception if columns from tables in two separate schema are returned" do
     POSTGRES_DB.create_table!(:public__domains){integer :d}
     POSTGRES_DB.create_table(:schema_test__domains){integer :i}
@@ -641,41 +641,41 @@ describe "Postgres::Database schema qualified tables" do
       POSTGRES_DB.drop_table(:public__domains)
     end
   end
-  
+
   specify "#table_exists? should see if the table is in a given schema" do
     POSTGRES_DB.create_table(:schema_test__schema_test){integer :i}
     POSTGRES_DB.table_exists?(:schema_test__schema_test).should == true
   end
-  
+
   specify "should be able to get primary keys for tables in a given schema" do
     POSTGRES_DB.create_table(:schema_test__schema_test){primary_key :i}
     POSTGRES_DB.primary_key(:schema_test__schema_test).should == 'i'
   end
-  
+
   specify "should be able to get serial sequences for tables in a given schema" do
     POSTGRES_DB.create_table(:schema_test__schema_test){primary_key :i}
     POSTGRES_DB.primary_key_sequence(:schema_test__schema_test).should == '"schema_test".schema_test_i_seq'
   end
-  
+
   specify "should be able to get serial sequences for tables that have spaces in the name in a given schema" do
     POSTGRES_DB.quote_identifiers = true
     POSTGRES_DB.create_table(:"schema_test__schema test"){primary_key :i}
     POSTGRES_DB.primary_key_sequence(:"schema_test__schema test").should == '"schema_test"."schema test_i_seq"'
   end
-  
+
   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.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.quote_identifiers = true
     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.primary_key_sequence(:"schema_test__schema test").should == '"schema_test"."ks eq"'
   end
-  
+
   specify "#default_schema= should change the default schema used from public" do
     POSTGRES_DB.create_table(:schema_test__schema_test){primary_key :i}
     POSTGRES_DB.default_schema = :schema_test
@@ -692,12 +692,12 @@ describe "Postgres::Database schema qualified tables and eager graphing" do
     @db.run "DROP SCHEMA s CASCADE" rescue nil
     @db.run "CREATE SCHEMA s"
     @db.quote_identifiers = true
-    
+
     @db.create_table(:s__bands){primary_key :id; String :name}
     @db.create_table(:s__albums){primary_key :id; String :name; foreign_key :band_id, :s__bands}
     @db.create_table(:s__tracks){primary_key :id; String :name; foreign_key :album_id, :s__albums}
     @db.create_table(:s__members){primary_key :id; String :name; foreign_key :band_id, :s__bands}
-    
+
     @Band = Class.new(Sequel::Model(:s__bands))
     @Album = Class.new(Sequel::Model(:s__albums))
     @Track = Class.new(Sequel::Model(:s__tracks))
@@ -706,17 +706,17 @@ describe "Postgres::Database schema qualified tables and eager graphing" do
     def @Album.name; :Album; end
     def @Track.name; :Track; end
     def @Member.name; :Member; end
-    
+
     @Band.one_to_many :albums, :class=>@Album, :order=>:name
     @Band.one_to_many :members, :class=>@Member, :order=>:name
     @Album.many_to_one :band, :class=>@Band, :order=>:name
     @Album.one_to_many :tracks, :class=>@Track, :order=>:name
     @Track.many_to_one :album, :class=>@Album, :order=>:name
     @Member.many_to_one :band, :class=>@Band, :order=>:name
-    
+
     @Member.many_to_many :members, :class=>@Member, :join_table=>:s__bands, :right_key=>:id, :left_key=>:id, :left_primary_key=>:band_id, :right_primary_key=>:band_id, :order=>:name
     @Band.many_to_many :tracks, :class=>@Track, :join_table=>:s__albums, :right_key=>:id, :right_primary_key=>:album_id, :order=>:name
-    
+
     @b1 = @Band.create(:name=>"BM")
     @b2 = @Band.create(:name=>"J")
     @a1 = @Album.create(:name=>"BM1", :band=>@b1)
@@ -736,7 +736,7 @@ describe "Postgres::Database schema qualified tables and eager graphing" do
     @db.quote_identifiers = false
     @db.run "DROP SCHEMA s CASCADE"
   end
-  
+
   specify "should return all eager graphs correctly" do
     bands = @Band.order(:bands__name).eager_graph(:albums).all
     bands.should == [@b1, @b2]
@@ -918,7 +918,7 @@ if POSTGRES_DB.dataset.supports_window_functions?
     after do
       @db.drop_table(:i1)
     end
-    
+
     specify "should give correct results for window functions" do
       @ds.window(:win, :partition=>:group_id, :order=>:id).select(:id){sum(:over, :args=>amount, :window=>win){}}.all.should ==
         [{:sum=>1, :id=>1}, {:sum=>11, :id=>2}, {:sum=>111, :id=>3}, {:sum=>1000, :id=>4}, {:sum=>11000, :id=>5}, {:sum=>111000, :id=>6}]
@@ -932,7 +932,7 @@ if POSTGRES_DB.dataset.supports_window_functions?
   end
 end
 
-describe "Postgres::Database functions, languages, and triggers" do
+describe "Postgres::Database functions, languages, schemas, and triggers" do
   before do
     @d = POSTGRES_DB
   end
@@ -940,6 +940,7 @@ describe "Postgres::Database functions, languages, and triggers" do
     @d.drop_function('tf', :if_exists=>true, :cascade=>true)
     @d.drop_function('tf', :if_exists=>true, :cascade=>true, :args=>%w'integer integer')
     @d.drop_language(:plpgsql, :if_exists=>true, :cascade=>true) if @d.server_version < 90000
+    @d.drop_schema(:sequel, :if_exists=>true, :cascade=>true)
     @d.drop_table(:test) rescue nil
   end
 
@@ -953,7 +954,7 @@ describe "Postgres::Database functions, languages, and triggers" do
     @d.drop_function('tf')
     proc{@d['SELECT tf()'].all}.should raise_error(Sequel::DatabaseError)
   end
-  
+
   specify "#create_function and #drop_function should support options" do
     args = ['tf', 'SELECT $1 + $2', {:args=>[[:integer, :a], :integer], :replace=>true, :returns=>:integer, :language=>'SQL', :behavior=>:immutable, :strict=>true, :security_definer=>true, :cost=>2, :set=>{:search_path => 'public'}}]
     @d.send(:create_function_sql,*args).should =~ /\A\s*CREATE OR REPLACE FUNCTION tf\(a integer, integer\)\s+RETURNS integer\s+LANGUAGE SQL\s+IMMUTABLE\s+STRICT\s+SECURITY DEFINER\s+COST 2\s+SET search_path = public\s+AS 'SELECT \$1 \+ \$2'\s*\z/
@@ -967,7 +968,7 @@ describe "Postgres::Database functions, languages, and triggers" do
     # Make sure if exists works
     @d.drop_function(*args)
   end
-  
+
   specify "#create_language and #drop_language should create and drop languages" do
     @d.send(:create_language_sql, :plpgsql).should == 'CREATE LANGUAGE plpgsql'
     @d.create_language(:plpgsql, :replace=>true) if @d.server_version < 90000
@@ -980,7 +981,20 @@ describe "Postgres::Database functions, languages, and triggers" do
     # Make sure if exists works
     @d.drop_language(:plpgsql, :if_exists=>true, :cascade=>true) if @d.server_version < 90000
   end
-  
+
+  specify "#create_schema and #drop_schema should create and drop schemas" do
+    @d.send(:create_schema_sql, :sequel).should == 'CREATE SCHEMA sequel'
+    @d.send(:drop_schema_sql, :sequel).should == 'DROP SCHEMA sequel'
+    @d.send(:drop_schema_sql, :sequel, :if_exists=>true, :cascade=>true).should == 'DROP SCHEMA IF EXISTS sequel CASCADE'
+    @d.create_schema(:sequel)
+    @d.create_table(:sequel__test){Integer :a}
+    if @d.server_version >= 80200
+      @d.drop_schema(:sequel, :if_exists=>true, :cascade=>true)
+    else
+      @d.drop_schema(:sequel, :cascade=>true)
+    end
+  end
+
   specify "#create_trigger and #drop_trigger should create and drop triggers" do
     @d.create_language(:plpgsql) if @d.server_version < 90000
     @d.create_function(:tf, 'BEGIN IF NEW.value IS NULL THEN RAISE EXCEPTION \'Blah\'; END IF; RETURN NEW; END;', :language=>:plpgsql, :returns=>:trigger)
@@ -1014,11 +1028,11 @@ if POSTGRES_DB.adapter_scheme == :postgres
     after(:all) do
       @db.drop_table(:test_cursor) rescue nil
     end
-  
+
     specify "should return the same results as the non-cursor use" do
       @ds.all.should == @ds.use_cursor.all
     end
-    
+
     specify "should respect the :rows_per_fetch option" do
       @db.sqls.clear
       @ds.use_cursor.all
@@ -1027,7 +1041,7 @@ if POSTGRES_DB.adapter_scheme == :postgres
       @ds.use_cursor(:rows_per_fetch=>100).all
       @db.sqls.length.should == 15
     end
-    
+
     specify "should handle returning inside block" do
       def @ds.check_return
         use_cursor.each{|r| return}
@@ -1044,7 +1058,7 @@ if POSTGRES_DB.adapter_scheme == :postgres
       @db.instance_eval do
         disconnect
         @conversion_procs = nil
-      end 
+      end
     end
     after do
       Sequel::Postgres::PG_NAMED_TYPES.delete(:interval)
@@ -1075,7 +1089,7 @@ if POSTGRES_DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG && POSTGRE
     after(:all) do
       @db.drop_table(:test_copy) rescue nil
     end
-  
+
     specify "without a block or options should return a text version of the table as a single string" do
       @db.copy_table(:test_copy).should == "1\t2\n3\t4\n"
     end
@@ -1083,35 +1097,35 @@ if POSTGRES_DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG && POSTGRE
     specify "without a block and with :format=>:csv should return a csv version of the table as a single string" do
       @db.copy_table(:test_copy, :format=>:csv).should == "1,2\n3,4\n"
     end
-  
+
     specify "should treat string as SQL code" do
       @db.copy_table('COPY "test_copy" TO STDOUT').should == "1\t2\n3\t4\n"
     end
-  
+
     specify "should respect given :options options" do
       @db.copy_table(:test_copy, :options=>"FORMAT csv, HEADER TRUE").should == "x,y\n1,2\n3,4\n"
     end
-  
+
     specify "should respect given :options options when :format is used" do
       @db.copy_table(:test_copy, :format=>:csv, :options=>"QUOTE '''', FORCE_QUOTE *").should == "'1','2'\n'3','4'\n"
     end
-  
+
     specify "should accept dataset as first argument" do
       @db.copy_table(@db[:test_copy].cross_join(:test_copy___tc).order(1, 2, 3, 4)).should == "1\t2\t1\t2\n1\t2\t3\t4\n3\t4\t1\t2\n3\t4\t3\t4\n"
     end
-  
+
     specify "with a block and no options should yield each row as a string in text format" do
       buf = []
       @db.copy_table(:test_copy){|b| buf << b}
       buf.should == ["1\t2\n", "3\t4\n"]
     end
-  
+
     specify "with a block and :format=>:csv should yield each row as a string in csv format" do
       buf = []
       @db.copy_table(:test_copy, :format=>:csv){|b| buf << b}
       buf.should == ["1,2\n", "3,4\n"]
     end
-  
+
     specify "should work fine when using a block that is terminated early with a following copy_table" do
       buf = []
       proc{@db.copy_table(:test_copy, :format=>:csv){|b| buf << b; break}}.should raise_error(Sequel::DatabaseDisconnectError)
@@ -1123,7 +1137,7 @@ if POSTGRES_DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG && POSTGRE
       @db.copy_table(:test_copy){|b| buf << b}
       buf.should == ["1\t2\n", "3\t4\n"]
     end
-  
+
     specify "should work fine when using a block that is terminated early with a following regular query" do
       buf = []
       proc{@db.copy_table(:test_copy, :format=>:csv){|b| buf << b; break}}.should raise_error(Sequel::DatabaseDisconnectError)
@@ -1133,13 +1147,13 @@ if POSTGRES_DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG && POSTGRE
       buf.should == ["1,2\n"]
       @db[:test_copy].select_order_map(:x).should == [1, 3]
     end
-  end  
+  end
 
   describe "Postgres::Database LISTEN/NOTIFY" do
     before(:all) do
       @db = POSTGRES_DB
     end
-  
+
     specify "should support listen and notify" do
       notify_pid = @db.synchronize{|conn| conn.backend_pid}
 
@@ -1196,3 +1210,50 @@ if POSTGRES_DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG && POSTGRE
     end
   end
 end
+
+describe 'POSTGRES special float handling' do
+  before do
+    @db = POSTGRES_DB
+    @db.create_table!(:test5){Float :value}
+    @db.sqls.clear
+    @ds = @db[:test5]
+  end
+  after do
+    @db.drop_table(:test5) rescue nil
+  end
+
+  specify 'should quote NaN' do
+    nan = 0.0/0.0
+    @ds.insert_sql(:value => nan).should == %q{INSERT INTO test5 (value) VALUES ('NaN')}
+  end
+
+  specify 'should quote +Infinity' do
+    inf = 1.0/0.0
+    @ds.insert_sql(:value => inf).should == %q{INSERT INTO test5 (value) VALUES ('Infinity')}
+  end
+
+  specify 'should quote -Infinity' do
+    inf = -1.0/0.0
+    @ds.insert_sql(:value => inf).should == %q{INSERT INTO test5 (value) VALUES ('-Infinity')}
+  end
+
+  if POSTGRES_DB.adapter_scheme == :postgres
+    specify 'inserts NaN' do
+      nan = 0.0/0.0
+      @ds.insert(:value=>nan)
+      @ds.all[0][:value].nan?.should be_true
+    end
+
+    specify 'inserts +Infinity' do
+      inf = 1.0/0.0
+      @ds.insert(:value=>inf)
+      @ds.all[0][:value].infinite?.should > 0
+    end
+
+    specify 'inserts -Infinity' do
+      inf = -1.0/0.0
+      @ds.insert(:value=>inf)
+      @ds.all[0][:value].infinite?.should < 0
+    end
+  end
+end