sequel 3.33.0 → 3.34.0

data/lib/sequel/no_core_ext.rb

@@ -0,0 +1,2 @@
+::SEQUEL_NO_CORE_EXTENSIONS = true
+require 'sequel'

data/lib/sequel/plugins/caching.rb

@@ -53,9 +53,21 @@ module Sequel
         # The time to live for the cache store, in seconds.
         attr_reader :cache_ttl
 
-        # Set the time to live for the cache store, in seconds (default is 3600, # so 1 hour).
-        def set_cache_ttl(ttl)
-          @cache_ttl = ttl
+        # Delete the cached object with the given primary key.
+        def cache_delete_pk(pk)
+          cache_delete(cache_key(pk))
+        end
+
+        # Return the cached object with the given primary key,
+        # or nil if no such object is in the cache.
+        def cache_get_pk(pk)
+          cache_get(cache_key(pk))
+        end
+
+        # Return a key string for the given primary key.
+        def cache_key(pk)
+          raise(Error, 'no primary key for this record') unless pk.is_a?(Array) ? pk.all? : pk
+          "#{self}:#{Array(pk).join(',')}"
         end
         
         # Copy the necessary class instance variables to the subclass.
@@ -69,8 +81,13 @@ module Sequel
             @cache_ttl = ttl
             @cache_ignore_exceptions = cache_ignore_exceptions
           end
-        end
+        end 
 
+        # Set the time to live for the cache store, in seconds (default is 3600, # so 1 hour).
+        def set_cache_ttl(ttl)
+          @cache_ttl = ttl
+        end
+        
         private
     
         # Delete the entry with the matching key from the cache
@@ -79,6 +96,8 @@ module Sequel
           nil
         end
         
+        # Returned the cached object, or nil if the object was not
+        # in the cached
         def cache_get(ck)
           if @cache_ignore_exceptions
             @cache_store.get(ck) rescue nil
@@ -87,11 +106,6 @@ module Sequel
           end
         end
     
-        # Return a key string for the pk
-        def cache_key(pk)
-          "#{self}:#{Array(pk).join(',')}"
-        end
-        
         # Set the object in the cache_store with the given key for cache_ttl seconds.
         def cache_set(ck, obj)
           @cache_store.set(ck, obj, @cache_ttl)
@@ -120,14 +134,7 @@ module Sequel
         # primary key value(s) for the object.  If the model does not have a primary
         # key, raise an Error.
         def cache_key
-          raise(Error, "No primary key is associated with this model") unless key = primary_key
-          pk = case key
-          when Array
-            key.collect{|k| @values[k]}
-          else
-            @values[key] || (raise Error, 'no primary key for this record')
-          end
-          model.send(:cache_key, pk)
+          model.cache_key(pk)
         end
     
         # Remove the object from the cache when deleting
@@ -140,7 +147,7 @@ module Sequel
     
         # Delete this object from the cache
         def cache_delete
-          model.send(:cache_delete, cache_key)
+          model.cache_delete_pk(pk)
         end
       end
     end

data/lib/sequel/plugins/composition.rb

@@ -35,7 +35,7 @@ module Sequel
     # will be instance_evaled before saving.  The above example could
     # also be implemented as:
     #
-    #   Album.composition, :date,
+    #   Album.composition :date,
     #     :composer=>proc{Date.new(year, month, day) if year || month || day},
     #     :decomposer=>(proc do
     #       if d = compositions[:date]

data/lib/sequel/plugins/hook_class_methods.rb

@@ -90,9 +90,9 @@ module Sequel
 
         # Make a copy of the current class's hooks for the subclass.
         def inherited(subclass)
-          super
           hooks = subclass.instance_variable_set(:@hooks, {}) 
           instance_variable_get(:@hooks).each{|k,v| hooks[k] = v.dup}
+          super
         end
     
         private

data/lib/sequel/plugins/identity_map.rb

@@ -228,10 +228,18 @@ module Sequel
         # key option has a value and the association uses the primary key of
         # the associated class as the :primary_key option, check the identity
         # map for the associated object and return it if present.
-        def _load_associated_objects(opts, dynamic_opts={})
+        def _load_associated_object(opts, dynamic_opts)
           klass = opts.associated_class
-          if !dynamic_opts[:callback] && klass.respond_to?(:identity_map) && idm = klass.identity_map and opts[:type] == :many_to_one and opts.primary_key == klass.primary_key and
-           opts[:key] and pk = _associated_object_pk(opts[:key]) and o = idm[klass.identity_map_key(pk)]
+          cache_lookup = opts.fetch(:idm_cache_lookup) do 
+            opts[:idm_cache_lookup] = klass.respond_to?(:identity_map) &&
+              opts[:type] == :many_to_one &&
+              opts[:key] &&
+              opts.primary_key == klass.primary_key
+          end
+          if cache_lookup &&
+            !dynamic_opts[:callback] &&
+            (idm = klass.identity_map) &&
+            (o = idm[klass.identity_map_key(_associated_object_pk(opts[:key]))])
             o
           else
             super

