sequel 2.9.0 → 2.10.0

data/lib/sequel_core/version.rb

@@ -0,0 +1,11 @@
+module Sequel
+  MAJOR = 2
+  MINOR = 10
+  TINY  = 0
+  
+  VERSION = [MAJOR, MINOR, TINY].join('.')
+  
+  def self.version
+    VERSION
+  end
+end

data/lib/sequel_model.rb

@@ -50,6 +50,8 @@ module Sequel
   #   cache_store, cache_ttl, dataset_methods, primary_key, restricted_columns,
   #   sti_dataset, and sti_key.  You should not usually need to
   #   access these directly.
+  # * All validation methods also accept the options specified in #validates_each,
+  #   in addition to the options specified in the RDoc for that method.
   # * The following class level attr_accessors are created: raise_on_typecast_failure,
   #   raise_on_save_failure, strict_param_setting, typecast_empty_string_to_nil,
   #   and typecast_on_assignment:

data/lib/sequel_model/base.rb

@@ -402,8 +402,8 @@ module Sequel
     # create dataset methods, so they can be chained for scoping.
     # For example:
     #
-    #   Topic.subset(:popular, :num_posts > 100)
-    #   Topic.subset(:recent, :created_on > Date.today - 7)
+    #   Topic.subset(:popular, :num_posts.sql_number > 100)
+    #   Topic.subset(:recent, :created_on + 7 > Date.today)
     #
     # Allows you to do:
     #

data/lib/sequel_model/hooks.rb

@@ -8,6 +8,45 @@ module Sequel
     # Hooks that are only for internal use
     PRIVATE_HOOKS = [:before_update_values, :before_delete]
     
+    # This adds a new hook type. It will define both a class
+    # method that you can use to add hooks, as well as an instance method
+    # that you can use to call all hooks of that type.  The class method
+    # can be called with a symbol or a block or both.  If a block is given and
+    # and symbol is not, it adds the hook block to the hook type.  If a block
+    # and symbol are both given, it replaces the hook block associated with
+    # that symbol for a given hook type, or adds it if there is no hook block
+    # with that symbol for that hook type.  If no block is given, it assumes
+    # the symbol specifies an instance method to call and adds it to the hook
+    # type.
+    #
+    # If any hook block returns false, the instance method will return false
+    # immediately without running the rest of the hooks of that type.
+    #
+    # It is recommended that you always provide a symbol to this method,
+    # for descriptive purposes.  It's only necessary to do so when you 
+    # are using a system that reloads code.
+    # 
+    # All of Sequel's standard hook types are also implemented using this
+    # method.
+    #
+    # Example of usage:
+    #
+    #  class MyModel
+    #   define_hook :before_move_to
+    #   before_move_to(:check_move_allowed){|o| o.allow_move?}
+    #   def move_to(there)
+    #     return if before_move_to == false
+    #     # move MyModel object to there
+    #   end
+    #  end
+    def self.add_hook_type(*hooks)
+      hooks.each do |hook|
+        @hooks[hook] = []
+        instance_eval("def #{hook}(method = nil, &block); define_hook_instance_method(:#{hook}); add_hook(:#{hook}, method, &block) end")
+        class_eval("def #{hook}; end")
+      end
+    end
+
     # Returns true if there are any hook blocks for the given hook.
     def self.has_hooks?(hook)
       !@hooks[hook].empty?
@@ -32,7 +71,11 @@ module Sequel
       if tag && (old = h.find{|x| x[0] == tag})
         old[1] = block
       else
-        h << [tag, block]
+        if hook.to_s =~ /^before/
+          h.unshift([tag,block])
+        else
+          h << [tag, block]
+        end
       end
     end
 
@@ -43,7 +86,7 @@ module Sequel
 
     private_class_method :add_hook, :define_hook_instance_method
 
-    private 
+    private
 
     # Runs all hook blocks of given hook type on this object.
     # Stops running hook blocks and returns false if any hook block returns false.
@@ -53,10 +96,6 @@ module Sequel
     
     # For performance reasons, we define empty hook instance methods, which are
     # overwritten with real hook instance methods whenever the hook class method is called.
