sequel 4.26.0 → 5.37.0

data/lib/sequel/adapters/cubrid.rb

@@ -1,142 +0,0 @@
-require 'cubrid'
-Sequel.require 'adapters/shared/cubrid'
-
-module Sequel
-  module Cubrid
-     CUBRID_TYPE_PROCS = {
-       ::Cubrid::DATE => lambda{|t| Date.new(t.year, t.month, t.day)},
-       ::Cubrid::TIME => lambda{|t| SQLTime.create(t.hour, t.min, t.sec)},
-       21 => lambda(&:to_i)
-     }
-
-    class Database < Sequel::Database
-      include Sequel::Cubrid::DatabaseMethods
-
-      ROW_COUNT = "SELECT ROW_COUNT()".freeze
-      LAST_INSERT_ID = "SELECT LAST_INSERT_ID()".freeze
-
-      set_adapter_scheme :cubrid
-      
-      def connect(server)
-        opts = server_opts(server)
-        conn = ::Cubrid.connect(
-          opts[:database],
-          opts[:host] || 'localhost',
-          opts[:port] || 30000,
-          opts[:user] || 'public',
-          opts[:password] || ''
-        )
-        conn.auto_commit = true
-        conn
-      end
-
-      def server_version
-        @server_version ||= synchronize(&:server_version)
-      end
-      
-      def execute(sql, opts=OPTS)
-        synchronize(opts[:server]) do |conn|
-          r = log_yield(sql) do
-            begin
-              conn.query(sql)
-            rescue => e
-              raise_error(e)
-            end
-          end
-          if block_given?
-            yield(r)
-          else
-            begin
-              case opts[:type]
-              when :dui
-                # This is cubrid's API, but it appears to be completely broken,
-                # giving StandardError: ERROR: CCI, -18, Invalid request handle
-                #r.affected_rows
-
-                # Work around bugs by using the ROW_COUNT function.
-                begin
-                  r2 = conn.query(ROW_COUNT)
-                  r2.each{|a| return a.first.to_i}
-                ensure
-                  r2.close if r2
-                end
-              when :insert
-                begin
-                  r2 = conn.query(LAST_INSERT_ID)
-                  r2.each{|a| return a.first.to_i}
-                ensure
-                  r2.close if r2
-                end
-              end
-            ensure
-              r.close
-            end
-          end
-        end
-      end
-
-      def execute_ddl(sql, opts=OPTS)
-        execute(sql, opts.merge(:type=>:ddl))
-      end
-
-      def execute_dui(sql, opts=OPTS)
-        execute(sql, opts.merge(:type=>:dui))
-      end
-
-      def execute_insert(sql, opts=OPTS)
-        execute(sql, opts.merge(:type=>:insert))
-      end
-
-      private
-
-      def begin_transaction(conn, opts=OPTS)
-        log_yield(TRANSACTION_BEGIN){conn.auto_commit = false}
-      end
-      
-      def commit_transaction(conn, opts=OPTS)
-        log_yield(TRANSACTION_COMMIT){conn.commit}
-      end
-
-      def database_error_classes
-        [StandardError]
-      end
-
-      def remove_transaction(conn, committed)
-        conn.auto_commit = true
-      ensure
-        super
-      end
-      
-      # This doesn't actually work, as the cubrid ruby driver
-      # does not implement transactions correctly.
-      def rollback_transaction(conn, opts=OPTS)
-        log_yield(TRANSACTION_ROLLBACK){conn.rollback}
-      end
-    end
-    
-    class Dataset < Sequel::Dataset
-      include Sequel::Cubrid::DatasetMethods
-      COLUMN_INFO_NAME = "name".freeze
-      COLUMN_INFO_TYPE = "type_name".freeze
-
-      Database::DatasetClass = self
-      
-      def fetch_rows(sql)
-        execute(sql) do |stmt|
-          begin
-            cols = stmt.column_info.map{|c| [output_identifier(c[COLUMN_INFO_NAME]), CUBRID_TYPE_PROCS[c[COLUMN_INFO_TYPE]]]}
-            @columns = cols.map(&:first)
-            stmt.each do |r|
-              row = {}
-              cols.zip(r).each{|(k, p), v| row[k] = (v && p) ? p.call(v) : v}
-              yield row
-            end
-          ensure
-            stmt.close
-          end
-        end
-        self
-      end
-    end
-  end
-end

