sequel 4.26.0 → 5.37.0

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

@@ -1,52 +0,0 @@
-module Sequel
-  module Informix
-    module DatabaseMethods
-      extend Sequel::Database::ResetIdentifierMangling
-
-      TEMPORARY = 'TEMP '.freeze
-
-      # Informix uses the :informix database type
-      def database_type
-        :informix
-      end
-
-      private
-
-      # Informix has issues with quoted identifiers, so
-      # turn off database quoting by default.
-      def quote_identifiers_default
-        false
-      end
-
-      # SQL fragment for showing a table is temporary
-      def temporary_table_sql
-        TEMPORARY
-      end
-    end
-    
-    module DatasetMethods
-      FIRST = " FIRST ".freeze
-      SKIP = " SKIP ".freeze
-
-      Dataset.def_sql_method(self, :select, %w'select limit distinct columns from join where having group compounds order')
-
-      # Informix does not support INTERSECT or EXCEPT
-      def supports_intersect_except?
-        false
-      end
-
-      private
-
-      def select_limit_sql(sql)
-        if o = @opts[:offset]
-          sql << SKIP
-          literal_append(sql, o)
-        end
-        if l = @opts[:limit]
-          sql << FIRST
-          literal_append(sql, l)
-        end
-      end
-    end
-  end
-end

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

@@ -1,150 +0,0 @@
-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,38 +0,0 @@
-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.rb

@@ -1,158 +0,0 @@
-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_yield(sql){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_yield(sql){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_yield(sql){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 = {}
-          @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/swift/mysql.rb

@@ -1,47 +0,0 @@
-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_yield(sql){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