colincasey-sequel 2.10.1 → 2.10.2

data/lib/sequel_core/adapters/shared/postgres.rb

@@ -161,7 +161,7 @@ module Sequel
     
     # Methods shared by Database instances that connect to PostgreSQL.
     module DatabaseMethods
-      PREPARED_ARG_PLACEHOLDER = '$'.lit.freeze
+      PREPARED_ARG_PLACEHOLDER = LiteralString.new('$').freeze
       RE_CURRVAL_ERROR = /currval of sequence "(.*)" is not yet defined in this session|relation "(.*)" does not exist/.freeze
       SQL_BEGIN = 'BEGIN'.freeze
       SQL_SAVEPOINT = 'SAVEPOINT autopoint_%d'.freeze
@@ -550,6 +550,7 @@ module Sequel
       FOR_SHARE = ' FOR SHARE'.freeze
       FOR_UPDATE = ' FOR UPDATE'.freeze
       LOCK = 'LOCK TABLE %s IN %s MODE'.freeze
+      NULL = LiteralString.new('NULL').freeze
       PG_TIMESTAMP_FORMAT = "TIMESTAMP '%Y-%m-%d %H:%M:%S".freeze
       QUERY_PLAN = 'QUERY PLAN'.to_sym
       ROW_EXCLUSIVE = 'ROW EXCLUSIVE'.freeze
@@ -629,29 +630,6 @@ module Sequel
         single_record(default_server_opts(:naked=>true, :sql=>insert_returning_sql(nil, *values))) if server_version >= 80200
       end
 
-      # Handle microseconds for Time and DateTime values, as well as PostgreSQL
-      # specific boolean values and string escaping.
-      def literal(v)
-        case v
-        when LiteralString
-          v
-        when SQL::Blob
-          "'#{v.gsub(/[\000-\037\047\134\177-\377]/){|b| "\\#{("%o" % b[0..1].unpack("C")[0]).rjust(3, '0')}"}}'"
-        when String
-          "'#{v.gsub("'", "''")}'"
-        when Time
-          "#{v.strftime(PG_TIMESTAMP_FORMAT)}.#{sprintf("%06d",v.usec)}'"
-        when DateTime
-          "#{v.strftime(PG_TIMESTAMP_FORMAT)}.#{sprintf("%06d", (v.sec_fraction * 86400000000).to_i)}'"
-        when TrueClass
-          BOOL_TRUE
-        when FalseClass
-          BOOL_FALSE
-        else
-          super
-        end
-      end
-      
       # Locks the table with the specified mode.
       def lock(mode, server=nil)
         sql = LOCK % [source_list(@opts[:from]), mode]
@@ -679,9 +657,33 @@ module Sequel
       # Use the RETURNING clause to return the primary key of the inserted record, if it exists
       def insert_returning_pk_sql(*values)
         pk = db.primary_key(opts[:from].first)
-        insert_returning_sql(pk ? Sequel::SQL::Identifier.new(pk) : 'NULL'.lit, *values)
+        insert_returning_sql(pk ? Sequel::SQL::Identifier.new(pk) : NULL, *values)
       end
       
+      def literal_blob(v)
+        "'#{v.gsub(/[\000-\037\047\134\177-\377]/){|b| "\\#{("%o" % b[0..1].unpack("C")[0]).rjust(3, '0')}"}}'"
+      end
+
+      def literal_datetime(v)
+        "#{v.strftime(PG_TIMESTAMP_FORMAT)}.#{sprintf("%06d", (v.sec_fraction * 86400000000).to_i)}'"
+      end
+
+      def literal_false
+        BOOL_FALSE
+      end
+
+      def literal_string(v)
+        "'#{v.gsub("'", "''")}'"
+      end
+
+      def literal_true
+        BOOL_TRUE
+      end
+
+      def literal_time(v)
+        "#{v.strftime(PG_TIMESTAMP_FORMAT)}.#{sprintf("%06d",v.usec)}'"
+      end
+
       # PostgreSQL is smart and can use parantheses around all datasets to get
       # the correct answers.
       def select_compounds_sql(sql, opts)

