sequel 3.34.1 → 3.35.0

data/lib/sequel/plugins/prepared_statements_associations.rb

@@ -53,8 +53,7 @@ module Sequel
           when :many_to_many
             association_bound_variable_hash(opts.join_table_alias, opts[:left_keys], opts[:left_primary_keys])
           when :many_through_many
-            opts.reverse_edges
-            association_bound_variable_hash(opts[:final_reverse_edge][:alias], Array(opts[:left_key]), opts[:left_primary_keys])
+            association_bound_variable_hash(opts.final_reverse_edge[:alias], Array(opts[:left_key]), opts[:left_primary_keys])
           end
         end
 
@@ -62,7 +61,7 @@ module Sequel
         # that, given appropriate bound variables, the prepared statement will work correctly for any
         # instance.
         def association_prepared_statement(opts)
-          opts[:prepared_statement] ||= begin
+          opts.send(:cached_fetch, :prepared_statement) do
             ps = _associated_dataset(opts, {}).unbind.first.prepare(opts.returns_array? ? :select : :first, :"smpsap_#{NEXT.call}")
             ps.log_sql = true
             ps

data/lib/sequel/plugins/prepared_statements_with_pk.rb

@@ -31,7 +31,7 @@ module Sequel
         # Return a prepared statement that can be used to lookup a row given a dataset for the row matching
         # the primary key.
         def prepared_lookup_dataset(ds)
-          @prepared_statements[:lookup_sql][ds.sql] ||= prepare_statement(ds.filter(prepared_statement_key_array(primary_key).map{|k, v| [SQL::QualifiedIdentifier.new(ds.model.table_name, k), v]}), :first)
+          cached_prepared_statement(:lookup_sql, ds.sql){prepare_statement(ds.filter(prepared_statement_key_array(primary_key).map{|k, v| [SQL::QualifiedIdentifier.new(ds.model.table_name, k), v]}), :first)}
         end
       end
 

data/lib/sequel/plugins/single_table_inheritance.rb

@@ -131,7 +131,7 @@ module Sequel
         # keys for all of their descendant classes.
         def sti_subclass_added(key)
           if sti_key_array
-            sti_key_array << key
+            Sequel.synchronize{sti_key_array << key}
             superclass.sti_subclass_added(key)
           end
         end

data/lib/sequel/plugins/subclasses.rb

@@ -28,7 +28,7 @@ module Sequel
 
         # All descendent classes of this model.
         def descendents
-          subclasses.map{|x| [x] + x.descendents}.flatten
+          Sequel.synchronize{_descendents}
         end
 
         # Add the subclass to this model's current subclasses,
@@ -36,9 +36,17 @@ module Sequel
         # in the subclass.
         def inherited(subclass)
           super
-          subclasses << subclass
+          Sequel.synchronize{subclasses << subclass}
           subclass.instance_variable_set(:@subclasses, [])
         end
+
+        private
+
+        # Recursive, non-thread safe version of descendents, since
+        # the mutex Sequel uses isn't reentrant.
+        def _descendents
+          subclasses.map{|x| [x] + x.send(:_descendents)}.flatten
+        end
       end
     end
   end

data/lib/sequel/plugins/timestamps.rb

@@ -19,7 +19,7 @@ module Sequel
     #   # timestamp, and setting the update timestamp when creating
     #   Album.plugin :timestamps, :force=>true, :update_on_create=>true
     module Timestamps
-      # Configure the plugin by setting the avialable options.  Note that
+      # Configure the plugin by setting the available options.  Note that
       # if this method is run more than once, previous settings are ignored,
       # and it will just use the settings given or the default settings.  Options:
       # * :create - The field to hold the create timestamp (default: :created_at)

data/lib/sequel/plugins/xml_serializer.rb

@@ -79,6 +79,11 @@ module Sequel
     #
     #   Album.array_from_xml(Album.to_xml) # same as Album.all
     #
+    # If you have an existing array of model instances you want to convert to
+    # XML, you can call the class to_xml method with the :array option:
+    #
+    #   Album.to_xml(:array=>[Album[1], Album[2]])
+    #
     # Usage:
     #
     #   # Add XML output capability to all model subclass instances (called before loading subclasses)
@@ -316,8 +321,14 @@ module Sequel
           raise(Sequel::Error, "Dataset#to_xml") unless row_proc
           x = model.xml_builder(opts)
           name_proc = model.xml_serialize_name_proc(opts)
