sequel 4.10.0 → 4.11.0

data/lib/sequel/extensions/to_dot.rb

@@ -92,6 +92,7 @@ module Sequel
         dot "AliasedExpression"
         v(e.expression, :expression)
         v(e.alias, :alias)
+        v(e.columns, :columns) if e.columns
       when SQL::CaseExpression
         dot "CaseExpression"
         v(e.expression, :expression) if e.expression
@@ -102,18 +103,16 @@ module Sequel
         v(e.expr, :expr)
         v(e.type, :type)
       when SQL::Function
-        dot "Function: #{e.f}"
+        dot "Function: #{e.name}"
         e.args.each_with_index do |val, j|
           v(val, j)
         end
+        v(e.args, :args)
+        v(e.opts, :opts)
       when SQL::Subscript 
         dot "Subscript"
         v(e.f, :f)
         v(e.sub, :sub)
-      when SQL::WindowFunction
-        dot "WindowFunction"
-        v(e.function, :function)
-        v(e.window, :window)
       when SQL::Window
         dot "Window"
         v(e.opts, :opts)
@@ -130,8 +129,7 @@ module Sequel
           str << " USING"
         end
         dot str
-        v(e.table, :table)
-        v(e.table_alias, :alias) if e.table_alias
+        v(e.table_expr, :table)
         if e.is_a?(SQL::JoinOnClause)
           v(e.on, :on) 
         elsif e.is_a?(SQL::JoinUsingClause)

data/lib/sequel/model/associations.rb

@@ -1350,20 +1350,6 @@ module Sequel
           association_reflections.values
         end
         
-        # REMOVE410
-        def apply_association_dataset_opts(opts, ds)
-          Deprecation.deprecate("Model.apply_association_dataset_opts/Model.eager_loading_dataset", "Use AssociationReflection#apply_dataset_changes/Association#reflection#apply_eager_dataset_changes instead.")
-          ds = ds.select(*opts.select) if opts.select
-          if c = opts[:conditions]
-            ds = (c.is_a?(Array) && !Sequel.condition_specifier?(c)) ? ds.where(*c) : ds.where(c)
-          end
-          ds = ds.order(*opts[:order]) if opts[:order]
-          ds = ds.eager(opts[:eager]) if opts[:eager]
-          ds = ds.distinct if opts[:distinct]
-          ds = opts[:eager_block].call(ds) if opts[:eager_block]
-          ds
-        end
-
         # Associates a related model with the current model. The following types are
         # supported:
         #
@@ -1646,22 +1632,6 @@ module Sequel
           opts.eager_load_results(eo, &block)
         end
 
-        # REMOVE410
-        def eager_loading_dataset(opts, ds, select, associations, eager_options=OPTS)
-          ds = apply_association_dataset_opts(opts, ds)
-          ds = ds.select(*select) if select
-          if opts[:eager_graph]
-            raise(Error, "cannot eagerly load a #{opts[:type]} association that uses :eager_graph") if opts.eager_loading_use_associated_key?
-            ds = ds.eager_graph(opts[:eager_graph])
-          end
-          ds = ds.eager(associations) unless Array(associations).empty?
-          ds = eager_options[:eager_block].call(ds) if eager_options[:eager_block]
-          if opts.eager_loading_use_associated_key?
-            ds = ds.select_append(*opts.associated_key_array)
-          end
-          ds
-        end
-
         # Shortcut for adding a many_to_many association, see #associate
         def many_to_many(name, opts=OPTS, &block)
           associate(:many_to_many, name, opts, &block)
@@ -1711,19 +1681,6 @@ module Sequel
           association_module(opts).send(:private, name)
         end
 
-        # REMOVE410
-        def def_add_method(opts)
-          Deprecation.deprecate("Model.def_add_method", "The Model.associate method now sets up the add method you if an :adder association reflection entry is present.")
-          association_module_def(opts.add_method, opts){|o,*args| add_associated_object(opts, o, *args)}
-        end
-
-        # REMOVE410
-        def def_association_dataset_methods(opts)
-          Deprecation.deprecate("Model.def_association_dataset_methods", "The Model.associate method now sets up the association dataset methods.")
-          association_module_def(opts.dataset_method, opts){_dataset(opts)}
-          def_association_method(opts)
-        end
-      
         # Adds the association method to the association methods module.
         def def_association_method(opts)
           association_module_def(opts.association_method, opts){|*dynamic_opts, &block| load_associated_objects(opts, dynamic_opts[0], &block)}