data/lib/sequel_core/adapters/shared/progress.rb

@@ -1,3 +1,6 @@
+require 'sequel_core/adapters/utils/date_format'
+require 'sequel_core/adapters/utils/unsupported'
+
 module Sequel
   module Progress
     module DatabaseMethods
@@ -11,6 +14,7 @@ module Sequel
   
     module DatasetMethods
       include Dataset::UnsupportedIntersectExcept
+      include Dataset::SQLStandardDateFormat
 
       SELECT_CLAUSE_ORDER = %w'limit distinct columns from join where group order having compounds'.freeze
 

data/lib/sequel_core/adapters/shared/sqlite.rb

@@ -1,3 +1,5 @@
+require 'sequel_core/adapters/utils/unsupported'
+
 module Sequel
   module SQLite
     module DatabaseMethods
@@ -142,7 +144,7 @@ module Sequel
       # The array of column schema hashes, except for the ones given in opts[:except]
       def defined_columns_for(table, opts={})
         cols = parse_pragma(table, {})
-        cols.each{|c| c[:default] = c[:default].lit if c[:default]}
+        cols.each{|c| c[:default] = LiteralString.new(c[:default]) if c[:default]}
         if opts[:except]
           nono= Array(opts[:except]).compact.map{|n| n.to_s}
           cols.reject!{|c| nono.include? c[:name] }
@@ -234,27 +236,18 @@ module Sequel
         end
       end
       
-      def literal(v)
-        case v
-        when ::Sequel::SQL::Blob
-          blob = ''
-          v.each_byte{|x| blob << sprintf('%02x', x)}
-          "X'#{blob}'"
-        when Time
-          literal(v.iso8601)
-        when Date, DateTime
-          literal(v.to_s)
-        else
-          super
-        end
-      end
-      
       # SQLite uses the nonstandard ` (backtick) for quoting identifiers.
       def quoted_identifier(c)
         "`#{c}`"
       end
       
       private
+
+      def literal_blob(v)
+        blob = ''
+        v.each_byte{|x| blob << sprintf('%02x', x)}
+        "X'#{blob}'"
+      end
       
       # SQLite uses string literals instead of identifiers in AS clauses.
       def as_sql(expression, aliaz)

data/lib/sequel_core/adapters/sqlite.rb

@@ -159,7 +159,7 @@ module Sequel
         # SQLite uses a : before the name of the argument for named
         # arguments.
         def prepared_arg(k)
-          "#{prepared_arg_placeholder}#{k}".lit
+          LiteralString.new("#{prepared_arg_placeholder}#{k}")
         end
       end
       
@@ -214,19 +214,6 @@ module Sequel
         end
       end
       
-      # Use the ISO format for dates and timestamps, and quote strings
-      # using the ::SQLite3::Database.quote method.
-      def literal(v)
-        case v
-        when LiteralString, ::Sequel::SQL::Blob
-          super
-        when String
-          "'#{::SQLite3::Database.quote(v)}'"
-        else
-          super
-        end
-      end
-      
       # Prepare the given type of query with the given name and store
       # it in the database.  Note that a new native prepared statement is
       # created on each call to this prepared statement.
@@ -239,6 +226,10 @@ module Sequel
       
       private
       
+      def literal_string(v)
+        "'#{::SQLite3::Database.quote(v)}'"
+      end
+
       # SQLite uses a : before the name of the argument as a placeholder.
       def prepared_arg_placeholder
         PREPARED_ARG_PLACEHOLDER

data/lib/sequel_core/core_sql.rb

@@ -121,7 +121,7 @@ class String
   include Sequel::SQL::AliasMethods
   include Sequel::SQL::CastMethods
 
-  # Converts a string into an LiteralString, in order to override string
+  # Converts a string into a Sequel::LiteralString, in order to override string
   # literalization, e.g.:
   #
   #   DB[:items].filter(:abc => 'def').sql #=>
