sequel 4.36.0 → 5.61.0

data/lib/sequel/dataset/dataset_module.rb

@@ -0,0 +1,46 @@
+# frozen-string-literal: true
+
+module Sequel
+  class Dataset
+    # This Module subclass is used by Database#extend_datasets
+    # and Dataset#with_extend to add dataset methods to classes.
+    # It adds some helper methods inside the module that can define
+    # named methods on the dataset instances which do specific actions.
+    # For example:
+    #
+    #   DB.extend_datasets do
+    #     order :by_id, :id
+    #     select :with_id_and_name, :id, :name
+    #     where :active, :active
+    #   end
+    #
+    #   DB[:table].active.with_id_and_name.by_id
+    #   # SELECT id, name FROM table WHERE active ORDER BY id
+    class DatasetModule < ::Module
+      meths = (<<-METHS).split.map(&:to_sym)
+        where exclude exclude_having having
+        distinct grep group group_and_count group_append 
+        limit offset order order_append order_prepend reverse 
+        select select_all select_append select_group server
+      METHS
+
+      # Define a method in the module
+      def self.def_dataset_caching_method(mod, meth)
+        mod.send(:define_method, meth) do |name, *args, &block|
+          if block
+            define_method(name){public_send(meth, *args, &block)}
+          else
+            key = :"_#{meth}_#{name}_ds"
+            define_method(name) do
+              cached_dataset(key){public_send(meth, *args)}
+            end
+          end
+        end
+      end
+
+      meths.each do |meth|
+        def_dataset_caching_method(self, meth)
+      end
+    end
+  end
+end

data/lib/sequel/dataset/features.rb

@@ -10,52 +10,52 @@ module Sequel
     
     # Whether this dataset quotes identifiers.
     def quote_identifiers?
-      if defined?(@quote_identifiers)
-        @quote_identifiers
-      else
-        @quote_identifiers = db.quote_identifiers?
-      end
+      @opts.fetch(:quote_identifiers, true)
     end
     
     # Whether this dataset will provide accurate number of rows matched for
-    # delete and update statements.  Accurate in this case is the number of
+    # delete and update statements, true by default.  Accurate in this case is the number of
     # rows matched by the dataset's filter.
     def provides_accurate_rows_matched?
       true
     end
     
-    # Whether you must use a column alias list for recursive CTEs (false by
-    # default).
+    # Whether you must use a column alias list for recursive CTEs, false by default.
     def recursive_cte_requires_column_aliases?
       false
     end
 
-    # Whether the dataset requires SQL standard datetimes (false by default,
-    # as most allow strings with ISO 8601 format).
+    # Whether the dataset requires SQL standard datetimes. False by default,
+    # as most allow strings with ISO 8601 format.
     def requires_sql_standard_datetimes?
       false
     end
 
     # Whether type specifiers are required for prepared statement/bound
-    # variable argument placeholders (i.e. :bv__integer)
+    # variable argument placeholders (i.e. :bv__integer), false by default.
     def requires_placeholder_type_specifiers?
       false
     end
 
-    # Whether the dataset supports common table expressions (the WITH clause).
+    # Whether the dataset supports common table expressions, false by default.
     # If given, +type+ can be :select, :insert, :update, or :delete, in which case it
     # determines whether WITH is supported for the respective statement type.
     def supports_cte?(type=:select)
       false
     end
 
-    # Whether the dataset supports common table expressions (the WITH clause)
-    # in subqueries.  If false, applies the WITH clause to the main query, which can cause issues
+    # Whether the dataset supports common table expressions in subqueries, false by default.
+    # If false, applies the WITH clause to the main query, which can cause issues
     # if multiple WITH clauses use the same name.
     def supports_cte_in_subqueries?
       false
     end
 
+    # Whether deleting from joined datasets is supported, false by default.
+    def supports_deleting_joins?
+      supports_modifying_joins?
+    end
+    
     # Whether the database supports derived column lists (e.g.
     # "table_expr AS table_alias(column_alias1, column_alias2, ...)"), true by
     # default.
