sequel 4.49.0 → 5.0.0

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

@@ -1,261 +0,0 @@
-# frozen-string-literal: true
-
-Sequel::Deprecation.deprecate("Sequel support for Firebird", "Please consider maintaining it yourself as an external sequel adapter if you want to continue using it")
-
-module Sequel
-  module Firebird
-    Sequel::Database.set_shared_adapter_scheme(:firebird, self)
-
-    module DatabaseMethods
-      AUTO_INCREMENT = ''.freeze
-      Sequel::Deprecation.deprecate_constant(self, :AUTO_INCREMENT)
-      TEMPORARY = 'GLOBAL TEMPORARY '.freeze
-      Sequel::Deprecation.deprecate_constant(self, :TEMPORARY)
-
-      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]).where(:"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
-
-      def temporary_table_sql
-        'GLOBAL TEMPORARY '
-      end
-
-      # 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
-        ''
-      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]).where(:"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
-      NULL = LiteralString.new('NULL').freeze
-
-      BOOL_TRUE = '1'.freeze
-      Sequel::Deprecation.deprecate_constant(self, :BOOL_TRUE)
-      BOOL_FALSE = '0'.freeze
-      Sequel::Deprecation.deprecate_constant(self, :BOOL_FALSE)
-      FIRST = " FIRST ".freeze
-      Sequel::Deprecation.deprecate_constant(self, :FIRST)
-      SKIP = " SKIP ".freeze
-      Sequel::Deprecation.deprecate_constant(self, :SKIP)
-      DEFAULT_FROM = " FROM RDB$DATABASE"
-      Sequel::Deprecation.deprecate_constant(self, :DEFAULT_FROM)
-      
-      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
-        " FROM RDB$DATABASE"
-      end
-
-      def insert_pk(*values)
-        pk = db.primary_key(opts[:from].first)
-        pk ? Sequel::SQL::Identifier.new(pk) : NULL
-      end
-
-      def literal_false
-        '0'
-      end
-
-      def literal_true
-        '1'
-      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

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

@@ -1,63 +0,0 @@
-# frozen-string-literal: true
-
-Sequel::Deprecation.deprecate("Sequel support for Informix", "Please consider maintaining it yourself as an external sequel adapter if you want to continue using it")
-
-module Sequel
-  module Informix
-    Sequel::Database.set_shared_adapter_scheme(:informix, self)
-
-    module DatabaseMethods
-      TEMPORARY = 'TEMP '.freeze
-      Sequel::Deprecation.deprecate_constant(self, :TEMPORARY)
-
-      # 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
-        'TEMP '
-      end
-    end
-    
-    module DatasetMethods
-      FIRST = " FIRST ".freeze
-      Sequel::Deprecation.deprecate_constant(self, :FIRST)
-      SKIP = " SKIP ".freeze
-      Sequel::Deprecation.deprecate_constant(self, :SKIP)
-
-      Dataset.def_sql_method(self, :select, %w'select limit distinct columns from join where having group compounds order')
-
-      def quote_identifiers?
-        @opts.fetch(:quote_identifiers, false)
-      end
-
-      # 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/progress.rb

@@ -1,40 +0,0 @@
-# frozen-string-literal: true
-
-Sequel::Deprecation.deprecate("Sequel support for Progress", "Please consider maintaining it yourself as an external sequel adapter if you want to continue using it")
-
-module Sequel
-  module Progress
-    module DatabaseMethods
-      # 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,169 +0,0 @@
-# frozen-string-literal: true
-
-Sequel::Deprecation.deprecate("The swift adapter", "Please consider maintaining it yourself as an external gem if you want to continue using it")
-
-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|
-        db.extend(Sequel::Swift::Postgres::DatabaseMethods)
-        db.extend_datasets Sequel::Postgres::DatasetMethods
-        db.swift_class = ::Swift::DB::Postgres
-      end,
-      :mysql=>proc do |db|
-        db.extend(Sequel::Swift::MySQL::DatabaseMethods)
-        db.dataset_class = Sequel::Swift::MySQL::Dataset
-        db.swift_class = ::Swift::DB::Mysql
-      end,
-      :sqlite=>proc do |db|
-        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
-
-      def initialize(opts=OPTS)
-        Sequel.require "adapters/swift/#{opts[:db_type]}" if %w'postgres mysql sqlite'.include?(opts[:db_type].to_s)
-        super
-      end
-      
-      # 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
-
-      def dataset_class_default
-        Dataset
-      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
-      Sequel::Deprecation.deprecate_constant(Database, :DatasetClass)
-
-      # 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