sequel 4.49.0 → 5.0.0

data/lib/sequel/extensions/no_auto_literal_strings.rb

@@ -1,86 +1,4 @@
 # frozen-string-literal: true
-#
-# The no_auto_literal_strings extension removes Sequel's automatic conversion
-# of strings to literal strings in the dataset filter methods.  By default,
-# Sequel considers a string passed to a filter method as a literal string:
-#
-#   DB[:table].where("name > 'A'")
-#
-# This is fine, except when the string is derived from user input:
-#
-#   DB[:table].where("name > '#{params[:user]}'") # SQL Injection!
-#
-# Sequel does support using placeholders for such strings:
-#
-#   DB[:table].where("name > ?", params[:user].to_s) # Safe
-#
-# However, if you forget to user placeholders, and pass a string to a filter
-# method that is derived from user input, you open yourself up to SQL injection.
-# With this extension, using a plain string in a filter method will result
-# in an exception being raised.  You either need to explicitly use a literal
-# string:
-#
-#   DB[:table].where(Sequel.lit("name > ?", params[:user].to_s))
-#
-# or you need to construct the same SQL using a non-string based approach:
-#
-#   DB[:table].where{|o| o.name > params[:user].to_s}
-#
-# Note that as listed in Sequel's security guide, a large number of dataset
-# methods call down to a filtering method, and this protects all of those
-# cases.
-#
-# This extension also protects the use of a plain string passed to Dataset#update:
-#
-#   DB[:table].update("column = column + 1")
-#
-# Again, you either need to explicitly use a literal string:
-#
-#   DB[:table].update(Sequel.lit("column = column + 1"))
-#
-# or construct the same SQL using a non-string based approach:
-#
-#   DB[:table].update(:column => Sequel[:column] + 1)
-#
-# Related module: Sequel::Dataset::NoAutoLiteralStrings
 
-#
-module Sequel
-  class Dataset
-    module NoAutoLiteralStrings
-      # Raise an error if passing a plain string or an array whose first
-      # entry is a plain string.
-      def filter_expr(expr = nil)
-        case expr
-        when LiteralString
-          super
-        when String
-          raise Error, "plain string passed to a dataset filtering method"
-        when Array
-          if expr.first.is_a?(String) && !expr.first.is_a?(LiteralString)
-            raise Error, "plain string passed to a dataset filtering method"
-          end
-          super
-        else
-          super
-        end
-      end
-
-      # Raise an error if passing a plain string.
-      def update_sql(values=OPTS)
-        case values
-        when LiteralString
-          super
-        when String
-          raise Error, "plain string passed to a dataset filtering method"
-        else
-          super
-        end
-      end
-    end
-
-    register_extension(:no_auto_literal_strings, NoAutoLiteralStrings)
-  end
-end
-
-# Sequel::Dataset.register_extension(:no_auto_literal_strings){} # SEQUEL5
+Sequel::Database.register_extension(:no_auto_literal_strings){}
+Sequel::Dataset.register_extension(:no_auto_literal_strings){}

data/lib/sequel/extensions/null_dataset.rb

@@ -13,7 +13,7 @@
 #
 # Usage:
 #
-#   ds = DB[:items].nullify.where(:a=>:b).select(:c)
+#   ds = DB[:items].nullify.where(a: :b).select(:c)
 #   ds.sql # => "SELECT c FROM items WHERE (a = b)"
 #   ds.all # => [] # no query sent to the database
 #
@@ -41,13 +41,7 @@ module Sequel
     module Nullifiable
       # Return a cloned nullified dataset.
       def nullify
-        clone.with_extend(NullDataset)
-      end
-
-      # Nullify the current dataset
-      def nullify!
-        Sequel::Deprecation.deprecate("Dataset#nullify! from the null_dataset extension", "Use Dataset#nullify, which returned a modified copy")
-        extend NullDataset
+        with_extend(NullDataset)
       end
     end
 

data/lib/sequel/extensions/pagination.rb

@@ -64,10 +64,8 @@ module Sequel
 
   class Dataset
     # Holds methods that only relate to paginated datasets. Paginated dataset
-    # have pages starting at 1 (page 1 is offset 0, page 1 is offset page_size).
+    # have pages starting at 1 (page 1 is offset 0, page 2 is offset 1 * page_size).
     module Pagination