+          array = if opts[:array]
+            opts = opts.dup
+            opts.delete(:array)
+          else
+            all
+          end
           x.send(name_proc[opts.fetch(:array_root_name, model.send(:pluralize, model.send(:underscore, model.name))).to_s]) do |x1|
-            all.each do |obj|
+            array.each do |obj|
               obj.to_xml(opts.merge(:builder=>x1))
             end
           end

data/lib/sequel/sql.rb

@@ -138,7 +138,7 @@ module Sequel
       MATHEMATICAL_OPERATORS = [:+, :-, :/, :*]
 
       # Bitwise mathematical operators used in +NumericMethods+
-      BITWISE_OPERATORS = [:&, :|, :^, :<<, :>>]
+      BITWISE_OPERATORS = [:&, :|, :^, :<<, :>>, :%]
 
       # Inequality operators used in +InequalityMethods+
       INEQUALITY_OPERATORS = [:<, :>, :<=, :>=]

data/lib/sequel/version.rb

@@ -3,10 +3,10 @@ module Sequel
   MAJOR = 3
   # The minor version of Sequel.  Bumped for every non-patch level
   # release, generally around once a month.
-  MINOR = 34
+  MINOR = 35
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.
-  TINY  = 1
+  TINY  = 0
   
   # The version of Sequel you are using, as a string (e.g. "2.11.0")
   VERSION = [MAJOR, MINOR, TINY].join('.')

data/spec/adapters/postgres_spec.rb

@@ -23,7 +23,7 @@ def logger.method_missing(m, msg)
 end
 POSTGRES_DB.loggers << logger
 
-#POSTGRES_DB.instance_variable_set(:@server_version, 80100)
+#POSTGRES_DB.instance_variable_set(:@server_version, 80200)
 POSTGRES_DB.create_table! :test do
   text :name
   integer :value, :index => true
@@ -111,9 +111,6 @@ describe "A PostgreSQL dataset" do
 
       @d.insert_sql(:value => 333).should =~ \
         /\AINSERT INTO "test" \("value"\) VALUES \(333\)( RETURNING NULL)?\z/
-
-      @d.disable_insert_returning.insert_sql(:value => 333).should =~ \
-        /\AINSERT INTO "test" \("value"\) VALUES \(333\)\z/
     end
   end
 
@@ -163,6 +160,25 @@ describe "A PostgreSQL dataset" do
   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
+
+  specify "should truncate with options" do
+    @d << { :name => 'abc', :value => 1}
+    @d.count.should == 1
+    @d.truncate(:cascade => true)
+    @d.count.should == 0
+    if @d.db.server_version > 80400
+      @d << { :name => 'abc', :value => 1}
+      @d.truncate(:cascade => true, :only=>true, :restart=>true)
+      @d.count.should == 0
+    end
+  end
+
+  specify "should truncate multiple tables at once" do
+    tables = [:test, :test2, :test3, :test4]
+    tables.each{|t| @d.from(t).insert}
+    @d.from(:test, :test2, :test3, :test4).truncate
+    tables.each{|t| @d.from(t).count.should == 0}
+  end
 end
 
 describe "Dataset#distinct" do
@@ -262,7 +278,7 @@ describe "A PostgreSQL dataset with a timestamp field" do
     t2 = @d[:value =>1][:time]
     @d.literal(t2).should == @d.literal(t)
     t2.strftime('%Y-%m-%d %H:%M:%S').should == t.strftime('%Y-%m-%d %H:%M:%S')
-    t2.is_a?(Time) ? t2.usec : t2.strftime('%N').to_i/1000 == t.usec
+    (t2.is_a?(Time) ? t2.usec : t2.strftime('%N').to_i/1000).should == t.usec
   end
 
   cspecify "should store milliseconds in time fields for DateTime objects", :do, :swift do
@@ -271,7 +287,7 @@ describe "A PostgreSQL dataset with a timestamp field" do
     t2 = @d[:value =>1][:time]
     @d.literal(t2).should == @d.literal(t)
     t2.strftime('%Y-%m-%d %H:%M:%S').should == t.strftime('%Y-%m-%d %H:%M:%S')
-    t2.is_a?(Time) ? t2.usec : t2.strftime('%N').to_i/1000 == t.strftime('%N').to_i/1000
+    (t2.is_a?(Time) ? t2.usec : t2.strftime('%N').to_i/1000).should == t.strftime('%N').to_i/1000
   end
 
   if POSTGRES_DB.adapter_scheme == :postgres
