sequel 5.39.0 → 5.63.0

data/lib/sequel/dataset/query.rb

@@ -65,7 +65,7 @@ module Sequel
       Sequel.synchronize{EXTENSIONS[ext] = block}
     end
 
-    # On Ruby 2.4+, use clone(:freeze=>false) to create clones, because
+    # On Ruby 2.4+, use clone(freeze: false) to create clones, because
     # we use true freezing in that case, and we need to modify the opts
     # in the frozen copy.
     #
@@ -116,7 +116,7 @@ module Sequel
     #  DB[:items].order(:id).distinct(:id) # SQL: SELECT DISTINCT ON (id) * FROM items ORDER BY id
     #  DB[:items].order(:id).distinct{func(:id)} # SQL: SELECT DISTINCT ON (func(id)) * FROM items ORDER BY id
     #
-    # There is support for emualting the DISTINCT ON support in MySQL, but it
+    # There is support for emulating the DISTINCT ON support in MySQL, but it
     # does not support the ORDER of the dataset, and also doesn't work in many
     # cases if the ONLY_FULL_GROUP_BY sql_mode is used, which is the default on
     # MySQL 5.7.5+.
@@ -508,6 +508,7 @@ module Sequel
     #                            argument.
     #            :implicit_qualifier :: The name to use for qualifying implicit conditions.  By default,
     #                                   the last joined or primary table is used.
+    #            :join_using :: Force the using of JOIN USING, even if +expr+ is not an array of symbols.
     #            :reset_implicit_qualifier :: Can set to false to ignore this join when future joins determine qualifier
     #                                         for implicit conditions.
     #            :qualify :: Can be set to false to not do any implicit qualification.  Can be set
@@ -541,7 +542,7 @@ module Sequel
         return s.join_table(type, ds, expr, options, &block)
       end
 
-      using_join = expr.is_a?(Array) && !expr.empty? && expr.all?{|x| x.is_a?(Symbol)}
+      using_join = options[:join_using] || (expr.is_a?(Array) && !expr.empty? && expr.all?{|x| x.is_a?(Symbol)})
       if using_join && !supports_join_using?
         h = {}
         expr.each{|e| h[e] = e}
@@ -616,7 +617,7 @@ module Sequel
     UNCONDITIONED_JOIN_TYPES.each do |jtype|
       class_eval(<<-END, __FILE__, __LINE__+1)
         def #{jtype}_join(table, opts=Sequel::OPTS)
