Class: ApplicationRecord

Inherits:

ActiveRecord::Base

Object
ActiveRecord::Base
ApplicationRecord

Includes:: CrossDatabaseModification, DatabaseReflection, LegacyBulkInsert, ResetOnUnionError, SensitiveSerializableHash, Transactions

Defined in:: app/models/application_record.rb

Direct Known Subclasses

Constant Summary collapse

MAX_PLUCK = We should avoid using pluck docs.gitlab.com/ee/development/sql.html#plucking-ids but, if we are going to use it, let’s try and limit the number of records

1_000

Constants included from ResetOnUnionError

ResetOnUnionError::MAX_RESET_PERIOD

Class Method Summary collapse

.cached_column_list ⇒ Object
.declarative_enum(enum_mod) ⇒ Object
.default_select_columns ⇒ Object
.id_in(ids) ⇒ Object
.id_not_in(ids) ⇒ Object
.iid_in(iids) ⇒ Object
.pluck_primary_key ⇒ Object
.primary_key_in(values) ⇒ Object
.safe_ensure_unique(retries: 0) ⇒ Object
.safe_find_or_create_by(*args, &block) ⇒ Object
.safe_find_or_create_by!(*args, &block) ⇒ Object
.underscore ⇒ Object
.where_exists(query) ⇒ Object
.where_not_exists(query) ⇒ Object
.with_fast_read_statement_timeout(timeout_ms = 4500) ⇒ Object

Start a new transaction with a shorter-than-usual statement timeout.
.without_order ⇒ Object

Instance Method Summary collapse

Methods included from SensitiveSerializableHash

#serializable_hash

Class Method Details

.cached_column_list ⇒ `Object`



114
115
116

# File 'app/models/application_record.rb', line 114

def self.cached_column_list
  column_names.map { |column_name| arel_table[column_name] }
end

.declarative_enum(enum_mod) ⇒ `Object`



110
111
112

# File 'app/models/application_record.rb', line 110

def self.declarative_enum(enum_mod)
  enum(enum_mod.key => enum_mod.values)
end

.default_select_columns ⇒ `Object`

# File 'app/models/application_record.rb', line 118

def self.default_select_columns
  if ignored_columns.any?
    cached_column_list
  else
    arel_table[Arel.star]
  end
end

.id_in(ids) ⇒ `Object`



23
24
25

# File 'app/models/application_record.rb', line 23

def self.id_in(ids)
  where(id: ids)
end

.id_not_in(ids) ⇒ `Object`



35
36
37

# File 'app/models/application_record.rb', line 35

def self.id_not_in(ids)
  where.not(id: ids)
end

.iid_in(iids) ⇒ `Object`



31
32
33

# File 'app/models/application_record.rb', line 31

def self.iid_in(iids)
  where(iid: iids)
end

.pluck_primary_key ⇒ `Object`



39
40
41

# File 'app/models/application_record.rb', line 39

def self.pluck_primary_key
  where(nil).pluck(primary_key)
end

.primary_key_in(values) ⇒ `Object`



27
28
29

# File 'app/models/application_record.rb', line 27

def self.primary_key_in(values)
  where(primary_key => values)
end

.safe_ensure_unique(retries: 0) ⇒ `Object`

# File 'app/models/application_record.rb', line 43

def self.safe_ensure_unique(retries: 0)
  transaction(requires_new: true) do # rubocop:disable Performance/ActiveRecordSubtransactions
    yield
  end
rescue ActiveRecord::RecordNotUnique
  if retries > 0
    retries -= 1
    retry
  end

  false
end

.safe_find_or_create_by(*args, &block) ⇒ `Object`

# File 'app/models/application_record.rb', line 78

