sequel 4.45.0 → 4.46.0

data/lib/sequel/database/transactions.rb

@@ -10,20 +10,29 @@ module Sequel
     # ---------------------
 
     SQL_BEGIN = 'BEGIN'.freeze
+    Sequel::Deprecation.deprecate_constant(self, :SQL_BEGIN)
     SQL_COMMIT = 'COMMIT'.freeze
+    Sequel::Deprecation.deprecate_constant(self, :SQL_COMMIT)
     SQL_RELEASE_SAVEPOINT = 'RELEASE SAVEPOINT autopoint_%d'.freeze
+    Sequel::Deprecation.deprecate_constant(self, :SQL_RELEASE_SAVEPOINT)
     SQL_ROLLBACK = 'ROLLBACK'.freeze
+    Sequel::Deprecation.deprecate_constant(self, :SQL_ROLLBACK)
     SQL_ROLLBACK_TO_SAVEPOINT = 'ROLLBACK TO SAVEPOINT autopoint_%d'.freeze
+    Sequel::Deprecation.deprecate_constant(self, :SQL_ROLLBACK_TO_SAVEPOINT)
     SQL_SAVEPOINT = 'SAVEPOINT autopoint_%d'.freeze
+    Sequel::Deprecation.deprecate_constant(self, :SQL_SAVEPOINT)
     
     TRANSACTION_BEGIN = 'Transaction.begin'.freeze
+    Sequel::Deprecation.deprecate_constant(self, :TRANSACTION_BEGIN)
     TRANSACTION_COMMIT = 'Transaction.commit'.freeze
+    Sequel::Deprecation.deprecate_constant(self, :TRANSACTION_COMMIT)
     TRANSACTION_ROLLBACK = 'Transaction.rollback'.freeze
+    Sequel::Deprecation.deprecate_constant(self, :TRANSACTION_ROLLBACK)
 
     TRANSACTION_ISOLATION_LEVELS = {:uncommitted=>'READ UNCOMMITTED'.freeze,
       :committed=>'READ COMMITTED'.freeze,
       :repeatable=>'REPEATABLE READ'.freeze,
-      :serializable=>'SERIALIZABLE'.freeze}
+      :serializable=>'SERIALIZABLE'.freeze}#.freeze # SEQUEL5
     
     # The default transaction isolation level for this database,
     # used for all future transactions.  For MSSQL, this should be set
@@ -122,7 +131,7 @@ module Sequel
     #               use a savepoint you must use this option.  If the surrounding transaction
     #               uses :auto_savepoint, you can set this to false to not use a savepoint.
     #               If the value given for this option is :only, it will only create a
-    #               savepoint if it is inside a transacation.
+    #               savepoint if it is inside a transaction.
     #
     # PostgreSQL specific options:
     #
@@ -217,9 +226,10 @@ module Sequel
       rescue Exception => e
         begin
           rollback_transaction(conn, opts)
-        rescue Exception
+        rescue Exception => e3
         end
         transaction_error(e, :conn=>conn, :rollback=>rollback)
+        raise e3 if e3
         ret
       ensure
         begin
@@ -292,7 +302,7 @@ module Sequel
 
     # SQL to start a new savepoint
     def begin_savepoint_sql(depth)
-      SQL_SAVEPOINT % depth
+      "SAVEPOINT autopoint_#{depth}"
     end
 
     # Start a new database connection on the given connection
@@ -316,7 +326,7 @@ module Sequel
     
     # SQL to BEGIN a transaction.
     def begin_transaction_sql
-      SQL_BEGIN
+      'BEGIN'
     end
 
     # Whether to commit the current transaction. Thread.current.status is
@@ -340,7 +350,7 @@ module Sequel
     
     # SQL to commit a savepoint
     def commit_savepoint_sql(depth)
-      SQL_RELEASE_SAVEPOINT % depth
+      "RELEASE SAVEPOINT autopoint_#{depth}"
     end
 
     # Commit the active transaction on the connection
@@ -355,7 +365,7 @@ module Sequel
 
     # SQL to COMMIT a transaction.
     def commit_transaction_sql
-      SQL_COMMIT
+      'COMMIT'
     end
     
     # Method called on the connection object to execute SQL on the database,
@@ -393,7 +403,7 @@ module Sequel
 
     # SQL to rollback to a savepoint
     def rollback_savepoint_sql(depth)
