sequel 4.49.0 → 5.3.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/swift.rb

@@ -1,169 +0,0 @@
-# frozen-string-literal: true
-
-Sequel::Deprecation.deprecate("The swift adapter", "Please consider maintaining it yourself as an external gem if you want to continue using it")
-
-module Sequel
-  # Module holding the Swift DB support for Sequel.  Swift DB is a
-  # collection of drivers used in Swift ORM.
-  #
-  # The Swift adapter currently supports PostgreSQL, MySQL and SQLite3
-  #
-  #   Sequel.connect('swift://user:password@host/database?db_type=postgres')
-  #   Sequel.connect('swift://user:password@host/database?db_type=mysql')
-  module Swift
-    # Contains procs keyed on sub adapter type that extend the
-    # given database object so it supports the correct database type.
-    DATABASE_SETUP = {:postgres=>proc do |db|
-        db.extend(Sequel::Swift::Postgres::DatabaseMethods)
-        db.extend_datasets Sequel::Postgres::DatasetMethods
-        db.swift_class = ::Swift::DB::Postgres
-      end,
-      :mysql=>proc do |db|
-        db.extend(Sequel::Swift::MySQL::DatabaseMethods)
-        db.dataset_class = Sequel::Swift::MySQL::Dataset
-        db.swift_class = ::Swift::DB::Mysql
-      end,
-      :sqlite=>proc do |db|
-        db.extend(Sequel::Swift::SQLite::DatabaseMethods)
-        db.dataset_class = Sequel::Swift::SQLite::Dataset
-        db.swift_class = ::Swift::DB::Sqlite3
-        db.set_integer_booleans
-      end,
-    }
-      
-    class Database < Sequel::Database
-      set_adapter_scheme :swift
-
-      # The Swift adapter class being used by this database.  Connections
-      # in this database's connection pool will be instances of this class.
-      attr_accessor :swift_class
-
-      def initialize(opts=OPTS)
-        Sequel.require "adapters/swift/#{opts[:db_type]}" if %w'postgres mysql sqlite'.include?(opts[:db_type].to_s)
-        super
-      end
-      
-      # Create an instance of swift_class for the given options.
-      def connect(server)
-        opts = server_opts(server)
-        opts[:pass] = opts[:password]
-        setup_connection(swift_class.new(opts))
-      end
-      
-      # Execute the given SQL, yielding a Swift::Result if a block is given.
-      def execute(sql, opts=OPTS)
-        synchronize(opts[:server]) do |conn|
-          begin
-            res = log_connection_yield(sql, conn){conn.execute(sql)}
-            yield res if block_given?
-            nil
-          rescue ::Swift::Error => e
-            raise_error(e)
-          end
-        end
-      end
-      
-      # Execute the SQL on the this database, returning the number of affected
-      # rows.
-      def execute_dui(sql, opts=OPTS)
-        synchronize(opts[:server]) do |conn|
-          begin
-            log_connection_yield(sql, conn){conn.execute(sql).affected_rows}
-          rescue ::Swift::Error => e
-            raise_error(e)
-          end
-        end
-      end
-      
-      # Execute the SQL on this database, returning the primary key of the
-      # table being inserted to.
-      def execute_insert(sql, opts=OPTS)
-        synchronize(opts[:server]) do |conn|
-          begin
-            log_connection_yield(sql, conn){conn.execute(sql).insert_id}
-          rescue ::Swift::Error => e
-            raise_error(e)
-          end
-        end
-      end
-      
-      private
-      
-      # Call the DATABASE_SETUP proc directly after initialization,
-      # so the object always uses sub adapter specific code.  Also,
-      # raise an error immediately if the connection doesn't have a
-      # db_type specified, since one is required to include the correct
-      # subadapter.
-      def adapter_initialize
-        if db_type = @opts[:db_type] and !db_type.to_s.empty? 
-          if prok = DATABASE_SETUP[db_type.to_s.to_sym]
-            prok.call(self)
-          else
-            raise(Error, "No :db_type option specified")
-          end
-        else
-          raise(Error, ":db_type option not valid, should be postgres, mysql, or sqlite")
-        end
-      end
-      
-      # Method to call on a statement object to execute SQL that does
-      # not return any rows.
-      def connection_execute_method
-        :execute
-      end
-      
-      def database_error_classes
-        [::Swift::Error]
-      end
-
-      def dataset_class_default
-        Dataset
-      end
-
-      # Set the :db entry to the same as the :database entry, since
-      # Swift uses :db.
-      def server_opts(o)
-        o = super
-        o[:db] ||= o[:database]
-        o
-      end
-      
-      # Allow extending the given connection when it is first created.
-      # By default, just returns the connection.
-      def setup_connection(conn)
-        conn
-      end
-    end
-    
-    class Dataset < Sequel::Dataset
-      Database::DatasetClass = self
-      Sequel::Deprecation.deprecate_constant(Database, :DatasetClass)
-
-      # Set the columns and yield the hashes to the block.
-      def fetch_rows(sql)
-        execute(sql) do |res|
-          col_map = {}
-          self.columns = res.fields.map do |c|
-            col_map[c] = output_identifier(c)
-          end
-          tz = db.timezone if Sequel.application_timezone
-          res.each do |r|
-            h = {}
-            r.each do |k, v|
-              h[col_map[k]] = case v
-              when StringIO
-                SQL::Blob.new(v.read)
-              when DateTime
-                tz ? Sequel.database_to_application_timestamp(Sequel.send(:convert_input_datetime_no_offset, v, tz)) : v
-              else
-                v
-              end
-            end
-            yield h
-          end
-        end
-        self
-      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

data/lib/sequel/extensions/hash_aliases.rb

@@ -1,51 +0,0 @@
-# frozen-string-literal: true
-#
-# The hash_aliases extension allows Dataset#select and Dataset#from
-# to treat a hash argument as an alias specification, with keys
-# being the expressions and values being the aliases, 
-# 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(:hash_aliases)
-#
-# 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(:hash_aliases)
-#
-# Related module: Sequel::HashAliases
-
-Sequel::Deprecation.deprecate("The hash_aliases extension", "Please consider maintaining it yourself as an external gem if you want to continue using it")
-
-#
-module Sequel
-  module HashAliases
-    def from(*source)
-      super(*convert_hash_aliases(source))
-    end
-
-    def select(*columns, &block)
-      virtual_row_columns(columns, block)
-      super(*convert_hash_aliases(columns), &nil)
-    end
-
-    private
-
-    def convert_hash_aliases(columns)
-      m = []
-      columns.each do |i|
-        if i.is_a?(Hash)
-          m.concat(i.map{|k, v| SQL::AliasedExpression.new(k,v)})
-        else
-          m << i
-        end
-      end
-      m
-    end
-  end
-
-  Dataset.register_extension(:hash_aliases, HashAliases)
-end