sequel 4.49.0 → 5.3.0

data/lib/sequel/dataset/graph.rb

@@ -13,19 +13,15 @@ module Sequel
     # unlike +set_graph_aliases+, which replaces the list (the equivalent
     # 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)
       graph = opts[:graph]
-      unless (ga = opts[:graph_aliases]) || (graph && (ga = graph[:column_aliases])) # SEQUEL5: Remove graph_aliases support
+      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)
-      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
+      select_append(*columns).clone(:graph => Hash[graph].merge!(:column_aliases=>Hash[ga].merge!(graph_aliases).freeze).freeze)
     end
 
     # Similar to Dataset#join_table, but uses unambiguous aliases for selected
@@ -64,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?
@@ -118,8 +114,6 @@ 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) # SEQUEL5: Remove graph_aliases support
 
       if graph = opts[:graph]
         graph = graph.dup
@@ -146,27 +140,25 @@ module Sequel
         # 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)
+        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)
+          end
         end
       end
 
@@ -178,7 +170,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
@@ -207,7 +199,7 @@ module Sequel
       end
       [:column_aliases, :table_aliases, :column_alias_num].each{|k| graph[k].freeze}
       ds = ds.clone(:graph=>graph.freeze)
-      add_columns ? ds.select(*select) : ds
+      ds.select(*select)
     end
 
     # This allows you to manually specify the graph aliases to use
@@ -217,42 +209,41 @@ 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)
       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
+        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) # SEQUEL5: Remove :graph_aliases
+      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)

data/lib/sequel/dataset/misc.rb

@@ -7,15 +7,6 @@ module Sequel
     # These methods don't fit cleanly into another section.
     # ---------------------
     
-    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.
     attr_reader :db
@@ -33,9 +24,9 @@ module Sequel
     # the Database#dataset method return an instance of that subclass.
     def initialize(db)
       @db = db
-      @opts = {} # OPTS # SEQUEL5
+      @opts = OPTS
       @cache = {}
-      # freeze # SEQUEL5
+      freeze
     end
 
     # Define a hash value such that datasets with the same class, DB, and opts
@@ -55,30 +46,16 @@ 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
-        _clone(:freeze=>false)
-      end
-    else
-      # :nocov:
-      def dup
-        c = clone
-        c.instance_variable_set(:@opts, Hash[c.opts])
-        c
-      end
-      # :nocov:
+    # Return self, as datasets are always frozen.
+    def dup
+      self
     end
     
     # Yield a dataset for each server in the connection pool that is tied to that server.
     # Intended for use in sharded environments where all servers need to be modified
     # with the same data:
     #
-    #   DB[:configs].where(:key=>'setting').each_server{|ds| ds.update(:value=>'new_value')}
+    #   DB[:configs].where(key: 'setting').each_server{|ds| ds.update(value: 'new_value')}
     def each_server
       db.servers.each{|s| yield server(s)}
     end
@@ -101,12 +78,11 @@ module Sequel
     else
       # :nocov:
       def freeze # :nodoc:
-        @opts.freeze # SEQUEL5: remove
         self
       end
 
       def frozen?  # :nodoc:
-        @opts.frozen? # SEQUEL5: true
+        true
       end
       # :nocov:
     end
@@ -122,7 +98,7 @@ module Sequel
     #   DB[:table].first_source_alias
     #   # => :table
     #
-    #   DB[:table___t].first_source_alias
+    #   DB[Sequel[:table].as(:t)].first_source_alias
     #   # => :t
     def first_source_alias
       source = @opts[:from]
@@ -147,7 +123,7 @@ module Sequel
     #   DB[:table].first_source_table
     #   # => :table
     #
-    #   DB[:table___t].first_source_table
+    #   DB[Sequel[:table].as(:t)].first_source_table
     #   # => :table
     def first_source_table
       source = @opts[:from]
@@ -215,7 +191,7 @@ module Sequel
     # SQL identifier that represents the unqualified column for the given value.
     # The given value should be a Symbol, SQL::Identifier, SQL::QualifiedIdentifier,
     # or SQL::AliasedExpression containing one of those.  In other cases, this
-    # returns nil
+    # returns nil.
     def unqualified_column_for(v)
       unless v.is_a?(String)
         _unqualified_column_for(v)
@@ -299,12 +275,11 @@ module Sequel
     private
 
     # Check the cache for the given key, returning the value.