@@ -1996,13 +1953,6 @@ module Sequel
           def_one_to_many(opts)
         end
         
-        # REMOVE410
-        def def_remove_methods(opts)
-          Deprecation.deprecate("Model.def_remove_methods", "The Model.associate method now sets up the remove/remove_all methods for you if a :remover or :clearer association reflection entry is present.")
-          association_module_def(opts.remove_method, opts){|o,*args| remove_associated_object(opts, o, *args)}
-          association_module_def(opts.remove_all_method, opts){|*args| remove_all_associated_objects(opts, *args)}
-        end
-          
         # Return dataset to graph into given the association reflection, applying the :callback option if set.
         def eager_graph_dataset(opts, eager_options)
           ds = opts.associated_class.dataset

data/lib/sequel/plugins/class_table_inheritance.rb

@@ -71,7 +71,9 @@ module Sequel
     #   # You can also set options when loading the plugin:
     #   # :kind :: column to hold the class name
     #   # :table_map :: map of class name symbols to table name symbols
-    #   Employee.plugin :class_table_inheritance, :key=>:kind, :table_map=>{:Staff=>:staff}
+    #   # :model_map :: map of column values to class name symbols
+    #   Employee.plugin :class_table_inheritance, :key=>:kind, :table_map=>{:Staff=>:staff},
+    #     :model_map=>{1=>:Employee, 2=>:Manager, 3=>:Executive, 4=>:Staff}
     module ClassTableInheritance
       # The class_table_inheritance plugin requires the lazy_attributes plugin
       # to handle lazily-loaded attributes for subclass instances returned
@@ -83,25 +85,26 @@ module Sequel
       # Initialize the per-model data structures and set the dataset's row_proc
       # to check for the :key option column for the type of class when loading objects.
       # Options:
-      # * :key - The column symbol holding the name of the model class this
-      #   is an instance of.  Necessary if you want to call model methods
-      #   using the superclass, but have them return subclass instances.
-      # * :table_map - Hash with class name symbol keys and table name symbol
-      #   values.  Necessary if the implicit table name for the model class
-      #   does not match the database table name
+      # :key :: The column symbol holding the name of the model class this
+      #         is an instance of.  Necessary if you want to call model methods
+      #         using the superclass, but have them return subclass instances.
+      # :table_map :: Hash with class name symbol keys and table name symbol
+      #               values.  Necessary if the implicit table name for the model class
+      #               does not match the database table name
+      # :model_map :: Hash with keys being values of the cti_key column, and values
+      #               being class name strings or symbols.  Used if you don't want to
+      #               store class names in the database.  If you use this option, you
+      #               are responsible for setting the values of the cti_key column
+      #               manually (usually in a before_create hook).
       def self.configure(model, opts=OPTS)
         model.instance_eval do
-          m = method(:constantize)
           @cti_base_model = self
           @cti_key = key = opts[:key] 
           @cti_tables = [table_name]
           @cti_columns = {table_name=>columns}
           @cti_table_map = opts[:table_map] || {}
-          dataset.row_proc = if key
-            lambda{|r| (m.call(r[key]) rescue model).call(r)}
-          else
-            model
-          end
+          @cti_model_map = opts[:model_map]
+          set_dataset_cti_row_proc
         end
       end
 
@@ -120,6 +123,11 @@ module Sequel
         # load method.
         attr_reader :cti_key
         
+        # A hash with keys being values of the cti_key column, and values
+        # being class name strings or symbols.  Used if you don't want to
+        # store class names in the database.
+        attr_reader :cti_model_map
+        
         # An array of table symbols that back this model.  The first is
         # cti_base_model table symbol, and the last is the current model
         # table symbol.
@@ -139,6 +147,7 @@ module Sequel
           ct = cti_tables.dup
           ctm = cti_table_map.dup
           cbm = cti_base_model
+          cmm = cti_model_map
           pk = primary_key
           ds = dataset
           subclass.instance_eval do
@@ -150,6 +159,7 @@ module Sequel
             @cti_columns = cc.merge(table=>columns)
             @cti_table_map = ctm
             @cti_base_model = cbm
+            @cti_model_map = cmm
             # Need to set dataset and columns before calling super so that
             # the main column accessor module is included in the class before any
             # plugin accessor modules (such as the lazy attributes accessor module).