-      Sequel::Dataset.def_deprecated_opts_setter(self, :page_size, :page_count, :current_page, :pagination_record_count)
-
       # The number of records per page (the final page may have fewer than
       # this number of records).
       def page_size
@@ -135,20 +133,6 @@ module Sequel
       def prev_page
         current_page > 1 ? (current_page - 1) : nil
       end
-
-      # SEQUEL5: Remove
-      # :nocov:
-      def set_pagination_info(page_no, page_size, record_count)
-        Sequel::Deprecation.deprecate("Dataset#set_pagination_info", "It should no longer be necessary to call this method")
-        self.current_page = page_no
-        self.page_size = page_size
-        self.pagination_record_count = record_count
-        page_count = (record_count / page_size.to_f).ceil
-        page_count = 1 if page_count == 0
-        self.page_count = page_count
-        self
-      end
-      # :nocov:
     end
   end
 

data/lib/sequel/extensions/pg_array.rb

@@ -32,7 +32,7 @@
 #
 # So if you want to insert an array into an integer[] database column:
 #
-#   DB[:table].insert(:column=>Sequel.pg_array([1, 2, 3]))
+#   DB[:table].insert(column: Sequel.pg_array([1, 2, 3]))
 #
 # To use this extension, first load it into your Sequel::Database instance:
 #
@@ -71,7 +71,6 @@
 
 require 'delegate'
 require 'strscan'
-Sequel.require 'adapters/shared/postgres'
 
 module Sequel
   module Postgres
@@ -79,108 +78,16 @@ module Sequel
     class PGArray < DelegateClass(Array)
       include Sequel::SQL::AliasMethods
 
-      ARRAY = "ARRAY".freeze
-      Sequel::Deprecation.deprecate_constant(self, :ARRAY)
-      DOUBLE_COLON = '::'.freeze
-      Sequel::Deprecation.deprecate_constant(self, :DOUBLE_COLON)
-      EMPTY_ARRAY = "'{}'".freeze
-      Sequel::Deprecation.deprecate_constant(self, :EMPTY_ARRAY)
-      EMPTY_BRACKET = '[]'.freeze
-      Sequel::Deprecation.deprecate_constant(self, :EMPTY_BRACKET)
-      OPEN_BRACKET = '['.freeze
-      Sequel::Deprecation.deprecate_constant(self, :OPEN_BRACKET)
-      CLOSE_BRACKET = ']'.freeze
-      Sequel::Deprecation.deprecate_constant(self, :CLOSE_BRACKET)
-      COMMA = ','.freeze
-      Sequel::Deprecation.deprecate_constant(self, :COMMA)
-      BACKSLASH = '\\'.freeze
-      Sequel::Deprecation.deprecate_constant(self, :BACKSLASH)
-      EMPTY_STRING = ''.freeze
-      Sequel::Deprecation.deprecate_constant(self, :EMPTY_STRING)
-      OPEN_BRACE = '{'.freeze
-      Sequel::Deprecation.deprecate_constant(self, :OPEN_BRACE)
-      CLOSE_BRACE = '}'.freeze
-      Sequel::Deprecation.deprecate_constant(self, :CLOSE_BRACE)
-      NULL = 'NULL'.freeze
-      Sequel::Deprecation.deprecate_constant(self, :NULL)
-      QUOTE = '"'.freeze
-      Sequel::Deprecation.deprecate_constant(self, :QUOTE)
-
-      # SEQUEL5: Remove
-      ARRAY_TYPES = {}
-
-      # SEQUEL5: Remove
-      def self.register(db_type, opts=OPTS, &block)
-        Sequel::Deprecation.deprecate("Sequel::Postgres::PGArray.register", "Use Database#register_array_type on a Database instance using the pg_array extension") unless opts[:skip_deprecation_warning]
-
-        db_type = db_type.to_s
-        type = (opts[:type_symbol] || db_type).to_sym
-        type_procs = opts[:type_procs] || PG__TYPES
-        mod = opts[:typecast_methods_module] || DatabaseMethods
-        typecast_method_map = opts[:typecast_method_map] || ARRAY_TYPES
-
-        if converter = opts[:converter]
-          raise Error, "can't provide both a block and :converter option to register" if block
-        else
-          converter = block
-        end
-
-        if soid = opts[:scalar_oid]
-          raise Error, "can't provide both a converter and :scalar_oid option to register" if converter 
-          converter = type_procs[soid]
-        end
-
-        array_type = (opts[:array_type] || db_type).to_s.dup.freeze
-        creator = Creator.new(array_type, converter)
-
-        typecast_method_map[db_type] = :"#{type}_array"
-
-        define_array_typecast_method(mod, type, creator, opts.fetch(:scalar_typecast, type))
-
-        if oid = opts[:oid]
-          if opts[:skip_deprecation_warning]
-            def creator.call(s)
-              Sequel::Deprecation.deprecate("Conversion proc for #{type}[] added globally by pg_array or other pg_* extension", "Load the appropriate pg_* extension(s) into the Database instance")
-              super
-            end
-          end
-          type_procs[oid] = creator
-        end
-
-        nil
-      end
-
-      # SEQUEL5: Remove
-      def self.define_array_typecast_method(mod, type, creator, scalar_typecast)
-        mod.class_eval do
-          meth = :"typecast_value_#{type}_array"
-          scalar_typecast_method = :"typecast_value_#{scalar_typecast}"
-          define_method(meth){|v| typecast_value_pg_array(v, creator, scalar_typecast_method)}
-          private meth
-        end
-      end
-      private_class_method :define_array_typecast_method
-
       module DatabaseMethods