-    # Otherwise, yield to get the dataset, and if the current dataset
-    # is frozen, cache the dataset under the given key.
+    # Otherwise, yield to get the dataset and cache the dataset under the given key.
     def cached_dataset(key)
       unless ds = cache_get(key)
         ds = yield
-        cache_set(key, ds) if frozen? # SEQUEL5: Remove if frozen?
+        cache_set(key, ds)
       end
 
       ds

data/lib/sequel/dataset/placeholder_literalizer.rb

@@ -15,7 +15,7 @@ module Sequel
     # Example:
     #
     #   loader = Sequel::Dataset::PlaceholderLiteralizer.loader(DB[:items]) do |pl, ds|
-    #     ds.where(:id=>pl.arg).exclude(:name=>pl.arg).limit(1)
+    #     ds.where(id: pl.arg).exclude(name: pl.arg).limit(1)
     #   end
     #   loader.first(1, "foo")
     #   # SELECT * FROM items WHERE ((id = 1) AND (name != 'foo')) LIMIT 1
@@ -27,7 +27,7 @@ module Sequel
     # Note that this method does not handle all possible cases.  For example:
     #
     #   loader = Sequel::Dataset::PlaceholderLiteralizer.loader(DB[:items]) do |pl, ds|
-    #     ds.join(pl.arg, :item_id=>:id)
+    #     ds.join(pl.arg, item_id: :id)
     #   end
     #   loader.all(:cart_items)
     #  
@@ -35,7 +35,7 @@ module Sequel
     # best to add a table alias when joining:
     #
     #   loader = Sequel::Dataset::PlaceholderLiteralizer.loader(DB[:items]) do |pl, ds|
-    #     ds.join(Sequel.as(pl.arg, :t), :item_id=>:id)
+    #     ds.join(Sequel.as(pl.arg, :t), item_id: :id)
     #   end
     #   loader.all(:cart_items)
     #
@@ -107,7 +107,7 @@ module Sequel
         end
 
         # Record the offset at which the argument is used in the SQL query, and any
-        # transforming
+        # transforming block.
         def use(sql, arg, transformer)
           @args << [sql, sql.length, arg, transformer]
         end

data/lib/sequel/dataset/prepared_statements.rb

@@ -37,23 +37,10 @@ module Sequel
     end
     private_class_method :prepared_statements_module
 
-    def self.def_deprecated_opts_setter(mod, *meths)
-      meths.each do |meth|
-        mod.send(:define_method, :"#{meth}=") do |v|
-          # :nocov:
-          Sequel::Deprecation.deprecate("Dataset##{meth}=", "The API has changed, and this value should now be passed in as an option via Dataset#clone")
-          @opts[meth] = v
-          # :nocov:
-        end
-      end
-    end
-    
     # Default implementation of the argument mapper to allow
     # native database support for bind variables and prepared
     # statements (as opposed to the emulated ones used by default).
     module ArgumentMapper
-      Dataset.def_deprecated_opts_setter(self, :prepared_statement_name, :bind_arguments)
-      
       # The name of the prepared statement, if any.
       def prepared_statement_name
         @opts[:prepared_statement_name]
@@ -89,11 +76,6 @@ module Sequel
     # into the query, which works on all databases, as it is no different
     # from using the dataset without bind variables.
     module PreparedStatementMethods
-      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.
       def log_sql
@@ -141,6 +123,12 @@ module Sequel
         orig_dataset.columns
       end
       
+      # Disallow use of delayed evaluations in prepared statements.
+      def delayed_evaluation_sql_append(sql, delay)
+        raise Error, "delayed evaluations cannot be used in prepared statements" if @opts[:no_delayed_evaluations]
+        super
+      end
+
       # Returns the SQL for the prepared statement, depending on
       # the type of the statement and the prepared_modify_values.
       def prepared_sql
@@ -188,13 +176,10 @@ module Sequel
       
       protected
       
-      # Run the method based on the type of prepared statement, with
-      # :select running #all to get all of the rows, and the other
-      # types running the method with the same name as the type.
+      # Run the method based on the type of prepared statement.
       def run(&block)
         case prepared_type
         when :select, :all
-          # Most common scenario, so listed first
           all(&block)
         when :each
           each(&block)
@@ -208,18 +193,17 @@ module Sequel
           elsif prepared_type == :delete
             delete
           else
-            send(prepared_type, *prepared_modify_values)
+            public_send(prepared_type, *prepared_modify_values)
           end
         when :insert_pk
           fetch_rows(prepared_sql){|r| return r.values.first}
         when Array
           case prepared_type[0]
           when :map, :as_hash, :to_hash, :to_hash_groups
