Module ActiveRecord::ModelSchema::ClassMethods

# File activerecord/lib/active_record/model_schema.rb, line 376
def column_defaults
  load_schema
  @column_defaults ||= _default_attributes.to_hash
end

# File activerecord/lib/active_record/model_schema.rb, line 387
def column_names
  @column_names ||= columns.map(&:name)
end

# File activerecord/lib/active_record/model_schema.rb, line 340
def columns
  load_schema
  @columns ||= columns_hash.values
end

# File activerecord/lib/active_record/model_schema.rb, line 503
def compute_table_name
  base = base_class
  if self == base
    # Nested classes are prefixed with singular parent table name.
    if parent < Base && !parent.abstract_class?
      contained = parent.table_name
      contained = contained.singularize if parent.pluralize_table_names
      contained += "_"
    end

    "#{full_table_name_prefix}#{contained}#{undecorated_table_name(name)}#{full_table_name_suffix}"
  else
    # STI subclasses always use their superclass' table.
    base.table_name
  end
end

# File activerecord/lib/active_record/model_schema.rb, line 393
def content_columns
  @content_columns ||= columns.reject do |c|
    c.name == primary_key ||
    c.name == inheritance_column ||
    c.name.end_with?("_id") ||
    c.name.end_with?("_count")
  end
end

# File activerecord/lib/active_record/model_schema.rb, line 264
def ignored_columns
  if defined?(@ignored_columns)
    @ignored_columns
  else
    superclass.ignored_columns
  end
end

# File activerecord/lib/active_record/model_schema.rb, line 274
def ignored_columns=(columns)
  @ignored_columns = columns.map(&:to_s)
end

# File activerecord/lib/active_record/model_schema.rb, line 252
def inheritance_column
  (@inheritance_column ||= nil) || superclass.inheritance_column
end

# File activerecord/lib/active_record/model_schema.rb, line 257
def inheritance_column=(value)
  @inheritance_column = value.to_s
  @explicit_inheritance_column = true
end

# File activerecord/lib/active_record/model_schema.rb, line 445
def inherited(child_class)
  super
  child_class.initialize_load_schema_monitor
end

# File activerecord/lib/active_record/model_schema.rb, line 439
def initialize_load_schema_monitor
  @load_schema_monitor = Monitor.new
end

# File activerecord/lib/active_record/model_schema.rb, line 454
      def load_schema
        return if schema_loaded?
        @load_schema_monitor.synchronize do
          return if defined?(@columns_hash) && @columns_hash

          load_schema!

          @schema_loaded = true
        end
      end

      def load_schema!
        @columns_hash = connection.schema_cache.columns_hash(table_name).except(*ignored_columns)
        @columns_hash.each do |name, column|
          define_attribute(
            name,
            connection.lookup_cast_type_from_column(column),
            default: column.default,
            user_provided_default: false
          )
        end
      end

      def reload_schema_from_cache
        @arel_table = nil
        @column_names = nil
        @attribute_types = nil
        @content_columns = nil
        @default_attributes = nil
        @column_defaults = nil
        @inheritance_column = nil unless defined?(@explicit_inheritance_column) && @explicit_inheritance_column
        @attributes_builder = nil
        @columns = nil
        @columns_hash = nil
        @schema_loaded = false
        @attribute_names = nil
        @yaml_encoder = nil
        direct_descendants.each do |descendant|
          descendant.send(:reload_schema_from_cache)
        end
      end

      # Guesses the table name, but does not decorate it with prefix and suffix information.
      def undecorated_table_name(class_name = base_class.name)
        table_name = class_name.to_s.demodulize.underscore
        pluralize_table_names ? table_name.pluralize : table_name
      end

      # Computes and returns a table name according to default conventions.
      def compute_table_name
        base = base_class
        if self == base
          # Nested classes are prefixed with singular parent table name.
          if parent < Base && !parent.abstract_class?
            contained = parent.table_name
            contained = contained.singularize if parent.pluralize_table_names
            contained += "_"
          end

          "#{full_table_name_prefix}#{contained}#{undecorated_table_name(name)}#{full_table_name_suffix}"
        else
          # STI subclasses always use their superclass' table.
          base.table_name
        end
      end
  end
end

