[checkstyle] Enable check style for all the components

pinot-compatibility-verifier/pom.xml

@@ -84,6 +84,10 @@
           <groupId>net.minidev</groupId>
           <artifactId>json-smart</artifactId>
         </exclusion>
+        <exclusion>
+          <groupId>com.typesafe.netty</groupId>
+          <artifactId>netty-reactive-streams</artifactId>
+        </exclusion>
       </exclusions>
     </dependency>
     <dependency>
@@ -96,12 +100,24 @@
       <groupId>org.testng</groupId>
       <artifactId>testng</artifactId>
       <scope>runtime</scope>
+      <exclusions>
+        <exclusion>
+          <groupId>com.beust</groupId>
+          <artifactId>jcommander</artifactId>
+        </exclusion>
+      </exclusions>
     </dependency>
     <dependency>
       <groupId>org.apache.pinot</groupId>
       <artifactId>pinot-controller</artifactId>
       <version>${project.version}</version>
       <type>test-jar</type>
+      <exclusions>
+        <exclusion>
+          <groupId>jakarta.activation</groupId>
+          <artifactId>jakarta.activation-api</artifactId>
+        </exclusion>
+      </exclusions>
     </dependency>
     <!-- Kafka  -->
     <dependency>

pinot-connectors/pinot-spark-2-connector/pom.xml

@@ -38,9 +38,6 @@
     <scalaxml.version>1.3.0</scalaxml.version>
     <scalatest.version>3.1.1</scalatest.version>
     <shadeBase>org.apache.pinot.\$internal</shadeBase>
-
-    <!-- TODO: delete this prop once all the checkstyle warnings are fixed -->
-    <checkstyle.fail.on.violation>false</checkstyle.fail.on.violation>
   </properties>
 
   <profiles>

pinot-connectors/pinot-spark-3-connector/pom.xml

@@ -37,9 +37,6 @@
     <antlr-runtime.version>4.8</antlr-runtime.version>
     <scalatest.version>3.1.1</scalatest.version>
     <shadeBase>org.apache.pinot.\$internal</shadeBase>
-
-    <!-- TODO: delete this prop once all the checkstyle warnings are fixed -->
-    <checkstyle.fail.on.violation>false</checkstyle.fail.on.violation>
   </properties>
 
   <profiles>

pinot-connectors/pinot-spark-common/pom.xml

@@ -37,9 +37,6 @@
     <paranameter.version>2.8</paranameter.version>
     <scalaxml.version>1.3.0</scalaxml.version>
     <scalatest.version>3.1.1</scalatest.version>
-
-    <!-- TODO: delete this prop once all the checkstyle warnings are fixed -->
-    <checkstyle.fail.on.violation>false</checkstyle.fail.on.violation>
   </properties>
 
   <profiles>

pinot-connectors/pinot-spark-common/src/main/java/org/apache/pinot/connector/spark/common/CaseInsensitiveStringMap.java