-            send(*prepared_type, &block) 
+            public_send(*prepared_type, &block) 
           end
         else
-          Sequel::Deprecation.deprecate("Using an unsupported prepared statement type (#{prepared_type.inspect})", 'Switch to using :select as the prepared statement type')
-          all(&block)
+          raise Error, "unsupported prepared statement type used: #{prepared_type.inspect}"
         end
       end
       
@@ -235,8 +219,7 @@ module Sequel
         @opts[:bind_vars].has_key?(k)
       end
 
-      # The symbol cache should always be skipped, since placeholders
-      # are symbols.
+      # The symbol cache should always be skipped, since placeholders are symbols.
       def skip_symbol_cache?
         true
       end
@@ -286,7 +269,7 @@ module Sequel
     # already been set for this dataset, they are updated with the contents
     # of bind_vars.
     #
-    #   DB[:table].where(:id=>:$id).bind(:id=>1).call(:first)
+    #   DB[:table].where(id: :$id).bind(id: 1).call(:first)
     #   # SELECT * FROM table WHERE id = ? LIMIT 1 -- (1)
     #   # => {:id=>1}
     def bind(bind_vars={})
@@ -307,7 +290,7 @@ module Sequel
     # run the sql with the bind variables specified in the hash.  +values+ is a hash passed to
     # insert or update (if one of those types is used), which may contain placeholders.
     #
-    #   DB[:table].where(:id=>:$id).call(:first, :id=>1)
+    #   DB[:table].where(id: :$id).call(:first, id: 1)
     #   # SELECT * FROM table WHERE id = ? LIMIT 1 -- (1)
     #   # => {:id=>1}
     def call(type, bind_variables={}, *values, &block)
@@ -315,36 +298,25 @@ module Sequel
     end
     
     # Prepare an SQL statement for later execution.  Takes a type similar to #call,
-    # and the +name+ symbol of the prepared statement.  While +name+ defaults to +nil+,
-    # it should always be provided as a symbol for the name of the prepared statement,
-    # as some databases require that prepared statements have names.
+    # and the +name+ symbol of the prepared statement.
     #
     # This returns a clone of the dataset extended with PreparedStatementMethods,
     # which you can +call+ with the hash of bind variables to use.
     # The prepared statement is also stored in
-    # the associated database, where it can be called by name.
+    # the associated Database, where it can be called by name.
     # The following usage is identical:
     #
-    #   ps = DB[:table].where(:name=>:$name).prepare(:first, :select_by_name)
+    #   ps = DB[:table].where(name: :$name).prepare(:first, :select_by_name)
     #
-    #   ps.call(:name=>'Blah')
+    #   ps.call(name: 'Blah')
     #   # SELECT * FROM table WHERE name = ? -- ('Blah')
     #   # => {:id=>1, :name=>'Blah'}
     #
-    #   DB.call(:select_by_name, :name=>'Blah') # Same thing
-    def prepare(type, name=nil, *values)
-      ps = to_prepared_statement(type, values, :name=>name, :extend=>prepared_statement_modules)
-
-      if name
-        ps.prepared_sql
-        db.set_prepared_statement(name, ps)
-      else
-        # :nocov:
-        # SEQUEL5: Add coverage
-        Sequel::Deprecation.deprecate("Dataset#prepare will change to requiring a name argument in Sequel 5, please update your code") unless name
-        # :nocov:
-      end
-
+    #   DB.call(:select_by_name, name: 'Blah') # Same thing
+    def prepare(type, name, *values)
+      ps = to_prepared_statement(type, values, :name=>name, :extend=>prepared_statement_modules, :no_delayed_evaluations=>true)
+      ps.prepared_sql
+      db.set_prepared_statement(name, ps)
       ps
     end
     
@@ -357,7 +329,7 @@ module Sequel
       mods += [PreparedStatementMethods]
 
       bind.
-        clone(:prepared_statement_name=>opts[:name], :prepared_type=>type, :prepared_modify_values=>values, :orig_dataset=>self, :no_cache_sql=>true, :prepared_args=>@opts[:prepared_args]||[]).
+        clone(:prepared_statement_name=>opts[:name], :prepared_type=>type, :prepared_modify_values=>values, :orig_dataset=>self, :no_cache_sql=>true, :prepared_args=>@opts[:prepared_args]||[], :no_delayed_evaluations=>opts[:no_delayed_evaluations]).
         with_extend(*mods)
     end