sequel 4.49.0 → 5.0.0

data/lib/sequel/extensions/pg_range_ops.rb

@@ -75,9 +75,7 @@ module Sequel
         :starts_after => ["(".freeze, " &> ".freeze, ")".freeze].freeze,
         :adjacent_to => ["(".freeze, " -|- ".freeze, ")".freeze].freeze,
         :overlaps => ["(".freeze, " && ".freeze, ")".freeze].freeze,
-      }#.freeze # SEQUEL5
-      FUNCTIONS = %w'lower upper isempty lower_inc upper_inc lower_inf upper_inf'
-      Sequel::Deprecation.deprecate_constant(self, :FUNCTIONS)
+      }.freeze
 
       %w'lower upper isempty lower_inc upper_inc lower_inf upper_inf'.each do |f|
         class_eval("def #{f}; function(:#{f}) end", __FILE__, __LINE__)

data/lib/sequel/extensions/pg_row.rb

@@ -64,12 +64,12 @@
 #
 # You can also use a hash:
 #
-#   DB.row_type(:address, :street=>'123 Sesame St.', :city=>'Some City', :zip=>'12345')
+#   DB.row_type(:address, street: '123 Sesame St.', city: 'Some City', zip: '12345')
 #
 # So if you have a person table that has an address column, here's how you
 # could insert into the column:
 #
-#   DB[:table].insert(:address=>DB.row_type(:address, :street=>'123 Sesame St.', :city=>'Some City', :zip=>'12345'))
+#   DB[:table].insert(address: DB.row_type(:address, street: '123 Sesame St.', city: 'Some City', zip: '12345'))
 #
 # Note that registering row types without providing an explicit :converter option
 # creates anonymous classes.  This results in ruby being unable to Marshal such
@@ -88,16 +88,10 @@
 
 require 'delegate'
 require 'strscan'
-Sequel.require 'adapters/shared/postgres'
 
 module Sequel
   module Postgres
     module PGRow
-      ROW = 'ROW'.freeze
-      Sequel::Deprecation.deprecate_constant(self, :ROW)
-      CAST = '::'.freeze
-      Sequel::Deprecation.deprecate_constant(self, :CAST)
-
       # Class for row-valued/composite types that are treated as arrays. By default,
       # this is only used for generic PostgreSQL record types, as registered
       # types use HashRow by default.
@@ -216,7 +210,7 @@ module Sequel
         end
       end
 
-      ROW_TYPE_CLASSES = [HashRow, ArrayRow]#.freeze # SEQUEL5
+      ROW_TYPE_CLASSES = [HashRow, ArrayRow].freeze
 
       # This parser-like class splits the PostgreSQL
       # row-valued/composite type output string format
@@ -225,25 +219,6 @@ module Sequel
       # will accept, it only handles the output format that
       # PostgreSQL uses.
       class Splitter < StringScanner
