sequel 4.10.0 → 4.11.0

data/lib/sequel/adapters/shared/sqlanywhere.rb

@@ -235,6 +235,11 @@ module Sequel
           select_map(:a__name).
           map{|n| m.call(n)}
       end
+      
+      # SQLAnywhere supports views with check option, but not local.
+      def view_with_check_option_support
+        true
+      end
     end
 
     module DatasetMethods

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

@@ -613,6 +613,11 @@ module Sequel
         db.sqlite_version >= 30803
       end
 
+      # SQLite does not support table aliases with column aliases
+      def supports_derived_column_lists?
+        false
+      end
+
       # SQLite does not support INTERSECT ALL or EXCEPT ALL
       def supports_intersect_except_all?
         false
@@ -643,7 +648,8 @@ module Sequel
       private
       
       # SQLite uses string literals instead of identifiers in AS clauses.
-      def as_sql_append(sql, aliaz)
+      def as_sql_append(sql, aliaz, column_aliases=nil)
+        raise Error, "sqlite does not support derived column lists" if column_aliases
         aliaz = aliaz.value if aliaz.is_a?(SQL::Identifier)
         sql << AS
         literal_append(sql, aliaz.to_s)
@@ -666,6 +672,11 @@ module Sequel
         end
       end
 
+      # SQLite supports a maximum of 500 rows in a VALUES clause.
+      def default_import_slice
+        500
+      end
+
       # SQL fragment specifying a list of identifiers
       def identifier_list(columns)
         columns.map{|i| quote_identifier(i)}.join(COMMA)

data/lib/sequel/ast_transformer.rb

@@ -33,7 +33,7 @@ module Sequel
       when SQL::OrderedExpression
         SQL::OrderedExpression.new(v(o.expression), o.descending, :nulls=>o.nulls)
       when SQL::AliasedExpression
-        SQL::AliasedExpression.new(v(o.expression), o.alias)
+        SQL::AliasedExpression.new(v(o.expression), o.alias, o.columns)
       when SQL::CaseExpression
         args = [v(o.conditions), v(o.default)]
         args << v(o.expression) if o.expression?
@@ -41,11 +41,13 @@ module Sequel
       when SQL::Cast
         SQL::Cast.new(v(o.expr), o.type)
       when SQL::Function
-        SQL::Function.new(o.f, *v(o.args))
+        h = {}
+        o.opts.each do |k, val|
+          h[k] = v(val)
+        end
+        SQL::Function.new!(o.name, v(o.args), h)
       when SQL::Subscript
         SQL::Subscript.new(v(o.f), v(o.sub))
-      when SQL::WindowFunction
-        SQL::WindowFunction.new(v(o.function), v(o.window))
       when SQL::Window
         opts = o.opts.dup
         opts[:partition] = v(opts[:partition]) if opts[:partition]
@@ -61,11 +63,11 @@ module Sequel
         end
         SQL::PlaceholderLiteralString.new(o.str, args, o.parens)
       when SQL::JoinOnClause
-        SQL::JoinOnClause.new(v(o.on), o.join_type, v(o.table), v(o.table_alias))
+        SQL::JoinOnClause.new(v(o.on), o.join_type, v(o.table_expr))
       when SQL::JoinUsingClause
-        SQL::JoinUsingClause.new(v(o.using), o.join_type, v(o.table), v(o.table_alias))
+        SQL::JoinUsingClause.new(v(o.using), o.join_type, v(o.table_expr))
       when SQL::JoinClause
-        SQL::JoinClause.new(o.join_type, v(o.table), v(o.table_alias))
+        SQL::JoinClause.new(o.join_type, v(o.table_expr))
       when SQL::DelayedEvaluation
         SQL::DelayedEvaluation.new(lambda{v(o.callable.call)})
       when SQL::Wrapper

data/lib/sequel/connection_pool.rb