@@ -130,8 +130,12 @@ class String
   #   DB[:items].filter(:abc => 'def'.lit).sql #=>
   #     "SELECT * FROM items WHERE (abc = def)"
   #
-  def lit
-    Sequel::LiteralString.new(self)
+  # You can also provide arguments, to create a Sequel::SQL::PlaceholderLiteralString:
+  #
+  #    DB[:items].select{|o| o.count('DISTINCT ?'.lit(:a))}.sql #=>
+  #      "SELECT count(DISTINCT a) FROM items"
+  def lit(*args)
+    args.empty? ? Sequel::LiteralString.new(self) : Sequel::SQL::PlaceholderLiteralString.new(self, args)
   end
   alias_method :expr, :lit
   

data/lib/sequel_core/dataset/convenience.rb

@@ -1,7 +1,7 @@
 module Sequel
   class Dataset
     COMMA_SEPARATOR = ', '.freeze
-    COUNT_OF_ALL_AS_COUNT = SQL::Function.new(:count, '*'.lit).as(:count)
+    COUNT_OF_ALL_AS_COUNT = SQL::Function.new(:count, LiteralString.new('*'.freeze)).as(:count)
 
     # Returns the first record matching the conditions.
     def [](*conditions)

data/lib/sequel_core/dataset/prepared_statements.rb

@@ -1,6 +1,6 @@
 module Sequel 
   class Dataset
-    PREPARED_ARG_PLACEHOLDER = '?'.lit.freeze
+    PREPARED_ARG_PLACEHOLDER = LiteralString.new('?').freeze
     
     # Default implementation of the argument mapper to allow
     # native database support for bind variables and prepared

data/lib/sequel_core/dataset/sql.rb

@@ -7,13 +7,11 @@ module Sequel
     COLUMN_REF_RE2 = /\A([\w ]+)___([\w ]+)\z/.freeze
     COLUMN_REF_RE3 = /\A([\w ]+)__([\w ]+)\z/.freeze
     COUNT_FROM_SELF_OPTS = [:distinct, :group, :sql, :limit, :compounds]
-    DATE_FORMAT = "DATE '%Y-%m-%d'".freeze
     N_ARITY_OPERATORS = ::Sequel::SQL::ComplexExpression::N_ARITY_OPERATORS
     NULL = "NULL".freeze
     QUESTION_MARK = '?'.freeze
-    STOCK_COUNT_OPTS = {:select => ["COUNT(*)".lit], :order => nil}.freeze
+    STOCK_COUNT_OPTS = {:select => [LiteralString.new("COUNT(*)").freeze], :order => nil}.freeze
     SELECT_CLAUSE_ORDER = %w'distinct columns from join where group having compounds order limit'.freeze
-    TIMESTAMP_FORMAT = "TIMESTAMP '%Y-%m-%d %H:%M:%S'".freeze
     TWO_ARITY_OPERATORS = ::Sequel::SQL::ComplexExpression::TWO_ARITY_OPERATORS
     WILDCARD = '*'.freeze
 
@@ -131,7 +129,7 @@ module Sequel
     #   DB.select(1).where(DB[:items].exists).sql
     #   #=> "SELECT 1 WHERE EXISTS (SELECT * FROM items)"
     def exists(opts = nil)
-      "EXISTS (#{select_sql(opts)})".lit
+      LiteralString.new("EXISTS (#{select_sql(opts)})")
     end
 
     # Returns a copy of the dataset with the given conditions imposed upon it.  
@@ -468,38 +466,39 @@ module Sequel
     # If an unsupported object is given, an exception is raised.
     def literal(v)
       case v
-      when LiteralString
-        v
       when String
-        "'#{v.gsub(/\\/, "\\\\\\\\").gsub(/'/, "''")}'"
-      when Integer, Float
-        v.to_s
+        return v if v.is_a?(LiteralString)
+        v.is_a?(SQL::Blob) ? literal_blob(v) : literal_string(v)
+      when Symbol
+        literal_symbol(v)
+      when Integer
+        literal_integer(v)
+      when Hash
+        literal_hash(v)
+      when SQL::Expression
+        literal_expression(v)
+      when Float
+        literal_float(v)
       when BigDecimal