-        APOS = "'".freeze
-        Sequel::Deprecation.deprecate_constant(self, :APOS)
-        DOUBLE_APOS = "''".freeze
-        Sequel::Deprecation.deprecate_constant(self, :DOUBLE_APOS)
-        ESCAPE_RE = /("|\\)/.freeze
-        Sequel::Deprecation.deprecate_constant(self, :ESCAPE_RE)
-        ESCAPE_REPLACEMENT = '\\\\\1'.freeze
-        Sequel::Deprecation.deprecate_constant(self, :ESCAPE_REPLACEMENT)
-
         BLOB_RANGE = 1...-1
 
         # Create the local hash of database type strings to schema type symbols,
         # used for array types local to this database.
         def self.extended(db)
-          db.instance_eval do
+          db.instance_exec do
             @pg_array_schema_types ||= {}
-            procs = conversion_procs
-            add_conversion_proc(1115, Creator.new("timestamp without time zone", procs[1114]))
-            add_conversion_proc(1185, Creator.new("timestamp with time zone", procs[1184]))
+            register_array_type('timestamp without time zone', :oid=>1115, :scalar_oid=>1114, :type_symbol=>:datetime)
+            register_array_type('timestamp with time zone', :oid=>1185, :scalar_oid=>1184, :type_symbol=>:datetime_timezone, :scalar_typecast=>:datetime)
 
             register_array_type('text', :oid=>1009, :scalar_oid=>25, :type_symbol=>:string)
             register_array_type('integer', :oid=>1007, :scalar_oid=>23)
@@ -220,6 +127,15 @@ module Sequel
           end
         end
 
+        def add_named_conversion_proc(name, &block)
+          ret = super
+          name = name.to_s if name.is_a?(Symbol)
+          from(:pg_type).where(:typname=>name).select_map([:oid, :typarray]).each do |scalar_oid, array_oid|
+            register_array_type(name, :oid=>array_oid.to_i, :scalar_oid=>scalar_oid.to_i)
+          end
+          ret
+        end
+
         # Handle arrays in bound variables
         def bound_variable_arg(arg, conn)
           case arg
@@ -260,9 +176,6 @@ module Sequel
         #
         # If a block is given, it is treated as the :converter option.
         def register_array_type(db_type, opts=OPTS, &block)
-          # Only for convert_named_procs_to_procs usage
-          type_procs = opts[:type_procs] || conversion_procs # SEQUEL5: Remove
-
           oid = opts[:oid]
           soid = opts[:scalar_oid]
 
@@ -286,17 +199,16 @@ module Sequel
 
           if soid
             raise Error, "can't provide both a converter and :scalar_oid option to register" if has_converter 
-            converter = type_procs[soid] # SEQUEL5: conversion_procs[soid]
+            converter = conversion_procs[soid]
           end
 
           array_type = (opts[:array_type] || db_type).to_s.dup.freeze
           creator = Creator.new(array_type, converter)
-          type_procs[oid] = creator # SEQUEL5: Remove
-          #add_conversion_proc(oid, creator) # SEQUEL5
+          add_conversion_proc(oid, creator)
 
           typecast_method_map[db_type] = :"#{type}_array"
 
-          (class << self; self end).class_eval do # singleton_class.class_eval do # SEQUEL5
+          singleton_class.class_eval do
             meth = :"typecast_value_#{type}_array"
             scalar_typecast_method = :"typecast_value_#{opts.fetch(:scalar_typecast, type)}"
             define_method(meth){|v| typecast_value_pg_array(v, creator, scalar_typecast_method)}
@@ -304,15 +216,9 @@ module Sequel
           end
 
           @schema_type_classes[:"#{type}_array"] = PGArray
-          conversion_procs_updated # SEQUEL5: Remove
           nil
         end
 
-        # SEQUEL5: Remove
-        def schema_type_class(type)
-          super || (ARRAY_TYPES.each_value{|v| return PGArray if type == v}; nil)
-        end
-
         private
 
         # Format arrays used in bound variables.
@@ -331,32 +237,11 @@ module Sequel
           end
         end
 
-        # Automatically handle array types for the given named types. 
-        def convert_named_procs_to_procs(named_procs)
-          h = super
-          unless h.empty?
-            from(:pg_type).where(:oid=>h.keys).select_map([:typname, :oid, :typarray]).each do |name, scalar_oid, array_oid|
-              register_array_type(name, :type_procs=>h, :oid=>array_oid.to_i, :scalar_oid=>scalar_oid.to_i)
-            end
-          end
-          h
-        end
-
-        # SEQUEL5: Remove
-        def get_conversion_procs
-          procs = super
-
-          procs[1115] = Creator.new("timestamp without time zone", procs[1114])
-          procs[1185] = Creator.new("timestamp with time zone", procs[1184])
-
-          procs
-        end
-
         # Look into both the current database's array schema types and the global
         # array schema types to get the type symbol for the given database type
         # string.
         def pg_array_schema_type(type)
-          @pg_array_schema_types[type] || ARRAY_TYPES[type] # SEQUEL5: Remove || ARRAY_TYPES[type] 
+          @pg_array_schema_types[type]
         end
 
         # Make the column type detection handle registered array types.
@@ -408,15 +293,6 @@ module Sequel
       # Note that does not handle all forms out input that PostgreSQL will
       # accept, and it will not raise an error for all forms of invalid input.
       class Parser < StringScanner
-        UNQUOTED_RE = /[{}",]|[^{}",]+/
-        Sequel::Deprecation.deprecate_constant(self, :UNQUOTED_RE)
-        QUOTED_RE = /["\\]|[^"\\]+/
-        Sequel::Deprecation.deprecate_constant(self, :QUOTED_RE)
-        NULL_RE = /NULL",/
-        Sequel::Deprecation.deprecate_constant(self, :NULL_RE)
-        OPEN_RE = /((\[\d+:\d+\])+=)?\{/
-        Sequel::Deprecation.deprecate_constant(self, :OPEN_RE)
-
         # Set the source for the input, and any converter callable
         # to call with objects to be created.  For nested parsers
         # the source may contain text after the end current parse,
@@ -425,8 +301,8 @@ module Sequel
           super(source)
           @converter = converter 
           @stack = [[]]
-          @recorded = new_entry_buffer
-          #@encoding = string.encoding # SEQUEL5
+          @encoding = string.encoding
+          @recorded = String.new.force_encoding(@encoding)
         end
 
         # Take the buffer of recorded characters and add it to the array
@@ -440,7 +316,7 @@ module Sequel
               entry = @converter.call(entry)
             end
             @stack.last.push(entry)
-            @recorded = new_entry_buffer
+            @recorded = String.new.force_encoding(@encoding)
           end
         end
 
@@ -499,21 +375,6 @@ module Sequel
 
           raise Sequel::Error, "array parsing finished with array unclosed"
         end
-
-        private
-
-        if RUBY_VERSION < '1.9.0'
-          # :nocov:
-          def new_entry_buffer
-            String.new
-          end
-          # :nocov:
-        else
-          def new_entry_buffer
-            String.new.force_encoding(string.encoding)
-            #String.new.force_encoding(@encoding) # SEQUEL5
-          end
-        end
       end unless Sequel::Postgres.respond_to?(:parse_pg_array)
 
       # Callable object that takes the input string and parses it using Parser.
@@ -596,36 +457,6 @@ module Sequel
         end
         sql << ']'
       end
-
-      # SEQUEL5: Remove
-      register('text', :oid=>1009, :scalar_oid=>25, :type_symbol=>:string, :skip_deprecation_warning=>true)
-      register('integer', :oid=>1007, :scalar_oid=>23, :skip_deprecation_warning=>true)
-      register('bigint', :oid=>1016, :scalar_oid=>20, :scalar_typecast=>:integer, :skip_deprecation_warning=>true)
-      register('numeric', :oid=>1231, :scalar_oid=>1700, :type_symbol=>:decimal, :skip_deprecation_warning=>true)
-      register('double precision', :oid=>1022, :scalar_oid=>701, :type_symbol=>:float, :skip_deprecation_warning=>true)
-      register('boolean', :oid=>1000, :scalar_oid=>16, :skip_deprecation_warning=>true)
-      register('bytea', :oid=>1001, :scalar_oid=>17, :type_symbol=>:blob, :skip_deprecation_warning=>true)
-      register('date', :oid=>1182, :scalar_oid=>1082, :skip_deprecation_warning=>true)
-      register('time without time zone', :oid=>1183, :scalar_oid=>1083, :type_symbol=>:time, :skip_deprecation_warning=>true)
-      register('timestamp without time zone', :oid=>1115, :scalar_oid=>1114, :type_symbol=>:datetime, :skip_deprecation_warning=>true)
-      register('time with time zone', :oid=>1270, :scalar_oid=>1083, :type_symbol=>:time_timezone, :scalar_typecast=>:time, :skip_deprecation_warning=>true)
-      register('timestamp with time zone', :oid=>1185, :scalar_oid=>1184, :type_symbol=>:datetime_timezone, :scalar_typecast=>:datetime, :skip_deprecation_warning=>true)
-      register('smallint', :oid=>1005, :scalar_oid=>21, :scalar_typecast=>:integer, :skip_deprecation_warning=>true)
-      register('oid', :oid=>1028, :scalar_oid=>26, :scalar_typecast=>:integer, :skip_deprecation_warning=>true)
-      register('real', :oid=>1021, :scalar_oid=>700, :scalar_typecast=>:float, :skip_deprecation_warning=>true)
-      register('character', :oid=>1014, :array_type=>:text, :scalar_typecast=>:string, :skip_deprecation_warning=>true)
-      register('character varying', :oid=>1015, :scalar_typecast=>:string, :type_symbol=>:varchar, :skip_deprecation_warning=>true)
-      register('xml', :oid=>143, :scalar_oid=>142, :skip_deprecation_warning=>true)
-      register('money', :oid=>791, :scalar_oid=>790, :skip_deprecation_warning=>true)
-      register('bit', :oid=>1561, :scalar_oid=>1560, :skip_deprecation_warning=>true)
-      register('bit varying', :oid=>1563, :scalar_oid=>1562, :type_symbol=>:varbit, :skip_deprecation_warning=>true)
-      register('uuid', :oid=>2951, :scalar_oid=>2950, :skip_deprecation_warning=>true)
-      register('xid', :oid=>1011, :scalar_oid=>28, :skip_deprecation_warning=>true)
-      register('cid', :oid=>1012, :scalar_oid=>29, :skip_deprecation_warning=>true)
-      register('name', :oid=>1003, :scalar_oid=>19, :skip_deprecation_warning=>true)
-      register('tid', :oid=>1010, :scalar_oid=>27, :skip_deprecation_warning=>true)
-      register('int2vector', :oid=>1006, :scalar_oid=>22, :skip_deprecation_warning=>true)
-      register('oidvector', :oid=>1013, :scalar_oid=>30, :skip_deprecation_warning=>true)
     end
   end