sequel 4.49.0 → 5.0.0

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

@@ -1,50 +0,0 @@
-# frozen-string-literal: true
-
-require 'swift/db/mysql'
-Sequel.require 'adapters/shared/mysql'
-
-module Sequel
-  module Swift
-    # Database and Dataset instance methods for MySQL specific
-    # support via Swift.
-    module MySQL
-      # Database instance methods for MySQL databases accessed via Swift.
-      module DatabaseMethods
-        include Sequel::MySQL::DatabaseMethods
-        
-        private
-        
-        # The database name for the given database.
-        def database_name
-          opts[:database]
-        end
-
-        # Consider tinyint(1) columns as boolean.
-        def schema_column_type(db_type)
-          db_type =~ /\Atinyint\(1\)/ ? :boolean : super
-        end
-      
-        # Apply the connectiong setting SQLs for every new connection.
-        def setup_connection(conn)
-          mysql_connection_setting_sqls.each{|sql| log_connection_yield(sql, conn){conn.execute(sql)}}
-          super
-        end
-      end
-      
-      # Dataset class for MySQL datasets accessed via Swift.
-      class Dataset < Swift::Dataset
-        include Sequel::MySQL::DatasetMethods
-
-        APOS = "'".freeze
-        Sequel::Deprecation.deprecate_constant(self, :APOS)
-        
-        private
-        
-        # Use Swift's escape method for quoting.
-        def literal_string_append(sql, s)
-          sql << "'" << db.synchronize(@opts[:server]){|c| c.escape(s)} << "'"
-        end
-      end
-    end
-  end
-end

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

@@ -1,49 +0,0 @@
-# frozen-string-literal: true
-
-require 'swift/db/postgres'
-Sequel.require 'adapters/shared/postgres'
-
-module Sequel
-  module Swift
-    # Adapter, Database, and Dataset support for accessing a PostgreSQL
-    # database via Swift.
-    module Postgres
-      # Methods to add to Database instances that access PostgreSQL via Swift.
-      module DatabaseMethods
-        include Sequel::Postgres::DatabaseMethods
-        
-        # Add the primary_keys and primary_key_sequences instance variables,
-        # so we can get the correct return values for inserted rows.
-        def self.extended(db)
-          super
-          db.send(:initialize_postgres_adapter)
-        end
-        
-        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.
-        def server_opts(o)
-          o = super
-          so = {}
-          [:db, :user, :password, :host, :port].each{|s| so[s] = o[s] if o.has_key?(s)}
-          so
-        end
-      
-        # Extend the adapter with the Swift PostgreSQL AdapterMethods.
-        def setup_connection(conn)
-          conn = super(conn)
-          conn.native_bind_format = true
-          connection_configuration_sqls.each{|sql| log_connection_yield(sql, conn){conn.execute(sql)}}
-          conn
-        end
-      end
-    end
-  end
-end

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

@@ -1,48 +0,0 @@
-# frozen-string-literal: true
-
-require 'swift/db/sqlite3'
-Sequel.require 'adapters/shared/sqlite'
-
-module Sequel
-  module Swift
-    # Database and Dataset instance methods for SQLite specific
-    # support via Swift.
-    module SQLite
-      # Database instance methods for SQLite databases accessed via Swift.
-      module DatabaseMethods
-        include Sequel::SQLite::DatabaseMethods
-
-        DATABASE_ERROR_REGEXPS = {
-          /\AUNIQUE constraint failed: / => UniqueConstraintViolation,
-          /\AFOREIGN KEY constraint failed/ => ForeignKeyConstraintViolation,
-          /\ACHECK constraint failed/ => CheckConstraintViolation,
-          /\A(SQLITE ERROR 19 \(CONSTRAINT\) : )?constraint failed/ => ConstraintViolation,
-          /may not be NULL\z|NOT NULL constraint failed: .+/ => NotNullConstraintViolation,
-          /\ASQLITE ERROR \d+ \(\) : CHECK constraint failed: / => CheckConstraintViolation
-        }.freeze
-        def database_error_regexps
-          DATABASE_ERROR_REGEXPS
-        end
-
-        # Set the correct pragmas on the connection.
-        def connect(opts)
-          c = super
-          connection_pragmas.each{|s| log_connection_yield(s, c){c.execute(s)}}
-          c
-        end
-      end
-      
-      # Dataset class for SQLite datasets accessed via Swift.
-      class Dataset < Swift::Dataset
-        include Sequel::SQLite::DatasetMethods
-        
-        private
-        
-        # Use Swift's escape method for quoting.
-        def literal_string_append(sql, s)
-          sql << "'" << db.synchronize(@opts[:server]){|c| c.escape(s)} << "'"
-        end
-      end
-    end
-  end
-end

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

@@ -1,4 +0,0 @@
-# frozen-string-literal: true
-
-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'

data/lib/sequel/dataset/mutation.rb

