sequel 4.49.0 → 5.0.0

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

@@ -1,92 +0,0 @@
-# frozen-string-literal: true
-
-Sequel::Deprecation.deprecate("The jdbc/as400 adapter", "This gem will replace it: https://github.com/ecraft/sequel-jdbc-as400")
-
-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
-        include Sequel::JDBC::Transactions
-
-        TRANSACTION_BEGIN = 'Transaction.begin'.freeze
-        Sequel::Deprecation.deprecate_constant(self, :TRANSACTION_BEGIN)
-        TRANSACTION_COMMIT = 'Transaction.commit'.freeze
-        Sequel::Deprecation.deprecate_constant(self, :TRANSACTION_COMMIT)
-        TRANSACTION_ROLLBACK = 'Transaction.rollback'.freeze
-        Sequel::Deprecation.deprecate_constant(self, :TRANSACTION_ROLLBACK)
-        
-        # 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 =~ /\A(The connection does not exist|Communication link failure)\./
-        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
-        Sequel::Deprecation.deprecate_constant(self, :WILDCARD)
-        FETCH_FIRST_ROW_ONLY = " FETCH FIRST ROW ONLY".freeze
-        Sequel::Deprecation.deprecate_constant(self, :FETCH_FIRST_ROW_ONLY)
-        FETCH_FIRST = " FETCH FIRST ".freeze
-        Sequel::Deprecation.deprecate_constant(self, :FETCH_FIRST)
-        ROWS_ONLY = " ROWS ONLY".freeze
-        Sequel::Deprecation.deprecate_constant(self, :ROWS_ONLY)
-        
-        # 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

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

@@ -1,65 +0,0 @@
-# frozen-string-literal: true
-
-#SEQUEL5: Remove
-
-Sequel::JDBC.load_driver('Java::cubrid.jdbc.driver.CUBRIDDriver')
-Sequel.require 'adapters/shared/cubrid'
-Sequel.require 'adapters/jdbc/transactions'
-
-module Sequel
-  module JDBC
-    Sequel.synchronize do
-      DATABASE_SETUP[:cubrid] = proc do |db|
-        db.extend(Sequel::JDBC::Cubrid::DatabaseMethods)
-        db.extend_datasets Sequel::Cubrid::DatasetMethods
-        Java::cubrid.jdbc.driver.CUBRIDDriver
-      end
-    end
-
-    module Cubrid
-      module DatabaseMethods
-        include Sequel::Cubrid::DatabaseMethods
-        include Sequel::JDBC::Transactions
-
-        def supports_savepoints?
-          false
-        end
-      
-        private
-        
-        # Get the last inserted id using LAST_INSERT_ID().
-        def last_insert_id(conn, opts=OPTS)
-          if stmt = opts[:stmt]
-            rs = stmt.getGeneratedKeys
-            begin
-              if rs.next
-                rs.getLong(1)
-              end
-            rescue NativeException
-              nil
-            ensure
-              rs.close
-            end
-          end
-        end
-
-        # Use execute instead of executeUpdate.
-        def execute_prepared_statement_insert(stmt)
-          stmt.execute
-        end
-      
-        # Return generated keys for insert statements, and use
-        # execute intead of executeUpdate as CUBRID doesn't
-        # return generated keys in executeUpdate.
-        def execute_statement_insert(stmt, sql)
-          stmt.execute(sql, JavaSQL::Statement.RETURN_GENERATED_KEYS)
-        end
-
-        # Return generated keys for insert statements.
-        def prepare_jdbc_statement(conn, sql, opts)
-          opts[:type] == :insert ? conn.prepareStatement(sql, JavaSQL::Statement.RETURN_GENERATED_KEYS) : super
-        end
-      end
-    end
-  end
-end

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