-        d = v.to_s("F")
-        d = "'#{d}'" if v.nan? || v.infinite?
-        d
+        literal_big_decimal(v)
       when NilClass
         NULL
       when TrueClass
-        BOOL_TRUE
+        literal_true
       when FalseClass
-        BOOL_FALSE
-      when Symbol
-        symbol_to_column_ref(v)
-      when ::Sequel::SQL::Expression
-        v.to_s(self)
+        literal_false
       when Array
-        v.all_two_pairs? ? literal(v.sql_expr) : array_sql(v)
-      when Hash
-        literal(v.sql_expr)
-      when Time, DateTime
-        v.strftime(TIMESTAMP_FORMAT)
+        literal_array(v)
+      when Time
+        literal_time(v)
+      when DateTime
+        literal_datetime(v)
       when Date
-        v.strftime(DATE_FORMAT)
+        literal_date(v)
       when Dataset
-        "(#{subselect_sql(v)})"
+        literal_dataset(v)
       else
-        raise Error, "can't express #{v.inspect} as a SQL literal"
+        literal_other(v)
       end
     end
 
@@ -674,9 +673,7 @@ module Sequel
     #   :items__abc___a.to_column_ref(ds) #=> "items.abc AS a"
     #
     def symbol_to_column_ref(sym)
-      c_table, column, c_alias = split_symbol(sym)
-      qc = "#{"#{quote_identifier(c_table)}." if c_table}#{quote_identifier(column)}"
-      c_alias ? as_sql(qc, c_alias) : qc
+      literal_symbol(sym)
     end
 
     # Returns a copy of the dataset with no filters (HAVING or WHERE clause) applied.
@@ -745,6 +742,12 @@ module Sequel
       sql
     end
 
+    # Returns a copy of the dataset with the static SQL used.  This is useful if you want
+    # to keep the same row_proc/transform/graph, but change the SQL used to custom SQL.
+    def with_sql(sql)
+      clone(:sql=>sql)
+    end
+
     [:inner, :full_outer, :right_outer, :left_outer].each do |jtype|
       class_eval("def #{jtype}_join(*args, &block); join_table(:#{jtype}, *args, &block) end")
     end
@@ -816,7 +819,7 @@ module Sequel
       when TrueClass, FalseClass
         SQL::BooleanExpression.new(:NOOP, expr)
       when String
-        "(#{expr})".lit
+        LiteralString.new("(#{expr})")
       else
         raise(Error, 'Invalid filter argument')
       end
@@ -857,6 +860,89 @@ module Sequel
       "#{join_type.to_s.gsub('_', ' ').upcase} JOIN"
     end
 