@@ -158,12 +168,7 @@ module Sequel
           end
           super
           subclass.instance_eval do
-            m = method(:constantize)
-            dataset.row_proc = if cti_key
-              lambda{|r| (m.call(r[ck]) rescue subclass).call(r)}
-            else
-              subclass
-            end
+            set_dataset_cti_row_proc
             (columns - [cbm.primary_key]).each{|a| define_lazy_attribute_getter(a)}
             cti_tables.reverse.each do |table|
               db.schema(table).each{|k,v| db_schema[k] = v}
@@ -192,12 +197,35 @@ module Sequel
           ds.row_proc = @dataset.row_proc if @dataset
         end
 
+        # Set the row_proc for the model's dataset appropriately
+        # based on the cti key and model map.
+        def set_dataset_cti_row_proc
+          m = method(:constantize)
+          dataset.row_proc = if ck = cti_key
+            if model_map = cti_model_map
+              lambda do |r|
+                mod = if name = model_map[r[ck]]
+                  m.call(name)
+                else
+                  self
+                end
+                mod.call(r)
+              end
+            else
+              lambda{|r| (m.call(r[ck]) rescue self).call(r)}
+            end
+          else
+            self
+          end
+        end
       end
 
       module InstanceMethods
         # Set the cti_key column to the name of the model.
-        def before_create
-          send("#{model.cti_key}=", model.name.to_s) if model.cti_key
+        def before_validation
+          if new? && model.cti_key && !model.cti_model_map
+            send("#{model.cti_key}=", model.name.to_s)
+          end
           super
         end
         

data/lib/sequel/plugins/many_through_many.rb

@@ -9,14 +9,13 @@ module Sequel
     # The many_through_many plugin would allow this:
     #
     #    Artist.plugin :many_through_many
-    #    Artist.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]]
+    #    Artist.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums_tags, :album_id, :tag_id]]
     #
     # Which will give you the tags for all of the artist's albums.
     #
     # Let's break down the 2nd argument of the many_through_many call:
     #
     #   [[:albums_artists, :artist_id, :album_id],
-    #    [:albums, :id, :id],
     #    [:albums_tags, :album_id, :tag_id]]
     #
     # This argument is an array of arrays with three elements.  Each entry in the main array represents a JOIN in SQL:
@@ -29,12 +28,12 @@ module Sequel
     #
     #   FROM artists
     #   JOIN albums_artists ON (artists.id = albums_artists.artist_id)
-    #   JOIN albums ON (albums_artists.album_id = albums.id)
-    #   JOIN albums_tags ON (albums.id = albums_tag.album_id)
+    #   JOIN albums_tags ON (albums_artists.album_id = albums_tag.album_id)
     #   JOIN tags ON (albums_tags.tag_id = tags.id)
     #
     # The "artists.id" and "tags.id" criteria come from other association options (defaulting to the primary keys of the current and
-    # associated tables), but hopefully you can see how each argument in the array is used in the JOIN clauses.
+    # associated tables), but hopefully you can see how each argument in the array is used in the JOIN clauses. Note that you do
+    # not need to add an entry for the final table (tags in this example), as that comes from the associated class.
     #
     # Here are some more examples:
     #
@@ -42,20 +41,20 @@ module Sequel
     #   Artist.many_through_many :albums, [[:albums_artists, :artist_id, :album_id]]
     #
     #   # All artists that are associated to any album that this artist is associated to
-    #   Artist.many_through_many :artists, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_artists, :album_id, :artist_id]]
+    #   Artist.many_through_many :artists, [[:albums_artists, :artist_id, :album_id], [:albums_artists, :album_id, :artist_id]]
     #
     #   # All albums by artists that are associated to any album that this artist is associated to
-    #   Artist.many_through_many :artist_albums, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], \
-    #    [:albums_artists, :album_id, :artist_id], [:artists, :id, :id], [:albums_artists, :artist_id, :album_id]], \
+    #   Artist.many_through_many :artist_albums, [[:albums_artists, :artist_id, :album_id], \
+    #    [:albums_artists, :album_id, :artist_id], [:albums_artists, :artist_id, :album_id]], \
     #    :class=>:Album
     #
-    #   # All tracks on albums by this artist
-    #   Artist.many_through_many :tracks, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id]], \
+    #   # All tracks on albums by this artist (also could be a many_to_many)
+    #   Artist.many_through_many :tracks, [[:albums_artists, :artist_id, :album_id]], \
     #    :right_primary_key=>:album_id
     #
     # Often you don't want the current object to appear in the array of associated objects.  This is easiest to handle via an :after_load hook:
     # 