@@ -1,37 +0,0 @@
-# frozen-string-literal: true
-
-#SEQUEL5: Remove
-
-Sequel::JDBC.load_driver('org.firebirdsql.jdbc.FBDriver')
-Sequel.require 'adapters/shared/firebird'
-Sequel.require 'adapters/jdbc/transactions'
-
-module Sequel
-  module JDBC
-    Sequel.synchronize do
-      DATABASE_SETUP[:firebirdsql] = proc do |db|
-        db.extend(Sequel::JDBC::Firebird::DatabaseMethods)
-        db.extend_datasets Sequel::Firebird::DatasetMethods
-        org.firebirdsql.jdbc.FBDriver
-      end
-    end
-
-    # Database and Dataset instance methods for Firebird specific
-    # support via JDBC.
-    module Firebird
-      # Database instance methods for Firebird databases accessed via JDBC.
-      module DatabaseMethods
-        include Sequel::Firebird::DatabaseMethods
-        include Sequel::JDBC::Transactions
-        
-        # 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)
-          db.instance_eval do
-            @primary_keys = {}
-          end
-        end
-      end
-    end
-  end
-end

data/lib/sequel/adapters/jdbc/informix-sqli.rb

@@ -1,34 +0,0 @@
-# frozen-string-literal: true
-
-#SEQUEL5: Remove
-
-Sequel::JDBC.load_driver('com.informix.jdbc.IfxDriver')
-Sequel.require 'adapters/shared/informix'
-
-module Sequel
-  module JDBC
-    Sequel.synchronize do
-      DATABASE_SETUP[:"informix-sqli"] = proc do |db|
-        db.extend(Sequel::JDBC::Informix::DatabaseMethods)
-        db.extend_datasets Sequel::Informix::DatasetMethods
-        com.informix.jdbc.IfxDriver
-      end
-    end
-
-    # Database and Dataset instance methods for Informix specific
-    # support via JDBC.
-    module Informix
-      # Database instance methods for Informix databases accessed via JDBC.
-      module DatabaseMethods
-        include Sequel::Informix::DatabaseMethods
-        
-        private
-        
-        # TODO: implement
-        def last_insert_id(conn, opts=OPTS)
-          nil
-        end
-      end
-    end
-  end
-end

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

@@ -1,34 +0,0 @@
-# frozen-string-literal: true
-
-#SEQUEL5: Remove
-
-Sequel::JDBC.load_driver('com.progress.sql.jdbc.JdbcProgressDriver')
-Sequel.require 'adapters/shared/progress'
-Sequel.require 'adapters/jdbc/transactions'
-
-module Sequel
-  module JDBC
-    Sequel.synchronize do
-      DATABASE_SETUP[:jdbcprogress] = proc do |db|
-        db.extend(Sequel::JDBC::Progress::DatabaseMethods)
-        db.extend_datasets Sequel::Progress::DatasetMethods
-        com.progress.sql.jdbc.JdbcProgressDriver
-      end
-    end
-
-    # Database and Dataset instance methods for Progress v9 specific
-    # support via JDBC.
-    module Progress
-      # Database instance methods for Progress databases accessed via JDBC.
-      module DatabaseMethods
-        include Sequel::Progress::DatabaseMethods
-        include Sequel::JDBC::Transactions
-
-        # Progress DatabaseMetaData doesn't even implement supportsSavepoints()
-        def supports_savepoints?
-          false
-        end
-      end
-    end
-  end
-end

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

@@ -1,12 +0,0 @@
-# frozen-string-literal: true
-
-#SEQUEL5: Remove
-
-Sequel.require 'adapters/shared/progress'
-
-Sequel.synchronize do
-  Sequel::ODBC::DATABASE_SETUP[:progress] = proc do |db|
-    db.extend Sequel::Progress::DatabaseMethods
-    db.extend_datasets(Sequel::Progress::DatasetMethods)
-  end
-end

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