-    (HOOKS + PRIVATE_HOOKS).each do |hook|
-      @hooks[hook] = []
-      instance_eval("def #{hook}(method = nil, &block); define_hook_instance_method(:#{hook}); add_hook(:#{hook}, method, &block) end")
-      class_eval("def #{hook}; end")
-    end
+    add_hook_type(*(HOOKS + PRIVATE_HOOKS))
   end
 end

data/lib/sequel_model/record.rb

@@ -199,7 +199,7 @@ module Sequel
     def save!(*columns)
       opts = columns.extract_options!
       return save_failure(:save) if before_save == false
-      if @new
+      if new?
         return save_failure(:create) if before_create == false
         ds = model.dataset
         if ds.respond_to?(:insert_select) and h = ds.insert_select(@values)
@@ -212,26 +212,28 @@ module Sequel
           if (pk = primary_key) && !(Array === pk) && !@values[pk]
             @values[pk] = iid
           end
-          if pk
-            @this = nil # remove memoized this dataset
-            refresh
-          end
+          @this = nil if pk
         end
-        @new = false
         after_create
+        after_save
+        @new = false
+        refresh if pk
       else
         return save_failure(:update) if before_update == false
         if columns.empty?
           vals = opts[:changed] ? @values.reject{|k,v| !changed_columns.include?(k)} : @values
           this.update(vals)
-          changed_columns.clear
         else # update only the specified columns
           this.update(@values.reject{|k, v| !columns.include?(k)})
-          changed_columns.reject!{|c| columns.include?(c)}
         end
         after_update
+        after_save
+        if columns.empty?
+          changed_columns.clear
+        else
+          changed_columns.reject!{|c| columns.include?(c)}
+        end
       end
-      after_save
       self
     end
     

data/lib/sequel_model/schema.rb

@@ -2,7 +2,7 @@ module Sequel
   class Model
     # Creates table, using the column information from set_schema.
     def self.create_table
-      db.create_table(table_name, @schema)
+      db.create_table(table_name, :generator=>@schema)
       @db_schema = get_db_schema(true)
       columns
     end

data/lib/sequel_model/validations.rb

@@ -104,26 +104,21 @@ module Sequel
     end
     
     # Validates acceptance of an attribute.  Just checks that the value
-    # is equal to the :accept option.
+    # is equal to the :accept option. This method is unique in that
+    # :allow_nil is assumed to be true instead of false.
     #
     # Possible Options:
     # * :accept - The value required for the object to be valid (default: '1')
-    # * :allow_blank - Whether to skip the validation if the value is blank (default: false)
-    # * :allow_nil - Whether to skip the validation if the value is nil (default: true)
-    # * :if - A symbol (indicating an instance_method) or proc (which is instance_evaled)
-    #   skipping this validation if it returns nil or false.
     # * :message - The message to use (default: 'is not accepted')
-    # * :tag - The tag to use for this validation (default: :acceptance)
     def self.validates_acceptance_of(*atts)
       opts = {
         :message => 'is not accepted',
         :allow_nil => true,
-        :accept => '1'
+        :accept => '1',
+        :tag => :acceptance,
       }.merge!(atts.extract_options!)
-      
-      atts << {:if=>opts[:if], :tag=>opts[:tag]||:acceptance}
+      atts << opts
       validates_each(*atts) do |o, a, v|
-        next if (v.nil? && opts[:allow_nil]) || (v.blank? && opts[:allow_blank])
         o.errors[a] << opts[:message] unless v == opts[:accept]
       end
     end
@@ -137,22 +132,15 @@ module Sequel
     # or email addresses on web forms.
     #
     # Possible Options:
-    # * :allow_false - Whether to skip the validation if the value is blank (default: false)
-    # * :allow_nil - Whether to skip the validation if the value is nil (default: false)
-    # * :if - A symbol (indicating an instance_method) or proc (which is instance_evaled)
-    #   skipping this validation if it returns nil or false.
     # * :message - The message to use (default: 'is not confirmed')
-    # * :tag - The tag to use for this validation (default: :confirmation)
     def self.validates_confirmation_of(*atts)
       opts = {
         :message => 'is not confirmed',
+        :tag => :confirmation,
       }.merge!(atts.extract_options!)