-    #   Artist.many_through_many :artists, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_artists, :album_id, :artist_id]],
+    #   Artist.many_through_many :artists, [[:albums_artists, :artist_id, :album_id], [:albums_artists, :album_id, :artist_id]],
     #     :after_load=>proc{|artist, associated_artists| associated_artists.delete(artist)}
     #
     # You can also handle it by adding a dataset block that excludes the current record (so it won't be retrieved at all), but

data/lib/sequel/plugins/serialization.rb

@@ -163,7 +163,10 @@ module Sequel
                 end
               end
               define_method("#{column}=") do |v| 
-                changed_columns << column unless changed_columns.include?(column)
+                if !changed_columns.include?(column) && (new? || send(column) != v)
+                  changed_columns << column
+                end
+
                 deserialized_values[column] = v
               end
             end

data/lib/sequel/plugins/sharding.rb

@@ -39,15 +39,6 @@ module Sequel
           super
         end
 
-        # REMOVE410
-        def eager_loading_dataset(opts, ds, select, associations, eager_options=OPTS)
-          ds = super(opts, ds, select, associations, eager_options)
-          if !ds.opts[:server] and s = eager_options[:self] and server = s.opts[:server]
-            ds = ds.server(server)
-          end
-          ds
-        end
-
         # Return a newly instantiated object that is tied to the given
         # shard s.  When the object is saved, a record will be inserted
         # on shard s.

data/lib/sequel/plugins/single_table_inheritance.rb

@@ -216,8 +216,10 @@ module Sequel
 
       module InstanceMethods
         # Set the sti_key column based on the sti_key_map.
-        def before_create
-          send("#{model.sti_key}=", model.sti_key_chooser.call(self)) unless self[model.sti_key]
+        def before_validation
+          if new? && !self[model.sti_key]
+            send("#{model.sti_key}=", model.sti_key_chooser.call(self))
+          end
           super
         end
       end

data/lib/sequel/plugins/timestamps.rb

@@ -58,8 +58,8 @@ module Sequel
 
       module InstanceMethods
         # Set the create timestamp when creating
-        def before_create
-          set_create_timestamp
+        def before_validation
+          set_create_timestamp if new?
           super
         end
         

data/lib/sequel/sql.rb

@@ -251,8 +251,9 @@ module Sequel
       # Create an SQL alias (+AliasedExpression+) of the receiving column or expression to the given alias.
       #
       #   Sequel.function(:func).as(:alias) # func() AS "alias"
-      def as(aliaz)
-        AliasedExpression.new(self, aliaz)
+      #   Sequel.function(:func).as(:alias, [:col_alias1, :col_alias2]) # func() AS "alias"("col_alias1", "col_alias2")
+      def as(aliaz, columns=nil)
+        AliasedExpression.new(self, aliaz, columns)
       end
     end
 
@@ -320,8 +321,9 @@ module Sequel
       # 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)
+      #   Sequel.as(:column, :alias, [:col_alias1, :col_alias2]) # "column" AS "alias"("col_alias1", "col_alias2")
+      def as(exp, aliaz, columns=nil)
+        SQL::AliasedExpression.new(exp, aliaz, columns)
       end
 
       # Order the given argument ascending.
@@ -391,7 +393,7 @@ module Sequel
       #   Sequel.char_length(:a) # char_length(a) -- Most databases
       #   Sequel.char_length(:a) # length(a) -- SQLite
       def char_length(arg)
-        SQL::EmulatedFunction.new(:char_length, arg)
+        SQL::Function.new!(:char_length, [arg], :emulate=>true)
       end
 
       # Do a deep qualification of the argument using the qualifier.  This recurses into
@@ -555,7 +557,7 @@ module Sequel
       # 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%'
+      #   Sequel.ilike(:a, 'A%') # "a" ILIKE 'A%' ESCAPE '\'
       def ilike(*args)
         SQL::StringExpression.like(*(args << {:case_insensitive=>true}))
       end
@@ -563,7 +565,7 @@ module Sequel
       # 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%'
+      #   Sequel.like(:a, 'A%') # "a" LIKE 'A%' ESCAPE '\'
       def like(*args)
         SQL::StringExpression.like(*args)
       end