-          raise(Sequel::Error, '#{jtype}_join does not accept join table blocks') if block_given?
+          raise(Sequel::Error, '#{jtype}_join does not accept join table blocks') if defined?(yield)
           raise(Sequel::Error, '#{jtype}_join 2nd argument should be an options hash, not conditions') unless opts.is_a?(Hash)
           join_table(:#{jtype}, table, nil, opts)
         end
@@ -677,6 +678,56 @@ module Sequel
       clone(:lock => style)
     end
     
+    # Return a dataset with a WHEN MATCHED THEN DELETE clause added to the
+    # MERGE statement.  If a block is passed, treat it as a virtual row and
+    # use it as additional conditions for the match.
+    #
+    #   merge_delete
+    #   # WHEN MATCHED THEN DELETE
+    #
+    #   merge_delete{a > 30}
+    #   # WHEN MATCHED AND (a > 30) THEN DELETE
+    def merge_delete(&block)
+      _merge_when(:type=>:delete, &block)
+    end
+
+    # Return a dataset with a WHEN NOT MATCHED THEN INSERT clause added to the
+    # MERGE statement.  If a block is passed, treat it as a virtual row and
+    # use it as additional conditions for the match.
+    #
+    # The arguments provided can be any arguments that would be accepted by
+    # #insert.
+    #
+    #   merge_insert(i1: :i2, a: Sequel[:b]+11)
+    #   # WHEN NOT MATCHED THEN INSERT (i1, a) VALUES (i2, (b + 11))
+    #
+    #   merge_insert(:i2, Sequel[:b]+11){a > 30}
+    #   # WHEN NOT MATCHED AND (a > 30) THEN INSERT VALUES (i2, (b + 11))
+    def merge_insert(*values, &block)
+      _merge_when(:type=>:insert, :values=>values, &block)
+    end
+    
+    # Return a dataset with a WHEN MATCHED THEN UPDATE clause added to the
+    # MERGE statement.  If a block is passed, treat it as a virtual row and
+    # use it as additional conditions for the match.
+    #
+    #   merge_update(i1: Sequel[:i1]+:i2+10, a: Sequel[:a]+:b+20)
+    #   # WHEN MATCHED THEN UPDATE SET i1 = (i1 + i2 + 10), a = (a + b + 20)
+    #
+    #   merge_update(i1: :i2){a > 30}
+    #   # WHEN MATCHED AND (a > 30) THEN UPDATE SET i1 = i2
+    def merge_update(values, &block)
+      _merge_when(:type=>:update, :values=>values, &block)
+    end
+
+    # Return a dataset with the source and join condition to use for the MERGE statement.
+    #
+    #   merge_using(:m2, i1: :i2)
+    #   # USING m2 ON (i1 = i2)
+    def merge_using(source, join_condition)
+      clone(:merge_using => [source, join_condition].freeze)
+    end
+
     # Returns a cloned dataset without a row_proc.
     #
     #   ds = DB[:items].with_row_proc(:invert.to_proc)
@@ -699,7 +750,7 @@ module Sequel
     end
 
     # Returns a copy of the dataset with a specified order. Can be safely combined with limit.
-    # If you call limit with an offset, it will override override the offset if you've called
+    # If you call limit with an offset, it will override the offset if you've called
     # offset first.
     #
     #   DB[:items].offset(10) # SELECT * FROM items OFFSET 10
@@ -736,7 +787,7 @@ module Sequel
     #   DB[:items].order(Sequel.lit('a + b')) # SELECT * FROM items ORDER BY a + b
     #   DB[:items].order(Sequel[:a] + :b) # SELECT * FROM items ORDER BY (a + b)
     #   DB[:items].order(Sequel.desc(:name)) # SELECT * FROM items ORDER BY name DESC
-    #   DB[:items].order(Sequel.asc(:name, :nulls=>:last)) # SELECT * FROM items ORDER BY name ASC NULLS LAST
+    #   DB[:items].order(Sequel.asc(:name, nulls: :last)) # SELECT * FROM items ORDER BY name ASC NULLS LAST
     #   DB[:items].order{sum(name).desc} # SELECT * FROM items ORDER BY sum(name) DESC
     #   DB[:items].order(nil) # SELECT * FROM items
     def order(*columns, &block)
@@ -806,13 +857,13 @@ module Sequel
     #   DB[:items].returning(nil) # RETURNING NULL
     #   DB[:items].returning(:id, :name) # RETURNING id, name
     #
-    #   DB[:items].returning.insert(:a=>1) do |hash|
+    #   DB[:items].returning.insert(a: 1) do |hash|
     #     # hash for each row inserted, with values for all columns
     #   end
-    #   DB[:items].returning.update(:a=>1) do |hash|
+    #   DB[:items].returning.update(a: 1) do |hash|
     #     # hash for each row updated, with values for all columns
     #   end
-    #   DB[:items].returning.delete(:a=>1) do |hash|
+    #   DB[:items].returning.delete(a: 1) do |hash|
     #     # hash for each row deleted, with values for all columns
     #   end
     def returning(*values)
@@ -1051,7 +1102,7 @@ module Sequel
     # referenced in window functions. See Sequel::SQL::Window for a list of
     # options that can be passed in. Example:
     #
-    #   DB[:items].window(:w, :partition=>:c1, :order=>:c2)
+    #   DB[:items].window(:w, partition: :c1, order: :c2)
     #   # SELECT * FROM items WINDOW w AS (PARTITION BY c1 ORDER BY c2)
     def window(name, opts)
       clone(:window=>((@opts[:window]||EMPTY_ARRAY) + [[name, SQL::Window.new(opts)].freeze]).freeze)
@@ -1059,13 +1110,12 @@ module Sequel
 
     # Add a common table expression (CTE) with the given name and a dataset that defines the CTE.
     # A common table expression acts as an inline view for the query.
+    #
     # Options:
     # :args :: Specify the arguments/columns for the CTE, should be an array of symbols.
     # :recursive :: Specify that this is a recursive CTE
-    #
-    # PostgreSQL Specific Options:
     # :materialized :: Set to false to force inlining of the CTE, or true to force not inlining
-    #                  the CTE (PostgreSQL 12+).
+    #                  the CTE (PostgreSQL 12+/SQLite 3.35+).
     #
     #   DB[:items].with(:items, DB[:syx].where(Sequel[:name].like('A%')))
     #   # WITH items AS (SELECT * FROM syx WHERE (name LIKE 'A%' ESCAPE '\')) SELECT * FROM items
@@ -1081,20 +1131,60 @@ module Sequel
 
     # Add a recursive common table expression (CTE) with the given name, a dataset that
     # defines the nonrecursive part of the CTE, and a dataset that defines the recursive part
-    # of the CTE.  Options:
+    # of the CTE.
+    #
+    # Options:
     # :args :: Specify the arguments/columns for the CTE, should be an array of symbols.
     # :union_all :: Set to false to use UNION instead of UNION ALL combining the nonrecursive and recursive parts.
     #
+    # PostgreSQL 14+ Options:
+    # :cycle :: Stop recursive searching when a cycle is detected. Includes two columns in the
+    #           result of the CTE, a cycle column indicating whether a cycle was detected for
+    #           the current row, and a path column for the path traversed to get to the current
+    #           row.  If given, must be a hash with the following keys:
+    #           :columns :: (required) The column or array of columns to use to detect a cycle.
+    #                       If the value of these columns match columns already traversed, then
+    #                       a cycle is detected, and recursive searching will not traverse beyond
+    #                       the cycle (the CTE will include the row where the cycle was detected).
+    #           :cycle_column :: The name of the cycle column in the output, defaults to :is_cycle.
+    #           :cycle_value :: The value of the cycle column in the output if the current row was
+    #                           detected as a cycle, defaults to true.
+    #           :noncycle_value :: The value of the cycle column in the output if the current row
+    #                              was not detected as a cycle, defaults to false. Only respected
+    #                              if :cycle_value is given.
+    #           :path_column :: The name of the path column in the output, defaults to :path.
+    # :search :: Include an order column in the result of the CTE that allows for breadth or
+    #            depth first searching. If given, must be a hash with the following keys:
+    #            :by :: (required) The column or array of columns to search by.
+    #            :order_column :: The name of the order column in the output, defaults to :ordercol.
+    #            :type :: Set to :breadth to use breadth-first searching (depth-first searching
+    #                     is the default).
+    #
     #   DB[:t].with_recursive(:t,
     #     DB[:i1].select(:id, :parent_id).where(parent_id: nil),
     #     DB[:i1].join(:t, id: :parent_id).select(Sequel[:i1][:id], Sequel[:i1][:parent_id]),
-    #     :args=>[:id, :parent_id])
+    #     args: [:id, :parent_id])
     #   
     #   # WITH RECURSIVE t(id, parent_id) AS (
     #   #   SELECT id, parent_id FROM i1 WHERE (parent_id IS NULL)
     #   #   UNION ALL
     #   #   SELECT i1.id, i1.parent_id FROM i1 INNER JOIN t ON (t.id = i1.parent_id)
     #   # ) SELECT * FROM t
+    #
+    #   DB[:t].with_recursive(:t,
+    #     DB[:i1].where(parent_id: nil),
+    #     DB[:i1].join(:t, id: :parent_id).select_all(:i1),
+    #     search: {by: :id, type: :breadth},
+    #     cycle: {columns: :id, cycle_value: 1, noncycle_value: 2})
+    #     
+    #   # WITH RECURSIVE t AS (
+    #   #     SELECT * FROM i1 WHERE (parent_id IS NULL)
+    #   #     UNION ALL
+    #   #     (SELECT i1.* FROM i1 INNER JOIN t ON (t.id = i1.parent_id))
+    #   #   )
+    #   #   SEARCH BREADTH FIRST BY id SET ordercol
+    #   #   CYCLE id SET is_cycle TO 1 DEFAULT 2 USING path
+    #   # SELECT * FROM t
     def with_recursive(name, nonrecursive, recursive, opts=OPTS)
       raise(Error, 'This dataset does not support common table expressions') unless supports_cte?
       if hoist_cte?(nonrecursive)
@@ -1151,7 +1241,7 @@ module Sequel
     #
     # You can also provide a method name and arguments to call to get the SQL:
     #
-    #   DB[:items].with_sql(:insert_sql, :b=>1) # INSERT INTO items (b) VALUES (1)
+    #   DB[:items].with_sql(:insert_sql, b: 1) # INSERT INTO items (b) VALUES (1)
     #
     # Note that datasets that specify custom SQL using this method will generally
     # ignore future dataset methods that modify the SQL used, as specifying custom SQL
@@ -1247,6 +1337,18 @@ module Sequel
       end
     end
 
+    # Append to the current MERGE WHEN clauses.
+    # Mutates the hash to add the conditions, if a virtual row block is passed.
+    def _merge_when(hash, &block)
+      hash[:conditions] = Sequel.virtual_row(&block) if block
+
+      if merge_when = @opts[:merge_when]
+        clone(:merge_when => (merge_when.dup << hash.freeze).freeze)
+      else
+        clone(:merge_when => [hash.freeze].freeze)
+      end
+    end
+
     # Add the given filter condition. Arguments:
     # clause :: Symbol or which SQL clause to effect, should be :where or :having
     # cond :: The filter condition to add

data/lib/sequel/dataset/sql.rb

@@ -22,31 +22,9 @@ module Sequel
     def insert_sql(*values)
       return static_sql(@opts[:sql]) if @opts[:sql]
 
-      check_modification_allowed!
-
-      columns = []
-
-      case values.size
-      when 0
-        return insert_sql(OPTS)
-      when 1
-        case vals = values[0]
-        when Hash
-          values = []
-          vals.each do |k,v| 
-            columns << k
-            values << v
-          end
-        when Dataset, Array, LiteralString
-          values = vals
-        end
-      when 2
-        if (v0 = values[0]).is_a?(Array) && ((v1 = values[1]).is_a?(Array) || v1.is_a?(Dataset) || v1.is_a?(LiteralString))
-          columns, values = v0, v1
-          raise(Error, "Different number of values and columns given to insert_sql") if values.is_a?(Array) and columns.length != values.length
-        end
-      end
+      check_insert_allowed!
 
+      columns, values = _parse_insert_sql_args(values)
       if values.is_a?(Array) && values.empty? && !insert_supports_empty_values? 
         columns, values = insert_empty_columns_values
       elsif values.is_a?(Dataset) && hoist_cte?(values) && supports_cte?(:insert)
@@ -112,6 +90,31 @@ module Sequel
       end
     end
     
+    # The SQL to use for the MERGE statement.
+    def merge_sql
+      raise Error, "This database doesn't support MERGE" unless supports_merge?
+      if sql = opts[:sql]
+        return static_sql(sql)
+      end
+      if sql = cache_get(:_merge_sql)
+        return sql
+      end
+      source, join_condition = @opts[:merge_using]
+      raise Error, "No USING clause for MERGE" unless source
+      sql = @opts[:append_sql] || sql_string_origin
+
+      select_with_sql(sql)
+      sql << "MERGE INTO "
+      source_list_append(sql, @opts[:from])
+      sql << " USING "
+      identifier_append(sql, source)
+      sql << " ON "
+      literal_append(sql, join_condition)
+      _merge_when_sql(sql)
+      cache_set(:_merge_sql, sql) if cache_sql?
+      sql
+    end
+
     # Returns an array of insert statements for inserting multiple records.
     # This method is used by +multi_insert+ to format insert statements and
     # expects a keys array and and an array of value arrays.
@@ -172,7 +175,7 @@ module Sequel
     # than one table.
     def update_sql(values = OPTS)
       return static_sql(opts[:sql]) if opts[:sql]
-      check_modification_allowed!
+      check_update_allowed!
       check_not_limited!(:update)
 
       case values
@@ -215,7 +218,7 @@ module Sequel
       lines << "def #{'_' if priv}#{type}_sql"
       lines << 'if sql = opts[:sql]; return static_sql(sql) end' unless priv
       lines << "if sql = cache_get(:_#{type}_sql); return sql end" if cacheable
-      lines << 'check_modification_allowed!' << 'check_not_limited!(:delete)' if type == :delete
+      lines << 'check_delete_allowed!' << 'check_not_limited!(:delete)' if type == :delete
       lines << 'sql = @opts[:append_sql] || sql_string_origin'
 
       if clauses.all?{|c| c.is_a?(Array)}
@@ -559,11 +562,9 @@ module Sequel
     # Append literalization of JOIN USING clause to SQL string.
     def join_using_clause_sql_append(sql, jc)
       join_clause_sql_append(sql, jc)
-      sql << ' USING ('
-      column_list_append(sql, jc.using)
-      sql << ')'
+      join_using_clause_using_sql_append(sql, jc.using) 
     end
-    
+
     # Append literalization of negative boolean constant to SQL string.
     def negative_boolean_constant_sql_append(sql, constant)
       sql << 'NOT '
@@ -852,6 +853,83 @@ module Sequel
     
     private
 
+    # Append the INSERT sql used in a MERGE
+    def _merge_insert_sql(sql, data)
+      sql << " THEN INSERT"
+      columns, values = _parse_insert_sql_args(data[:values])
+      _insert_columns_sql(sql, columns)
+      _insert_values_sql(sql, values)
+    end
+
+    def _merge_update_sql(sql, data)
+      sql << " THEN UPDATE SET "
+      update_sql_values_hash(sql, data[:values])
+    end
+
+    def _merge_delete_sql(sql, data)
+      sql << " THEN DELETE"
+    end
+
+    # Mapping of merge types to related SQL
+    MERGE_TYPE_SQL = {
+      :insert => ' WHEN NOT MATCHED',
+      :delete => ' WHEN MATCHED',
+      :update => ' WHEN MATCHED',
+      :matched => ' WHEN MATCHED',
+      :not_matched => ' WHEN NOT MATCHED',
+    }.freeze
+    private_constant :MERGE_TYPE_SQL
+
+    # Add the WHEN clauses to the MERGE SQL
+    def _merge_when_sql(sql)
+      raise Error, "no WHEN [NOT] MATCHED clauses provided for MERGE" unless merge_when = @opts[:merge_when]
+      merge_when.each do |data|
+        type = data[:type]
+        sql << MERGE_TYPE_SQL[type]
+        _merge_when_conditions_sql(sql, data)
+        send(:"_merge_#{type}_sql", sql, data)
+      end
+    end
+
+    # Append MERGE WHEN conditions, if there are conditions provided.
+    def _merge_when_conditions_sql(sql, data)
+      if data.has_key?(:conditions)
+        sql << " AND "
+        literal_append(sql, data[:conditions])
+      end
+    end
+
+    # Parse the values passed to insert_sql, returning columns and values
+    # to use for the INSERT.  Returned columns is always an array, but can be empty
+    # for an INSERT without explicit column references. Returned values can be an
+    # array, dataset, or literal string.
+    def _parse_insert_sql_args(values)
+      columns = []
+
+      case values.size
+      when 0
+        values = []
+      when 1
+        case vals = values[0]
+        when Hash
+          values = []
+          vals.each do |k,v| 
+            columns << k
+            values << v
+          end
+        when Dataset, Array, LiteralString
+          values = vals
+        end
+      when 2
+        if (v0 = values[0]).is_a?(Array) && ((v1 = values[1]).is_a?(Array) || v1.is_a?(Dataset) || v1.is_a?(LiteralString))
+          columns, values = v0, v1
+          raise(Error, "Different number of values and columns given to insert_sql") if values.is_a?(Array) and columns.length != values.length
+        end
+      end
+
+      [columns, values]
+    end
+
     # Formats the truncate statement.  Assumes the table given has already been
     # literalized.
     def _truncate_sql(table)
@@ -896,9 +974,10 @@ module Sequel
     # Clone of this dataset usable in aggregate operations.  Does
     # a from_self if dataset contains any parameters that would
     # affect normal aggregation, or just removes an existing
-    # order if not.
+    # order if not. Also removes the row_proc, which isn't needed
+    # for aggregate calculations.
     def aggregate_dataset
-      options_overlap(COUNT_FROM_SELF_OPTS) ? from_self : unordered
+      (options_overlap(COUNT_FROM_SELF_OPTS) ? from_self : unordered).naked
     end
 
     # Append aliasing expression to SQL string.
@@ -918,10 +997,35 @@ module Sequel
       !@opts[:no_cache_sql] && !cache_get(:_no_cache_sql)
     end
 
-    # Raise an InvalidOperation exception if deletion is not allowed for this dataset.
+    # Raise an InvalidOperation exception if modification is not allowed for this dataset.
+    # Check whether it is allowed to insert into this dataset.
+    # Only for backwards compatibility with older external adapters.
     def check_modification_allowed!
+      # SEQUEL6: Remove
+      Sequel::Deprecation.deprecate("Dataset#check_modification_allowed!", "Use check_{insert,delete,update,truncation}_allowed! instead")
+      _check_modification_allowed!(supports_modifying_joins?)
+    end
+
+    # Check whether it is allowed to insert into this dataset.
+    def check_insert_allowed!
+      _check_modification_allowed!(false)
+    end
+    alias check_truncation_allowed! check_insert_allowed!
+
+    # Check whether it is allowed to delete from this dataset.
+    def check_delete_allowed!
+      _check_modification_allowed!(supports_deleting_joins?)
+    end
+
+    # Check whether it is allowed to update this dataset.
+    def check_update_allowed!
+      _check_modification_allowed!(supports_updating_joins?)
+    end
+
+    # Internals of the check_*_allowed! methods
+    def _check_modification_allowed!(modifying_joins_supported)
       raise(InvalidOperation, "Grouped datasets cannot be modified") if opts[:group]
-      raise(InvalidOperation, "Joined datasets cannot be modified") if !supports_modifying_joins? && joined_dataset?
+      raise(InvalidOperation, "Joined datasets cannot be modified") if !modifying_joins_supported && joined_dataset?
     end
 
     # Raise error if the dataset uses limits or offsets.
@@ -930,11 +1034,6 @@ module Sequel
       raise InvalidOperation, "Dataset##{type} not supported on datasets with limits or offsets" if opts[:limit] || opts[:offset]
     end
 
-    # Alias of check_modification_allowed!
-    def check_truncation_allowed!
-      check_modification_allowed!
-    end
-
     # Append column list to SQL string.
     # If the column list is empty, a wildcard (*) is appended.
     def column_list_append(sql, columns)
@@ -971,7 +1070,9 @@ module Sequel
     # operators unsupported by some databases. Used by adapters for databases
     # that don't support the operators natively.
     def complex_expression_emulate_append(sql, op, args)
+      # :nocov:
       case op
+      # :nocov:
       when :%
         complex_expression_arg_pairs_append(sql, args){|a, b| Sequel.function(:MOD, a, b)}
       when :>>
@@ -1144,7 +1245,10 @@ module Sequel
     end
 
     def insert_columns_sql(sql)
-      columns = opts[:columns]
+      _insert_columns_sql(sql, opts[:columns])
+    end
+
+    def _insert_columns_sql(sql, columns)
       if columns && !columns.empty?
         sql << ' ('
         identifier_list_append(sql, columns)
@@ -1163,7 +1267,11 @@ module Sequel
     end
 
     def insert_values_sql(sql)
-      case values = opts[:values]
+      _insert_values_sql(sql, opts[:values])
+    end
+    
+    def _insert_values_sql(sql, values)
+      case values
       when Array
         if values.empty?
           sql << " DEFAULT VALUES"
@@ -1196,6 +1304,13 @@ module Sequel
       "#{join_type.to_s.gsub('_', ' ').upcase} JOIN"
     end
 
+    # Append USING clause for JOIN USING
+    def join_using_clause_using_sql_append(sql, using_columns)
+      sql << ' USING ('
+      column_list_append(sql, using_columns)
+      sql << ')'
+    end
+    
     # Append a literalization of the array to SQL string.
     # Treats as an expression if an array of all two pairs, or as a SQL array otherwise.
     def literal_array_append(sql, v)
@@ -1516,15 +1631,14 @@ module Sequel
 
     def select_with_sql(sql)
       return unless supports_cte?
-      ws = opts[:with]
-      return if !ws || ws.empty?
+      ctes = opts[:with]
+      return if !ctes || ctes.empty?
       sql << select_with_sql_base
       c = false
       comma = ', '
-      ws.each do |w|
+      ctes.each do |cte|
         sql << comma if c
-        select_with_sql_prefix(sql, w)
-        literal_dataset_append(sql, w[:dataset])
+        select_with_sql_cte(sql, cte)
         c ||= true
       end
       sql << ' '
@@ -1537,6 +1651,11 @@ module Sequel
       "WITH "
     end
 
+    def select_with_sql_cte(sql, cte)
+      select_with_sql_prefix(sql, cte)
+      literal_dataset_append(sql, cte[:dataset])
+    end
+    
     def select_with_sql_prefix(sql, w)
       quote_identifier_append(sql, w[:name])
       if args = w[:args]
@@ -1545,6 +1664,13 @@ module Sequel
        sql << ')'
       end
       sql << ' AS '
+
+      case w[:materialized]
+      when true
+        sql << "MATERIALIZED "
+      when false
+        sql << "NOT MATERIALIZED "
+      end
     end
 
     # Whether the symbol cache should be skipped when literalizing the dataset
@@ -1599,7 +1725,7 @@ module Sequel
     # Append literalization of the subselect to SQL string.
     def subselect_sql_append(sql, ds)
       sds = subselect_sql_dataset(sql, ds)
-      sds.sql
+      subselect_sql_append_sql(sql, sds)
       unless sds.send(:cache_sql?)
         # If subquery dataset does not allow caching SQL,
         # then this dataset should not allow caching SQL.
@@ -1611,6 +1737,10 @@ module Sequel
       ds.clone(:append_sql=>sql)
     end
 
+    def subselect_sql_append_sql(sql, ds)
+      ds.sql
+    end
+
     # The number of decimal digits of precision to use in timestamps.
     def timestamp_precision
       supports_timestamp_usecs? ? 6 : 0

data/lib/sequel/extensions/_model_pg_row.rb

@@ -23,18 +23,6 @@ module Sequel
             super
           end
         end
-
-        private
-
-        # Handle Sequel::Model instances in bound variable arrays.
-        def bound_variable_array(arg)
-          case arg
-          when Sequel::Model
-            "\"(#{arg.values.values_at(*arg.columns).map{|v| bound_variable_array(v)}.join(',').gsub(/("|\\)/, '\\\\\1')})\""
-          else
-            super
-          end
-        end
       end
     end
   end

data/lib/sequel/extensions/_pretty_table.rb

@@ -39,7 +39,7 @@ module Sequel
 
     # Hash of the maximum size of the value for each column 
     def self.column_sizes(records, columns) # :nodoc:
-      sizes = Hash.new {0}
+      sizes = Hash.new(0)
       columns.each do |c|
         sizes[c] = c.to_s.size
       end

data/lib/sequel/extensions/any_not_empty.rb

@@ -33,7 +33,7 @@ module Sequel
   module AnyNotEmpty
     # If a block is not given, return whether the dataset is not empty.
     def any?
-      if block_given?
+      if defined?(yield)
         super
       else
         !empty?