Delete unused ComponentQuery#language

diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/component/ComponentQuery.java b/server/sonar-db-dao/src/main/java/org/sonar/db/component/ComponentQuery.java
index 01fc40ca2cf42fe5c66ac7bfb79d48b7fd72737e..42c97fcc66cf2dd6a921fcaea0c0a1c75f4ce847 100644 (file)
--- a/server/sonar-db-dao/src/main/java/org/sonar/db/component/ComponentQuery.java
+++ b/server/sonar-db-dao/src/main/java/org/sonar/db/component/ComponentQuery.java
@@ -34,7 +34,6 @@ public class ComponentQuery {
   private final String nameOrKeyQuery;
   private final boolean partialMatchOnKey;
   private final String[] qualifiers;
-  private final String language;
   private final Boolean isPrivate;
   private final Set<Long> componentIds;
   private final Set<String> componentUuids;
@@ -48,7 +47,6 @@ public class ComponentQuery {
     this.nameOrKeyQuery = builder.nameOrKeyQuery;
     this.partialMatchOnKey = builder.partialMatchOnKey == null ? false : builder.partialMatchOnKey;
     this.qualifiers = builder.qualifiers;
-    this.language = builder.language;
     this.componentIds = builder.componentIds;
     this.componentUuids = builder.componentUuids;
     this.componentKeys = builder.componentKeys;
@@ -83,11 +81,6 @@ public class ComponentQuery {
     return partialMatchOnKey;
   }
 
-  @CheckForNull
-  public String getLanguage() {
-    return language;
-  }
-
   @CheckForNull
   public Set<Long> getComponentIds() {
     return componentIds;
@@ -140,7 +133,6 @@ public class ComponentQuery {
     private String nameOrKeyQuery;
     private Boolean partialMatchOnKey;
     private String[] qualifiers;
-    private String language;
     private Boolean isPrivate;
     private Set<Long> componentIds;
     private Set<String> componentUuids;
@@ -168,11 +160,6 @@ public class ComponentQuery {
       return this;
     }
 
-    public Builder setLanguage(@Nullable String language) {
-      this.language = language;
-      return this;
-    }
-
     public Builder setComponentIds(@Nullable Set<Long> componentIds) {
       this.componentIds = componentIds;
       return this;

diff --git a/server/sonar-db-dao/src/main/resources/org/sonar/db/component/ComponentMapper.xml b/server/sonar-db-dao/src/main/resources/org/sonar/db/component/ComponentMapper.xml
index d4c71a6ee39415156113d853eeb7a3f1eb8d8ab5..d67984456c39c23832f6a491d2b0fe98ba7ad1da 100644 (file)
--- a/server/sonar-db-dao/src/main/resources/org/sonar/db/component/ComponentMapper.xml
+++ b/server/sonar-db-dao/src/main/resources/org/sonar/db/component/ComponentMapper.xml
@@ -307,9 +307,6 @@
             #{qualifier,jdbcType=VARCHAR}
           </foreach>
       </if>
-      <if test="query.language!=null">
-        and p.language = #{query.language,jdbcType=VARCHAR}
-      </if>
       <if test="query.componentIds!=null">
         and p.id in
         <foreach collection="query.componentIds" item="componentId" open="(" close=")" separator=",">

diff --git a/server/sonar-db-dao/src/test/java/org/sonar/db/component/ComponentDaoTest.java b/server/sonar-db-dao/src/test/java/org/sonar/db/component/ComponentDaoTest.java
index 4d7f7d2b46c1af3c6535db9cf2ef3c1f36f53d97..56075591440276c26cc7f90e911a679bdf679dbd 100644 (file)
--- a/server/sonar-db-dao/src/test/java/org/sonar/db/component/ComponentDaoTest.java
+++ b/server/sonar-db-dao/src/test/java/org/sonar/db/component/ComponentDaoTest.java
@@ -1537,18 +1537,6 @@ public class ComponentDaoTest {
     assertThat(result.get(0).getDbKey()).isEqualTo("project-key");
   }
 
-  @Test
-  public void selectByQuery_filter_on_language() {
-    db.components().insertComponent(newPrivateProjectDto(db.getDefaultOrganization()).setDbKey("java-project-key").setLanguage("java"));
-    db.components().insertComponent(newPrivateProjectDto(db.getDefaultOrganization()).setDbKey("cpp-project-key").setLanguage("cpp"));
-
-    ComponentQuery query = ComponentQuery.builder().setLanguage("java").setQualifiers(PROJECT).build();
-    List<ComponentDto> result = underTest.selectByQuery(dbSession, query, 0, 10);
-
-    assertThat(result).hasSize(1);
-    assertThat(result.get(0).getDbKey()).isEqualTo("java-project-key");
-  }
-
   @Test
   public void selectByQuery_filter_last_analysis_date() {
     long aLongTimeAgo = 1_000_000_000L;
@@ -1560,19 +1548,19 @@ public class ComponentDaoTest {
     db.components().insertSnapshot(recentProject, s -> s.setCreatedAt(aLongTimeAgo).setLast(false));
 
     // before date
-    assertThat(selectProjectUuidsByQuery(q -> q.setAnalyzedBefore(recentTime), 0, 10))
+    assertThat(selectProjectUuidsByQuery(q -> q.setAnalyzedBefore(recentTime)))
       .containsExactlyInAnyOrder(oldProject.uuid());
-    assertThat(selectProjectUuidsByQuery(q -> q.setAnalyzedBefore(aLongTimeAgo), 0, 10))
+    assertThat(selectProjectUuidsByQuery(q -> q.setAnalyzedBefore(aLongTimeAgo)))
       .isEmpty();
-    assertThat(selectProjectUuidsByQuery(q -> q.setAnalyzedBefore(recentTime + 1_000L), 0, 10))
+    assertThat(selectProjectUuidsByQuery(q -> q.setAnalyzedBefore(recentTime + 1_000L)))
       .containsExactlyInAnyOrder(oldProject.uuid(), recentProject.uuid());
 
     // after date
-    assertThat(selectProjectUuidsByQuery(q -> q.setAnalyzedAfter(recentTime - 1_000L), 0, 10))
+    assertThat(selectProjectUuidsByQuery(q -> q.setAnalyzedAfter(recentTime - 1_000L)))
       .containsExactlyInAnyOrder(recentProject.uuid());
-    assertThat(selectProjectUuidsByQuery(q -> q.setAnalyzedAfter(recentTime + 1_000L), 0, 10))
+    assertThat(selectProjectUuidsByQuery(q -> q.setAnalyzedAfter(recentTime + 1_000L)))
       .isEmpty();
-    assertThat(selectProjectUuidsByQuery(q -> q.setAnalyzedAfter(aLongTimeAgo), 0, 10))
+    assertThat(selectProjectUuidsByQuery(q -> q.setAnalyzedAfter(aLongTimeAgo)))
       .containsExactlyInAnyOrder(oldProject.uuid(), recentProject.uuid());
   }
 
@@ -1592,11 +1580,11 @@ public class ComponentDaoTest {
     db.components().insertSnapshot(recentProjectBranch, s -> s.setCreatedAt(aLongTimeAgo).setLast(false));
 
     // after date
-    assertThat(selectProjectUuidsByQuery(q -> q.setAnalyzedAfter(recentTime - 1_000L), 0, 10))
+    assertThat(selectProjectUuidsByQuery(q -> q.setAnalyzedAfter(recentTime - 1_000L)))
       .containsExactlyInAnyOrder(recentProject.uuid());
-    assertThat(selectProjectUuidsByQuery(q -> q.setAnalyzedAfter(recentTime + 1_000L), 0, 10))
+    assertThat(selectProjectUuidsByQuery(q -> q.setAnalyzedAfter(recentTime + 1_000L)))
       .isEmpty();
-    assertThat(selectProjectUuidsByQuery(q -> q.setAnalyzedAfter(aLongTimeAgo), 0, 10))
+    assertThat(selectProjectUuidsByQuery(q -> q.setAnalyzedAfter(aLongTimeAgo)))
       .containsExactlyInAnyOrder(oldProject.uuid(), recentProject.uuid());
   }
 
@@ -1605,18 +1593,19 @@ public class ComponentDaoTest {
     ComponentDto project1 = db.components().insertPrivateProject(p -> p.setCreatedAt(parseDate("2018-02-01")));
     ComponentDto project2 = db.components().insertPrivateProject(p -> p.setCreatedAt(parseDate("2018-06-01")));
 
-    assertThat(selectProjectUuidsByQuery(q -> q.setCreatedAfter(parseDate("2017-12-01")), 0, 10))
+    assertThat(selectProjectUuidsByQuery(q -> q.setCreatedAfter(parseDate("2017-12-01"))))
       .containsExactlyInAnyOrder(project1.uuid(), project2.uuid());
-    assertThat(selectProjectUuidsByQuery(q -> q.setCreatedAfter(parseDate("2018-02-20")), 0, 10))
+    assertThat(selectProjectUuidsByQuery(q -> q.setCreatedAfter(parseDate("2018-02-20"))))
       .containsExactlyInAnyOrder(project2.uuid());
-    assertThat(selectProjectUuidsByQuery(q -> q.setCreatedAfter(parseDate("2019-01-01")), 0, 10))
+
+    assertThat(selectProjectUuidsByQuery(q -> q.setCreatedAfter(parseDate("2019-01-01"))))
       .isEmpty();
   }
 
-  private List<String> selectProjectUuidsByQuery(Consumer<ComponentQuery.Builder> query, int offset, int limit) {
+  private List<String> selectProjectUuidsByQuery(Consumer<ComponentQuery.Builder> query) {
     ComponentQuery.Builder builder = ComponentQuery.builder().setQualifiers(PROJECT);
     query.accept(builder);
-    return underTest.selectByQuery(dbSession, builder.build(), offset, limit)
+    return underTest.selectByQuery(dbSession, builder.build(), 0, 5)
       .stream()
       .map(ComponentDto::uuid)
       .collect(Collectors.toList());

diff --git a/server/sonar-db-dao/src/test/java/org/sonar/db/component/ComponentQueryTest.java b/server/sonar-db-dao/src/test/java/org/sonar/db/component/ComponentQueryTest.java
index 10e8d6389a2dc6235f7982712df787d856eef01a..e9d060978ac22b9ab2b3b1790d551eacb2b1a639 100644 (file)
--- a/server/sonar-db-dao/src/test/java/org/sonar/db/component/ComponentQueryTest.java
+++ b/server/sonar-db-dao/src/test/java/org/sonar/db/component/ComponentQueryTest.java
@@ -19,6 +19,7 @@
  */
 package org.sonar.db.component;
 
+import java.util.Date;
 import java.util.function.Supplier;
 import org.junit.Rule;
 import org.junit.Test;
@@ -38,15 +39,17 @@ public class ComponentQueryTest {
   public void build_query() {
     ComponentQuery underTest = ComponentQuery.builder()
       .setNameOrKeyQuery("key")
-      .setLanguage("java")
-      .setAnalyzedBefore(1_000_000_000L)
+      .setAnalyzedBefore(100L)
+      .setAnalyzedAfter(200L)
+      .setCreatedAfter(new Date(300L))
       .setQualifiers(PROJECT)
       .build();
 
     assertThat(underTest.getNameOrKeyQuery()).isEqualTo("key");
-    assertThat(underTest.getLanguage()).isEqualTo("java");
     assertThat(underTest.getQualifiers()).containsOnly(PROJECT);
-    assertThat(underTest.getAnalyzedBefore()).isEqualTo(1_000_000_000L);
+    assertThat(underTest.getAnalyzedBefore()).isEqualTo(100L);
+    assertThat(underTest.getAnalyzedAfter()).isEqualTo(200L);
+    assertThat(underTest.getCreatedAfter().getTime()).isEqualTo(300L);
     assertThat(underTest.isOnProvisionedOnly()).isFalse();
     assertThat(underTest.isPartialMatchOnKey()).isFalse();
     assertThat(underTest.hasEmptySetOfComponents()).isFalse();
@@ -59,7 +62,6 @@ public class ComponentQueryTest {
       .build();
 
     assertThat(underTest.getNameOrKeyQuery()).isNull();
-    assertThat(underTest.getLanguage()).isNull();
     assertThat(underTest.getQualifiers()).containsOnly(PROJECT);
   }
 
@@ -90,7 +92,7 @@ public class ComponentQueryTest {
     expectedException.expect(IllegalArgumentException.class);
     expectedException.expectMessage("At least one qualifier must be provided");
 
-    ComponentQuery.builder().setLanguage("java").build();
+    ComponentQuery.builder().build();
   }
 
   @Test