@@ -648,7 +650,7 @@ module Sequel
       #   Sequel.trim(:a) # trim(a) -- Most databases
       #   Sequel.trim(:a) # ltrim(rtrim(a)) -- Microsoft SQL Server
       def trim(arg)
-        SQL::EmulatedFunction.new(:trim, arg)
+        SQL::Function.new!(:trim, [arg], :emulate=>true)
       end
 
       # Return a <tt>SQL::ValueList</tt> created from the given array.  Used if the array contains
@@ -887,7 +889,7 @@ module Sequel
       # Create a +BooleanExpression+ case insensitive pattern match of the receiver
       # with the given patterns.  See <tt>StringExpression.like</tt>.
       #
-      #   :a.ilike('A%') # "a" ILIKE 'A%'
+      #   :a.ilike('A%') # "a" ILIKE 'A%' ESCAPE '\'
       def ilike(*ces)
         StringExpression.like(self, *(ces << {:case_insensitive=>true}))
       end
@@ -895,7 +897,7 @@ module Sequel
       # Create a +BooleanExpression+ case sensitive (if the database supports it) pattern match of the receiver with
       # the given patterns.  See <tt>StringExpression.like</tt>.
       #
-      #   :a.like('A%') # "a" LIKE 'A%'
+      #   :a.like('A%') # "a" LIKE 'A%' ESCAPE '\'
       def like(*ces)
         StringExpression.like(self, *ces)
       end
@@ -940,9 +942,15 @@ module Sequel
       attr_reader :aliaz
       alias_method :alias, :aliaz
 
+      # The columns aliases to use, for when the aliased expression is
+      # a record or set of records (such as a dataset). 
+      attr_reader :columns
+
       # Create an object with the given expression and alias.
-      def initialize(expression, aliaz)
-        @expression, @aliaz = expression, aliaz
+      def initialize(expression, aliaz, columns=nil)
+        @expression = expression
+        @aliaz = aliaz
+        @columns = columns
       end
 
       to_s_method :aliased_expression_sql
@@ -1222,44 +1230,122 @@ module Sequel
       COMMA_ARRAY = [LiteralString.new(', ').freeze].freeze
 
       # The SQL function to call
-      attr_reader :f
+      attr_reader :name
+      alias f name
       
       # The array of arguments to pass to the function (may be blank)
       attr_reader :args
 
-      # Set the functions and args to the given arguments
-      def initialize(f, *args)
-        @f, @args = f, args
+      # Options for this function
+      attr_reader :opts
+
+      # Set the name and args for the function
+      def initialize(name, *args)
+        @name = name
+        @args = args
+        @opts = OPTS
+      end
+
+      def self.new!(name, args, opts)
+        f = new(name, *args)
+        f.instance_variable_set(:@opts, opts)
+        f
       end
 
       # If no arguments are given, return a new function with the wildcard prepended to the arguments.
       #
       #   Sequel.function(:count).*  # count(*)
-      #   Sequel.function(:count, 1).*  # count(*, 1)
       def *(ce=(arg=false;nil))
         if arg == false
-          Function.new(f, WILDCARD, *args)
+          raise Error, "Cannot apply * to functions with arguments" unless args.empty?
+          with_opts(:"*"=>true)
         else
           super(ce)
         end
       end
 
       # Return a new function with DISTINCT before the method arguments.
+      #
+      #   Sequel.function(:count, :col).distinct # count(DISTINCT col)
       def distinct
-        Function.new(f, PlaceholderLiteralString.new(DISTINCT + COMMA_ARRAY * (args.length-1), args))
+        with_opts(:distinct=>true)
+      end
+
+      # Return a new function with FILTER added to it, for filtered
+      # aggregate functions:
+      #
+      #   Sequel.function(:foo, :col).filter(:a=>1) # foo(col) FILTER (WHERE a = 1)
+      def filter(*args, &block)
+        args = args.first if args.length == 1
+        with_opts(:filter=>args, :filter_block=>block)
+      end
+
+      # Return a function which will use LATERAL when literalized:
+      #
+      #   Sequel.function(:foo, :col).lateral # LATERAL foo(col)
+      def lateral
+        with_opts(:lateral=>true)
+      end
+
+      # Return a new function with an OVER clause (making it a window function).
+      #
+      #   Sequel.function(:row_number).over(:partition=>:col) # row_number() OVER (PARTITION BY col)
+      def over(window=OPTS)
+        raise Error, "function already has a window applied to it" if opts[:over]
+        window = Window.new(window) unless window.is_a?(Window)
+        with_opts(:over=>window)
+      end
+
+      # Return a new function where the function name will be quoted if the database supports
+      # quoted functions:
+      #
+      #   Sequel.function(:foo).quoted # "foo"()
+      def quoted
+        with_opts(:quoted=>true)
+      end
+
+      # Return a new function where the function name will not be quoted even
+      # if the database supports quoted functions:
+      #
+      #   Sequel.expr(:foo).function.unquoted # foo()
+      def unquoted
+        with_opts(:quoted=>false)
+      end
+
+      # Return a new function that will use WITH ORDINALITY to also return
+      # a row number for every row the function returns:
+      #
+      #   Sequel.function(:foo).with_ordinality # foo() WITH ORDINALITY
+      def with_ordinality
+        with_opts(:with_ordinality=>true)
       end
 