@@ -483,46 +499,24 @@ describe "Postgres::Dataset#import" do
     @db.drop_table?(:test)
   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'] if check_sqls
-    @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}
+  specify "#import should a single insert statement" do
     @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}
+  specify "#import should work correctly when returning primary keys" do
     @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}
+  specify "#import should work correctly when returning primary keys with :slice option" do
     @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}]
     @ds.all.should == [{:x=>1, :y=>2}, {:x=>3, :y=>4}]
   end
@@ -545,56 +539,17 @@ describe "Postgres::Dataset#insert" do
     @ds.all.should == [{:xid=>1, :value=>10}, {:xid=>2, :value=>20}]
   end
 
-  specify "should work regardless of how it is used" do
-    @ds.insert(:value=>10).should == 1
-    @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)',
-      "SELECT currval('\"public\".test5_xid_seq')",
-      'INSERT INTO "test5" ("value") VALUES (13)',
-      "SELECT currval('\"public\".test5_xid_seq')"
-    ] if check_sqls
-    @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
-    @ds.all.should == [{:xid=>1, :value=>10}]
-  end
-
-  specify "should insert correctly if disabling insert returning" do
-    @ds.disable_insert_returning.insert(:value=>10).should == 1
-    @ds.all.should == [{:xid=>1, :value=>10}]
-  end
-
-  specify "should insert correctly if using a column array and a value array and server_version < 80200" do
-    @ds.meta_def(:server_version){80100}
+  specify "should insert correctly if using a column array and a value array" do
     @ds.insert([:value], [10]).should == 1
     @ds.all.should == [{:xid=>1, :value=>10}]
   end
 
-  specify "should use INSERT RETURNING if server_version >= 80200" do
-    @ds.meta_def(:server_version){80201}
+  specify "should use INSERT RETURNING" do
     @ds.insert(:value=>10).should == 1
     @db.sqls.last.should == 'INSERT INTO "test5" ("value") VALUES (10) RETURNING "xid"' if check_sqls
   end
 
-  specify "should have insert_select return nil if server_version < 80200" do
-    @ds.meta_def(:server_version){80100}
-    @ds.insert_select(:value=>10).should == nil
-  end
-
-  specify "should have insert_select return nil if disable_insert_returning is used" do
-    @ds.disable_insert_returning.insert_select(:value=>10).should == nil
-  end
-
-  specify "should have insert_select insert the record and return the inserted record if server_version >= 80200" do
-    @ds.meta_def(:server_version){80201}
+  specify "should have insert_select insert the record and return the inserted record" do
     h = @ds.insert_select(:value=>10)
     h[:value].should == 10
     @ds.first(:xid=>h[:xid])[:value].should == 10
@@ -1024,11 +979,7 @@ describe "Postgres::Database functions, languages, schemas, and triggers" do
     @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
+    @d.drop_schema(:sequel, :if_exists=>true, :cascade=>true)
   end
 
   specify "#create_trigger and #drop_trigger should create and drop triggers" do
@@ -1237,7 +1188,7 @@ if POSTGRES_DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG && POSTGRE
       i = 0
       @db.listen('foo2', :timeout=>0.001, :loop=>proc{i+=1; throw :stop if i > 3}){|ev, pid, payload| called = true}.should == nil
       i.should == 4
-    end unless RUBY_VERSION == '1.9.2' && RUBY_PLATFORM =~ /mingw/ # Ruby freezes on this spec on this platform/version
+    end unless RUBY_VERSION =~ /1.8.7|1.9.2/ && RUBY_PLATFORM =~ /mingw/ # Ruby freezes on this spec on this platform/version
   end
 end
 

data/spec/core/database_spec.rb

@@ -193,8 +193,7 @@ describe "A new Database" do
   end
 
   specify "should populate :adapter option when using connection string" do
-    Sequel::Database.should_receive(:adapter_class).once.with(:do).and_return(Sequel::Database)
-    Sequel.connect('do:test://host/db_name').opts[:adapter] == :do
+    Sequel.connect('mock:/').opts[:adapter].should == "mock"
   end
 end
 
@@ -637,6 +636,45 @@ shared_examples_for "Database#transaction" do
     proc {@db.transaction {raise RuntimeError}}.should raise_error(RuntimeError)
   end
   