# File activerecord/lib/active_record/model_schema.rb, line 465
def load_schema!
  @columns_hash = connection.schema_cache.columns_hash(table_name).except(*ignored_columns)
  @columns_hash.each do |name, column|
    define_attribute(
      name,
      connection.lookup_cast_type_from_column(column),
      default: column.default,
      user_provided_default: false
    )
  end
end

# File activerecord/lib/active_record/model_schema.rb, line 318
def next_sequence_value
  connection.next_sequence_value(sequence_name)
end

# File activerecord/lib/active_record/model_schema.rb, line 312
def prefetch_primary_key?
  connection.prefetch_primary_key?(table_name)
end

# File activerecord/lib/active_record/model_schema.rb, line 230
def protected_environments
  if defined?(@protected_environments)
    @protected_environments
  else
    superclass.protected_environments
  end
end

# File activerecord/lib/active_record/model_schema.rb, line 239
def protected_environments=(environments)
  @protected_environments = environments.map(&:to_s)
end

# File activerecord/lib/active_record/model_schema.rb, line 205
def quoted_table_name
  @quoted_table_name ||= connection.quote_table_name(table_name)
end

# File activerecord/lib/active_record/model_schema.rb, line 477
def reload_schema_from_cache
  @arel_table = nil
  @column_names = nil
  @attribute_types = nil
  @content_columns = nil
  @default_attributes = nil
  @column_defaults = nil
  @inheritance_column = nil unless defined?(@explicit_inheritance_column) && @explicit_inheritance_column
  @attributes_builder = nil
  @columns = nil
  @columns_hash = nil
  @schema_loaded = false
  @attribute_names = nil
  @yaml_encoder = nil
  direct_descendants.each do |descendant|
    descendant.send(:reload_schema_from_cache)
  end
end

# File activerecord/lib/active_record/model_schema.rb, line 428
def reset_column_information
  connection.clear_cache!
  ([self] + descendants).each(&:undefine_attribute_methods)
  connection.schema_cache.clear_data_source_cache!(table_name)

  reload_schema_from_cache
  initialize_find_by_cache
end

# File activerecord/lib/active_record/model_schema.rb, line 450
def schema_loaded?
  defined?(@schema_loaded) && @schema_loaded
end

# File activerecord/lib/active_record/model_schema.rb, line 278
def sequence_name
  if base_class == self
    @sequence_name ||= reset_sequence_name
  else
    (@sequence_name ||= nil) || base_class.sequence_name
  end
end

# File activerecord/lib/active_record/model_schema.rb, line 305
def sequence_name=(value)
  @sequence_name          = value.to_s
  @explicit_sequence_name = true
end

# File activerecord/lib/active_record/model_schema.rb, line 323
def table_exists?
  connection.schema_cache.data_source_exists?(table_name)
end

# File activerecord/lib/active_record/model_schema.rb, line 179
def table_name
  reset_table_name unless defined?(@table_name)
  @table_name
end