data/lib/sequel/adapters/do.rb

@@ -1,156 +0,0 @@
-require 'data_objects'
-
-module Sequel
-  # Module holding the DataObjects support for Sequel.  DataObjects is a
-  # ruby library with a standard API for accessing databases.
-  #
-  # The DataObjects adapter currently supports PostgreSQL, MySQL, and
-  # SQLite:
-  #
-  # *  Sequel.connect('do:sqlite3::memory:')
-  # *  Sequel.connect('do:postgres://user:password@host/database')
-  # *  Sequel.connect('do:mysql://user:password@host/database')
-  module DataObjects
-    # Contains procs keyed on subadapter type that extend the
-    # given database object so it supports the correct database type.
-    DATABASE_SETUP = {}
-      
-    # Wrapper for require that raises AdapterNotFound if driver could not be loaded
-    def self.load_driver(path)
-      require path
-    rescue LoadError => e
-      raise AdapterNotFound, e.message
-    end
-        
-    # DataObjects uses it's own internal connection pooling in addition to the
-    # pooling that Sequel uses.  You should make sure that you don't set
-    # the connection pool size to more than 8 for a
-    # Sequel::DataObjects::Database object, or hack DataObjects (or Extlib) to
-    # use a pool size at least as large as the pool size being used by Sequel.
-    class Database < Sequel::Database
-      DISCONNECT_ERROR_RE = /terminating connection due to administrator command/
-
-      set_adapter_scheme :do
-      
-      # Setup a DataObjects::Connection to the database.
-      def connect(server)
-        setup_connection(::DataObjects::Connection.new(uri(server_opts(server))))
-      end
-
-      def disconnect_connection(conn)
-        conn.dispose
-      end
-      
-      # Execute the given SQL.  If a block is given, the DataObjects::Reader
-      # created is yielded to it. A block should not be provided unless a
-      # a SELECT statement is being used (or something else that returns rows).
-      # Otherwise, the return value is the insert id if opts[:type] is :insert,
-      # or the number of affected rows, otherwise.
-      def execute(sql, opts=OPTS)
-        synchronize(opts[:server]) do |conn|
-          begin
-            command = conn.create_command(sql)
-            res = log_yield(sql){block_given? ? command.execute_reader : command.execute_non_query}
-          rescue ::DataObjects::Error => e
-            raise_error(e)
-          end
-          if block_given?
-            begin
-              yield(res)
-            ensure
-             res.close if res
-            end
-          elsif opts[:type] == :insert
-            res.insert_id
-          else
-            res.affected_rows
-          end
-        end
-      end
-      
-      # Execute the SQL on the this database, returning the number of affected
-      # rows.
-      def execute_dui(sql, opts=OPTS)
-        execute(sql, opts)
-      end
-      
-      # Execute the SQL on this database, returning the primary key of the
-      # table being inserted to.
-      def execute_insert(sql, opts=OPTS)
-        execute(sql, opts.merge(:type=>:insert))
-      end
-      
-      # Return the subadapter type for this database, i.e. sqlite3 for
-      # do:sqlite3::memory:.
-      def subadapter
-        uri.split(":").first
-      end
-      
-      # Return the DataObjects URI for the Sequel URI, removing the do:
-      # prefix.
-      def uri(opts=OPTS)
-        opts = @opts.merge(opts)
-        (opts[:uri] || opts[:url]).sub(/\Ado:/, '')
-      end
-
-      private
-      
-      # Call the DATABASE_SETUP proc directly after initialization,
-      # so the object always uses subadapter specific code.  Also,
-      # raise an error immediately if the connection doesn't have a
-      # uri, since DataObjects requires one.
-      def adapter_initialize
-        raise(Error, "No connection string specified") unless uri
-        if prok = Sequel::Database.load_adapter(subadapter.to_sym, :map=>DATABASE_SETUP, :subdir=>'do')
-          prok.call(self)
-        end
-      end
-      
-      # Method to call on a statement object to execute SQL that does
-      # not return any rows.
-      def connection_execute_method
-        :execute_non_query
-      end
-      
-      # dataobjects uses the DataObjects::Error class as the main error class.
-      def database_error_classes
-        [::DataObjects::Error]
-      end
-
-      # Recognize DataObjects::ConnectionError instances as disconnect errors.
-      def disconnect_error?(e, opts)
-        super || (e.is_a?(::DataObjects::Error) && (e.is_a?(::DataObjects::ConnectionError) || e.message =~ DISCONNECT_ERROR_RE))
-      end
-      
-      # Execute SQL on the connection by creating a command first
-      def log_connection_execute(conn, sql)
-        log_yield(sql){conn.create_command(sql).execute_non_query}
-      end
-      
-      # Allow extending the given connection when it is first created.
-      # By default, just returns the connection.
-      def setup_connection(conn)
-        conn
-      end
-    end
-    
-    # Dataset class for Sequel::DataObjects::Database objects.
-    class Dataset < Sequel::Dataset
-      Database::DatasetClass = self
-
-      # Execute the SQL on the database and yield the rows as hashes
-      # with symbol keys.
-      def fetch_rows(sql)
-        execute(sql) do |reader|
-          cols = @columns = reader.fields.map{|f| output_identifier(f)}
-          while(reader.next!) do
-            h = {}
-            cols.zip(reader.values).each{|k, v| h[k] = v}
-            yield h
-          end
-        end
-        self
-      end
-    end
-  end
-end

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