@@ -69,9 +69,9 @@ class Sequel::ConnectionPool
   # with a single symbol (specifying the server/shard to use) every time a new
   # connection is needed.  The following options are respected for all connection
   # pools:
-  # :after_connect :: The proc called after each new connection is made, with the
-  #                   connection object, useful for customizations that you want to apply to all
-  #                   connections.
+  # :after_connect :: A callable object called after each new connection is made, with the
+  #                   connection object (and server argument if the callable accepts 2 arguments),
+  #                   useful for customizations that you want to apply to all connections.
   def initialize(db, opts=OPTS)
     @db = db
     @after_connect = opts[:after_connect]
@@ -94,7 +94,13 @@ class Sequel::ConnectionPool
   def make_new(server)
     begin
       conn = @db.connect(server)
-      @after_connect.call(conn) if @after_connect
+      if ac = @after_connect
+        if ac.arity == 2
+          ac.call(conn, server)
+        else
+          ac.call(conn)
+        end
+      end
     rescue Exception=>exception
       raise Sequel.convert_exception_class(exception, Sequel::DatabaseConnectionError)
     end

data/lib/sequel/database/features.rb

@@ -94,6 +94,16 @@ module Sequel
       false
     end
 
+    # Whether CREATE VIEW ... WITH CHECK OPTION is supported, false by default.
+    def supports_views_with_check_option?
+      !!view_with_check_option_support
+    end
+
+    # Whether CREATE VIEW ... WITH LOCAL CHECK OPTION is supported, false by default.
+    def supports_views_with_local_check_option?
+      view_with_check_option_support == :local
+    end
+
     private
 
     # Whether the database supports combining multiple alter table
@@ -115,5 +125,10 @@ module Sequel
     def supports_named_column_constraints?
       true
     end
+
+    # Don't advertise support for WITH CHECK OPTION by default.
+    def view_with_check_option_support
+      nil
+    end
   end
 end

data/lib/sequel/database/schema_generator.rb

@@ -322,9 +322,9 @@ module Sequel
       # See CreateTableGenerator#constraint.
       #
       #   add_constraint(:valid_name, Sequel.like(:name, 'A%'))
-      #   # ADD CONSTRAINT valid_name CHECK (name LIKE 'A%')
+      #   # ADD CONSTRAINT valid_name CHECK (name LIKE 'A%' ESCAPE '\')
       #   add_constraint({:name=>:valid_name, :deferrable=>true}, :num=>1..5)
-      #   # CONSTRAINT valid_name CHECK (name LIKE 'A%') DEFERRABLE INITIALLY DEFERRED
+      #   # ADD CONSTRAINT valid_name CHECK (name LIKE 'A%' ESCAPE '\') DEFERRABLE INITIALLY DEFERRED
       def add_constraint(name, *args, &block)
         opts = name.is_a?(Hash) ? name : {:name=>name}
         @operations << opts.merge(:op=>:add_constraint, :type=>:check, :check=>block || args)

data/lib/sequel/database/schema_methods.rb

@@ -241,16 +241,30 @@ module Sequel
     # Creates a view based on a dataset or an SQL string:
     #
     #   DB.create_view(:cheap_items, "SELECT * FROM items WHERE price < 100")
-    #   DB.create_view(:ruby_items, DB[:items].filter(:category => 'ruby'))
+    #   # CREATE VIEW cheap_items AS
+    #   # SELECT * FROM items WHERE price < 100
+    #
+    #   DB.create_view(:ruby_items, DB[:items].where(:category => 'ruby'))
+    #   # CREATE VIEW ruby_items AS
+    #   # SELECT * FROM items WHERE (category = 'ruby')
+    #
+    #   DB.create_view(:checked_items, DB[:items].where(:foo), :check=>true)
+    #   # CREATE VIEW checked_items AS
+    #   # SELECT * FROM items WHERE foo
+    #   # WITH CHECK OPTION
     #
     # Options:
     # :columns :: The column names to use for the view.  If not given,
     #             automatically determined based on the input dataset.