@@ -68,23 +68,23 @@ module Sequel
       false
     end
 
-    # Whether the dataset supports CUBE with GROUP BY.
+    # Whether the dataset supports CUBE with GROUP BY, false by default.
     def supports_group_cube?
       false
     end
 
-    # Whether the dataset supports ROLLUP with GROUP BY.
+    # Whether the dataset supports ROLLUP with GROUP BY, false by default.
     def supports_group_rollup?
       false
     end
 
-    # Whether the dataset supports GROUPING SETS with GROUP BY.
+    # Whether the dataset supports GROUPING SETS with GROUP BY, false by default.
     def supports_grouping_sets?
       false
     end
 
     # Whether this dataset supports the +insert_select+ method for returning all columns values
-    # directly from an insert query.
+    # directly from an insert query, false by default.
     def supports_insert_select?
       supports_returning?(:insert)
     end
@@ -99,33 +99,44 @@ module Sequel
       true
     end
 
-    # Whether the dataset supports the IS TRUE syntax.
+    # Whether the dataset supports the IS TRUE syntax, true by default.
     def supports_is_true?
       true
     end
     
-    # Whether the dataset supports the JOIN table USING (column1, ...) syntax.
+    # Whether the dataset supports the JOIN table USING (column1, ...) syntax, true by default.
+    # If false, support is emulated using JOIN table ON (table.column1 = other_table.column1).
     def supports_join_using?
       true
     end
     
-    # Whether the dataset supports LATERAL for subqueries in the FROM or JOIN clauses.
+    # Whether the dataset supports LATERAL for subqueries in the FROM or JOIN clauses, false by default.
     def supports_lateral_subqueries?
       false
     end
 
-    # Whether limits are supported in correlated subqueries.  True by default.
+    # Whether limits are supported in correlated subqueries, true by default.
     def supports_limits_in_correlated_subqueries?
       true
     end
     
-    # Whether modifying joined datasets is supported.
+    # Whether the dataset supports skipping raising an error instead of waiting for locked rows when returning data, false by default.
+    def supports_nowait?
+      false
+    end
+
+    # Whether the MERGE statement is supported, false by default.
+    def supports_merge?
+      false
+    end
+
+    # Whether modifying joined datasets is supported, false by default.
     def supports_modifying_joins?
       false
     end
     
     # Whether the IN/NOT IN operators support multiple columns when an
-    # array of values is given.
+    # array of values is given, true by default.
     def supports_multiple_column_in?
       true
     end
@@ -136,12 +147,12 @@ module Sequel
     end
 
     # Whether the dataset supports or can fully emulate the DISTINCT ON clause,
-    # including respecting the ORDER BY clause, false by default
+    # including respecting the ORDER BY clause, false by default.
     def supports_ordered_distinct_on?
       supports_distinct_on?
     end
     
-    # Whether the dataset supports pattern matching by regular expressions.
+    # Whether the dataset supports pattern matching by regular expressions, false by default.
     def supports_regexp?
       false
     end
@@ -151,39 +162,62 @@ module Sequel
       false
     end
 
-    # Whether the RETURNING clause is supported for the given type of query.
+    # Whether the RETURNING clause is supported for the given type of query, false by default.
     # +type+ can be :insert, :update, or :delete.
     def supports_returning?(type)
       false
     end
 
-    # Whether the dataset supports skipping locked rows when returning data.
+    # Whether the dataset supports skipping locked rows when returning data, false by default.
     def supports_skip_locked?
       false
     end
 
-    # Whether the database supports SELECT *, column FROM table
+    # Whether the database supports <tt>SELECT *, column FROM table</tt>, true by default.
     def supports_select_all_and_column?
       true
     end
 
-    # Whether the dataset supports timezones in literal timestamps
+    # Whether the dataset supports timezones in literal timestamps, false by default.
     def supports_timestamp_timezones?
       false
     end
     