-     
-      atts << {:if=>opts[:if], :tag=>opts[:tag]||:confirmation}
+      atts << opts
       validates_each(*atts) do |o, a, v|
-        next if (v.nil? && opts[:allow_nil]) || (v.blank? && opts[:allow_blank])
-        c = o.send(:"#{a}_confirmation")
-        o.errors[a] << opts[:message] unless v == c
+        o.errors[a] << opts[:message] unless v == o.send(:"#{a}_confirmation")
       end
     end
 
@@ -165,13 +153,30 @@ module Sequel
     #   end
     #
     # Possible Options:
+    # * :allow_blank - Whether to skip the validation if the value is blank. 
+    # * :allow_missing - Whether to skip the validation if the attribute isn't a key in the
+    #   values hash.  This is different from allow_nil, because Sequel only sends the attributes
+    #   in the values when doing an insert or update.  If the attribute is not present, Sequel
+    #   doesn't specify it, so the database will use the table's default value.  This is different
+    #   from having an attribute in values with a value of nil, which Sequel will send as NULL.
+    #   If your database table has a non NULL default, this may be a good option to use.  You
+    #   don't want to use allow_nil, because if the attribute is in values but has a value nil,
+    #   Sequel will attempt to insert a NULL value into the database, instead of using the
+    #   database's default.
+    # * :allow_nil - Whether to skip the validation if the value is nil.
     # * :if - A symbol (indicating an instance_method) or proc (which is instance_evaled)
     #   skipping this validation if it returns nil or false.
-    # * :tag - The tag to use for this validation (default: nil)
+    # * :tag - The tag to use for this validation.
     def self.validates_each(*atts, &block)
       opts = atts.extract_options!
-      blk = if opts[:if]
-        proc{|o,a,v| block.call(o,a,v) if o.instance_eval(&if_proc(opts))}
+      blk = if (i = opts[:if]) || (am = opts[:allow_missing]) || (an = opts[:allow_nil]) || (ab = opts[:allow_blank])
+        proc do |o,a,v|
+          next if i && !o.instance_eval(&if_proc(opts))
+          next if an && Array(v).all?{|x| x.nil?}
+          next if ab && Array(v).all?{|x| x.blank?}
+          next if am && Array(a).all?{|x| !o.values.has_key?(x)}
+          block.call(o,a,v)
+        end
       else
         block
       end
@@ -190,25 +195,20 @@ module Sequel
     # value against the regular expression provided by the :with option.
     #
     # Possible Options:
-    # * :allow_blank - Whether to skip the validation if the value is blank (default: false)
-    # * :allow_nil - Whether to skip the validation if the value is nil (default: false)
-    # * :if - A symbol (indicating an instance_method) or proc (which is instance_evaled)
-    #   skipping this validation if it returns nil or false.
     # * :message - The message to use (default: 'is invalid')
-    # * :tag - The tag to use for this validation (default: :format)
     # * :with - The regular expression to validate the value with (required).
     def self.validates_format_of(*atts)
       opts = {
         :message => 'is invalid',
+        :tag => :format,
       }.merge!(atts.extract_options!)
       
       unless opts[:with].is_a?(Regexp)
         raise ArgumentError, "A regular expression must be supplied as the :with option of the options hash"
       end
       
-      atts << {:if=>opts[:if], :tag=>opts[:tag]||:format}
+      atts << opts
       validates_each(*atts) do |o, a, v|
-        next if (v.nil? && opts[:allow_nil]) || (v.blank? && opts[:allow_blank])
         o.errors[a] << opts[:message] unless v.to_s =~ opts[:with]
       end
     end
@@ -216,16 +216,11 @@ module Sequel
     # Validates the length of an attribute.
     #
     # Possible Options:
