sequel 4.47.0 → 4.48.0

data/lib/sequel/adapters/shared/sqlanywhere.rb

@@ -4,12 +4,17 @@ module Sequel
   module SqlAnywhere
     Sequel::Database.set_shared_adapter_scheme(:sqlanywhere, self)
 
+    # SEQUEL5: Remove
     @convert_smallint_to_bool = true
-
     class << self
-      # Whether to convert smallint values to bool, false by default.
-      # Can also be overridden per dataset.
-      attr_accessor :convert_smallint_to_bool
+      def convert_smallint_to_bool
+        Sequel::Deprecation.deprecate("Sequel::SqlAnywhere.convert_smallint_to_bool", "Call this method on the Database instance")
+        @convert_smallint_to_bool
+      end
+      def convert_smallint_to_bool=(v)
+        Sequel::Deprecation.deprecate("Sequel::SqlAnywhere.convert_smallint_to_bool=", "Call this method on the Database instance")
+        @convert_smallint_to_bool = v
+      end
     end
 
     module DatabaseMethods
@@ -36,7 +41,7 @@ module Sequel
       # Whether to convert smallint to boolean arguments for this dataset.
       # Defaults to the SqlAnywhere module setting.
       def convert_smallint_to_bool
-        defined?(@convert_smallint_to_bool) ? @convert_smallint_to_bool : (@convert_smallint_to_bool = ::Sequel::SqlAnywhere.convert_smallint_to_bool)
+        defined?(@convert_smallint_to_bool) ? @convert_smallint_to_bool : (@convert_smallint_to_bool = ::Sequel::SqlAnywhere.instance_variable_get(:@convert_smallint_to_bool)) # true) # SEQUEL5
       end
 
       # Sysbase Server uses the :sqlanywhere type.
@@ -319,14 +324,22 @@ module Sequel
       Dataset.def_sql_method(self, :insert, %w'with insert into columns values')
       Dataset.def_sql_method(self, :select, %w'with select distinct limit columns into from join where group having compounds order lock')
 
+      # Override the default IBMDB.convert_smallint_to_bool setting for this dataset.
+      def convert_smallint_to_bool=(v)
+        Sequel::Deprecation.deprecate("Sequel::SqlAnywhere::Dataset#convert_smallint_to_bool=", "Call with_convert_smallint_to_bool instead, which returns a modified copy instead of modifying the object")
+        @opts[:convert_smallint_to_bool] = v
+      end
+
       # Whether to convert smallint to boolean arguments for this dataset.
-      # Defaults to the SqlAnywhere module setting.
+      # Defaults to the IBMDB module setting.
       def convert_smallint_to_bool
-        defined?(@convert_smallint_to_bool) ? @convert_smallint_to_bool : (@convert_smallint_to_bool = @db.convert_smallint_to_bool)
+        opts.has_key?(:convert_smallint_to_bool) ? opts[:convert_smallint_to_bool] : db.convert_smallint_to_bool
       end
 
-      # Override the default SqlAnywhere.convert_smallint_to_bool setting for this dataset.
-      attr_writer :convert_smallint_to_bool
+      # Return a cloned dataset with the convert_smallint_to_bool option set.
+      def with_convert_smallint_to_bool(v)
+        clone(:convert_smallint_to_bool=>v)
+      end
 
       def supports_cte?(type=:select)
         type == :select || type == :insert