# File activerecord/lib/active_record/model_schema.rb, line 189
      def table_name=(value)
        value = value && value.to_s

        if defined?(@table_name)
          return if value == @table_name
          reset_column_information if connected?
        end

        @table_name        = value
        @quoted_table_name = nil
        @arel_table        = nil
        @sequence_name     = nil unless defined?(@explicit_sequence_name) && @explicit_sequence_name
        @predicate_builder = nil
      end

      # Returns a quoted version of the table name, used to construct SQL statements.
      def quoted_table_name
        @quoted_table_name ||= connection.quote_table_name(table_name)
      end

      # Computes the table name, (re)sets it internally, and returns it.
      def reset_table_name #:nodoc:
        self.table_name = if abstract_class?
          superclass == Base ? nil : superclass.table_name
        elsif superclass.abstract_class?
          superclass.table_name || compute_table_name
        else
          compute_table_name
        end
      end

      def full_table_name_prefix #:nodoc:
        (parents.detect { |p| p.respond_to?(:table_name_prefix) } || self).table_name_prefix
      end

      def full_table_name_suffix #:nodoc:
        (parents.detect { |p| p.respond_to?(:table_name_suffix) } || self).table_name_suffix
      end

      # The array of names of environments where destructive actions should be prohibited. By default,
      # the value is <tt>["production"]</tt>.
      def protected_environments
        if defined?(@protected_environments)
          @protected_environments
        else
          superclass.protected_environments
        end
      end

      # Sets an array of names of environments where destructive actions should be prohibited.
      def protected_environments=(environments)
        @protected_environments = environments.map(&:to_s)
      end

      # Defines the name of the table column which will store the class name on single-table
      # inheritance situations.
      #
      # The default inheritance column name is +type+, which means it's a
      # reserved word inside Active Record. To be able to use single-table
      # inheritance with another column name, or to use the column +type+ in
      # your own model for something else, you can set +inheritance_column+:
      #
      #     self.inheritance_column = 'zoink'
      def inheritance_column
        (@inheritance_column ||= nil) || superclass.inheritance_column
      end

      # Sets the value of inheritance_column
      def inheritance_column=(value)
        @inheritance_column = value.to_s
        @explicit_inheritance_column = true
      end

      # The list of columns names the model should ignore. Ignored columns won't have attribute
      # accessors defined, and won't be referenced in SQL queries.
      def ignored_columns
        if defined?(@ignored_columns)
          @ignored_columns
        else
          superclass.ignored_columns
        end
      end

      # Sets the columns names the model should ignore. Ignored columns won't have attribute
      # accessors defined, and won't be referenced in SQL queries.
      def ignored_columns=(columns)
        @ignored_columns = columns.map(&:to_s)
      end

      def sequence_name
        if base_class == self
          @sequence_name ||= reset_sequence_name
        else
          (@sequence_name ||= nil) || base_class.sequence_name
        end
      end

      def reset_sequence_name #:nodoc:
        @explicit_sequence_name = false
        @sequence_name          = connection.default_sequence_name(table_name, primary_key)
      end

      # Sets the name of the sequence to use when generating ids to the given
      # value, or (if the value is +nil+ or +false+) to the value returned by the
      # given block. This is required for Oracle and is useful for any
      # database which relies on sequences for primary key generation.
      #
      # If a sequence name is not explicitly set when using Oracle,
      # it will default to the commonly used pattern of: #{table_name}_seq
      #
      # If a sequence name is not explicitly set when using PostgreSQL, it
      # will discover the sequence corresponding to your primary key for you.
      #
      #   class Project < ActiveRecord::Base
      #     self.sequence_name = "projectseq"   # default would have been "project_seq"
      #   end
      def sequence_name=(value)
        @sequence_name          = value.to_s
        @explicit_sequence_name = true
      end

      # Determines if the primary key values should be selected from their
      # corresponding sequence before the insert statement.
      def prefetch_primary_key?
        connection.prefetch_primary_key?(table_name)
      end

      # Returns the next value that will be used as the primary key on
      # an insert statement.
      def next_sequence_value
        connection.next_sequence_value(sequence_name)
      end

      # Indicates whether the table associated with this class exists
      def table_exists?
        connection.schema_cache.data_source_exists?(table_name)
      end

      def attributes_builder # :nodoc:
        unless defined?(@attributes_builder) && @attributes_builder
          defaults = _default_attributes.except(*(column_names - [primary_key]))
          @attributes_builder = ActiveModel::AttributeSet::Builder.new(attribute_types, defaults)
        end
        @attributes_builder
      end

      def columns_hash # :nodoc:
        load_schema
        @columns_hash
      end

      def columns
        load_schema
        @columns ||= columns_hash.values
      end

      def attribute_types # :nodoc:
        load_schema
        @attribute_types ||= Hash.new(Type.default_value)
      end

      def yaml_encoder # :nodoc:
        @yaml_encoder ||= ActiveModel::AttributeSet::YAMLEncoder.new(attribute_types)
      end

      # Returns the type of the attribute with the given name, after applying
      # all modifiers. This method is the only valid source of information for
      # anything related to the types of a model's attributes. This method will
      # access the database and load the model's schema if it is required.
      #
      # The return value of this method will implement the interface described
      # by ActiveModel::Type::Value (though the object itself may not subclass
      # it).
      #
      # +attr_name+ The name of the attribute to retrieve the type for. Must be
      # a string or a symbol.
      def type_for_attribute(attr_name, &block)
        attr_name = attr_name.to_s
        if block
          attribute_types.fetch(attr_name, &block)
        else
          attribute_types[attr_name]
        end
      end

      # Returns a hash where the keys are column names and the values are
      # default values when instantiating the Active Record object for this table.
      def column_defaults
        load_schema
        @column_defaults ||= _default_attributes.to_hash
      end

      def _default_attributes # :nodoc:
        load_schema
        @default_attributes ||= ActiveModel::AttributeSet.new({})
      end

      # Returns an array of column names as strings.
      def column_names
        @column_names ||= columns.map(&:name)
      end

      # Returns an array of column objects where the primary id, all columns ending in "_id" or "_count",
      # and columns used for single table inheritance have been removed.
      def content_columns
        @content_columns ||= columns.reject do |c|
          c.name == primary_key ||
          c.name == inheritance_column ||
          c.name.end_with?("_id") ||
          c.name.end_with?("_count")
        end
      end

      # Resets all the cached information about columns, which will cause them
      # to be reloaded on the next request.
      #
      # The most common usage pattern for this method is probably in a migration,
      # when just after creating a table you want to populate it with some default
      # values, eg:
      #
      #  class CreateJobLevels < ActiveRecord::Migration[5.0]
      #    def up
      #      create_table :job_levels do |t|
      #        t.integer :id
      #        t.string :name
      #
      #        t.timestamps
      #      end
      #
      #      JobLevel.reset_column_information
      #      %w{assistant executive manager director}.each do |type|
      #        JobLevel.create(name: type)
      #      end
      #    end
      #
      #    def down
      #      drop_table :job_levels
      #    end
      #  end
      def reset_column_information
        connection.clear_cache!
        ([self] + descendants).each(&:undefine_attribute_methods)
        connection.schema_cache.clear_data_source_cache!(table_name)

        reload_schema_from_cache
        initialize_find_by_cache
      end

      protected

        def initialize_load_schema_monitor
          @load_schema_monitor = Monitor.new
        end

      private

        def inherited(child_class)
          super
          child_class.initialize_load_schema_monitor
        end

        def schema_loaded?
          defined?(@schema_loaded) && @schema_loaded
        end

        def load_schema
          return if schema_loaded?
          @load_schema_monitor.synchronize do
            return if defined?(@columns_hash) && @columns_hash

            load_schema!

            @schema_loaded = true
          end
        end

        def load_schema!
          @columns_hash = connection.schema_cache.columns_hash(table_name).except(*ignored_columns)
          @columns_hash.each do |name, column|
            define_attribute(
              name,
              connection.lookup_cast_type_from_column(column),
              default: column.default,
              user_provided_default: false
            )
          end
        end

        def reload_schema_from_cache
          @arel_table = nil
          @column_names = nil
          @attribute_types = nil
          @content_columns = nil
          @default_attributes = nil
          @column_defaults = nil
          @inheritance_column = nil unless defined?(@explicit_inheritance_column) && @explicit_inheritance_column
          @attributes_builder = nil
          @columns = nil
          @columns_hash = nil
          @schema_loaded = false
          @attribute_names = nil
          @yaml_encoder = nil
          direct_descendants.each do |descendant|
            descendant.send(:reload_schema_from_cache)
          end
        end

        # Guesses the table name, but does not decorate it with prefix and suffix information.
        def undecorated_table_name(class_name = base_class.name)
          table_name = class_name.to_s.demodulize.underscore
          pluralize_table_names ? table_name.pluralize : table_name
        end

        # Computes and returns a table name according to default conventions.
        def compute_table_name
          base = base_class
          if self == base
            # Nested classes are prefixed with singular parent table name.
            if parent < Base && !parent.abstract_class?
              contained = parent.table_name
              contained = contained.singularize if parent.pluralize_table_names
              contained += "_"
            end

            "#{full_table_name_prefix}#{contained}#{undecorated_table_name(name)}#{full_table_name_suffix}"
          else
            # STI subclasses always use their superclass' table.
            base.table_name
          end
        end
    end
  end
end

# File activerecord/lib/active_record/model_schema.rb, line 365
def type_for_attribute(attr_name, &block)
  attr_name = attr_name.to_s
  if block
    attribute_types.fetch(attr_name, &block)
  else
    attribute_types[attr_name]
  end
end

# File activerecord/lib/active_record/model_schema.rb, line 497
def undecorated_table_name(class_name = base_class.name)
  table_name = class_name.to_s.demodulize.underscore
  pluralize_table_names ? table_name.pluralize : table_name
end