-        OPEN_PAREN = /\(/.freeze
-        Sequel::Deprecation.deprecate_constant(self, :OPEN_PAREN)
-        CLOSE_PAREN = /\)/.freeze
-        Sequel::Deprecation.deprecate_constant(self, :CLOSE_PAREN)
-        UNQUOTED_RE = /[^,)]*/.freeze
-        Sequel::Deprecation.deprecate_constant(self, :UNQUOTED_RE)
-        SEP_RE = /[,)]/.freeze
-        Sequel::Deprecation.deprecate_constant(self, :SEP_RE)
-        QUOTE_RE = /"/.freeze
-        Sequel::Deprecation.deprecate_constant(self, :QUOTE_RE)
-        QUOTE_SEP_RE = /"[,)]/.freeze
-        Sequel::Deprecation.deprecate_constant(self, :QUOTE_SEP_RE)
-        QUOTED_RE = /(\\.|""|[^"])*/.freeze
-        Sequel::Deprecation.deprecate_constant(self, :QUOTED_RE)
-        REPLACE_RE = /\\(.)|"(")/.freeze
-        Sequel::Deprecation.deprecate_constant(self, :REPLACE_RE)
-        REPLACE_WITH = '\1\2'.freeze
-        Sequel::Deprecation.deprecate_constant(self, :REPLACE_WITH)
-
         # Split the stored string into an array of strings, handling
         # the different types of quoting.
         def parse
@@ -387,13 +362,6 @@ module Sequel
       end
 
       module DatabaseMethods
-        ESCAPE_RE = /("|\\)/.freeze
-        Sequel::Deprecation.deprecate_constant(self, :ESCAPE_RE)
-        ESCAPE_REPLACEMENT = '\\\\\1'.freeze
-        Sequel::Deprecation.deprecate_constant(self, :ESCAPE_REPLACEMENT)
-        COMMA = ','.freeze
-        Sequel::Deprecation.deprecate_constant(self, :COMMA)
-
         # A hash mapping row type keys (usually symbols), to option
         # hashes.  At the least, the values will contain the :parser
         # option for the Parser instance that the type will use.
@@ -401,7 +369,7 @@ module Sequel
 
         # Do some setup for the data structures the module uses.
         def self.extended(db)
-          db.instance_eval do
+          db.instance_exec do
             @row_types = {}
             @row_schema_types = {}
             extend(@row_type_method_module = Module.new)
@@ -433,8 +401,6 @@ module Sequel
           super
         end
 
-        STRING_TYPES = [18, 19, 25, 1042, 1043].freeze
-
         # Register a new row type for the Database instance. db_type should be the type
         # symbol.  This parses the PostgreSQL system tables to get information the
         # composite type, and by default has the type return instances of a subclass
@@ -487,23 +453,7 @@ module Sequel
 
           # Using the conversion_procs, lookup converters for each member of the composite type
           parser_opts[:column_converters] = parser_opts[:column_oids].map do |oid|
-            # procs[oid] # SEQUEL5
-
-            # SEQUEL5: Remove
-            if pr = procs[oid]
-              pr
-            elsif !STRING_TYPES.include?(oid)
-              # It's not a string type, and it's possible a conversion proc for this
-              # oid will be added later, so do a runtime check for it.
-              lambda do |s|
-                if (pr = procs[oid])
-                  Sequel::Deprecation.deprecate("Calling conversion proc for subtype (oid: #{oid}) of composite type (oid: #{parser_opts[:oid]}) not added until after composite type registration", "Register subtype conversion procs before registering composite type")
-                  pr.call(s)
-                else
-                  s
-                end
-              end
-            end
+            procs[oid]
           end
 
           # Setup the converter and typecaster
@@ -533,21 +483,9 @@ module Sequel
             private meth
           end
 
-          conversion_procs_updated # SEQUEL5: Remove
           nil
         end
 
-        # SEQUEL5: Remove
-        def reset_conversion_procs
-          procs = super
-
-          row_types.values.each do |opts|
-            register_row_type(opts[:type], opts)
-          end
-
-          procs
-        end
-
         # Handle typecasting of the given object to the given database type.
         # In general, the given database type should already be registered,
         # but if obj is an array, this will handled unregistered types.
@@ -602,16 +540,6 @@ module Sequel
         end
       end
     end
-
-    # SEQUEL5: Remove
-    parser = PGRow::Parser.new(:converter=>PGRow::ArrayRow)
-    PG__TYPES[2249] = lambda do |s|
-      Sequel::Deprecation.deprecate("Conversion proc for record added globally by pg_row extension", "Load the pg_row extension into the Database instance")
-      parser.call(s)
-    end
-    if defined?(PGArray) && PGArray.respond_to?(:register)
-      PGArray.register('record', :oid=>2287, :scalar_oid=>2249, :skip_deprecation_warning=>true)
-    end
   end
 
   module SQL::Builders

data/lib/sequel/extensions/pg_row_ops.rb

@@ -76,8 +76,8 @@
 #
 # This feature is mostly useful for a different way to graph tables:
 #
-#   DB[:a].join(:b, :id=>:b_id).select(Sequel.pg_row_op(:a).splat(:a),
-#                                      Sequel.pg_row_op(:b).splat(:b))
+#   DB[:a].join(:b, id: :b_id).select(Sequel.pg_row_op(:a).splat(:a),
+#                                     Sequel.pg_row_op(:b).splat(:b))
 #   # SELECT (a.*)::a, (b.*)::b FROM a INNER JOIN b ON (b.id = a.b_id)
 #   # => {:a=>{:id=>1, :b_id=>2}, :b=>{:id=>2}}
 #
@@ -88,17 +88,6 @@ module Sequel
   module Postgres
     # This class represents a composite type expression reference.
     class PGRowOp < SQL::PlaceholderLiteralString
-      OPEN = '('.freeze
-      Sequel::Deprecation.deprecate_constant(self, :OPEN)
-      CLOSE_DOT = ').'.freeze
-      Sequel::Deprecation.deprecate_constant(self, :CLOSE_DOT)
-      CLOSE_STAR = '.*)'.freeze
-      Sequel::Deprecation.deprecate_constant(self, :CLOSE_STAR)
-      CLOSE_STAR_CAST = '.*)::'.freeze
-      Sequel::Deprecation.deprecate_constant(self, :CLOSE_STAR_CAST)
-      EMPTY = "".freeze
-      Sequel::Deprecation.deprecate_constant(self, :EMPTY)
-
       ROW = ['(', '.*)'].freeze.each(&:freeze)
       ROW_CAST = ['(', '.*)::'].freeze.each(&:freeze)
       QUALIFY = ['(', ').'].freeze.each(&:freeze)

data/lib/sequel/extensions/query.rb

@@ -37,11 +37,9 @@ module Sequel
   end
 
   module DatasetQuery
-    Dataset.def_mutation_method(:query, :module=>self)
-
     # Translates a query block into a dataset. Query blocks are an
     # alternative to Sequel's usual method chaining, by using
-    # instance_eval with a proxy object:
+    # instance_exec with a proxy object:
     #
     #   dataset = DB[:items].query do
     #     select :x, :y, :z
@@ -54,7 +52,7 @@ module Sequel
     #  dataset = DB[:items].select(:x, :y, :z).where{(x > 1) & (y > 2)}.reverse(:z)
     def query(&block)
       query = Dataset::Query.new(self)
-      query.instance_eval(&block)
+      query.instance_exec(&block)
       query.dataset
     end
   end
@@ -71,6 +69,7 @@ module Sequel
 
       # Replace the query's dataset with dataset returned by the method call.
       def method_missing(method, *args, &block)
+        # Allow calling private methods, so things like raise works
         @dataset = @dataset.send(method, *args, &block)
         raise(Sequel::Error, "method #{method.inspect} did not return a dataset") unless @dataset.is_a?(Dataset)
         self

data/lib/sequel/extensions/round_timestamps.rb

@@ -25,12 +25,6 @@
 #
 # Related module: Sequel::Dataset::RoundTimestamps
 
-unless RUBY_VERSION >= '1.9'
-  # :nocov:
-  raise LoadError, 'the round_timestamps extension only works on ruby 1.9+'
-  # :nocov:
-end
-
 module Sequel
   class Dataset
     module RoundTimestamps

data/lib/sequel/extensions/schema_dumper.rb

@@ -70,7 +70,7 @@ module Sequel
     end
 
     # Dump foreign key constraints for all tables as a migration. This complements
-    # the :foreign_keys=>false option to dump_schema_migration. This only dumps
+    # the foreign_keys: false option to dump_schema_migration. This only dumps
     # the constraints (not the columns) using alter_table/add_foreign_key with an
     # array of columns.
     #
@@ -81,14 +81,14 @@ module Sequel
       <<END_MIG
 Sequel.migration do
   change do
-#{ts.sort_by(&:to_s).map{|t| dump_table_foreign_keys(t)}.reject{|x| x == ''}.join("\n\n").gsub(/^/, '    ')}
+#{ts.sort.map{|t| dump_table_foreign_keys(t)}.reject{|x| x == ''}.join("\n\n").gsub(/^/, '    ')}
   end
 end
 END_MIG
     end
 
     # Dump indexes for all tables as a migration.  This complements
-    # the :indexes=>false option to dump_schema_migration. Options:
+    # the indexes: false option to dump_schema_migration. Options:
     # :same_db :: Create a dump for the same database type, so
     #             don't ignore errors if the index statements fail.
     # :index_names :: If set to false, don't record names of indexes. If
@@ -99,13 +99,13 @@ END_MIG
       <<END_MIG
 Sequel.migration do
   change do
-#{ts.sort_by(&:to_s).map{|t| dump_table_indexes(t, :add_index, options)}.reject{|x| x == ''}.join("\n\n").gsub(/^/, '    ')}
+#{ts.sort.map{|t| dump_table_indexes(t, :add_index, options)}.reject{|x| x == ''}.join("\n\n").gsub(/^/, '    ')}
   end
 end
 END_MIG
     end
 
-    # Return a string that contains a Sequel::Migration subclass that when
+    # Return a string that contains a Sequel migration that when
     # run would recreate the database structure. Options:
     # :same_db :: Don't attempt to translate database types to ruby types.
     #             If this isn't set to true, all database types will be translated to
@@ -132,7 +132,7 @@ END_MIG
         # Handle skipped foreign keys by adding them at the end via
         # alter_table/add_foreign_key.  Note that skipped foreign keys
         # probably result in a broken down migration.
-        sfka = sfk.sort_by{|table, fks| table.to_s}.map{|table, fks| dump_add_fk_constraints(table, fks.values)}
+        sfka = sfk.sort.map{|table, fks| dump_add_fk_constraints(table, fks.values)}
         sfka.join("\n\n").gsub(/^/, '    ') unless sfka.empty?
       end
 
@@ -225,7 +225,7 @@ END_MIG
       sfks = String.new
       sfks << "alter_table(#{table.inspect}) do\n"
       sfks << create_table_generator do
-        fks.sort_by{|fk| fk[:columns].map(&:to_s)}.each do |fk|
+        fks.sort_by{|fk| fk[:columns]}.each do |fk|
           foreign_key fk[:columns], fk
         end
       end.dump_constraints.gsub(/^foreign_key /, '  add_foreign_key ')
@@ -236,7 +236,7 @@ END_MIG
     # string that would add the foreign keys if run in a migration.
     def dump_table_foreign_keys(table, options=OPTS)
       if supports_foreign_key_parsing?
-        fks = foreign_key_list(table, options).sort_by{|fk| fk[:columns].map(&:to_s)}
+        fks = foreign_key_list(table, options).sort_by{|fk| fk[:columns]}
       end
 
       if fks.nil? || fks.empty?
@@ -256,7 +256,7 @@ END_MIG
       im = method(:index_to_generator_opts)
 
       if options[:indexes] != false && supports_index_parsing?
-        indexes = indexes(table).sort_by{|k,v| k.to_s}
+        indexes = indexes(table).sort
       end
 
       if options[:foreign_keys] != false && supports_foreign_key_parsing?
@@ -296,7 +296,7 @@ END_MIG
     # creating the index migration.
     def dump_table_indexes(table, meth, options=OPTS)
       if supports_index_parsing?
-        indexes = indexes(table).sort_by{|k,v| k.to_s}
+        indexes = indexes(table).sort
       else
         return ''
       end
@@ -335,7 +335,7 @@ END_MIG
         options[:skipped_foreign_keys] = skipped_foreign_keys
         tables
       else
-        tables.sort_by(&:to_s)
+        tables.sort
       end
     end
 
@@ -360,14 +360,14 @@ END_MIG
           # outstanding foreign keys and skipping those foreign keys.
           # The skipped foreign keys will be added at the end of the
           # migration.
-          skip_table, skip_fks = table_fks.sort_by{|table, fks| [fks.length, table.to_s]}.first
+          skip_table, skip_fks = table_fks.sort_by{|table, fks| [fks.length, table]}.first
           skip_fks_hash = skipped_foreign_keys[skip_table] = {}
           skip_fks.each{|fk| skip_fks_hash[fk[:columns]] = fk}
           this_loop << skip_table
         end
 
         # Add sorted tables from this loop to the final list
-        sorted_tables.concat(this_loop.sort_by(&:to_s))
+        sorted_tables.concat(this_loop.sort)
 
         # Remove tables that were handled this loop
         this_loop.each{|t| table_fks.delete(t)}

data/lib/sequel/extensions/select_remove.rb

@@ -1,6 +1,6 @@
 # frozen-string-literal: true
 #
-# The select_remove extension adds Sequel::Dataset#select_remove for removing existing selected
+# The select_remove extension adds select_remove for removing existing selected
 # columns from a dataset.  It's not part of Sequel core as it is rarely needed and has
 # some corner cases where it can't work correctly.
 #
@@ -26,8 +26,8 @@ module Sequel
     #   # Assume columns a, b, and c in items table
     #   DB[:items] # SELECT * FROM items
     #   DB[:items].select_remove(:c) # SELECT a, b FROM items
-    #   DB[:items].select(:a, :b___c, :c___b).select_remove(:c) # SELECT a, c AS b FROM items
-    #   DB[:items].select(:a, :b___c, :c___b).select_remove(:c___b) # SELECT a, b AS c FROM items
+    #   DB[:items].select(:a, Sequel[:b].as(:c), Sequel[:c].as(:b)).select_remove(:c) # SELECT a, c AS b FROM items
+    #   DB[:items].select(:a, Sequel[:b][:c], Sequel[:c][:b]).select_remove(Sequel[:c][:b]) # SELECT a, b AS c FROM items
     #
     # Note that there are a few cases where this method may not work correctly:
     #

data/lib/sequel/extensions/split_array_nil.rb

@@ -3,7 +3,7 @@
 # The split_array_nil extension overrides Sequel's default handling of
 # IN/NOT IN with arrays of values to do specific nil checking.  For example,
 #
-#   ds = DB[:table].where(:column=>[1, nil])
+#   ds = DB[:table].where(column: [1, nil])
 # 
 # By default, that produces the following SQL:
 #
@@ -19,7 +19,7 @@
 #
 # Similarly, for NOT IN queries:
 #
-#   ds = DB[:table].exclude(:column=>[1, nil])
+#   ds = DB[:table].exclude(column: [1, nil])
 #   # Default:
 #   #   SELECT * FROM table WHERE (column NOT IN (1, NULL))
 #   # with split_array_nils extension:

data/lib/sequel/extensions/sql_comments.rb

@@ -20,7 +20,7 @@
 # work correctly when used in subqueries:
 #
 #   ds = DB[:table].comment("Some\r\nComment     Here")
-#   ds.where(:id=>ds).all
+#   ds.where(id: ds).all
 #   # SELECT * FROM table WHERE (id IN (SELECT * FROM table -- Some Comment Here
 #   # )) -- Some Comment Here
 #   #
@@ -31,7 +31,7 @@
 # Due to the use of single line SQL comments and converting all
 # whitespace to spaces, this should correctly handle even
 # malicious input.  However, it would be unwise to rely on that,
-# you should probably attempt to ensure that the argument given
+# you should ensure that the argument given
 # to Dataset#comment is not derived from user input.
 #
 # You can load this extension into specific datasets:

data/lib/sequel/extensions/string_agg.rb

@@ -103,8 +103,7 @@ module Sequel
               f = f.distinct
             end
             literal_append(sql, f)
-          # SEQUEL5: Remove cubrid
-          when :mysql, :hsqldb, :cubrid, :h2
+          when :mysql, :hsqldb, :h2
             sql << "GROUP_CONCAT("
             if distinct
               sql << "DISTINCT "
@@ -148,6 +147,8 @@ module Sequel
       def initialize(expr, separator=nil)
         @expr = expr
         @separator = separator
+        yield self if block_given?
+        freeze
       end
 
       # Whether the current expression uses distinct expressions 
@@ -157,16 +158,18 @@ module Sequel
 
       # Return a modified StringAgg that uses distinct expressions
       def distinct
-        sa = dup
-        sa.instance_variable_set(:@distinct, true)
-        sa
+        self.class.new(@expr, @separator) do |sa|
+          sa.instance_variable_set(:@order_expr, @order_expr) if @order_expr
+          sa.instance_variable_set(:@distinct, true)
+        end
       end
 
       # Return a modified StringAgg with the given order
       def order(*o)
-        sa = dup
-        sa.instance_variable_set(:@order_expr, o.empty? ? nil : o)
-        sa
+        self.class.new(@expr, @separator) do |sa|
+          sa.instance_variable_set(:@distinct, @distinct) if @distinct
+          sa.instance_variable_set(:@order_expr, o.empty? ? nil : o.freeze)
+        end
       end
 
       to_s_method :string_agg_sql