-    # Whether the dataset supports fractional seconds in literal timestamps
+    # Whether the dataset supports fractional seconds in literal timestamps, true by default.
     def supports_timestamp_usecs?
       true
     end
     
-    # Whether the dataset supports window functions.
+    # Whether updating joined datasets is supported, false by default.
+    def supports_updating_joins?
+      supports_modifying_joins?
+    end
+    
+    # Whether the dataset supports the WINDOW clause to define windows used by multiple
+    # window functions, false by default.
+    def supports_window_clause?
+      false
+    end
+
+    # Whether the dataset supports window functions, false by default.
     def supports_window_functions?
       false
     end
     
+    # Whether the dataset supports the given window function option.  True by default.
+    # This should only be called if supports_window_functions? is true. Possible options
+    # are :rows, :range, :groups, :offset, :exclude.
+    def supports_window_function_frame_option?(option)
+      case option
+      when :rows, :range, :offset
+        true
+      else
+        false
+      end
+    end
+    
     # Whether the dataset supports WHERE TRUE (or WHERE 1 for databases that
-    # that use 1 for true).
+    # that use 1 for true), true by default.
     def supports_where_true?
       true
     end
@@ -191,12 +225,33 @@ module Sequel
     private
 
     # Whether insert(nil) or insert({}) must be emulated by
-    # using at least one value, false by default.
+    # using at least one value.
     def insert_supports_empty_values?
       true
     end
 
-    # Whether the database supports quoting function names, false by default.
+    # Whether the dataset needs ESCAPE for LIKE for correct behavior.
+    def requires_like_escape?
+      true
+    end
+
+    # Whether ORDER BY col NULLS FIRST/LAST must be emulated.
+    def requires_emulating_nulls_first?
+      false
+    end
+
+    # Whether common table expressions are supported in UNION/INTERSECT/EXCEPT clauses.
+    def supports_cte_in_compounds?
+      supports_cte_in_subqueries?
+    end
+
+    # Whether the dataset supports the FILTER clause for aggregate functions.
+    # If not, support is emulated using CASE.
+    def supports_filtered_aggregates?
+      false
+    end
+
+    # Whether the database supports quoting function names.
     def supports_quoted_function_names?
       false
     end

data/lib/sequel/dataset/graph.rb

@@ -11,16 +11,17 @@ module Sequel
     
     # Adds the given graph aliases to the list of graph aliases to use,
     # unlike +set_graph_aliases+, which replaces the list (the equivalent
-    # of +select_more+ when graphing).  See +set_graph_aliases+.
+    # of +select_append+ when graphing).  See +set_graph_aliases+.
     #
-    #   DB[:table].add_graph_aliases(:some_alias=>[:table, :column])
+    #   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 (graph && (ga = graph[:column_aliases]))
         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_more(*columns).clone(:graph_aliases => Hash[ga].merge!(graph_aliases))
+      select_append(*columns).clone(:graph => graph.merge(:column_aliases=>ga.merge(graph_aliases).freeze).freeze)
     end
 
     # Similar to Dataset#join_table, but uses unambiguous aliases for selected
@@ -59,7 +60,7 @@ module Sequel
       case dataset
       when Symbol
         # let alias be the same as the table name (sans any optional schema)
-        # unless alias explicitly given in the symbol using ___ notation
+        # unless alias explicitly given in the symbol using ___ notation and symbol splitting is enabled
         table_alias ||= split_symbol(table).compact.last
       when Dataset
         if dataset.simple_select_all?
@@ -95,10 +96,30 @@ module Sequel
       
       table_alias_qualifier = qualifier_from_alias_symbol(table_alias, table)
       implicit_qualifier = options[:implicit_qualifier]
+      joined_dataset = joined_dataset?
       ds = self
