SONAR-4301 Remove project_id when querying issues

4 files changed, 55 insertions, 52 deletions

diff --git a/sonar-core/src/main/java/org/sonar/core/issue/db/IssueDao.java b/sonar-core/src/main/java/org/sonar/core/issue/db/IssueDao.java
index 9c46d100585..7489e27e786 100644
--- a/sonar-core/src/main/java/org/sonar/core/issue/db/IssueDao.java
+++ b/sonar-core/src/main/java/org/sonar/core/issue/db/IssueDao.java
@@ -71,19 +71,20 @@ public class IssueDao implements BatchComponent, ServerComponent {
   }
 
   @VisibleForTesting
-  List<IssueDto> selectIssueAndProjectIds(IssueQuery query, Collection<Integer> authorizedRootProjectIds, Integer maxResult) {
+  List<IssueDto> selectIssues(IssueQuery query, Collection<Integer> authorizedRootProjectIds, Integer maxResult) {
     SqlSession session = mybatis.openSession();
     try {
-      return selectIssueAndProjectIds(query, authorizedRootProjectIds, maxResult, session);
+      return selectIssues(query, authorizedRootProjectIds, maxResult, session);
     } finally {
       MyBatis.closeQuietly(session);
     }
   }
 
-  List<IssueDto> selectIssueAndProjectIds(IssueQuery query, Collection<Integer> authorizedRootProjectIds) {
+  @VisibleForTesting
+  List<IssueDto> selectIssues(IssueQuery query, Collection<Integer> authorizedRootProjectIds) {
     SqlSession session = mybatis.openSession();
     try {
-      return selectIssueAndProjectIds(query, authorizedRootProjectIds, Integer.MAX_VALUE, session);
+      return selectIssues(query, authorizedRootProjectIds, Integer.MAX_VALUE, session);
     } finally {
       MyBatis.closeQuietly(session);
     }
@@ -92,17 +93,17 @@ public class IssueDao implements BatchComponent, ServerComponent {
   /**
    * The returned IssueDto list contains only the issue id, the project id and the sort column
    */
-  public List<IssueDto> selectIssueAndProjectIds(IssueQuery query, Collection<Integer> authorizedRootProjectIds, SqlSession session){
-    return selectIssueAndProjectIds(query, authorizedRootProjectIds, query.maxResults(), session);
+  public List<IssueDto> selectIssues(IssueQuery query, Collection<Integer> authorizedRootProjectIds, SqlSession session){
+    return selectIssues(query, authorizedRootProjectIds, query.maxResults(), session);
   }
 
-  private List<IssueDto> selectIssueAndProjectIds(IssueQuery query, Collection<Integer> authorizedRootProjectIds, Integer maxResults, SqlSession session){
+  private List<IssueDto> selectIssues(IssueQuery query, Collection<Integer> authorizedRootProjectIds, Integer maxResults, SqlSession session){
     if (authorizedRootProjectIds.isEmpty()) {
       return Collections.emptyList();
     }
     IssueMapper mapper = session.getMapper(IssueMapper.class);
     List<List<Integer>> idsPartition = Lists.partition(newArrayList(authorizedRootProjectIds), 1000);
-    return mapper.selectIssueAndProjectIds(query, idsPartition, maxResults);
+    return mapper.selectIssues(query, idsPartition, maxResults);
   }
 
   @VisibleForTesting
diff --git a/sonar-core/src/main/java/org/sonar/core/issue/db/IssueMapper.java b/sonar-core/src/main/java/org/sonar/core/issue/db/IssueMapper.java
index 210f04a3d15..59826460c46 100644
--- a/sonar-core/src/main/java/org/sonar/core/issue/db/IssueMapper.java
+++ b/sonar-core/src/main/java/org/sonar/core/issue/db/IssueMapper.java
@@ -30,7 +30,7 @@ public interface IssueMapper {
 
   List<IssueDto> selectNonClosedIssues(int rootComponentId);
 
-  List<IssueDto> selectIssueAndProjectIds(@Param("query") IssueQuery query, @Param("authorizedRootProjectIds") List<List<Integer>> authorizedRootProjectIds,
+  List<IssueDto> selectIssues(@Param("query") IssueQuery query, @Param("authorizedRootProjectIds") List<List<Integer>> authorizedRootProjectIds,
                                           @Param("maxResults") Integer maxResult);
 
   void insert(IssueDto issue);
diff --git a/sonar-core/src/main/resources/org/sonar/core/issue/db/IssueMapper.xml b/sonar-core/src/main/resources/org/sonar/core/issue/db/IssueMapper.xml
index 90e60093e22..2b2f9f5969c 100644
--- a/sonar-core/src/main/resources/org/sonar/core/issue/db/IssueMapper.xml
+++ b/sonar-core/src/main/resources/org/sonar/core/issue/db/IssueMapper.xml
@@ -30,8 +30,12 @@
     i.updated_at as updatedAt,
     r.plugin_rule_key as ruleKey,
     r.plugin_name as ruleRepo,
-    p.kee as componentKey,
-    root.kee as projectKey
+    p.kee as componentKey
+  </sql>
+
+  <sql id="issueColumnsWitRoot">
+    <include refid="issueColumns"/>
+    , root.kee as projectKey
   </sql>
 
   <sql id="sortColumn">
@@ -113,14 +117,14 @@
 
   <select id="selectByKey" parameterType="String" resultType="Issue">
     select
-    <include refid="issueColumns"/>
+    <include refid="issueColumnsWitRoot"/>
     from issues i, rules r, projects p, projects root
     where i.kee=#{kee} and i.rule_id=r.id and p.id=i.resource_id and i.project_id=root.id
   </select>
 
   <select id="selectNonClosedIssues" parameterType="int" resultType="Issue">
     select distinct
-    <include refid="issueColumns"/>
+    <include refid="issueColumnsWitRoot"/>
     from issues i, rules r, projects p, projects root
     where i.status &lt;&gt; 'CLOSED'
     and (p.root_id=#{id} or (p.root_id is null and p.id=#{id}))
@@ -131,7 +135,7 @@
 
   <select id="selectByIds" parameterType="map" resultType="Issue">
     select
-    <include refid="issueColumns"/>
+    <include refid="issueColumnsWitRoot"/>
     from issues i, rules r, projects p, projects root
     <where>
       and
@@ -146,8 +150,8 @@
     </where>
   </select>
 
-  <select id="selectIssueAndProjectIds" parameterType="map" resultType="Issue" fetchSize="100000">
-    select i.id, i.project_id as projectId
+  <select id="selectIssues" parameterType="map" resultType="Issue" fetchSize="100000">
+    select i.id
     <include refid="sortColumn"/>
     <include refid="selectQueryConditions"/>
     <if test="_databaseId != 'oracle'">
@@ -163,7 +167,7 @@
   </select>
 
   <sql id="selectQueryConditions">
-    from issues i, projects p, rules r, projects root
+    from issues i, projects p, rules r
     <if test="query.componentRoots() != null and query.componentRoots().size() > 0">
       , projects rootprojects, snapshots rootsnapshots, snapshots s
     </if>
@@ -172,7 +176,6 @@
     </if>
     <where>
       and i.resource_id=p.id
-      and i.project_id=root.id
       and
       <foreach collection="authorizedRootProjectIds" open="i.project_id in (" close=")" item="list" separator=") or i.project_id in in (">
         <foreach collection="list" item="element" separator=",">
diff --git a/sonar-core/src/test/java/org/sonar/core/issue/db/IssueDaoTest.java b/sonar-core/src/test/java/org/sonar/core/issue/db/IssueDaoTest.java
index 5c262b7d813..c7bc22653c8 100644
--- a/sonar-core/src/test/java/org/sonar/core/issue/db/IssueDaoTest.java
+++ b/sonar-core/src/test/java/org/sonar/core/issue/db/IssueDaoTest.java
@@ -81,13 +81,13 @@ public class IssueDaoTest extends AbstractDaoTestCase {
     setupData("shared", "should_select_by_rules");
 
     IssueQuery query = IssueQuery.builder().rules(newArrayList(RuleKey.of("squid", "AvoidCycle"))).build();
-    assertThat(dao.selectIssueAndProjectIds(query, newArrayList(399))).hasSize(2);
+    assertThat(dao.selectIssues(query, newArrayList(399))).hasSize(2);
 
     query = IssueQuery.builder().rules(newArrayList(RuleKey.of("squid", "AvoidCycle"), RuleKey.of("squid", "NullRef"))).build();
-    assertThat(dao.selectIssueAndProjectIds(query, newArrayList(399))).hasSize(3);
+    assertThat(dao.selectIssues(query, newArrayList(399))).hasSize(3);
 
     query = IssueQuery.builder().rules(newArrayList(RuleKey.of("squid", "Other"))).build();
-    assertThat(dao.selectIssueAndProjectIds(query, newArrayList(399))).isEmpty();
+    assertThat(dao.selectIssues(query, newArrayList(399))).isEmpty();
   }
 
   @Test
@@ -95,10 +95,10 @@ public class IssueDaoTest extends AbstractDaoTestCase {
     setupData("shared", "should_select_by_date_creation");
 
     IssueQuery query = IssueQuery.builder().createdAfter(DateUtils.parseDate("2013-04-15")).build();
-    assertThat(dao.selectIssueAndProjectIds(query, newArrayList(399))).hasSize(1);
+    assertThat(dao.selectIssues(query, newArrayList(399))).hasSize(1);
 
     query = IssueQuery.builder().createdBefore(DateUtils.parseDate("2013-04-17")).build();
-    assertThat(dao.selectIssueAndProjectIds(query, newArrayList(399))).hasSize(2);
+    assertThat(dao.selectIssues(query, newArrayList(399))).hasSize(2);
   }
 
   @Test
@@ -106,24 +106,24 @@ public class IssueDaoTest extends AbstractDaoTestCase {
     setupData("shared", "should_select_by_component_root");
 
     IssueQuery query = IssueQuery.builder().componentRoots(newArrayList("struts")).build();
-    List<IssueDto> issues = newArrayList(dao.selectIssueAndProjectIds(query, newArrayList(399)));
+    List<IssueDto> issues = newArrayList(dao.selectIssues(query, newArrayList(399)));
     assertThat(issues).hasSize(2);
     assertThat(issues.get(0).getId()).isEqualTo(100);
     assertThat(issues.get(1).getId()).isEqualTo(101);
 
     query = IssueQuery.builder().componentRoots(newArrayList("struts-core")).build();
-    issues = newArrayList(dao.selectIssueAndProjectIds(query, newArrayList(399)));
+    issues = newArrayList(dao.selectIssues(query, newArrayList(399)));
     assertThat(issues).hasSize(2);
     assertThat(issues.get(0).getId()).isEqualTo(100);
     assertThat(issues.get(1).getId()).isEqualTo(101);
 
     query = IssueQuery.builder().componentRoots(newArrayList("Filter.java")).build();
-    issues = newArrayList(dao.selectIssueAndProjectIds(query, newArrayList(399)));
+    issues = newArrayList(dao.selectIssues(query, newArrayList(399)));
     assertThat(issues).hasSize(1);
     assertThat(issues.get(0).getId()).isEqualTo(101);
 
     query = IssueQuery.builder().componentRoots(newArrayList("not-found")).build();
-    issues = newArrayList(dao.selectIssueAndProjectIds(query, newArrayList(399)));
+    issues = newArrayList(dao.selectIssues(query, newArrayList(399)));
     assertThat(issues).isEmpty();
   }
 
@@ -132,15 +132,15 @@ public class IssueDaoTest extends AbstractDaoTestCase {
     setupData("shared", "should_select_by_assigned");
 
     IssueQuery query = IssueQuery.builder().assigned(true).build();
-    List<IssueDto> issues = newArrayList(dao.selectIssueAndProjectIds(query, newArrayList(399)));
+    List<IssueDto> issues = newArrayList(dao.selectIssues(query, newArrayList(399)));
     assertThat(issues).hasSize(2);
 
     query = IssueQuery.builder().assigned(false).build();
-    issues = newArrayList(dao.selectIssueAndProjectIds(query, newArrayList(399)));
+    issues = newArrayList(dao.selectIssues(query, newArrayList(399)));
     assertThat(issues).hasSize(1);
 
     query = IssueQuery.builder().assigned(null).build();
-    issues = newArrayList(dao.selectIssueAndProjectIds(query, newArrayList(399)));
+    issues = newArrayList(dao.selectIssues(query, newArrayList(399)));
     assertThat(issues).hasSize(3);
   }
 
@@ -149,15 +149,15 @@ public class IssueDaoTest extends AbstractDaoTestCase {
     setupData("shared", "should_select_by_planned");
 
     IssueQuery query = IssueQuery.builder().planned(true).build();
-    List<IssueDto> issues = newArrayList(dao.selectIssueAndProjectIds(query, newArrayList(399)));
+    List<IssueDto> issues = newArrayList(dao.selectIssues(query, newArrayList(399)));
     assertThat(issues).hasSize(2);
 
     query = IssueQuery.builder().planned(false).build();
-    issues = newArrayList(dao.selectIssueAndProjectIds(query, newArrayList(399)));
+    issues = newArrayList(dao.selectIssues(query, newArrayList(399)));
     assertThat(issues).hasSize(1);
 
     query = IssueQuery.builder().planned(null).build();
-    issues = newArrayList(dao.selectIssueAndProjectIds(query, newArrayList(399)));
+    issues = newArrayList(dao.selectIssues(query, newArrayList(399)));
     assertThat(issues).hasSize(3);
   }
 
@@ -166,15 +166,15 @@ public class IssueDaoTest extends AbstractDaoTestCase {
     setupData("shared", "should_select_by_resolved");
 
     IssueQuery query = IssueQuery.builder().resolved(true).build();
-    List<IssueDto> issues = newArrayList(dao.selectIssueAndProjectIds(query, newArrayList(399)));
+    List<IssueDto> issues = newArrayList(dao.selectIssues(query, newArrayList(399)));
     assertThat(issues).hasSize(2);
 
     query = IssueQuery.builder().resolved(false).build();
-    issues = newArrayList(dao.selectIssueAndProjectIds(query, newArrayList(399)));
+    issues = newArrayList(dao.selectIssues(query, newArrayList(399)));
     assertThat(issues).hasSize(1);
 
     query = IssueQuery.builder().resolved(null).build();
-    issues = newArrayList(dao.selectIssueAndProjectIds(query, newArrayList(399)));
+    issues = newArrayList(dao.selectIssues(query, newArrayList(399)));
     assertThat(issues).hasSize(3);
   }
 
@@ -183,13 +183,13 @@ public class IssueDaoTest extends AbstractDaoTestCase {
     setupData("shared", "should_select_by_action_plans");
 
     IssueQuery query = IssueQuery.builder().actionPlans(newArrayList("ABC")).build();
-    assertThat(dao.selectIssueAndProjectIds(query, newArrayList(399))).hasSize(2);
+    assertThat(dao.selectIssues(query, newArrayList(399))).hasSize(2);
 
     query = IssueQuery.builder().actionPlans(newArrayList("ABC", "DEF")).build();
-    assertThat(dao.selectIssueAndProjectIds(query, newArrayList(399))).hasSize(3);
+    assertThat(dao.selectIssues(query, newArrayList(399))).hasSize(3);
 
     query = IssueQuery.builder().actionPlans(newArrayList("<Unkown>")).build();
-    assertThat(dao.selectIssueAndProjectIds(query, newArrayList(399))).isEmpty();
+    assertThat(dao.selectIssues(query, newArrayList(399))).isEmpty();
   }
 
   @Test
@@ -197,54 +197,53 @@ public class IssueDaoTest extends AbstractDaoTestCase {
     setupData("shared", "should_select_all");
 
     IssueQuery query = IssueQuery.builder().build();
-    assertThat(dao.selectIssueAndProjectIds(query, newArrayList(399))).hasSize(3);
+    assertThat(dao.selectIssues(query, newArrayList(399))).hasSize(3);
   }
 
   @Test
-  public void should_select_issue_and_project_ids() {
+  public void should_select_issues() {
     setupData("shared", "should_select_issue_and_project_ids");
 
     IssueQuery query = IssueQuery.builder().build();
-    List<IssueDto> results = dao.selectIssueAndProjectIds(query, newArrayList(399));
+    List<IssueDto> results = dao.selectIssues(query, newArrayList(399));
     assertThat(results).hasSize(3);
 
     IssueDto issueDto = results.get(0);
     assertThat(issueDto.getId()).isNotNull();
-    assertThat(issueDto.getProjectId()).isNotNull();
 
-    results = dao.selectIssueAndProjectIds(query, Collections.<Integer>emptyList());
+    results = dao.selectIssues(query, Collections.<Integer>emptyList());
     assertThat(results).isEmpty();
 
-    results = dao.selectIssueAndProjectIds(query, newArrayList(399), 2);
+    results = dao.selectIssues(query, newArrayList(399), 2);
     assertThat(results).hasSize(2);
   }
 
   @Test
-  public void should_select_issue_and_project_ids_with_sort_column() {
+  public void should_select_issues_with_sort_column() {
     setupData("shared", "should_select_issue_and_project_ids");
 
     IssueQuery query = IssueQuery.builder().sort(IssueQuery.Sort.ASSIGNEE).build();
-    List<IssueDto> results = dao.selectIssueAndProjectIds(query, newArrayList(399));
+    List<IssueDto> results = dao.selectIssues(query, newArrayList(399));
     assertThat(results.get(0).getAssignee()).isNotNull();
 
     query = IssueQuery.builder().sort(IssueQuery.Sort.SEVERITY).build();
-    results = dao.selectIssueAndProjectIds(query, newArrayList(399));
+    results = dao.selectIssues(query, newArrayList(399));
     assertThat(results.get(0).getSeverity()).isNotNull();
 
     query = IssueQuery.builder().sort(IssueQuery.Sort.STATUS).build();
-    results = dao.selectIssueAndProjectIds(query, newArrayList(399));
+    results = dao.selectIssues(query, newArrayList(399));
     assertThat(results.get(0).getStatus()).isNotNull();
 
     query = IssueQuery.builder().sort(IssueQuery.Sort.CREATION_DATE).build();
-    results = dao.selectIssueAndProjectIds(query, newArrayList(399));
+    results = dao.selectIssues(query, newArrayList(399));
     assertThat(results.get(0).getIssueCreationDate()).isNotNull();
 
     query = IssueQuery.builder().sort(IssueQuery.Sort.UPDATE_DATE).build();
-    results = dao.selectIssueAndProjectIds(query, newArrayList(399));
+    results = dao.selectIssues(query, newArrayList(399));
     assertThat(results.get(0).getIssueUpdateDate()).isNotNull();
 
     query = IssueQuery.builder().sort(IssueQuery.Sort.CLOSE_DATE).build();
-    results = dao.selectIssueAndProjectIds(query, newArrayList(399));
+    results = dao.selectIssues(query, newArrayList(399));
     assertThat(results.get(0).getIssueCloseDate()).isNotNull();
   }