sequel 5.39.0 → 5.72.0

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,15 @@ 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
+      (aggreate_dataset_use_from_self? ? from_self : unordered).naked
+    end
+
+    # Whether to use from_self for an aggregate dataset.
+    def aggreate_dataset_use_from_self?
+      options_overlap(COUNT_FROM_SELF_OPTS)
     end
 
     # Append aliasing expression to SQL string.
@@ -918,10 +1002,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 +1039,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 +1075,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 +1250,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 +1272,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 +1309,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 +1636,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 +1656,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 +1669,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 +1730,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 +1742,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/dataset.rb

@@ -53,4 +53,8 @@ module Sequel
   require_relative "dataset/sql"
   require_relative "dataset/placeholder_literalizer"
   require_relative "dataset/dataset_module"
+
+  # :nocov:
+  require_relative "dataset/deprecated_singleton_class_methods" if Dataset::TRUE_FREEZE
+  # :nocov:
 end

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?