-    # * :allow_blank - Whether to skip the validation if the value is blank (default: false)
-    # * :allow_nil - Whether to skip the validation if the value is nil (default: false)
-    # * :if - A symbol (indicating an instance_method) or proc (which is instance_evaled)
-    #   skipping this validation if it returns nil or false.
     # * :is - The exact size required for the value to be valid (no default)
     # * :maximum - The maximum size allowed for the value (no default)
     # * :message - The message to use (no default, overrides :too_long, :too_short, and :wrong_length
     #   options if present)
     # * :minimum - The minimum size allowed for the value (no default)
-    # * :tag - The tag to use for this validation (default: :length)
     # * :too_long - The message to use use if it the value is too long (default: 'is too long')
     # * :too_short - The message to use use if it the value is too short (default: 'is too short')
     # * :with - The array/range that must include the size of the value for it to be valid (no default)
@@ -237,14 +232,9 @@ module Sequel
         :wrong_length => 'is the wrong length'
       }.merge!(atts.extract_options!)
       
-      tag = if opts[:tag]
-        opts[:tag]
-      else
-       ([:length] + [:maximum, :minimum, :is, :within].reject{|x| !opts.include?(x)}).join('-').to_sym
-      end
-      atts << {:if=>opts[:if], :tag=>tag}
+      opts[:tag] ||= ([:length] + [:maximum, :minimum, :is, :within].reject{|x| !opts.include?(x)}).join('-').to_sym
+      atts << opts
       validates_each(*atts) do |o, a, v|
-        next if (v.nil? && opts[:allow_nil]) || (v.blank? && opts[:allow_blank])
         if m = opts[:maximum]
           o.errors[a] << (opts[:message] || opts[:too_long]) unless v && v.size <= m
         end
@@ -260,24 +250,46 @@ module Sequel
       end
     end
 
+    # Validates whether an attribute is not a string.  This is generally useful
+    # in conjunction with raise_on_typecast_failure = false, where you are
+    # passing in string values for non-string attributes (such as numbers and dates).
+    # If typecasting fails (invalid number or date), the value of the attribute will
+    # be a string in an invalid format, and if typecasting succeeds, the value will
+    # not be a string.
+    #
+    # Possible Options:
+    # * :message - The message to use (default: 'is a string' or 'is not a valid (integer|datetime|etc.)' if the type is known)
+    def self.validates_not_string(*atts)
+      opts = {
+        :tag => :not_string,
+      }.merge!(atts.extract_options!)
+      atts << opts
+      validates_each(*atts) do |o, a, v|
+        if v.is_a?(String)
+          unless message = opts[:message]
+            message = if sch = o.db_schema[a] and typ = sch[:type]
+              "is not a valid #{typ}"
+            else
+              "is a string"
+            end
+          end
+          o.errors[a] << message
+        end
+      end
+    end
+
     # Validates whether an attribute is a number.
     #
     # Possible Options:
-    # * :allow_blank - Whether to skip the validation if the value is blank (default: false)
-    # * :allow_nil - Whether to skip the validation if the value is nil (default: false)
-    # * :if - A symbol (indicating an instance_method) or proc (which is instance_evaled)
-    #   skipping this validation if it returns nil or false.
     # * :message - The message to use (default: 'is not a number')
-    # * :tag - The tag to use for this validation (default: :numericality)
     # * :only_integer - Whether only integers are valid values (default: false)
     def self.validates_numericality_of(*atts)
       opts = {
         :message => 'is not a number',
+        :tag => :numericality,
       }.merge!(atts.extract_options!)
-      
-      atts << {:if=>opts[:if], :tag=>opts[:tag]||:numericality}
+      atts << opts
       validates_each(*atts) do |o, a, v|
-        next if (v.nil? && opts[:allow_nil]) || (v.blank? && opts[:allow_blank])
         begin
           if opts[:only_integer]
             Kernel.Integer(v.to_s)
@@ -294,16 +306,13 @@ module Sequel
     # with false considered present instead of absent.
     #
     # Possible Options:
-    # * :if - A symbol (indicating an instance_method) or proc (which is instance_evaled)
-    #   skipping this validation if it returns nil or false.
     # * :message - The message to use (default: 'is not present')
-    # * :tag - The tag to use for this validation (default: :presence)
     def self.validates_presence_of(*atts)
       opts = {
         :message => 'is not present',
+        :tag => :presence,
       }.merge!(atts.extract_options!)