@@ -1,98 +0,0 @@
-# frozen-string-literal: true
-
-module Sequel
-  class Dataset
-    # ---------------------
-    # :section: 7 - Mutation methods
-    # These methods modify the receiving dataset and should be used with care.
-    # ---------------------
-    
-    # All methods that should have a ! method added that modifies the receiver.
-    MUTATION_METHODS = QUERY_METHODS - [:naked, :from_self]
-    Sequel::Deprecation.deprecate_constant(self, :MUTATION_METHODS)
-    
-    # Setup mutation (e.g. filter!) methods.  These operate the same as the
-    # non-! methods, but replace the options of the current dataset with the
-    # options of the resulting dataset.
-    #
-    # Do not call this method with untrusted input, as that can result in
-    # arbitrary code execution.
-    def self.def_mutation_method(*meths)
-      options = meths.pop if meths.last.is_a?(Hash)
-      mod = options[:module] if options
-      mod ||= self
-      meths.each do |meth|
-        mod.class_eval("def #{meth}!(*args, &block); mutation_method(:#{meth}, *args, &block) end", __FILE__, __LINE__)
-      end
-    end
-    
-    # Add the mutation methods via metaprogramming
-    def_mutation_method(*(QUERY_METHODS - [:naked, :from_self]))
-    
-    # Like #extension, but modifies and returns the receiver instead of returning a modified clone.
-    def extension!(*exts)
-      raise_if_frozen!(%w"extension! extension")
-      _extension!(exts)
-    end
-
-    # Avoid self-referential dataset by cloning.
-    def from_self!(*args, &block)
-      raise_if_frozen!(%w"from_self! from_self")
-      @opts = clone.from_self(*args, &block).opts
-      self
-    end
-
-    # Remove the row_proc from the current dataset.
-    def naked!
-      raise_if_frozen!(%w"naked! naked")
-      @opts[:row_proc] = nil
-      self
-    end
-    
-    # Set whether to quote identifiers for this dataset
-    def quote_identifiers=(v)
-      raise_if_frozen!(%w"quote_identifiers= with_quote_identifiers")
-      skip_symbol_cache!
-      @opts[:quote_identifiers] = v
-    end
-
-    # Override the row_proc for this dataset
-    def row_proc=(v)
-      raise_if_frozen!(%w"row_proc= with_row_proc")
-      @opts[:row_proc] = v
-    end
-    
-    private
-    
-    # Modify the receiver with the results of sending the meth, args, and block
-    # to the receiver and merging the options of the resulting dataset into
-    # the receiver's options.
-    def mutation_method(meth, *args, &block)
-      raise_if_frozen!(["#{meth}!", meth])
-      @opts = send(meth, *args, &block).opts
-      @cache = {}
-      self
-    end
-
-    # Raise a RuntimeError if the receiver is frozen
-    def raise_if_frozen!(meth = nil)
-      if frozen?
-        raise RuntimeError, "can't modify frozen #{visible_class_name}"
-      end
-      case meth
-      when Array
-        meth = " (method called: #{meth.first}, non-mutating replacement: #{meth.last})"
-      when String
-        # :nocov:
-        meth = " (method called: #{meth})"
-        # :nocov:
-      end
-      Sequel::Deprecation.deprecate("Dataset mutation is deprecated and will be removed in Sequel 5#{meth}")
-    end
-
-    # Set the dataset to skip the symbol cache
-    def skip_symbol_cache!
-      @opts[:skip_symbol_cache] = true
-    end
-  end
-end

data/lib/sequel/extensions/_deprecated_identifier_mangling.rb