-      SQL_ROLLBACK_TO_SAVEPOINT % depth
+      "ROLLBACK TO SAVEPOINT autopoint_#{depth}"
     end
 
     # Rollback the active transaction on the connection
@@ -408,7 +418,7 @@ module Sequel
 
     # SQL to ROLLBACK a transaction.
     def rollback_transaction_sql
-      SQL_ROLLBACK
+      'ROLLBACK'
     end
     
     # Set the transaction isolation level on the given connection

data/lib/sequel/dataset/actions.rb

@@ -34,7 +34,7 @@ module Sequel
     #   DB[:table][:id=>1] # SELECT * FROM table WHERE (id = 1) LIMIT 1
     #   # => {:id=1}
     def [](*conditions)
-      raise(Error, ARRAY_ACCESS_ERROR_MSG) if (conditions.length == 1 and conditions.first.is_a?(Integer)) or conditions.length == 0
+      raise(Error, 'You cannot call Dataset#[] with an integer or with no arguments') if (conditions.length == 1 and conditions.first.is_a?(Integer)) or conditions.length == 0
       first(*conditions)
     end
 
@@ -104,7 +104,8 @@ module Sequel
     def count(arg=(no_arg=true), &block)
       if no_arg && !block
         cached_dataset(:_count_ds) do
-          aggregate_dataset.select{count{}.*.as(:count)}.single_value_ds
+          aggregate_dataset.select(Sequel.function(:count).*.as(:count)).single_value_ds
+          #aggregate_dataset.select(COUNT_SELECT).single_value_ds # SEQUEL5
         end.single_value!.to_i
       else
         if block
@@ -118,6 +119,9 @@ module Sequel
         _aggregate(:count, arg)
       end
     end
+    # SEQUEL5
+    #COUNT_SELECT = Sequel.function(:count).*.as(:count)
+    #private_constant :COUNT_SELECT
 
     # Deletes the records in the dataset.  The returned value should be 
     # number of records deleted, but that is adapter dependent.
@@ -158,8 +162,12 @@ module Sequel
     def empty?
       cached_dataset(:_empty_ds) do
         single_value_ds.unordered.select(Sequel::SQL::AliasedExpression.new(1, :one))
+        # single_value_ds.unordered.select(EMPTY_SELECT) # SEQUEL5
       end.single_value!.nil?
     end
+    # SEQUEL5
+    #EMPTY_SELECT = Sequel::SQL::AliasedExpression.new(1, :one)
+    #private_constant :EMPTY_SELECT
 
     # If a integer argument is given, it is interpreted as a limit, and then returns all 
     # matching records up to that limit.  If no argument is passed,
@@ -267,7 +275,7 @@ module Sequel
     def get(column=(no_arg=true; nil), &block)
       ds = naked
       if block
-        raise(Error, ARG_BLOCK_ERROR_MSG) unless no_arg
+        raise(Error, 'Must call Dataset#get with an argument or a block, not both') unless no_arg
         ds = ds.select(&block)
         column = ds.opts[:select]
         column = nil if column.is_a?(Array) && column.length < 2
@@ -334,7 +342,7 @@ module Sequel
       return @db.transaction{insert(columns, values)} if values.is_a?(Dataset)
 
       return if values.empty?
-      raise(Error, IMPORT_ERROR_MSG) if columns.empty?
+      raise(Error, 'Using Sequel::Dataset#import with an empty column array is not allowed') if columns.empty?
       ds = opts[:server] ? server(opts[:server]) : self
       
       if slice_size = opts.fetch(:commit_every, opts.fetch(:slice, default_import_slice))
@@ -444,7 +452,7 @@ module Sequel
     #   # => [[1, 'A'], [2, 'B'], [3, 'C'], ...]
     def map(column=nil, &block)
       if column
-        raise(Error, ARG_BLOCK_ERROR_MSG) if block
+        raise(Error, 'Must call Dataset#map with either an argument or a block, not both') if block
         return naked.map(column) if row_proc
         if column.is_a?(Array)
           super(){|r| r.values_at(*column)}
@@ -972,7 +980,8 @@ module Sequel
   
     # Returns an array of the first value in each row.
     def _select_map_single
-      map{|r| r.values.first}
+      k = nil
+      map{|r| r[k||=r.keys.first]}
     end
   
     # A dataset for returning single values from the current dataset.

data/lib/sequel/dataset/graph.rb

