sequel 4.26.0 → 5.37.0

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

@@ -1,62 +0,0 @@
-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
-        extend Sequel::Database::ResetIdentifierMangling
-        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,34 +0,0 @@
-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
-        extend Sequel::Database::ResetIdentifierMangling
-        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,31 +0,0 @@
-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
-        extend Sequel::Database::ResetIdentifierMangling
-        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,31 +0,0 @@
-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
-        extend Sequel::Database::ResetIdentifierMangling
-        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,8 +0,0 @@
-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,243 +0,0 @@
-Sequel.require 'adapters/utils/split_alter_table'
-
-module Sequel
-  module Cubrid
-    module DatabaseMethods
-      extend Sequel::Database::ResetIdentifierMangling
-
-      include Sequel::Database::SplitAlterTable
-
-      AUTOINCREMENT = 'AUTO_INCREMENT'.freeze
-      COLUMN_DEFINITION_ORDER = [:auto_increment, :default, :null, :unique, :primary_key, :references]
-
-      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(:db_index_key___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___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(:db_index_key___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___db_type, :default_value___default, :is_nullable___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
-        AUTOINCREMENT
-      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 is case insensitive, so don't modify identifiers
-      def identifier_input_method_default
-        nil
-      end
-
-      # CUBRID is case insensitive, so don't modify identifiers
-      def identifier_output_method_default
-        nil
-      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
-      COMMA = Sequel::Dataset::COMMA
-      LIMIT = Sequel::Dataset::LIMIT
-      BOOL_FALSE = '0'.freeze
-      BOOL_TRUE = '1'.freeze
-
-      # Hope you don't have more than 2**32 + offset rows in your dataset
-      ONLY_OFFSET = ",4294967295".freeze
-
-      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
-        BOOL_FALSE
-      end
-
-      def literal_true
-        BOOL_TRUE
-      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 << COMMA
-              literal_append(sql, l)
-            else
-              sql << ONLY_OFFSET
-            end
-          else
-            literal_append(sql, l)
-          end
-        end
-      end
-
-      # CUBRID doesn't support FOR UPDATE.
-      def select_lock_sql(sql)
-      end
-    end
-  end
-end

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

@@ -1,245 +0,0 @@
-module Sequel
-  module Firebird
-    module DatabaseMethods
-      extend Sequel::Database::ResetIdentifierMangling
-
-      AUTO_INCREMENT = ''.freeze
-      TEMPORARY = 'GLOBAL TEMPORARY '.freeze
-
-      def clear_primary_key(*tables)
-        tables.each{|t| @primary_keys.delete(dataset.send(:input_identifier, t))}
-      end
-
-      def create_trigger(*args)
-        self << create_trigger_sql(*args)
-      end
-
-      def database_type
-        :firebird
-      end
-
-      def drop_sequence(name)
-        self << drop_sequence_sql(name)
-      end
-
-      # Return primary key for the given table.
-      def primary_key(table)
-        t = dataset.send(:input_identifier, table)
-        @primary_keys.fetch(t) do
-          pk = fetch("SELECT RDB$FIELD_NAME FROM RDB$INDEX_SEGMENTS NATURAL JOIN RDB$RELATION_CONSTRAINTS WHERE RDB$CONSTRAINT_TYPE = 'PRIMARY KEY' AND RDB$RELATION_NAME = ?", t).single_value
-          @primary_keys[t] = dataset.send(:output_identifier, pk.rstrip) if pk
-        end
-      end
-
-      def restart_sequence(*args)
-        self << restart_sequence_sql(*args)
-      end
-
-      def sequences(opts=OPTS)
-        ds = self[:"rdb$generators"].server(opts[:server]).filter(:"rdb$system_flag" => 0).select(:"rdb$generator_name")
-        block_given? ? yield(ds) : ds.map{|r| ds.send(:output_identifier, r[:"rdb$generator_name"])}
-      end
-
-      def tables(opts=OPTS)
-        tables_or_views(0, opts)
-      end
-
-      def views(opts=OPTS)
-        tables_or_views(1, opts)
-      end
-
-      private
-
-      # Use Firebird specific syntax for add column
-      def alter_table_sql(table, op)
-        case op[:op]
-        when :add_column
-          "ALTER TABLE #{quote_schema_table(table)} ADD #{column_definition_sql(op)}"
-        when :drop_column
-          "ALTER TABLE #{quote_schema_table(table)} DROP #{column_definition_sql(op)}"
-        when :rename_column
-          "ALTER TABLE #{quote_schema_table(table)} ALTER #{quote_identifier(op[:name])} TO #{quote_identifier(op[:new_name])}"
-        when :set_column_type
-          "ALTER TABLE #{quote_schema_table(table)} ALTER #{quote_identifier(op[:name])} TYPE #{type_literal(op)}"
-        else
-          super(table, op)
-        end
-      end
-
-      def auto_increment_sql()
-        AUTO_INCREMENT
-      end
-      
-      def create_sequence_sql(name, opts=OPTS)
-        "CREATE SEQUENCE #{quote_identifier(name)}"
-      end
-
-      # Firebird gets an override because of the mess of creating a
-      # sequence and trigger for auto-incrementing primary keys.
-      def create_table_from_generator(name, generator, options)
-        drop_statement, create_statements = create_table_sql_list(name, generator, options)
-        (execute_ddl(drop_statement) rescue nil) if drop_statement
-        create_statements.each{|sql| execute_ddl(sql)}
-      end
-
-      def create_table_sql_list(name, generator, options=OPTS)
-        statements = [create_table_sql(name, generator, options)]
-        drop_seq_statement = nil
-        generator.columns.each do |c|
-          if c[:auto_increment]
-            c[:sequence_name] ||= "seq_#{name}_#{c[:name]}"
-            unless c[:create_sequence] == false
-              drop_seq_statement = drop_sequence_sql(c[:sequence_name])
-              statements << create_sequence_sql(c[:sequence_name])
-              statements << restart_sequence_sql(c[:sequence_name], {:restart_position => c[:sequence_start_position]}) if c[:sequence_start_position]
-            end
-            unless c[:create_trigger] == false
-              c[:trigger_name] ||= "BI_#{name}_#{c[:name]}"
-              c[:quoted_name] = quote_identifier(c[:name])
-              trigger_definition = <<-END
-              begin
-                if ((new.#{c[:quoted_name]} is null) or (new.#{c[:quoted_name]} = 0)) then
-                begin
-                  new.#{c[:quoted_name]} = next value for #{c[:sequence_name]};
-                end
-              end
-              END
-              statements << create_trigger_sql(name, c[:trigger_name], trigger_definition, {:events => [:insert]})
-            end
-          end
-        end
-        [drop_seq_statement, statements]
-      end
-
-      def create_trigger_sql(table, name, definition, opts=OPTS)
-        events = opts[:events] ? Array(opts[:events]) : [:insert, :update, :delete]
-        whence = opts[:after] ? 'AFTER' : 'BEFORE'
-        inactive = opts[:inactive] ? 'INACTIVE' : 'ACTIVE'
-        position = opts.fetch(:position, 0)
-        sql = <<-end_sql
-          CREATE TRIGGER #{quote_identifier(name)} for #{quote_identifier(table)}
-          #{inactive} #{whence} #{events.map{|e| e.to_s.upcase}.join(' OR ')} position #{position}
-          as #{definition}
-        end_sql
-        sql
-      end
-      
-      def drop_sequence_sql(name)
-        "DROP SEQUENCE #{quote_identifier(name)}"
-      end
-
-      def remove_cached_schema(table)
-        clear_primary_key(table)
-        super
-      end
-
-      def restart_sequence_sql(name, opts=OPTS)
-        seq_name = quote_identifier(name)
-        "ALTER SEQUENCE #{seq_name} RESTART WITH #{opts[:restart_position]}"
-      end
-
-      def tables_or_views(type, opts)
-        ds = self[:"rdb$relations"].server(opts[:server]).filter(:"rdb$relation_type" => type, Sequel::SQL::Function.new(:COALESCE, :"rdb$system_flag", 0) => 0).select(:"rdb$relation_name")
-        ds.map{|r| ds.send(:output_identifier, r[:"rdb$relation_name"].rstrip)}
-      end
-
-      def type_literal_generic_string(column)
-        column[:text] ? :"BLOB SUB_TYPE TEXT" : super
-      end
-
-      # Firebird supports views with check option, but not local.
-      def view_with_check_option_support
-        true
-      end
-    end
-
-    module DatasetMethods
-      BOOL_TRUE = '1'.freeze
-      BOOL_FALSE = '0'.freeze
-      NULL = LiteralString.new('NULL').freeze
-      FIRST = " FIRST ".freeze
-      SKIP = " SKIP ".freeze
-      DEFAULT_FROM = " FROM RDB$DATABASE"
-      
-      Dataset.def_sql_method(self, :select, %w'with select distinct limit columns from join where group having compounds order')
-      Dataset.def_sql_method(self, :insert, %w'insert into columns values returning')
-
-      # Insert given values into the database.
-      def insert(*values)
-        if @opts[:sql] || @opts[:returning]
-          super
-        else
-          returning(insert_pk).insert(*values){|r| return r.values.first}
-        end
-      end
-
-      # Insert a record returning the record inserted
-      def insert_select(*values)
-        with_sql_first(insert_select_sql(*values))
-      end
-
-      # The SQL to use for an insert_select, adds a RETURNING clause to the insert
-      # unless the RETURNING clause is already present.
-      def insert_select_sql(*values)
-        ds = opts[:returning] ? self : returning
-        ds.insert_sql(*values)
-      end
-
-      def requires_sql_standard_datetimes?
-        true
-      end
-
-      def supports_cte?(type=:select)
-        type == :select
-      end
-
-      def supports_insert_select?
-        true
-      end
-
-      # Firebird does not support INTERSECT or EXCEPT
-      def supports_intersect_except?
-        false
-      end
-
-      def supports_returning?(type)
-        type == :insert
-      end
-
-      private
-
-      def empty_from_sql
-        DEFAULT_FROM
-      end
-
-      def insert_pk(*values)
-        pk = db.primary_key(opts[:from].first)
-        pk ? Sequel::SQL::Identifier.new(pk) : NULL
-      end
-
-      def literal_false
-        BOOL_FALSE
-      end
-
-      def literal_true
-        BOOL_TRUE
-      end
-
-      # Firebird can insert multiple rows using a UNION
-      def multi_insert_sql_strategy
-        :union
-      end
-
-      def select_limit_sql(sql)
-        if l = @opts[:limit]
-          sql << FIRST
-          literal_append(sql, l)
-        end
-        if o = @opts[:offset]
-          sql << SKIP
-          literal_append(sql, o)
-        end
-      end
-    end
-  end
-end