Further remove code branches by database type

We dropped MySQL support and a lot of mysql specific code has been
removed in https://gitlab.com/gitlab-org/gitlab-ce/merge_requests/29608.

This comes in from the other direction and removes any `if postgresql?`
branches.

app/finders/issuable_finder.rb

@@ -320,7 +320,6 @@ class IssuableFinder
   def use_cte_for_search?
     strong_memoize(:use_cte_for_search) do
       next false unless search
-      next false unless Gitlab::Database.postgresql?
       # Only simple unsorted & simple sorts can use CTE
       next false if params[:sort].present? && !params[:sort].in?(klass.simple_sorts.keys)
 

app/finders/members_finder.rb

@@ -59,35 +59,16 @@ class MembersFinder
   def distinct_on(union)
     # We're interested in a list of members without duplicates by user_id.
     # We prefer project members over group members, project members should go first.
-    if Gitlab::Database.postgresql?
-      <<~SQL
-          SELECT DISTINCT ON (user_id, invite_email) member_union.*
-          FROM (#{union.to_sql}) AS member_union
-          ORDER BY user_id,
-            invite_email,
-            CASE
-              WHEN type = 'ProjectMember' THEN 1
-              WHEN type = 'GroupMember' THEN 2
-              ELSE 3
-            END
-      SQL
-    else
-      # Older versions of MySQL do not support window functions (and DISTINCT ON is postgres-specific).
-      <<~SQL
-          SELECT t1.*
-          FROM (#{union.to_sql}) AS t1
-          JOIN (
-            SELECT
-              COALESCE(user_id, -1) AS user_id,
-              COALESCE(invite_email, 'NULL') AS invite_email,
-              MIN(CASE WHEN type = 'ProjectMember' THEN 1 WHEN type = 'GroupMember' THEN 2 ELSE 3 END) AS type_number
-            FROM
-            (#{union.to_sql}) AS t3
-            GROUP BY COALESCE(user_id, -1), COALESCE(invite_email, 'NULL')
-          ) AS t2 ON COALESCE(t1.user_id, -1) = t2.user_id
-                 AND COALESCE(t1.invite_email, 'NULL') = t2.invite_email
-                 AND CASE WHEN t1.type = 'ProjectMember' THEN 1 WHEN t1.type = 'GroupMember' THEN 2 ELSE 3 END = t2.type_number
-      SQL
-    end
+    <<~SQL
+        SELECT DISTINCT ON (user_id, invite_email) member_union.*
+        FROM (#{union.to_sql}) AS member_union
+        ORDER BY user_id,
+          invite_email,
+          CASE
+            WHEN type = 'ProjectMember' THEN 1
+            WHEN type = 'GroupMember' THEN 2
+            ELSE 3
+          END
+    SQL
   end
 end

app/models/merge_request.rb

@@ -1249,15 +1249,8 @@ class MergeRequest < ApplicationRecord
   end
 
   def all_commits
-    # MySQL doesn't support LIMIT in a subquery.
-    diffs_relation = if Gitlab::Database.postgresql?
-                       merge_request_diffs.recent
-                     else
-                       merge_request_diffs
-                     end
-
     MergeRequestDiffCommit
-      .where(merge_request_diff: diffs_relation)
+      .where(merge_request_diff: merge_request_diffs.recent)
       .limit(10_000)
   end
 

app/models/milestone.rb

@@ -149,29 +149,10 @@ class Milestone < ApplicationRecord
   end
 
   def self.upcoming_ids(projects, groups)
-    rel = unscoped
-            .for_projects_and_groups(projects, groups)
-            .active.where('milestones.due_date > CURRENT_DATE')
-
-    if Gitlab::Database.postgresql?
-      rel.order(:project_id, :group_id, :due_date).select('DISTINCT ON (project_id, group_id) id')
-    else
-      # We need to use MySQL's NULL-safe comparison operator `<=>` here
-      # because one of `project_id` or `group_id` is always NULL
-      join_clause = <<~HEREDOC
-        LEFT OUTER JOIN milestones earlier_milestones
-          ON milestones.project_id <=> earlier_milestones.project_id
-            AND milestones.group_id <=> earlier_milestones.group_id
-            AND milestones.due_date > earlier_milestones.due_date
-            AND earlier_milestones.due_date > CURRENT_DATE
-            AND earlier_milestones.state = 'active'
-      HEREDOC
-
-      rel
-        .joins(join_clause)
-        .where('earlier_milestones.id IS NULL')
-        .select(:id)
-    end
+    unscoped
+      .for_projects_and_groups(projects, groups)
+      .active.where('milestones.due_date > CURRENT_DATE')
+      .order(:project_id, :group_id, :due_date).select('DISTINCT ON (project_id, group_id) id')
   end
 
   def participants

app/models/redirect_route.rb

@@ -11,11 +11,7 @@ class RedirectRoute < ApplicationRecord
     uniqueness: { case_sensitive: false }
 
   scope :matching_path_and_descendants, -> (path) do
-    wheres = if Gitlab::Database.postgresql?
-               'LOWER(redirect_routes.path) = LOWER(?) OR LOWER(redirect_routes.path) LIKE LOWER(?)'
-             else
-               'redirect_routes.path = ? OR redirect_routes.path LIKE ?'
-             end
+    wheres = 'LOWER(redirect_routes.path) = LOWER(?) OR LOWER(redirect_routes.path) LIKE LOWER(?)'
 
     where(wheres, path, "#{sanitize_sql_like(path)}/%")
   end

app/services/cohorts_service.rb

@@ -95,10 +95,6 @@ class CohortsService
   # rubocop: enable CodeReuse/ActiveRecord
 
   def column_to_date(column)
-    if Gitlab::Database.postgresql?
-      "CAST(DATE_TRUNC('month', #{column}) AS date)"
-    else
-      "STR_TO_DATE(DATE_FORMAT(#{column}, '%Y-%m-01'), '%Y-%m-%d')"
-    end
+    "CAST(DATE_TRUNC('month', #{column}) AS date)"
   end
 end

app/services/projects/base_move_relations_service.rb

@@ -13,14 +13,9 @@ module Projects
 
     private
 
-    # rubocop: disable CodeReuse/ActiveRecord
     def prepare_relation(relation, id_param = :id)
-      if Gitlab::Database.postgresql?
-        relation
-      else
-        relation.model.where("#{id_param}": relation.pluck(id_param))
-      end
+      # TODO: Refactor and remove this method (https://gitlab.com/gitlab-org/gitlab-ce/issues/65054)
+      relation
     end
-    # rubocop: enable CodeReuse/ActiveRecord
   end
 end

app/services/projects/fetch_statistics_increment_service.rb

@@ -12,14 +12,9 @@ module Projects
       increment_fetch_count_sql = <<~SQL
         INSERT INTO #{table_name} (project_id, date, fetch_count)
         VALUES (#{project.id}, '#{Date.today}', 1)
+        ON CONFLICT (project_id, date) DO UPDATE SET fetch_count = #{table_name}.fetch_count + 1
       SQL
 
-      increment_fetch_count_sql += if Gitlab::Database.postgresql?
-                                     "ON CONFLICT (project_id, date) DO UPDATE SET fetch_count = #{table_name}.fetch_count + 1"
-                                   else
-                                     "ON DUPLICATE KEY UPDATE fetch_count = #{table_name}.fetch_count + 1"
-                                   end
-
       ActiveRecord::Base.connection.execute(increment_fetch_count_sql)
     end
 

app/workers/background_migration_worker.rb

@@ -76,8 +76,6 @@ class BackgroundMigrationWorker
   # class_name - The name of the background migration that we might want to
   #              run.
   def healthy_database?
-    return true unless Gitlab::Database.postgresql?
-
     !Postgresql::ReplicationSlot.lag_too_great?
   end
 

lib/gitlab/background_migration/migrate_stage_index.rb

@@ -13,34 +13,22 @@ module Gitlab
       private
 
       def migrate_stage_index_sql(start_id, stop_id)
-        if Gitlab::Database.postgresql?
-          <<~SQL
-            WITH freqs AS (
-              SELECT stage_id, stage_idx, COUNT(*) AS freq FROM ci_builds
-                WHERE stage_id BETWEEN #{start_id} AND #{stop_id}
-                  AND stage_idx IS NOT NULL
-                GROUP BY stage_id, stage_idx
-            ), indexes AS (
-              SELECT DISTINCT stage_id, first_value(stage_idx)
-                OVER (PARTITION BY stage_id ORDER BY freq DESC) AS index
-                FROM freqs
-            )
+        <<~SQL
+          WITH freqs AS (
+            SELECT stage_id, stage_idx, COUNT(*) AS freq FROM ci_builds
+              WHERE stage_id BETWEEN #{start_id} AND #{stop_id}
+                AND stage_idx IS NOT NULL
+              GROUP BY stage_id, stage_idx
+          ), indexes AS (
+            SELECT DISTINCT stage_id, first_value(stage_idx)
+              OVER (PARTITION BY stage_id ORDER BY freq DESC) AS index
+              FROM freqs
+          )
 
-            UPDATE ci_stages SET position = indexes.index
-              FROM indexes WHERE indexes.stage_id = ci_stages.id
-                AND ci_stages.position IS NULL;
-          SQL
-        else
-          <<~SQL
-            UPDATE ci_stages
-              SET position =
-                (SELECT stage_idx FROM ci_builds
-                  WHERE ci_builds.stage_id = ci_stages.id
-                  GROUP BY ci_builds.stage_idx ORDER BY COUNT(*) DESC LIMIT 1)
-            WHERE ci_stages.id BETWEEN #{start_id} AND #{stop_id}
-              AND ci_stages.position IS NULL
-          SQL
-        end
+          UPDATE ci_stages SET position = indexes.index
+            FROM indexes WHERE indexes.stage_id = ci_stages.id
+              AND ci_stages.position IS NULL;
+        SQL
       end
     end
   end

lib/gitlab/background_migration/prepare_untracked_uploads.rb

@@ -147,19 +147,13 @@ module Gitlab
         "#{UntrackedFile.table_name} (path) VALUES #{values}"
       end
 
-      def postgresql?
-        strong_memoize(:postgresql) do
-          Gitlab::Database.postgresql?
-        end
-      end
-
       def can_bulk_insert_and_ignore_duplicates?
         !postgresql_pre_9_5?
       end
 
       def postgresql_pre_9_5?
         strong_memoize(:postgresql_pre_9_5) do
-          postgresql? && Gitlab::Database.version.to_f < 9.5
+          Gitlab::Database.version.to_f < 9.5
         end
       end
 

lib/gitlab/background_migration/remove_restricted_todos.rb

@@ -50,14 +50,7 @@ module Gitlab
       private
 
       def remove_non_members_todos(project_id)
-        if Gitlab::Database.postgresql?
-          batch_remove_todos_cte(project_id)
-        else
-          unauthorized_project_todos(project_id)
-            .each_batch(of: 5000) do |batch|
-              batch.delete_all
-            end
-        end
+        batch_remove_todos_cte(project_id)
       end
 
       def remove_confidential_issue_todos(project_id)
@@ -90,13 +83,7 @@ module Gitlab
 
           next if target_types.empty?
 
-          if Gitlab::Database.postgresql?
-            batch_remove_todos_cte(project_id, target_types)
-          else
-            unauthorized_project_todos(project_id)
-              .where(target_type: target_types)
-              .delete_all
-          end
+          batch_remove_todos_cte(project_id, target_types)
         end
       end
 

lib/gitlab/ci/charts.rb

@@ -21,16 +21,10 @@ module Gitlab
       module MonthlyInterval
         # rubocop: disable CodeReuse/ActiveRecord
         def grouped_count(query)
-          if Gitlab::Database.postgresql?
-            query
-              .group("to_char(#{::Ci::Pipeline.table_name}.created_at, '01 Month YYYY')")
-              .count(:created_at)
-              .transform_keys(&:squish)
-          else
-            query
-              .group("DATE_FORMAT(#{::Ci::Pipeline.table_name}.created_at, '01 %M %Y')")
-              .count(:created_at)
-          end
+          query
+            .group("to_char(#{::Ci::Pipeline.table_name}.created_at, '01 Month YYYY')")
+            .count(:created_at)
+            .transform_keys(&:squish)
         end
         # rubocop: enable CodeReuse/ActiveRecord
 

lib/gitlab/contributions_calendar.rb

@@ -84,11 +84,7 @@ module Gitlab
         .and(t[:created_at].lteq(Date.current.end_of_day))
         .and(t[:author_id].eq(contributor.id))
 
-      date_interval = if Gitlab::Database.postgresql?
-                        "INTERVAL '#{Time.zone.now.utc_offset} seconds'"
-                      else
-                        "INTERVAL #{Time.zone.now.utc_offset} SECOND"
-                      end
+      date_interval = "INTERVAL '#{Time.zone.now.utc_offset} seconds'"
 
       Event.reorder(nil)
         .select(t[:project_id], t[:target_type], t[:action], "date(created_at + #{date_interval}) AS date", 'count(id) as total_amount')

lib/gitlab/database.rb

@@ -46,6 +46,7 @@ module Gitlab
       end
     end
 
+    # @deprecated
     def self.postgresql?
       adapter_name.casecmp('postgresql').zero?
     end
@@ -79,19 +80,19 @@ module Gitlab
     end
 
     def self.postgresql_9_or_less?
-      postgresql? && version.to_f < 10
+      version.to_f < 10
     end
 
     def self.join_lateral_supported?
-      postgresql? && version.to_f >= 9.3
+      version.to_f >= 9.3
     end
 
     def self.replication_slots_supported?
-      postgresql? && version.to_f >= 9.4
+      version.to_f >= 9.4
     end
 
     def self.postgresql_minimum_supported_version?
-      postgresql? && version.to_f >= 9.6
+      version.to_f >= 9.6
     end
 
     # map some of the function names that changed between PostgreSQL 9 and 10

lib/gitlab/database/grant.rb

@@ -6,47 +6,25 @@ module Gitlab
     class Grant < ActiveRecord::Base
       include FromUnion
 
-      self.table_name =
-        if Database.postgresql?
-          'information_schema.role_table_grants'
-        else
-          'information_schema.schema_privileges'
-        end
+      self.table_name = 'information_schema.role_table_grants'
 
       # Returns true if the current user can create and execute triggers on the
       # given table.
       def self.create_and_execute_trigger?(table)
-        if Database.postgresql?
-          # We _must not_ use quote_table_name as this will produce double
-          # quotes on PostgreSQL and for "has_table_privilege" we need single
-          # quotes.
-          quoted_table = connection.quote(table)
+        # We _must not_ use quote_table_name as this will produce double
+        # quotes on PostgreSQL and for "has_table_privilege" we need single
+        # quotes.
+        quoted_table = connection.quote(table)
 
-          begin
-            from(nil)
-              .pluck(Arel.sql("has_table_privilege(#{quoted_table}, 'TRIGGER')"))
-              .first
-          rescue ActiveRecord::StatementInvalid
-            # This error is raised when using a non-existing table name. In this
-            # case we just want to return false as a user technically can't
-            # create triggers for such a table.
-            false
-          end
-        else
-          queries = [
-            Grant.select(1)
-              .from('information_schema.user_privileges')
-              .where("PRIVILEGE_TYPE = 'SUPER'")
-              .where("GRANTEE = CONCAT('\\'', REPLACE(CURRENT_USER(), '@', '\\'@\\''), '\\'')"),
-
-            Grant.select(1)
-              .from('information_schema.schema_privileges')
-              .where("PRIVILEGE_TYPE = 'TRIGGER'")
-              .where('TABLE_SCHEMA = ?', Gitlab::Database.database_name)
-              .where("GRANTEE = CONCAT('\\'', REPLACE(CURRENT_USER(), '@', '\\'@\\''), '\\'')")
-          ]
-
-          Grant.from_union(queries, alias_as: 'privs').any?
+        begin
+          from(nil)
+            .pluck(Arel.sql("has_table_privilege(#{quoted_table}, 'TRIGGER')"))
+            .first
+        rescue ActiveRecord::StatementInvalid
+          # This error is raised when using a non-existing table name. In this
+          # case we just want to return false as a user technically can't
+          # create triggers for such a table.
+          false
         end
       end
     end

lib/gitlab/database/median.rb

@@ -137,8 +137,6 @@ module Gitlab
       end
 
       def extract_diff_epoch(diff)
-        return diff unless Gitlab::Database.postgresql?
-
         Arel.sql(%Q{EXTRACT(EPOCH FROM (#{diff.to_sql}))})
       end
 

lib/gitlab/database/migration_helpers.rb

@@ -152,8 +152,6 @@ module Gitlab
 
       # Only available on Postgresql >= 9.2
       def supports_drop_index_concurrently?
-        return false unless Database.postgresql?
-
         version = select_one("SELECT current_setting('server_version_num') AS v")['v'].to_i
 
         version >= 90200

lib/gitlab/database/sha_attribute.rb

@@ -2,14 +2,9 @@
 
 module Gitlab
   module Database
-    BINARY_TYPE =
-      if Gitlab::Database.postgresql?
-        # PostgreSQL defines its own class with slightly different
-        # behaviour from the default Binary type.
-        ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Bytea
-      else
-        ActiveModel::Type::Binary
-      end
+    # PostgreSQL defines its own class with slightly different
+    # behaviour from the default Binary type.
+    BINARY_TYPE = ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Bytea
 
     # Class for casting binary data to hexadecimal SHA1 hashes (and vice-versa).
     #

lib/gitlab/health_checks/db_check.rb

@@ -18,11 +18,7 @@ module Gitlab
 
         def check
           catch_timeout 10.seconds do
-            if Gitlab::Database.postgresql?
-              ActiveRecord::Base.connection.execute('SELECT 1 as ping')&.first&.[]('ping')&.to_s
-            else
-              ActiveRecord::Base.connection.execute('SELECT 1 as ping')&.first&.first&.to_s
-            end
+            ActiveRecord::Base.connection.execute('SELECT 1 as ping')&.first&.[]('ping')&.to_s
           end
         end
       end

lib/gitlab/sherlock/query.rb

@@ -96,12 +96,7 @@ module Gitlab
       private
 
       def raw_explain(query)
-        explain =
-          if Gitlab::Database.postgresql?
-            "EXPLAIN ANALYZE #{query};"
-          else
-            "EXPLAIN #{query};"
-          end
+        explain = "EXPLAIN ANALYZE #{query};"
 
         ActiveRecord::Base.connection.execute(explain)
       end

lib/tasks/gitlab/setup.rake

@@ -45,8 +45,6 @@ namespace :gitlab do
   # method terminates all the connections so that a subsequent DROP
   # will work.
   def self.terminate_all_connections
-    return false unless Gitlab::Database.postgresql?
-
     cmd = <<~SQL
     SELECT pg_terminate_backend(pg_stat_activity.pid)
         FROM pg_stat_activity

spec/features/admin/dashboard_spec.rb

@@ -17,10 +17,8 @@ describe 'admin visits dashboard' do
 
       # Make sure the fork_networks & fork_networks reltuples have been updated
       # to get a correct count on postgresql
-      if Gitlab::Database.postgresql?
-        ActiveRecord::Base.connection.execute('ANALYZE fork_networks')
-        ActiveRecord::Base.connection.execute('ANALYZE fork_network_members')
-      end
+      ActiveRecord::Base.connection.execute('ANALYZE fork_networks')
+      ActiveRecord::Base.connection.execute('ANALYZE fork_network_members')
 
       visit admin_root_path
 

spec/finders/issues_finder_spec.rb

@@ -690,7 +690,6 @@ describe IssuesFinder do
     let(:finder) { described_class.new(nil, params) }
 
     before do
-      allow(Gitlab::Database).to receive(:postgresql?).and_return(true)
       stub_feature_flags(attempt_group_search_optimizations: true)
     end
 
@@ -702,18 +701,6 @@ describe IssuesFinder do
       end
     end
 
-    context 'when the database is not Postgres' do
-      let(:params) { { search: 'foo', attempt_group_search_optimizations: true } }
-
-      before do
-        allow(Gitlab::Database).to receive(:postgresql?).and_return(false)
-      end
-
-      it 'returns false' do
-        expect(finder.use_cte_for_search?).to be_falsey
-      end
-    end
-
     context 'when the force_cte param is falsey' do
       let(:params) { { search: 'foo' } }
 

spec/lib/gitlab/database/sha_attribute_spec.rb

@@ -12,11 +12,7 @@ describe Gitlab::Database::ShaAttribute do
   end
 
   let(:binary_from_db) do
-    if Gitlab::Database.postgresql?
-      "\\x#{sha}"
-    else
-      binary_sha
-    end
+    "\\x#{sha}"
   end
 
   let(:attribute) { described_class.new }

spec/lib/gitlab/database_spec.rb

@@ -17,14 +17,6 @@ describe Gitlab::Database do
     it 'returns the name of the adapter' do
       expect(described_class.adapter_name).to be_an_instance_of(String)
     end
-  end
-
-  describe '.human_adapter_name' do
-    it 'returns PostgreSQL when using PostgreSQL' do
-      allow(described_class).to receive(:postgresql?).and_return(true)
-
-      expect(described_class.human_adapter_name).to eq('PostgreSQL')
-    end
 
     it 'returns Unknown when using anything else' do
       allow(described_class).to receive(:postgresql?).and_return(false)
@@ -33,6 +25,12 @@ describe Gitlab::Database do
     end
   end
 
+  describe '.human_adapter_name' do
+    it 'returns PostgreSQL when using PostgreSQL' do
+      expect(described_class.human_adapter_name).to eq('PostgreSQL')
+    end
+  end
+
   describe '.postgresql?' do
     subject { described_class.postgresql? }
 
@@ -65,21 +63,18 @@ describe Gitlab::Database do
   end
 
   describe '.postgresql_9_or_less?' do
-    it 'returns false when not using postgresql' do
-      allow(described_class).to receive(:postgresql?).and_return(false)
-
-      expect(described_class.postgresql_9_or_less?).to eq(false)
+    it 'returns true when using postgresql 8.4' do
+      allow(described_class).to receive(:version).and_return('8.4')
+      expect(described_class.postgresql_9_or_less?).to eq(true)
     end
 
     it 'returns true when using PostgreSQL 9.6' do
-      allow(described_class).to receive(:postgresql?).and_return(true)
       allow(described_class).to receive(:version).and_return('9.6')
 
       expect(described_class.postgresql_9_or_less?).to eq(true)
     end
 
     it 'returns false when using PostgreSQL 10 or newer' do
-      allow(described_class).to receive(:postgresql?).and_return(true)
       allow(described_class).to receive(:version).and_return('10')
 
       expect(described_class.postgresql_9_or_less?).to eq(false)
@@ -87,53 +82,33 @@ describe Gitlab::Database do
   end
 
   describe '.postgresql_minimum_supported_version?' do
-    it 'returns false when not using PostgreSQL' do
-      allow(described_class).to receive(:postgresql?).and_return(false)
+    it 'returns false when using PostgreSQL 9.5' do
+      allow(described_class).to receive(:version).and_return('9.5')
 
       expect(described_class.postgresql_minimum_supported_version?).to eq(false)
     end
 
-    context 'when using PostgreSQL' do
-      before do
-        allow(described_class).to receive(:postgresql?).and_return(true)
-      end
+    it 'returns true when using PostgreSQL 9.6' do
+      allow(described_class).to receive(:version).and_return('9.6')
 
-      it 'returns false when using PostgreSQL 9.5' do
-        allow(described_class).to receive(:version).and_return('9.5')
+      expect(described_class.postgresql_minimum_supported_version?).to eq(true)
+    end
 
-        expect(described_class.postgresql_minimum_supported_version?).to eq(false)
-      end
+    it 'returns true when using PostgreSQL 10 or newer' do
+      allow(described_class).to receive(:version).and_return('10')
 
-      it 'returns true when using PostgreSQL 9.6' do
-        allow(described_class).to receive(:version).and_return('9.6')
-
-        expect(described_class.postgresql_minimum_supported_version?).to eq(true)
-      end
-
-      it 'returns true when using PostgreSQL 10 or newer' do
-        allow(described_class).to receive(:version).and_return('10')
-
-        expect(described_class.postgresql_minimum_supported_version?).to eq(true)
-      end
+      expect(described_class.postgresql_minimum_supported_version?).to eq(true)
     end
   end
 
   describe '.join_lateral_supported?' do
-    it 'returns false when not using postgresql' do
-      allow(described_class).to receive(:postgresql?).and_return(false)
-
-      expect(described_class.join_lateral_supported?).to eq(false)
-    end
-
     it 'returns false when using PostgreSQL 9.2' do
-      allow(described_class).to receive(:postgresql?).and_return(true)
       allow(described_class).to receive(:version).and_return('9.2.1')
 
       expect(described_class.join_lateral_supported?).to eq(false)
     end
 
     it 'returns true when using PostgreSQL 9.3.0 or newer' do
-      allow(described_class).to receive(:postgresql?).and_return(true)
       allow(described_class).to receive(:version).and_return('9.3.0')
 
       expect(described_class.join_lateral_supported?).to eq(true)
@@ -141,21 +116,13 @@ describe Gitlab::Database do
   end
 
   describe '.replication_slots_supported?' do
-    it 'returns false when not using postgresql' do
-      allow(described_class).to receive(:postgresql?).and_return(false)
-
-      expect(described_class.replication_slots_supported?).to eq(false)
-    end
-
     it 'returns false when using PostgreSQL 9.3' do
-      allow(described_class).to receive(:postgresql?).and_return(true)
       allow(described_class).to receive(:version).and_return('9.3.1')
 
       expect(described_class.replication_slots_supported?).to eq(false)
     end
 
     it 'returns true when using PostgreSQL 9.4.0 or newer' do
-      allow(described_class).to receive(:postgresql?).and_return(true)
       allow(described_class).to receive(:version).and_return('9.4.0')
 
       expect(described_class.replication_slots_supported?).to eq(true)
@@ -164,14 +131,12 @@ describe Gitlab::Database do
 
   describe '.pg_wal_lsn_diff' do
     it 'returns old name when using PostgreSQL 9.6' do
-      allow(described_class).to receive(:postgresql?).and_return(true)
       allow(described_class).to receive(:version).and_return('9.6')
 
       expect(described_class.pg_wal_lsn_diff).to eq('pg_xlog_location_diff')
     end
 
     it 'returns new name when using PostgreSQL 10 or newer' do
-      allow(described_class).to receive(:postgresql?).and_return(true)
       allow(described_class).to receive(:version).and_return('10')
 
       expect(described_class.pg_wal_lsn_diff).to eq('pg_wal_lsn_diff')
@@ -180,14 +145,12 @@ describe Gitlab::Database do
 
   describe '.pg_current_wal_insert_lsn' do
     it 'returns old name when using PostgreSQL 9.6' do
-      allow(described_class).to receive(:postgresql?).and_return(true)
       allow(described_class).to receive(:version).and_return('9.6')
 
       expect(described_class.pg_current_wal_insert_lsn).to eq('pg_current_xlog_insert_location')
     end
 
     it 'returns new name when using PostgreSQL 10 or newer' do
-      allow(described_class).to receive(:postgresql?).and_return(true)
       allow(described_class).to receive(:version).and_return('10')
 
       expect(described_class.pg_current_wal_insert_lsn).to eq('pg_current_wal_insert_lsn')
@@ -196,14 +159,12 @@ describe Gitlab::Database do
 
   describe '.pg_last_wal_receive_lsn' do
     it 'returns old name when using PostgreSQL 9.6' do
-      allow(described_class).to receive(:postgresql?).and_return(true)
       allow(described_class).to receive(:version).and_return('9.6')
 
       expect(described_class.pg_last_wal_receive_lsn).to eq('pg_last_xlog_receive_location')
     end
 
     it 'returns new name when using PostgreSQL 10 or newer' do
-      allow(described_class).to receive(:postgresql?).and_return(true)
       allow(described_class).to receive(:version).and_return('10')
 
       expect(described_class.pg_last_wal_receive_lsn).to eq('pg_last_wal_receive_lsn')
@@ -212,14 +173,12 @@ describe Gitlab::Database do
 
   describe '.pg_last_wal_replay_lsn' do
     it 'returns old name when using PostgreSQL 9.6' do
-      allow(described_class).to receive(:postgresql?).and_return(true)
       allow(described_class).to receive(:version).and_return('9.6')
 
       expect(described_class.pg_last_wal_replay_lsn).to eq('pg_last_xlog_replay_location')
     end
 
     it 'returns new name when using PostgreSQL 10 or newer' do
-      allow(described_class).to receive(:postgresql?).and_return(true)
       allow(described_class).to receive(:version).and_return('10')
 
       expect(described_class.pg_last_wal_replay_lsn).to eq('pg_last_wal_replay_lsn')
@@ -434,7 +393,6 @@ describe Gitlab::Database do
   describe '.db_read_only?' do
     before do
       allow(ActiveRecord::Base.connection).to receive(:execute).and_call_original
-      allow(described_class).to receive(:postgresql?).and_return(true)
     end
 
     it 'detects a read only database' do

spec/models/project_feature_spec.rb

@@ -8,11 +8,7 @@ describe ProjectFeature do
 
   describe '.quoted_access_level_column' do
     it 'returns the table name and quoted column name for a feature' do
-      expected = if Gitlab::Database.postgresql?
-                   '"project_features"."issues_access_level"'
-                 else
-                   '`project_features`.`issues_access_level`'
-                 end
+      expected = '"project_features"."issues_access_level"'
 
       expect(described_class.quoted_access_level_column(:issues)).to eq(expected)
     end