github-advanced-security[bot] commented on code in PR #18939:
URL: https://github.com/apache/druid/pull/18939#discussion_r2714646373
##########
server/src/test/java/org/apache/druid/server/compaction/CompactionStatusTest.java:
##########
@@ -884,4 +895,304 @@
null
);
}
+
+ // ============================
+ // computeRequiredSetOfFilterRulesForCandidate tests
+ // ============================
+
+ @Test
+ public void testComputeRequiredFilters_SingleFilter_NotOrFilter_ReturnsAsIs()
+ {
+ DimFilter filterA = new SelectorDimFilter("country", "US", null);
+ NotDimFilter expectedFilter = new NotDimFilter(filterA);
+
+ CompactionCandidate candidate = createCandidateWithFingerprints("fp1");
+
+ NotDimFilter result =
CompactionStatus.computeRequiredSetOfFilterRulesForCandidate(
+ candidate,
+ expectedFilter,
+ fingerprintMapper
+ );
+
+ Assert.assertEquals(expectedFilter, result);
+ }
+
+ @Test
+ public void testComputeRequiredFilters_AllFiltersAlreadyApplied_ReturnsNull()
+ {
+ DimFilter filterA = new SelectorDimFilter("country", "US", null);
+ DimFilter filterB = new SelectorDimFilter("country", "UK", null);
+ DimFilter filterC = new SelectorDimFilter("country", "FR", null);
+
+ CompactionState state = createStateWithFilters("fp1", filterA, filterB,
filterC);
+ indexingStateStorage.upsertIndexingState(TestDataSource.WIKI, "fp1",
state, DateTimes.nowUtc());
+ syncCacheFromManager();
+
+ NotDimFilter expectedFilter = new NotDimFilter(new
OrDimFilter(Arrays.asList(filterA, filterB, filterC)));
+ CompactionCandidate candidate = createCandidateWithFingerprints("fp1");
+
+ NotDimFilter result =
CompactionStatus.computeRequiredSetOfFilterRulesForCandidate(
+ candidate,
+ expectedFilter,
+ fingerprintMapper
+ );
+
+ Assert.assertNull(result);
+ }
+
+ @Test
+ public void testComputeRequiredFilters_NoFiltersApplied_ReturnsAllExpected()
+ {
+ DimFilter filterA = new SelectorDimFilter("country", "US", null);
+ DimFilter filterB = new SelectorDimFilter("country", "UK", null);
+ DimFilter filterC = new SelectorDimFilter("country", "FR", null);
+
+ CompactionState state = createStateWithoutFilters("fp1");
+ indexingStateStorage.upsertIndexingState(TestDataSource.WIKI, "fp1",
state, DateTimes.nowUtc());
+ syncCacheFromManager();
+
+ NotDimFilter expectedFilter = new NotDimFilter(new
OrDimFilter(Arrays.asList(filterA, filterB, filterC)));
+ CompactionCandidate candidate = createCandidateWithFingerprints("fp1");
+
+ NotDimFilter result =
CompactionStatus.computeRequiredSetOfFilterRulesForCandidate(
+ candidate,
+ expectedFilter,
+ fingerprintMapper
+ );
+
+ OrDimFilter innerOr = (OrDimFilter) result.getField();
+ Assert.assertEquals(3, innerOr.getFields().size());
+ Assert.assertTrue(innerOr.getFields().containsAll(Arrays.asList(filterA,
filterB, filterC)));
+ }
+
+ @Test
+ public void testComputeRequiredFilters_PartiallyApplied_ReturnsDelta()
+ {
+ DimFilter filterA = new SelectorDimFilter("country", "US", null);
+ DimFilter filterB = new SelectorDimFilter("country", "UK", null);
+ DimFilter filterC = new SelectorDimFilter("country", "FR", null);
+ DimFilter filterD = new SelectorDimFilter("country", "DE", null);
+
+ CompactionState state = createStateWithFilters("fp1", filterA, filterB);
+ indexingStateStorage.upsertIndexingState(TestDataSource.WIKI, "fp1",
state, DateTimes.nowUtc());
+ syncCacheFromManager();
+
+ NotDimFilter expectedFilter = new NotDimFilter(
+ new OrDimFilter(Arrays.asList(filterA, filterB, filterC, filterD))
+ );
+ CompactionCandidate candidate = createCandidateWithFingerprints("fp1");
+
+ NotDimFilter result =
CompactionStatus.computeRequiredSetOfFilterRulesForCandidate(
+ candidate,
+ expectedFilter,
+ fingerprintMapper
+ );
+
+ OrDimFilter innerOr = (OrDimFilter) result.getField();
+ Set<DimFilter> resultSet = new HashSet<>(innerOr.getFields());
+ Set<DimFilter> expectedSet = new HashSet<>(Arrays.asList(filterC,
filterD));
+
+ Assert.assertEquals(expectedSet, resultSet);
+ }
+
+ @Test
+ public void testComputeRequiredFilters_MultipleFingerprints_UnionOfMissing()
+ {
+ DimFilter filterA = new SelectorDimFilter("country", "US", null);
+ DimFilter filterB = new SelectorDimFilter("country", "UK", null);
+ DimFilter filterC = new SelectorDimFilter("country", "FR", null);
+ DimFilter filterD = new SelectorDimFilter("country", "DE", null);
+
+ CompactionState state1 = createStateWithFilters("fp1", filterA, filterB);
+ CompactionState state2 = createStateWithFilters("fp2", filterA, filterC);
+ DateTime now = DateTimes.nowUtc();
+ indexingStateStorage.upsertIndexingState(TestDataSource.WIKI, "fp1",
state1, now);
+ indexingStateStorage.upsertIndexingState(TestDataSource.WIKI, "fp2",
state2, now);
+ syncCacheFromManager();
+
+ NotDimFilter expectedFilter = new NotDimFilter(
+ new OrDimFilter(Arrays.asList(filterA, filterB, filterC, filterD))
+ );
+ CompactionCandidate candidate = createCandidateWithFingerprints("fp1",
"fp2");
+
+ NotDimFilter result =
CompactionStatus.computeRequiredSetOfFilterRulesForCandidate(
+ candidate,
+ expectedFilter,
+ fingerprintMapper
+ );
+
+ OrDimFilter innerOr = (OrDimFilter) result.getField();
+ Set<DimFilter> resultSet = new HashSet<>(innerOr.getFields());
+ Set<DimFilter> expectedSet = new HashSet<>(Arrays.asList(filterB, filterC,
filterD));
+
+ Assert.assertEquals(expectedSet, resultSet);
+ }
+
+ @Test
+ public void testComputeRequiredFilters_MultipleFingerprints_NoDuplicates()
+ {
+ DimFilter filterA = new SelectorDimFilter("country", "US", null);
+ DimFilter filterB = new SelectorDimFilter("country", "UK", null);
+ DimFilter filterC = new SelectorDimFilter("country", "FR", null);
+
+ CompactionState state1 = createStateWithFilters("fp1", filterA);
+ CompactionState state2 = createStateWithFilters("fp2", filterA);
+ DateTime now = DateTimes.nowUtc();
+ indexingStateStorage.upsertIndexingState(TestDataSource.WIKI, "fp1",
state1, now);
+ indexingStateStorage.upsertIndexingState(TestDataSource.WIKI, "fp2",
state2, now);
+ syncCacheFromManager();
+
+ NotDimFilter expectedFilter = new NotDimFilter(
+ new OrDimFilter(Arrays.asList(filterA, filterB, filterC))
+ );
+ CompactionCandidate candidate = createCandidateWithFingerprints("fp1",
"fp2");
+
+ NotDimFilter result =
CompactionStatus.computeRequiredSetOfFilterRulesForCandidate(
+ candidate,
+ expectedFilter,
+ fingerprintMapper
+ );
+
+ OrDimFilter innerOr = (OrDimFilter) result.getField();
+ Set<DimFilter> resultSet = new HashSet<>(innerOr.getFields());
+
+ Assert.assertEquals(2, resultSet.size());
+ Assert.assertTrue(resultSet.containsAll(Arrays.asList(filterB, filterC)));
+ }
+
+ @Test
+ public void
testComputeRequiredFilters_MissingCompactionState_ReturnsAllFilters()
+ {
+ DimFilter filterA = new SelectorDimFilter("country", "US", null);
+ DimFilter filterB = new SelectorDimFilter("country", "UK", null);
+ DimFilter filterC = new SelectorDimFilter("country", "FR", null);
+
+ // No state persisted for fp1
+ NotDimFilter expectedFilter = new NotDimFilter(
+ new OrDimFilter(Arrays.asList(filterA, filterB, filterC))
+ );
+ CompactionCandidate candidate = createCandidateWithFingerprints("fp1");
+
+ NotDimFilter result =
CompactionStatus.computeRequiredSetOfFilterRulesForCandidate(
+ candidate,
+ expectedFilter,
+ fingerprintMapper
+ );
+
+ Assert.assertEquals(expectedFilter, result);
+ }
+
+ @Test
+ public void testComputeRequiredFilters_TransformSpecWithSingleFilter()
+ {
+ DimFilter filterA = new SelectorDimFilter("country", "US", null);
+ DimFilter filterB = new SelectorDimFilter("country", "UK", null);
+ DimFilter filterC = new SelectorDimFilter("country", "FR", null);
+
+ CompactionState state = createStateWithSingleFilter("fp1", filterA);
+ indexingStateStorage.upsertIndexingState(TestDataSource.WIKI, "fp1",
state, DateTimes.nowUtc());
+ syncCacheFromManager();
+
+ NotDimFilter expectedFilter = new NotDimFilter(
+ new OrDimFilter(Arrays.asList(filterA, filterB, filterC))
+ );
+ CompactionCandidate candidate = createCandidateWithFingerprints("fp1");
+
+ NotDimFilter result =
CompactionStatus.computeRequiredSetOfFilterRulesForCandidate(
+ candidate,
+ expectedFilter,
+ fingerprintMapper
+ );
+
+ OrDimFilter innerOr = (OrDimFilter) result.getField();
+ Assert.assertEquals(2, innerOr.getFields().size());
+ Assert.assertTrue(innerOr.getFields().containsAll(Arrays.asList(filterB,
filterC)));
+ }
+
+ @Test
+ public void testComputeRequiredFilters_SegmentsWithNoFingerprints()
+ {
+ DimFilter filterA = new SelectorDimFilter("country", "US", null);
+ DimFilter filterB = new SelectorDimFilter("country", "UK", null);
+ DimFilter filterC = new SelectorDimFilter("country", "FR", null);
+
+ CompactionCandidate candidate = createCandidateWithNullFingerprints(3);
+
+ NotDimFilter expectedFilter = new NotDimFilter(
+ new OrDimFilter(Arrays.asList(filterA, filterB, filterC))
+ );
+
+ NotDimFilter result =
CompactionStatus.computeRequiredSetOfFilterRulesForCandidate(
+ candidate,
+ expectedFilter,
+ fingerprintMapper
+ );
+
+ Assert.assertEquals(expectedFilter, result);
+ }
+
+ // Helper methods for filter tests
+
+ private CompactionCandidate createCandidateWithFingerprints(String...
fingerprints)
+ {
+ List<DataSegment> segments = Arrays.stream(fingerprints)
+ .map(fp ->
DataSegment.builder(WIKI_SEGMENT).indexingStateFingerprint(fp).build())
+ .collect(Collectors.toList());
+ return CompactionCandidate.from(segments, null);
+ }
+
+ private CompactionCandidate createCandidateWithNullFingerprints(int count)
+ {
+ List<DataSegment> segments = new ArrayList<>();
+ for (int i = 0; i < count; i++) {
+
segments.add(DataSegment.builder(WIKI_SEGMENT).indexingStateFingerprint(null).build());
+ }
+ return CompactionCandidate.from(segments, null);
+ }
+
+ private CompactionState createStateWithFilters(String fingerprint,
DimFilter... filters)
+ {
+ OrDimFilter orFilter = new OrDimFilter(Arrays.asList(filters));
+ NotDimFilter notFilter = new NotDimFilter(orFilter);
+ CompactionTransformSpec transformSpec = new
CompactionTransformSpec(notFilter);
+
+ return new CompactionState(
+ null,
+ null,
+ null,
+ transformSpec,
+ IndexSpec.getDefault(),
+ null,
+ null
+ );
+ }
+
+ private CompactionState createStateWithSingleFilter(String fingerprint,
DimFilter filter)
+ {
+ NotDimFilter notFilter = new NotDimFilter(filter);
+ CompactionTransformSpec transformSpec = new
CompactionTransformSpec(notFilter);
+
+ return new CompactionState(
+ null,
+ null,
+ null,
+ transformSpec,
+ IndexSpec.getDefault(),
+ null,
+ null
+ );
+ }
+
+ private CompactionState createStateWithoutFilters(String fingerprint)
Review Comment:
## Useless parameter
The parameter 'fingerprint' is never used.
[Show more
details](https://github.com/apache/druid/security/code-scanning/10780)
##########
server/src/main/java/org/apache/druid/server/coordinator/InlineSchemaDataSourceCompactionConfig.java:
##########
@@ -276,6 +276,29 @@
return result;
}
+ /**
+ * Creates a builder initialized with all fields from this config.
+ * Useful for creating modified copies of an existing config.
+ */
+ public Builder toBuilder()
+ {
+ return new Builder()
+ .forDataSource(this.dataSource)
+ .withTaskPriority(this.taskPriority)
+ .withInputSegmentSizeBytes(this.inputSegmentSizeBytes)
+ .withMaxRowsPerSegment(this.maxRowsPerSegment)
Review Comment:
## Deprecated method or constructor invocation
Invoking [Builder.withMaxRowsPerSegment](1) should be avoided because it has
been deprecated.
[Show more
details](https://github.com/apache/druid/security/code-scanning/10783)
##########
server/src/test/java/org/apache/druid/server/compaction/CompactionStatusTest.java:
##########
@@ -884,4 +895,304 @@
null
);
}
+
+ // ============================
+ // computeRequiredSetOfFilterRulesForCandidate tests
+ // ============================
+
+ @Test
+ public void testComputeRequiredFilters_SingleFilter_NotOrFilter_ReturnsAsIs()
+ {
+ DimFilter filterA = new SelectorDimFilter("country", "US", null);
+ NotDimFilter expectedFilter = new NotDimFilter(filterA);
+
+ CompactionCandidate candidate = createCandidateWithFingerprints("fp1");
+
+ NotDimFilter result =
CompactionStatus.computeRequiredSetOfFilterRulesForCandidate(
+ candidate,
+ expectedFilter,
+ fingerprintMapper
+ );
+
+ Assert.assertEquals(expectedFilter, result);
+ }
+
+ @Test
+ public void testComputeRequiredFilters_AllFiltersAlreadyApplied_ReturnsNull()
+ {
+ DimFilter filterA = new SelectorDimFilter("country", "US", null);
+ DimFilter filterB = new SelectorDimFilter("country", "UK", null);
+ DimFilter filterC = new SelectorDimFilter("country", "FR", null);
+
+ CompactionState state = createStateWithFilters("fp1", filterA, filterB,
filterC);
+ indexingStateStorage.upsertIndexingState(TestDataSource.WIKI, "fp1",
state, DateTimes.nowUtc());
+ syncCacheFromManager();
+
+ NotDimFilter expectedFilter = new NotDimFilter(new
OrDimFilter(Arrays.asList(filterA, filterB, filterC)));
+ CompactionCandidate candidate = createCandidateWithFingerprints("fp1");
+
+ NotDimFilter result =
CompactionStatus.computeRequiredSetOfFilterRulesForCandidate(
+ candidate,
+ expectedFilter,
+ fingerprintMapper
+ );
+
+ Assert.assertNull(result);
+ }
+
+ @Test
+ public void testComputeRequiredFilters_NoFiltersApplied_ReturnsAllExpected()
+ {
+ DimFilter filterA = new SelectorDimFilter("country", "US", null);
+ DimFilter filterB = new SelectorDimFilter("country", "UK", null);
+ DimFilter filterC = new SelectorDimFilter("country", "FR", null);
+
+ CompactionState state = createStateWithoutFilters("fp1");
+ indexingStateStorage.upsertIndexingState(TestDataSource.WIKI, "fp1",
state, DateTimes.nowUtc());
+ syncCacheFromManager();
+
+ NotDimFilter expectedFilter = new NotDimFilter(new
OrDimFilter(Arrays.asList(filterA, filterB, filterC)));
+ CompactionCandidate candidate = createCandidateWithFingerprints("fp1");
+
+ NotDimFilter result =
CompactionStatus.computeRequiredSetOfFilterRulesForCandidate(
+ candidate,
+ expectedFilter,
+ fingerprintMapper
+ );
+
+ OrDimFilter innerOr = (OrDimFilter) result.getField();
+ Assert.assertEquals(3, innerOr.getFields().size());
+ Assert.assertTrue(innerOr.getFields().containsAll(Arrays.asList(filterA,
filterB, filterC)));
+ }
+
+ @Test
+ public void testComputeRequiredFilters_PartiallyApplied_ReturnsDelta()
+ {
+ DimFilter filterA = new SelectorDimFilter("country", "US", null);
+ DimFilter filterB = new SelectorDimFilter("country", "UK", null);
+ DimFilter filterC = new SelectorDimFilter("country", "FR", null);
+ DimFilter filterD = new SelectorDimFilter("country", "DE", null);
+
+ CompactionState state = createStateWithFilters("fp1", filterA, filterB);
+ indexingStateStorage.upsertIndexingState(TestDataSource.WIKI, "fp1",
state, DateTimes.nowUtc());
+ syncCacheFromManager();
+
+ NotDimFilter expectedFilter = new NotDimFilter(
+ new OrDimFilter(Arrays.asList(filterA, filterB, filterC, filterD))
+ );
+ CompactionCandidate candidate = createCandidateWithFingerprints("fp1");
+
+ NotDimFilter result =
CompactionStatus.computeRequiredSetOfFilterRulesForCandidate(
+ candidate,
+ expectedFilter,
+ fingerprintMapper
+ );
+
+ OrDimFilter innerOr = (OrDimFilter) result.getField();
+ Set<DimFilter> resultSet = new HashSet<>(innerOr.getFields());
+ Set<DimFilter> expectedSet = new HashSet<>(Arrays.asList(filterC,
filterD));
+
+ Assert.assertEquals(expectedSet, resultSet);
+ }
+
+ @Test
+ public void testComputeRequiredFilters_MultipleFingerprints_UnionOfMissing()
+ {
+ DimFilter filterA = new SelectorDimFilter("country", "US", null);
+ DimFilter filterB = new SelectorDimFilter("country", "UK", null);
+ DimFilter filterC = new SelectorDimFilter("country", "FR", null);
+ DimFilter filterD = new SelectorDimFilter("country", "DE", null);
+
+ CompactionState state1 = createStateWithFilters("fp1", filterA, filterB);
+ CompactionState state2 = createStateWithFilters("fp2", filterA, filterC);
+ DateTime now = DateTimes.nowUtc();
+ indexingStateStorage.upsertIndexingState(TestDataSource.WIKI, "fp1",
state1, now);
+ indexingStateStorage.upsertIndexingState(TestDataSource.WIKI, "fp2",
state2, now);
+ syncCacheFromManager();
+
+ NotDimFilter expectedFilter = new NotDimFilter(
+ new OrDimFilter(Arrays.asList(filterA, filterB, filterC, filterD))
+ );
+ CompactionCandidate candidate = createCandidateWithFingerprints("fp1",
"fp2");
+
+ NotDimFilter result =
CompactionStatus.computeRequiredSetOfFilterRulesForCandidate(
+ candidate,
+ expectedFilter,
+ fingerprintMapper
+ );
+
+ OrDimFilter innerOr = (OrDimFilter) result.getField();
+ Set<DimFilter> resultSet = new HashSet<>(innerOr.getFields());
+ Set<DimFilter> expectedSet = new HashSet<>(Arrays.asList(filterB, filterC,
filterD));
+
+ Assert.assertEquals(expectedSet, resultSet);
+ }
+
+ @Test
+ public void testComputeRequiredFilters_MultipleFingerprints_NoDuplicates()
+ {
+ DimFilter filterA = new SelectorDimFilter("country", "US", null);
+ DimFilter filterB = new SelectorDimFilter("country", "UK", null);
+ DimFilter filterC = new SelectorDimFilter("country", "FR", null);
+
+ CompactionState state1 = createStateWithFilters("fp1", filterA);
+ CompactionState state2 = createStateWithFilters("fp2", filterA);
+ DateTime now = DateTimes.nowUtc();
+ indexingStateStorage.upsertIndexingState(TestDataSource.WIKI, "fp1",
state1, now);
+ indexingStateStorage.upsertIndexingState(TestDataSource.WIKI, "fp2",
state2, now);
+ syncCacheFromManager();
+
+ NotDimFilter expectedFilter = new NotDimFilter(
+ new OrDimFilter(Arrays.asList(filterA, filterB, filterC))
+ );
+ CompactionCandidate candidate = createCandidateWithFingerprints("fp1",
"fp2");
+
+ NotDimFilter result =
CompactionStatus.computeRequiredSetOfFilterRulesForCandidate(
+ candidate,
+ expectedFilter,
+ fingerprintMapper
+ );
+
+ OrDimFilter innerOr = (OrDimFilter) result.getField();
+ Set<DimFilter> resultSet = new HashSet<>(innerOr.getFields());
+
+ Assert.assertEquals(2, resultSet.size());
+ Assert.assertTrue(resultSet.containsAll(Arrays.asList(filterB, filterC)));
+ }
+
+ @Test
+ public void
testComputeRequiredFilters_MissingCompactionState_ReturnsAllFilters()
+ {
+ DimFilter filterA = new SelectorDimFilter("country", "US", null);
+ DimFilter filterB = new SelectorDimFilter("country", "UK", null);
+ DimFilter filterC = new SelectorDimFilter("country", "FR", null);
+
+ // No state persisted for fp1
+ NotDimFilter expectedFilter = new NotDimFilter(
+ new OrDimFilter(Arrays.asList(filterA, filterB, filterC))
+ );
+ CompactionCandidate candidate = createCandidateWithFingerprints("fp1");
+
+ NotDimFilter result =
CompactionStatus.computeRequiredSetOfFilterRulesForCandidate(
+ candidate,
+ expectedFilter,
+ fingerprintMapper
+ );
+
+ Assert.assertEquals(expectedFilter, result);
+ }
+
+ @Test
+ public void testComputeRequiredFilters_TransformSpecWithSingleFilter()
+ {
+ DimFilter filterA = new SelectorDimFilter("country", "US", null);
+ DimFilter filterB = new SelectorDimFilter("country", "UK", null);
+ DimFilter filterC = new SelectorDimFilter("country", "FR", null);
+
+ CompactionState state = createStateWithSingleFilter("fp1", filterA);
+ indexingStateStorage.upsertIndexingState(TestDataSource.WIKI, "fp1",
state, DateTimes.nowUtc());
+ syncCacheFromManager();
+
+ NotDimFilter expectedFilter = new NotDimFilter(
+ new OrDimFilter(Arrays.asList(filterA, filterB, filterC))
+ );
+ CompactionCandidate candidate = createCandidateWithFingerprints("fp1");
+
+ NotDimFilter result =
CompactionStatus.computeRequiredSetOfFilterRulesForCandidate(
+ candidate,
+ expectedFilter,
+ fingerprintMapper
+ );
+
+ OrDimFilter innerOr = (OrDimFilter) result.getField();
+ Assert.assertEquals(2, innerOr.getFields().size());
+ Assert.assertTrue(innerOr.getFields().containsAll(Arrays.asList(filterB,
filterC)));
+ }
+
+ @Test
+ public void testComputeRequiredFilters_SegmentsWithNoFingerprints()
+ {
+ DimFilter filterA = new SelectorDimFilter("country", "US", null);
+ DimFilter filterB = new SelectorDimFilter("country", "UK", null);
+ DimFilter filterC = new SelectorDimFilter("country", "FR", null);
+
+ CompactionCandidate candidate = createCandidateWithNullFingerprints(3);
+
+ NotDimFilter expectedFilter = new NotDimFilter(
+ new OrDimFilter(Arrays.asList(filterA, filterB, filterC))
+ );
+
+ NotDimFilter result =
CompactionStatus.computeRequiredSetOfFilterRulesForCandidate(
+ candidate,
+ expectedFilter,
+ fingerprintMapper
+ );
+
+ Assert.assertEquals(expectedFilter, result);
+ }
+
+ // Helper methods for filter tests
+
+ private CompactionCandidate createCandidateWithFingerprints(String...
fingerprints)
+ {
+ List<DataSegment> segments = Arrays.stream(fingerprints)
+ .map(fp ->
DataSegment.builder(WIKI_SEGMENT).indexingStateFingerprint(fp).build())
+ .collect(Collectors.toList());
+ return CompactionCandidate.from(segments, null);
+ }
+
+ private CompactionCandidate createCandidateWithNullFingerprints(int count)
+ {
+ List<DataSegment> segments = new ArrayList<>();
+ for (int i = 0; i < count; i++) {
+
segments.add(DataSegment.builder(WIKI_SEGMENT).indexingStateFingerprint(null).build());
+ }
+ return CompactionCandidate.from(segments, null);
+ }
+
+ private CompactionState createStateWithFilters(String fingerprint,
DimFilter... filters)
+ {
+ OrDimFilter orFilter = new OrDimFilter(Arrays.asList(filters));
+ NotDimFilter notFilter = new NotDimFilter(orFilter);
+ CompactionTransformSpec transformSpec = new
CompactionTransformSpec(notFilter);
+
+ return new CompactionState(
+ null,
+ null,
+ null,
+ transformSpec,
+ IndexSpec.getDefault(),
+ null,
+ null
+ );
+ }
+
+ private CompactionState createStateWithSingleFilter(String fingerprint,
DimFilter filter)
Review Comment:
## Useless parameter
The parameter 'fingerprint' is never used.
[Show more
details](https://github.com/apache/druid/security/code-scanning/10781)
##########
server/src/test/java/org/apache/druid/server/compaction/CompactionStatusTest.java:
##########
@@ -884,4 +895,304 @@
null
);
}
+
+ // ============================
+ // computeRequiredSetOfFilterRulesForCandidate tests
+ // ============================
+
+ @Test
+ public void testComputeRequiredFilters_SingleFilter_NotOrFilter_ReturnsAsIs()
+ {
+ DimFilter filterA = new SelectorDimFilter("country", "US", null);
+ NotDimFilter expectedFilter = new NotDimFilter(filterA);
+
+ CompactionCandidate candidate = createCandidateWithFingerprints("fp1");
+
+ NotDimFilter result =
CompactionStatus.computeRequiredSetOfFilterRulesForCandidate(
+ candidate,
+ expectedFilter,
+ fingerprintMapper
+ );
+
+ Assert.assertEquals(expectedFilter, result);
+ }
+
+ @Test
+ public void testComputeRequiredFilters_AllFiltersAlreadyApplied_ReturnsNull()
+ {
+ DimFilter filterA = new SelectorDimFilter("country", "US", null);
+ DimFilter filterB = new SelectorDimFilter("country", "UK", null);
+ DimFilter filterC = new SelectorDimFilter("country", "FR", null);
+
+ CompactionState state = createStateWithFilters("fp1", filterA, filterB,
filterC);
+ indexingStateStorage.upsertIndexingState(TestDataSource.WIKI, "fp1",
state, DateTimes.nowUtc());
+ syncCacheFromManager();
+
+ NotDimFilter expectedFilter = new NotDimFilter(new
OrDimFilter(Arrays.asList(filterA, filterB, filterC)));
+ CompactionCandidate candidate = createCandidateWithFingerprints("fp1");
+
+ NotDimFilter result =
CompactionStatus.computeRequiredSetOfFilterRulesForCandidate(
+ candidate,
+ expectedFilter,
+ fingerprintMapper
+ );
+
+ Assert.assertNull(result);
+ }
+
+ @Test
+ public void testComputeRequiredFilters_NoFiltersApplied_ReturnsAllExpected()
+ {
+ DimFilter filterA = new SelectorDimFilter("country", "US", null);
+ DimFilter filterB = new SelectorDimFilter("country", "UK", null);
+ DimFilter filterC = new SelectorDimFilter("country", "FR", null);
+
+ CompactionState state = createStateWithoutFilters("fp1");
+ indexingStateStorage.upsertIndexingState(TestDataSource.WIKI, "fp1",
state, DateTimes.nowUtc());
+ syncCacheFromManager();
+
+ NotDimFilter expectedFilter = new NotDimFilter(new
OrDimFilter(Arrays.asList(filterA, filterB, filterC)));
+ CompactionCandidate candidate = createCandidateWithFingerprints("fp1");
+
+ NotDimFilter result =
CompactionStatus.computeRequiredSetOfFilterRulesForCandidate(
+ candidate,
+ expectedFilter,
+ fingerprintMapper
+ );
+
+ OrDimFilter innerOr = (OrDimFilter) result.getField();
+ Assert.assertEquals(3, innerOr.getFields().size());
+ Assert.assertTrue(innerOr.getFields().containsAll(Arrays.asList(filterA,
filterB, filterC)));
+ }
+
+ @Test
+ public void testComputeRequiredFilters_PartiallyApplied_ReturnsDelta()
+ {
+ DimFilter filterA = new SelectorDimFilter("country", "US", null);
+ DimFilter filterB = new SelectorDimFilter("country", "UK", null);
+ DimFilter filterC = new SelectorDimFilter("country", "FR", null);
+ DimFilter filterD = new SelectorDimFilter("country", "DE", null);
+
+ CompactionState state = createStateWithFilters("fp1", filterA, filterB);
+ indexingStateStorage.upsertIndexingState(TestDataSource.WIKI, "fp1",
state, DateTimes.nowUtc());
+ syncCacheFromManager();
+
+ NotDimFilter expectedFilter = new NotDimFilter(
+ new OrDimFilter(Arrays.asList(filterA, filterB, filterC, filterD))
+ );
+ CompactionCandidate candidate = createCandidateWithFingerprints("fp1");
+
+ NotDimFilter result =
CompactionStatus.computeRequiredSetOfFilterRulesForCandidate(
+ candidate,
+ expectedFilter,
+ fingerprintMapper
+ );
+
+ OrDimFilter innerOr = (OrDimFilter) result.getField();
+ Set<DimFilter> resultSet = new HashSet<>(innerOr.getFields());
+ Set<DimFilter> expectedSet = new HashSet<>(Arrays.asList(filterC,
filterD));
+
+ Assert.assertEquals(expectedSet, resultSet);
+ }
+
+ @Test
+ public void testComputeRequiredFilters_MultipleFingerprints_UnionOfMissing()
+ {
+ DimFilter filterA = new SelectorDimFilter("country", "US", null);
+ DimFilter filterB = new SelectorDimFilter("country", "UK", null);
+ DimFilter filterC = new SelectorDimFilter("country", "FR", null);
+ DimFilter filterD = new SelectorDimFilter("country", "DE", null);
+
+ CompactionState state1 = createStateWithFilters("fp1", filterA, filterB);
+ CompactionState state2 = createStateWithFilters("fp2", filterA, filterC);
+ DateTime now = DateTimes.nowUtc();
+ indexingStateStorage.upsertIndexingState(TestDataSource.WIKI, "fp1",
state1, now);
+ indexingStateStorage.upsertIndexingState(TestDataSource.WIKI, "fp2",
state2, now);
+ syncCacheFromManager();
+
+ NotDimFilter expectedFilter = new NotDimFilter(
+ new OrDimFilter(Arrays.asList(filterA, filterB, filterC, filterD))
+ );
+ CompactionCandidate candidate = createCandidateWithFingerprints("fp1",
"fp2");
+
+ NotDimFilter result =
CompactionStatus.computeRequiredSetOfFilterRulesForCandidate(
+ candidate,
+ expectedFilter,
+ fingerprintMapper
+ );
+
+ OrDimFilter innerOr = (OrDimFilter) result.getField();
+ Set<DimFilter> resultSet = new HashSet<>(innerOr.getFields());
+ Set<DimFilter> expectedSet = new HashSet<>(Arrays.asList(filterB, filterC,
filterD));
+
+ Assert.assertEquals(expectedSet, resultSet);
+ }
+
+ @Test
+ public void testComputeRequiredFilters_MultipleFingerprints_NoDuplicates()
+ {
+ DimFilter filterA = new SelectorDimFilter("country", "US", null);
+ DimFilter filterB = new SelectorDimFilter("country", "UK", null);
+ DimFilter filterC = new SelectorDimFilter("country", "FR", null);
+
+ CompactionState state1 = createStateWithFilters("fp1", filterA);
+ CompactionState state2 = createStateWithFilters("fp2", filterA);
+ DateTime now = DateTimes.nowUtc();
+ indexingStateStorage.upsertIndexingState(TestDataSource.WIKI, "fp1",
state1, now);
+ indexingStateStorage.upsertIndexingState(TestDataSource.WIKI, "fp2",
state2, now);
+ syncCacheFromManager();
+
+ NotDimFilter expectedFilter = new NotDimFilter(
+ new OrDimFilter(Arrays.asList(filterA, filterB, filterC))
+ );
+ CompactionCandidate candidate = createCandidateWithFingerprints("fp1",
"fp2");
+
+ NotDimFilter result =
CompactionStatus.computeRequiredSetOfFilterRulesForCandidate(
+ candidate,
+ expectedFilter,
+ fingerprintMapper
+ );
+
+ OrDimFilter innerOr = (OrDimFilter) result.getField();
+ Set<DimFilter> resultSet = new HashSet<>(innerOr.getFields());
+
+ Assert.assertEquals(2, resultSet.size());
+ Assert.assertTrue(resultSet.containsAll(Arrays.asList(filterB, filterC)));
+ }
+
+ @Test
+ public void
testComputeRequiredFilters_MissingCompactionState_ReturnsAllFilters()
+ {
+ DimFilter filterA = new SelectorDimFilter("country", "US", null);
+ DimFilter filterB = new SelectorDimFilter("country", "UK", null);
+ DimFilter filterC = new SelectorDimFilter("country", "FR", null);
+
+ // No state persisted for fp1
+ NotDimFilter expectedFilter = new NotDimFilter(
+ new OrDimFilter(Arrays.asList(filterA, filterB, filterC))
+ );
+ CompactionCandidate candidate = createCandidateWithFingerprints("fp1");
+
+ NotDimFilter result =
CompactionStatus.computeRequiredSetOfFilterRulesForCandidate(
+ candidate,
+ expectedFilter,
+ fingerprintMapper
+ );
+
+ Assert.assertEquals(expectedFilter, result);
+ }
+
+ @Test
+ public void testComputeRequiredFilters_TransformSpecWithSingleFilter()
+ {
+ DimFilter filterA = new SelectorDimFilter("country", "US", null);
+ DimFilter filterB = new SelectorDimFilter("country", "UK", null);
+ DimFilter filterC = new SelectorDimFilter("country", "FR", null);
+
+ CompactionState state = createStateWithSingleFilter("fp1", filterA);
+ indexingStateStorage.upsertIndexingState(TestDataSource.WIKI, "fp1",
state, DateTimes.nowUtc());
+ syncCacheFromManager();
+
+ NotDimFilter expectedFilter = new NotDimFilter(
+ new OrDimFilter(Arrays.asList(filterA, filterB, filterC))
+ );
+ CompactionCandidate candidate = createCandidateWithFingerprints("fp1");
+
+ NotDimFilter result =
CompactionStatus.computeRequiredSetOfFilterRulesForCandidate(
+ candidate,
+ expectedFilter,
+ fingerprintMapper
+ );
+
+ OrDimFilter innerOr = (OrDimFilter) result.getField();
+ Assert.assertEquals(2, innerOr.getFields().size());
+ Assert.assertTrue(innerOr.getFields().containsAll(Arrays.asList(filterB,
filterC)));
+ }
+
+ @Test
+ public void testComputeRequiredFilters_SegmentsWithNoFingerprints()
+ {
+ DimFilter filterA = new SelectorDimFilter("country", "US", null);
+ DimFilter filterB = new SelectorDimFilter("country", "UK", null);
+ DimFilter filterC = new SelectorDimFilter("country", "FR", null);
+
+ CompactionCandidate candidate = createCandidateWithNullFingerprints(3);
+
+ NotDimFilter expectedFilter = new NotDimFilter(
+ new OrDimFilter(Arrays.asList(filterA, filterB, filterC))
+ );
+
+ NotDimFilter result =
CompactionStatus.computeRequiredSetOfFilterRulesForCandidate(
+ candidate,
+ expectedFilter,
+ fingerprintMapper
+ );
+
+ Assert.assertEquals(expectedFilter, result);
+ }
+
+ // Helper methods for filter tests
+
+ private CompactionCandidate createCandidateWithFingerprints(String...
fingerprints)
+ {
+ List<DataSegment> segments = Arrays.stream(fingerprints)
+ .map(fp ->
DataSegment.builder(WIKI_SEGMENT).indexingStateFingerprint(fp).build())
+ .collect(Collectors.toList());
+ return CompactionCandidate.from(segments, null);
+ }
+
+ private CompactionCandidate createCandidateWithNullFingerprints(int count)
+ {
+ List<DataSegment> segments = new ArrayList<>();
+ for (int i = 0; i < count; i++) {
+
segments.add(DataSegment.builder(WIKI_SEGMENT).indexingStateFingerprint(null).build());
+ }
+ return CompactionCandidate.from(segments, null);
+ }
+
+ private CompactionState createStateWithFilters(String fingerprint,
DimFilter... filters)
Review Comment:
## Useless parameter
The parameter 'fingerprint' is never used.
[Show more
details](https://github.com/apache/druid/security/code-scanning/10782)
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: [email protected]
For queries about this service, please contact Infrastructure at:
[email protected]
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