+    # :check :: Adds a WITH CHECK OPTION clause, so that attempting to modify 
+    #           rows in the underlying table that would not be returned by the
+    #           view is not allowed.  This can be set to :local to use WITH
+    #           LOCAL CHECK OPTION.
     #
     # PostgreSQL/SQLite specific option:
     # :temp :: Create a temporary view, automatically dropped on disconnect.
     #
-    # PostgreSQL specific option:
+    # PostgreSQL specific options:
     # :materialized :: Creates a materialized view, similar to a regular view,
     #                  but backed by a physical table.
     # :recursive :: Creates a recursive view.  As columns must be specified for
@@ -683,7 +697,11 @@ module Sequel
     # DDL statement for creating a view.
     def create_view_sql(name, source, options)
       source = source.sql if source.is_a?(Dataset)
-      "#{create_view_prefix_sql(name, options)} AS #{source}"
+      sql = "#{create_view_prefix_sql(name, options)} AS #{source}"
+      if check = options[:check]
+        sql << " WITH#{' LOCAL' if check == :local} CHECK OPTION"
+      end
+      sql
     end
 
     # Append the column list to the SQL, if a column list is given.

data/lib/sequel/database/transactions.rb

@@ -198,7 +198,12 @@ module Sequel
     def already_in_transaction?(conn, opts)
       _trans(conn) && (!supports_savepoints? || !opts[:savepoint])
     end
-    
+
+    # Issue query to begin a new savepoint.
+    def begin_savepoint(conn, opts)
+      log_connection_execute(conn, begin_savepoint_sql(savepoint_level(conn)-1))
+    end
+
     # SQL to start a new savepoint
     def begin_savepoint_sql(depth)
       SQL_SAVEPOINT % depth
@@ -213,9 +218,8 @@ module Sequel
     # Start a new database transaction or a new savepoint on the given connection.
     def begin_transaction(conn, opts=OPTS)
       if supports_savepoints?
-        depth = savepoint_level(conn)
-        if depth > 1
-          log_connection_execute(conn, begin_savepoint_sql(depth-1))
+        if savepoint_level(conn) > 1
+          begin_savepoint(conn, opts)
         else
           begin_new_transaction(conn, opts)
         end

data/lib/sequel/dataset/actions.rb

@@ -279,7 +279,7 @@ module Sequel
       raise(Error, IMPORT_ERROR_MSG) if columns.empty?
       ds = opts[:server] ? server(opts[:server]) : self
       
-      if slice_size = opts[:commit_every] || opts[:slice]
+      if slice_size = opts.fetch(:commit_every, opts.fetch(:slice, default_import_slice))
         offset = 0
         rows = []
         while offset < values.length
@@ -572,13 +572,13 @@ module Sequel
     # Returns a hash with key_column values as keys and an array of value_column values.
     # Similar to to_hash_groups, but only selects the columns given.
     #
-    #   DB[:table].select_hash(:name, :id) # SELECT id, name FROM table
+    #   DB[:table].select_hash_groups(:name, :id) # SELECT id, name FROM table
     #   # => {'a'=>[1, 4, ...], 'b'=>[2, ...], ...}
     #
     # You can also provide an array of column names for either the key_column,
     # the value column, or both:
     #
-    #   DB[:table].select_hash([:first, :middle], [:last, :id]) # SELECT * FROM table
+    #   DB[:table].select_hash_groups([:first, :middle], [:last, :id]) # SELECT * FROM table
     #   # {['a', 'b']=>[['c', 1], ['d', 2], ...], ...}
     #
     # When using this method, you must be sure that each expression has an alias
@@ -708,19 +708,19 @@ module Sequel
     # array of column values. If the value_column is not given or nil, uses
     # the entire hash as the value.
     #
-    #   DB[:table].to_hash(:name, :id) # SELECT * FROM table
+    #   DB[:table].to_hash_groups(:name, :id) # SELECT * FROM table
     #   # {'Jim'=>[1, 4, 16, ...], 'Bob'=>[2], ...}
     #