data/lib/sequel/plugins/instance_filters.rb

@@ -68,6 +68,16 @@ module Sequel
       
         private
         
+        # If there are any instance filters, make sure not to use the
+        # instance delete optimization.
+        def _delete_without_checking
+          if @instance_filters && !@instance_filters.empty?
+            _delete_dataset.delete 
+          else
+            super
+          end
+        end
+
         # Lazily initialize the instance filter array.
         def instance_filters
           @instance_filters ||= []

data/lib/sequel/plugins/many_to_one_pk_lookup.rb

@@ -0,0 +1,71 @@
+module Sequel
+  module Plugins
+    # This is a fairly simple plugin that modifies the internal association loading logic
+    # for many_to_one associations to use a simple primary key lookup on the associated
+    # class, which is generally faster as it uses mostly static SQL.  Additional, if the
+    # associated class is caching primary key lookups, you get the benefit of a cached
+    # lookup.
+    #
+    # This plugin is generally not as fast as the prepared_statements_associations plugin
+    # in the case where the model is not caching primary key lookups, however, it is
+    # probably significantly faster if the model is caching primary key lookups.  If
+    # the prepared_statements_associations plugin has been loaded first, this
+    # plugin will only use the primary key lookup code if the associated model is
+    # caching primary key lookups.
+    #
+    # This plugin attempts to determine cases where the primary key lookup would have
+    # different results than the regular lookup, and use the regular lookup in that case,
+    # but it cannot handle all situations correctly, which is why it is not Sequel's
+    # default behavior.
+    #
+    # You can disable primary key lookups on a per association basis with this
+    # plugin using the :many_to_one_pk_lookup=>false association option.
+    # 
+    # Usage:
+    #
+    #   # Make all model subclass instances use primary key lookups for many_to_one
+    #   # association loading
+    #   Sequel::Model.plugin :many_to_one_pk_lookup
+    #
+    #   # Do so for just the album class.
+    #   Album.plugin :many_to_one_pk_lookup
+    module ManyToOnePkLookup
+      module InstanceMethods
+        private
+
+        # If the current association is a fairly simple many_to_one association, use
+        # a simple primary key lookup on the associated model, which can benefit from
+        # caching if the associated model is using caching.
+        def _load_associated_object(opts, dynamic_opts)
+          klass = opts.associated_class
+          cache_lookup = opts.fetch(:many_to_one_pk_lookup) do 
+            opts[:many_to_one_pk_lookup] = opts[:type] == :many_to_one &&
+              opts[:key] &&
+              opts.primary_key == klass.primary_key
+          end
+          if cache_lookup &&
+            !dynamic_opts[:callback] &&
+            (o = klass.send(:primary_key_lookup, ((fk = opts[:key]).is_a?(Array) ? fk.map{|c| send(c)} : send(fk))))
+            o
+          else
+            super
+          end
+        end
+
+        # Deal with the situation where the prepared_statements_associations plugin is
+        # loaded first, by using a primary key lookup for many_to_one associations if
+        # the associated class is using caching, and using the default code otherwise.
+        # This is done because the prepared_statements_associations code is probably faster
+        # than the primary key lookup this plugin uses if the model is not caching lookups,
+        # but probably slower if the model is caching lookups.
+        def _load_associated_objects(opts, dynamic_opts={})
+          if opts.can_have_associated_objects?(self) && opts[:type] == :many_to_one && opts.associated_class.respond_to?(:cache_get_pk)
+            _load_associated_object(opts, dynamic_opts)
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/nested_attributes.rb

@@ -159,7 +159,7 @@ module Sequel
         # is not found and the :strict option is not false, raise an Error.
         def nested_attributes_find(reflection, pk)
           pk = pk.to_s
-          unless obj = Array(associated_objects = send(reflection[:name])).find{|x| x.pk.to_s == pk}
+          unless obj = Array(send(reflection[:name])).find{|x| x.pk.to_s == pk}
             raise(Error, "no matching associated object with given primary key (association: #{reflection[:name]}, pk: #{pk})") unless reflection[:nested_attributes][:strict] == false
           end
           obj
@@ -218,9 +218,10 @@ module Sequel
           modified!
           klass = reflection.associated_class
           if pk = attributes.delete(klass.primary_key) || attributes.delete(klass.primary_key.to_s)
-            if klass.db.send(:typecast_value_boolean, attributes[:_delete] || attributes['_delete']) && reflection[:nested_attributes][:destroy]
+            attributes = attributes.dup
+            if reflection[:nested_attributes][:destroy] && klass.db.send(:typecast_value_boolean, attributes.delete(:_delete) || attributes.delete('_delete'))
               nested_attributes_remove(reflection, pk, :destroy=>true)