@@ -1,64 +0,0 @@
-Sequel::DataObjects.load_driver 'do_mysql'
-Sequel.require 'adapters/shared/mysql'
-
-module Sequel
-  module DataObjects
-    Sequel.synchronize do
-      DATABASE_SETUP[:mysql] = proc do |db|
-        db.extend(Sequel::DataObjects::MySQL::DatabaseMethods)
-        db.dataset_class = Sequel::DataObjects::MySQL::Dataset
-      end
-    end
-
-    # Database and Dataset instance methods for MySQL specific
-    # support via DataObjects.
-    module MySQL
-      # Database instance methods for MySQL databases accessed via DataObjects.
-      module DatabaseMethods
-        extend Sequel::Database::ResetIdentifierMangling
-        include Sequel::MySQL::DatabaseMethods
-        
-        private
-        
-        # The database name for the given database.  Need to parse it out
-        # of the connection string, since the DataObjects does no parsing on the
-        # given connection string by default.
-        def database_name
-          (m = /\/(.*)/.match(URI.parse(uri).path)) && m[1]
-        end
-
-        # Recognize the tinyint(1) column 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.create_command(sql).execute_non_query}}
-          super
-        end
-      end
-      
-      # Dataset class for MySQL datasets accessed via DataObjects.
-      class Dataset < DataObjects::Dataset
-        include Sequel::MySQL::DatasetMethods
-        APOS = Dataset::APOS
-        APOS_RE = Dataset::APOS_RE
-        DOUBLE_APOS = Dataset::DOUBLE_APOS
-        
-        # The DataObjects MySQL driver uses the number of rows actually modified in the update,
-        # instead of the number of matched by the filter.
-        def provides_accurate_rows_matched?
-          false
-        end
-      
-        private
-        
-        # do_mysql sets NO_BACKSLASH_ESCAPES, so use standard SQL string escaping
-        def literal_string_append(sql, s)
-          sql << APOS << s.gsub(APOS_RE, DOUBLE_APOS) << APOS
-        end
-      end
-    end
-  end
-end

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

@@ -1,42 +0,0 @@
-Sequel::DataObjects.load_driver 'do_postgres'
-Sequel.require 'adapters/shared/postgres'
-
-module Sequel
-  Postgres::CONVERTED_EXCEPTIONS << ::DataObjects::Error
-  
-  module DataObjects
-    Sequel.synchronize do
-      DATABASE_SETUP[:postgres] = proc do |db|
-        db.extend(Sequel::DataObjects::Postgres::DatabaseMethods)
-        db.extend_datasets Sequel::Postgres::DatasetMethods
-      end
-    end
-
-    # Adapter, Database, and Dataset support for accessing a PostgreSQL
-    # database via DataObjects.
-    module Postgres
-      # Methods to add to Database instances that access PostgreSQL via
-      # DataObjects.
-      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
-        
-        # Extend the adapter with the DataObjects PostgreSQL AdapterMethods
-        def setup_connection(conn)
-          conn = super(conn)
-          connection_configuration_sqls.each{|sql| log_yield(sql){conn.create_command(sql).execute_non_query}}
-          conn
-        end
-      end
-    end
-  end
-end