-    #   DB[:table].to_hash(:name) # SELECT * FROM table
+    #   DB[:table].to_hash_groups(:name) # SELECT * FROM table
     #   # {'Jim'=>[{:id=>1, :name=>'Jim'}, {:id=>4, :name=>'Jim'}, ...], 'Bob'=>[{:id=>2, :name=>'Bob'}], ...}
     #
     # You can also provide an array of column names for either the key_column,
     # the value column, or both:
     #
-    #   DB[:table].to_hash([:first, :middle], [:last, :id]) # SELECT * FROM table
+    #   DB[:table].to_hash_groups([:first, :middle], [:last, :id]) # SELECT * FROM table
     #   # {['Jim', 'Bob']=>[['Smith', 1], ['Jackson', 4], ...], ...}
     #
-    #   DB[:table].to_hash([:first, :middle]) # SELECT * FROM table
+    #   DB[:table].to_hash_groups([:first, :middle]) # SELECT * FROM table
     #   # {['Jim', 'Bob']=>[{:id=>1, :first=>'Jim', :middle=>'Bob', :last=>'Smith'}, ...], ...}
     def to_hash_groups(key_column, value_column = nil)
       h = {}
@@ -889,6 +889,12 @@ module Sequel
       end
     end
 
+    # The default number of rows that can be inserted in a single INSERT statement via import.
+    # The default is for no limit.
+    def default_import_slice
+      nil
+    end
+
     # Set the server to use to :default unless it is already set in the passed opts
     def default_server_opts(opts)
       {:server=>@opts[:server] || :default}.merge(opts)

data/lib/sequel/dataset/features.rb

@@ -54,6 +54,13 @@ module Sequel
       false
     end
 
+    # Whether the database supports derived column lists (e.g.
+    # "table_expr AS table_alias(column_alias1, column_alias2, ...)"), true by
+    # default.
+    def supports_derived_column_lists?
+      true
+    end
+
     # Whether the dataset supports or can emulate the DISTINCT ON clause, false by default.
     def supports_distinct_on?
       false

data/lib/sequel/dataset/query.rb

@@ -213,10 +213,13 @@ module Sequel
     #
     #   ds.from_self(:alias=>:foo)
     #   # SELECT * FROM (SELECT id, name FROM items ORDER BY name) AS foo
+    #
+    #   ds.from_self(:alias=>:foo, :column_aliases=>[:c1, :c2])
+    #   # SELECT * FROM (SELECT id, name FROM items ORDER BY name) AS foo(c1, c2)
     def from_self(opts=OPTS)
       fs = {}
       @opts.keys.each{|k| fs[k] = nil unless NON_SQL_OPTIONS.include?(k)}
-      clone(fs).from(opts[:alias] ? as(opts[:alias]) : self)
+      clone(fs).from(opts[:alias] ? as(opts[:alias], opts[:column_aliases]) : self)
     end
 
     # Match any of the columns to any of the patterns. The terms can be
@@ -237,19 +240,23 @@ module Sequel
     # Examples:
     #
     #   dataset.grep(:a, '%test%')
-    #   # SELECT * FROM items WHERE (a LIKE '%test%')
+    #   # SELECT * FROM items WHERE (a LIKE '%test%' ESCAPE '\')
     #
     #   dataset.grep([:a, :b], %w'%test% foo')
-    #   # SELECT * FROM items WHERE ((a LIKE '%test%') OR (a LIKE 'foo') OR (b LIKE '%test%') OR (b LIKE 'foo'))
+    #   # SELECT * FROM items WHERE ((a LIKE '%test%' ESCAPE '\') OR (a LIKE 'foo' ESCAPE '\')
+    #   #   OR (b LIKE '%test%' ESCAPE '\') OR (b LIKE 'foo' ESCAPE '\'))
     #
     #   dataset.grep([:a, :b], %w'%foo% %bar%', :all_patterns=>true)
