Please enable JavaScript.

Coggle requires JavaScript to display documents.

ruby on rails model (validation (validate methods (validates :attributes .…

- - - - methods
        
        association(force_reload = false)
        
        association=(associate)
        
        build_association(attributes = {})
        
        create_association(attributes = {})
        
        create_association!(attributes = {})
      - options
        
        :autosave
        
        :counter_cache
        
        :class_name
        
        :dependent
        
        :foreign_key
        
        :inverse_of
        
        :polymorphic
        
        :touch
      - Scopes where select includes readonly
    - - method = belongs_to
      - options compare with belongs_to
        :polymorphic => :as
        : through, :source, :source_type
      - scopes = belongs_to
    - - methods
        
        collection(force_reload = false)
        
        collection<<(object, ...)
        
        collection.delete(object, ...)
        
        collection.destroy(object, ...)
        
        collection=(objects)
        
        collection_singular_ids
        
        collection_singular_ids=(ids)
        
        collection.clear
        
        collection.empty?
        
        collection.size
        
        collection.find(...)
        
        collection.where(...)
        
        collection.exists?(...)
        
        collection.build(attributes = {}, ...)
        
        collection.create(attributes = {})
        
        collection.create!(attributes = {})
      - options = has_one
      - scope + limit offset group uniq
- - - - before_validation
      - after_validation
      - before_save
      - around_save
      - before_create(update)
      - around_create(update)
      - after_create(update)
      - after_save
      - after_commit
  - - - find
      - take
      - first
      - last
      - find_by
    - - all
      - find_each
      - find_in_batches {|array| }
      - where
    - - string
      - array
      - Hash Conditions: Author.joins(:articles).where(articles: { author: author })
      - Placeholder Conditions
      - Range Condition Client.where(created_at: (Time.now.midnight )..Time.now.midnight)
      - Subset Conditions
      - NOT Conditions
    - - unscope
      - only
      - reorder, reverse_order
      - rewhere
    - - Item.lock("LOCK IN SHARE MODE").find(1)
      - item.with_lock {}
      - lock version
    - - joins for searching, string & association
      - includes for reading
    - - select_all, update_all, delete_all