@@ -16,11 +16,16 @@ module Sequel
     #   DB[:table].add_graph_aliases(:some_alias=>[:table, :column])
     #   # SELECT ..., table.column AS some_alias
     def add_graph_aliases(graph_aliases)
-      unless (ga = opts[:graph_aliases]) || (opts[:graph] && (ga = opts[:graph][:column_aliases]))
+      graph = opts[:graph]
+      unless (ga = opts[:graph_aliases]) || (graph && (ga = graph[:column_aliases])) # SEQUEL5: Remove graph_aliases support
         raise Error, "cannot call add_graph_aliases on a dataset that has not been called with graph or set_graph_aliases"
       end
       columns, graph_aliases = graph_alias_columns(graph_aliases)
-      select_append(*columns).clone(:graph_aliases => Hash[ga].merge!(graph_aliases).freeze)
+      if opts[:graph_aliases]
+        select_append(*columns).clone(:graph_aliases => Hash[ga].merge!(graph_aliases).freeze) # SEQUEL5: Remove
+      else
+        select_append(*columns).clone(:graph => Hash[graph].merge!(:column_aliases=>Hash[ga].merge!(graph_aliases).freeze).freeze)
+      end
     end
 
     # Similar to Dataset#join_table, but uses unambiguous aliases for selected
@@ -114,7 +119,7 @@ module Sequel
       # Whether to include the table in the result set
       add_table = options[:select] == false ? false : true
       # Whether to add the columns to the list of column aliases
-      add_columns = !ds.opts.include?(:graph_aliases)
+      add_columns = !ds.opts.include?(:graph_aliases) # SEQUEL5: Remove graph_aliases support
 
       if graph = opts[:graph]
         graph = graph.dup
@@ -230,13 +235,18 @@ module Sequel
     #   # SELECT artists.name, albums.name AS album_name, 42 AS forty_two ...
     def set_graph_aliases(graph_aliases)
       columns, graph_aliases = graph_alias_columns(graph_aliases)
-      select(*columns).clone(:graph_aliases=>graph_aliases.freeze)
+      if graph = opts[:graph]
+        select(*columns).clone(:graph => Hash[graph].merge!(:column_aliases=>graph_aliases.freeze).freeze)
+      else
+        Sequel::Deprecation.deprecate("Calling Dataset#set_graph_aliases before Dataset#graph", "Call Dataset#set_graph_aliases after Dataset#graph now")
+        select(*columns).clone(:graph_aliases=>graph_aliases.freeze) # SEQUEL5: Remove
+      end
     end
 
     # Remove the splitting of results into subhashes, and all metadata
     # related to the current graph (if any).
     def ungraphed
-      clone(:graph=>nil, :graph_aliases=>nil)
+      clone(:graph=>nil, :graph_aliases=>nil) # SEQUEL5: Remove :graph_aliases
     end
 
     private

data/lib/sequel/dataset/misc.rb

@@ -8,9 +8,13 @@ module Sequel
     # ---------------------
     
     NOTIMPL_MSG = "This method must be overridden in Sequel adapters".freeze
+    Sequel::Deprecation.deprecate_constant(self, :NOTIMPL_MSG)
     ARRAY_ACCESS_ERROR_MSG = 'You cannot call Dataset#[] with an integer or with no arguments.'.freeze
+    Sequel::Deprecation.deprecate_constant(self, :ARRAY_ACCESS_ERROR_MSG)
     ARG_BLOCK_ERROR_MSG = 'Must use either an argument or a block, not both'.freeze
+    Sequel::Deprecation.deprecate_constant(self, :ARG_BLOCK_ERROR_MSG)
     IMPORT_ERROR_MSG = 'Using Sequel::Dataset#import an empty column array is not allowed'.freeze
+    Sequel::Deprecation.deprecate_constant(self, :IMPORT_ERROR_MSG)
     
     # The database related to this dataset.  This is the Database instance that
     # will execute all of this dataset's queries.
@@ -29,7 +33,7 @@ module Sequel
     # the Database#dataset method return an instance of that subclass.
     def initialize(db)
       @db = db
-      @opts = {}
+      @opts = {} # OPTS # SEQUEL5
       @cache = {}
     end
 
@@ -50,6 +54,10 @@ module Sequel
       self == o
     end
 
+    # SEQUEL5: Remove other dup methods
+    # def dup
+    #   self
+    # end
     if TRUE_FREEZE
       # Similar to #clone, but returns an unfrozen clone if the receiver is frozen.
       def dup