-      # Create a WindowFunction using the receiver and the appropriate options for the window.
-      def over(opts=OPTS)
-        WindowFunction.new(self, Window.new(opts))
+      # Return a new function that uses WITHIN GROUP ordered by the given expression,
+      # useful for ordered-set and hypothetical-set aggregate functions:
+      #
+      #   Sequel.function(:rank, :a).within_group(:b, :c)
+      #   # rank(a) WITHIN GROUP (ORDER BY b, c)
+      def within_group(*expressions)
+        with_opts(:within_group=>expressions)
       end
 
       to_s_method :function_sql
+
+      private
+
+      # Return a new function call with the given opts merged into the current opts.
+      def with_opts(opts)
+        self.class.new!(name, args, @opts.merge(opts))
+      end
     end
 
-    # Represents an SQL function call that is translated/emulated
-    # on databases that lack support for such a function.
+    # REMOVE411
     class EmulatedFunction < Function
+      def self.new(name, *args)
+        Deprecation.deprecate("Sequel::SQL::EmulatedFunction", "Please use Sequel::SQL::Function.new!(name, args, :emulate=>true) to create an emulated SQL function")
+        Function.new!(name, args, :emulate=>true)
+      end
+
       to_s_method :emulated_function_sql
     end
     
@@ -1303,15 +1389,48 @@ module Sequel
       # The type of join to do
       attr_reader :join_type
 
-      # The actual table to join
-      attr_reader :table
-
-      # The table alias to use for the join, if any
-      attr_reader :table_alias
+      # The expression representing the table/set related to the JOIN.
+      # Is an AliasedExpression if the JOIN uses an alias.
+      attr_reader :table_expr
 
-      # Create an object with the given join_type, table, and table alias
+      # Create an object with the given join_type and table expression.
       def initialize(join_type, table, table_alias = nil)
-        @join_type, @table, @table_alias = join_type, table, table_alias
+        @join_type = join_type
+
+        @table_expr = if table.is_a?(AliasedExpression)
+          table
+        # REMOVE411
+        elsif table_alias
+          Deprecation.deprecate("The table_alias argument to Sequel::SQL::JoinClause#initialize", "Please use a Sequel::SQL::AliasedExpression as the table argument instead.")
+          AliasedExpression.new(table, table_alias)
+        else
+          table
+        end
+      end
+
+      # The table/set related to the JOIN, without any alias.
+      def table
+        if @table_expr.is_a?(AliasedExpression)
+          @table_expr.expression
+        else
+          @table_expr
+        end
+      end
+
+      # The table alias to use for the JOIN , or nil if the
+      # JOIN does not alias the table.
+      def table_alias
+        if @table_expr.is_a?(AliasedExpression)
+          @table_expr.alias
+        end
+      end
+
+      # The column aliases to use for the JOIN , or nil if the
+      # JOIN does not use a derived column list.
+      def column_aliases
+        if @table_expr.is_a?(AliasedExpression)
+          @table_expr.columns
+        end
       end
 
       to_s_method :join_clause_sql
@@ -1486,9 +1605,9 @@ module Sequel
       # if a case insensitive regular expression is used (//i), that particular
       # pattern which will always be case insensitive.
       #