+    # SQL fragment for Array.  Treats as an expression if an array of all two pairs, or as a SQL array otherwise.
+    def literal_array(v)
+      v.all_two_pairs? ? literal_expression(v.sql_expr) : array_sql(v)
+    end
+
+    # SQL fragment for BigDecimal
+    def literal_big_decimal(v)
+      d = v.to_s("F")
+      v.nan? || v.infinite? ?  "'#{d}'" : d
+    end
+
+    # SQL fragment for SQL::Blob
+    def literal_blob(v)
+      literal_string(v)
+    end
+
+    # SQL fragment for Dataset.  Does a subselect inside parantheses.
+    def literal_dataset(v)
+      "(#{subselect_sql(v)})"
+    end
+
+    # SQL fragment for Date, using the ISO8601 format.
+    def literal_date(v)
+      "'#{v}'"
+    end
+
+    # SQL fragment for DateTime, using the ISO8601 format.
+    def literal_datetime(v)
+      "'#{v}'"
+    end
+
+    # SQL fragment for SQL::Expression, result depends on the specific type of expression.
+    def literal_expression(v)
+      v.to_s(self)
+    end
+
+    # SQL fragment for false
+    def literal_false
+      BOOL_FALSE
+    end
+
+    # SQL fragment for Float
+    def literal_float(v)
+      v.to_s
+    end
+
+    # SQL fragment for Hash, treated as an expression
+    def literal_hash(v)
+      literal_expression(v.sql_expr)
+    end
+
+    # SQL fragment for Integer
+    def literal_integer(v)
+      v.to_s
+    end
+
+    # SQL fragmento for a type of object not handled by Dataset#literal.  Raises an error.  If a database specific type is allowed, this should be overriden in a subclass.
+    def literal_other(v)
+      raise Error, "can't express #{v.inspect} as a SQL literal"
+    end
+
+    # SQL fragment for String.  Doubles \ and ' by default.
+    def literal_string(v)
+      "'#{v.gsub(/\\/, "\\\\\\\\").gsub(/'/, "''")}'"
+    end
+
+    # SQL fragment for Symbol, treated as an identifier, possibly aliased and/or qualified.
+    def literal_symbol(v)
+      c_table, column, c_alias = split_symbol(v)
+      qc = "#{"#{quote_identifier(c_table)}." if c_table}#{quote_identifier(column)}"
+      c_alias ? as_sql(qc, c_alias) : qc
+    end
+
+    # SQL fragment for Time, uses the ISO8601 format.
+    def literal_time(v)
+      "'#{v.iso8601}'"
+    end
+
+    # SQL fragment for true.
+    def literal_true
+      BOOL_TRUE
+    end
+
     # Returns a qualified column name (including a table name) if the column
     # name isn't already qualified.
     def qualified_column_name(column, table)

data/lib/sequel_core/dataset.rb

@@ -1,4 +1,4 @@
-%w'callback convenience pagination prepared_statements query schema sql unsupported'.each do |f|
+%w'callback convenience pagination prepared_statements query schema sql'.each do |f|
   require "sequel_core/dataset/#{f}"
 end
 
@@ -54,7 +54,7 @@ module Sequel
     left_outer_join limit naked or order order_by order_more paginate query reject
     reverse reverse_order right_outer_join select select_all select_more
     set_defaults set_graph_aliases set_model set_overrides sort sort_by
