/ - Diff - Redmine

« Previous | Next »

Revision 13252

Added by Toshi MARUYAMA almost 11 years ago

use references

On Rails 4.0:

DEPRECATION WARNING: It looks like you are eager loading table(s) (one of: issues, projects, em)
that are referenced in a string SQL snippet. For example:

    Post.includes(:comments).where("comments.title = 'foo'")

Currently, Active Record recognizes the table in the string, and knows to JOIN the comments table to the query,
rather than loading comments in a separate query.
However, doing this without writing a full-blown SQL parser is inherently flawed.
Since we don't want to write an SQL parser, we are removing this functionality.
From now on, you must explicitly tell Active Record when you are referencing a table from a string:

    Post.includes(:comments).where("comments.title = 'foo'").references(:comments)

If you don't rely on implicit join references you can disable the feature entirely
by setting `config.active_record.disable_implicit_join_references = true`.

sandbox/rails-4.1/app/controllers/boards_controller.rb
46	46	@topics = @board.topics.
47	47	reorder("#{Message.table_name}.sticky DESC").
48	48	joins("LEFT OUTER JOIN #{Message.table_name} last_replies_messages ON last_replies_messages.id = #{Message.table_name}.last_reply_id").
	49	references(:last_reply).
49	50	limit(@topic_pages.per_page).
50	51	offset(@topic_pages.offset).
51	52	order(sort_clause).

       end
       def show
         @journals = @issue.journals.includes(:user, :details).reorder("#{Journal.table_name}.id ASC").to_a
         @journals = @issue.journals.includes(:user, :details).
                         references(:user, :details).
                         reorder("#{Journal.table_name}.id ASC").to_a
         @journals.each_with_index {|j,i| j.indice = i+1}
         @journals.reject!(&:private_notes?) unless User.current.allowed_to?(:view_private_notes, @issue.project)
         Journal.preload_journals_details_custom_fields(@journals)

           where(:project_id => User.current.projects.map(&:id)).
           where("(start_date>=? and start_date<=?) or (due_date>=? and due_date<=?)", startdt, enddt, startdt, enddt).
           includes(:project, :tracker, :priority, :assigned_to).
           references(:project, :tracker, :priority, :assigned_to).
           to_a
       end
-...
           where(:assigned_to_id => ([User.current.id] + User.current.group_ids)).
           limit(10).
           includes(:status, :project, :tracker, :priority).
           references(:status, :project, :tracker, :priority).
           order("#{IssuePriority.table_name}.position DESC, #{Issue.table_name}.updated_on DESC").
           to_a
       end
-...
           where(:author_id => User.current.id).
           limit(10).
           includes(:status, :project, :tracker).
           references(:status, :project, :tracker).
           order("#{Issue.table_name}.updated_on DESC").
           to_a
       end
-...
           where(:project_id => User.current.projects.map(&:id)).
           limit(10).
           includes(:project, :author).
           references(:project, :author).
           order("#{News.table_name}.created_on DESC").
           to_a
       end