+      graph = opts[:graph]
+
+      if !graph && (select = @opts[:select]) && !select.empty?
+        select_columns = nil
+
+        unless !joined_dataset && select.length == 1 && (select[0].is_a?(SQL::ColumnAll))
+          force_from_self = false
+          select_columns = select.map do |sel|
+            unless col = _hash_key_symbol(sel)
+              force_from_self = true
+              break
+            end
+
+            [sel, col]
+          end
+
+          select_columns = nil if force_from_self
+        end
+      end
 
       # Use a from_self if this is already a joined table (or from_self specifically disabled for graphs)
-      if (@opts[:graph_from_self] != false && !@opts[:graph] && joined_dataset?)
+      if (@opts[:graph_from_self] != false && !graph && (joined_dataset || force_from_self))
         from_selfed = true
         implicit_qualifier = options[:from_self_alias] || first_source
         ds = ds.from_self(:alias=>implicit_qualifier)
@@ -113,11 +134,9 @@ 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)
 
-      if graph = opts[:graph]
-        opts[:graph] = graph = graph.dup
+      if graph
+        graph = graph.dup
         select = opts[:select].dup
         [:column_aliases, :table_aliases, :column_alias_num].each{|k| graph[k] = graph[k].dup}
       else
@@ -127,7 +146,7 @@ module Sequel
         raise_alias_error.call if master == table_alias
 
         # Master hash storing all .graph related information
-        graph = opts[:graph] = {}
+        graph = {}
 
         # Associates column aliases back to tables and columns
         column_aliases = graph[:column_aliases] = {}
@@ -138,30 +157,24 @@ module Sequel
         # Keep track of the alias numbers used
         ca_num = graph[:column_alias_num] = Hash.new(0)
 
-        # All columns in the master table are never
-        # aliased, but are not included if set_graph_aliases
-        # has been used.
-        if add_columns
-          if (select = @opts[:select]) && !select.empty? && !(select.length == 1 && (select.first.is_a?(SQL::ColumnAll)))
-            select = select.map do |sel|
-              raise Error, "can't figure out alias to use for graphing for #{sel.inspect}" unless column = _hash_key_symbol(sel)
-              column_aliases[column] = [master, column]
-              if from_selfed
-                # Initial dataset was wrapped in subselect, selected all
-                # columns in the subselect, qualified by the subselect alias.
-                Sequel.qualify(qualifier, Sequel.identifier(column))
-              else
-                # Initial dataset not wrapped in subslect, just make
-                # sure columns are qualified in some way.
-                qualified_expression(sel, qualifier)
-              end
-            end
-          else
-            select = columns.map do |column|
-              column_aliases[column] = [master, column]
-              SQL::QualifiedIdentifier.new(qualifier, column)
+        select = if select_columns
+          select_columns.map do |sel, column|
+            column_aliases[column] = [master, column]
+            if from_selfed
+              # Initial dataset was wrapped in subselect, selected all
+              # columns in the subselect, qualified by the subselect alias.
+              Sequel.qualify(qualifier, Sequel.identifier(column))
+            else
+              # Initial dataset not wrapped in subslect, just make
+              # sure columns are qualified in some way.
+              qualified_expression(sel, qualifier)
             end
           end
+        else
+          columns.map do |column|
+            column_aliases[column] = [master, column]
+            SQL::QualifiedIdentifier.new(qualifier, column)
+          end
         end
       end
 
@@ -173,7 +186,7 @@ module Sequel
       table_aliases[table_alias] = add_table ? dataset : nil
 
       # Add the columns to the selection unless we are ignoring them
-      if add_table && add_columns
+      if add_table
         column_aliases = graph[:column_aliases]
         ca_num = graph[:column_alias_num]
         # Which columns to add to the result set
@@ -196,11 +209,13 @@ module Sequel
             ident = SQL::QualifiedIdentifier.new(table_alias_qualifier, column)
             [column, ident]
           end
-          column_aliases[col_alias] = [table_alias, column]
+          column_aliases[col_alias] = [table_alias, column].freeze
           select.push(identifier)
         end
       end