@@ -1,117 +0,0 @@
-# frozen-string-literal: true
-
-#
-module Sequel
-  module DeprecatedIdentifierMangling
-    module DatabaseMethods
-      def self.extended(db)
-        db.instance_exec do
-          @identifier_input_method = nil
-          @identifier_output_method = nil
-          @quote_identifiers = nil
-          reset_identifier_mangling
-          extend_datasets(DatasetMethods)
-        end
-      end
-
-      attr_reader :identifier_input_method
-      attr_reader :identifier_output_method
-
-      def identifier_input_method=(v)
-        Sequel::Deprecation.deprecate("Database#identifier_input_method=", "Explicitly load the identifier_mangling extension if you would like to use this")
-        reset_default_dataset
-        @identifier_input_method = v
-      end
-      
-      def identifier_output_method=(v)
-        Sequel::Deprecation.deprecate("Database#identifier_output_method=", "Explicitly load the identifier_mangling extension if you would like to use this")
-        reset_default_dataset
-        @identifier_output_method = v
-      end
-
-      def quote_identifiers=(v)
-        Sequel::Deprecation.deprecate("Database#quote_identifiers=", "Explicitly load the identifier_mangling extension if you would like to use this")
-        reset_default_dataset
-        @quote_identifiers = v
-      end
-      
-      def quote_identifiers?
-        @quote_identifiers
-      end
-
-      private
-
-      def _metadata_dataset
-        super.clone(:identifier_input_method=>identifier_input_method_default, :identifier_output_method=>identifier_output_method_default, :skip_symbol_cache=>true)
-      end
-
-      def identifier_input_method_default
-        return super if defined?(super)
-        :upcase if folds_unquoted_identifiers_to_uppercase?
-      end
-
-      def identifier_output_method_default
-        return super if defined?(super)
-        :downcase if folds_unquoted_identifiers_to_uppercase?
-      end
-
-      def reset_identifier_mangling
-        @quote_identifiers = @opts.fetch(:quote_identifiers){(qi = Database.quote_identifiers).nil? ? quote_identifiers_default : qi}
-        @identifier_input_method = @opts.fetch(:identifier_input_method){(iim = Database.identifier_input_method).nil? ? identifier_input_method_default : (iim if iim)}
-        @identifier_output_method = @opts.fetch(:identifier_output_method){(iom = Database.identifier_output_method).nil? ? identifier_output_method_default : (iom if iom)}
-        reset_default_dataset
-      end
-    end
-
-    module DatasetMethods
-      def identifier_input_method
-        @opts.fetch(:identifier_input_method, db.identifier_input_method)
-      end
-      
-      def identifier_input_method=(v)
-        Sequel::Deprecation.deprecate("Dataset#identifier_input_method=", "Explicitly load the identifier_mangling extension if you would like to use this")
-        raise_if_frozen!(%w"identifier_input_method= with_identifier_input_method")
-        skip_symbol_cache!
-        @opts[:identifier_input_method] = v
-      end
-      
-      def identifier_output_method
-        @opts.fetch(:identifier_output_method, db.identifier_output_method)
-      end
-    
-      def identifier_output_method=(v)
-        Sequel::Deprecation.deprecate("Dataset#identifier_output_method=", "Explicitly load the identifier_mangling extension if you would like to use this")
-        raise_if_frozen!(%w"identifier_output_method= with_identifier_output_method")
-        @opts[:identifier_output_method] = v
-      end
-
-      def quote_identifiers?
-        @opts.fetch(:quote_identifiers, db.quote_identifiers?)
-      end
-
-      def with_identifier_input_method(meth)
-        Sequel::Deprecation.deprecate("Dataset#with_identifier_input_method", "Explicitly load the identifier_mangling extension if you would like to use this")
-        clone(:identifier_input_method=>meth, :skip_symbol_cache=>true)
-      end
-
-      def with_identifier_output_method(meth)
-        Sequel::Deprecation.deprecate("Dataset#with_identifier_output_method", "Explicitly load the identifier_mangling extension if you would like to use this")
-        clone(:identifier_output_method=>meth)
-      end
-      
-      private
-
-      def input_identifier(v)
-        (i = identifier_input_method) ? v.to_s.send(i) : v.to_s
-      end
-
-      def output_identifier(v)
-        v = 'untitled' if v == ''
-        (i = identifier_output_method) ? v.to_s.send(i).to_sym : v.to_sym
-      end
-    end
-  end
-
-  Database.register_extension(:_deprecated_identifier_mangling, DeprecatedIdentifierMangling::DatabaseMethods)
-end
-

data/lib/sequel/extensions/empty_array_ignore_nulls.rb

@@ -1,8 +0,0 @@
-# frozen-string-literal: true
-#
-# This only exists for backwards compatibility, as the behavior
-# added by this extension is now the default Sequel behavior. 
-
-Sequel::Deprecation.deprecate("The empty_array_ignore_nulls", "It has been a no-op since 4.25.0")
-
-Sequel::Dataset.register_extension(:empty_array_ignore_nulls){}

data/lib/sequel/extensions/filter_having.rb

@@ -1,65 +0,0 @@
-# frozen-string-literal: true
-#
-# The filter_having extension allows Dataset#filter, #and, #or
-# and #exclude to operate on the HAVING clause if the dataset
-# already has a HAVING clause, which was the historical behavior
-# before Sequel 4.  It is only recommended to use this for
-# backwards compatibility.
-#
-# You can load this extension into specific datasets:
-#
-#   ds = DB[:table]
-#   ds = ds.extension(:filter_having)
-#
-# Or you can load it into all of a database's datasets, which
-# is probably the desired behavior if you are using this extension:
-#
-#   DB.extension(:filter_having)
-#
-# Related module: Sequel::FilterHaving
-
-Sequel::Deprecation.deprecate("The filter_having extension", "Please consider maintaining it yourself as an external gem if you want to continue using it")
-
-#
-module Sequel
-  module FilterHaving
-    # Operate on HAVING clause if HAVING clause already present.
-    def and(*cond, &block)
-      if @opts[:having]
-        having(*cond, &block)
-      else
-        super
-      end
-    end
-
-    # Operate on HAVING clause if HAVING clause already present.
-    def exclude(*cond, &block)
-      if @opts[:having]
-        exclude_having(*cond, &block)
-      else
-        super
-      end
-    end
-
-    # Operate on HAVING clause if HAVING clause already present.
-    def filter(*cond, &block)
-      if @opts[:having]
-        having(*cond, &block)
-      else
-        super
-      end
-    end
-
-    # Operate on HAVING clause if HAVING clause already present.
-    def or(*cond, &block)
-      if having = @opts[:having]
-        cond = cond.first if cond.size == 1
-        clone(:having => SQL::BooleanExpression.new(:OR, having, filter_expr(cond, &block)))
-      else
-        super
-      end
-    end
-  end
-
-  Dataset.register_extension(:filter_having, FilterHaving)
-end