-...
         TimeEntry.
           where("#{TimeEntry.table_name}.user_id = ? AND #{TimeEntry.table_name}.spent_on BETWEEN ? AND ?", User.current.id, Date.today - 6, Date.today).
           joins(:activity, :project, {:issue => [:tracker, :status]}).
           references(:activity, :project, {:issue => [:tracker, :status]}).
           order("#{TimeEntry.table_name}.spent_on DESC, #{Project.table_name}.name ASC, #{Tracker.table_name}.position ASC, #{Issue.table_name}.id ASC").
           to_a
       end

       attr_protected :id
       scope :visible, lambda {|*args|
         joins(:project).where(Project.allowed_to_condition(args.shift || User.current, :view_messages, *args))
         joins(:project).
         references(:project).
         where(Project.allowed_to_condition(args.shift || User.current, :view_messages, *args))
+      }
       safe_attributes 'name', 'description', 'parent_id', 'move_to'

       attr_protected :id
       scope :visible, lambda {|*args|
         joins(:repository => :project).where(Project.allowed_to_condition(args.shift || User.current, :view_changesets, *args))
         joins(:repository => :project).
         references(:repository => :project).
         where(Project.allowed_to_condition(args.shift || User.current, :view_changesets, *args))
+      }
       after_create :scan_for_issues

       after_create :send_notification
       scope :visible, lambda {|*args|
         joins(:project).where(Project.allowed_to_condition(args.shift || User.current, :view_documents, *args))
         joins(:project).
         references(:project).
         where(Project.allowed_to_condition(args.shift || User.current, :view_documents, *args))
+      }
       safe_attributes 'category_id', 'title', 'description'

       attr_protected :id
       scope :visible, lambda {|*args|
         joins(:project).where(Issue.visible_condition(args.shift || User.current, *args))
         joins(:project).
         references(:project).
         where(Issue.visible_condition(args.shift || User.current, *args))
+      }
       scope :open, lambda {|*args|
         is_closed = args.size > 0 ? !args.first : false
         joins(:status).where("#{IssueStatus.table_name}.is_closed = ?", is_closed)
         joins(:status).
         references(:status).
         where("#{IssueStatus.table_name}.is_closed = ?", is_closed)
+      }
       scope :recently_updated, lambda { order("#{Issue.table_name}.updated_on DESC") }
       scope :on_active_project, lambda {
         joins(:project).where("#{Project.table_name}.status = ?", Project::STATUS_ACTIVE)
         joins(:project).
         references(:project).
         where("#{Project.table_name}.status = ?", Project::STATUS_ACTIVE)
+      }
       scope :fixed_version, lambda {|versions|
         ids = [versions].flatten.compact.map {|v| v.is_a?(Version) ? v.id : v}
-...
         if issues.any?
           issue_ids = issues.map(&:id)
           # Relations with issue_from in given issues and visible issue_to
           relations_from = IssueRelation.joins(:issue_to => :project).where(visible_condition(user)).where(:issue_from_id => issue_ids).to_a
           relations_from = IssueRelation.joins(:issue_to => :project).
                              references(:issue_to => :project).
                              where(visible_condition(user)).where(:issue_from_id => issue_ids).to_a
           # Relations with issue_to in given issues and visible issue_from
           relations_to = IssueRelation.joins(:issue_from => :project).where(visible_condition(user)).where(:issue_to_id => issue_ids).to_a
           relations_to = IssueRelation.joins(:issue_from => :project).
                              references(:issue_from => :project).
                              where(visible_condition(user)).
                              where(:issue_to_id => issue_ids).to_a
           issues.each do |issue|
             relations =
               relations_from.select {|relation| relation.issue_from_id == issue.id} +
-...
         # Only need to update issues with a fixed_version from
         # a different project and that is not systemwide shared
         Issue.joins(:project, :fixed_version).
           references(:version, :fixed_version).
           where("#{Issue.table_name}.fixed_version_id IS NOT NULL" +
             " AND #{Issue.table_name}.project_id <> #{Version.table_name}.project_id" +
             " AND #{Version.table_name}.sharing <> 'system'").

         user = args.shift || User.current
         base = Project.allowed_to_condition(user, :view_issues, *args)
         scope = joins("LEFT OUTER JOIN #{Project.table_name} ON #{table_name}.project_id = #{Project.table_name}.id").
           references(:project).
           where("#{table_name}.project_id IS NULL OR (#{base})")
         if user.admin?
-...
           joins(:status, :project).
           where(statement).
           includes(([:status, :project] + (options[:include] || [])).uniq).
           references(([:status, :project] + (options[:include] || [])).uniq).
           where(options[:conditions]).
           order(order_option).
           joins(joins_for_order_statement(order_option.join(','))).
-...
           where(project_statement).
           where(options[:conditions]).
           includes(:project).
           references(:project).
           to_a
       rescue ::ActiveRecord::StatementInvalid => e
         raise StatementInvalid.new(e.message)

       scope :visible, lambda {|*args|
         user = args.shift || User.current
         joins(:issue => :project).
         references(:project).
           where(Issue.visible_condition(user, *args)).
           where("(#{Journal.table_name}.private_notes = ? OR (#{Project.allowed_to_condition(user, :view_private_notes, *args)}))", false)
+      }

       after_create :send_notification
       scope :visible, lambda {|*args|
         joins(:board => :project).where(Project.allowed_to_condition(args.shift || User.current, :view_messages, *args))
         joins(:board => :project).
         references(:board => :project).
         where(Project.allowed_to_condition(args.shift || User.current, :view_messages, *args))
+      }
       safe_attributes 'subject', 'content'

       after_create :send_notification
       scope :visible, lambda {|*args|
         joins(:project).where(Project.allowed_to_condition(args.shift || User.current, :view_news, *args))
         joins(:project).
         references([:author, :project]).
         where(Project.allowed_to_condition(args.shift || User.current, :view_news, *args))
+      }
       safe_attributes 'title', 'summary', 'description'

       # Specific overridden Activities
       has_many :time_entry_activities
       has_many :members, lambda {joins(:principal, :roles).where("#{Principal.table_name}.type='User' AND #{Principal.table_name}.status=#{Principal::STATUS_ACTIVE}")}
       has_many :members,
                lambda { joins(:principal, :roles).
                         references(:principal, :roles).
                         where("#{Principal.table_name}.type='User' AND #{Principal.table_name}.status=#{Principal::STATUS_ACTIVE}") }
       has_many :memberships, :class_name => 'Member'
       has_many :member_principals, lambda {joins(:principal).where("#{Principal.table_name}.type='Group' OR (#{Principal.table_name}.type='User' AND #{Principal.table_name}.status=#{Principal::STATUS_ACTIVE})")},
       has_many :member_principals,
                lambda { joins(:principal).
                         references(:principal).
                         where("#{Principal.table_name}.type='Group' OR (#{Principal.table_name}.type='User' AND #{Principal.table_name}.status=#{Principal::STATUS_ACTIVE})")},
         :class_name => 'Member'
       has_many :enabled_modules, :dependent => :delete_all
       has_and_belongs_to_many :trackers, lambda {order("#{Tracker.table_name}.position")}
-...
         @rolled_up_trackers ||=
           Tracker.
             joins(:projects).
             references(:project).
             joins("JOIN #{EnabledModule.table_name} ON #{EnabledModule.table_name}.project_id = #{Project.table_name}.id AND #{EnabledModule.table_name}.name = 'issue_tracking'").
             select("DISTINCT #{Tracker.table_name}.*").
             where("#{Project.table_name}.lft >= ? AND #{Project.table_name}.rgt <= ? AND #{Project.table_name}.status <> #{STATUS_ARCHIVED}", lft, rgt).
-...
         @rolled_up_versions ||=
           Version.
             joins(:project).
             references(:project).
             where("#{Project.table_name}.lft >= ? AND #{Project.table_name}.rgt <= ? AND #{Project.table_name}.status <> ?", lft, rgt, STATUS_ARCHIVED)
       end
-...
         if new_record?
           Version.
             joins(:project).
             references(:project).
             preload(:project).
             where("#{Project.table_name}.status <> ? AND #{Version.table_name}.sharing = 'system'", STATUS_ARCHIVED)
         else
-...
             r = root? ? self : root
             Version.
               joins(:project).
               references(:project).
               preload(:project).
               where("#{Project.table_name}.id = #{id}" +
                       " OR (#{Project.table_name}.status <> #{Project::STATUS_ARCHIVED} AND (" +

       validate :validate_time_entry
       scope :visible, lambda {|*args|
         joins(:project).where(Project.allowed_to_condition(args.shift || User.current, :view_time_entries, *args))
         joins(:project).
         references(:project).
         where(Project.allowed_to_condition(args.shift || User.current, :view_time_entries, *args))
+      }
       scope :on_issue, lambda {|issue|
         joins(:issue).where("#{Issue.table_name}.root_id = #{issue.root_id} AND #{Issue.table_name}.lft >= #{issue.lft} AND #{Issue.table_name}.rgt <= #{issue.rgt}")
         joins(:issue).
         references(:issue).
         where("#{Issue.table_name}.root_id = #{issue.root_id} AND #{Issue.table_name}.lft >= #{issue.lft} AND #{Issue.table_name}.rgt <= #{issue.rgt}")
+      }
       scope :on_project, lambda {|project, include_subprojects|
         joins(:project).where(project.project_condition(include_subprojects))
         joins(:project).
         references(:project).
         where(project.project_condition(include_subprojects))
+      }
       scope :spent_between, lambda {|from, to|
         if from && to

       scope :named, lambda {|arg| where("LOWER(#{table_name}.name) = LOWER(?)", arg.to_s.strip)}
       scope :open, lambda { where(:status => 'open') }
       scope :visible, lambda {|*args|
         joins(:project).where(Project.allowed_to_condition(args.first || User.current, :view_issues))
         joins(:project).
         references(:project).
         where(Project.allowed_to_condition(args.first || User.current, :view_issues))
+      }
       safe_attributes 'name',

       def find_issues_with_query(query)
         Issue.joins(:status, :tracker, :project, :priority).where(
              query.statement
            ).to_a
            ).references([:assigned_to, :status, :tracker, :project, :priority]).to_a
       end
       def assert_find_issues_with_query_is_successful(query)

Also available in: Unified diff

Project

General

Profile

Redmine

Revision 13252

Added by Toshi MARUYAMA almost 11 years ago