-    #   # SELECT * FROM a WHERE (((a LIKE '%foo%') OR (b LIKE '%foo%')) AND ((a LIKE '%bar%') OR (b LIKE '%bar%')))
+    #   # SELECT * FROM a WHERE (((a LIKE '%foo%' ESCAPE '\') OR (b LIKE '%foo%' ESCAPE '\'))
+    #   #   AND ((a LIKE '%bar%' ESCAPE '\') OR (b LIKE '%bar%' ESCAPE '\')))
     #
     #   dataset.grep([:a, :b], %w'%foo% %bar%', :all_columns=>true)
-    #   # SELECT * FROM a WHERE (((a LIKE '%foo%') OR (a LIKE '%bar%')) AND ((b LIKE '%foo%') OR (b LIKE '%bar%')))
+    #   # SELECT * FROM a WHERE (((a LIKE '%foo%' ESCAPE '\') OR (a LIKE '%bar%' ESCAPE '\'))
+    #   #   AND ((b LIKE '%foo%' ESCAPE '\') OR (b LIKE '%bar%' ESCAPE '\')))
     #
     #   dataset.grep([:a, :b], %w'%foo% %bar%', :all_patterns=>true, :all_columns=>true)
-    #   # SELECT * FROM a WHERE ((a LIKE '%foo%') AND (b LIKE '%foo%') AND (a LIKE '%bar%') AND (b LIKE '%bar%'))
+    #   # SELECT * FROM a WHERE ((a LIKE '%foo%' ESCAPE '\') AND (b LIKE '%foo%' ESCAPE '\')
+    #   #   AND (a LIKE '%bar%' ESCAPE '\') AND (b LIKE '%bar%' ESCAPE '\'))
     def grep(columns, patterns, opts=OPTS)
       if opts[:all_patterns]
         conds = Array(patterns).map do |pat|
@@ -445,23 +452,33 @@ module Sequel
       last_alias = options[:implicit_qualifier]
       qualify_type = options[:qualify]
 
-      if table.is_a?(Dataset)
+      if table.is_a?(SQL::AliasedExpression)
+        table_expr = if table_alias
+          SQL::AliasedExpression.new(table.expression, table_alias, table.columns)
+        else
+          table
+        end
+        table = table_expr.expression
+        table_name = table_alias = table_expr.alias
+      elsif table.is_a?(Dataset)
         if table_alias.nil?
           table_alias_num = (@opts[:num_dataset_sources] || 0) + 1
           table_alias = dataset_alias(table_alias_num)
         end
         table_name = table_alias
+        table_expr = SQL::AliasedExpression.new(table, table_alias)
       else
         table, implicit_table_alias = split_alias(table)
         table_alias ||= implicit_table_alias
         table_name = table_alias || table
+        table_expr = table_alias ? SQL::AliasedExpression.new(table, table_alias) : table
       end
 
       join = if expr.nil? and !block
-        SQL::JoinClause.new(type, table, table_alias)
+        SQL::JoinClause.new(type, table_expr)
       elsif using_join
         raise(Sequel::Error, "can't use a block if providing an array of symbols as expr") if block
-        SQL::JoinUsingClause.new(expr, type, table, table_alias)
+        SQL::JoinUsingClause.new(expr, type, table_expr)
       else
         last_alias ||= @opts[:last_joined_table] || first_source_alias
         if Sequel.condition_specifier?(expr)
@@ -485,7 +502,7 @@ module Sequel
           expr2 = yield(table_name, last_alias, @opts[:join] || [])
           expr = expr ? SQL::BooleanExpression.new(:AND, expr, expr2) : expr2
         end
-        SQL::JoinOnClause.new(expr, type, table, table_alias)
+        SQL::JoinOnClause.new(expr, type, table_expr)
       end
 
       opts = {:join => (@opts[:join] || []) + [join], :last_joined_table => table_name}