@@ -424,7 +437,7 @@ module Sequel
         string.gsub(/[\\%_\[]/){|m| "\\#{m}"}
       end
 
-      # Use Date() and Now() for CURRENT_DATE and CURRENT_TIMESTAMP
+      # Use today() and Now() for CURRENT_DATE and CURRENT_TIMESTAMP
       def constant_sql_append(sql, constant)
         case constant
         when :CURRENT_DATE

data/lib/sequel/adapters/shared/sqlite.rb

@@ -20,12 +20,14 @@ module Sequel
 
       PRIMARY_KEY_INDEX_RE = /\Asqlite_autoindex_/.freeze
       Sequel::Deprecation.deprecate_constant(self, :PRIMARY_KEY_INDEX_RE)
+      TABLES_FILTER = Sequel.~(:name=>'sqlite_sequence'.freeze) & {:type => 'table'.freeze}
+      Sequel::Deprecation.deprecate_constant(self, :TABLES_FILTER)
+      VIEWS_FILTER = {:type => 'view'.freeze}.freeze
+      Sequel::Deprecation.deprecate_constant(self, :VIEWS_FILTER)
 
       AUTO_VACUUM = [:none, :full, :incremental].freeze
       SYNCHRONOUS = [:off, :normal, :full].freeze
-      TABLES_FILTER = Sequel.~(:name=>'sqlite_sequence'.freeze) & {:type => 'table'.freeze}
       TEMP_STORE = [:default, :file, :memory].freeze
-      VIEWS_FILTER = {:type => 'view'.freeze}.freeze
       TRANSACTION_MODE = {
         :deferred => "BEGIN DEFERRED TRANSACTION".freeze,
         :immediate => "BEGIN IMMEDIATE TRANSACTION".freeze,
@@ -37,26 +39,6 @@ module Sequel
       # booleans be stored as integers, but historically Sequel has used 't'/'f'.
       attr_accessor :integer_booleans
 
-      # A symbol signifying the value of the auto_vacuum PRAGMA.
-      def auto_vacuum
-        AUTO_VACUUM[pragma_get(:auto_vacuum).to_i]
-      end
-      
-      # Set the auto_vacuum PRAGMA using the given symbol (:none, :full, or
-      # :incremental).  See pragma_set.  Consider using the :auto_vacuum
-      # Database option instead.
-      def auto_vacuum=(value)
-        value = AUTO_VACUUM.index(value) || (raise Error, "Invalid value for auto_vacuum option. Please specify one of :none, :full, :incremental.")
-        pragma_set(:auto_vacuum, value)
-      end
-
-      # Set the case_sensitive_like PRAGMA using the given boolean value, if using
-      # SQLite 3.2.3+.  If not using 3.2.3+, no error is raised. See pragma_set.
-      # Consider using the :case_sensitive_like Database option instead.
-      def case_sensitive_like=(value)
-        pragma_set(:case_sensitive_like, !!value ? 'on' : 'off') if sqlite_version >= 30203
-      end
-
       # A symbol signifying the value of the default transaction mode
       attr_reader :transaction_mode
 
@@ -74,18 +56,50 @@ module Sequel
         :sqlite
       end
       
-      # Boolean signifying the value of the foreign_keys PRAGMA, or nil
-      # if not using SQLite 3.6.19+.
+      # SEQUEL5: Remove
+      def auto_vacuum
+        AUTO_VACUUM[pragma_get(:auto_vacuum).to_i]
+      end
+      def auto_vacuum=(value)
+        value = AUTO_VACUUM.index(value) || (raise Error, "Invalid value for auto_vacuum option. Please specify one of :none, :full, :incremental.")
+        pragma_set(:auto_vacuum, value)
+      end
+      def case_sensitive_like=(value)
+        pragma_set(:case_sensitive_like, !!value ? 'on' : 'off') if sqlite_version >= 30203
+      end
       def foreign_keys
         pragma_get(:foreign_keys).to_i == 1 if sqlite_version >= 30619
       end
-      
-      # Set the foreign_keys PRAGMA using the given boolean value, if using
-      # SQLite 3.6.19+.  If not using 3.6.19+, no error is raised. See pragma_set.
-      # Consider using the :foreign_keys Database option instead.
       def foreign_keys=(value)
         pragma_set(:foreign_keys, !!value ? 'on' : 'off') if sqlite_version >= 30619
       end
+      def pragma_get(name)
+        Sequel::Deprecation.deprecate('Database#{pragma_get,auto_vacuum,case_sensitive_like,foreign_keys,synchronous,temp_store} on SQLite', "These methods may not be safe when using multiple connections, call fetch(#{"PRAGMA #{name}".inspect}).single_value if you really want to get the pragma value")
+        self["PRAGMA #{name}"].single_value
+      end
+      def pragma_set(name, value)
+        Sequel::Deprecation.deprecate('Database#{pragma_set,auto_vacuum=,case_sensitive_like=,foreign_keys=,synchronous=,temp_store=} on SQLite', "These methods are not thread safe or safe when using multiple connections, pass the appropriate option when connecting to set the pragma correctly for all connections")
+        execute_ddl("PRAGMA #{name} = #{value}")
+      end
+      def synchronous
+        SYNCHRONOUS[pragma_get(:synchronous).to_i]
+      end
+      def synchronous=(value)
+        value = SYNCHRONOUS.index(value) || (raise Error, "Invalid value for synchronous option. Please specify one of :off, :normal, :full.")
+        pragma_set(:synchronous, value)
+      end
+      def temp_store
+        TEMP_STORE[pragma_get(:temp_store).to_i]
+      end
+      def temp_store=(value)
+        value = TEMP_STORE.index(value) || (raise Error, "Invalid value for temp_store option. Please specify one of :default, :file, :memory.")
+        pragma_set(:temp_store, value)
+      end
+
+      # Set the integer_booleans option using the passed in :integer_boolean option.
+      def set_integer_booleans
+        @integer_booleans = @opts.has_key?(:integer_booleans) ? typecast_value_boolean(@opts[:integer_booleans]) : true
+      end
 
       # Return the array of foreign key info hashes using the foreign_key_list PRAGMA,
       # including information for the :on_update and :on_delete entries.
@@ -115,8 +129,18 @@ module Sequel
         im = input_identifier_meth
         indexes = {}
         metadata_dataset.with_sql("PRAGMA index_list(?)", im.call(table)).each do |r|
-          # :only_autocreated internal option can be used to get only autocreated indexes
-          next if (!!(r[:name] =~ /\Asqlite_autoindex_/) ^ !!opts[:only_autocreated])
+          if opts[:only_autocreated]
+            # If specifically asked for only autocreated indexes, then return those an only those
+            next unless r[:name] =~ /\Asqlite_autoindex_/
+          elsif r.has_key?(:origin)
+            # If origin is set, then only exclude primary key indexes and partial indexes
+            next if r[:origin] == 'pk'
+            next if r[:partial].to_i == 1
+          else
+            # When :origin key not present, assume any autoindex could be a primary key one and exclude it
+            next if r[:name] =~ /\Asqlite_autoindex_/
+          end
+
           indexes[m.call(r[:name])] = {:unique=>r[:unique].to_i==1}
         end
         indexes.each do |k, v|
@@ -125,28 +149,6 @@ module Sequel
         indexes
       end
 
-      # Get the value of the given PRAGMA.
-      def pragma_get(name)
-        Sequel::Deprecation.deprecate('Database#{pragma_get,auto_vacuum,case_sensitive_like,foreign_keys,synchronous,temp_store} on SQLite', "These methods may not be safe when using multiple connections, call fetch(#{"PRAGMA #{name}".inspect}).single_value if you really want to get the pragma value")
-        self["PRAGMA #{name}"].single_value
-      end
-      
-      # Set the value of the given PRAGMA to value.
-      #
-      # This method is not thread safe, and will not work correctly if there
-      # are multiple connections in the Database's connection pool. PRAGMA
-      # modifications should be done when the connection is created, using
-      # an option provided when creating the Database object.
-      def pragma_set(name, value)
-        Sequel::Deprecation.deprecate('Database#{pragma_set,auto_vacuum=,case_sensitive_like=,foreign_keys=,synchronous=,temp_store=} on SQLite', "These methods are not thread safe or safe when using multiple connections, pass the appropriate option when connecting to set the pragma correctly for all connections")
-        execute_ddl("PRAGMA #{name} = #{value}")
-      end
-
-      # Set the integer_booleans option using the passed in :integer_boolean option.
-      def set_integer_booleans
-        @integer_booleans = @opts.has_key?(:integer_booleans) ? typecast_value_boolean(@opts[:integer_booleans]) : true
-      end
-      
       # The version of the server as an integer, where 3.6.19 = 30619.
       # If the server version can't be determined, 0 is used.
       def sqlite_version
@@ -190,36 +192,12 @@ module Sequel
         defined?(@use_timestamp_timezones) ? @use_timestamp_timezones : (@use_timestamp_timezones = false)
       end
 
-      # A symbol signifying the value of the synchronous PRAGMA.
-      def synchronous
-        SYNCHRONOUS[pragma_get(:synchronous).to_i]
-      end
-      
-      # Set the synchronous PRAGMA using the given symbol (:off, :normal, or :full). See pragma_set.
-      # Consider using the :synchronous Database option instead.
-      def synchronous=(value)
-        value = SYNCHRONOUS.index(value) || (raise Error, "Invalid value for synchronous option. Please specify one of :off, :normal, :full.")
-        pragma_set(:synchronous, value)
-      end
-      
       # Array of symbols specifying the table names in the current database.
       #
       # Options:
       # :server :: Set the server to use.
       def tables(opts=OPTS)
-        tables_and_views(TABLES_FILTER, opts)
-      end
-      
-      # A symbol signifying the value of the temp_store PRAGMA.
-      def temp_store
-        TEMP_STORE[pragma_get(:temp_store).to_i]
-      end
-      
-      # Set the temp_store PRAGMA using the given symbol (:default, :file, or :memory). See pragma_set.
-      # Consider using the :temp_store Database option instead.
-      def temp_store=(value)
-        value = TEMP_STORE.index(value) || (raise Error, "Invalid value for temp_store option. Please specify one of :default, :file, :memory.")
-        pragma_set(:temp_store, value)
+        tables_and_views(Sequel.~(:name=>'sqlite_sequence') & {:type => 'table'}, opts)
       end
       
       # Creates a dataset that uses the VALUES clause:
@@ -235,7 +213,7 @@ module Sequel
       # Options:
       # :server :: Set the server to use.
       def views(opts=OPTS)
-        tables_and_views(VIEWS_FILTER, opts)
+        tables_and_views({:type => 'view'}, opts)
       end
 
       private
@@ -438,8 +416,12 @@ module Sequel
 
         # Determine unique constraints and make sure the new columns have them
         unique_columns = []
-        indexes(table, :only_autocreated=>true).each_value do |h|
-          unique_columns.concat(h[:columns]) if h[:columns].length == 1 && h[:unique]
+        skip_indexes = []
+        indexes(table, :only_autocreated=>true).each do |name, h|
+          skip_indexes << name
+          if h[:columns].length == 1 && h[:unique]
+            unique_columns.concat(h[:columns])
+          end
         end
         unique_columns -= pks
         unless unique_columns.empty?
@@ -462,6 +444,7 @@ module Sequel
            "DROP TABLE #{bt}"
         ]
         indexes(table).each do |name, h|
+          next if skip_indexes.include?(name)
           if (h[:columns].map(&:to_s) - new_columns).empty?
             a << alter_table_sql(table, h.merge(:op=>:add_index, :name=>name))
           end
@@ -471,7 +454,7 @@ module Sequel
 
       # Does the reverse of on_delete_clause, eg. converts strings like +'SET NULL'+
       # to symbols +:set_null+.
-      def on_delete_sql_to_sym str
+      def on_delete_sql_to_sym(str)
         case str
         when 'RESTRICT'
           :restrict
@@ -549,6 +532,9 @@ module Sequel
       include Dataset::Replace
       include UnmodifiedIdentifiers::DatasetMethods
 
+      # The allowed values for insert_conflict
+      INSERT_CONFLICT_RESOLUTIONS = %w'ROLLBACK ABORT FAIL IGNORE REPLACE'.each(&:freeze).freeze
+
       CONSTANT_MAP = {:CURRENT_DATE=>"date(CURRENT_TIMESTAMP, 'localtime')".freeze, :CURRENT_TIMESTAMP=>"datetime(CURRENT_TIMESTAMP, 'localtime')".freeze, :CURRENT_TIME=>"time(CURRENT_TIMESTAMP, 'localtime')".freeze}#.freeze # SEQUEL5
       EXTRACT_MAP = {:year=>"'%Y'", :month=>"'%m'", :day=>"'%d'", :hour=>"'%H'", :minute=>"'%M'", :second=>"'%f'"}#.freeze # SEQUEL5
       #EXTRACT_MAP.each_value(&:freeze) # SEQUEL5
@@ -676,7 +662,7 @@ module Sequel
       end
       
       # Return an array of strings specifying a query explanation for a SELECT of the
-      # current dataset. Currently, the options are ignore, but it accepts options
+      # current dataset. Currently, the options are ignored, but it accepts options
       # to be compatible with other adapters.
       def explain(opts=nil)
         # Load the PrettyTable class, needed for explain output
@@ -723,6 +709,10 @@ module Sequel
       #   DB[:table].insert_conflict(:replace).insert(:a=>1, :b=>2)
       #   # INSERT OR REPLACE INTO TABLE (a, b) VALUES (1, 2)
       def insert_conflict(resolution = :ignore)
+        unless INSERT_CONFLICT_RESOLUTIONS.include?(resolution.to_s.upcase)
+          Sequel::Deprecation.deprecate("Passing #{resolution.inspect} argument to Dataset#insert_conflict", "The allowed values are: :rollback, :abort, :fail, :ignore, or :replace")
+          # raise Error, "Invalid value passed to Dataset#insert_conflict: #{resolution.inspect}.  The allowed values are: :rollback, :abort, :fail, :ignore, or :replace"
+        end
         clone(:insert_conflict => resolution)
       end
 

data/lib/sequel/adapters/sqlanywhere.rb

@@ -19,7 +19,7 @@ module Sequel
       end
     end
 
-    TYPE_TRANSLATOR = tt = Class.new do
+    tt = Class.new do
       def blob(s) ::Sequel::SQL::Blob.new(s) end
       def boolean(s) s.to_i != 0 end
       def date(s) ::Date.strptime(s) end
@@ -27,6 +27,9 @@ module Sequel
       def time(s) ::Sequel.string_to_time(s) end
     end.new
 
+    TYPE_TRANSLATOR = tt
+    Sequel::Deprecation.deprecate_constant(self, :TYPE_TRANSLATOR)
+
     SQLANYWHERE_TYPES = {}
     {
         [0, 484] => tt.method(:decimal),

data/lib/sequel/adapters/sqlite.rb

@@ -7,9 +7,9 @@ module Sequel
   # Top level module for holding all SQLite-related modules and classes
   # for Sequel.
   module SQLite
-    TYPE_TRANSLATOR = tt = Class.new do
-      FALSE_VALUES = (%w'0 false f no n' + [0]).freeze
+    FALSE_VALUES = (%w'0 false f no n' + [0]).freeze
 
+    tt = Class.new do
       def blob(s)
         Sequel::SQL::Blob.new(s.to_s)
       end
@@ -58,9 +58,11 @@ module Sequel
           raise Sequel::Error, "unhandled type when converting to date: #{s.inspect} (#{s.class.inspect})"
         end
       end
-
     end.new
 
+    TYPE_TRANSLATOR = tt
+    Sequel::Deprecation.deprecate_constant(self, :TYPE_TRANSLATOR)
+
     # Hash with string keys and callable values for converting SQLite types.
     SQLITE_TYPES = {}
     {

data/lib/sequel/adapters/swift/postgres.rb

@@ -4,8 +4,6 @@ require 'swift/db/postgres'
 Sequel.require 'adapters/shared/postgres'
 
 module Sequel
-  Postgres::CONVERTED_EXCEPTIONS << ::Swift::Error
-  
   module Swift
     # Adapter, Database, and Dataset support for accessing a PostgreSQL
     # database via Swift.
@@ -23,6 +21,11 @@ module Sequel
         
         private
         
+        DATABASE_ERROR_CLASSES = [::Swift::Error].freeze
+        def database_error_classes
+          DATABASE_ERROR_CLASSES
+        end
+
         # Remove all other options except for ones specifically handled, as
         # otherwise swift passes them to dbic++ which passes them to PostgreSQL
         # which can raise an error.

data/lib/sequel/adapters/tinytds.rb

@@ -188,14 +188,11 @@ module Sequel
       Database::DatasetClass = self
       Sequel::Deprecation.deprecate_constant(Database, :DatasetClass)
       
-      # SQLite already supports named bind arguments, so use directly.
       module ArgumentMapper
         include Sequel::Dataset::ArgumentMapper
         
         protected
         
-        # Return a hash with the same values as the given hash,
-        # but with the keys converted to strings.
         def map_to_prepared_args(hash)
           args = {}
           hash.each{|k,v| args[k.to_s.gsub('.', '__')] = v}
@@ -204,8 +201,6 @@ module Sequel
         
         private
         
-        # SQLite uses a : before the name of the argument for named
-        # arguments.
         def prepared_arg(k)
           LiteralString.new("@#{k.to_s.gsub('.', '__')}")
         end

data/lib/sequel/adapters/utils/mysql_mysql2.rb

@@ -18,7 +18,7 @@ module Sequel
         closed MySQL connection
         END
         # Error messages for mysql and mysql2 that indicate the current connection should be disconnected
-        MYSQL_DATABASE_DISCONNECT_ERRORS = /\A#{Regexp.union(disconnect_errors)}/o
+        MYSQL_DATABASE_DISCONNECT_ERRORS = /\A#{Regexp.union(disconnect_errors)}/
        
         # Support stored procedures on MySQL
         def call_sproc(name, opts=OPTS, &block)

data/lib/sequel/adapters/utils/pg_types.rb

@@ -1,78 +1,4 @@
 # frozen-string-literal: true
 
-module Sequel
-  module Postgres
-    NAN             = 0.0/0.0
-    PLUS_INFINITY   = 1.0/0.0
-    MINUS_INFINITY  = -1.0/0.0
-
-    NAN_STR             = 'NaN'.freeze
-    Sequel::Deprecation.deprecate_constant(self, :NAN_STR)
-    PLUS_INFINITY_STR   = 'Infinity'.freeze
-    Sequel::Deprecation.deprecate_constant(self, :PLUS_INFINITY_STR)
-    MINUS_INFINITY_STR  = '-Infinity'.freeze
-    Sequel::Deprecation.deprecate_constant(self, :MINUS_INFINITY_STR)
-    TRUE_STR = 't'.freeze
-    Sequel::Deprecation.deprecate_constant(self, :TRUE_STR)
-    DASH_STR = '-'.freeze
-    Sequel::Deprecation.deprecate_constant(self, :DASH_STR)
-    
-    TYPE_TRANSLATOR = tt = Class.new do
-      def boolean(s) s == 't' end
-      def integer(s) s.to_i end
-      def float(s) 
-        case s
-        when 'NaN'
-          NAN
-        when 'Infinity'
-          PLUS_INFINITY
-        when '-Infinity'
-          MINUS_INFINITY
-        else
-          s.to_f 
-        end
-      end
-      def date(s) ::Date.new(*s.split('-').map(&:to_i)) end
-      def bytea(str)
-        str = if str =~ /\A\\x/
-          # PostgreSQL 9.0+ bytea hex format
-          str[2..-1].gsub(/(..)/){|s| s.to_i(16).chr}
-        else
-          # Historical PostgreSQL bytea escape format
-          str.gsub(/\\(\\|'|[0-3][0-7][0-7])/) {|s|
-            if s.size == 2 then s[1,1] else s[1,3].oct.chr end
-          }
-        end
-        ::Sequel::SQL::Blob.new(str)
-      end
-    end.new
-
-    # Type OIDs for string types used by PostgreSQL.  These types don't
-    # have conversion procs associated with them (since the data is
-    # already in the form of a string).
-    STRING_TYPES = [18, 19, 25, 1042, 1043]#.freeze # SEQUEL5
-
-    # Hash with type name strings/symbols and callable values for converting PostgreSQL types.
-    # Non-builtin types that don't have fixed numbers should use this to register
-    # conversion procs.
-    PG_NAMED_TYPES = {} unless defined?(PG_NAMED_TYPES)
-    PG_NAMED__TYPES = PG_NAMED_TYPES
-    Sequel::Deprecation.deprecate_constant(self, :PG_NAMED_TYPES)
-
-    # Hash with integer keys and callable values for converting PostgreSQL types.
-    PG_TYPES = {} unless defined?(PG_TYPES)
-
-    {
-      [16] => tt.method(:boolean),
-      [17] => tt.method(:bytea),
-      [20, 21, 23, 26] => tt.method(:integer),
-      [700, 701] => tt.method(:float),
-      [1700] => ::BigDecimal.method(:new),
-      [1083, 1266] => ::Sequel.method(:string_to_time),
-      [1082] => ::Sequel.method(:string_to_date),
-      [1184, 1114] => ::Sequel.method(:database_to_application_timestamp),
-    }.each do |k,v|
-      k.each{|n| PG_TYPES[n] = v}
-    end
-  end
-end 
+Sequel::Deprecation.deprecate("requiring sequel/adapters/utils/pg_types", "This file should no longer be required, use Database#conversion_procs to modify conversion procs for a Database instance")
+Sequel.require 'adapters/shared/postgres'