@@ -92,12 +100,12 @@ module Sequel
     else
       # :nocov:
       def freeze # :nodoc:
-        @opts.freeze
+        @opts.freeze # SEQUEL5: remove
         self
       end
 
       def frozen?  # :nodoc:
-        @opts.frozen?
+        @opts.frozen? # SEQUEL5: true
       end
       # :nocov:
     end
@@ -295,7 +303,7 @@ module Sequel
     def cached_dataset(key)
       unless ds = cache_get(key)
         ds = yield
-        cache_set(key, ds) if frozen?
+        cache_set(key, ds) if frozen? # SEQUEL5: Remove if frozen?
       end
 
       ds

data/lib/sequel/dataset/mutation.rb

@@ -9,6 +9,7 @@ module Sequel
     
     # All methods that should have a ! method added that modifies the receiver.
     MUTATION_METHODS = QUERY_METHODS - [:naked, :from_self]
+    Sequel::Deprecation.deprecate_constant(self, :MUTATION_METHODS)
     
     # Setup mutation (e.g. filter!) methods.  These operate the same as the
     # non-! methods, but replace the options of the current dataset with the
@@ -26,38 +27,38 @@ module Sequel
     end
     
     # Add the mutation methods via metaprogramming
-    def_mutation_method(*MUTATION_METHODS)
+    def_mutation_method(*(QUERY_METHODS - [:naked, :from_self]))
     
     # Like #extension, but modifies and returns the receiver instead of returning a modified clone.
     def extension!(*exts)
-      raise_if_frozen!("extension!")
+      raise_if_frozen!(%w"extension! extension")
       _extension!(exts)
     end
 
     # Avoid self-referential dataset by cloning.
     def from_self!(*args, &block)
-      raise_if_frozen!("from_self!")
+      raise_if_frozen!(%w"from_self! from_self")
       @opts = clone.from_self(*args, &block).opts
       self
     end
 
     # Remove the row_proc from the current dataset.
     def naked!
-      raise_if_frozen!("naked=")
+      raise_if_frozen!(%w"naked! naked")
       @opts[:row_proc] = nil
       self
     end
     
     # Set whether to quote identifiers for this dataset
     def quote_identifiers=(v)
-      raise_if_frozen!("quote_identifiers=")
+      raise_if_frozen!(%w"quote_identifiers= with_quote_identifiers")
       skip_symbol_cache!
       @opts[:quote_identifiers] = v
     end
 
     # Override the row_proc for this dataset
     def row_proc=(v)
-      raise_if_frozen!("row_proc=")
+      raise_if_frozen!(%w"row_proc= with_row_proc")
       @opts[:row_proc] = v
     end
     
@@ -67,7 +68,7 @@ module Sequel
     # to the receiver and merging the options of the resulting dataset into
     # the receiver's options.
     def mutation_method(meth, *args, &block)
-      raise_if_frozen!("#{meth}!")
+      raise_if_frozen!(["#{meth}!", meth])
       @opts = send(meth, *args, &block).opts
       @cache = {}
       self
@@ -78,7 +79,15 @@ module Sequel
       if frozen?
         raise RuntimeError, "can't modify frozen #{visible_class_name}"
       end