-    unfiltered union unordered where'.collect{|x| x.to_sym}
+    unfiltered union unordered where with_sql'.collect{|x| x.to_sym}
 
     NOTIMPL_MSG = "This method must be overridden in Sequel adapters".freeze
     STOCK_TRANSFORMS = {

data/lib/sequel_core/sql.rb

@@ -336,12 +336,12 @@ module Sequel
     module ComplexExpressionMethods
       # Extract a datetime_part (e.g. year, month) from self:
       #
-      #   :date.extract(:year) # SQL:  extract(year FROM date)
+      #   :date.extract(:year) # SQL:  extract(year FROM "date")
       #
       # Also has the benefit of returning the result as a
       # NumericExpression instead of a generic ComplexExpression.
       def extract(datetime_part)
-        IrregularFunction.new(:extract, datetime_part.to_s.lit, :FROM, self).sql_number
+        Function.new(:extract, PlaceholderLiteralString.new("#{datetime_part} FROM ?", [self])).sql_number
       end
 
       # Return a BooleanExpression representation of self.
@@ -592,35 +592,6 @@ module Sequel
       end 
     end
     
-    # IrregularFunction is used for the SQL EXTRACT function,
-    # which don't use regular function calling syntax. The IrregularFunction
-    # replaces the commas the regular function uses with a custom
-    # join string.
-    #
-    # This shouldn't be used directly, see
-    # ComplexExpressionMethods#extract.
-    class IrregularFunction < Function
-      # The arguments to pass to the function (may be blank)
-      attr_reader :arg1, :arg2
-
-      # The SQL function to call
-      attr_reader :f
-      
-      # The literal string to use in place of a comma to join arguments
-      attr_reader :joiner
-
-      # Set the attributes to the given arguments
-      def initialize(f, arg1, joiner, arg2)
-        @f, @arg1, @joiner, @arg2 = f, arg1, joiner, arg2
-      end
-
-      # Delegate the creation of the resulting SQL to the given dataset,
-      # since it may be database dependent.
-      def to_s(ds)
-        ds.irregular_function_sql(self)
-      end
-    end
-
     # Represents an SQL JOIN clause, used for joining tables.
     class JoinClause < SpecificExpression
       # The type of join to do

data/lib/sequel_model/base.rb

@@ -14,6 +14,8 @@ module Sequel
     @raise_on_typecast_failure = true
     @restrict_primary_key = true
     @restricted_columns = nil
+    @simple_pk = nil
+    @simple_table = nil
     @skip_superclass_validations = nil
     @sti_dataset = nil
     @sti_key = nil
@@ -48,6 +50,14 @@ module Sequel
     # (default: no columns).
     metaattr_reader :restricted_columns
 
+    # Should be the literal primary key column name if this Model's table has a simple primary key, or
+    # nil if the model has a compound primary key or no primary key.
+    metaattr_reader :simple_pk
+
+    # Should be the literal table name if this Model's dataset is a simple table (no select, order, join, etc.),
+    # or nil otherwise.
+    metaattr_reader :simple_table
+
     # The base dataset for STI, to which filters are added to get
     # only the models for the specific STI subclass.
     metaattr_reader :sti_dataset
@@ -75,12 +85,13 @@ module Sequel
        left_outer_join limit map multi_insert naked order order_by order_more 
        paginate print query range reverse_order right_outer_join select 
        select_all select_more server set set_graph_aliases single_value size to_csv to_hash
-       transform union uniq unfiltered unordered update where'.map{|x| x.to_sym}
+       transform union uniq unfiltered unordered update where with_sql'.map{|x| x.to_sym}
 
     # Instance variables that are inherited in subclasses
     INHERITED_INSTANCE_VARIABLES = {:@allowed_columns=>:dup, :@cache_store=>nil,
       :@cache_ttl=>nil, :@dataset_methods=>:dup, :@primary_key=>nil, 
       :@raise_on_save_failure=>nil, :@restricted_columns=>:dup, :@restrict_primary_key=>nil,
+      :@simple_pk=>nil, :@simple_table=>nil,
       :@sti_dataset=>nil, :@sti_key=>nil, :@strict_param_setting=>nil,
       :@typecast_empty_string_to_nil=>nil, :@typecast_on_assignment=>nil,
       :@raise_on_typecast_failure=>nil, :@association_reflections=>:dup}
@@ -95,11 +106,12 @@ module Sequel
     # first before a dataset lookup is attempted unless a hash is supplied.
     def self.[](*args)
       args = args.first if (args.size == 1)
-
-      if Hash === args
-        dataset[args]
+      return dataset[args] if args.is_a?(Hash)
+      return cache_lookup(args) if @cache_store
+      if t = simple_table and p = simple_pk
+        with_sql("SELECT * FROM #{t} WHERE #{p} = #{dataset.literal(args)} LIMIT 1").first
       else
-        @cache_store ? cache_lookup(args) : dataset[primary_key_hash(args)]
+        dataset[primary_key_hash(args)]
       end
     end
     
@@ -223,7 +235,7 @@ module Sequel
         db
         begin
           if sup_class == Model
-            subclass.set_dataset(Model.db[subclass.implicit_table_name]) unless subclass.name.blank?
+            subclass.set_dataset(subclass.implicit_table_name) unless subclass.name.blank?
           elsif ds = sup_class.instance_variable_get(:@dataset)
             subclass.set_dataset(sup_class.sti_key ? sup_class.sti_dataset.filter(sup_class.sti_key=>subclass.name.to_s) : ds.clone, :inherited=>true)
           end
@@ -251,7 +263,7 @@ module Sequel
     # Mark the model as not having a primary key. Not having a primary key
     # can cause issues, among which is that you won't be able to update records.
     def self.no_primary_key
-      @primary_key = nil
+      @simple_pk = @primary_key = nil
     end
 
     # Returns primary key attribute hash.  If using a composite primary key
@@ -329,8 +341,10 @@ module Sequel
       inherited = opts[:inherited]
       @dataset = case ds
       when Symbol
+        @simple_table = db.literal(ds)
         db[ds]
       when Dataset
+        @simple_table = nil
         @db = ds.db
         ds
       else
@@ -339,6 +353,7 @@ module Sequel
       @dataset.set_model(self)
       @dataset.transform(@transform) if @transform
       if inherited
+        @simple_table = sti_key ? nil : superclass.simple_table
         @columns = @dataset.columns rescue nil
       else
         @dataset.extend(DatasetMethods)
@@ -366,6 +381,7 @@ module Sequel
     # You can set it to nil to not have a primary key, but that
     # cause certain things not to work, see #no_primary_key.
     def self.set_primary_key(*key)
+      @simple_pk = key.length == 1 ? db.literal(key.first) : nil 
       @primary_key = (key.length == 1) ? key[0] : key.flatten
     end
 

data/spec/integration/dataset_test.rb

@@ -101,7 +101,7 @@ describe "Dataset UNION, EXCEPT, and INTERSECT" do
   
   specify "should give the correct results for simple UNION, EXCEPT, and INTERSECT" do
     @ds1.union(@ds2).order(:number).map{|x| x[:number].to_s}.should == %w'10 20 30'
-    unless @ds1.class.ancestors.include?(Sequel::Dataset::UnsupportedIntersectExcept)
+    unless defined?(Sequel::Dataset::UnsupportedIntersectExcept) and @ds1.class.ancestors.include?(Sequel::Dataset::UnsupportedIntersectExcept)
       @ds1.except(@ds2).order(:number).map{|x| x[:number].to_s}.should == %w'20'
       @ds1.intersect(@ds2).order(:number).map{|x| x[:number].to_s}.should == %w'10'
     end
@@ -110,7 +110,7 @@ describe "Dataset UNION, EXCEPT, and INTERSECT" do
   specify "should give the correct results for compound UNION, EXCEPT, and INTERSECT" do
     @ds1.union(@ds2).union(@ds3).order(:number).map{|x| x[:number].to_s}.should == %w'10 20 30 40'
     @ds1.union(@ds2.union(@ds3)).order(:number).map{|x| x[:number].to_s}.should == %w'10 20 30 40'
-    unless @ds1.class.ancestors.include?(Sequel::Dataset::UnsupportedIntersectExcept)
+    unless defined?(Sequel::Dataset::UnsupportedIntersectExcept) and @ds1.class.ancestors.include?(Sequel::Dataset::UnsupportedIntersectExcept)
       @ds1.union(@ds2).except(@ds3).order(:number).map{|x| x[:number].to_s}.should == %w'20 30'
       @ds1.union(@ds2.except(@ds3)).order(:number).map{|x| x[:number].to_s}.should == %w'10 20 30'
       @ds1.union(@ds2).intersect(@ds3).order(:number).map{|x| x[:number].to_s}.should == %w'10 '

data/spec/sequel_core/core_sql_spec.rb

@@ -124,6 +124,15 @@ context "String#lit" do
     Sequel::Database.new[:t].update_sql(:stamp => "NOW()".expr).should == \
       "UPDATE t SET stamp = NOW()"
   end
+
+  specify "should return a PlaceholderLiteralString object if args are given" do
+    a = 'DISTINCT ?'.lit(:a)
+    a.should be_a_kind_of(Sequel::SQL::PlaceholderLiteralString)
+    ds = MockDatabase.new.dataset
+    ds.literal(a).should == 'DISTINCT a'
+    ds.quote_identifiers = true
+    ds.literal(a).should == 'DISTINCT "a"'
+  end
 end
 
 context "String#to_blob and #to_sequel_blob" do