-            elsif klass.db.send(:typecast_value_boolean, attributes[:_remove] || attributes['_remove']) && reflection[:nested_attributes][:remove]
+            elsif reflection[:nested_attributes][:remove] && klass.db.send(:typecast_value_boolean, attributes.delete(:_remove) || attributes.delete('_remove'))
               nested_attributes_remove(reflection, pk)
             else
               nested_attributes_update(reflection, pk, attributes)

data/lib/sequel/plugins/prepared_statements.rb

@@ -46,7 +46,9 @@ module Sequel
         # Create a prepared statement based on the given dataset with a unique name for the given
         # type of query and values.
         def prepare_statement(ds, type, vals={})
-          ds.prepare(type, :"smpsp_#{NEXT.call}", vals)
+          ps = ds.prepare(type, :"smpsp_#{NEXT.call}", vals)
+          ps.log_sql = true
+          ps
         end
 
         # Return a sorted array of columns for use as a hash key.

data/lib/sequel/plugins/prepared_statements_associations.rb

@@ -62,7 +62,11 @@ module Sequel
         # that, given appropriate bound variables, the prepared statement will work correctly for any
         # instance.
         def association_prepared_statement(opts)
-          opts[:prepared_statement] ||= _associated_dataset(opts, {}).unbind.first.prepare(opts.returns_array? ? :select : :first, :"smpsap_#{NEXT.call}")
+          opts[:prepared_statement] ||= begin
+            ps = _associated_dataset(opts, {}).unbind.first.prepare(opts.returns_array? ? :select : :first, :"smpsap_#{NEXT.call}")
+            ps.log_sql = true
+            ps
+          end
         end
 
         # If a prepared statement can be used to load the associated objects, execute it to retrieve them.  Otherwise,

data/lib/sequel/plugins/schema.rb

@@ -29,7 +29,7 @@ module Sequel
         # Drops the table if it exists and then runs create_table.  Should probably
         # not be used except in testing.
         def create_table!(*args, &block)
-          drop_table rescue nil
+          drop_table?
           create_table(*args, &block)
         end
 
@@ -38,11 +38,16 @@ module Sequel
           create_table(*args, &block) unless table_exists?
         end
         
-        # Drops table.
+        # Drops table.  If the table doesn't exist, this will probably raise an error.
         def drop_table
           db.drop_table(table_name)
         end
     
+        # Drops table if it already exists, do nothing if it doesn't exist.
+        def drop_table?
+          db.drop_table?(table_name)
+        end
+    
         # Returns table schema created with set_schema for direct descendant of Model.
         # Does not retreive schema information from the database, see db_schema if you
         # want that.

data/lib/sequel/plugins/single_table_inheritance.rb

@@ -117,7 +117,7 @@ module Sequel
             @sti_dataset = sd
             @sti_key_map = skm
             @sti_model_map = smm
-            @simple_table = nil
+            self.simple_table = nil
           end
         end
 

data/lib/sequel/plugins/static_cache.rb

@@ -0,0 +1,99 @@
+module Sequel
+  module Plugins
+    # The static_cache plugin is designed for models that are not modified at all
+    # in production use cases, or at least where modifications to them would usually
+    # coincide with an application restart.  When loaded into a model class, it 
+    # retrieves all rows in the database and staticly caches a ruby array and hash
+    # keyed on primary key containing all of the model instances.  All of these instances
+    # are frozen so they won't be modified unexpectedly.
+    #
+    # The caches this plugin creates are used for the following things:
+    #
+    # * Primary key lookups (e.g. Model[1])
+    # * Model.all calls
+    # * Model.each calls
+    # * Model.map calls without an argument
+    # * Model.to_hash calls without an argument
+    #
+    # Usage:
+    #
+    #   # Cache the AlbumType class staticly
+    #   AlbumType.plugin :static_cache
+    module StaticCache
+      # Populate the static caches when loading the plugin.
+      def self.configure(model)
+        model.send(:load_cache)
+      end
+
+      module ClassMethods
+        # A frozen ruby hash holding all of the model's frozen instances, keyed by frozen primary key.
+        attr_reader :cache
+
+        # An array of all of the model's frozen instances, without issuing a database
+        # query.
+        def all
+          @all.dup
+        end
+
+        # Return the frozen object with the given pk, or nil if no such object exists
+        # in the cache, without issuing a database query.
+        def cache_get_pk(pk)
+          cache[pk]
+        end
+
+        # Yield each of the model's frozen instances to the block, without issuing a database
+        # query.
+        def each(&block)
+          @all.each(&block)
+        end
+
+        # If no arguments are given, yield each of the model's frozen instances to the block.
+        # and return a new array, without issuing a database query.  If any arguments are
+        # given, use the default Sequel behavior.
+        def map(*a)
+          if a.empty?
+            @all.map(&(Proc.new if block_given?))
+          else
+            super
+          end
+        end
+
+        # Reload the cache when the dataset changes.
+        def set_dataset(*)
+          s = super
+          load_cache
+          s
+        end
+
+        # If no arguments are given, yield an identity map for the model with frozen primary keys
+        # and instances, without issuing a database query. If any arguments are
+        # given, use the default Sequel behavior.
+        def to_hash(*a)
+          if a.empty?
+            cache.dup
+          else
+            super
+          end
+        end
+
+        private
+
+        # Return the frozen object with the given pk, or nil if no such object exists
+        # in the cache, without issuing a database query.
+        def primary_key_lookup(pk)
+          cache[pk]
+        end
+
+        # Reload the cache for this model by retrieving all of the instances in the dataset
+        # freezing them, and populating the cached array and hash.
+        def load_cache
+          a = dataset.all
+          h = {}
+          a.each{|o| h[o.pk.freeze] = o.freeze}
+          @all = a.freeze
+          @cache = h.freeze
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/validation_class_methods.rb