@@ -41,39 +41,39 @@
  * keys converted to lower case. This map doesn't allow null key.
  */
 public class CaseInsensitiveStringMap implements Map<String, String> {
-  private final Logger logger = LoggerFactory.getLogger(CaseInsensitiveStringMap.class);
+  private final Logger _logger = LoggerFactory.getLogger(CaseInsensitiveStringMap.class);
 
-  private String unsupportedOperationMsg = "CaseInsensitiveStringMap is read-only.";
+  private String _unsupportedOperationMsg = "CaseInsensitiveStringMap is read-only.";
 
   public static CaseInsensitiveStringMap empty() {
     return new CaseInsensitiveStringMap(new HashMap<>(0));
   }
 
-  private final Map<String, String> original;
+  private final Map<String, String> _original;
 
-  private final Map<String, String> delegate;
+  private final Map<String, String> _delegate;
 
   public CaseInsensitiveStringMap(Map<String, String> originalMap) {
-    original = new HashMap<>(originalMap);
-    delegate = new HashMap<>(originalMap.size());
+    _original = new HashMap<>(originalMap);
+    _delegate = new HashMap<>(originalMap.size());
     for (Map.Entry<String, String> entry : originalMap.entrySet()) {
       String key = toLowerCase(entry.getKey());
-      if (delegate.containsKey(key)) {
-        logger.warn("Converting duplicated key " + entry.getKey() +
-            " into CaseInsensitiveStringMap.");
+      if (_delegate.containsKey(key)) {
+        _logger.warn("Converting duplicated key " + entry.getKey()
+            + " into CaseInsensitiveStringMap.");
       }
-      delegate.put(key, entry.getValue());
+      _delegate.put(key, entry.getValue());
     }
   }
 
   @Override
   public int size() {
-    return delegate.size();
+    return _delegate.size();
   }
 
   @Override
   public boolean isEmpty() {
-    return delegate.isEmpty();
+    return _delegate.isEmpty();
   }
 
   private String toLowerCase(Object key) {
@@ -82,52 +82,52 @@ private String toLowerCase(Object key) {
 
   @Override
   public boolean containsKey(Object key) {
-    return delegate.containsKey(toLowerCase(key));
+    return _delegate.containsKey(toLowerCase(key));
   }
 
   @Override
   public boolean containsValue(Object value) {
-    return delegate.containsValue(value);
+    return _delegate.containsValue(value);
   }
 
   @Override
   public String get(Object key) {
-    return delegate.get(toLowerCase(key));
+    return _delegate.get(toLowerCase(key));
   }
 
   @Override
   public String put(String key, String value) {
-    throw new UnsupportedOperationException(unsupportedOperationMsg);
+    throw new UnsupportedOperationException(_unsupportedOperationMsg);
   }
 
   @Override
   public String remove(Object key) {
-    throw new UnsupportedOperationException(unsupportedOperationMsg);
+    throw new UnsupportedOperationException(_unsupportedOperationMsg);
   }
 
   @Override
   public void putAll(Map<? extends String, ? extends String> m) {
-    throw new UnsupportedOperationException(unsupportedOperationMsg);
+    throw new UnsupportedOperationException(_unsupportedOperationMsg);
   }
 
   @Override
   public void clear() {
-    throw new UnsupportedOperationException(unsupportedOperationMsg);
+    throw new UnsupportedOperationException(_unsupportedOperationMsg);
   }
 
   @Override
   public Set<String> keySet() {
-    return delegate.keySet();
+    return _delegate.keySet();
   }
 
   @Override
   public Collection<String> values() {
-    return delegate.values();
+    return _delegate.values();
   }
 
   @Override
   public Set<Map.Entry<String, String>> entrySet() {
-    return delegate.entrySet();
+    return _delegate.entrySet();
   }
 
   /**
@@ -179,7 +179,7 @@ public double getDouble(String key, double defaultValue) {
    * Returns the original case-sensitive map.
    */
   public Map<String, String> asCaseSensitiveMap() {
-    return Collections.unmodifiableMap(original);
+    return Collections.unmodifiableMap(_original);
   }
 
   @Override
@@ -191,11 +191,11 @@ public boolean equals(Object o) {
       return false;
     }
     CaseInsensitiveStringMap that = (CaseInsensitiveStringMap) o;
-    return delegate.equals(that.delegate);
+    return _delegate.equals(that._delegate);
   }
 
   @Override
   public int hashCode() {
-    return Objects.hash(delegate);
+    return Objects.hash(_delegate);
   }
 }

pinot-integration-test-base/pom.xml

@@ -38,8 +38,6 @@
     <localstack-utils.version>0.2.11</localstack-utils.version>
     <awaitility.version>3.0.0</awaitility.version>
     <aws.sdk.version>2.14.28</aws.sdk.version>
-    <!-- TODO: delete this prop once all the checkstyle warnings are fixed -->
-    <checkstyle.fail.on.violation>false</checkstyle.fail.on.violation>
   </properties>
 
   <build>

pinot-integration-test-base/src/test/java/org/apache/pinot/integration/tests/QueryGenerator.java

@@ -508,25 +508,26 @@ public String generateH2Query() {
       List<String> h2AggregateColumnAndFunctions = new ArrayList<>();
       for (String aggregateColumnAndFunction : _aggregateColumnsAndFunctions) {
         String h2AggregateColumnAndFunction;
-        if (!aggregateColumnAndFunction.equals("COUNT(*)")) {
-          aggregateColumnAndFunction = aggregateColumnAndFunction.replace("(", "(`").replace(")", "`)");
+        String pinotAggregateFunction = aggregateColumnAndFunction;
+        if (!pinotAggregateFunction.equals("COUNT(*)")) {
+          pinotAggregateFunction = pinotAggregateFunction.replace("(", "(`").replace(")", "`)");
         }
-        if (!aggregateColumnAndFunction.contains("(")) {
-          aggregateColumnAndFunction = String.format("`%s`", aggregateColumnAndFunction);
+        if (!pinotAggregateFunction.contains("(")) {
+          pinotAggregateFunction = String.format("`%s`", pinotAggregateFunction);
         }
         // Make 'AVG' and
-        if (aggregateColumnAndFunction.startsWith("DISTINCTCOUNT(")) {
+        if (pinotAggregateFunction.startsWith("DISTINCTCOUNT(")) {
           // make 'DISTINCTCOUNT(..)' compatible with H2 SQL query using 'COUNT(DISTINCT(..)'
-          h2AggregateColumnAndFunction = aggregateColumnAndFunction.replace("DISTINCTCOUNT(", "COUNT(DISTINCT ");
-        } else if (AGGREGATION_FUNCTIONS.contains(aggregateColumnAndFunction.substring(0, 3))) {
+          h2AggregateColumnAndFunction = pinotAggregateFunction.replace("DISTINCTCOUNT(", "COUNT(DISTINCT ");
+        } else if (AGGREGATION_FUNCTIONS.contains(pinotAggregateFunction.substring(0, 3))) {
           // make AGG functions (SUM, MIN, MAX, AVG) compatible with H2 SQL query.
           // this is because Pinot queries casts all to double before doing aggregation
-          String aggFunctionName = aggregateColumnAndFunction.substring(0, 3);
-          h2AggregateColumnAndFunction = aggregateColumnAndFunction
+          String aggFunctionName = pinotAggregateFunction.substring(0, 3);
+          h2AggregateColumnAndFunction = pinotAggregateFunction
               .replace(aggFunctionName + "(", aggFunctionName + "(CAST(")
               .replace(")", " AS DOUBLE))");
         } else {
-          h2AggregateColumnAndFunction = aggregateColumnAndFunction;
+          h2AggregateColumnAndFunction = pinotAggregateFunction;
         }
         h2AggregateColumnAndFunctions.add(h2AggregateColumnAndFunction);
       }