sequel 4.36.0 → 5.61.0

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

@@ -1,152 +0,0 @@
-# frozen-string-literal: true
-
-Sequel.require %w'shared/mysql utils/stored_procedures', 'adapters'
-
-module Sequel
-  module MySQL
-    # This module is used by the mysql and mysql2 adapters to support
-    # prepared statements and stored procedures.
-    module PreparedStatements
-      module DatabaseMethods
-        disconnect_errors = <<-END.split("\n").map(&:strip)
-        Commands out of sync; you can't run this command now
-        Can't connect to local MySQL server through socket
-        MySQL server has gone away
-        Lost connection to MySQL server during query
-        This connection is still waiting for a result, try again once you have the result
-        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
-       
-        # Support stored procedures on MySQL
-        def call_sproc(name, opts=OPTS, &block)
-          args = opts[:args] || [] 
-          execute("CALL #{name}#{args.empty? ? '()' : literal(args)}", opts.merge(:sproc=>false), &block)
-        end
-        
-        # Executes the given SQL using an available connection, yielding the
-        # connection if the block is given.
-        def execute(sql, opts=OPTS, &block)
-          if opts[:sproc]
-            call_sproc(sql, opts, &block)
-          elsif sql.is_a?(Symbol)
-            execute_prepared_statement(sql, opts, &block)
-          else
-            synchronize(opts[:server]){|conn| _execute(conn, sql, opts, &block)}
-          end
-        end
-        
-        private
-
-        def add_prepared_statements_cache(conn)
-          class << conn
-            attr_accessor :prepared_statements
-          end
-          conn.prepared_statements = {}
-        end
-
-        # Stupid MySQL doesn't use SQLState error codes correctly, mapping
-        # all constraint violations to 23000 even though it recognizes
-        # different types.
-        def database_specific_error_class(exception, opts)
-          case exception.errno
-          when 1048
-            NotNullConstraintViolation
-          when 1062
-            UniqueConstraintViolation
-          when 1451, 1452
-            ForeignKeyConstraintViolation
-          else
-            super
-          end
-        end
-
-        # Executes a prepared statement on an available connection.  If the
-        # prepared statement already exists for the connection and has the same
-        # SQL, reuse it, otherwise, prepare the new statement.  Because of the
-        # usual MySQL stupidity, we are forced to name arguments via separate
-        # SET queries.  Use @sequel_arg_N (for N starting at 1) for these
-        # arguments.
-        def execute_prepared_statement(ps_name, opts, &block)
-          args = opts[:arguments]
-          ps = prepared_statement(ps_name)
-          sql = ps.prepared_sql
-          synchronize(opts[:server]) do |conn|
-            unless conn.prepared_statements[ps_name] == sql
-              _execute(conn, "PREPARE #{ps_name} FROM #{literal(sql)}", opts)
-              conn.prepared_statements[ps_name] = sql
-            end
-            i = 0
-            _execute(conn, "SET " + args.map {|arg| "@sequel_arg_#{i+=1} = #{literal(arg)}"}.join(", "), opts) unless args.empty?
-            opts = opts.merge(:log_sql=>" (#{sql})") if ps.log_sql
-            _execute(conn, "EXECUTE #{ps_name}#{" USING #{(1..i).map{|j| "@sequel_arg_#{j}"}.join(', ')}" unless i == 0}", opts, &block)
-          end
-        end
-      end
-
-      module DatasetMethods
-        include Sequel::Dataset::StoredProcedures
-       
-        # Methods to add to MySQL prepared statement calls without using a
-        # real database prepared statement and bound variables.
-        module CallableStatementMethods
-          # Extend given dataset with this module so subselects inside subselects in
-          # prepared statements work.
-          def subselect_sql_append(sql, ds)
-            ps = ds.to_prepared_statement(:select).clone(:append_sql => sql)
-            ps.extend(CallableStatementMethods)
-            ps = ps.bind(@opts[:bind_vars]) if @opts[:bind_vars]
-            ps.prepared_args = prepared_args
-            ps.prepared_sql
-          end
-        end
-        
-        PreparedStatementMethods = Sequel::Dataset.send(:prepared_statements_module,
-          :prepare_bind,
-          Sequel::Dataset::UnnumberedArgumentMapper) do
-            # Raise a more obvious error if you attempt to call a unnamed prepared statement.
-            def call(*)
-              raise Error, "Cannot call prepared statement without a name" if prepared_statement_name.nil?
-              super
-            end
-        end
-        
-        StoredProcedureMethods = Sequel::Dataset.send(:prepared_statements_module,
-          "sql = @sproc_name; opts = Hash[opts]; opts[:args] = @sproc_args; opts[:sproc] = true",
-          Sequel::Dataset::StoredProcedureMethods, %w'execute execute_dui')
-        
-        # MySQL is different in that it supports prepared statements but not bound
-        # variables outside of prepared statements.  The default implementation
-        # breaks the use of subselects in prepared statements, so extend the
-        # temporary prepared statement that this creates with a module that
-        # fixes it.
-        def call(type, bind_arguments={}, *values, &block)
-          ps = to_prepared_statement(type, values)
-          ps.extend(CallableStatementMethods)
-          ps.call(bind_arguments, &block)
-        end
-        
-        # Store the given type of prepared statement in the associated database
-        # with the given name.
-        def prepare(type, name=nil, *values)
-          ps = to_prepared_statement(type, values)
-          ps.extend(PreparedStatementMethods)
-          if name
-            ps.prepared_statement_name = name
-            db.set_prepared_statement(name, ps)
-          end
-          ps
-        end
-        
-        private
-
-        # Extend the dataset with the MySQL stored procedure methods.
-        def prepare_extend_sproc(ds)
-          ds.extend(StoredProcedureMethods)
-        end
-        
-      end
-    end
-  end
-end

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

@@ -1,40 +0,0 @@
-# frozen-string-literal: true
-
-module Sequel
-  module Progress
-    module DatabaseMethods
-      extend Sequel::Database::ResetIdentifierMangling
-
-      # Progress uses the :progress database type.
-      def database_type
-        :progress
-      end
-    end
-  
-    module DatasetMethods
-      Dataset.def_sql_method(self, :select, %w'select limit distinct columns from join where group order having compounds')
-
-      # Progress requires SQL standard datetimes
-      def requires_sql_standard_datetimes?
-        true
-      end
-
-      # Progress does not support INTERSECT or EXCEPT
-      def supports_intersect_except?
-        false
-      end
-
-      private
-
-      # Progress uses TOP for limit, but it is only supported in Progress 10.
-      # The Progress adapter targets Progress 9, so it silently ignores the option.
-      def select_limit_sql(sql)
-        raise(Error, "OFFSET not supported") if @opts[:offset]
-        # if l = @opts[:limit]
-        #   sql << " TOP "
-        #   literal_append(sql, l)
-        # end
-      end
-    end
-  end
-end

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

@@ -1,49 +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
-        extend Sequel::Database::ResetIdentifierMangling
-        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 = Dataset::APOS
-        
-        private
-        
-        # Use Swift's escape method for quoting.
-        def literal_string_append(sql, s)
-          sql << APOS << db.synchronize(@opts[:server]){|c| c.escape(s)} << APOS
-        end
-      end
-    end
-  end
-end

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

@@ -1,47 +0,0 @@
-# frozen-string-literal: true
-
-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.
-    module Postgres
-      # Methods to add to Database instances that access PostgreSQL via Swift.
-      module DatabaseMethods
-        extend Sequel::Database::ResetIdentifierMangling
-        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
-        
-        # 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,49 +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
-        extend Sequel::Database::ResetIdentifierMangling
-        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 << APOS << db.synchronize(@opts[:server]){|c| c.escape(s)} << APOS
-        end
-      end
-    end
-  end
-end

data/lib/sequel/adapters/swift.rb

@@ -1,160 +0,0 @@
-# frozen-string-literal: true
-
-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|
-        Sequel.require 'adapters/swift/postgres'
-        db.extend(Sequel::Swift::Postgres::DatabaseMethods)
-        db.extend_datasets Sequel::Postgres::DatasetMethods
-        db.swift_class = ::Swift::DB::Postgres
-      end,
-      :mysql=>proc do |db|
-        Sequel.require 'adapters/swift/mysql'
-        db.extend(Sequel::Swift::MySQL::DatabaseMethods)
-        db.dataset_class = Sequel::Swift::MySQL::Dataset
-        db.swift_class = ::Swift::DB::Mysql
-      end,
-      :sqlite=>proc do |db|
-        Sequel.require 'adapters/swift/sqlite'
-        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
-      
-      # 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
-
-      # 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
-
-      # 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,70 +0,0 @@
-# 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
-    PLUS_INFINITY_STR   = 'Infinity'.freeze
-    MINUS_INFINITY_STR  = '-Infinity'.freeze
-    TRUE_STR = 't'.freeze
-    DASH_STR = '-'.freeze
-    
-    TYPE_TRANSLATOR = tt = Class.new do
-      def boolean(s) s == TRUE_STR end
-      def integer(s) s.to_i end
-      def float(s) 
-        case s
-        when NAN_STR
-          NAN
-        when PLUS_INFINITY_STR
-          PLUS_INFINITY
-        when MINUS_INFINITY_STR
-          MINUS_INFINITY
-        else
-          s.to_f 
-        end
-      end
-      def date(s) ::Date.new(*s.split(DASH_STR).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]
-
-    # 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)
-
-    # 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 

data/lib/sequel/dataset/mutation.rb

@@ -1,111 +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]
-    
-    # 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(*MUTATION_METHODS)
-    
-    # The row_proc for this database, should be any object that responds to +call+ with
-    # a single hash argument and returns the object you want #each to return.
-    attr_reader :row_proc
-    
-    # Load an extension into the receiver.  In addition to requiring the extension file, this
-    # also modifies the dataset to work with the extension (usually extending it with a
-    # module defined in the extension file).  If no related extension file exists or the
-    # extension does not have specific support for Database objects, an Error will be raised.
-    # Returns self.
-    def extension!(*exts)
-      raise_if_frozen!
-      Sequel.extension(*exts)
-      exts.each do |ext|
-        if pr = Sequel.synchronize{EXTENSIONS[ext]}
-          pr.call(self)
-        else
-          raise(Error, "Extension #{ext} does not have specific support handling individual datasets (try: Sequel.extension #{ext.inspect})")
-        end
-      end
-      self
-    end
-
-    # Avoid self-referential dataset by cloning.
-    def from_self!(*args, &block)
-      raise_if_frozen!
-      @opts = clone.from_self(*args, &block).opts
-      self
-    end
-
-    # Set the method to call on identifiers going into the database for this dataset
-    def identifier_input_method=(v)
-      raise_if_frozen!
-      skip_symbol_cache!
-      @identifier_input_method = v
-    end
-    
-    # Set the method to call on identifiers coming the database for this dataset
-    def identifier_output_method=(v)
-      raise_if_frozen!
-      @identifier_output_method = v
-    end
-
-    # Remove the row_proc from the current dataset.
-    def naked!
-      raise_if_frozen!
-      self.row_proc = nil
-      self
-    end
-    
-    # Set whether to quote identifiers for this dataset
-    def quote_identifiers=(v)
-      raise_if_frozen!
-      skip_symbol_cache!
-      @quote_identifiers = v
-    end
-
-    # Override the row_proc for this dataset
-    def row_proc=(v)
-      raise_if_frozen!
-      @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!
-      @opts = send(meth, *args, &block).opts
-      self
-    end
-
-    # Raise a RuntimeError if the receiver is frozen
-    def raise_if_frozen!
-      if frozen?
-        raise RuntimeError, "can't modify frozen #{visible_class_name}"
-      end
-    end
-  end
-end

data/lib/sequel/extensions/empty_array_ignore_nulls.rb

@@ -1,5 +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::Dataset.register_extension(:empty_array_ignore_nulls){}