-      add_columns ? ds.select(*select) : ds
+      [:column_aliases, :table_aliases, :column_alias_num].each{|k| graph[k].freeze}
+      ds = ds.clone(:graph=>graph.freeze)
+      ds.select(*select)
     end
 
     # This allows you to manually specify the graph aliases to use
@@ -210,44 +225,51 @@ module Sequel
     # graphed dataset, and must be used instead of +select+ whenever
     # graphing is used.
     #
-    # graph_aliases :: Should be a hash with keys being symbols of
-    #                  column aliases, and values being either symbols or arrays with one to three elements.
-    #                  If the value is a symbol, it is assumed to be the same as a one element
-    #                  array containing that symbol.
-    #                  The first element of the array should be the table alias symbol.
-    #                  The second should be the actual column name symbol.  If the array only
-    #                  has a single element the column name symbol will be assumed to be the
-    #                  same as the corresponding hash key. If the array
-    #                  has a third element, it is used as the value returned, instead of
-    #                  table_alias.column_name.
+    # graph_aliases should be a hash with keys being symbols of
+    # column aliases, and values being either symbols or arrays with one to three elements.
+    # If the value is a symbol, it is assumed to be the same as a one element
+    # array containing that symbol.
+    # The first element of the array should be the table alias symbol.
+    # The second should be the actual column name symbol.  If the array only
+    # has a single element the column name symbol will be assumed to be the
+    # same as the corresponding hash key. If the array
+    # has a third element, it is used as the value returned, instead of
+    # table_alias.column_name.
     #
-    #   DB[:artists].graph(:albums, :artist_id=>:id).
-    #     set_graph_aliases(:name=>:artists,
-    #                       :album_name=>[:albums, :name],
-    #                       :forty_two=>[:albums, :fourtwo, 42]).first
+    #   DB[:artists].graph(:albums, :artist_id: :id).
+    #     set_graph_aliases(name: :artists,
+    #                       album_name: [:albums, :name],
+    #                       forty_two: [:albums, :fourtwo, 42]).first
     #   # 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)
-      ds = select(*columns)
-      ds.opts[:graph_aliases] = graph_aliases
-      ds
+      if graph = opts[:graph]
+        select(*columns).clone(:graph => graph.merge(:column_aliases=>graph_aliases.freeze).freeze)
+      else
+        raise Error, "cannot call #set_graph_aliases on an ungraphed dataset"
+      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)
     end
 
     private
 
     # Wrap the alias symbol in an SQL::Identifier if the identifier on which is based
-    # is an SQL::Identifier.  This works around cases where the alias symbol contains
+    # is an SQL::Identifier.  This works around cases where symbol splitting is enabled and the alias symbol contains
     # double embedded underscores which would be considered an implicit qualified identifier
     # if not wrapped in an SQL::Identifier.
     def qualifier_from_alias_symbol(aliaz, identifier)
-      identifier = identifier.column if identifier.is_a?(SQL::QualifiedIdentifier)
       case identifier
+      when SQL::QualifiedIdentifier
+        if identifier.column.is_a?(String)
+          Sequel.identifier(aliaz)
+        else
+          aliaz
+        end
       when SQL::Identifier
         Sequel.identifier(aliaz)
       else
@@ -260,10 +282,10 @@ module Sequel
     # a select method, and the second is a new hash of preprocessed graph aliases.
     def graph_alias_columns(graph_aliases)
       gas = {}
-      identifiers = graph_aliases.collect do |col_alias, tc| 
+      identifiers = graph_aliases.map do |col_alias, tc| 
         table, column, value = Array(tc)
         column ||= col_alias
-        gas[col_alias] = [table, column]
+        gas[col_alias] = [table, column].freeze
         identifier = value || SQL::QualifiedIdentifier.new(table, column)
         identifier = SQL::AliasedExpression.new(identifier, col_alias) if value || column != col_alias
         identifier