-      #   StringExpression.like(:a, 'a%') # "a" LIKE 'a%'
-      #   StringExpression.like(:a, 'a%', :case_insensitive=>true) # "a" ILIKE 'a%'
-      #   StringExpression.like(:a, 'a%', /^a/i) # "a" LIKE 'a%' OR "a" ~* '^a' 
+      #   StringExpression.like(:a, 'a%') # "a" LIKE 'a%' ESCAPE '\'
+      #   StringExpression.like(:a, 'a%', :case_insensitive=>true) # "a" ILIKE 'a%' ESCAPE '\'
+      #   StringExpression.like(:a, 'a%', /^a/i) # "a" LIKE 'a%' ESCAPE '\' OR "a" ~* '^a'
       def self.like(l, *ces)
         l, lre, lci = like_element(l)
         lci = (ces.last.is_a?(Hash) ? ces.pop : {})[:case_insensitive] ? true : lci
@@ -1568,7 +1687,7 @@ module Sequel
     # If the block doesn't take an argument, the block is instance_execed in the context of
     # an instance of this class.
     #
-    # +VirtualRow+ uses +method_missing+ to return either an +Identifier+, +QualifiedIdentifier+, +Function+, or +WindowFunction+, 
+    # +VirtualRow+ uses +method_missing+ to return either an +Identifier+, +QualifiedIdentifier+, or +Function+
     # depending on how it is called.
     #
     # If a block is _not_ given, creates one of the following objects:
@@ -1579,16 +1698,15 @@ module Sequel
     #                          table being the part before __, and the column being the part after.
     # +Identifier+ :: Returned otherwise, using the method name.
     #
-    # If a block is given, it returns either a +Function+ or +WindowFunction+, depending on the first
-    # argument to the method.  Note that the block is currently not called by the code, though
+    # If a block is given, it returns a +Function+.  Note that the block is currently not called by the code, though
     # this may change in a future version.  If the first argument is:
     #
     # no arguments given :: creates a +Function+ with no arguments.
     # :* :: creates a +Function+ with a literal wildcard argument (*), mostly useful for COUNT.
     # :distinct :: creates a +Function+ that prepends DISTINCT to the rest of the arguments, mostly
     #              useful for aggregate functions.
-    # :over :: creates a +WindowFunction+.  If a second argument is provided, it should be a hash
-    #          of options which are passed to Window (with possible keys :window, :partition, :order, and :frame).  The
+    # :over :: creates a +Function+ with a window.  If a second argument is provided, it should be a hash
+    #          of options which are used to create the +Window+ (with possible keys :window, :partition, :order, and :frame).  The
     #          arguments to the function itself should be specified as <tt>:*=>true</tt> for a wildcard, or via
     #          the <tt>:args</tt> option.
     #
@@ -1657,7 +1775,7 @@ module Sequel
         Sequel::LiteralString.new(s)
       end
 
-      # Return an +Identifier+, +QualifiedIdentifier+, +Function+, or +WindowFunction+, depending
+      # Return an +Identifier+, +QualifiedIdentifier+, or +Function+, depending
       # on arguments and whether a block is provided.  Does not currently call the block.
       # See the class level documentation.
       def method_missing(m, *args, &block)
@@ -1690,9 +1808,7 @@ module Sequel
       Sequel::VIRTUAL_ROW = new
     end
 
-    # A +Window+ is part of a window function specifying the window over which the function operates.
-    # It is separated from the +WindowFunction+ class because it also can be used separately on
-    # some databases.
+    # A +Window+ is part of a window function specifying the window over which a window function operates.
     class Window < Expression
       # The options for this window.  Options currently supported:
       # :frame :: if specified, should be :all, :rows, or a String that is used literally. :all always operates over all rows in the
@@ -1711,7 +1827,7 @@ module Sequel
       to_s_method :window_sql, '@opts'
     end
 
-    # A +WindowFunction+ is a grouping of a +Function+ with a +Window+ over which it operates.
+    # REMOVE411
     class WindowFunction < GenericExpression
       # The function to use, should be an <tt>SQL::Function</tt>.
       attr_reader :function
@@ -1719,8 +1835,14 @@ module Sequel
       # The window to use, should be an <tt>SQL::Window</tt>.
       attr_reader :window
 
+      def self.new(function, window)
+        Deprecation.deprecate("Sequel::SQL::WindowFunction", "Please use Sequel::SQL::Function.new(name, *args).over(...) to create an SQL window function")
+        function.over(window)
+      end
+
       # Set the function and window.
       def initialize(function, window)
+        Deprecation.deprecate("Sequel::SQL::WindowFunction", "Please use Sequel::SQL::Function.new(name, *args).over(...) to create an SQL window function")
         @function, @window = function, window
       end