+  specify "should handle errors when sending BEGIN" do
+    ec = Class.new(StandardError)
+    @db.meta_def(:database_error_classes){[ec]}
+    @db.meta_def(:log_connection_execute){|c, sql| sql =~ /BEGIN/ ? raise(ec, 'bad') : super(c, sql)}
+    begin
+      @db.transaction{@db.execute 'DROP TABLE test;'}
+    rescue Sequel::DatabaseError => e
+    end
+    e.should_not be_nil
+    e.wrapped_exception.should be_a_kind_of(ec)
+    @db.sqls.should == ['ROLLBACK']
+  end
+  
+  specify "should handle errors when sending COMMIT" do
+    ec = Class.new(StandardError)
+    @db.meta_def(:database_error_classes){[ec]}
+    @db.meta_def(:log_connection_execute){|c, sql| sql =~ /COMMIT/ ? raise(ec, 'bad') : super(c, sql)}
+    begin
+      @db.transaction{@db.execute 'DROP TABLE test;'}
+    rescue Sequel::DatabaseError => e
+    end
+    e.should_not be_nil
+    e.wrapped_exception.should be_a_kind_of(ec)
+    @db.sqls.should == ['BEGIN', 'DROP TABLE test;']
+  end
+  
+  specify "should handle errors when sending ROLLBACK" do
+    ec = Class.new(StandardError)
+    @db.meta_def(:database_error_classes){[ec]}
+    @db.meta_def(:log_connection_execute){|c, sql| sql =~ /ROLLBACK/ ? raise(ec, 'bad') : super(c, sql)}
+    begin
+      @db.transaction{raise ArgumentError, 'asdf'}
+    rescue Sequel::DatabaseError => e
+    end
+    e.should_not be_nil
+    e.wrapped_exception.should be_a_kind_of(ec)
+    @db.sqls.should == ['BEGIN']
+  end
+  
   specify "should issue ROLLBACK if Sequel::Rollback is called in the transaction" do
     @db.transaction do
       @db.drop_table(:a)
@@ -1952,6 +1990,12 @@ describe "Database#schema_autoincrementing_primary_key?" do
   end
 end
 
+describe "Database#supports_transactional_ddl?" do
+  specify "should be false by default" do
+    Sequel::Database.new.supports_transactional_ddl?.should == false
+  end
+end
+
 describe "Database#supports_savepoints?" do
   specify "should be false by default" do
     Sequel::Database.new.supports_savepoints?.should == false

data/spec/core/dataset_spec.rb

@@ -214,6 +214,11 @@ describe "A simple dataset" do
     @dataset.truncate_sql.should == 'TRUNCATE TABLE test'
   end
   
+  specify "should format a truncate statement with multiple tables if supported" do
+    @dataset.meta_def(:check_truncation_allowed!){}
+    @dataset.from(:test, :test2).truncate_sql.should == 'TRUNCATE TABLE test, test2'
+  end
+  
   specify "should format an insert statement with default values" do
     @dataset.insert_sql.should == 'INSERT INTO test DEFAULT VALUES'
   end
@@ -709,7 +714,7 @@ describe "Dataset#and" do
   specify "should raise if no filter exists" do
     proc {@dataset.and(:a => 1)}.should raise_error(Sequel::Error)
     proc {@dataset.where(:a => 1).group(:t).and(:b => 2)}.should_not raise_error(Sequel::Error)
-    @dataset.where(:a => 1).group(:t).and(:b => 2).sql == "SELECT * FROM test WHERE (a = 1) AND (b = 2) GROUP BY t"
+    @dataset.where(:a => 1).group(:t).and(:b => 2).sql.should == "SELECT * FROM test WHERE ((a = 1) AND (b = 2)) GROUP BY t"
   end
   
   specify "should add an alternative expression to the where clause" do
@@ -987,9 +992,9 @@ describe "Dataset#literal" do
     @dataset.literal('a"x"bc').should == "'a\"x\"bc'"
     @dataset.literal("a'bc").should == "'a''bc'"
     @dataset.literal("a''bc").should == "'a''''bc'"
-    @dataset.literal("a\\bc").should == "'a\\\\bc'"
-    @dataset.literal("a\\\\bc").should == "'a\\\\\\\\bc'"
-    @dataset.literal("a\\'bc").should == "'a\\\\''bc'"
+    @dataset.literal("a\\bc").should == "'a\\bc'"
+    @dataset.literal("a\\\\bc").should == "'a\\\\bc'"
+    @dataset.literal("a\\'bc").should == "'a\\''bc'"
   end
   
   specify "should escape blobs as strings by default" do