@@ -1,245 +0,0 @@
-# frozen-string-literal: true
-
-Sequel::Deprecation.deprecate("Sequel support for Cubrid", "Please consider maintaining it yourself as an external sequel adapter if you want to continue using it")
-
-Sequel.require %w'split_alter_table unmodified_identifiers', 'adapters/utils'
-
-module Sequel
-  module Cubrid
-    Sequel::Database.set_shared_adapter_scheme(:cubrid, self)
-
-    module DatabaseMethods
-      include Sequel::Database::SplitAlterTable
-      include UnmodifiedIdentifiers::DatabaseMethods
-
-      AUTOINCREMENT = 'AUTO_INCREMENT'.freeze
-      Sequel::Deprecation.deprecate_constant(self, :AUTOINCREMENT)
-      COLUMN_DEFINITION_ORDER = [:auto_increment, :default, :null, :unique, :primary_key, :references]#.freeze # SEQUEL5
-
-      def database_type
-        :cubrid
-      end
-
-      def indexes(table, opts=OPTS)
-        m = output_identifier_meth
-        m2 = input_identifier_meth
-        indexes = {}
-        metadata_dataset.
-          from{db_index[:i]}.
-          join(Sequel[:db_index_key].as(:k), :index_name=>:index_name, :class_name=>:class_name).
-          where{{i[:class_name]=>m2.call(table), :is_primary_key=>'NO'}}.
-          order{k[:key_order]}.
-          select{[i[:index_name], k[:key_attr_name].as(:column), :is_unique]}.
-          each do |row|
-            index = indexes[m.call(row[:index_name])] ||= {:columns=>[], :unique=>row[:is_unique]=='YES'}
-            index[:columns] << m.call(row[:column])
-          end
-        indexes
-      end
-
-      def supports_savepoints?
-        false
-      end
-
-      def schema_parse_table(table_name, opts)
-        m = output_identifier_meth(opts[:dataset])
-        m2 = input_identifier_meth(opts[:dataset])
-
-        pks = metadata_dataset.
-          from{db_index[:i]}.
-          join(Sequel[:db_index_key].as(:k), :index_name=>:index_name, :class_name=>:class_name).
-          where{{i[:class_name]=>m2.call(table_name), :is_primary_key=>'YES'}}.
-          order{k[:key_order]}.
-          select_map{k[:key_attr_name]}.
-          map{|c| m.call(c)}
-
-        metadata_dataset.
-          from(:db_attribute).
-          where(:class_name=>m2.call(table_name)).
-          order(:def_order).
-          select{[:attr_name, data_type.as(:db_type), default_value.as(:default), is_nullable.as(:allow_null), :prec]}.
-          map do |row|
-            name = m.call(row.delete(:attr_name))
-            row[:allow_null] = row[:allow_null] == 'YES'
-            row[:primary_key] = pks.include?(name)
-            row[:type] = schema_column_type(row[:db_type])
-            row[:max_length] = row[:prec] if row[:type] == :string
-            [name, row]
-          end
-      end
-
-      def tables(opts=OPTS)
-        _tables('CLASS')
-      end
-
-      def views(opts=OPTS)
-        _tables('VCLASS')
-      end
-
-      private
-
-      def _tables(type)
-        m = output_identifier_meth
-        metadata_dataset.
-          from(:db_class).
-          where(:is_system_class=>'NO', :class_type=>type).
-          select_map(:class_name).
-          map{|c| m.call(c)}
-      end
-
-      def alter_table_rename_column_sql(table, op)
-        "RENAME COLUMN #{quote_identifier(op[:name])} AS #{quote_identifier(op[:new_name])}"
-      end
-
-      def alter_table_change_column_sql(table, op)
-        o = op[:op]
-        opts = schema(table).find{|x| x.first == op[:name]}
-        opts = opts ? opts.last.dup : {}
-        opts[:name] = o == :rename_column ? op[:new_name] : op[:name]
-        opts[:type] = o == :set_column_type ? op[:type] : opts[:db_type]
-        opts[:null] = o == :set_column_null ? op[:null] : opts[:allow_null]
-        opts[:default] = o == :set_column_default ? op[:default] : opts[:ruby_default]
-        opts.delete(:default) if opts[:default] == nil
-        "CHANGE COLUMN #{quote_identifier(op[:name])} #{column_definition_sql(op.merge(opts))}"
-      end
-      alias alter_table_set_column_type_sql alter_table_change_column_sql
-      alias alter_table_set_column_null_sql alter_table_change_column_sql
-      alias alter_table_set_column_default_sql alter_table_change_column_sql
-
-      def alter_table_sql(table, op)
-        case op[:op]
-        when :drop_index
-          "ALTER TABLE #{quote_schema_table(table)} #{drop_index_sql(table, op)}"
-        else
-          super
-        end
-      end
-
-      def auto_increment_sql
-        'AUTO_INCREMENT'
-      end
-
-      # CUBRID requires auto increment before primary key
-      def column_definition_order
-        COLUMN_DEFINITION_ORDER
-      end
-
-      # CUBRID requires FOREIGN KEY keywords before a column reference
-      def column_references_sql(column)
-        sql = super
-        sql = " FOREIGN KEY#{sql}" unless column[:columns]
-        sql
-      end
-
-      def connection_execute_method
-        :query
-      end
-
-      DATABASE_ERROR_REGEXPS = {
-        /Operation would have caused one or more unique constraint violations/ => UniqueConstraintViolation,
-        /The constraint of the foreign key .+ is invalid|Update\/Delete operations are restricted by the foreign key/ => ForeignKeyConstraintViolation,
-        /cannot be made NULL/ => NotNullConstraintViolation,
-        /Your transaction .+ has been unilaterally aborted by the system/ => SerializationFailure,
-      }.freeze
-      def database_error_regexps
-        DATABASE_ERROR_REGEXPS
-      end
-
-      # CUBRID does not support named column constraints.
-      def supports_named_column_constraints?
-        false
-      end
-
-      # CUBRID doesn't support booleans, it recommends using smallint.
-      def type_literal_generic_trueclass(column)
-        :smallint
-      end
-
-      # CUBRID uses clob for text types.
-      def uses_clob_for_text?
-        true
-      end
-
-      # CUBRID supports views with check option, but not local.
-      def view_with_check_option_support
-        true
-      end
-    end
-    
-    module DatasetMethods
-      include UnmodifiedIdentifiers::DatasetMethods
-
-      COMMA = ', '.freeze
-      Sequel::Deprecation.deprecate_constant(self, :COMMA)
-      LIMIT = " LIMIT ".freeze
-      Sequel::Deprecation.deprecate_constant(self, :LIMIT)
-      BOOL_FALSE = '0'.freeze
-      Sequel::Deprecation.deprecate_constant(self, :BOOL_FALSE)
-      BOOL_TRUE = '1'.freeze
-      Sequel::Deprecation.deprecate_constant(self, :BOOL_TRUE)
-      ONLY_OFFSET = ",4294967295".freeze
-      Sequel::Deprecation.deprecate_constant(self, :ONLY_OFFSET)
-
-      def supports_join_using?
-        false
-      end
-
-      def supports_multiple_column_in?
-        false
-      end
-
-      def supports_timestamp_usecs?
-        false
-      end
-
-      # CUBRID supposedly supports TRUNCATE, but it appears not to work in my testing.
-      # Fallback to using DELETE.
-      def truncate
-        delete
-        nil
-      end
-
-      private
-
-      def literal_false
-        '0'
-      end
-
-      def literal_true
-        '1'
-      end
-     
-      # CUBRID supports multiple rows in INSERT.
-      def multi_insert_sql_strategy
-        :values
-      end
-
-      # CUBRID requires a limit to use an offset,
-      # and requires a FROM table if a limit is used.
-      def select_limit_sql(sql)
-        return unless @opts[:from]
-        l = @opts[:limit]
-        o = @opts[:offset]
-        if l || o
-          sql << " LIMIT "
-          if o
-            literal_append(sql, o)
-            if l
-              sql << ', '
-              literal_append(sql, l)
-            else
-              # Hope you don't have more than 2**32 + offset rows in your dataset
-              sql << ",4294967295"
-            end
-          else
-            literal_append(sql, l)
-          end
-        end
-      end
-
-      # CUBRID doesn't support FOR UPDATE.
-      def select_lock_sql(sql)
-      end
-    end
-  end
-end