@@ -890,7 +907,7 @@ module Sequel
     # :recursive :: Specify that this is a recursive CTE
     #
     #   DB[:items].with(:items, DB[:syx].where(:name.like('A%')))
-    #   # WITH items AS (SELECT * FROM syx WHERE (name LIKE 'A%')) SELECT * FROM items
+    #   # WITH items AS (SELECT * FROM syx WHERE (name LIKE 'A%' ESCAPE '\')) SELECT * FROM items
     def with(name, dataset, opts=OPTS)
       raise(Error, 'This dataset does not support common table expressions') unless supports_cte?
       if hoist_cte?(dataset)

data/lib/sequel/dataset/sql.rb

@@ -5,7 +5,7 @@ module Sequel
     # These are methods you can call to see what SQL will be generated by the dataset.
     # ---------------------
     
-    # Returns an EXISTS clause for the dataset as a +LiteralString+.
+    # Returns an EXISTS clause for the dataset as an SQL::PlaceholderLiteralString.
     #
     #   DB.select(1).where(DB[:items].exists)
     #   # SELECT 1 WHERE (EXISTS (SELECT * FROM items))
@@ -274,6 +274,7 @@ module Sequel
     ESCAPE = " ESCAPE ".freeze
     EXTRACT = 'extract('.freeze
     EXISTS = ['EXISTS '.freeze].freeze
+    FILTER = " FILTER (WHERE ".freeze
     FOR_UPDATE = ' FOR UPDATE'.freeze
     FORMAT_DATE = "'%Y-%m-%d'".freeze
     FORMAT_DATE_STANDARD = "DATE '%Y-%m-%d'".freeze
@@ -284,7 +285,7 @@ module Sequel
     FRAME_ALL = "ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING".freeze
     FRAME_ROWS = "ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW".freeze
     FROM = ' FROM '.freeze
-    FUNCTION_EMPTY = '()'.freeze
+    FUNCTION_DISTINCT = "DISTINCT ".freeze
     GROUP_BY = " GROUP BY ".freeze
     HAVING = " HAVING ".freeze
     INSERT = "INSERT".freeze
@@ -332,6 +333,8 @@ module Sequel
     VALUES = " VALUES ".freeze
     V190 = '1.9.0'.freeze
     WHERE = " WHERE ".freeze
+    WITH_ORDINALITY = " WITH ORDINALITY".freeze
+    WITHIN_GROUP = " WITHIN GROUP (ORDER BY ".freeze
 
     [:literal, :quote_identifier, :quote_schema_table].each do |meth|
       class_eval(<<-END, __FILE__, __LINE__ + 1)
@@ -346,7 +349,7 @@ module Sequel
     # Append literalization of aliased expression to SQL string.
     def aliased_expression_sql_append(sql, ae)
       literal_append(sql, ae.expression)
-      as_sql_append(sql, ae.alias)
+      as_sql_append(sql, ae.alias, ae.columns)
     end
 
     # Append literalization of array to SQL string.
@@ -522,28 +525,87 @@ module Sequel
       end
     end
 
-    # Append literalization of emulated function call to SQL string.
-    # By default, assumes just the function name may need to
-    # be emulated, adapters should set an EMULATED_FUNCTION_MAP
-    # hash mapping emulated functions to native functions in
-    # their dataset class to setup the emulation.
+    # REMOVE411
     def emulated_function_sql_append(sql, f)
       _function_sql_append(sql, native_function_name(f.f), f.args)
     end
 
     # Append literalization of function call to SQL string.
     def function_sql_append(sql, f)