def self.safe_find_or_create_by(*args, &block)
  record = find_by(*args)
  return record if record.present?

  # We need to use `all.create` to make this implementation follow `find_or_create_by` which delegates this in
  # https://github.com/rails/rails/blob/v6.1.3.2/activerecord/lib/active_record/querying.rb#L22
  #
  # When calling this method on an association, just calling `self.create` would call `ActiveRecord::Persistence.create`
  # and that skips some code that adds the newly created record to the association.
  transaction(requires_new: true) { all.create(*args, &block) } # rubocop:disable Performance/ActiveRecordSubtransactions
rescue ActiveRecord::RecordNotUnique
  find_by(*args)
end

.safe_find_or_create_by!(*args, &block) ⇒ `Object`

# File 'app/models/application_record.rb', line 56

def self.safe_find_or_create_by!(*args, &block)
  safe_find_or_create_by(*args, &block).tap do |record|
    raise ActiveRecord::RecordNotFound unless record.present?

    record.validate! unless record.persisted?
  end
end

.underscore ⇒ `Object`



98
99
100

# File 'app/models/application_record.rb', line 98

def self.underscore
  @underscore ||= to_s.underscore
end

.where_exists(query) ⇒ `Object`



102
103
104

# File 'app/models/application_record.rb', line 102

def self.where_exists(query)
  where('EXISTS (?)', query.select(1))
end

.where_not_exists(query) ⇒ `Object`



106
107
108

# File 'app/models/application_record.rb', line 106

def self.where_not_exists(query)
  where('NOT EXISTS (?)', query.select(1))
end

.with_fast_read_statement_timeout(timeout_ms = 4500) ⇒ `Object`

Start a new transaction with a shorter-than-usual statement timeout. This is currently one third of the default 15-second timeout with a 500ms buffer to allow callers gracefully handling the errors to still complete within the 5s target duration of a low urgency request.

# File 'app/models/application_record.rb', line 68

def self.with_fast_read_statement_timeout(timeout_ms = 4500)
  ::Gitlab::Database::LoadBalancing::Session.current.fallback_to_replicas_for_ambiguous_queries do
    transaction(requires_new: true) do # rubocop:disable Performance/ActiveRecordSubtransactions
      connection.exec_query("SET LOCAL statement_timeout = #{timeout_ms}")

      yield
    end
  end
end

.without_order ⇒ `Object`



19
20
21

# File 'app/models/application_record.rb', line 19

def self.without_order
  reorder(nil)
end

Instance Method Details

#create_or_load_association(association_name) ⇒ `Object`

# File 'app/models/application_record.rb', line 92

def create_or_load_association(association_name)
  association(association_name).create unless association(association_name).loaded?
rescue ActiveRecord::RecordNotUnique, PG::UniqueViolation
  association(association_name).reader
end

#readable_by?(user) ⇒ `Boolean`

Returns:

(Boolean)



126
127
128

# File 'app/models/application_record.rb', line 126

def readable_by?(user)
  Ability.allowed?(user, "read_#{to_ability_name}".to_sym, self)
end

#to_ability_name ⇒ `Object`



130
131
132

# File 'app/models/application_record.rb', line 130

def to_ability_name
  model_name.element
end

Class: ApplicationRecord

Direct Known Subclasses

Constant Summary collapse

Constants included from ResetOnUnionError

Class Method Summary collapse

Instance Method Summary collapse

Methods included from SensitiveSerializableHash

Class Method Details

.cached_column_list ⇒ Object

.declarative_enum(enum_mod) ⇒ Object

.default_select_columns ⇒ Object

.id_in(ids) ⇒ Object

.id_not_in(ids) ⇒ Object

.iid_in(iids) ⇒ Object

.pluck_primary_key ⇒ Object

.primary_key_in(values) ⇒ Object

.safe_ensure_unique(retries: 0) ⇒ Object

.safe_find_or_create_by(*args, &block) ⇒ Object

.safe_find_or_create_by!(*args, &block) ⇒ Object

.underscore ⇒ Object

.where_exists(query) ⇒ Object

.where_not_exists(query) ⇒ Object

.with_fast_read_statement_timeout(timeout_ms = 4500) ⇒ Object

.without_order ⇒ Object