-      
-      atts << {:if=>opts[:if], :tag=>opts[:tag]||:presence}
+      atts << opts
       validates_each(*atts) do |o, a, v|
         o.errors[a] << opts[:message] if v.blank? && v != false
       end
@@ -314,26 +323,28 @@ module Sequel
     # fields to specify that the combination of fields must be unique,
     # instead of that each field should have a unique value.
     #
+    # This means that the code:
+    #   validates_uniqueness_of([:column1, :column2])
+    # validates the grouping of column1 and column2 while
+    #   validates_uniqueness_of(:column1, :column2)
+    # validates them separately.
+    #
     # You should also add a unique index in the
     # database, as this suffers from a fairly obvious race condition.
     #
     # Possible Options:
-    # * :allow_nil - Whether to skip the validation if the value(s) is/are nil (default: false)
-    # * :if - A symbol (indicating an instance_method) or proc (which is instance_evaled)
-    #   skipping this validation if it returns nil or false.
     # * :message - The message to use (default: 'is already taken')
-    # * :tag - The tag to use for this validation (default: :uniqueness)
     def self.validates_uniqueness_of(*atts)
       opts = {
         :message => 'is already taken',
+        :tag => :uniqueness,
       }.merge!(atts.extract_options!)
 
-      atts << {:if=>opts[:if], :tag=>opts[:tag]||:uniqueness}
+      atts << opts
       validates_each(*atts) do |o, a, v|
         error_field = a
         a = Array(a)
         v = Array(v)
-        next unless v.any? or opts[:allow_nil] == false
         ds = o.class.filter(a.zip(v))
         num_dups = ds.count
         allow = if num_dups == 0

data/spec/adapters/firebird_spec.rb