-      _function_sql_append(sql, f.f, f.args)
+      name = f.name
+      opts = f.opts
+
+      if opts[:emulate]
+        if emulate_function?(name)
+          emulate_function_sql_append(sql, f)
+          return
+        end
+
+        name = native_function_name(name) 
+      end
+
+      sql << LATERAL if opts[:lateral]
+
+      case name
+      when SQL::Identifier
+        if supports_quoted_function_names? && opts[:quoted] != false
+          literal_append(sql, name)
+        else
+          sql << name.value.to_s
+        end
+      when SQL::QualifiedIdentifier
+        if supports_quoted_function_names? && opts[:quoted] != false
+          literal_append(sql, name)
+        else
+          sql << split_qualifiers(name).join(DOT)
+        end
+      else
+        if supports_quoted_function_names? && opts[:quoted]
+          quote_identifier_append(sql, name)
+        else
+          sql << name.to_s
+        end
+      end
+
+      sql << PAREN_OPEN
+      if opts[:*]
+        sql << WILDCARD
+      else
+        sql << FUNCTION_DISTINCT if opts[:distinct]
+        expression_list_append(sql, f.args)
+      end
+      sql << PAREN_CLOSE
+
+      if group = opts[:within_group]
+        sql << WITHIN_GROUP
+        expression_list_append(sql, group)
+        sql << PAREN_CLOSE
+      end
+
+      if filter = opts[:filter]
+        sql << FILTER
+        literal_append(sql, filter_expr(filter, &opts[:filter_block]))
+        sql << PAREN_CLOSE
+      end
+
+      if window = opts[:over]
+        sql << OVER
+        window_sql_append(sql, window.opts)
+      end
+
+      if opts[:with_ordinality]
+        sql << WITH_ORDINALITY
+      end
     end
 
     # Append literalization of JOIN clause without ON or USING to SQL string.
     def join_clause_sql_append(sql, jc)
       table = jc.table
       table_alias = jc.table_alias
-      table_alias = nil if table == table_alias
+      table_alias = nil if table == table_alias && !jc.column_aliases
       sql << SPACE << join_type_sql(jc.join_type) << SPACE
       identifier_append(sql, table)
-      as_sql_append(sql, table_alias) if table_alias
+      as_sql_append(sql, table_alias, jc.column_aliases) if table_alias
     end
 
     # Append literalization of JOIN ON clause to SQL string.
@@ -765,8 +827,9 @@ module Sequel
       sql << PAREN_CLOSE
     end
 
-    # Append literalization of window function calls to SQL string.
+    # REMOVE411
     def window_function_sql_append(sql, function, window)
+      Deprecation.deprecate("Dataset#window_function_sql_append", "Please use Sequel::SQL::Function.new(name, *args).over(...) to create an SQL window function")
       literal_append(sql, function)
       sql << OVER
       literal_append(sql, window)
@@ -782,8 +845,9 @@ module Sequel
     
     private
 
-    # Backbone of function_sql_append and emulated_function_sql_append.
+    # REMOVE411
     def _function_sql_append(sql, name, args)
+      Deprecation.deprecate("Dataset#emulated_function_sql_append and #_function_sql_append", "Please use Sequel::SQL::Function.new!(name, args, :emulate=>true) to create an emulated SQL function")
       case name
       when SQL::Identifier
         if supports_quoted_function_names?
@@ -857,9 +921,15 @@ module Sequel
     end
 
     # Append aliasing expression to SQL string.
-    def as_sql_append(sql, aliaz)
+    def as_sql_append(sql, aliaz, column_aliases=nil)
       sql << AS
       quote_identifier_append(sql, aliaz)
+      if column_aliases
+        raise Error, "#{db.database_type} does not support derived column lists" unless supports_derived_column_lists?
+        sql << PAREN_OPEN
+        identifier_list_append(sql, column_aliases)
+        sql << PAREN_CLOSE
+      end
     end
     
     # Raise an InvalidOperation exception if deletion is not allowed
@@ -960,6 +1030,12 @@ module Sequel
       nil
     end
 
+    # Whether to emulate the function with the given name.  This should only be true
+    # if the emulation goes beyond choosing a function with a different name.
+    def emulate_function?(name)
+      false
+    end
+
     # Append literalization of array of expressions to SQL string.
     def expression_list_append(sql, columns)
       c = false