data/lib/sequel/adapters/do/sqlite3.rb

@@ -1,40 +0,0 @@
-Sequel::DataObjects.load_driver 'do_sqlite3'
-Sequel.require 'adapters/shared/sqlite'
-
-module Sequel
-  module DataObjects
-    Sequel.synchronize do
-      DATABASE_SETUP[:sqlite3] = proc do |db|
-        db.extend(Sequel::DataObjects::SQLite::DatabaseMethods)
-        db.extend_datasets Sequel::SQLite::DatasetMethods
-        db.set_integer_booleans
-      end
-    end
-
-    # Database and Dataset support for SQLite databases accessed via DataObjects.
-    module SQLite
-      # Instance methods for SQLite Database objects accessed via DataObjects.
-      module DatabaseMethods
-        extend Sequel::Database::ResetIdentifierMangling
-        include Sequel::SQLite::DatabaseMethods
-        
-        private
-        
-        # Default to a single connection for a memory database.
-        def connection_pool_default_options
-          o = super
-          uri == 'sqlite3::memory:' ? o.merge(:max_connections=>1) : o
-        end
-        
-        # Execute the connection pragmas on the connection
-        def setup_connection(conn)
-          connection_pragmas.each do |s|
-            com = conn.create_command(s)
-            log_yield(s){com.execute_non_query}
-          end
-          super
-        end
-      end
-    end
-  end
-end

data/lib/sequel/adapters/jdbc/as400.rb

@@ -1,82 +0,0 @@
-Sequel::JDBC.load_driver('com.ibm.as400.access.AS400JDBCDriver')
-Sequel.require 'adapters/jdbc/transactions'
-Sequel.require 'adapters/utils/emulate_offset_with_row_number'
-
-module Sequel
-  module JDBC
-    Sequel.synchronize do
-      DATABASE_SETUP[:as400] = proc do |db|
-        db.extend(Sequel::JDBC::AS400::DatabaseMethods)
-        db.dataset_class = Sequel::JDBC::AS400::Dataset
-        com.ibm.as400.access.AS400JDBCDriver
-      end
-    end
-
-    # Database and Dataset support for AS400 databases accessed via JDBC.
-    module AS400
-      # Instance methods for AS400 Database objects accessed via JDBC.
-      module DatabaseMethods
-        extend Sequel::Database::ResetIdentifierMangling
-        include Sequel::JDBC::Transactions
-
-        TRANSACTION_BEGIN = 'Transaction.begin'.freeze
-        TRANSACTION_COMMIT = 'Transaction.commit'.freeze
-        TRANSACTION_ROLLBACK = 'Transaction.rollback'.freeze
-        
-        # AS400 uses the :as400 database type.
-        def database_type
-          :as400
-        end
-
-        # TODO: Fix for AS400
-        def last_insert_id(conn, opts=OPTS)
-          nil
-        end
-
-        # AS400 supports transaction isolation levels
-        def supports_transaction_isolation_levels?
-          true
-        end
-
-        private
-
-        def disconnect_error?(exception, opts)
-          super || exception.message =~ /\AThe connection does not exist\./
-        end
-
-        # Use JDBC connection's setAutoCommit to false to start transactions
-        def begin_transaction(conn, opts=OPTS)
-          set_transaction_isolation(conn, opts)
-          super
-        end
-      end
-      
-      # Dataset class for AS400 datasets accessed via JDBC.
-      class Dataset < JDBC::Dataset
-        include EmulateOffsetWithRowNumber
-
-        WILDCARD = Sequel::LiteralString.new('*').freeze
-        FETCH_FIRST_ROW_ONLY = " FETCH FIRST ROW ONLY".freeze
-        FETCH_FIRST = " FETCH FIRST ".freeze
-        ROWS_ONLY = " ROWS ONLY".freeze
-        
-        # Modify the sql to limit the number of rows returned
-        def select_limit_sql(sql)
-          if l = @opts[:limit]
-            if l == 1
-              sql << FETCH_FIRST_ROW_ONLY
-            elsif l > 1
-              sql << FETCH_FIRST
-              literal_append(sql, l)
-              sql << ROWS_ONLY
-            end
-          end
-        end
-          
-        def supports_window_functions?
-          true
-        end
-      end
-    end
-  end
-end