-      Sequel::Deprecation.deprecate("Dataset mutation is deprecated and will be removed in Sequel 5#{" (method called: #{meth})" if meth}")
+      case meth
+      when Array
+        meth = " (method called: #{meth.first}, non-mutating replacement: #{meth.last})"
+      when String
+        # :nocov:
+        meth = " (method called: #{meth})"
+        # :nocov:
+      end
+      Sequel::Deprecation.deprecate("Dataset mutation is deprecated and will be removed in Sequel 5#{meth}")
     end
 
     # Set the dataset to skip the symbol cache

data/lib/sequel/dataset/prepared_statements.rb

@@ -92,6 +92,7 @@ module Sequel
       Dataset.def_deprecated_opts_setter(self, :log_sql, :prepared_type, :prepared_args, :orig_dataset, :prepared_modify_values)
 
       PLACEHOLDER_RE = /\A\$(.*)\z/
+      Sequel::Deprecation.deprecate_constant(self, :PLACEHOLDER_RE)
       
       # Whether to log the full SQL query.  By default, just the prepared statement
       # name is generally logged on adapters that support native prepared statements.
@@ -166,7 +167,7 @@ module Sequel
       # prepared_args is present.  If so, they are considered placeholders,
       # and they are substituted using prepared_arg.
       def literal_symbol_append(sql, v)
-        if @opts[:bind_vars] and match = PLACEHOLDER_RE.match(v.to_s)
+        if @opts[:bind_vars] and match = /\A\$(.*)\z/.match(v.to_s)
           s = match[1].to_sym
           if prepared_arg?(s)
             literal_append(sql, prepared_arg(s))
@@ -212,7 +213,7 @@ module Sequel
         when :insert_pk
           fetch_rows(prepared_sql){|r| return r.values.first}
         when Array
-          case prepared_type.at(0)
+          case prepared_type[0]
           when :map, :to_hash, :to_hash_groups
             send(*prepared_type, &block) 
           end

data/lib/sequel/dataset/query.rb

@@ -12,13 +12,15 @@ module Sequel
     # in the extension).
     EXTENSIONS = {}
 
+    EMPTY_ARRAY = [].freeze
+
     # The dataset options that require the removal of cached columns
     # if changed.
     COLUMN_CHANGE_OPTS = [:select, :sql, :from, :join].freeze
 
     # Which options don't affect the SQL generation.  Used by simple_select_all?
     # to determine if this is a simple SELECT * FROM table.
-    NON_SQL_OPTIONS = [:server, :graph, :eager, :eager_graph, :graph_aliases, :row_proc, :quote_identifiers, :identifier_input_method, :identifier_output_method, :skip_symbol_cache, :model, :model_object, :association_reflection, :fetch, :numrows, :autoid].freeze
+    NON_SQL_OPTIONS = [:server, :graph, :eager, :eager_graph, :graph_aliases, :row_proc, :quote_identifiers, :identifier_input_method, :identifier_output_method, :skip_symbol_cache, :model, :model_object, :association_reflection, :fetch, :numrows, :autoid].freeze # SEQUEL5: Remove graph_aliases
     
     # These symbols have _join methods created (e.g. inner_join) that
     # call join_table with the symbol, passing along the arguments and
@@ -91,7 +93,7 @@ module Sequel
         unless opts.each_key{|o| break if COLUMN_CHANGE_OPTS.include?(o)}
           c.clear_columns_cache
         end
-        c.freeze if frozen?
+        c.freeze if frozen? # SEQUEL5: Remove if frozen?
         c
       end
     else
@@ -102,7 +104,7 @@ module Sequel
         unless opts.each_key{|o| break if COLUMN_CHANGE_OPTS.include?(o)}
           c.clear_columns_cache
         end
-        c.freeze if frozen?
+        c.freeze if frozen? # SEQUEL5: c.opts.freeze
         c
       end
       # :nocov:
@@ -172,7 +174,7 @@ module Sequel
     #   DB[:items].exclude(Sequel.~(:category=>nil) & {:category => 'software'})
     #   # SELECT * FROM items WHERE ((category IS NULL) OR (category != 'software'))
     def exclude(*cond, &block)
-      _filter_or_exclude(true, :where, *cond, &block)
+      add_filter(:where, cond, true, &block)
     end
 
     # Inverts the given conditions and adds them to the HAVING clause.
@@ -183,7 +185,7 @@ module Sequel
     # See documentation for exclude for how inversion is handled in regards
     # to SQL 3-valued boolean logic.
     def exclude_having(*cond, &block)
-      _filter_or_exclude(true, :having, *cond, &block)
+      add_filter(:having, cond, true, &block)
     end
 
     # Alias for exclude.
@@ -198,7 +200,7 @@ module Sequel
       def extension(*a)
         c = _clone(:freeze=>false)
         c.send(:_extension!, a)
-        c.freeze if frozen?
+        c.freeze if frozen? # SEQUEL5: Remove if frozen?
         c
       end
     else
@@ -258,7 +260,7 @@ module Sequel
         end
       end
       o = {:from=>source.empty? ? nil : source.freeze}
-      o[:with] = ((opts[:with] || []) + ctes).freeze if ctes
+      o[:with] = ((opts[:with] || EMPTY_ARRAY) + ctes).freeze if ctes
       o[:num_dataset_sources] = table_alias_num if table_alias_num > 0
       clone(o)
     end
@@ -413,7 +415,7 @@ module Sequel
     #   DB[:items].group(:sum).having(:sum=>10)
     #   # SELECT * FROM items GROUP BY sum HAVING (sum = 10)
     def having(*cond, &block)
-      _filter(:having, *cond, &block)
+      add_filter(:having, cond, &block)
     end
     
     # Adds an INTERSECT clause using a second dataset object.
@@ -542,8 +544,6 @@ module Sequel
       end
 
       table_alias = options[:table_alias]
-      last_alias = options[:implicit_qualifier]
-      qualify_type = options[:qualify]
 
       if table.is_a?(SQL::AliasedExpression)
         table_expr = if table_alias
@@ -573,7 +573,8 @@ module Sequel
         raise(Sequel::Error, "can't use a block if providing an array of symbols as expr") if block
         SQL::JoinUsingClause.new(expr, type, table_expr)
       else
-        last_alias ||= @opts[:last_joined_table] || first_source_alias
+        last_alias = options[:implicit_qualifier] || @opts[:last_joined_table] || first_source_alias
+        qualify_type = options[:qualify]
         if Sequel.condition_specifier?(expr)
           expr = expr.collect do |k, v|
             qualify_type = default_join_table_qualification if qualify_type.nil?
@@ -592,13 +593,13 @@ module Sequel
           expr = SQL::BooleanExpression.from_value_pairs(expr)
         end
         if block
-          expr2 = yield(table_name, last_alias, @opts[:join] || [])
+          expr2 = yield(table_name, last_alias, @opts[:join] || EMPTY_ARRAY)
           expr = expr ? SQL::BooleanExpression.new(:AND, expr, expr2) : expr2
         end
         SQL::JoinOnClause.new(expr, type, table_expr)
       end
 
-      opts = {:join => ((@opts[:join] || []) + [join]).freeze}
+      opts = {:join => ((@opts[:join] || EMPTY_ARRAY) + [join]).freeze}
       opts[:last_joined_table] = table_name unless options[:reset_implicit_qualifier] == false
       opts[:num_dataset_sources] = table_alias_num if table_alias_num
       clone(opts)
@@ -694,17 +695,17 @@ module Sequel
       clone(:offset => o)
     end
     
-    # Adds an alternate filter to an existing filter using OR. If no filter 
-    # exists an +Error+ is raised.
+    # Adds an alternate filter to an existing WHERE clause using OR.  If there 
+    # is no WHERE clause, then the default is WHERE true, and OR would be redundant,
+    # so return an unmodified clone of the dataset in that case.
     #
     #   DB[:items].where(:a).or(:b) # SELECT * FROM items WHERE a OR b
+    #   DB[:items].or(:b) # SELECT * FROM items
     def or(*cond, &block)
-      cond = cond.first if cond.size == 1
-      v = @opts[:where]
-      if v.nil? || (cond.respond_to?(:empty?) && cond.empty? && !block)
+      if @opts[:where].nil?
         clone
       else
-        clone(:where => SQL::BooleanExpression.new(:OR, v, filter_expr(cond, &block)))
+        add_filter(:where, cond, false, :OR, &block)
       end
     end
 
@@ -766,7 +767,7 @@ module Sequel
     #   # SELECT i.* FROM items WHERE (i.id = 1)
     def qualify(table=first_source)
       o = @opts
-      return clone if o[:sql]
+      return clone if o[:sql] # SEQUEL5: return self
       h = {}
       (o.keys & QUALIFY_KEYS).each do |k|
         h[k] = qualified_expression(o[k], table)
@@ -1030,7 +1031,7 @@ module Sequel
     #
     # See the {"Dataset Filtering" guide}[rdoc-ref:doc/dataset_filtering.rdoc] for more examples and details.
     def where(*cond, &block)
-      _filter(:where, *cond, &block)
+      add_filter(:where, cond, &block)
     end
     
     # Add a common table expression (CTE) with the given name and a dataset that defines the CTE.
@@ -1047,7 +1048,7 @@ module Sequel
         s, ds = hoist_cte(dataset)
         s.with(name, ds, opts)
       else
-        clone(:with=>((@opts[:with]||[]) + [Hash[opts].merge!(:name=>name, :dataset=>dataset)]).freeze)
+        clone(:with=>((@opts[:with]||EMPTY_ARRAY) + [Hash[opts].merge!(:name=>name, :dataset=>dataset)]).freeze)
       end
     end
 
@@ -1076,7 +1077,7 @@ module Sequel
         s, ds = hoist_cte(recursive)
         s.with_recursive(name, nonrecursive, ds, opts)
       else
-        clone(:with=>((@opts[:with]||[]) + [Hash[opts].merge!(:recursive=>true, :name=>name, :dataset=>nonrecursive.union(recursive, {:all=>opts[:union_all] != false, :from_self=>false}))]).freeze)
+        clone(:with=>((@opts[:with]||EMPTY_ARRAY) + [Hash[opts].merge!(:recursive=>true, :name=>name, :dataset=>nonrecursive.union(recursive, {:all=>opts[:union_all] != false, :from_self=>false}))]).freeze)
       end
     end
     
@@ -1090,7 +1091,7 @@ module Sequel
         c = _clone(:freeze=>false)
         c.extend(*mods) unless mods.empty?
         c.extend(Module.new(&block)) if block
-        c.freeze if frozen?
+        c.freeze if frozen? # SEQUEL5: Remove if frozen?
         c
       end
     else
@@ -1171,14 +1172,21 @@ module Sequel
       !(@opts.collect{|k,v| k unless v.nil?}.compact & opts).empty?
     end
 
+    # From types allowed to be considered a simple_select_all
+    SIMPLE_SELECT_ALL_ALLOWED_FROM = [Symbol, SQL::Identifier, SQL::QualifiedIdentifier].freeze
+
     # Whether this dataset is a simple select from an underlying table, such as:
     #
     #   SELECT * FROM table
     #   SELECT table.* FROM table
     def simple_select_all?
+      return false unless (f = @opts[:from]) && f.length == 1
       non_sql = non_sql_options
       o = @opts.reject{|k,v| v.nil? || non_sql.include?(k)}
-      if (f = o[:from]) && f.length == 1 && (f.first.is_a?(Symbol) || f.first.is_a?(SQL::AliasedExpression))
+      from = f.first
+      from = from.expression if from.is_a?(SQL::AliasedExpression)
+
+      if SIMPLE_SELECT_ALL_ALLOWED_FROM.any?{|x| from.is_a?(x)}
         case o.length
         when 1
           true
@@ -1207,24 +1215,54 @@ module Sequel
       self
     end
 
-    # Internal filtering method so it works on either the WHERE or HAVING clauses, with or
-    # without inversion.
-    def _filter_or_exclude(invert, clause, *cond, &block)
+    def add_filter(clause, cond, invert=false, combine=:AND, &block)
+      if cond == EMPTY_ARRAY && !block
+        Sequel::Deprecation.deprecate("Passing no arguments and no block to a filtering method", "Include at least one argument or a block when calling a filtering method")
+        #raise Error, "must provide an argument to a filtering method if not passing a block" # SEQUEL5
+      end
+      
       cond = cond.first if cond.size == 1
-      if cond.respond_to?(:empty?) && cond.empty? && !block
+
+      empty = cond == OPTS || cond == EMPTY_ARRAY
+      old_empty = cond.respond_to?(:empty?) && cond.empty?
+      if old_empty && !empty
+        Sequel::Deprecation.deprecate("Treating #{cond.inspect} as a empty filter expression", "Only {} and [] are considered empty expressions now")
+        empty = true
+      end
+
+      if empty && !block
         clone
       else
+        if cond == nil
+          if block
+            Sequel::Deprecation.deprecate("Ignoring explicit nil argument when passing a block to a filtering method", "Do not pass an explicit nil argument to the filtering method, only pass the block")
+          end
+          unless @opts[clause]
+            Sequel::Deprecation.deprecate("Ignoring explicit nil argument to a filtering method if dataset has no explicit filter", "Starting in Sequel 5, this will add a NULL condition")
+          end
+          #cond = Sequel::NULL # SEQUEL5
+        end
+        if empty && block
+          cond = nil
+        end
+
         cond = filter_expr(cond, &block)
         cond = SQL::BooleanExpression.invert(cond) if invert
-        cond = SQL::BooleanExpression.new(:AND, @opts[clause], cond) if @opts[clause]
+        cond = SQL::BooleanExpression.new(combine, @opts[clause], cond) if @opts[clause]
         clone(clause => cond)
       end
     end
 
-    # Internal filter method so it works on either the having or where clauses.
+    # :nocov:
+    def _filter_or_exclude(invert, clause, *cond, &block)
+      Sequel::Deprecation.deprecate("Sequel::Dataset#_filter/_filter_or_exclude (private methods)", "Switch to calling a public dataset filtering method directly")
+      add_filter(clause, cond, invert, &block)
+    end
+
     def _filter(clause, *cond, &block)
       _filter_or_exclude(false, clause, *cond, &block)
     end
+    # :nocov:
 
     # The default :qualify option to use for join tables if one is not specified.
     def default_join_table_qualification
@@ -1233,7 +1271,7 @@ module Sequel
     
     # SQL expression object based on the expr type.  See +where+.
     def filter_expr(expr = nil, &block)
-      expr = nil if expr == []
+      expr = nil if expr == EMPTY_ARRAY
 
       if block
         if expr
@@ -1247,10 +1285,13 @@ module Sequel
       when Hash
         SQL::BooleanExpression.from_value_pairs(expr)
       when Array
-        if (sexpr = expr.at(0)).is_a?(String)
-          SQL::PlaceholderLiteralString.new(sexpr, expr[1..-1], true)
-        elsif Sequel.condition_specifier?(expr)
+        if Sequel.condition_specifier?(expr)
           SQL::BooleanExpression.from_value_pairs(expr)
+        #else # SEQUEL5
+        #  raise(Error, "Invalid filter expression: #{expr.inspect}") 
+        elsif (sexpr = expr[0]).is_a?(String)
+          Sequel::Deprecation.deprecate("Calling a dataset filtering method with multiple arguments or an array where the first argument/element is a string", "Use Sequel.lit(#{sexpr.inspect}#{", #{expr[1..-1].map(&:inspect).join(', ')}" if expr.length > 1}) to create an SQL fragment expression and pass that to the dataset filtering method, or use the auto_literal_strings extension")
+          SQL::PlaceholderLiteralString.new(sexpr, expr[1..-1], true)
         else
           Sequel::Deprecation.deprecate("Passing multiple arguments as filter arguments when not using a conditions specifier (#{expr.inspect})", "Pass the arguments to separate filter methods or use Sequel.& to combine them")
           SQL::BooleanExpression.new(:AND, *expr.map{|x| filter_expr(x)})
@@ -1258,7 +1299,9 @@ module Sequel
       when Proc
         Sequel::Deprecation.deprecate("Passing Proc objects as filter arguments", "Pass them as blocks to the filtering methods or to Sequel.expr")
         filter_expr(Sequel.virtual_row(&expr))
-      when Numeric, SQL::NumericExpression, SQL::StringExpression #, Proc # SEQUEL5
+      when LiteralString
+        LiteralString.new("(#{expr})")
+      when Numeric, SQL::NumericExpression, SQL::StringExpression #, Proc, String # SEQUEL5
         raise(Error, "Invalid filter expression: #{expr.inspect}") 
       when TrueClass, FalseClass
         if supports_where_true?
@@ -1269,9 +1312,12 @@ module Sequel
           SQL::Constants::SQLFALSE
         end
       when String
+        Sequel::Deprecation.deprecate("Calling a dataset filtering method with a plain string", "Use Sequel.lit(#{expr.inspect}) to create a literal string and pass that to the dataset filtering method, or use the auto_literal_strings extension")
         LiteralString.new("(#{expr})")
       when PlaceholderLiteralizer::Argument
         expr.transform{|v| filter_expr(v)}
+      when SQL::PlaceholderLiteralString
+        expr.with_parens
       else
         expr
       end
@@ -1281,7 +1327,7 @@ module Sequel
     # clause from the given dataset added to it, and the second a clone of
     # the given dataset with the WITH clause removed.
     def hoist_cte(ds)
-      [clone(:with => ((opts[:with] || []) + ds.opts[:with]).freeze), ds.clone(:with => nil)]
+      [clone(:with => ((opts[:with] || EMPTY_ARRAY) + ds.opts[:with]).freeze), ds.clone(:with => nil)]
     end
 
     # Whether CTEs need to be hoisted from the given ds into the current ds.
@@ -1295,7 +1341,7 @@ module Sequel
     #   DB[:items].invert_order([Sequel.desc(:id)]]) #=> [Sequel.asc(:id)]
     #   DB[:items].invert_order([:category, Sequel.desc(:price)]) #=> [Sequel.desc(:category), Sequel.asc(:price)]
     def invert_order(order)
-      return nil unless order
+      return unless order
       order.map do |f|
         case f
         when SQL::OrderedExpression