@@ -3216,6 +3221,7 @@ describe "Dataset default #fetch_rows, #insert, #update, #delete, #with_sql_dele
   
   specify "#truncate should raise an InvalidOperation exception if the dataset is filtered" do
     proc{@ds.filter(:a=>1).truncate}.should raise_error(Sequel::InvalidOperation)
+    proc{@ds.having(:a=>1).truncate}.should raise_error(Sequel::InvalidOperation)
   end
   
   specify "#execute should execute the SQL on the database" do
@@ -3677,42 +3683,42 @@ describe Sequel::SQL::Constants do
   end
   
   it "should have CURRENT_DATE" do
-    @db.literal(Sequel::SQL::Constants::CURRENT_DATE) == 'CURRENT_DATE'
-    @db.literal(Sequel::CURRENT_DATE) == 'CURRENT_DATE'
+    @db.literal(Sequel::SQL::Constants::CURRENT_DATE).should == 'CURRENT_DATE'
+    @db.literal(Sequel::CURRENT_DATE).should == 'CURRENT_DATE'
   end
 
   it "should have CURRENT_TIME" do
-    @db.literal(Sequel::SQL::Constants::CURRENT_TIME) == 'CURRENT_TIME'
-    @db.literal(Sequel::CURRENT_TIME) == 'CURRENT_TIME'
+    @db.literal(Sequel::SQL::Constants::CURRENT_TIME).should == 'CURRENT_TIME'
+    @db.literal(Sequel::CURRENT_TIME).should == 'CURRENT_TIME'
   end
 
   it "should have CURRENT_TIMESTAMP" do
-    @db.literal(Sequel::SQL::Constants::CURRENT_TIMESTAMP) == 'CURRENT_TIMESTAMP'
-    @db.literal(Sequel::CURRENT_TIMESTAMP) == 'CURRENT_TIMESTAMP'
+    @db.literal(Sequel::SQL::Constants::CURRENT_TIMESTAMP).should == 'CURRENT_TIMESTAMP'
+    @db.literal(Sequel::CURRENT_TIMESTAMP).should == 'CURRENT_TIMESTAMP'
   end
 
   it "should have NULL" do
-    @db.literal(Sequel::SQL::Constants::NULL) == 'NULL'
-    @db.literal(Sequel::NULL) == 'NULL'
+    @db.literal(Sequel::SQL::Constants::NULL).should == 'NULL'
+    @db.literal(Sequel::NULL).should == 'NULL'
   end
 
   it "should have NOTNULL" do
-    @db.literal(Sequel::SQL::Constants::NOTNULL) == 'NOT NULL'
-    @db.literal(Sequel::NOTNULL) == 'NOT NULL'
+    @db.literal(Sequel::SQL::Constants::NOTNULL).should == 'NOT NULL'
+    @db.literal(Sequel::NOTNULL).should == 'NOT NULL'
   end
 
   it "should have TRUE and SQLTRUE" do
-    @db.literal(Sequel::SQL::Constants::TRUE) == '1'
-    @db.literal(Sequel::TRUE) == '1'
-    @db.literal(Sequel::SQL::Constants::SQLTRUE) == '1'
-    @db.literal(Sequel::SQLTRUE) == '1'
+    @db.literal(Sequel::SQL::Constants::TRUE).should == "'t'"
+    @db.literal(Sequel::TRUE).should == "'t'"
+    @db.literal(Sequel::SQL::Constants::SQLTRUE).should == "'t'"
+    @db.literal(Sequel::SQLTRUE).should == "'t'"
   end
 
   it "should have FALSE and SQLFALSE" do
-    @db.literal(Sequel::SQL::Constants::FALSE) == '0'
-    @db.literal(Sequel::FALSE) == '0'
-    @db.literal(Sequel::SQL::Constants::SQLFALSE) == '0'
-    @db.literal(Sequel::SQLFALSE) == '0'
+    @db.literal(Sequel::SQL::Constants::FALSE).should == "'f'"
+    @db.literal(Sequel::FALSE).should == "'f'"
+    @db.literal(Sequel::SQL::Constants::SQLFALSE).should == "'f'"
+    @db.literal(Sequel::SQLFALSE).should == "'f'"
   end
 end