@@ -60,7 +60,6 @@ module Sequel
 
         # Setup the validations and validation_reflections hash in the subclass.
         def inherited(subclass)
-          super
           vr = @validation_reflections
           subclass.class_eval do
             @validation_mutex = Mutex.new
@@ -69,6 +68,7 @@ module Sequel
             vr.each{|k,v| h[k] = v.dup}
             @validation_reflections = h
           end
+          super
         end
     
         # Instructs the model to skip validations defined in superclasses

data/lib/sequel/sql.rb

@@ -281,6 +281,293 @@ module Sequel
       end
     end
 
+    # These methods are designed as replacements for the core extensions, so that
+    # Sequel is still easy to use if the core extensions are not enabled.
+    module Builders
+      # Create an SQL::AliasedExpression for the given expression and alias.
+      #
+      #   Sequel.as(:column, :alias) # "column" AS "alias"
+      def as(exp, aliaz)
+        SQL::AliasedExpression.new(exp, aliaz)
+      end
+
+      # Order the given argument ascending.
+      # Options:
+      #
+      # :nulls :: Set to :first to use NULLS FIRST (so NULL values are ordered
+      #           before other values), or :last to use NULLS LAST (so NULL values
+      #           are ordered after other values).
+      #
+      #   Sequel.asc(:a) # a ASC
+      #   Sequel.asc(:b, :nulls=>:last) # b ASC NULLS LAST
+      def asc(arg, opts={})
+        SQL::OrderedExpression.new(arg, false, opts)
+      end
+
+      # Return an <tt>SQL::Blob</tt> that holds the same data as this string.
+      # Blobs provide proper escaping of binary data.  If given a blob, returns it
+      # directly.
+      def blob(s)
+        if s.is_a?(SQL::Blob)
+          s
+        else
+          SQL::Blob.new(s)
+        end
+      end
+
+      # Return an <tt>SQL::CaseExpression</tt> created with the given arguments.
+      #
+      #   Sequel.case([[{:a=>[2,3]}, 1]], 0) # SQL: CASE WHEN a IN (2, 3) THEN 1 ELSE 0 END
+      #   Sequel.case({:a=>1}, 0, :b) # SQL: CASE b WHEN a THEN 1 ELSE 0 END
+      def case(*args) # core_sql ignore
+        SQL::CaseExpression.new(*args)
+      end
+
+      # Cast the reciever to the given SQL type.  You can specify a ruby class as a type,
+      # and it is handled similarly to using a database independent type in the schema methods.
+      #
+      #   Sequel.cast(:a, :integer) # CAST(a AS integer)
+      #   Sequel.cast(:a, String) # CAST(a AS varchar(255))
+      def cast(arg, sql_type)
+        SQL::Cast.new(arg, sql_type)
+      end
+
+      # Cast the reciever to the given SQL type (or the database's default Integer type if none given),
+      # and return the result as a +NumericExpression+, so you can use the bitwise operators
+      # on the result. 
+      #
+      #   Sequel.cast_numeric(:a) # CAST(a AS integer)
+      #   Sequel.cast_numeric(:a, Float) # CAST(a AS double precision)
+      def cast_numeric(arg, sql_type = nil)
+        cast(arg, sql_type || Integer).sql_number
+      end
+
+      # Cast the reciever to the given SQL type (or the database's default String type if none given),
+      # and return the result as a +StringExpression+, so you can use +
+      # directly on the result for SQL string concatenation.
+      #
+      #   Sequel.cast_string(:a) # CAST(a AS varchar(255))
+      #   Sequel.cast_string(:a, :text) # CAST(a AS text)
+      def cast_string(arg, sql_type = nil)
+        cast(arg, sql_type || String).sql_string
+      end
+
+      # Order the given argument descending.
+      # Options:
+      #
+      # :nulls :: Set to :first to use NULLS FIRST (so NULL values are ordered
+      #           before other values), or :last to use NULLS LAST (so NULL values
+      #           are ordered after other values).
+      #
+      #   Sequel.desc(:a) # b DESC
+      #   Sequel.desc(:b, :nulls=>:first) # b DESC NULLS FIRST
+      def desc(arg, opts={})
+        SQL::OrderedExpression.new(arg, true, opts)
+      end
+
+      # Wraps the given object in an appropriate Sequel wrapper.
+      # If the given object is already a Sequel object, return it directly.
+      # For condition specifiers (hashes and arrays of two pairs), true, and false,
+      # return a boolean expressions.  For numeric objects, return a numeric
+      # expression.  For strings, return a string expression.  For procs or when
+      # the method is passed a block, evaluate it as a virtual row and wrap it
+      # appropriately.  In all other cases, use a generic wrapper.
+      #
+      # This method allows you to construct SQL expressions that are difficult
+      # to construct via other methods.  For example:
+      #
+      #   Sequel.expr(1) - :a # SQL: (1 - a)
+      def expr(arg=(no_arg=true), &block)
+        if block_given?
+          if no_arg
+            return expr(block)
+          else
+            raise Error, 'cannot provide both an argument and a block to Sequel.expr'
+          end
+        elsif no_arg
+          raise Error, 'must provide either an argument or a block to Sequel.expr'
+        end
+
+        case arg
+        when SQL::Expression, LiteralString, SQL::Blob
+          arg
+        when Hash
+          SQL::BooleanExpression.from_value_pairs(arg, :AND)
+        when Array
+          if condition_specifier?(arg)
+            SQL::BooleanExpression.from_value_pairs(arg, :AND)
+          else
+            SQL::Wrapper.new(arg)
+          end
+        when Numeric
+          SQL::NumericExpression.new(:NOOP, arg)
+        when String
+          SQL::StringExpression.new(:NOOP, arg)
+        when TrueClass, FalseClass
+          SQL::BooleanExpression.new(:NOOP, arg)
+        when Proc
+          expr(virtual_row(&arg))
+        else
+          SQL::Wrapper.new(arg)
+        end
+      end
+
+      # Extract a datetime_part (e.g. year, month) from the given
+      # expression:
+      #
+      #   Sequel.extract(:year, :date) # extract(year FROM "date")
+      def extract(datetime_part, exp)
+        SQL::NumericExpression.new(:extract, datetime_part, exp)
+      end
+
+      # Returns a <tt>Sequel::SQL::Function</tt> with the function name
+      # and the given arguments.
+      #
+      #   Sequel.function(:now) # SQL: now()
+      #   Sequel.function(:substr, :a, 1) # SQL: substr(a, 1)
+      def function(name, *args)
+        SQL::Function.new(name, *args)
+      end
+
+      # Return the argument wrapped as an <tt>SQL::Identifier</tt>.
+      #
+      #   Sequel.identifier(:a__b) # "a__b"
+      def identifier(name)
+        SQL::Identifier.new(name)
+      end
+
+      # Return a <tt>Sequel::SQL::StringExpression</tt> representing an SQL string made up of the
+      # concatenation of the given array's elements.  If an argument is passed,
+      # it is used in between each element of the array in the SQL
+      # concatenation.
+      #
+      #   Sequel.join([:a]) # SQL: a
+      #   Sequel.join([:a, :b]) # SQL: a || b
+      #   Sequel.join([:a, 'b']) # SQL: a || 'b'
+      #   Sequel.join(['a', :b], ' ') # SQL: 'a' || ' ' || b
+      def join(args, joiner=nil)
+        raise Error, 'argument to Sequel.join must be an array' unless args.is_a?(Array)
+        if joiner
+          args = args.zip([joiner]*args.length).flatten
+          args.pop
+        end
+
+        return SQL::StringExpression.new(:NOOP, '') if args.empty?
+
+        args = args.map do |a|
+          case a
+          when Symbol, ::Sequel::SQL::Expression, ::Sequel::LiteralString, TrueClass, FalseClass, NilClass
+            a
+          else
+            a.to_s
+          end
+        end
+        SQL::StringExpression.new(:'||', *args)
+      end
+
+      # Create a <tt>BooleanExpression</tt> case insensitive (if the database supports it) pattern match of the receiver with
+      # the given patterns.  See <tt>SQL::StringExpression.like</tt>.
+      #
+      #   Sequel.ilike(:a, 'A%') # "a" ILIKE 'A%'
+      def ilike(*args)
+        SQL::StringExpression.like(*(args << {:case_insensitive=>true}))
+      end
+
+      # Create a <tt>SQL::BooleanExpression</tt> case sensitive (if the database supports it) pattern match of the receiver with
+      # the given patterns.  See <tt>SQL::StringExpression.like</tt>.
+      #
+      #   Sequel.like(:a, 'A%') # "a" LIKE 'A%'
+      def like(*args)
+        SQL::StringExpression.like(*args)
+      end
+
+      # Converts a string into a <tt>Sequel::LiteralString</tt>, in order to override string
+      # literalization, e.g.:
+      #
+      #   DB[:items].filter(:abc => 'def').sql #=>
+      #     "SELECT * FROM items WHERE (abc = 'def')"
+      #
+      #   DB[:items].filter(:abc => Sequel.lit('def')).sql #=>
+      #     "SELECT * FROM items WHERE (abc = def)"
+      #
+      # You can also provide arguments, to create a <tt>Sequel::SQL::PlaceholderLiteralString</tt>:
+      #
+      #    DB[:items].select{|o| o.count(Sequel.lit('DISTINCT ?', :a))}.sql #=>
+      #      "SELECT count(DISTINCT a) FROM items"
+      def lit(s, *args) # core_sql ignore
+        if args.empty?
+          if s.is_a?(LiteralString)
+            s
+          else
+            LiteralString.new(s)
+          end
+        else
+          SQL::PlaceholderLiteralString.new(s, args) 
+        end
+      end
+
+      # Return a <tt>Sequel::SQL::BooleanExpression</tt> created from the condition
+      # specifier, matching none of the conditions.
+      #
+      #   Sequel.negate(:a=>true) # SQL: a IS NOT TRUE
+      #   Sequel.negate([[:a, true]]) # SQL: a IS NOT TRUE
+      #   Sequel.negate([[:a, 1], [:b, 2]]) # SQL: ((a != 1) AND (b != 2))
+      def negate(arg)
+        if condition_specifier?(arg)
+          SQL::BooleanExpression.from_value_pairs(arg, :AND, true)
+        else
+          raise Error, 'must pass a conditions specifier to Sequel.negate'
+        end
+      end
+
+      # Return a <tt>Sequel::SQL::BooleanExpression</tt> created from the condition
+      # specifier, matching any of the conditions.
+      #
+      #   Sequel.or(:a=>true) # SQL: a IS TRUE
+      #   Sequel.or([[:a, true]]) # SQL: a IS TRUE
+      #   Sequel.or([[:a, 1], [:b, 2]]) # SQL: ((a = 1) OR (b = 2))
+      def or(arg)
+        if condition_specifier?(arg)
+          SQL::BooleanExpression.from_value_pairs(arg, :OR, false)
+        else
+          raise Error, 'must pass a conditions specifier to Sequel.or'
+        end
+      end
+
+      # Create a qualified identifier with the given qualifier and identifier
+      #
+      #   Sequel.qualify(:table, :column) # "table"."column"
+      #   Sequel.qualify(:schema, :table) # "schema"."table"
+      #   Sequel.qualify(:table, :column).qualify(:schema) # "schema"."table"."column"
+      def qualify(qualifier, identifier)
+        SQL::QualifiedIdentifier.new(qualifier, identifier)
+      end
+
+      # Return an <tt>SQL::Subscript</tt> with the given arguments, representing an
+      # SQL array access.
+      #
+      #   Sequel.subscript(:array, 1) # array[1]
+      #   Sequel.subscript(:array, 1, 2) # array[1, 2]
+      #   Sequel.subscript(:array, [1, 2]) # array[1, 2]
+      def subscript(exp, *subs)
+        SQL::Subscript.new(exp, subs.flatten)
+      end
+
+      # Return a <tt>SQL::ValueList</tt> created from the given array.  Used if the array contains
+      # all two element arrays and you want it treated as an SQL value list (IN predicate) 
+      # instead of as a conditions specifier (similar to a hash).  This is not necessary if you are using
+      # this array as a value in a filter, but may be necessary if you are using it as a
+      # value with placeholder SQL:
+      #
+      #   DB[:a].filter([:a, :b]=>[[1, 2], [3, 4]]) # SQL: (a, b) IN ((1, 2), (3, 4))
+      #   DB[:a].filter('(a, b) IN ?', [[1, 2], [3, 4]]) # SQL: (a, b) IN ((1 = 2) AND (3 = 4))
+      #   DB[:a].filter('(a, b) IN ?', Sequel.value_list([[1, 2], [3, 4]])) # SQL: (a, b) IN ((1, 2), (3, 4))
+      def value_list(arg)
+        raise Error, 'argument to Sequel.value_list must be an array' unless arg.is_a?(Array)
+        SQL::ValueList.new(arg)
+      end
+    end
+
     # Holds methods that are used to cast objects to different SQL types.
     module CastMethods 
       # Cast the reciever to the given SQL type.  You can specify a ruby class as a type,