@@ -0,0 +1,371 @@
+require File.join(File.dirname(__FILE__), 'spec_helper.rb')
+
+unless defined?(FIREBIRD_DB)
+  FIREBIRD_URL = 'firebird://sysdba:masterkey@localhost/reality_spec' unless defined? FIREBIRD_URL
+  FIREBIRD_DB = Sequel.connect(ENV['SEQUEL_FB_SPEC_DB']||FIREBIRD_URL)
+end
+
+FIREBIRD_DB.create_table! :test do
+  varchar :name,  :size => 50
+  integer :val,   :index => true
+end
+
+FIREBIRD_DB.create_table! :test2 do
+  integer :val
+  timestamp :time_stamp
+end
+
+FIREBIRD_DB.create_table! :test3 do
+  integer :val
+  timestamp :time_stamp
+end
+
+FIREBIRD_DB.create_table! :test5 do
+  primary_key :xid
+  integer :val
+end
+
+context "A Firebird database" do
+  setup do
+    @db = FIREBIRD_DB
+  end
+
+  specify "should provide disconnect functionality" do
+    @db.tables
+    @db.pool.size.should == 1
+    @db.disconnect
+    @db.pool.size.should == 0
+  end
+
+  specify "should raise Sequel::Error on error" do
+    proc{@db << "SELECT 1 + 'a'"}.should raise_error(Sequel::Error)
+  end
+end
+
+context "A Firebird dataset" do
+  setup do
+    @d = FIREBIRD_DB[:test]
+    @d.delete # remove all records
+  end
+
+  specify "should return the correct record count" do
+    @d.count.should == 0
+    @d << {:name => 'abc', :val => 123}
+    @d << {:name => 'abc', :val  => 456}
+    @d << {:name => 'def', :val => 789}
+    @d.count.should == 3
+  end
+
+  specify "should return the correct records" do
+    @d.to_a.should == []
+    @d << {:name => 'abc', :val => 123}
+    @d << {:name => 'abc', :val => 456}
+    @d << {:name => 'def', :val => 789}
+
+    @d.order(:val).to_a.should == [
+      {:name => 'abc', :val => 123},
+      {:name => 'abc', :val => 456},
+      {:name => 'def', :val => 789}
+    ]
+  end
+
+  specify "should update records correctly" do
+    @d << {:name => 'abc', :val => 123}
+    @d << {:name => 'abc', :val => 456}
+    @d << {:name => 'def', :val => 789}
+    @d.filter(:name => 'abc').update(:val => 530)
+
+    # the third record should stay the same
+    # floating-point precision bullshit
+    @d[:name => 'def'][:val].should == 789
+    @d.filter(:val => 530).count.should == 2
+  end
+
+  specify "should delete records correctly" do
+    @d << {:name => 'abc', :val => 123}
+    @d << {:name => 'abc', :val => 456}
+    @d << {:name => 'def', :val => 789}
+    @d.filter(:name => 'abc').delete
+
+    @d.count.should == 1
+    @d.first[:name].should == 'def'
+  end
+
+  specify "should be able to literalize booleans" do
+    proc {@d.literal(true)}.should_not raise_error
+    proc {@d.literal(false)}.should_not raise_error
+  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[:val]).sql.should == \
+      'SELECT max("VAL") FROM "TEST"'
+
+    @d.select(:now[]).sql.should == \
+    'SELECT now() FROM "TEST"'
+
+    @d.select(:max[:items__val]).sql.should == \
+      'SELECT max("ITEMS"."VAL") 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.select(:test[:ABC, 'hello']).sql.should == \
+      "SELECT test(\"ABC\", 'hello') FROM \"TEST\""
+
+    @d.select(:test[:ABC__DEF, 'hello']).sql.should == \
+      "SELECT test(\"ABC\".\"DEF\", 'hello') FROM \"TEST\""
+
+    @d.select(:test[:ABC__DEF, 'hello'].as(:X2)).sql.should == \
+      "SELECT test(\"ABC\".\"DEF\", 'hello') AS \"X2\" FROM \"TEST\""
+
+    @d.insert_sql(:val => 333).should =~ \
+      /\AINSERT INTO "TEST" \("VAL"\) VALUES \(333\)( RETURNING NULL)?\z/
+
+    @d.insert_sql(:X => :Y).should =~ \
+      /\AINSERT INTO "TEST" \("X"\) VALUES \("Y"\)( RETURNING NULL)?\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 == \
+      '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'
+  end
+
+  specify "should support transactions" do
+    FIREBIRD_DB.transaction do
+      @d << {:name => 'abc', :val => 1}
+    end
+
+    @d.count.should == 1
+  end
+
+  specify "should have #transaction yield the connection" do
+    FIREBIRD_DB.transaction do |conn|
+      conn.should_not == nil
+    end
+  end
+
+  specify "should correctly rollback transactions" do
+    proc do
+      FIREBIRD_DB.transaction do
+        @d << {:name => 'abc', :val => 1}
+        raise RuntimeError, 'asdf'
+      end
+    end.should raise_error(RuntimeError)
+
+    @d.count.should == 0
+  end
+
+  specify "should handle returning inside of the block by committing" do
+    def FIREBIRD_DB.ret_commit
+      transaction do
+        self[:test] << {:name => 'abc'}
+        return
+        self[:test] << {:name => 'd'}
+      end
+    end
+    @d.count.should == 0
+    FIREBIRD_DB.ret_commit
+    @d.count.should == 1
+    FIREBIRD_DB.ret_commit
+    @d.count.should == 2
+    proc do
+      FIREBIRD_DB.transaction do
+        raise RuntimeError, 'asdf'
+      end
+    end.should raise_error(RuntimeError)
+
+    @d.count.should == 2
+  end
+
+  specify "should quote and upcase reserved keywords" do
+    @d = FIREBIRD_DB[:testing]
+    @d.quote_identifiers = true
+    @d.select(:select).sql.should == \
+      'SELECT "SELECT" FROM "TESTING"'
+  end
+end
+
+context "A Firebird dataset with a timestamp field" do
+  setup do
+    @d = FIREBIRD_DB[:test3]
+    @d.delete
+  end
+
+  specify "should store milliseconds in time fields" do
+    t = Time.now
+    @d << {:val=>1, :time_stamp=>t}
+    @d.literal(@d[:val =>'1'][:time_stamp]).should == @d.literal(t)
+    @d[:val=>'1'][:time_stamp].usec.should == t.usec - t.usec % 100
+  end
+end
+
+context "A Firebird database" do
+  setup do
+    @db = FIREBIRD_DB
+  end
+
+  specify "should allow us to name the sequences" do
+    g = Sequel::Schema::Generator.new(FIREBIRD_DB) do
+      primary_key :id, :sequence_name => "seq_test"
+    end
+    FIREBIRD_DB.create_table_sql_list(:posts, *g.create_info).should == [[
+      "CREATE TABLE POSTS (ID integer PRIMARY KEY )",
+      "CREATE SEQUENCE SEQ_TEST",
+      "          CREATE TRIGGER BI_POSTS_ID for POSTS\n          ACTIVE BEFORE INSERT position 0\n          as               begin\n                if ((new.ID is null) or (new.ID = 0)) then\n                begin\n                  new.ID = next value for seq_test;\n                end\n              end\n\n"
+    ], "DROP SEQUENCE SEQ_TEST" ]
+  end
+
+  specify "should allow us to set the starting position for the sequences" do
+    g = Sequel::Schema::Generator.new(FIREBIRD_DB) do
+      primary_key :id, :sequence_start_position => 999
+    end
+    FIREBIRD_DB.create_table_sql_list(:posts, *g.create_info).should == [[
+      "CREATE TABLE POSTS (ID integer PRIMARY KEY )",
+      "CREATE SEQUENCE SEQ_POSTS_ID",
+      "ALTER SEQUENCE SEQ_POSTS_ID RESTART WITH 999",
+      "          CREATE TRIGGER BI_POSTS_ID for POSTS\n          ACTIVE BEFORE INSERT position 0\n          as               begin\n                if ((new.ID is null) or (new.ID = 0)) then\n                begin\n                  new.ID = next value for seq_posts_id;\n                end\n              end\n\n"
+    ], "DROP SEQUENCE SEQ_POSTS_ID" ]
+  end
+
+  specify "should allow us to name and set the starting position for the sequences" do
+    g = Sequel::Schema::Generator.new(FIREBIRD_DB) do
+      primary_key :id, :sequence_name => "seq_test", :sequence_start_position => 999
+    end
+    FIREBIRD_DB.create_table_sql_list(:posts, *g.create_info).should == [[
+      "CREATE TABLE POSTS (ID integer PRIMARY KEY )",
+      "CREATE SEQUENCE SEQ_TEST",
+      "ALTER SEQUENCE SEQ_TEST RESTART WITH 999",
+      "          CREATE TRIGGER BI_POSTS_ID for POSTS\n          ACTIVE BEFORE INSERT position 0\n          as               begin\n                if ((new.ID is null) or (new.ID = 0)) then\n                begin\n                  new.ID = next value for seq_test;\n                end\n              end\n\n"
+    ], "DROP SEQUENCE SEQ_TEST" ]
+  end
+
+  specify "should allow us to name the triggers" do
+    g = Sequel::Schema::Generator.new(FIREBIRD_DB) do
+      primary_key :id, :trigger_name => "trig_test"
+    end
+    FIREBIRD_DB.create_table_sql_list(:posts, *g.create_info).should == [[
+      "CREATE TABLE POSTS (ID integer PRIMARY KEY )",
+      "CREATE SEQUENCE SEQ_POSTS_ID",
+      "          CREATE TRIGGER TRIG_TEST for POSTS\n          ACTIVE BEFORE INSERT position 0\n          as               begin\n                if ((new.ID is null) or (new.ID = 0)) then\n                begin\n                  new.ID = next value for seq_posts_id;\n                end\n              end\n\n"
+    ], "DROP SEQUENCE SEQ_POSTS_ID" ]
+  end
+
+  specify "should allow us to not create the sequence" do
+    g = Sequel::Schema::Generator.new(FIREBIRD_DB) do
+      primary_key :id, :create_sequence => false
+    end
+    FIREBIRD_DB.create_table_sql_list(:posts, *g.create_info).should == [[
+      "CREATE TABLE POSTS (ID integer PRIMARY KEY )",
+      "          CREATE TRIGGER BI_POSTS_ID for POSTS\n          ACTIVE BEFORE INSERT position 0\n          as               begin\n                if ((new.ID is null) or (new.ID = 0)) then\n                begin\n                  new.ID = next value for seq_posts_id;\n                end\n              end\n\n"
+    ], nil]
+  end
+
+  specify "should allow us to not create the trigger" do
+    g = Sequel::Schema::Generator.new(FIREBIRD_DB) do
+      primary_key :id, :create_trigger => false
+    end
+    FIREBIRD_DB.create_table_sql_list(:posts, *g.create_info).should == [[
+      "CREATE TABLE POSTS (ID integer PRIMARY KEY )",
+      "CREATE SEQUENCE SEQ_POSTS_ID",
+    ], "DROP SEQUENCE SEQ_POSTS_ID"]
+  end
+
+  specify "should allow us to not create either the sequence nor the trigger" do
+    g = Sequel::Schema::Generator.new(FIREBIRD_DB) do
+      primary_key :id, :create_sequence => false, :create_trigger => false
+    end
+    FIREBIRD_DB.create_table_sql_list(:posts, *g.create_info).should == [[
+      "CREATE TABLE POSTS (ID integer PRIMARY KEY )"
+    ], nil]
+  end
+
+  specify "should support column operations" do
+    @db.create_table!(:test2){varchar :name, :size => 50; integer :val}
+    @db[:test2] << {}
+    @db[:test2].columns.should == [:name, :val]
+
+    @db.add_column :test2, :xyz, :varchar, :size => 50
+    @db[:test2].columns.should == [:name, :val, :xyz]
+
+    @db[:test2].columns.should == [:name, :val, :xyz]
+    @db.drop_column :test2, :xyz
+
+    @db[:test2].columns.should == [:name, :val]
+
+    @db[:test2].delete
+    @db.add_column :test2, :xyz, :varchar, :default => '000', :size => 50#, :create_domain => 'xyz_varchar'
+    @db[:test2] << {:name => 'mmm', :val => 111, :xyz => 'qqqq'}
+
+    @db[:test2].columns.should == [:name, :val, :xyz]
+    @db.rename_column :test2, :xyz, :zyx
+    @db[:test2].columns.should == [:name, :val, :zyx]
+    @db[:test2].first[:zyx].should == 'qqqq'
+
+    @db.add_column :test2, :xyz, :decimal, :elements => [12, 2]
+    @db[:test2].delete
+    @db[:test2] << {:name => 'mmm', :val => 111, :xyz => 56.4}
+    @db.set_column_type :test2, :xyz, :varchar, :size => 50
+
+    @db[:test2].first[:xyz].should == "56.40"
+  end
+end
+
+context "Postgres::Dataset#insert" do
+  setup do
+    @ds = FIREBIRD_DB[:test5]
+    @ds.delete
+  end
+
+  specify "should using call insert_returning_sql" do
+    @ds.should_receive(:single_value).once.with(:sql=>'INSERT INTO TEST5 (VAL) VALUES (10) RETURNING XID')
+    @ds.insert(:val=>10)
+  end
+
+  specify "should have insert_returning_sql use the RETURNING keyword" do
+    @ds.insert_returning_sql(:XID, :val=>10).should == "INSERT INTO TEST5 (VAL) VALUES (10) RETURNING XID"
+    @ds.insert_returning_sql('*'.lit, :val=>10).should == "INSERT INTO TEST5 (VAL) VALUES (10) RETURNING *"
+    @ds.insert_returning_sql('NULL'.lit, :val=>10).should == "INSERT INTO TEST5 (VAL) VALUES (10) RETURNING NULL"
+  end
+
+  specify "should correctly return the inserted record's primary key value" do
+    value1 = 10
+    id1 = @ds.insert(:val=>value1)
+    @ds.first(:XID=>id1)[:val].should == value1
+    value2 = 20
+    id2 = @ds.insert(:val=>value2)
+    @ds.first(:XID=>id2)[:val].should == value2
+  end
+
+  specify "should return nil if the table has no primary key" do
+    ds = FIREBIRD_DB[:test]
+    ds.delete
+    ds.insert(:name=>'a').should == nil
+  end
+end
+