@@ -333,10 +620,6 @@ module Sequel
       #
       # Also has the benefit of returning the result as a
       # NumericExpression instead of a generic ComplexExpression.
-      #
-      # The extract function is in the SQL standard, but it doesn't
-      # doesn't use the standard function calling convention, and it
-      # doesn't work on all databases.
       def extract(datetime_part)
         NumericExpression.new(:extract, datetime_part, self)
       end
@@ -424,6 +707,46 @@ module Sequel
       end
     end
 
+    # These methods are designed as replacements for the core extension operator
+    # methods, so that Sequel is still easy to use if the core extensions are not
+    # enabled.
+    #
+    # The following methods are defined via metaprogramming: +, -, *, /, &, |.
+    # The +, -, *, and / operators return numeric expressions combining all the
+    # arguments with the appropriate operator, and the & and | operators return
+    # boolean expressions combining all of the arguments with either AND or OR.
+    module OperatorBuilders
+      %w'+ - * /'.each do |op|
+        class_eval(<<-END, __FILE__, __LINE__ + 1)
+          def #{op}(*args)
+            SQL::NumericExpression.new(:#{op}, *args)
+          end
+        END
+      end
+
+      {'&'=>'AND', '|'=>'OR'}.each do |m, op|
+        class_eval(<<-END, __FILE__, __LINE__ + 1)
+          def #{m}(*args)
+            SQL::BooleanExpression.new(:#{op}, *args)
+          end
+        END
+      end
+      
+      # Invert the given expression.  Returns a <tt>Sequel::SQL::BooleanExpression</tt>
+      # created from this argument, not matching all of the conditions.
+      #
+      #   Sequel.~(nil) # SQL: NOT NULL
+      #   Sequel.~([[:a, true]]) # SQL: a IS NOT TRUE
+      #   Sequel.~([[:a, 1], [:b, [2, 3]]]) # SQL: a != 1 OR b NOT IN (2, 3)
+      def ~(arg)
+        if condition_specifier?(arg)
+          SQL::BooleanExpression.from_value_pairs(arg, :OR, true)
+        else
+          SQL::BooleanExpression.invert(arg)
+        end
+      end
+    end
+
     # Methods that create +OrderedExpressions+, used for sorting by columns
     # or more complex expressions.
     module OrderMethods
@@ -856,7 +1179,8 @@ module Sequel
       # substituted for :key phrases).
       attr_reader :args
 
-      # The literal string containing placeholders
+      # The literal string containing placeholders.  This can also be an array
+      # of strings, where each arg in args goes between the string elements. 
       attr_reader :str
 
       # Whether to surround the expression with parantheses
@@ -944,7 +1268,7 @@ module Sequel
         @table, @column = table, column
       end
       
-      to_s_method :qualified_identifier_sql
+      to_s_method :qualified_identifier_sql, "@table, @column"
     end
     
     # Subclass of +ComplexExpression+ where the expression results
@@ -1023,9 +1347,21 @@ module Sequel
 
       # Create a new +Subscript+ appending the given subscript(s)
       # the the current array of subscripts.
+      #
+      #   :a.sql_subscript(2) # a[2]
+      #   :a.sql_subscript(2) | 1 # a[2, 1]
       def |(sub)
         Subscript.new(@f, @sub + Array(sub))
       end
+
+      # Create a new +Subscript+ by accessing a subarray of a multidimensional
+      # array.
+      #
+      #   :a.sql_subscript(2) # a[2]
+      #   :a.sql_subscript(2)[1] # a[2][1]
+      def [](sub)
+        Subscript.new(self, Array(sub))
+      end
       
       to_s_method :subscript_sql
     end
@@ -1076,28 +1412,71 @@ module Sequel
     # Examples:
     #
     #   ds = DB[:t]
+    #
     #   # Argument yielded to block
     #   ds.filter{|r| r.name < 2} # SELECT * FROM t WHERE (name < 2)
+    #
     #   # Block without argument (instance_eval)
     #   ds.filter{name < 2} # SELECT * FROM t WHERE (name < 2)
+    #
     #   # Qualified identifiers
     #   ds.filter{table__column + 1 < 2} # SELECT * FROM t WHERE ((table.column + 1) < 2)
+    #
     #   # Functions
     #   ds.filter{is_active(1, 'arg2')} # SELECT * FROM t WHERE is_active(1, 'arg2')
     #   ds.select{version{}} # SELECT version() FROM t
     #   ds.select{count(:*){}} # SELECT count(*) FROM t
     #   ds.select{count(:distinct, col1){}} # SELECT count(DISTINCT col1) FROM t
+    #
     #   # Window Functions
     #   ds.select{rank(:over){}} # SELECT rank() OVER () FROM t
     #   ds.select{count(:over, :*=>true){}} # SELECT count(*) OVER () FROM t
     #   ds.select{sum(:over, :args=>col1, :partition=>col2, :order=>col3){}} # SELECT sum(col1) OVER (PARTITION BY col2 ORDER BY col3) FROM t
     #
+    #   # Math Operators
+    #   ds.select{|o| o.+(1, :a).as(:b)} # SELECT (1 + a) AS b FROM t
+    #   ds.select{|o| o.-(2, :a).as(:b)} # SELECT (2 - a) AS b FROM t
+    #   ds.select{|o| o.*(3, :a).as(:b)} # SELECT (3 * a) AS b FROM t
+    #   ds.select{|o| o./(4, :a).as(:b)} # SELECT (4 / a) AS b FROM t
+    #
+    #   # Boolean Operators
+    #   ds.filter{|o| o.&({:a=>1}, :b)}    # SELECT * FROM t WHERE ((a = 1) AND b)
+    #   ds.filter{|o| o.|({:a=>1}, :b)}    # SELECT * FROM t WHERE ((a = 1) OR b)
+    #   ds.filter{|o| o.~({:a=>1})}        # SELECT * FROM t WHERE (a != 1)
+    #   ds.filter{|o| o.~({:a=>1, :b=>2})} # SELECT * FROM t WHERE ((a != 1) OR (b != 2))
+    #
+    #   # Inequality Operators
+    #   ds.filter{|o| o.>(1, :a)}  # SELECT * FROM t WHERE (1 > a)
+    #   ds.filter{|o| o.<(2, :a)}  # SELECT * FROM t WHERE (2 < a)
+    #   ds.filter{|o| o.>=(3, :a)} # SELECT * FROM t WHERE (3 >= a)
+    #   ds.filter{|o| o.<=(4, :a)} # SELECT * FROM t WHERE (4 <= a)
+    #
+    #   # Literal Strings
+    #   ds.filter{{a=>`some SQL`}} # SELECT * FROM t WHERE (a = some SQL)
+    #
     # For a more detailed explanation, see the {Virtual Rows guide}[link:files/doc/virtual_rows_rdoc.html].
     class VirtualRow < BasicObject
       WILDCARD = LiteralString.new('*').freeze
       QUESTION_MARK = LiteralString.new('?').freeze
       COMMA_SEPARATOR = LiteralString.new(', ').freeze
       DOUBLE_UNDERSCORE = '__'.freeze
+      DISTINCT = ["DISTINCT ".freeze].freeze
+      COMMA_ARRAY = [COMMA_SEPARATOR].freeze
+
+      include OperatorBuilders
+
+      %w'> < >= <='.each do |op|
+        class_eval(<<-END, __FILE__, __LINE__ + 1)
+          def #{op}(*args)
+            SQL::BooleanExpression.new(:#{op}, *args)
+          end
+        END
+      end
+
+      # Return a literal string created with the given string.
+      def `(s)
+        Sequel::LiteralString.new(s)
+      end
 
       # Return an +Identifier+, +QualifiedIdentifier+, +Function+, or +WindowFunction+, depending
       # on arguments and whether a block is provided.  Does not currently call the block.
@@ -1111,7 +1490,7 @@ module Sequel
             when :*
               Function.new(m, WILDCARD)
             when :distinct
-              Function.new(m, PlaceholderLiteralString.new("DISTINCT #{args.map{QUESTION_MARK}.join(COMMA_SEPARATOR)}", args))
+              Function.new(m, PlaceholderLiteralString.new(DISTINCT + COMMA_ARRAY * (args.length-1), args))
             when :over
               opts = args.shift || {}
               fun_args = ::Kernel.Array(opts[:*] ? WILDCARD : opts[:args])
@@ -1165,6 +1544,20 @@ module Sequel
 
       to_s_method :window_function_sql, '@function, @window'
     end
+
+    # A +Wrapper+ is a simple way to wrap an existing object so that it supports
+    # the Sequel DSL.
+    class Wrapper < GenericExpression
+      # The underlying value wrapped by this object.
+      attr_reader :value
+
+      # Set the value wrapped by the object.
+      def initialize(value)
+        @value = value
+      end
+
+      to_s_method :literal, '@value'
+    end
   end
 
   # +LiteralString+ is used to represent literal SQL expressions. A 
@@ -1177,7 +1570,24 @@ module Sequel
     include SQL::NumericMethods
     include SQL::StringMethods
     include SQL::InequalityMethods
+
+    # If the core extensions are enabled, these will already be included
+    # in String, so we don't need to include/define them here.
+    unless Sequel.core_extensions?
+      include Sequel::SQL::AliasMethods
+      include Sequel::SQL::CastMethods
+      
+      def lit(*args)
+        args.empty? ? self : SQL::PlaceholderLiteralString.new(self, args)
+      end
+      
+      def to_sequel_blob
+        SQL::Blob.new(self)
+      end
+    end
   end
   
   include SQL::Constants
+  extend SQL::Builders
+  extend SQL::OperatorBuilders
 end